Style Change: NULL->nullptr

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 25 matching lines @@
     SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(args, gpu));
 
     GrGLProgramBuilder* pb = builder.get();
 
     // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
     // seed correctly here
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
     if (!pb->emitAndInstallProcs(&inputColor, &inputCoverage)) {
-        return NULL;
+        return nullptr;
     }
 
     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 new GrGLPathProgramBuilder(gpu, args);
     } else {
         return new GrGLProgramBuilder(gpu, args);
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
     , fOutOfStage(true)
     , fStageIndex(-1)
-    , fGeometryProcessor(NULL)
-    , fXferProcessor(NULL)
+    , fGeometryProcessor(nullptr)
+    , fXferProcessor(nullptr)
     , fArgs(args)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock)
     , fSamplerUniforms(4) {
 }
 
 void GrGLProgramBuilder::addVarying(const char* name,
                                     GrGLVarying* varying,
                                     GrSLPrecision fsPrecision) {
     SkASSERT(varying);
@@ skipping 161 matching lines @@
                                             GrGLSLExpr4* output) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(output, "output");
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
     fFS.codeAppend(openBrace.c_str());
 
-    this->emitAndInstallProc(fp, index, output->c_str(), input.isOnes() ? NULL : input.c_str());
+    this->emitAndInstallProc(fp, index, output->c_str(), input.isOnes() ? nullptr : input.c_str());
 
     fFS.codeAppend("}");
 }
 
 void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& proc,
                                             GrGLSLExpr4* outputColor,
                                             GrGLSLExpr4* outputCoverage) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(outputColor, "outputColor");
@@ skipping 117 matching lines @@
         SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
                                (localSamplerUniforms[t], processor.textureAccess(t)));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::finalize() {
     // verify we can get a program id
     GrGLuint programID;
     GL_CALL_RET(programID, CreateProgram());
     if (0 == programID) {
-        return NULL;
+        return nullptr;
     }
 
     // compile shaders and bind attributes / uniforms
     SkTDArray<GrGLuint> shadersToDelete;
 
     if (!fVS.compileAndAttachShaders(programID, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
-        return NULL;
+        return nullptr;
     }
 
     // NVPR actually requires a vertex shader to compile
     bool useNvpr = primitiveProcessor().isPathRendering();
     if (!useNvpr) {
         fVS.bindVertexAttributes(programID);
     }
 
     if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
-        return NULL;
+        return nullptr;
     }
 
     this->bindProgramResourceLocations(programID);
 
     GL_CALL(LinkProgram(programID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = kChromium_GrGLDriver != fGpu->ctxInfo().driver();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
         checkLinkStatus(programID);
     }
     this->resolveProgramResourceLocations(programID);
 
     this->cleanupShaders(shadersToDelete);
 
     return this->createProgram(programID);
 }
 
 void GrGLProgramBuilder::bindProgramResourceLocations(GrGLuint programID) {
-    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != nullptr;
     if (usingBindUniform) {
         int count = fUniforms.count();
         for (int i = 0; i < count; ++i) {
             GL_CALL(BindUniformLocation(programID, i, fUniforms[i].fVariable.c_str()));
             fUniforms[i].fLocation = i;
         }
     }
 
     fFS.bindFragmentShaderLocations(programID);
 }
@@ skipping 16 matching lines @@
             SkDebugf("%s", (char*)log.get());
         }
         SkDEBUGFAIL("Error linking program");
         GL_CALL(DeleteProgram(programID));
         programID = 0;
     }
     return SkToBool(linked);
 }
 
 void GrGLProgramBuilder::resolveProgramResourceLocations(GrGLuint programID) {
-    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != nullptr;
     if (!usingBindUniform) {
         int count = fUniforms.count();
         for (int i = 0; i < count; ++i) {
             GrGLint location;
             GL_CALL_RET(location, GetUniformLocation(programID, fUniforms[i].fVariable.c_str()));
             fUniforms[i].fLocation = location;
         }
     }
 }
 
@@ skipping 14 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }