Have SkTArray explicitly call default constructors.

include/core/SkTArray.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTArray_DEFINED
 #define SkTArray_DEFINED
 
@@ skipping 35 matching lines @@
         self->fItemArray[i].~T();
     }
 }
 
 }
 
 template <typename T, bool MEM_COPY> void* operator new(size_t, SkTArray<T, MEM_COPY>*, int);
 
 /** When MEM_COPY is true T will be bit copied when moved.
     When MEM_COPY is false, T will be copy constructed / destructed.
-    In all cases T's constructor will be called on allocation,
+    In all cases T will be default-initialized on allocation,
     and its destructor will be called from this object's destructor.
 */
 template <typename T, bool MEM_COPY> class SkTArray {
 public:
     /**
      * Creates an empty array with no initial storage
      */
     SkTArray() {
         fCount = 0;
         fReserveCount = gMIN_ALLOC_COUNT;
@@ skipping 99 matching lines @@
      * Number of elements in the array.
      */
     int count() const { return fCount; }
 
     /**
      * Is the array empty.
      */
     bool empty() const { return !fCount; }
 
     /**
-     * Adds 1 new default-constructed T value and returns in by reference. Note
+     * Adds 1 new default-initialized T value and returns it by reference. Note
      * the reference only remains valid until the next call that adds or removes
      * elements.
      */
     T& push_back() {
         T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
         SkNEW_PLACEMENT(newT, T);
         return *newT;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the new item
      */
     T& push_back(const T& t) {
         T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
         SkNEW_PLACEMENT_ARGS(newT, T, (t));
         return *newT;
     }
 
     /**
-     * Allocates n more default T values, and returns the address of the start
-     * of that new range. Note: this address is only valid until the next API
-     * call made on the array that might add or remove elements.
+     * Allocates n more default-initialized T values, and returns the address of
+     * the start of that new range. Note: this address is only valid until the
+     * next API call made on the array that might add or remove elements.
      */
     T* push_back_n(int n) {
         SkASSERT(n >= 0);
         T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
             SkNEW_PLACEMENT(newTs + i, T);
         }
         return newTs;
     }
 
@@ skipping 41 matching lines @@
         SkASSERT(n >= 0);
         SkASSERT(fCount >= n);
         fCount -= n;
         for (int i = 0; i < n; ++i) {
             fItemArray[fCount + i].~T();
         }
         this->checkRealloc(0);
     }
 
     /**
      * Pushes or pops from the back to resize. Pushes will be default

[bungeman-skia, 2014/03/24 15:45:48]

Interestingly, this comment is actually already correct.

      * initialized.
      */
     void resize_back(int newCount) {
         SkASSERT(newCount >= 0);
 
         if (newCount > fCount) {
             this->push_back_n(newCount - fCount);
         } else if (newCount < fCount) {
             this->pop_back_n(fCount - newCount);
         }
@@ skipping 249 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif