Style Change: NULL->nullptr

src/gpu/GrStencilAndCoverTextContext.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 "GrStencilAndCoverTextContext.h"
 #include "GrAtlasTextContext.h"
 #include "GrDrawContext.h"
@@ skipping 37 matching lines @@
                                            const GrPaint& paint,
                                            const SkPaint& skPaint,
                                            const SkMatrix& viewMatrix) {
     if (skPaint.getRasterizer()) {
         return false;
     }
     if (skPaint.getMaskFilter()) {
         return false;
     }
     if (SkPathEffect* pe = skPaint.getPathEffect()) {
-        if (pe->asADash(NULL) != SkPathEffect::kDash_DashType) {
+        if (pe->asADash(nullptr) != SkPathEffect::kDash_DashType) {
             return false;
         }
     }
 
     // No hairlines unless we can map the 1 px width to the object space.
     if (skPaint.getStyle() == SkPaint::kStroke_Style
         && skPaint.getStrokeWidth() == 0
         && viewMatrix.hasPerspective()) {
         return false;
     }
 
     // No color bitmap fonts.
     SkScalerContext::Rec    rec;
-    SkScalerContext::MakeRec(skPaint, &fSurfaceProps, NULL, &rec);
+    SkScalerContext::MakeRec(skPaint, &fSurfaceProps, nullptr, &rec);
     return rec.getFormat() != SkMask::kARGB32_Format;
 }
 
 void GrStencilAndCoverTextContext::onDrawText(GrRenderTarget* rt,
                                               const GrClip& clip,
                                               const GrPaint& paint,
                                               const SkPaint& skPaint,
                                               const SkMatrix& viewMatrix,
                                               const char text[],
                                               size_t byteLength,
                                               SkScalar x, SkScalar y,
                                               const SkIRect& regionClipBounds) {
-    SkASSERT(byteLength == 0 || text != NULL);
+    SkASSERT(byteLength == 0 || text != nullptr);
 
-    if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
+    if (text == nullptr || byteLength == 0 /*|| fRC->isEmpty()*/) {
         return;
     }
 
     // This is the slow path, mainly used by Skia unit tests.  The other
     // backends (8888, gpu, ...) use device-space dependent glyph caches. In
     // order to match the glyph positions that the other code paths produce, we
     // must also use device-space dependent glyph cache. This has the
     // side-effect that the glyph shape outline will be in device-space,
     // too. This in turn has the side-effect that NVPR can not stroke the paths,
     // as the stroke in NVPR is defined in object-space.
@@ skipping 72 matching lines @@
                                                  const GrClip& clip,
                                                  const GrPaint& paint,
                                                  const SkPaint& skPaint,
                                                  const SkMatrix& viewMatrix,
                                                  const char text[],
                                                  size_t byteLength,
                                                  const SkScalar pos[],
                                                  int scalarsPerPosition,
                                                  const SkPoint& offset,
                                                  const SkIRect& regionClipBounds) {
-    SkASSERT(byteLength == 0 || text != NULL);
+    SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
-    if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
+    if (text == nullptr || byteLength == 0/* || fRC->isEmpty()*/) {
         return;
     }
 
     // This is the fast path.  Here we do not bake in the device-transform to
     // the glyph outline or the advances. This is because we do not need to
     // position the glyphs at all, since the caller has done the positioning.
     // The positioning is based on SkPaint::measureText of individual
     // glyphs. That already uses glyph cache without device transforms. Device
     // transform is not part of SkPaint::measureText API, and thus we use the
     // same glyphs as what were measured.
@@ skipping 35 matching lines @@
     reinterpret_cast<uint32_t&>(builder[0]) = desc ? desc->getChecksum() : 0;
     reinterpret_cast<uint32_t&>(builder[1]) = typeface ? typeface->uniqueID() : 0;
     if (strokeDataCount > 0) {
         stroke.asUniqueKeyFragment(&builder[2]);
     }
     builder.finish();
 
     SkAutoTUnref<GrPathRange> glyphs(
         static_cast<GrPathRange*>(
             ctx->resourceProvider()->findAndRefResourceByUniqueKey(glyphKey)));
-    if (NULL == glyphs) {
+    if (nullptr == glyphs) {
         glyphs.reset(ctx->resourceProvider()->createGlyphs(typeface, desc, stroke));
         ctx->resourceProvider()->assignUniqueKeyToResource(glyphKey, glyphs);
     } else {
-        SkASSERT(NULL == desc || glyphs->isEqualTo(*desc));
+        SkASSERT(nullptr == desc || glyphs->isEqualTo(*desc));
     }
 
     return glyphs.detach();
 }
 
 void GrStencilAndCoverTextContext::init(GrRenderTarget* rt,
                                         const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkPaint& skPaint,
                                         size_t textByteLength,
@@ skipping 109 matching lines @@
             fTextRatio = fTextInverseRatio = 1.0f;
             canUseRawPaths = false;
         }
 
         SkMatrix textMatrix;
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         textMatrix.setScale(fTextRatio, -fTextRatio);
         fViewMatrix.preConcat(textMatrix);
         fLocalMatrix = textMatrix;
 
-        fGlyphCache = fSkPaint.detachCache(&fSurfaceProps, NULL, true /*ignoreGamma*/);
+        fGlyphCache = fSkPaint.detachCache(&fSurfaceProps, nullptr, true /*ignoreGamma*/);
         fGlyphs = canUseRawPaths ?
-                      get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, fStroke) :
+                      get_gr_glyphs(fContext, fSkPaint.getTypeface(), nullptr, fStroke) :
                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                     &fGlyphCache->getDescriptor(), fStroke);
     }
 
 }
 
 bool GrStencilAndCoverTextContext::mapToFallbackContext(SkMatrix* inverse) {
     // The current view matrix is flipped because GPU path rendering glyphs have an
     // inverted y-direction. Unflip the view matrix for the fallback context. If using
     // device-space glyphs, we'll also need to restore the original view matrix since
@@ skipping 92 matching lines @@
                                           2, SkPoint::Make(0, 0), fRegionClipBounds);
 
         fFallbackGlyphsIdx = kGlyphBufferSize;
     }
 }
 
 void GrStencilAndCoverTextContext::finish() {
     this->flush();
 
     fGlyphs->unref();
-    fGlyphs = NULL;
+    fGlyphs = nullptr;
 
     SkGlyphCache::AttachCache(fGlyphCache);
-    fGlyphCache = NULL;
+    fGlyphCache = nullptr;
 
     fViewMatrix = fContextInitialMatrix;
 }