Remove SkNEW_APPEND_TO_TARRAY.

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
 
 #include "../private/SkTLogic.h"
 #include "../private/SkTemplates.h"
 #include "SkTypes.h"
 
 #include <new>
 #include <utility>
 
-template <typename T, bool MEM_COPY = false> class SkTArray;
-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 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 {
+template <typename T, bool MEM_COPY = false> class SkTArray {
 public:
     /**
      * Creates an empty array with no initial storage
      */
     SkTArray() {
         fCount = 0;
         fReserveCount = gMIN_ALLOC_COUNT;
         fAllocCount = 0;
         fMemArray = NULL;
         fPreAllocMemArray = NULL;
@@ skipping 420 matching lines @@
 
             this->move(newMemArray);
 
             if (fMemArray != fPreAllocMemArray) {
                 sk_free(fMemArray);
             }
             fMemArray = newMemArray;
         }
     }
 
-    friend void* operator new<T>(size_t, SkTArray*, int);
-
     int     fReserveCount;
     int     fCount;
     int     fAllocCount;
     void*   fPreAllocMemArray;
     union {
         T*       fItemArray;
         void*    fMemArray;
     };
 };
 
-// Use the below macro (SkNEW_APPEND_TO_TARRAY) rather than calling this directly
-template <typename T, bool MEM_COPY>
-void* operator new(size_t, SkTArray<T, MEM_COPY>* array, int SkDEBUGCODE(atIndex)) {
-    // Currently, we only support adding to the end of the array. When the array class itself
-    // supports random insertion then this should be updated.
-    // SkASSERT(atIndex >= 0 && atIndex <= array->count());
-    SkASSERT(atIndex == array->count());
-    return array->push_back_raw(1);
-}
-
-// Skia doesn't use C++ exceptions but it may be compiled with them enabled. Having an op delete
-// to match the op new silences warnings about missing op delete when a constructor throws an
-// exception.
-template <typename T, bool MEM_COPY>
-void operator delete(void*, SkTArray<T, MEM_COPY>* /*array*/, int /*atIndex*/) {
-    SK_ABORT("Invalid Operation");
-}
-
-// Constructs a new object as the last element of an SkTArray.
-#define SkNEW_APPEND_TO_TARRAY(array_ptr, type_name, args)  \
-    (new ((array_ptr), (array_ptr)->count()) type_name args)
-
-
 /**
  * Subclass of SkTArray that contains a preallocated memory block for the array.
  */
 template <int N, typename T, bool MEM_COPY = false>
 class SkSTArray : public SkTArray<T, MEM_COPY> {
 private:
     typedef SkTArray<T, MEM_COPY> INHERITED;
 
 public:
     SkSTArray() : INHERITED(&fStorage) {
@@ skipping 22 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif