Style Change: NULL->nullptr

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 303 matching lines @@
         int firstVertex;
 
         void* verts = target->makeVertexSpace(vertexStride, maxVertices,
                                               &vertexBuffer, &firstVertex);
 
         if (!verts) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
-        const GrIndexBuffer* indexBuffer = NULL;
+        const GrIndexBuffer* indexBuffer = nullptr;
         int firstIndex = 0;
 
-        void* indices = NULL;
+        void* indices = nullptr;
         if (isIndexed) {
             indices = target->makeIndexSpace(maxIndices, &indexBuffer, &firstIndex);
 
             if (!indices) {
                 SkDebugf("Could not allocate indices\n");
                 return;
             }
         }
 
         // fill buffers
@@ skipping 224 matching lines @@
     const GrStencilSettings*    passes[3];
     GrPipelineBuilder::DrawFace drawFace[3];
     bool                        reverse = false;
     bool                        lastPassIsBounds;
 
     if (isHairline) {
         passCount = 1;
         if (stencilOnly) {
             passes[0] = &gDirectToStencil;
         } else {
-            passes[0] = NULL;
+            passes[0] = nullptr;
         }
         lastPassIsBounds = false;
         drawFace[0] = GrPipelineBuilder::kBoth_DrawFace;
     } else {
         if (single_pass_path(path, *stroke)) {
             passCount = 1;
             if (stencilOnly) {
                 passes[0] = &gDirectToStencil;
             } else {
-                passes[0] = NULL;
+                passes[0] = nullptr;
             }
             drawFace[0] = GrPipelineBuilder::kBoth_DrawFace;
             lastPassIsBounds = false;
         } else {
             switch (path.getFillType()) {
                 case SkPath::kInverseEvenOdd_FillType:
                     reverse = true;
                     // fallthrough
                 case SkPath::kEvenOdd_FillType:
                     passes[0] = &gEOStencilPass;
@@ skipping 110 matching lines @@
             target->drawBatch(*pipelineBuilder, batch);
         }
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
     return !args.fAntiAlias && (args.fStroke->isFillStyle() ||
                                 IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix,
-                                                             NULL));
+                                                             nullptr));
 }
 
 bool GrDefaultPathRenderer::onDrawPath(const DrawPathArgs& args) {
     return this->internalDrawPath(args.fTarget,
                                   args.fPipelineBuilder,
                                   args.fColor,
                                   *args.fViewMatrix,
                                   *args.fPath,
                                   *args.fStroke,
                                   false);
@@ skipping 28 matching lines @@
     geometry.fColor = color;
     geometry.fPath = path;
     geometry.fTolerance = srcSpaceTol;
 
     viewMatrix.mapRect(&bounds);
     uint8_t coverage = GrRandomCoverage(random);
     return DefaultPathBatch::Create(geometry, coverage, viewMatrix, true, bounds);
 }
 
 #endif