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

src/effects/SkColorFilters.cpp

 /*
  * Copyright 2006 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 "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
@@ skipping 116 matching lines @@
 class ModeColorFilterEffect : public GrFragmentProcessor {
 public:
     static GrFragmentProcessor* Create(const GrColor& c, SkXfermode::Mode mode) {
         // TODO: Make the effect take the coeffs rather than mode since we already do the
         // conversion here.
         SkXfermode::Coeff srcCoeff, dstCoeff;
         if (!SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) {
 //            SkDebugf("Failing to create color filter for mode %d\n", mode);
             return NULL;
         }
-        return SkNEW_ARGS(ModeColorFilterEffect, (c, mode));
+        return new ModeColorFilterEffect(c, mode);
     }
 
     bool willUseFilterColor() const {
         SkXfermode::Coeff dstCoeff;
         SkXfermode::Coeff srcCoeff;
         SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
         if (SkXfermode::kZero_Coeff == srcCoeff) {
             return GrBlendCoeffRefsSrc(sk_blend_to_grblend(dstCoeff));
         }
         return true;
@@ skipping 57 matching lines @@
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
 private:
     ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode)
         : fMode(mode),
           fColor(color) {
         this->initClassID<ModeColorFilterEffect>();
     }
 
-    GrGLFragmentProcessor* onCreateGLInstance() const override {
-        return SkNEW_ARGS(GLProcessor, (*this));
-    }
+    GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
 
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const override {
         GLProcessor::GenKey(*this, caps, b);
     }
 
     bool onIsEqual(const GrFragmentProcessor& other) const override {
         const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
         return fMode == s.fMode && fColor == s.fColor;
     }
@@ skipping 203 matching lines @@
                         SkXfermode::kDstOut_Mode == mode ||
                         SkXfermode::kSrcATop_Mode == mode ||
                         SkXfermode::kXor_Mode == mode ||
                         SkXfermode::kDarken_Mode == mode)) ||
             (0xFF == alpha && SkXfermode::kDstIn_Mode == mode)) {
         return NULL;
     }
 
     switch (mode) {
         case SkXfermode::kSrc_Mode:
-            return SkNEW_ARGS(Src_SkModeColorFilter, (color));
+            return new Src_SkModeColorFilter(color);
         case SkXfermode::kSrcOver_Mode:
-            return SkNEW_ARGS(SrcOver_SkModeColorFilter, (color));
+            return new SrcOver_SkModeColorFilter(color);
         default:
-            return SkNEW_ARGS(SkModeColorFilter, (color, mode));
+            return new SkModeColorFilter(color, mode);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkScalar byte_to_scale(U8CPU byte) {
     if (0xFF == byte) {
         // want to get this exact
         return 1;
     } else {
         return byte * 0.00392156862745f;
     }
 }
 
 SkColorFilter* SkColorFilter::CreateLightingFilter(SkColor mul, SkColor add) {
     SkColorMatrix matrix;
     matrix.setScale(byte_to_scale(SkColorGetR(mul)),
                     byte_to_scale(SkColorGetG(mul)),
                     byte_to_scale(SkColorGetB(mul)),
                     1);
     matrix.postTranslate(SkIntToScalar(SkColorGetR(add)),
                          SkIntToScalar(SkColorGetG(add)),
                          SkIntToScalar(SkColorGetB(add)),
                          0);
     return SkColorMatrixFilter::Create(matrix);
 }