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

include/private/SkTemplates.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkTemplates_DEFINED
@@ skipping 120 matching lines @@
   owns the T object that it points to.  Like a T*, an SkAutoTDelete<T> may hold
   either NULL or a pointer to a T object.  Also like T*, SkAutoTDelete<T> is
   thread-compatible, and once you dereference it, you get the threadsafety
   guarantees of T.
 
   The size of a SkAutoTDelete is small: sizeof(SkAutoTDelete<T>) == sizeof(T*)
 */
 template <typename T> class SkAutoTDelete : SkNoncopyable {
 public:
     SkAutoTDelete(T* obj = NULL) : fObj(obj) {}
-    ~SkAutoTDelete() { SkDELETE(fObj); }
+    ~SkAutoTDelete() { delete fObj; }
 
     T* get() const { return fObj; }
     operator T*() const { return fObj; }
     T& operator*() const { SkASSERT(fObj); return *fObj; }
     T* operator->() const { SkASSERT(fObj); return fObj; }
 
     void reset(T* obj) {
         if (fObj != obj) {
-            SkDELETE(fObj);
+            delete fObj;
             fObj = obj;
         }
     }
 
     /**
      *  Delete the owned object, setting the internal pointer to NULL.
      */
     void free() {
-        SkDELETE(fObj);
+        delete fObj;
         fObj = NULL;
     }
 
     /**
      *  Transfer ownership of the object to the caller, setting the internal
      *  pointer to NULL. Note that this differs from get(), which also returns
      *  the pointer, but it does not transfer ownership.
      */
     T* detach() {
         T* obj = fObj;
@@ skipping 23 matching lines @@
     T& operator*() const { SkASSERT(fObj); return *fObj; }
     T* operator->() const { SkASSERT(fObj); return fObj; }
 
 private:
     T*  fObj;
 };
 
 template <typename T> class SkAutoTDeleteArray : SkNoncopyable {
 public:
     SkAutoTDeleteArray(T array[]) : fArray(array) {}
-    ~SkAutoTDeleteArray() { SkDELETE_ARRAY(fArray); }
+    ~SkAutoTDeleteArray() { delete[] fArray; }
 
     T*      get() const { return fArray; }
-    void    free() { SkDELETE_ARRAY(fArray); fArray = NULL; }
+    void free() {
+        delete[] fArray;
+        fArray = NULL;
+    }
     T*      detach() { T* array = fArray; fArray = NULL; return array; }
 
     void reset(T array[]) {
         if (fArray != array) {
-            SkDELETE_ARRAY(fArray);
+            delete[] fArray;
             fArray = array;
         }
     }
 
 private:
     T*  fArray;
 };
 
 /** Allocate an array of T elements, and free the array in the destructor
  */
 template <typename T> class SkAutoTArray : SkNoncopyable {
 public:
     SkAutoTArray() {
         fArray = NULL;
         SkDEBUGCODE(fCount = 0;)
     }
     /** Allocate count number of T elements
      */
     explicit SkAutoTArray(int count) {
         SkASSERT(count >= 0);
         fArray = NULL;
         if (count) {
-            fArray = SkNEW_ARRAY(T, count);
+            fArray = new T[count];
         }
         SkDEBUGCODE(fCount = count;)
     }
 
     /** Reallocates given a new count. Reallocation occurs even if new count equals old count.
      */
     void reset(int count) {
-        SkDELETE_ARRAY(fArray);
+        delete[] fArray;
         SkASSERT(count >= 0);
         fArray = NULL;
         if (count) {
-            fArray = SkNEW_ARRAY(T, count);
+            fArray = new T[count];
         }
         SkDEBUGCODE(fCount = count;)
     }
 
-    ~SkAutoTArray() {
-        SkDELETE_ARRAY(fArray);
-    }
+    ~SkAutoTArray() { delete[] fArray; }
 
     /** Return the array of T elements. Will be NULL if count == 0
      */
     T* get() const { return fArray; }
 
     /** Return the nth element in the array
      */
     T&  operator[](int index) const {
         SkASSERT((unsigned)index < (unsigned)fCount);
         return fArray[index];
@@ skipping 58 matching lines @@
             } else {
                 fArray = NULL;
             }
 
             fCount = count;
         }
 
         iter = fArray;
         T* stop = fArray + count;
         while (iter < stop) {
-            SkNEW_PLACEMENT(iter++, T);
+            new (iter++) T;
         }
     }
 
     /** Return the number of T elements in the array
      */
     int count() const { return fCount; }
 
     /** Return the array of T elements. Will be NULL if count == 0
      */
     T* get() const { return fArray; }
@@ skipping 149 matching lines @@
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Pass the object and the storage that was offered during SkInPlaceNewCheck, and this will
  *  safely destroy (and free if it was dynamically allocated) the object.
  */
 template <typename T> void SkInPlaceDeleteCheck(T* obj, void* storage) {
     if (storage == obj) {
         obj->~T();
     } else {
-        SkDELETE(obj);
+        delete obj;
     }
 }
 
 /**
  *  Allocates T, using storage if it is large enough, and allocating on the heap (via new) if
  *  storage is not large enough.
  *
  *      obj = SkInPlaceNewCheck<Type>(storage, size);
  *      ...
  *      SkInPlaceDeleteCheck(obj, storage);
  */
 template <typename T> T* SkInPlaceNewCheck(void* storage, size_t size) {
-    return (sizeof(T) <= size) ? new (storage) T : SkNEW(T);
+    return (sizeof(T) <= size) ? new (storage) T : new T;
 }
 
 template <typename T, typename A1, typename A2, typename A3>
 T* SkInPlaceNewCheck(void* storage, size_t size, const A1& a1, const A2& a2, const A3& a3) {
-    return (sizeof(T) <= size) ? new (storage) T(a1, a2, a3) : SkNEW_ARGS(T, (a1, a2, a3));
+    return (sizeof(T) <= size) ? new (storage) T(a1, a2, a3) : new T(a1, a2, a3);
 }
 
 /**
  * Reserves memory that is aligned on double and pointer boundaries.
  * Hopefully this is sufficient for all practical purposes.
  */
 template <size_t N> class SkAlignedSStorage : SkNoncopyable {
 public:
     size_t size() const { return N; }
     void* get() { return fData; }
@@ skipping 19 matching lines @@
      * Returns void* because this object does not initialize the
      * memory. Use placement new for types that require a cons.
      */
     void* get() { return fStorage.get(); }
     const void* get() const { return fStorage.get(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif