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

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 
 #include "gl/GrGLGeometryProcessor.h"
@@ skipping 37 matching lines @@
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const DrawArgs& args,
                                                              GrGLGpu* gpu) {
     if (args.fPrimitiveProcessor->isPathRendering()) {
         SkASSERT(gpu->glCaps().shaderCaps()->pathRenderingSupport() &&
                  !args.fPrimitiveProcessor->willUseGeoShader() &&
                  args.fPrimitiveProcessor->numAttribs() == 0);
-        return SkNEW_ARGS(GrGLPathProgramBuilder, (gpu, args));
+        return new GrGLPathProgramBuilder(gpu, args);
     } else {
-        return SkNEW_ARGS(GrGLProgramBuilder, (gpu, args));
+        return new GrGLProgramBuilder(gpu, args);
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
     , fOutOfStage(true)
@@ skipping 125 matching lines @@
 
         totalTextures += processor->numTextures();
         if (totalTextures >= maxTextureUnits) {
             GrCapsDebugf(fGpu->caps(), "Program would use too many texture units\n");
             return false;
         }
     }
 
     this->emitAndInstallProc(primProc, inputColor, inputCoverage);
 
-    fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
+    fFragmentProcessors.reset(new GrGLInstalledFragProcs);
     int numProcs = this->pipeline().numFragmentStages();
     this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentStages(), inputColor);
     this->emitAndInstallFragProcs(this->pipeline().numColorFragmentStages(), numProcs,
                                   inputCoverage);
     this->emitAndInstallXferProc(*this->pipeline().getXferProcessor(), *inputColor, *inputCoverage);
     return true;
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset,
                                                  int numProcs,
@@ skipping 56 matching lines @@
 
     this->emitAndInstallProc(proc, outputColor->c_str(), outputCoverage->c_str());
 
     fFS.codeAppend("}");
 }
 
 void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& fs,
                                             int index,
                                             const char* outColor,
                                             const char* inColor) {
-    GrGLInstalledFragProc* ifp = SkNEW(GrGLInstalledFragProc);
+    GrGLInstalledFragProc* ifp = new GrGLInstalledFragProc;
 
     const GrFragmentProcessor& fp = *fs.processor();
     ifp->fGLProc.reset(fp.createGLInstance());
 
     SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTextures());
     this->emitSamplers(fp, &samplers, ifp);
 
     GrGLFragmentProcessor::EmitArgs args(this, fp, outColor, inColor, fOutCoords[index], samplers);
     ifp->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(fp);
     fFragmentProcessors->fProcs.push_back(ifp);
 }
 
 void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& gp,
                                             const char* outColor,
                                             const char* outCoverage) {
     SkASSERT(!fGeometryProcessor);
-    fGeometryProcessor = SkNEW(GrGLInstalledGeoProc);
+    fGeometryProcessor = new GrGLInstalledGeoProc;
 
     const GrBatchTracker& bt = this->batchTracker();
     fGeometryProcessor->fGLProc.reset(gp.createGLInstance(bt, *fGpu->glCaps().glslCaps()));
 
     SkSTArray<4, GrGLProcessor::TextureSampler> samplers(gp.numTextures());
     this->emitSamplers(gp, &samplers, fGeometryProcessor);
 
     GrGLGeometryProcessor::EmitArgs args(this, gp, bt, outColor, outCoverage, samplers,
                                          fCoordTransforms, &fOutCoords);
     fGeometryProcessor->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(gp);
 }
 
 void GrGLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                                 const GrGLSLExpr4& colorIn,
                                                 const GrGLSLExpr4& coverageIn) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
 
     SkASSERT(!fXferProcessor);
-    fXferProcessor = SkNEW(GrGLInstalledXferProc);
+    fXferProcessor = new GrGLInstalledXferProc;
 
     fXferProcessor->fGLProc.reset(xp.createGLInstance());
 
     // Enable dual source secondary output if we have one
     if (xp.hasSecondaryOutput()) {
         fFS.enableSecondaryOutput();
     }
 
     if (this->ctxInfo().caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
         fFS.enableCustomOutput();
@@ skipping 146 matching lines @@
     GL_CALL(DeleteProgram(programID));
     cleanupShaders(shaderIDs);
 }
 void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) {
     for (int i = 0; i < shaderIDs.count(); ++i) {
       GL_CALL(DeleteShader(shaderIDs[i]));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
-    return SkNEW_ARGS(GrGLProgram, (fGpu, this->desc(), fUniformHandles, programID, fUniforms,
-                                    fGeometryProcessor, fXferProcessor, fFragmentProcessors.get(),
-                                    &fSamplerUniforms));
+    return new GrGLProgram(fGpu, this->desc(), fUniformHandles, programID, fUniforms,
+                           fGeometryProcessor, fXferProcessor, fFragmentProcessors.get(),
+                           &fSamplerUniforms);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
-        SkDELETE(fProcs[e]);
+        delete fProcs[e];
     }
 }