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

tools/skpdiff/SkPMetric.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 <cmath>
 #include <math.h>
 
 #include "SkBitmap.h"
 #include "skpdiff_util.h"
 #include "SkPMetric.h"
 #include "SkPMetricUtil_generated.h"
 
 struct RGB {
     float r, g, b;
 };
 
 struct LAB {
     float l, a, b;
 };
 
 template<class T>
 struct Image2D {
     int width;
     int height;
     T* image;
 
     Image2D(int w, int h)
         : width(w),
           height(h) {
         SkASSERT(w > 0);
         SkASSERT(h > 0);
-        image = SkNEW_ARRAY(T, w * h);
+        image = new T[w * h];
     }
 
-    ~Image2D() {
-        SkDELETE_ARRAY(image);
-    }
+    ~Image2D() { delete[] image; }
 
     void readPixel(int x, int y, T* pixel) const {
         SkASSERT(x >= 0);
         SkASSERT(y >= 0);
         SkASSERT(x < width);
         SkASSERT(y < height);
         *pixel = image[y * width + x];
     }
 
     T* getRow(int y) const {
@@ skipping 15 matching lines @@
 
 template<class T>
 struct ImageArray
 {
     int slices;
     Image2D<T>** image;
 
     ImageArray(int w, int h, int s)
         : slices(s) {
         SkASSERT(s > 0);
-        image = SkNEW_ARRAY(Image2D<T>*, s);
+        image = new Image2D<T>* [s];
         for (int sliceIndex = 0; sliceIndex < slices; sliceIndex++) {
-            image[sliceIndex] = SkNEW_ARGS(Image2D<T>, (w, h));
+            image[sliceIndex] = new Image2D<T>(w, h);
         }
     }
 
     ~ImageArray() {
         for (int sliceIndex = 0; sliceIndex < slices; sliceIndex++) {
-            SkDELETE(image[sliceIndex]);
+            delete image[sliceIndex];
         }
-        SkDELETE_ARRAY(image);
+        delete[] image;
     }
 
     Image2D<T>* getLayer(int z) const {
         SkASSERT(z >= 0);
         SkASSERT(z < slices);
         return image[z];
     }
 };
 
 typedef ImageArray<float> ImageL3D;
@@ skipping 199 matching lines @@
         return 0.0;
     }
 
     const float fov = SK_ScalarPI / 180.0f * 45.0f;
     float contrastSensitivityMax = contrast_sensitivity(3.248f, 100.0f);
     float pixelsPerDegree = width / (2.0f * tanf(fov * 0.5f) * 180.0f / SK_ScalarPI);
 
     ImageL3D baselineL(width, height, maxLevels);
     ImageL3D testL(width, height, maxLevels);
     ImageL scratchImageL(width, height);
-    float* cyclesPerDegree = SkNEW_ARRAY(float, maxLevels);
-    float* thresholdFactorFrequency = SkNEW_ARRAY(float, maxLevels - 2);
-    float* contrast = SkNEW_ARRAY(float, maxLevels - 2);
+    float* cyclesPerDegree = new float[maxLevels];
+    float* thresholdFactorFrequency = new float[maxLevels - 2];
+    float* contrast = new float[maxLevels - 2];
 
     lab_to_l(baselineLAB, baselineL.getLayer(0));
     lab_to_l(testLAB, testL.getLayer(0));
 
     // Compute cpd - Cycles per degree on the pyramid
     cyclesPerDegree[0] = 0.5f * pixelsPerDegree;
     for (int levelIndex = 1; levelIndex < maxLevels; levelIndex++) {
         cyclesPerDegree[levelIndex] = cyclesPerDegree[levelIndex - 1] * 0.5f;
     }
 
     // Contrast sensitivity is based on image dimensions. Therefore it cannot be statically
     // generated.
-    float* contrastSensitivityTable = SkNEW_ARRAY(float, maxLevels * 1000);
+    float* contrastSensitivityTable = new float[maxLevels * 1000];
     for (int levelIndex = 0; levelIndex < maxLevels; levelIndex++) {
         for (int csLum = 0; csLum < 1000; csLum++) {
            contrastSensitivityTable[levelIndex * 1000 + csLum] =
            contrast_sensitivity(cyclesPerDegree[levelIndex], (float)csLum / 10.0f + 1e-5f);
        }
     }
 
     // Compute G - The convolved lum for the baseline
     for (int levelIndex = 1; levelIndex < maxLevels; levelIndex++) {
         convolve(baselineL.getLayer(levelIndex - 1), false, &scratchImageL);
@@ skipping 103 matching lines @@
                     isFailure = true;
                 }
             }
 
             if (isFailure) {
                 (*poiCount)++;
             }
         }
     }
 
-    SkDELETE_ARRAY(cyclesPerDegree);
-    SkDELETE_ARRAY(contrast);
-    SkDELETE_ARRAY(thresholdFactorFrequency);
-    SkDELETE_ARRAY(contrastSensitivityTable);
+    delete[] cyclesPerDegree;
+    delete[] contrast;
+    delete[] thresholdFactorFrequency;
+    delete[] contrastSensitivityTable;
     return 1.0 - (double)(*poiCount) / (width * height);
 }
 
 bool SkPMetric::diff(SkBitmap* baseline, SkBitmap* test, const BitmapsToCreate& bitmapsToCreate,
                      Result* result) const {
     double startTime = get_seconds();
 
     // Ensure the images are comparable
     if (baseline->width() != test->width() || baseline->height() != test->height() ||
                     baseline->width() <= 0 || baseline->height() <= 0) {
         return false;
     }
 
     ImageLAB baselineLAB(baseline->width(), baseline->height());
     ImageLAB testLAB(baseline->width(), baseline->height());
 
     if (!bitmap_to_cielab(baseline, &baselineLAB) || !bitmap_to_cielab(test, &testLAB)) {
         return true;
     }
 
     result->poiCount = 0;
     result->result = pmetric(&baselineLAB, &testLAB, &result->poiCount);
     result->timeElapsed = get_seconds() - startTime;
 
     return true;
 }