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

src/effects/SkMatrixConvolutionImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 21 matching lines @@
     SkImageFilter* input,
     const CropRect* cropRect)
   : INHERITED(1, &input, cropRect),
     fKernelSize(kernelSize),
     fGain(gain),
     fBias(bias),
     fKernelOffset(kernelOffset),
     fTileMode(tileMode),
     fConvolveAlpha(convolveAlpha) {
     size_t size = (size_t) sk_64_mul(fKernelSize.width(), fKernelSize.height());
-    fKernel = SkNEW_ARRAY(SkScalar, size);
+    fKernel = new SkScalar[size];
     memcpy(fKernel, kernel, size * sizeof(SkScalar));
     SkASSERT(kernelSize.fWidth >= 1 && kernelSize.fHeight >= 1);
     SkASSERT(kernelOffset.fX >= 0 && kernelOffset.fX < kernelSize.fWidth);
     SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight);
 }
 
 SkMatrixConvolutionImageFilter* SkMatrixConvolutionImageFilter::Create(
     const SkISize& kernelSize,
     const SkScalar* kernel,
     SkScalar gain,
     SkScalar bias,
     const SkIPoint& kernelOffset,
     TileMode tileMode,
     bool convolveAlpha,
     SkImageFilter* input,
     const CropRect* cropRect) {
     if (kernelSize.width() < 1 || kernelSize.height() < 1) {
         return NULL;
     }
     if (gMaxKernelSize / kernelSize.fWidth < kernelSize.fHeight) {
         return NULL;
     }
     if (!kernel) {
         return NULL;
     }
     if ((kernelOffset.fX < 0) || (kernelOffset.fX >= kernelSize.fWidth) ||
         (kernelOffset.fY < 0) || (kernelOffset.fY >= kernelSize.fHeight)) {
         return NULL;
     }
-    return SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize, kernel, gain, bias,
-                                                       kernelOffset, tileMode, convolveAlpha,
-                                                       input, cropRect));
+    return new SkMatrixConvolutionImageFilter(kernelSize, kernel, gain, bias, kernelOffset,
+                                              tileMode, convolveAlpha, input, cropRect);
 }
 
 SkFlattenable* SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkISize kernelSize;
     kernelSize.fWidth = buffer.readInt();
     kernelSize.fHeight = buffer.readInt();
     const int count = buffer.getArrayCount();
 
     const int64_t kernelArea = sk_64_mul(kernelSize.width(), kernelSize.height());
@@ skipping 294 matching lines @@
             str->appendf("%f ", fKernel[y * fKernelSize.width() + x]);
         }
     }
     str->appendf(")");
     str->appendf("gain: %f bias: %f ", fGain, fBias);
     str->appendf("offset: (%d, %d) ", fKernelOffset.fX, fKernelOffset.fY);
     str->appendf("convolveAlpha: %s", fConvolveAlpha ? "true" : "false");
     str->append(")");
 }
 #endif