Style Change: NULL->nullptr

src/core/SkValidatingReadBuffer.cpp

 /*
  * Copyright 2013 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 "SkValidatingReadBuffer.h"
@@ skipping 93 matching lines @@
     if (!fError) {
         string->set(cptr, len);
     }
 }
 
 void* SkValidatingReadBuffer::readEncodedString(size_t* length, SkPaint::TextEncoding encoding) {
     const int32_t encodingType = this->readInt();
     this->validate(encodingType == encoding);
     *length = this->readInt();
     const void* ptr = this->skip(SkAlign4(*length));
-    void* data = NULL;
+    void* data = nullptr;
     if (!fError) {
         data = sk_malloc_throw(*length);
         memcpy(data, ptr, *length);
     }
     return data;
 }
 
 void SkValidatingReadBuffer::readPoint(SkPoint* point) {
     point->fX = this->readScalar();
     point->fY = this->readScalar();
@@ skipping 82 matching lines @@
 }
 
 uint32_t SkValidatingReadBuffer::getArrayCount() {
     const size_t inc = sizeof(uint32_t);
     fError = fError || !IsPtrAlign4(fReader.peek()) || !fReader.isAvailable(inc);
     return fError ? 0 : *(uint32_t*)fReader.peek();
 }
 
 SkTypeface* SkValidatingReadBuffer::readTypeface() {
     // TODO: Implement this (securely) when needed
-    return NULL;
+    return nullptr;
 }
 
 bool SkValidatingReadBuffer::validateAvailable(size_t size) {
     return this->validate((size <= SK_MaxU32) && fReader.isAvailable(static_cast<uint32_t>(size)));
 }
 
 SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type) {
     SkString name;
     this->readString(&name);
     if (fError) {
-        return NULL;
+        return nullptr;
     }
 
     // Is this the type we wanted ?
     const char* cname = name.c_str();
     SkFlattenable::Type baseType;
     if (!SkFlattenable::NameToType(cname, &baseType) || (baseType != type)) {
-        return NULL;
+        return nullptr;
     }
 
     SkFlattenable::Factory factory = SkFlattenable::NameToFactory(cname);
-    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 = this->readUInt();
     if (factory) {
         size_t offset = fReader.offset();
         obj = (*factory)(*this);
         // check that we read the amount we expected
         size_t sizeRead = fReader.offset() - offset;
         this->validate(sizeRecorded == sizeRead);
         if (fError) {
             // we could try to fix up the offset...
             SkSafeUnref(obj);
-            obj = NULL;
+            obj = nullptr;
         }
     } else {
         // we must skip the remaining data
         this->skip(sizeRecorded);
         SkASSERT(false);
     }
     return obj;
 }
 
 void SkValidatingReadBuffer::skipFlattenable() {
     SkString name;
     this->readString(&name);
     if (fError) {
         return;
     }
     uint32_t sizeRecorded = this->readUInt();
     this->skip(sizeRecorded);
 }