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

src/core/SkResourceCache.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 "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
@@ skipping 87 matching lines @@
                                              SkDiscardableMemory* dm,
                                              size_t rowBytes)
     : INHERITED(info)
     , fDM(dm)
     , fRB(rowBytes)
 {
     SkASSERT(dm->data());
     fFirstTime = true;
 }
 
-SkOneShotDiscardablePixelRef::~SkOneShotDiscardablePixelRef() {
-    SkDELETE(fDM);
-}
+SkOneShotDiscardablePixelRef::~SkOneShotDiscardablePixelRef() { delete fDM; }
 
 bool SkOneShotDiscardablePixelRef::onNewLockPixels(LockRec* rec) {
     if (fFirstTime) {
         // we're already locked
         SkASSERT(fDM->data());
         fFirstTime = false;
         goto SUCCESS;
     }
 
     // A previous call to onUnlock may have deleted our DM, so check for that
@@ skipping 48 matching lines @@
     if (NULL == dm) {
         return false;
     }
 
     // can we relax this?
     if (kN32_SkColorType != bitmap->colorType()) {
         return false;
     }
 
     SkImageInfo info = bitmap->info();
-    bitmap->setPixelRef(SkNEW_ARGS(SkOneShotDiscardablePixelRef,
-                                   (info, dm, bitmap->rowBytes())))->unref();
+    bitmap->setPixelRef(new SkOneShotDiscardablePixelRef(info, dm, bitmap->rowBytes()))->unref();
     bitmap->lockPixels();
     return bitmap->readyToDraw();
 }
 
 SkResourceCache::SkResourceCache(DiscardableFactory factory) {
     this->init();
     fDiscardableFactory = factory;
 
-    fAllocator = SkNEW_ARGS(SkResourceCacheDiscardableAllocator, (factory));
+    fAllocator = new SkResourceCacheDiscardableAllocator(factory);
 }
 
 SkResourceCache::SkResourceCache(size_t byteLimit) {
     this->init();
     fTotalByteLimit = byteLimit;
 }
 
 SkResourceCache::~SkResourceCache() {
     SkSafeUnref(fAllocator);
 
     Rec* rec = fHead;
     while (rec) {
         Rec* next = rec->fNext;
-        SkDELETE(rec);
+        delete rec;
         rec = next;
     }
     delete fHash;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool SkResourceCache::find(const Key& key, FindVisitor visitor, void* context) {
     this->checkMessages();
 
@@ skipping 22 matching lines @@
 
 static bool gDumpCacheTransactions;
 
 void SkResourceCache::add(Rec* rec) {
     this->checkMessages();
 
     SkASSERT(rec);
     // See if we already have this key (racy inserts, etc.)
     Rec* existing = fHash->find(rec->getKey());
     if (existing) {
-        SkDELETE(rec);
+        delete rec;
         return;
     }
 
     this->addToHead(rec);
     fHash->add(rec);
 
     if (gDumpCacheTransactions) {
         SkString bytesStr, totalStr;
         make_size_str(rec->bytesUsed(), &bytesStr);
         make_size_str(fTotalBytesUsed, &totalStr);
@@ skipping 16 matching lines @@
     fCount -= 1;
 
     if (gDumpCacheTransactions) {
         SkString bytesStr, totalStr;
         make_size_str(used, &bytesStr);
         make_size_str(fTotalBytesUsed, &totalStr);
         SkDebugf("RC: remove %5s %12p key %08x -- total %5s, count %d\n",
                  bytesStr.c_str(), rec, rec->getHash(), totalStr.c_str(), fCount);
     }
 
-    SkDELETE(rec);
+    delete rec;
 }
 
 void SkResourceCache::purgeAsNeeded(bool forcePurge) {
     size_t byteLimit;
     int    countLimit;
 
     if (fDiscardableFactory) {
         countLimit = SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT;
         byteLimit = SK_MaxU32;  // no limit based on bytes
     } else {
@@ skipping 73 matching lines @@
         this->purgeAsNeeded();
     }
     return prevLimit;
 }
 
 SkCachedData* SkResourceCache::newCachedData(size_t bytes) {
     this->checkMessages();
 
     if (fDiscardableFactory) {
         SkDiscardableMemory* dm = fDiscardableFactory(bytes);
-        return dm ? SkNEW_ARGS(SkCachedData, (bytes, dm)) : NULL;
+        return dm ? new SkCachedData(bytes, dm) : NULL;
     } else {
-        return SkNEW_ARGS(SkCachedData, (sk_malloc_throw(bytes), bytes));
+        return new SkCachedData(sk_malloc_throw(bytes), bytes);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkResourceCache::detach(Rec* rec) {
     Rec* prev = rec->fPrev;
     Rec* next = rec->fNext;
 
     if (!prev) {
@@ skipping 140 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
 static SkResourceCache* gResourceCache = NULL;
 static void cleanup_gResourceCache() {
     // We'll clean this up in our own tests, but disable for clients.
     // Chrome seems to have funky multi-process things going on in unit tests that
     // makes this unsafe to delete when the main process atexit()s.
     // SkLazyPtr does the same sort of thing.
 #if SK_DEVELOPER
-    SkDELETE(gResourceCache);
+    delete gResourceCache;
 #endif
 }
 
 /** Must hold gMutex when calling. */
 static SkResourceCache* get_cache() {
     // gMutex is always held when this is called, so we don't need to be fancy in here.
     gMutex.assertHeld();
     if (NULL == gResourceCache) {
 #ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
-        gResourceCache = SkNEW_ARGS(SkResourceCache, (SkDiscardableMemory::Create));
+        gResourceCache = new SkResourceCache(SkDiscardableMemory::Create);
 #else
-        gResourceCache = SkNEW_ARGS(SkResourceCache, (SK_DEFAULT_IMAGE_CACHE_LIMIT));
+        gResourceCache = new SkResourceCache(SK_DEFAULT_IMAGE_CACHE_LIMIT);
 #endif
         atexit(cleanup_gResourceCache);
     }
     return gResourceCache;
 }
 
 size_t SkResourceCache::GetTotalBytesUsed() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getTotalBytesUsed();
 }
@@ skipping 102 matching lines @@
 /////////////
 
 static void dump_visitor(const SkResourceCache::Rec& rec, void*) {
     SkDebugf("RC: %12s bytes %9lu  discardable %p\n",
              rec.getCategory(), rec.bytesUsed(), rec.diagnostic_only_getDiscardable());
 }
 
 void SkResourceCache::TestDumpMemoryStatistics() {
     VisitAll(dump_visitor, nullptr);
 }