Fixup some conventions in SkTArray and add reset to count method.

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 10 matching lines @@
     memcpy(self->fMemArray, array, self->fCount * sizeof(T));
 }
 template<typename T>
 inline void copyAndDelete(SkTArray<T, true>* self, char* newMemArray) {
     memcpy(newMemArray, self->fMemArray, self->fCount * sizeof(T));
 }
 
 template<typename T>
 inline void copy(SkTArray<T, false>* self, const T* array) {
     for (int i = 0; i < self->fCount; ++i) {
-        new (self->fItemArray + i) T(array[i]);
+        SkNEW_PLACEMENT_ARGS(self->fItemArray + i, T, (array[i]));
     }
 }
 template<typename T>
 inline void copyAndDelete(SkTArray<T, false>* self, char* newMemArray) {
     for (int i = 0; i < self->fCount; ++i) {
-        new (newMemArray + sizeof(T) * i) T(self->fItemArray[i]);
+        SkNEW_PLACEMENT_ARGS(newMemArray + sizeof(T) * i, T, (self->fItemArray[i]));
         self->fItemArray[i].~T();
     }
 }
 
 }
 
 /** 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,
     and its destructor will be called from this object's destructor.
@@ skipping 57 matching lines @@
             sk_free(fMemArray);
         }
     }
 
     /**
      * Resets to count() == 0
      */
     void reset() { this->pop_back_n(fCount); }
 
     /**
+     * Resets to count() = n newly constructed T objects.
+     */
+    void reset(int n) {
+        SkASSERT(n >= 0);
+        for (int i = 0; i < fCount; ++i) {
+            fItemArray[i].~T();
+        }
+        // set fCount to 0 before calling checkRealloc so that no copy cons. are called.
+        fCount = 0;
+        this->checkRealloc(n);
+        fCount = n;
+        for (int i = 0; i < fCount; ++i) {
+            SkNEW_PLACEMENT(fItemArray + i, T);
+        }
+    }
+
+    /**
      * Resets to a copy of a C array.
      */
     void reset(const T* array, int count) {
         for (int i = 0; i < fCount; ++i) {
             fItemArray[i].~T();
         }
         int delta = count - fCount;
         this->checkRealloc(delta);
         fCount = count;
         for (int i = 0; i < count; ++i) {
@@ skipping 10 matching lines @@
      * Is the array empty.
      */
     bool empty() const { return !fCount; }
 
     /**
      * Adds 1 new default-constructed T value and returns in by reference. Note
      * the reference only remains valid until the next call that adds or removes
      * elements.
      */
     T& push_back() {
-        checkRealloc(1);
-        new ((char*)fMemArray+sizeof(T)*fCount) T;
+        this->checkRealloc(1);
+        SkNEW_PLACEMENT((char*)fMemArray + sizeof(T) * fCount, T);
         ++fCount;
         return fItemArray[fCount-1];
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the new item
      */
     T& push_back(const T& t) {
-        checkRealloc(1);
-        new ((char*)fMemArray+sizeof(T)*fCount) T(t);
+        this->checkRealloc(1);
+        SkNEW_PLACEMENT_ARGS((char*)fMemArray + sizeof(T) * fCount, T, (t));
         ++fCount;
         return fItemArray[fCount-1];
     }
 
     /**
      * 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.
      */
     T* push_back_n(int n) {
         SkASSERT(n >= 0);
-        checkRealloc(n);
+        this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
-            new (fItemArray + fCount + i) T;
+            SkNEW_PLACEMENT(fItemArray + fCount + i, T);
         }
         fCount += n;
         return fItemArray + fCount - n;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize all n items
      * to the same T.
      */
     T* push_back_n(int n, const T& t) {
         SkASSERT(n >= 0);
-        checkRealloc(n);
+        this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
-            new (fItemArray + fCount + i) T(t);
+            SkNEW_PLACEMENT_ARGS(fItemArray + fCount + i, T, (t));
         }
         fCount += n;
         return fItemArray + fCount - n;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the n items
      * to separate T values.
      */
     T* push_back_n(int n, const T t[]) {
         SkASSERT(n >= 0);
-        checkRealloc(n);
+        this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
-            new (fItemArray + fCount + i) T(t[i]);
+            SkNEW_PLACEMENT_ARGS(fItemArray + fCount + i, T, (t[i]));
         }
         fCount += n;
         return fItemArray + fCount - n;
     }
 
     /**
      * Removes the last element. Not safe to call when count() == 0.
      */
     void pop_back() {
         SkASSERT(fCount > 0);
         --fCount;
         fItemArray[fCount].~T();
-        checkRealloc(0);
+        this->checkRealloc(0);
     }
 
     /**
      * Removes the last n elements. Not safe to call when count() < n.
      */
     void pop_back_n(int n) {
         SkASSERT(n >= 0);
         SkASSERT(fCount >= n);
         fCount -= n;
         for (int i = 0; i < n; ++i) {
             fItemArray[i].~T();
         }
-        checkRealloc(0);
+        this->checkRealloc(0);
     }
 
     /**
      * Pushes or pops from the back to resize. Pushes will be default
      * initialized.
      */
     void resize_back(int newCount) {
         SkASSERT(newCount >= 0);
 
         if (newCount > fCount) {
-            push_back_n(newCount - fCount);
+            this->push_back_n(newCount - fCount);
         } else if (newCount < fCount) {
-            pop_back_n(fCount - newCount);
+            this->pop_back_n(fCount - newCount);
         }
     }
 
     T* begin() {
         return fItemArray;
     }
     const T* begin() const {
         return fItemArray;
     }
     T* end() {
@@ skipping 200 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif