Use the STL helpers for managing uninitialized buffers in bssl::Array

Prior to C++17, we're missing a few of them, but they're easy to fill
in. In doing so, switch default-construct + copy-assign in
Array::CopyFrom to copy-construct.

These will also be used for a bssl::InplaceVector next.

Change-Id: I4172a94382a23bd9f05d35e3c62c81c8c2c06948
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/71827
Reviewed-by: Adam Langley <agl@google.com>
Commit-Queue: David Benjamin <davidben@google.com>

ssl/internal.h

diff --git a/ssl/internal.h b/ssl/internal.h
index 43ea1c2..247f8c6 100644
--- a/ssl/internal.h
+++ b/ssl/internal.h
@@ -189,6 +189,32 @@
 
 // C++ utilities.
 
+// Fill-ins for various functions in C++17.
+// TODO(crbug.com/42290600): Replace these with the standard ones when we
+// require C++17.
+
+template <typename ForwardIt>
+ForwardIt cxx17_uninitialized_default_construct_n(ForwardIt first, size_t n) {
+  using T = typename std::iterator_traits<ForwardIt>::value_type;
+  while (n > 0) {
+    new (std::addressof(*first)) T;
+    first++;
+    n--;
+  }
+  return first;
+}
+
+template <typename ForwardIt>
+ForwardIt cxx17_destroy_n(ForwardIt first, size_t n) {
+  using T = typename std::iterator_traits<ForwardIt>::value_type;
+  while (n > 0) {
+    first->~T();
+    first++;
+    n--;
+  }
+  return first;
+}
+
 // New behaves like |new| but uses |OPENSSL_malloc| for memory allocation. It
 // returns nullptr on allocation error. It only implements single-object
 // allocation and not new T[n].
@@ -266,9 +292,7 @@
   // Reset releases the current contents of the array and takes ownership of the
   // raw pointer supplied by the caller.
   void Reset(T *new_data, size_t new_size) {
-    for (size_t i = 0; i < size_; i++) {
-      data_[i].~T();
-    }
+    cxx17_destroy_n(data_, size_);
     OPENSSL_free(data_);
     data_ = new_data;
     size_ = new_size;
@@ -289,6 +313,38 @@
   //
   // Note that if |T| is a primitive type like |uint8_t|, it is uninitialized.
   bool Init(size_t new_size) {
+    if (!InitUninitialized(new_size)) {
+      return false;
+    }
+    cxx17_uninitialized_default_construct_n(data_, size_);
+    return true;
+  }
+
+  // CopyFrom replaces the array with a newly-allocated copy of |in|. It returns
+  // true on success and false on error.
+  bool CopyFrom(Span<const T> in) {
+    if (!InitUninitialized(in.size())) {
+      return false;
+    }
+    std::uninitialized_copy(in.begin(), in.end(), data_);
+    return true;
+  }
+
+  // Shrink shrinks the stored size of the array to |new_size|. It crashes if
+  // the new size is larger. Note this does not shrink the allocation itself.
+  void Shrink(size_t new_size) {
+    if (new_size > size_) {
+      abort();
+    }
+    cxx17_destroy_n(data_ + new_size, size_ - new_size);
+    size_ = new_size;
+  }
+
+ private:
+  // InitUninitialized replaces the array with a newly-allocated array of
+  // |new_size| elements, but whose constructor has not yet run. On success, the
+  // elements must be constructed before returning control to the caller.
+  bool InitUninitialized(size_t new_size) {
     Reset();
     if (new_size == 0) {
       return true;
@@ -303,35 +359,9 @@
       return false;
     }
     size_ = new_size;
-    for (size_t i = 0; i < size_; i++) {
-      new (&data_[i]) T;
-    }
     return true;
   }
 
-  // CopyFrom replaces the array with a newly-allocated copy of |in|. It returns
-  // true on success and false on error.
-  bool CopyFrom(Span<const T> in) {
-    if (!Init(in.size())) {
-      return false;
-    }
-    std::copy(in.begin(), in.end(), data_);
-    return true;
-  }
-
-  // Shrink shrinks the stored size of the array to |new_size|. It crashes if
-  // the new size is larger. Note this does not shrink the allocation itself.
-  void Shrink(size_t new_size) {
-    if (new_size > size_) {
-      abort();
-    }
-    for (size_t i = new_size; i < size_; i++) {
-      data_[i].~T();
-    }
-    size_ = new_size;
-  }
-
- private:
   T *data_ = nullptr;
   size_t size_ = 0;
 };