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

src/gpu/GrBatchAtlas.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchAtlas.h"
 #include "GrBatchFlushState.h"
 #include "GrRectanizer.h"
@@ skipping 216 matching lines @@
     , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
     SkASSERT(fNumPlotsX * fNumPlotsY <= BulkUseTokenUpdater::kMaxPlots);
     SkASSERT(fPlotWidth * fNumPlotsX == static_cast<uint32_t>(texture->width()));
     SkASSERT(fPlotHeight * fNumPlotsY == static_cast<uint32_t>(texture->height()));
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig));
 
     // set up allocated plots
     fBPP = GrBytesPerPixel(texture->desc().fConfig);
-    fPlotArray = SkNEW_ARRAY(SkAutoTUnref<BatchPlot>, (fNumPlotsX * fNumPlotsY));
+    fPlotArray = new SkAutoTUnref<BatchPlot>[(fNumPlotsX * fNumPlotsY)];
 
     SkAutoTUnref<BatchPlot>* currPlot = fPlotArray;
     for (int y = fNumPlotsY - 1, r = 0; y >= 0; --y, ++r) {
         for (int x = fNumPlotsX - 1, c = 0; x >= 0; --x, ++c) {
             uint32_t id = r * fNumPlotsX + c;
-            currPlot->reset(SkNEW(BatchPlot));
+            currPlot->reset(new BatchPlot);
             (*currPlot)->init(this, texture, id, 1, x, y, fPlotWidth, fPlotHeight, fBPP);
 
             // build LRU list
             fPlotList.addToHead(currPlot->get());
             ++currPlot;
         }
     }
 }
 
 GrBatchAtlas::~GrBatchAtlas() {
     SkSafeUnref(fTexture);
-    SkDELETE_ARRAY(fPlotArray);
+    delete[] fPlotArray;
 }
 
 void GrBatchAtlas::processEviction(AtlasID id) {
     for (int i = 0; i < fEvictionCallbacks.count(); i++) {
         (*fEvictionCallbacks[i].fFunc)(id, fEvictionCallbacks[i].fData);
     }
 }
 
 void GrBatchAtlas::makeMRU(BatchPlot* plot) {
     if (fPlotList.head() == plot) {
         return;
     }
 
     fPlotList.remove(plot);
     fPlotList.addToHead(plot);
 }
 
 inline void GrBatchAtlas::updatePlot(GrDrawBatch::Target* target, AtlasID* id, BatchPlot* plot) {
     this->makeMRU(plot);
 
     // If our most recent upload has already occurred then we have to insert a new
     // upload. Otherwise, we already have a scheduled upload that hasn't yet ocurred.
     // This new update will piggy back on that previously scheduled update.
     if (target->hasTokenBeenFlushed(plot->lastUploadToken())) {
         plot->setLastUploadToken(target->asapToken());
-        SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (plot)));
+        SkAutoTUnref<GrPlotUploader> uploader(new GrPlotUploader(plot));
         target->upload(uploader);
     }
     *id = plot->id();
 }
 
 bool GrBatchAtlas::addToAtlas(AtlasID* id, GrDrawBatch::Target* batchTarget,
                               int width, int height, const void* image, SkIPoint16* loc) {
     // We should already have a texture, TODO clean this up
     SkASSERT(fTexture &&
              static_cast<uint32_t>(width) <= fPlotWidth &&
@@ skipping 39 matching lines @@
     // We take an extra ref here so our plot isn't deleted when we reset its index in the array.
     plot->ref();
     int index = plot->index();
     int x = plot->x();
     int y = plot->y();
     uint64_t generation = plot->genID();
 
     this->processEviction(plot->id());
     fPlotList.remove(plot);
     SkAutoTUnref<BatchPlot>& newPlot = fPlotArray[plot->index()];
-    newPlot.reset(SkNEW(BatchPlot));
+    newPlot.reset(new BatchPlot);
     newPlot->init(this, fTexture, index, ++generation, x, y, fPlotWidth, fPlotHeight, fBPP);
 
     fPlotList.addToHead(newPlot.get());
     SkDEBUGCODE(bool verify = )newPlot->addSubImage(width, height, image, loc, fBPP * width);
     SkASSERT(verify);
     newPlot->setLastUploadToken(batchTarget->currentToken());
-    SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (newPlot)));
+    SkAutoTUnref<GrPlotUploader> uploader(new GrPlotUploader(newPlot));
     batchTarget->upload(uploader);
     *id = newPlot->id();
     plot->unref();
     fAtlasGeneration++;
     return true;
 }
 
 bool GrBatchAtlas::hasID(AtlasID id) {
     uint32_t index = GetIndexFromID(id);
     SkASSERT(index < fNumPlotsX * fNumPlotsY);
@@ skipping 10 matching lines @@
 
 void GrBatchAtlas::setLastUseTokenBulk(const BulkUseTokenUpdater& updater,
                                        GrBatchToken batchToken) {
     int count = updater.fPlotsToUpdate.count();
     for (int i = 0; i < count; i++) {
         BatchPlot* plot = fPlotArray[updater.fPlotsToUpdate[i]];
         this->makeMRU(plot);
         plot->setLastUseToken(batchToken);
     }
 }