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

src/gpu/GrLayerCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
@@ skipping 72 matching lines @@
     memset(fPlotLocks, 0, sizeof(fPlotLocks));
 }
 
 GrLayerCache::~GrLayerCache() {
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
     for (; !iter.done(); ++iter) {
         GrCachedLayer* layer = &(*iter);
         SkASSERT(0 == layer->uses());
         this->unlock(layer);
-        SkDELETE(layer);
+        delete layer;
     }
 
     SkASSERT(0 == fPictureHash.count());
 
     // The atlas only lets go of its texture when the atlas is deleted.
     fAtlas.free();
 }
 
 void GrLayerCache::initAtlas() {
     SkASSERT(NULL == fAtlas.get());
     GR_STATIC_ASSERT(kNumPlotsX*kNumPlotsX == GrPictureInfo::kNumPlots);
 
     SkISize textureSize = SkISize::Make(kAtlasTextureWidth, kAtlasTextureHeight);
-    fAtlas.reset(SkNEW_ARGS(GrAtlas, (fContext->getGpu(), kSkia8888_GrPixelConfig,
-                                      kRenderTarget_GrSurfaceFlag,
-                                      textureSize, kNumPlotsX, kNumPlotsY, false)));
+    fAtlas.reset(new GrAtlas(fContext->getGpu(), kSkia8888_GrPixelConfig,
+                             kRenderTarget_GrSurfaceFlag, textureSize, kNumPlotsX, kNumPlotsY,
+                             false));
 }
 
 void GrLayerCache::freeAll() {
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
     for (; !iter.done(); ++iter) {
         GrCachedLayer* layer = &(*iter);
         this->unlock(layer);
-        SkDELETE(layer);
+        delete layer;
     }
     fLayerHash.rewind();
 
     // The atlas only lets go of its texture when the atlas is deleted.
     fAtlas.free();
 }
 
 GrCachedLayer* GrLayerCache::createLayer(uint32_t pictureID,
                                          int start, int stop,
                                          const SkIRect& srcIR,
                                          const SkIRect& dstIR,
                                          const SkMatrix& initialMat,
                                          const int* key,
                                          int keySize,
                                          const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
 
-    GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (pictureID, start, stop,
-                                                      srcIR, dstIR, initialMat,
-                                                      key, keySize, paint));
+    GrCachedLayer* layer = new GrCachedLayer(pictureID, start, stop, srcIR, dstIR, initialMat, key,
+                                             keySize, paint);
     fLayerHash.add(layer);
     return layer;
 }
 
 GrCachedLayer* GrLayerCache::findLayer(uint32_t pictureID, const SkMatrix& initialMat,
                                        const int* key, int keySize) {
     SkASSERT(pictureID != SK_InvalidGenID);
     return fLayerHash.find(GrCachedLayer::Key(pictureID, initialMat, key, keySize));
 }
 
@@ skipping 44 matching lines @@
     } else {
         if (!fAtlas) {
             this->initAtlas();
             if (!fAtlas) {
                 return false;
             }
         }
         // Not in the atlas - will it fit?
         GrPictureInfo* pictInfo = fPictureHash.find(layer->pictureID());
         if (NULL == pictInfo) {
-            pictInfo = SkNEW_ARGS(GrPictureInfo, (layer->pictureID()));
+            pictInfo = new GrPictureInfo(layer->pictureID());
             fPictureHash.add(pictInfo);
         }
 
         SkIPoint16 loc;
         for (int i = 0; i < 2; ++i) { // extra pass in case we fail to add but are able to purge
             GrPlot* plot = fAtlas->addToAtlas(&pictInfo->fPlotUsage,
                                               desc.fWidth, desc.fHeight,
                                               NULL, &loc);
             // addToAtlas can allocate the backing texture
             SkDEBUGCODE(avl.setBackingTexture(fAtlas->getTexture()));
@@ skipping 14 matching lines @@
 
             // The layer was rejected by the atlas (even though we know it is
             // plausibly atlas-able). See if a plot can be purged and try again.
             if (!this->purgePlot()) {
                 break;  // We weren't able to purge any plots
             }
         }
 
         if (pictInfo->fPlotUsage.isEmpty()) {
             fPictureHash.remove(pictInfo->fPictureID);
-            SkDELETE(pictInfo);
+            delete pictInfo;
         }
     }
 
     return false;
 }
 
 bool GrLayerCache::lock(GrCachedLayer* layer, const GrSurfaceDesc& desc, bool* needsRendering) {
     if (layer->locked()) {
         // This layer is already locked
         *needsRendering = false;
@@ skipping 39 matching lines @@
         GrPictureInfo* pictInfo = fPictureHash.find(layer->pictureID());
         SkASSERT(pictInfo);
 
         pictInfo->decPlotUsage(plotID);
 
         if (0 == pictInfo->plotUsage(plotID)) {
             GrAtlas::RemovePlot(&pictInfo->fPlotUsage, layer->plot());
 
             if (pictInfo->fPlotUsage.isEmpty()) {
                 fPictureHash.remove(pictInfo->fPictureID);
-                SkDELETE(pictInfo);
+                delete pictInfo;
             }
         }
 
         layer->setPlot(NULL);
         layer->setTexture(NULL, SkIRect::MakeEmpty());
 #endif
 
     } else {
         layer->setTexture(NULL, SkIRect::MakeEmpty());
     }
@@ skipping 64 matching lines @@
     for (; !iter.done(); ++iter) {
         if (pictureID == (*iter).pictureID()) {
             *toBeRemoved.append() = &(*iter);
         }
     }
 
     for (int i = 0; i < toBeRemoved.count(); ++i) {
         SkASSERT(0 == toBeRemoved[i]->uses());
         this->unlock(toBeRemoved[i]);
         fLayerHash.remove(GrCachedLayer::GetKey(*toBeRemoved[i]));
-        SkDELETE(toBeRemoved[i]);
+        delete toBeRemoved[i];
     }
 
     GrPictureInfo* pictInfo = fPictureHash.find(pictureID);
     if (pictInfo) {
         fPictureHash.remove(pictureID);
-        SkDELETE(pictInfo);
+        delete pictInfo;
     }
 }
 
 bool GrLayerCache::purgePlot() {
     SkDEBUGCODE(GrAutoValidateCache avc(this);)
     SkASSERT(fAtlas);
 
     GrAtlas::PlotIter iter;
     GrPlot* plot;
     for (plot = fAtlas->iterInit(&iter, GrAtlas::kLRUFirst_IterOrder);
@@ skipping 24 matching lines @@
     }
 
     for (int i = 0; i < toBeRemoved.count(); ++i) {
         SkASSERT(0 == toBeRemoved[i]->uses());
         SkASSERT(!toBeRemoved[i]->locked());
 
         uint32_t pictureIDToRemove = toBeRemoved[i]->pictureID();
 
         // Aggressively remove layers and, if it becomes totally uncached, delete the picture info
         fLayerHash.remove(GrCachedLayer::GetKey(*toBeRemoved[i]));
-        SkDELETE(toBeRemoved[i]);
+        delete toBeRemoved[i];
 
         GrPictureInfo* pictInfo = fPictureHash.find(pictureIDToRemove);
         if (pictInfo) {
 #if !GR_CACHE_HOISTED_LAYERS
             SkASSERT(0 == pictInfo->plotUsage(plot->id()));
 #endif
             GrAtlas::RemovePlot(&pictInfo->fPlotUsage, plot);
 
             if (pictInfo->fPlotUsage.isEmpty()) {
                 fPictureHash.remove(pictInfo->fPictureID);
-                SkDELETE(pictInfo);
+                delete pictInfo;
             }
         }
     }
 
     plot->resetRects();
 }
 
 #if !GR_CACHE_HOISTED_LAYERS
 void GrLayerCache::purgeAll() {
     if (!fAtlas) {
@@ skipping 54 matching lines @@
         fileName.appendf("\\%d", layer->fKey.pictureID());
         for (int i = 0; i < layer->fKey.keySize(); ++i) {
             fileName.appendf("-%d", layer->fKey.key()[i]);
         }
         fileName.appendf(".png");
 
         layer->texture()->surfacePriv().savePixels(fileName.c_str());
     }
 }
 #endif