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

src/gpu/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 35 matching lines @@
     GrAADistanceFieldPathRenderer* dfpr = (GrAADistanceFieldPathRenderer*)pr;
     // remove any paths that use this plot
     PathDataList::Iter iter;
     iter.init(dfpr->fPathList, PathDataList::Iter::kHead_IterStart);
     PathData* pathData;
     while ((pathData = iter.get())) {
         iter.next();
         if (id == pathData->fID) {
             dfpr->fPathCache.remove(pathData->fKey);
             dfpr->fPathList.remove(pathData);
-            SkDELETE(pathData);
+            delete pathData;
 #ifdef DF_PATH_TRACKING
             ++g_NumFreedPaths;
 #endif
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrAADistanceFieldPathRenderer::GrAADistanceFieldPathRenderer() : fAtlas(NULL) {}
 
 GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() {
     PathDataList::Iter iter;
     iter.init(fPathList, PathDataList::Iter::kHead_IterStart);
     PathData* pathData;
     while ((pathData = iter.get())) {
         iter.next();
         fPathList.remove(pathData);
-        SkDELETE(pathData);
+        delete pathData;
     }
-    SkDELETE(fAtlas);
+    delete fAtlas;
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     
     // TODO: Support inverse fill
@@ skipping 31 matching lines @@
     struct Geometry {
         Geometry(const SkStrokeRec& stroke) : fStroke(stroke) {}
         SkPath fPath;
         SkStrokeRec fStroke;
         bool fAntiAlias;
         PathData* fPathData;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                                GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
-        return SkNEW_ARGS(AADistanceFieldPathBatch, (geometry, color, viewMatrix,
-                                                     atlas, pathCache, pathList));
+        return new AADistanceFieldPathBatch(geometry, color, viewMatrix, atlas, pathCache,
+                                            pathList);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fBatch.fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
@@ skipping 84 matching lines @@
 
             // check to see if path is cached
             // TODO: handle stroked vs. filled version of same path
             PathData::Key key = { args.fPath.getGenerationID(), desiredDimension };
             args.fPathData = fPathCache->find(key);
             if (NULL == args.fPathData || !atlas->hasID(args.fPathData->fID)) {
                 // Remove the stale cache entry
                 if (args.fPathData) {
                     fPathCache->remove(args.fPathData->fKey);
                     fPathList->remove(args.fPathData);
-                    SkDELETE(args.fPathData);
+                    delete args.fPathData;
                 }
                 SkScalar scale = desiredDimension/maxDim;
-                args.fPathData = SkNEW(PathData);
+                args.fPathData = new PathData;
                 if (!this->addPathToAtlas(target,
                                           dfProcessor,
                                           this->pipeline(),
                                           &flushInfo,
                                           atlas,
                                           args.fPathData,
                                           args.fPath,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
@@ skipping 313 matching lines @@
     PathTestStruct() : fContextID(SK_InvalidGenID), fAtlas(NULL) {}
     ~PathTestStruct() { this->reset(); }
 
     void reset() {
         PathDataList::Iter iter;
         iter.init(fPathList, PathDataList::Iter::kHead_IterStart);
         PathData* pathData;
         while ((pathData = iter.get())) {
             iter.next();
             fPathList.remove(pathData);
-            SkDELETE(pathData);
+            delete pathData;
         }
-        SkDELETE(fAtlas);
+        delete fAtlas;
         fPathCache.reset();
     }
 
     static void HandleEviction(GrBatchAtlas::AtlasID id, void* pr) {
         PathTestStruct* dfpr = (PathTestStruct*)pr;
         // remove any paths that use this plot
         PathDataList::Iter iter;
         iter.init(dfpr->fPathList, PathDataList::Iter::kHead_IterStart);
         PathData* pathData;
         while ((pathData = iter.get())) {
             iter.next();
             if (id == pathData->fID) {
                 dfpr->fPathCache.remove(pathData->fKey);
                 dfpr->fPathList.remove(pathData);
-                SkDELETE(pathData);
+                delete pathData;
             }
         }
     }
 
     uint32_t fContextID;
     GrBatchAtlas* fAtlas;
     PathCache fPathCache;
     PathDataList fPathList;
 };
 
@@ skipping 18 matching lines @@
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif