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

tools/render_pictures_main.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 "LazyDecodeBitmap.h"
 #include "CopyTilesRenderer.h"
 #include "SkBitmap.h"
@@ skipping 255 matching lines @@
     SkBitmap* bitmap = NULL;
     renderer.setJsonSummaryPtr(jsonSummaryPtr);
     bool success = render_picture_internal(inputPath,
         FLAGS_writeWholeImage ? NULL : writePath,
         FLAGS_writeWholeImage ? NULL : mismatchPath,
         renderer,
         FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
 
     if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
         SkDebugf("Failed to draw the picture.\n");
-        SkDELETE(bitmap);
+        delete bitmap;
         return false;
     }
 
     if (FLAGS_validate) {
         SkBitmap* referenceBitmap = NULL;
         sk_tools::PictureRenderer* referenceRenderer;
         // If the renderer uses a BBoxHierarchy, then the reference renderer
         // will be the same renderer, without the bbh.
         AutoRestoreBbhType arbbh;
         if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
             renderer.getBBoxHierarchyType()) {
             referenceRenderer = &renderer;
             referenceRenderer->ref();  // to match auto unref below
             arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
         } else {
 #if SK_SUPPORT_GPU
-            referenceRenderer = SkNEW_ARGS(sk_tools::SimplePictureRenderer,
-                                           (renderer.getGrContextOptions()));
+            referenceRenderer = new sk_tools::SimplePictureRenderer(renderer.getGrContextOptions());
 #else
-            referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer);
+            referenceRenderer = new sk_tools::SimplePictureRenderer;
 #endif
         }
         SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
 
         success = render_picture_internal(inputPath, NULL, NULL, *referenceRenderer,
                                           &referenceBitmap);
 
         if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
             SkDebugf("Failed to draw the reference picture.\n");
-            SkDELETE(bitmap);
-            SkDELETE(referenceBitmap);
+            delete bitmap;
+            delete referenceBitmap;
             return false;
         }
 
         if (success && (bitmap->width() != referenceBitmap->width())) {
             SkDebugf("Expected image width: %i, actual image width %i.\n",
                      referenceBitmap->width(), bitmap->width());
-            SkDELETE(bitmap);
-            SkDELETE(referenceBitmap);
+            delete bitmap;
+            delete referenceBitmap;
             return false;
         }
         if (success && (bitmap->height() != referenceBitmap->height())) {
             SkDebugf("Expected image height: %i, actual image height %i",
                      referenceBitmap->height(), bitmap->height());
-            SkDELETE(bitmap);
-            SkDELETE(referenceBitmap);
+            delete bitmap;
+            delete referenceBitmap;
             return false;
         }
 
         for (int y = 0; success && y < bitmap->height(); y++) {
             for (int x = 0; success && x < bitmap->width(); x++) {
                 int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y),
                                        *bitmap->getAddr32(x, y));
                 SkASSERT(diff >= 0 && diff <= 255);
                 diffs[diff]++;
 
                 if (diff > FLAGS_maxComponentDiff) {
                     SkDebugf("Expected pixel at (%i %i) exceedds maximum "
                                  "component diff of %i: 0x%x, actual 0x%x\n",
                              x, y, FLAGS_maxComponentDiff,
                              *referenceBitmap->getAddr32(x, y),
                              *bitmap->getAddr32(x, y));
-                    SkDELETE(bitmap);
-                    SkDELETE(referenceBitmap);
+                    delete bitmap;
+                    delete referenceBitmap;
                     return false;
                 }
             }
         }
-        SkDELETE(referenceBitmap);
+        delete referenceBitmap;
 
         for (int i = 1; i <= 255; ++i) {
             if(diffs[i] > 0) {
                 SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
             }
         }
     }
 
     if (FLAGS_writeWholeImage) {
         sk_tools::force_all_opaque(*bitmap);
@@ skipping 10 matching lines @@
                 !jsonSummaryPtr->getExpectation(inputFilename.c_str()).matches(imageDigest)) {
                 success &= sk_tools::write_bitmap_to_disk(*bitmap, *mismatchPath, NULL,
                                                           outputFilename);
             }
         }
 
         if ((writePath) && !writePath->isEmpty()) {
             success &= sk_tools::write_bitmap_to_disk(*bitmap, *writePath, NULL, outputFilename);
         }
     }
-    SkDELETE(bitmap);
+    delete bitmap;
 
     return success;
 }
 
 
 static int process_input(const char* input, const SkString* writePath,
                          const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
                          sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
     SkOSFile::Iter iter(input, "skp");
     SkString inputFilename;
@@ skipping 116 matching lines @@
         jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
     }
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif