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

src/core/SkBitmapHeap.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapHeap.h"
 #include "SkBitmap.h"
@@ skipping 209 matching lines @@
 
 int SkBitmapHeap::findInLookupTable(const LookupEntry& indexEntry, SkBitmapHeapEntry** entry) {
     int index = SkTSearch<const LookupEntry, LookupEntry::Less>(
                                              (const LookupEntry**)fLookupTable.begin(),
                                              fLookupTable.count(),
                                              &indexEntry, sizeof(void*));
 
     if (index < 0) {
         // insert ourselves into the bitmapIndex
         index = ~index;
-        *fLookupTable.insert(index) = SkNEW_ARGS(LookupEntry, (indexEntry));
+        *fLookupTable.insert(index) = new LookupEntry(indexEntry);
     } else if (entry != NULL) {
         // populate the entry if needed
         *entry = fStorage[fLookupTable[index]->fStorageSlot];
     }
 
     return index;
 }
 
 bool SkBitmapHeap::copyBitmap(const SkBitmap& originalBitmap, SkBitmap& copiedBitmap) {
     SkASSERT(!fExternalStorage);
@@ skipping 16 matching lines @@
 }
 
 int SkBitmapHeap::removeEntryFromLookupTable(LookupEntry* entry) {
     // remove the bitmap index for the deleted entry
     SkDEBUGCODE(int count = fLookupTable.count();)
     int index = this->findInLookupTable(*entry, NULL);
     // Verify that findInLookupTable found an existing entry rather than adding
     // a new entry to the lookup table.
     SkASSERT(count == fLookupTable.count());
     fBytesAllocated -= fStorage[entry->fStorageSlot]->fBytesAllocated;
-    SkDELETE(fLookupTable[index]);
+    delete fLookupTable[index];
     fLookupTable.remove(index);
     return index;
 }
 
 int32_t SkBitmapHeap::insert(const SkBitmap& originalBitmap) {
     SkBitmapHeapEntry* entry = NULL;
     int searchIndex = this->findInLookupTable(LookupEntry(originalBitmap), &entry);
 
     if (entry) {
         // Already had a copy of the bitmap in the heap.
@@ skipping 32 matching lines @@
         }
     }
 
     // if we didn't have an entry yet we need to create one
     if (!entry) {
         if (fPreferredCount != UNLIMITED_SIZE && fUnusedSlots.count() > 0) {
             int slot;
             fUnusedSlots.pop(&slot);
             entry = fStorage[slot];
         } else {
-            entry = SkNEW(SkBitmapHeapEntry);
+            entry = new SkBitmapHeapEntry;
             fStorage.append(1, &entry);
             entry->fSlot = fStorage.count() - 1;
             fBytesAllocated += sizeof(SkBitmapHeapEntry);
         }
     }
 
     // create a copy of the bitmap
     bool copySucceeded;
     if (fExternalStorage) {
         copySucceeded = fExternalStorage->insert(originalBitmap, entry->fSlot);
     } else {
         copySucceeded = copyBitmap(originalBitmap, entry->fBitmap);
     }
 
     // if the copy failed then we must abort
     if (!copySucceeded) {
         // delete the index
-        SkDELETE(fLookupTable[searchIndex]);
+        delete fLookupTable[searchIndex];
         fLookupTable.remove(searchIndex);
         // If entry is the last slot in storage, it is safe to delete it.
         if (fStorage.count() - 1 == entry->fSlot) {
             // free the slot
             fStorage.remove(entry->fSlot);
             fBytesAllocated -= sizeof(SkBitmapHeapEntry);
-            SkDELETE(entry);
+            delete entry;
         } else {
             fUnusedSlots.push(entry->fSlot);
         }
         return INVALID_SLOT;
     }
 
     // update the index with the appropriate slot in the heap
     fLookupTable[searchIndex]->fStorageSlot = entry->fSlot;
 
     // compute the space taken by this entry
@@ skipping 27 matching lines @@
         for (int i = 0; i < fDeferredEntries.count(); i++) {
             SkASSERT(fOwnerCount != IGNORE_OWNERS);
             SkBitmapHeapEntry* heapEntry = this->getEntry(fDeferredEntries[i]);
             SkASSERT(heapEntry != NULL);
             heapEntry->addReferences(fOwnerCount);
         }
     }
     fDeferAddingOwners = false;
     fDeferredEntries.reset();
 }