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

src/core/SkLightingShader.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 "SkBitmapProcState.h"
 #include "SkColor.h"
@@ skipping 273 matching lines @@
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->mulByUnknownFourComponents();
     }
 
     const SkVector3& lightDir() const { return fLightDir; }
     const SkColor3f& lightColor() const { return fLightColor; }
     const SkColor3f& ambientColor() const { return fAmbientColor; }
     const SkVector& invNormRotation() const { return fInvNormRotation; }
 
 private:
-    GrGLFragmentProcessor* onCreateGLInstance() const override { return SkNEW(LightingGLFP); }
+    GrGLFragmentProcessor* onCreateGLInstance() const override { return new LightingGLFP; }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override { 
         const LightingFP& lightingFP = proc.cast<LightingFP>();
         return fDiffDeviceTransform == lightingFP.fDiffDeviceTransform &&
                fNormDeviceTransform == lightingFP.fNormDeviceTransform &&
                fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
                fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
                fLightDir == lightingFP.fLightDir &&
                fLightColor == lightingFP.fLightColor &&
                fAmbientColor == lightingFP.fAmbientColor &&
@@ skipping 81 matching lines @@
 
     GrTextureParams normParams(kClamp_TileMode, normFilterMode);
     SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context,
                                                                    fNormalMap, &normParams));
     if (!normalTexture) {
         SkErrorInternals::SetError(kInternalError_SkError,
             "Couldn't convert bitmap to texture.");
         return false;
     }
 
-
-    *fp = SkNEW_ARGS(LightingFP, (pdm, diffuseTexture, normalTexture,
-                                  diffM, normM, diffParams, normParams, fLights,
-                                  fInvNormRotation));
+    *fp = new LightingFP(pdm, diffuseTexture, normalTexture, diffM, normM, diffParams, normParams,
+                         fLights, fInvNormRotation);
 
     *color = GrColorPackA4(paint.getAlpha());
     return true;
 }
 #else
 
 bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint, 
                                                const SkMatrix& viewM, const SkMatrix* localMatrix, 
                                                GrColor* color, GrProcessorDataManager*,
                                                GrFragmentProcessor** fp) const {
@@ skipping 198 matching lines @@
             SkVector3 dir;
             if (!buf.readScalarArray(&dir.fX, 3)) {
                 return NULL;
             }
             builder.add(SkLight(color, dir));        
         }
     }
 
     SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish());
 
-    return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights,
-                                             SkVector::Make(1.0f, 0.0f),
-                                             &diffLocalM, &normLocalM));
+    return new SkLightingShaderImpl(diffuse, normal, lights, SkVector::Make(1.0f, 0.0f),
+                                    &diffLocalM, &normLocalM);
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     this->INHERITED::flatten(buf);
 
     bool hasNormLocalM = !fNormLocalMatrix.isIdentity();
     buf.writeBool(hasNormLocalM);
     if (hasNormLocalM) {
         buf.writeMatrix(fNormLocalMatrix);
     }
@@ skipping 34 matching lines @@
     SkMatrix diffTotalInv;
     // computeTotalInverse was called in SkShader::createContext so we know it will succeed
     SkAssertResult(this->computeTotalInverse(rec, &diffTotalInv));
 
     SkMatrix normTotalInv;
     if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
         return NULL;
     }
 
     void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext);
-    SkBitmapProcState* diffuseState = SkNEW_PLACEMENT(diffuseStateStorage, SkBitmapProcState);
+    SkBitmapProcState* diffuseState = new (diffuseStateStorage) SkBitmapProcState;
     SkASSERT(diffuseState);
 
     diffuseState->fTileModeX = SkShader::kClamp_TileMode;
     diffuseState->fTileModeY = SkShader::kClamp_TileMode;
     diffuseState->fOrigBitmap = fDiffuseMap;
     if (!diffuseState->chooseProcs(diffTotalInv, *rec.fPaint)) {
         diffuseState->~SkBitmapProcState();
         return NULL;
     }
 
     void* normalStateStorage = (char*)storage + sizeof(LightingShaderContext) + sizeof(SkBitmapProcState);
-    SkBitmapProcState* normalState = SkNEW_PLACEMENT(normalStateStorage, SkBitmapProcState);
+    SkBitmapProcState* normalState = new (normalStateStorage) SkBitmapProcState;
     SkASSERT(normalState);
 
     normalState->fTileModeX = SkShader::kClamp_TileMode;
     normalState->fTileModeY = SkShader::kClamp_TileMode;
     normalState->fOrigBitmap = fNormalMap;
     if (!normalState->chooseProcs(normTotalInv, *rec.fPaint)) {
         diffuseState->~SkBitmapProcState();
         normalState->~SkBitmapProcState();
         return NULL;
     }
 
-    return SkNEW_PLACEMENT_ARGS(storage, LightingShaderContext, (*this, rec,
-                                                                 diffuseState, normalState));
+    return new (storage) LightingShaderContext(*this, rec, diffuseState, normalState);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool bitmap_is_too_big(const SkBitmap& bm) {
     // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it
     // communicates between its matrix-proc and its sampler-proc. Until we can
     // widen that, we have to reject bitmaps that are larger.
     //
     static const int kMaxSize = 65535;
 
     return bm.width() > kMaxSize || bm.height() > kMaxSize;
 }
 
 SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& normal,
                                    const Lights* lights,
                                    const SkVector& invNormRotation,
                                    const SkMatrix* diffLocalM, const SkMatrix* normLocalM) {
     if (diffuse.isNull() || bitmap_is_too_big(diffuse) ||
         normal.isNull() || bitmap_is_too_big(normal) ||
         diffuse.width() != normal.width() ||
         diffuse.height() != normal.height()) {
         return nullptr;
     }
 
     SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1));
 
-    return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights,
-                                             invNormRotation, diffLocalM, normLocalM));
+    return new SkLightingShaderImpl(diffuse, normal, lights, invNormRotation, diffLocalM,
+                                    normLocalM);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////