Style Change: NULL->nullptr

src/core/SkReadBuffer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkErrorInternals.h"
 #include "SkReadBuffer.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 
 static uint32_t default_flags() {
     uint32_t flags = 0;
     flags |= SkReadBuffer::kScalarIsFloat_Flag;
     if (8 == sizeof(void*)) {
         flags |= SkReadBuffer::kPtrIs64Bit_Flag;
     }
     return flags;
 }
 
 SkReadBuffer::SkReadBuffer() {
     fFlags = default_flags();
     fVersion = 0;
-    fMemoryPtr = NULL;
+    fMemoryPtr = nullptr;
 
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
+    fBitmapStorage = nullptr;
+    fTFArray = nullptr;
     fTFCount = 0;
 
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
+    fFactoryTDArray = nullptr;
+    fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = NULL;
+    fBitmapDecoder = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::SkReadBuffer(const void* data, size_t size) {
     fFlags = default_flags();
     fVersion = 0;
     fReader.setMemory(data, size);
-    fMemoryPtr = NULL;
+    fMemoryPtr = nullptr;
 
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
+    fBitmapStorage = nullptr;
+    fTFArray = nullptr;
     fTFCount = 0;
 
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
+    fFactoryTDArray = nullptr;
+    fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = NULL;
+    fBitmapDecoder = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::SkReadBuffer(SkStream* stream) {
     fFlags = default_flags();
     fVersion = 0;
     const size_t length = stream->getLength();
     fMemoryPtr = sk_malloc_throw(length);
     stream->read(fMemoryPtr, length);
     fReader.setMemory(fMemoryPtr, length);
 
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
+    fBitmapStorage = nullptr;
+    fTFArray = nullptr;
     fTFCount = 0;
 
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
+    fFactoryTDArray = nullptr;
+    fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = NULL;
+    fBitmapDecoder = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::~SkReadBuffer() {
     sk_free(fMemoryPtr);
     SkSafeUnref(fBitmapStorage);
 }
 
@@ skipping 129 matching lines @@
         const size_t length = this->readUInt();
         if (length > 0) {
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
             fDecodedBitmapIndex++;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
             // A non-zero size means the SkBitmap was encoded. Read the data and pixel
             // offset.
             const void* data = this->skip(length);
             const int32_t xOffset = this->readInt();
             const int32_t yOffset = this->readInt();
-            if (fBitmapDecoder != NULL && fBitmapDecoder(data, length, bitmap)) {
+            if (fBitmapDecoder != nullptr && fBitmapDecoder(data, length, bitmap)) {
                 if (bitmap->width() == width && bitmap->height() == height) {
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
                     if (0 != xOffset || 0 != yOffset) {
                         SkDebugf("SkReadBuffer::readBitmap: heights match,"
                                  " but offset is not zero. \nInfo about the bitmap:"
                                  "\n\tIndex: %d\n\tDimensions: [%d %d]\n\tEncoded"
                                  " data size: %d\n\tOffset: (%d, %d)\n",
                                  fDecodedBitmapIndex, width, height, length, xOffset,
                                  yOffset);
                     }
@@ skipping 37 matching lines @@
     return false;
 }
 
 SkTypeface* SkReadBuffer::readTypeface() {
 
     uint32_t index = fReader.readU32();
     if (0 == index || index > (unsigned)fTFCount) {
         if (index) {
             SkDebugf("====== typeface index %d\n", index);
         }
-        return NULL;
+        return nullptr;
     } else {
         SkASSERT(fTFArray);
         return fTFArray[index - 1];
     }
 }
 
 SkFlattenable* SkReadBuffer::readFlattenable(SkFlattenable::Type ft) {
     //
     // TODO: confirm that ft matches the factory we decide to use
     //
 
-    SkFlattenable::Factory factory = NULL;
+    SkFlattenable::Factory factory = nullptr;
 
     if (fFactoryCount > 0) {
         int32_t index = fReader.readU32();
         if (0 == index) {
-            return NULL; // writer failed to give us the flattenable
+            return nullptr; // writer failed to give us the flattenable
         }
         index -= 1;     // we stored the index-base-1
         SkASSERT(index < fFactoryCount);
         factory = fFactoryArray[index];
     } else if (fFactoryTDArray) {
         int32_t index = fReader.readU32();
         if (0 == index) {
-            return NULL; // writer failed to give us the flattenable
+            return nullptr; // writer failed to give us the flattenable
         }
         index -= 1;     // we stored the index-base-1
         factory = (*fFactoryTDArray)[index];
     } else {
         factory = (SkFlattenable::Factory)readFunctionPtr();
-        if (NULL == factory) {
-            return NULL; // writer failed to give us the flattenable
+        if (nullptr == factory) {
+            return nullptr; // writer failed to give us the flattenable
         }
     }
 
     // if we get here, factory may still be null, but if that is the case, the
     // failure was ours, not the writer.
-    SkFlattenable* obj = NULL;
+    SkFlattenable* obj = nullptr;
     uint32_t sizeRecorded = fReader.readU32();
     if (factory) {
         size_t offset = fReader.offset();
         obj = (*factory)(*this);
         // check that we read the amount we expected
         size_t sizeRead = fReader.offset() - offset;
         if (sizeRecorded != sizeRead) {
             // we could try to fix up the offset...
             sk_throw();
         }
@@ skipping 11 matching lines @@
 void SkReadBuffer::skipFlattenable() {
     if (fFactoryCount > 0) {
         if (0 == fReader.readU32()) {
             return;
         }
     } else if (fFactoryTDArray) {
         if (0 == fReader.readU32()) {
             return;
         }
     } else {
-        if (NULL == this->readFunctionPtr()) {
+        if (nullptr == this->readFunctionPtr()) {
             return;
         }
     }
     uint32_t sizeRecorded = fReader.readU32();
     fReader.skip(sizeRecorded);
 }