Style Change: NULL->nullptr

src/core/SkPictureData.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 <new>
 #include "SkPictureData.h"
 #include "SkPictureRecord.h"
 #include "SkReadBuffer.h"
@@ skipping 62 matching lines @@
     fImageCount = imgs.count();
     if (fImageCount > 0) {
         fImageRefs = new const SkImage* [fImageCount];
         for (int i = 0; i < fImageCount; ++i) {
             fImageRefs[i] = SkRef(imgs[i]);
         }
     }
 }
 
 void SkPictureData::init() {
-    fPictureRefs = NULL;
+    fPictureRefs = nullptr;
     fPictureCount = 0;
-    fTextBlobRefs = NULL;
+    fTextBlobRefs = nullptr;
     fTextBlobCount = 0;
-    fImageRefs = NULL;
+    fImageRefs = nullptr;
     fImageCount = 0;
-    fOpData = NULL;
-    fFactoryPlayback = NULL;
+    fOpData = nullptr;
+    fFactoryPlayback = nullptr;
 }
 
 SkPictureData::~SkPictureData() {
     SkSafeUnref(fOpData);
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     delete[] fPictureRefs;
 
@@ skipping 25 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static size_t compute_chunk_size(SkFlattenable::Factory* array, int count) {
     size_t size = 4;  // for 'count'
 
     for (int i = 0; i < count; i++) {
         const char* name = SkFlattenable::FactoryToName(array[i]);
-        if (NULL == name || 0 == *name) {
+        if (nullptr == name || 0 == *name) {
             size += SkWStream::SizeOfPackedUInt(0);
         } else {
             size_t len = strlen(name);
             size += SkWStream::SizeOfPackedUInt(len);
             size += len;
         }
     }
 
     return size;
 }
@@ skipping 17 matching lines @@
 
     size_t size = compute_chunk_size(array, count);
 
     // TODO: write_tag_size should really take a size_t
     write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size);
     SkDEBUGCODE(size_t start = stream->bytesWritten());
     stream->write32(count);
 
     for (int i = 0; i < count; i++) {
         const char* name = SkFlattenable::FactoryToName(array[i]);
-        if (NULL == name || 0 == *name) {
+        if (nullptr == name || 0 == *name) {
             stream->writePackedUInt(0);
         } else {
             size_t len = strlen(name);
             stream->writePackedUInt(len);
             stream->write(name, len);
         }
     }
 
     SkASSERT(size == (stream->bytesWritten() - start));
 }
@@ skipping 163 matching lines @@
      *  but if they are present, they need to have been seen before the buffer.
      *
      *  We assert that if/when we see either of these, that we have not yet seen
      *  the buffer tag, because if we have, then its too-late to deal with the
      *  factories or typefaces.
      */
     SkDEBUGCODE(bool haveBuffer = false;)
 
     switch (tag) {
         case SK_PICT_READER_TAG:
-            SkASSERT(NULL == fOpData);
+            SkASSERT(nullptr == fOpData);
             fOpData = SkData::NewFromStream(stream, size);
             if (!fOpData) {
                 return false;
             }
             break;
         case SK_PICT_FACTORY_TAG: {
             SkASSERT(!haveBuffer);
             size = stream->readU32();
             fFactoryPlayback = new SkFactoryPlayback(size);
             for (size_t i = 0; i < size; i++) {
@@ skipping 67 matching lines @@
         } break;
     }
     return true;    // success
 }
 
 static const SkImage* create_image_from_buffer(SkReadBuffer& buffer) {
     int width = buffer.read32();
     int height = buffer.read32();
     if (width <= 0 || height <= 0) {    // SkImage never has a zero dimension
         buffer.validate(false);
-        return NULL;
+        return nullptr;
     }
 
     SkAutoTUnref<SkData> encoded(buffer.readByteArrayAsData());
     int originX = buffer.read32();
     int originY = buffer.read32();
     if (0 == encoded->size() || originX < 0 || originY < 0) {
         buffer.validate(false);
-        return NULL;
+        return nullptr;
     }
 
     const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height);
     return SkImage::NewFromEncoded(encoded, &subset);
 }
 
 // Need a shallow wrapper to return const SkPicture* to match the other factories,
 // as SkPicture::CreateFromBuffer() returns SkPicture*
 static const SkPicture* create_picture_from_buffer(SkReadBuffer& buffer) {
     return SkPicture::CreateFromBuffer(buffer);
 }
 
 template <typename T>
 bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount,
                            const T*** array, int* outCount, const T* (*factory)(SkReadBuffer&)) {
-    if (!buffer.validate((0 == *outCount) && (NULL == *array))) {
+    if (!buffer.validate((0 == *outCount) && (nullptr == *array))) {
         return false;
     }
     if (0 == inCount) {
         return true;
     }
     *outCount = inCount;
     *array = new const T* [*outCount];
     bool success = true;
     int i = 0;
     for (; i < *outCount; i++) {
         (*array)[i] = factory(buffer);
-        if (NULL == (*array)[i]) {
+        if (nullptr == (*array)[i]) {
             success = false;
             break;
         }
     }
     if (!success) {
         // Delete all of the blobs that were already created (up to but excluding i):
         for (int j = 0; j < i; j++) {
             (*array)[j]->unref();
         }
         // Delete the array
         delete[] * array;
-        *array = NULL;
+        *array = nullptr;
         *outCount = 0;
         return false;
     }
     return true;
 }
 
 bool SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t size) {
     switch (tag) {
         case SK_PICT_BITMAP_BUFFER_TAG: {
             const int count = SkToInt(size);
@@ skipping 30 matching lines @@
             break;
         case SK_PICT_IMAGE_BUFFER_TAG:
             if (!new_array_from_buffer(buffer, size, &fImageRefs, &fImageCount,
                                        create_image_from_buffer)) {
                 return false;
             }
             break;
         case SK_PICT_READER_TAG: {
             SkAutoDataUnref data(SkData::NewUninitialized(size));
             if (!buffer.readByteArray(data->writable_data(), size) ||
-                !buffer.validate(NULL == fOpData)) {
+                !buffer.validate(nullptr == fOpData)) {
                 return false;
             }
-            SkASSERT(NULL == fOpData);
+            SkASSERT(nullptr == fOpData);
             fOpData = data.detach();
         } break;
         case SK_PICT_PICTURE_TAG:
             if (!new_array_from_buffer(buffer, size, &fPictureRefs, &fPictureCount,
                                        create_picture_from_buffer)) {
                 return false;
             }
             break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
                                                const SkPictInfo& info,
                                                SkPicture::InstallPixelRefProc proc,
                                                SkTypefacePlayback* topLevelTFPlayback) {
     SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     if (!topLevelTFPlayback) {
         topLevelTFPlayback = &data->fTFPlayback;
     }
 
     if (!data->parseStream(stream, proc, topLevelTFPlayback)) {
-        return NULL;
+        return nullptr;
     }
     return data.detach();
 }
 
 SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
                                                const SkPictInfo& info) {
     SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     buffer.setVersion(info.fVersion);
 
     if (!data->parseBuffer(buffer)) {
-        return NULL;
+        return nullptr;
     }
     return data.detach();
 }
 
 bool SkPictureData::parseStream(SkStream* stream,
                                 SkPicture::InstallPixelRefProc proc,
                                 SkTypefacePlayback* topLevelTFPlayback) {
     for (;;) {
         uint32_t tag = stream->readU32();
         if (SK_PICT_EOF_TAG == tag) {
@@ skipping 28 matching lines @@
 
 #if SK_SUPPORT_GPU
 bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
                                                 int sampleCount) const {
     return fContentInfo.suitableForGpuRasterization(context, reason, sampleCount);
 }
 
 bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
                                                 GrPixelConfig config, SkScalar dpi) const {
 
-    if (context != NULL) {
+    if (context != nullptr) {
         return this->suitableForGpuRasterization(context, reason,
                                                  context->getRecommendedSampleCount(config, dpi));
     } else {
-        return this->suitableForGpuRasterization(NULL, reason);
+        return this->suitableForGpuRasterization(nullptr, reason);
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////