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

src/pdf/SkPDFShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
@@ skipping 500 matching lines @@
     }
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(SkPDFCanon* canon,
                                        SkScalar dpi,
                                        const SkShader& shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox,
                                        SkScalar rasterScale) {
-    SkAutoTDelete<SkPDFShader::State> state(
-            SkNEW_ARGS(State, (shader, matrix, surfaceBBox, rasterScale)));
+    SkAutoTDelete<SkPDFShader::State> state(new State(shader, matrix, surfaceBBox, rasterScale));
     return get_pdf_shader_by_state(canon, dpi, &state);
 }
 
 static SkPDFDict* get_gradient_resource_dict(
         SkPDFObject* functionShader,
         SkPDFObject* gState) {
     SkTDArray<SkPDFObject*> patterns;
     if (functionShader) {
         patterns.push(functionShader);
     }
@@ skipping 85 matching lines @@
     if (!colorShader) {
         return NULL;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
     SkAutoTUnref<SkPDFObject> alphaGs(
             create_smask_graphic_state(canon, dpi, state));
 
     SkPDFAlphaFunctionShader* alphaFunctionShader =
-            SkNEW_ARGS(SkPDFAlphaFunctionShader, (autoState->detach()));
+            new SkPDFAlphaFunctionShader(autoState->detach());
 
     SkAutoTUnref<SkPDFDict> resourceDict(
             get_gradient_resource_dict(colorShader.get(), alphaGs.get()));
 
     SkAutoTDelete<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     alphaFunctionShader->setData(colorStream.get());
 
     populate_tiling_pattern_dict(alphaFunctionShader, bbox, resourceDict.get(),
                                  SkMatrix::I());
@@ skipping 34 matching lines @@
 
     affine->setAll(sx - p0 * tx / p2,       kx - p1 * tx / p2,      tx / p2,
                    ky - p0 * ty / p2,       sy - p1 * ty / p2,      ty / p2,
                    zero,                    zero,                   one);
 
     return true;
 }
 
 namespace {
 SkPDFObject* create_range_object() {
-    SkPDFArray* range = SkNEW(SkPDFArray);
+    SkPDFArray* range = new SkPDFArray;
     range->reserve(6);
     range->appendInt(0);
     range->appendInt(1);
     range->appendInt(0);
     range->appendInt(1);
     range->appendInt(0);
     range->appendInt(1);
     return range;
 }
 
 template <typename T> void unref(T* ptr) { ptr->unref();}
 }  // namespace
 
 SK_DECLARE_STATIC_LAZY_PTR(SkPDFObject, rangeObject,
                            create_range_object, unref<SkPDFObject>);
 
 static SkPDFStream* make_ps_function(const SkString& psCode,
                                      SkPDFArray* domain) {
     SkAutoDataUnref funcData(
             SkData::NewWithCopy(psCode.c_str(), psCode.size()));
-    SkPDFStream* result = SkNEW_ARGS(SkPDFStream, (funcData.get()));
+    SkPDFStream* result = new SkPDFStream(funcData.get());
     result->insertInt("FunctionType", 4);
     result->insertObject("Domain", SkRef(domain));
     result->insertObject("Range", SkRef(rangeObject.get()));
     return result;
 }
 
 SkPDFFunctionShader* SkPDFFunctionShader::Create(
         SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
@@ skipping 92 matching lines @@
 
     SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insertObject("Domain", SkRef(domain.get()));
 
     SkAutoTUnref<SkPDFStream> function(
             make_ps_function(functionCode, domain.get()));
     pdfShader->insertObjRef("Function", function.detach());
 
-    SkPDFFunctionShader* pdfFunctionShader =
-            SkNEW_ARGS(SkPDFFunctionShader, (autoState->detach()));
+    SkPDFFunctionShader* pdfFunctionShader = new SkPDFFunctionShader(autoState->detach());
 
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insertObject("Matrix",
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", pdfShader.detach());
 
     canon->addFunctionShader(pdfFunctionShader);
     return pdfFunctionShader;
 }
 
@@ skipping 192 matching lines @@
                 bottomMatrix.postTranslate(2 * width, 0);
                 drawBitmapMatrix(&canvas, bottom, bottomMatrix);
             }
             patternBBox.fBottom = deviceBounds.height();
         }
     }
 
     // Put the canvas into the pattern stream (fContent).
     SkAutoTDelete<SkStreamAsset> content(patternDevice->content());
 
-    SkPDFImageShader* imageShader =
-            SkNEW_ARGS(SkPDFImageShader, (autoState->detach()));
+    SkPDFImageShader* imageShader = new SkPDFImageShader(autoState->detach());
     imageShader->setData(content.get());
 
     SkAutoTUnref<SkPDFDict> resourceDict(
             patternDevice->createResourceDict());
     populate_tiling_pattern_dict(imageShader, patternBBox,
                                  resourceDict.get(), finalMatrix);
 
     imageShader->fShaderState->fImage.unlockPixels();
 
     canon->addImageShader(imageShader);
@@ skipping 189 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }