Style Change: NULL->nullptr

src/gpu/gl/GrGLPathRendering.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 "gl/GrGLPathRendering.h"
 #include "gl/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
@@ skipping 45 matching lines @@
             return GR_GL_COUNT_UP;
         case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
 }
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu) {
     const GrGLInterface* glInterface = gpu->glInterface();
     fCaps.bindFragmentInputSupport =
-        NULL != glInterface->fFunctions.fBindFragmentInputLocation;
+        nullptr != glInterface->fFunctions.fBindFragmentInputLocation;
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
 }
 
 void GrGLPathRendering::abandonGpuResources() {
-    fPathNameAllocator.reset(NULL);
+    fPathNameAllocator.reset(nullptr);
 }
 
 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
     fHWPathStencilSettings.invalidate();
 }
 
@@ skipping 10 matching lines @@
     GrGLGpu* gpu = this->gpu();
     SkASSERT(gpu->caps()->shaderCaps()->pathRenderingSupport());
     gpu->flushColorWrite(false);
     gpu->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
 
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(args.fRenderTarget);
     SkISize size = SkISize::Make(rt->width(), rt->height());
     this->setProjectionMatrix(*args.fViewMatrix, size, rt->origin());
     gpu->flushScissor(*args.fScissor, rt->getViewport(), rt->origin());
     gpu->flushHWAAState(rt, args.fUseHWAA);
-    gpu->flushRenderTarget(rt, NULL);
+    gpu->flushRenderTarget(rt, nullptr);
 
     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
     this->flushPathStencilSettings(*args.fStencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
     GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
         fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
@@ skipping 114 matching lines @@
     GL_CALL(MatrixLoadf(GR_GL_PATH_PROJECTION, glMatrix));
 }
 
 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
     if (range > 1) {
         GrGLuint name;
         GL_CALL_RET(name, GenPaths(range));
         return name;
     }
 
-    if (NULL == fPathNameAllocator.get()) {
+    if (nullptr == fPathNameAllocator.get()) {
         static const int range = 65536;
         GrGLuint firstName;
         GL_CALL_RET(firstName, GenPaths(range));
         fPathNameAllocator.reset(new GrGLNameAllocator(firstName, firstName + range));
     }
 
     // When allocating names one at a time, pull from a client-side pool of
     // available names in order to save a round trip to the GL server.
     GrGLuint name = fPathNameAllocator->allocateName();
 
     if (0 == name) {
         // Our reserved path names are all in use. Fall back on GenPaths.
         GL_CALL_RET(name, GenPaths(1));
     }
 
     return name;
 }
 
 void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
     if (range > 1) {
         // It is not supported to delete names in ranges that were allocated
         // individually using GrGLPathNameAllocator.
-        SkASSERT(NULL == fPathNameAllocator.get() ||
+        SkASSERT(nullptr == fPathNameAllocator.get() ||
                  path + range <= fPathNameAllocator->firstName() ||
                  path >= fPathNameAllocator->endName());
         GL_CALL(DeletePaths(path, range));
         return;
     }
 
-    if (NULL == fPathNameAllocator.get() ||
+    if (nullptr == fPathNameAllocator.get() ||
         path < fPathNameAllocator->firstName() ||
         path >= fPathNameAllocator->endName()) {
         // If we aren't inside fPathNameAllocator's range then this name was
         // generated by the GenPaths fallback (or else was never allocated).
         GL_CALL(DeletePaths(path, 1));
         return;
     }
 
     // Make the path empty to save memory, but don't free the name in the driver.
-    GL_CALL(PathCommands(path, 0, NULL, 0, GR_GL_FLOAT, NULL));
+    GL_CALL(PathCommands(path, 0, nullptr, 0, GR_GL_FLOAT, nullptr));
     fPathNameAllocator->free(path);
 }
 
 void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
     if (fHWPathStencilSettings != stencilSettings) {
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
         GrGLenum func =
             GrToGLStencilFunc(stencilSettings.func(GrStencilSettings::kFront_Face));
         GL_CALL(PathStencilFunc(func, stencilSettings.funcRef(GrStencilSettings::kFront_Face),
                                 stencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }