Style Change: SkNEW->new; SkDELETE->delete

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 14 matching lines @@
 inline void copy(SkTArray<T, true>* self, const T* array) {
     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, int dst, int src) {
-    SkNEW_PLACEMENT_ARGS(&self->fItemArray[dst], T, (self->fItemArray[src]));
+    new (&self->fItemArray[dst]) T(self->fItemArray[src]);
 }
 template<typename T>
 inline void copy(SkTArray<T, false>* self, const T* array) {
     for (int i = 0; i < self->fCount; ++i) {
-        SkNEW_PLACEMENT_ARGS(self->fItemArray + i, T, (array[i]));
+        new (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) {
-        SkNEW_PLACEMENT_ARGS(newMemArray + sizeof(T) * i, T, (self->fItemArray[i]));
+        new (newMemArray + sizeof(T) * i) T(self->fItemArray[i]);
         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.
@@ skipping 71 matching lines @@
     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);
+            new (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();
         }
@@ skipping 24 matching lines @@
      */
     bool empty() const { return !fCount; }
 
     /**
      * 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);
+        new (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));
+        new (newT) T(t);
         return *newT;
     }
 
     /**
      * 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);
+            new (newTs + i) T;
         }
         return newTs;
     }
 
     /**
      * 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);
         T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
-            SkNEW_PLACEMENT_ARGS(newTs[i], T, (t));
+            new (newTs[i]) T(t);
         }
         return newTs;
     }
 
     /**
      * 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);
         this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
-            SkNEW_PLACEMENT_ARGS(fItemArray + fCount + i, T, (t[i]));
+            new (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);
@@ skipping 299 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif