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

src/core/SkImageFilter.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 "SkImageFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 186 matching lines @@
     delete[] fInputs;
 }
 
 SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer)
   : fUsesSrcInput(false)
   , fUniqueID(next_image_filter_unique_id()) {
     Common common;
     if (common.unflatten(buffer, inputCount)) {
         fCropRect = common.cropRect();
         fInputCount = common.inputCount();
-        fInputs = SkNEW_ARRAY(SkImageFilter*, fInputCount);
+        fInputs = new SkImageFilter* [fInputCount];
         common.detachInputs(fInputs);
         for (int i = 0; i < fInputCount; ++i) {
             if (NULL == fInputs[i] || fInputs[i]->usesSrcInput()) {
                 fUsesSrcInput = true;
             }
         }
     } else {
         fInputCount = 0;
         fInputs = NULL;
     }
@@ skipping 219 matching lines @@
                                                  SkFilterQuality filterQuality,
                                                  SkImageFilter* input) {
     return SkMatrixImageFilter::Create(matrix, filterQuality, input);
 }
 
 #if SK_SUPPORT_GPU
 
 void SkImageFilter::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
-    result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
+    result->setPixelRef(new SkGrPixelRef(info, texture))->unref();
 }
 
 bool SkImageFilter::getInputResultGPU(SkImageFilter::Proxy* proxy,
                                       const SkBitmap& src, const Context& ctx,
                                       SkBitmap* result, SkIPoint* offset) const {
     // Ensure that GrContext calls under filterImage and filterImageGPU below will see an identity
     // matrix with no clip and that the matrix, clip, and render target set before this function was
     // called are restored before we return to the caller.
     GrContext* context = src.getTexture()->getContext();
 
     if (this->canFilterImageGPU()) {
         return this->filterImageGPU(proxy, src, ctx, result, offset);
     } else {
         if (this->filterImage(proxy, src, ctx, result, offset)) {
             if (!result->getTexture()) {
                 const SkImageInfo info = result->info();
                 if (kUnknown_SkColorType == info.colorType()) {
                     return false;
                 }
                 SkAutoTUnref<GrTexture> resultTex(GrRefCachedBitmapTexture(context, *result, NULL));
-                result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, resultTex)))->unref();
+                result->setPixelRef(new SkGrPixelRef(info, resultTex))->unref();
             }
             return true;
         } else {
             return false;
         }
     }
 }
 #endif
 
 namespace {
@@ skipping 81 matching lines @@
     mutable SkMutex                    fMutex;
 };
 
 SkImageFilter::Cache* CreateCache() {
     return SkImageFilter::Cache::Create(kDefaultCacheSize);
 }
 
 } // namespace
 
 SkImageFilter::Cache* SkImageFilter::Cache::Create(size_t maxBytes) {
-    return SkNEW_ARGS(CacheImpl, (maxBytes));
+    return new CacheImpl(maxBytes);
 }
 
 SK_DECLARE_STATIC_LAZY_PTR(SkImageFilter::Cache, cache, CreateCache);
 
 SkImageFilter::Cache* SkImageFilter::Cache::Get() {
     return cache.get();
 }
 
 void SkImageFilter::PurgeCache() {
     cache.get()->purge();
@@ skipping 14 matching lines @@
     }
     return dev;
 }
 
 bool SkImageFilter::Proxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                                        const SkImageFilter::Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) {
     return fDevice->filterImage(filter, src, ctx, result, offset);
 }