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

src/core/SkDataTable.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDataTable.h"
 
@@ skipping 61 matching lines @@
         }
         return fU.fDir[index].fPtr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkDataTable* SkDataTable::NewEmpty() {
     static SkDataTable* gEmpty;
     if (NULL == gEmpty) {
-        gEmpty = SkNEW(SkDataTable);
+        gEmpty = new SkDataTable;
     }
     gEmpty->ref();
     return gEmpty;
 }
 
 SkDataTable* SkDataTable::NewCopyArrays(const void * const * ptrs,
                                         const size_t sizes[], int count) {
     if (count <= 0) {
         return SkDataTable::NewEmpty();
     }
 
     size_t dataSize = 0;
     for (int i = 0; i < count; ++i) {
         dataSize += sizes[i];
     }
 
     size_t bufferSize = count * sizeof(Dir) + dataSize;
     void* buffer = sk_malloc_throw(bufferSize);
 
     Dir* dir = (Dir*)buffer;
     char* elem = (char*)(dir + count);
     for (int i = 0; i < count; ++i) {
         dir[i].fPtr = elem;
         dir[i].fSize = sizes[i];
         memcpy(elem, ptrs[i], sizes[i]);
         elem += sizes[i];
     }
 
-    return SkNEW_ARGS(SkDataTable, (dir, count, malloc_freeproc, buffer));
+    return new SkDataTable(dir, count, malloc_freeproc, buffer);
 }
 
 SkDataTable* SkDataTable::NewCopyArray(const void* array, size_t elemSize,
                                        int count) {
     if (count <= 0) {
         return SkDataTable::NewEmpty();
     }
 
     size_t bufferSize = elemSize * count;
     void* buffer = sk_malloc_throw(bufferSize);
     memcpy(buffer, array, bufferSize);
 
-    return SkNEW_ARGS(SkDataTable,
-                      (buffer, elemSize, count, malloc_freeproc, buffer));
+    return new SkDataTable(buffer, elemSize, count, malloc_freeproc, buffer);
 }
 
 SkDataTable* SkDataTable::NewArrayProc(const void* array, size_t elemSize,
                                        int count, FreeProc proc, void* ctx) {
     if (count <= 0) {
         return SkDataTable::NewEmpty();
     }
-    return SkNEW_ARGS(SkDataTable, (array, elemSize, count, proc, ctx));
+    return new SkDataTable(array, elemSize, count, proc, ctx);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void chunkalloc_freeproc(void* context) {
-    SkDELETE((SkChunkAlloc*)context);
-}
+static void chunkalloc_freeproc(void* context) { delete (SkChunkAlloc*)context; }
 
 SkDataTableBuilder::SkDataTableBuilder(size_t minChunkSize)
     : fHeap(NULL)
     , fMinChunkSize(minChunkSize) {}
 
 SkDataTableBuilder::~SkDataTableBuilder() { this->reset(); }
 
 void SkDataTableBuilder::reset(size_t minChunkSize) {
     fMinChunkSize = minChunkSize;
     fDir.reset();
     if (fHeap) {
-        SkDELETE(fHeap);
+        delete fHeap;
         fHeap = NULL;
     }
 }
 
 void SkDataTableBuilder::append(const void* src, size_t size) {
     if (NULL == fHeap) {
-        fHeap = SkNEW_ARGS(SkChunkAlloc, (fMinChunkSize));
+        fHeap = new SkChunkAlloc(fMinChunkSize);
     }
 
     void* dst = fHeap->alloc(size, SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dst, src, size);
 
     SkDataTable::Dir* dir = fDir.append();
     dir->fPtr = dst;
     dir->fSize = size;
 }
 
 SkDataTable* SkDataTableBuilder::detachDataTable() {
     const int count = fDir.count();
     if (0 == count) {
         return SkDataTable::NewEmpty();
     }
 
     // Copy the dir into the heap;
     void* dir = fHeap->alloc(count * sizeof(SkDataTable::Dir),
                              SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dir, fDir.begin(), count * sizeof(SkDataTable::Dir));
 
-    SkDataTable* table = SkNEW_ARGS(SkDataTable,
-                                    ((SkDataTable::Dir*)dir, count,
-                                     chunkalloc_freeproc, fHeap));
+    SkDataTable* table = new SkDataTable((SkDataTable::Dir*)dir, count, chunkalloc_freeproc, fHeap);
     // we have to detach our fHeap, since we are giving that to the table
     fHeap = NULL;
     fDir.reset();
     return table;
 }