Style Change: NULL->nullptr

src/core/SkTextBlob.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 "SkTextBlob.h"
 
 #include "SkReadBuffer.h"
@@ skipping 226 matching lines @@
 
         it.next();
         SkDEBUGCODE(runCount--);
     }
     SkASSERT(0 == runCount);
 }
 
 const SkTextBlob* SkTextBlob::CreateFromBuffer(SkReadBuffer& reader) {
     int runCount = reader.read32();
     if (runCount < 0) {
-        return NULL;
+        return nullptr;
     }
 
     SkRect bounds;
     reader.readRect(&bounds);
 
     SkTextBlobBuilder blobBuilder;
     for (int i = 0; i < runCount; ++i) {
         int glyphCount = reader.read32();
         GlyphPositioning pos = static_cast<GlyphPositioning>(reader.read32());
         if (glyphCount <= 0 || pos > kFull_Positioning) {
-            return NULL;
+            return nullptr;
         }
 
         SkPoint offset;
         reader.readPoint(&offset);
         SkPaint font;
         reader.readPaint(&font);
 
-        const SkTextBlobBuilder::RunBuffer* buf = NULL;
+        const SkTextBlobBuilder::RunBuffer* buf = nullptr;
         switch (pos) {
         case kDefault_Positioning:
             buf = &blobBuilder.allocRun(font, glyphCount, offset.x(), offset.y(), &bounds);
             break;
         case kHorizontal_Positioning:
             buf = &blobBuilder.allocRunPosH(font, glyphCount, offset.y(), &bounds);
             break;
         case kFull_Positioning:
             buf = &blobBuilder.allocRunPos(font, glyphCount, &bounds);
             break;
         default:
-            return NULL;
+            return nullptr;
         }
 
         if (!reader.readByteArray(buf->glyphs, glyphCount * sizeof(uint16_t)) ||
             !reader.readByteArray(buf->pos,
                                   glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(pos))) {
-            return NULL;
+            return nullptr;
         }
     }
 
     return blobBuilder.build();
 }
 
 unsigned SkTextBlob::ScalarsPerGlyph(GlyphPositioning pos) {
     // GlyphPositioning values are directly mapped to scalars-per-glyph.
     SkASSERT(pos <= 2);
     return pos;
@@ skipping 57 matching lines @@
 SkTextBlobBuilder::SkTextBlobBuilder()
     : fStorageSize(0)
     , fStorageUsed(0)
     , fRunCount(0)
     , fDeferredBounds(false)
     , fLastRun(0) {
     fBounds.setEmpty();
 }
 
 SkTextBlobBuilder::~SkTextBlobBuilder() {
-    if (NULL != fStorage.get()) {
+    if (nullptr != fStorage.get()) {
         // We are abandoning runs and must destruct the associated font data.
         // The easiest way to accomplish that is to use the blob destructor.
         build()->unref();
     }
 }
 
 SkRect SkTextBlobBuilder::TightRunBounds(const SkTextBlob::RunRecord& run) {
     SkASSERT(SkTextBlob::kDefault_Positioning == run.positioning());
 
     SkRect bounds;
@@ skipping 67 matching lines @@
     fDeferredBounds = false;
 }
 
 void SkTextBlobBuilder::reserve(size_t size) {
     // We don't currently pre-allocate, but maybe someday...
     if (fStorageUsed + size <= fStorageSize) {
         return;
     }
 
     if (0 == fRunCount) {
-        SkASSERT(NULL == fStorage.get());
+        SkASSERT(nullptr == fStorage.get());
         SkASSERT(0 == fStorageSize);
         SkASSERT(0 == fStorageUsed);
 
         // the first allocation also includes blob storage
         fStorageUsed += sizeof(SkTextBlob);
     }
 
     fStorageSize = fStorageUsed + size;
     // FYI: This relies on everything we store being relocatable, particularly SkPaint.
     fStorage.realloc(fStorageSize);
@@ skipping 105 matching lines @@
 }
 
 const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunPos(const SkPaint& font, int count,
                                                                    const SkRect *bounds) {
     this->allocInternal(font, SkTextBlob::kFull_Positioning, count, SkPoint::Make(0, 0), bounds);
 
     return fCurrentRunBuffer;
 }
 
 const SkTextBlob* SkTextBlobBuilder::build() {
-    SkASSERT((fRunCount > 0) == (NULL != fStorage.get()));
+    SkASSERT((fRunCount > 0) == (nullptr != fStorage.get()));
 
     this->updateDeferredBounds();
 
     if (0 == fRunCount) {
-        SkASSERT(NULL == fStorage.get());
+        SkASSERT(nullptr == fStorage.get());
         fStorageUsed = sizeof(SkTextBlob);
         fStorage.realloc(fStorageUsed);
     }
 
     SkDEBUGCODE(
         size_t validateSize = sizeof(SkTextBlob);
         const SkTextBlob::RunRecord* run =
             SkTextBlob::RunRecord::First(reinterpret_cast<const SkTextBlob*>(fStorage.get()));
         for (int i = 0; i < fRunCount; ++i) {
             validateSize += SkTextBlob::RunRecord::StorageSize(run->fCount, run->fPositioning);
             run->validate(fStorage.get() + fStorageUsed);
             run = SkTextBlob::RunRecord::Next(run);
         }
         SkASSERT(validateSize == fStorageUsed);
     )
 
     const SkTextBlob* blob = new (fStorage.detach()) SkTextBlob(fRunCount, fBounds);
     SkDEBUGCODE(const_cast<SkTextBlob*>(blob)->fStorageSize = fStorageSize;)
 
     fStorageUsed = 0;
     fStorageSize = 0;
     fRunCount = 0;
     fLastRun = 0;
     fBounds.setEmpty();
 
     return blob;
 }