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

src/core/SkBitmapScaler.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 "SkBitmapScaler.h"
 #include "SkBitmapFilter.h"
 #include "SkConvolver.h"
 #include "SkImageInfo.h"
 #include "SkPixmap.h"
 #include "SkRect.h"
 #include "SkScalar.h"
 #include "SkTArray.h"
 
 // SkResizeFilter ----------------------------------------------------------------
 
 // Encapsulates computation and storage of the filters required for one complete
 // resize operation.
 class SkResizeFilter {
 public:
     SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                    int srcFullWidth, int srcFullHeight,
                    float destWidth, float destHeight,
                    const SkRect& destSubset,
                    const SkConvolutionProcs& convolveProcs);
-    ~SkResizeFilter() {
-        SkDELETE( fBitmapFilter );
-    }
+    ~SkResizeFilter() { delete fBitmapFilter; }
 
     // Returns the filled filter values.
     const SkConvolutionFilter1D& xFilter() { return fXFilter; }
     const SkConvolutionFilter1D& yFilter() { return fYFilter; }
 
 private:
 
     SkBitmapFilter* fBitmapFilter;
 
     // Computes one set of filters either horizontally or vertically. The caller
@@ skipping 22 matching lines @@
                                float destWidth, float destHeight,
                                const SkRect& destSubset,
                                const SkConvolutionProcs& convolveProcs) {
 
     // method will only ever refer to an "algorithm method".
     SkASSERT((SkBitmapScaler::RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
              (method <= SkBitmapScaler::RESIZE_LAST_ALGORITHM_METHOD));
 
     switch(method) {
         case SkBitmapScaler::RESIZE_BOX:
-            fBitmapFilter = SkNEW(SkBoxFilter);
+            fBitmapFilter = new SkBoxFilter;
             break;
         case SkBitmapScaler::RESIZE_TRIANGLE:
-            fBitmapFilter = SkNEW(SkTriangleFilter);
+            fBitmapFilter = new SkTriangleFilter;
             break;
         case SkBitmapScaler::RESIZE_MITCHELL:
-            fBitmapFilter = SkNEW_ARGS(SkMitchellFilter, (1.f/3.f, 1.f/3.f));
+            fBitmapFilter = new SkMitchellFilter(1.f / 3.f, 1.f / 3.f);
             break;
         case SkBitmapScaler::RESIZE_HAMMING:
-            fBitmapFilter = SkNEW(SkHammingFilter);
+            fBitmapFilter = new SkHammingFilter;
             break;
         case SkBitmapScaler::RESIZE_LANCZOS3:
-            fBitmapFilter = SkNEW(SkLanczosFilter);
+            fBitmapFilter = new SkLanczosFilter;
             break;
         default:
             // NOTREACHED:
-            fBitmapFilter = SkNEW_ARGS(SkMitchellFilter, (1.f/3.f, 1.f/3.f));
+            fBitmapFilter = new SkMitchellFilter(1.f / 3.f, 1.f / 3.f);
             break;
     }
 
 
     float scaleX = destWidth / srcFullWidth;
     float scaleY = destHeight / srcFullHeight;
 
     this->computeFilters(srcFullWidth, destSubset.fLeft, destSubset.width(),
                          scaleX, &fXFilter, convolveProcs);
     if (srcFullWidth == srcFullHeight &&
@@ skipping 205 matching lines @@
       static_cast<int>(result.rowBytes()),
       static_cast<unsigned char*>(result.getPixels()),
       convolveProcs, true);
 
     *resultPtr = result;
     resultPtr->lockPixels();
     SkASSERT(resultPtr->getPixels());
     return true;
 }