Style Change: NULL->nullptr

src/core/SkStream.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkStream.h"
@@ skipping 163 matching lines @@
             return false;
         }
         length -= n;
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFILEStream::SkFILEStream(const char file[]) : fName(file), fOwnership(kCallerPasses_Ownership) {
-    fFILE = file ? sk_fopen(fName.c_str(), kRead_SkFILE_Flag) : NULL;
+    fFILE = file ? sk_fopen(fName.c_str(), kRead_SkFILE_Flag) : nullptr;
 }
 
 SkFILEStream::SkFILEStream(FILE* file, Ownership ownership)
     : fFILE((SkFILE*)file)
     , fOwnership(ownership) {
 }
 
 SkFILEStream::~SkFILEStream() {
     if (fFILE && fOwnership != kCallerRetains_Ownership) {
         sk_fclose(fFILE);
     }
 }
 
 void SkFILEStream::setPath(const char path[]) {
     fName.set(path);
     if (fFILE) {
         sk_fclose(fFILE);
-        fFILE = NULL;
+        fFILE = nullptr;
     }
     if (path) {
         fFILE = sk_fopen(fName.c_str(), kRead_SkFILE_Flag);
     }
 }
 
 size_t SkFILEStream::read(void* buffer, size_t size) {
     if (fFILE) {
         return sk_fread(buffer, size, fFILE);
     }
     return 0;
 }
 
 bool SkFILEStream::isAtEnd() const {
     return sk_feof(fFILE);
 }
 
 bool SkFILEStream::rewind() {
     if (fFILE) {
         if (sk_frewind(fFILE)) {
             return true;
         }
         // we hit an error
         sk_fclose(fFILE);
-        fFILE = NULL;
+        fFILE = nullptr;
     }
     return false;
 }
 
 SkStreamAsset* SkFILEStream::duplicate() const {
-    if (NULL == fFILE) {
+    if (nullptr == fFILE) {
         return new SkMemoryStream();
     }
 
     if (fData.get()) {
         return new SkMemoryStream(fData);
     }
 
     if (!fName.isEmpty()) {
         SkAutoTDelete<SkFILEStream> that(new SkFILEStream(fName.c_str()));
         if (sk_fidentical(that->fFILE, this->fFILE)) {
             return that.detach();
         }
     }
 
     fData.reset(SkData::NewFromFILE(fFILE));
-    if (NULL == fData.get()) {
-        return NULL;
+    if (nullptr == fData.get()) {
+        return nullptr;
     }
     return new SkMemoryStream(fData);
 }
 
 size_t SkFILEStream::getPosition() const {
     return sk_ftell(fFILE);
 }
 
 bool SkFILEStream::seek(size_t position) {
     return sk_fseek(fFILE, position);
 }
 
 bool SkFILEStream::move(long offset) {
     return sk_fmove(fFILE, offset);
 }
 
 SkStreamAsset* SkFILEStream::fork() const {
     SkAutoTDelete<SkStreamAsset> that(this->duplicate());
     that->seek(this->getPosition());
     return that.detach();
 }
 
 size_t SkFILEStream::getLength() const {
     return sk_fgetsize(fFILE);
 }
 
 const void* SkFILEStream::getMemoryBase() {
-    if (NULL == fData.get()) {
-        return NULL;
+    if (nullptr == fData.get()) {
+        return nullptr;
     }
     return fData->data();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkData* newFromParams(const void* src, size_t size, bool copyData) {
     if (copyData) {
         return SkData::NewWithCopy(src, size);
     } else {
@@ skipping 10 matching lines @@
     fData = SkData::NewUninitialized(size);
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(const void* src, size_t size, bool copyData) {
     fData = newFromParams(src, size, copyData);
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(SkData* data) {
-    if (NULL == data) {
+    if (nullptr == data) {
         fData = SkData::NewEmpty();
     } else {
         fData = data;
         fData->ref();
     }
     fOffset = 0;
 }
 
 SkMemoryStream::~SkMemoryStream() {
     fData->unref();
@@ skipping 11 matching lines @@
     fOffset = 0;
 }
 
 SkData* SkMemoryStream::copyToData() const {
     fData->ref();
     return fData;
 }
 
 SkData* SkMemoryStream::setData(SkData* data) {
     fData->unref();
-    if (NULL == data) {
+    if (nullptr == data) {
         fData = SkData::NewEmpty();
     } else {
         fData = data;
         fData->ref();
     }
     fOffset = 0;
     return data;
 }
 
 void SkMemoryStream::skipToAlign4() {
     // cast to remove unary-minus warning
     fOffset += -(int)fOffset & 0x03;
 }
 
 size_t SkMemoryStream::read(void* buffer, size_t size) {
     size_t dataSize = fData->size();
 
     if (size > dataSize - fOffset) {
         size = dataSize - fOffset;
     }
     if (buffer) {
         memcpy(buffer, fData->bytes() + fOffset, size);
     }
     fOffset += size;
     return size;
 }
 
 bool SkMemoryStream::peek(void* buffer, size_t size) const {
-    SkASSERT(buffer != NULL);
+    SkASSERT(buffer != nullptr);
     const size_t position = fOffset;
     if (size > fData->size() - position) {
         // The stream is not large enough to satisfy this request.
         return false;
     }
     SkMemoryStream* nonConstThis = const_cast<SkMemoryStream*>(this);
     SkDEBUGCODE(const size_t bytesRead =) nonConstThis->read(buffer, size);
     SkASSERT(bytesRead == size);
     nonConstThis->fOffset = position;
     return true;
@@ skipping 57 matching lines @@
         sk_fclose(fFILE);
     }
 }
 
 size_t SkFILEWStream::bytesWritten() const {
     return sk_ftell(fFILE);
 }
 
 bool SkFILEWStream::write(const void* buffer, size_t size)
 {
-    if (fFILE == NULL) {
+    if (fFILE == nullptr) {
         return false;
     }
 
     if (sk_fwrite(buffer, size, fFILE) != size)
     {
         SkDEBUGCODE(SkDebugf("SkFILEWStream failed writing %d bytes\n", size);)
         sk_fclose(fFILE);
-        fFILE = NULL;
+        fFILE = nullptr;
         return false;
     }
     return true;
 }
 
 void SkFILEWStream::flush()
 {
     if (fFILE) {
         sk_fflush(fFILE);
     }
@@ skipping 25 matching lines @@
     char*   fCurr;
     char*   fStop;
 
     const char* start() const { return (const char*)(this + 1); }
     char*   start() { return (char*)(this + 1); }
     size_t  avail() const { return fStop - fCurr; }
     size_t  written() const { return fCurr - this->start(); }
 
     void init(size_t size)
     {
-        fNext = NULL;
+        fNext = nullptr;
         fCurr = this->start();
         fStop = this->start() + size;
     }
 
     const void* append(const void* data, size_t size)
     {
         SkASSERT((size_t)(fStop - fCurr) >= size);
         memcpy(fCurr, data, size);
         fCurr += size;
         return (const void*)((const char*)data + size);
     }
 };
 
 SkDynamicMemoryWStream::SkDynamicMemoryWStream()
-    : fHead(NULL), fTail(NULL), fBytesWritten(0), fCopy(NULL)
+    : fHead(nullptr), fTail(nullptr), fBytesWritten(0), fCopy(nullptr)
 {
 }
 
 SkDynamicMemoryWStream::~SkDynamicMemoryWStream()
 {
     reset();
 }
 
 void SkDynamicMemoryWStream::reset()
 {
     this->invalidateCopy();
 
     Block*  block = fHead;
 
-    while (block != NULL) {
+    while (block != nullptr) {
         Block*  next = block->fNext;
         sk_free(block);
         block = next;
     }
-    fHead = fTail = NULL;
+    fHead = fTail = nullptr;
     fBytesWritten = 0;
 }
 
 bool SkDynamicMemoryWStream::write(const void* buffer, size_t count)
 {
     if (count > 0) {
         this->invalidateCopy();
 
         fBytesWritten += count;
 
         size_t  size;
 
-        if (fTail != NULL && fTail->avail() > 0) {
+        if (fTail != nullptr && fTail->avail() > 0) {
             size = SkTMin(fTail->avail(), count);
             buffer = fTail->append(buffer, size);
             SkASSERT(count >= size);
             count -= size;
             if (count == 0)
                 return true;
         }
 
         size = SkTMax<size_t>(count, SkDynamicMemoryWStream_MinBlockSize);
         Block* block = (Block*)sk_malloc_throw(sizeof(Block) + size);
         block->init(size);
         block->append(buffer, count);
 
-        if (fTail != NULL)
+        if (fTail != nullptr)
             fTail->fNext = block;
         else
             fHead = fTail = block;
         fTail = block;
     }
     return true;
 }
 
 bool SkDynamicMemoryWStream::write(const void* buffer, size_t offset, size_t count)
 {
     if (offset + count > fBytesWritten) {
         return false; // test does not partially modify
     }
 
     this->invalidateCopy();
 
     Block* block = fHead;
-    while (block != NULL) {
+    while (block != nullptr) {
         size_t size = block->written();
         if (offset < size) {
             size_t part = offset + count > size ? size - offset : count;
             memcpy(block->start() + offset, buffer, part);
             if (count <= part)
                 return true;
             count -= part;
             buffer = (const void*) ((char* ) buffer + part);
         }
         offset = offset > size ? offset - size : 0;
         block = block->fNext;
     }
     return false;
 }
 
 bool SkDynamicMemoryWStream::read(void* buffer, size_t offset, size_t count)
 {
     if (offset + count > fBytesWritten)
         return false; // test does not partially modify
     Block* block = fHead;
-    while (block != NULL) {
+    while (block != nullptr) {
         size_t size = block->written();
         if (offset < size) {
             size_t part = offset + count > size ? size - offset : count;
             memcpy(buffer, block->start() + offset, part);
             if (count <= part)
                 return true;
             count -= part;
             buffer = (void*) ((char* ) buffer + part);
         }
         offset = offset > size ? offset - size : 0;
         block = block->fNext;
     }
     return false;
 }
 
 void SkDynamicMemoryWStream::copyTo(void* dst) const
 {
     if (fCopy) {
         memcpy(dst, fCopy->data(), fBytesWritten);
     } else {
         Block* block = fHead;
 
-        while (block != NULL) {
+        while (block != nullptr) {
             size_t size = block->written();
             memcpy(dst, block->start(), size);
             dst = (void*)((char*)dst + size);
             block = block->fNext;
         }
     }
 }
 
 void SkDynamicMemoryWStream::writeToStream(SkWStream* dst) const {
-    for (Block* block = fHead; block != NULL; block = block->fNext) {
+    for (Block* block = fHead; block != nullptr; block = block->fNext) {
         dst->write(block->start(), block->written());
     }
 }
 
 void SkDynamicMemoryWStream::padToAlign4()
 {
     // cast to remove unary-minus warning
     int padBytes = -(int)fBytesWritten & 0x03;
     if (padBytes == 0)
         return;
     int zero = 0;
     write(&zero, padBytes);
 }
 
 SkData* SkDynamicMemoryWStream::copyToData() const {
-    if (NULL == fCopy) {
+    if (nullptr == fCopy) {
         SkData* data = SkData::NewUninitialized(fBytesWritten);
         // be sure to call copyTo() before we assign to fCopy
         this->copyTo(data->writable_data());
         fCopy = data;
     }
     return SkRef(fCopy);
 }
 
 void SkDynamicMemoryWStream::invalidateCopy() {
     if (fCopy) {
         fCopy->unref();
-        fCopy = NULL;
+        fCopy = nullptr;
     }
 }
 
 class SkBlockMemoryRefCnt : public SkRefCnt {
 public:
     explicit SkBlockMemoryRefCnt(SkDynamicMemoryWStream::Block* head) : fHead(head) { }
 
     virtual ~SkBlockMemoryRefCnt() {
         SkDynamicMemoryWStream::Block* block = fHead;
-        while (block != NULL) {
+        while (block != nullptr) {
             SkDynamicMemoryWStream::Block* next = block->fNext;
             sk_free(block);
             block = next;
         }
     }
 
     SkDynamicMemoryWStream::Block* const fHead;
 };
 
 class SkBlockMemoryStream : public SkStreamAsset {
 public:
     SkBlockMemoryStream(SkDynamicMemoryWStream::Block* head, size_t size)
         : fBlockMemory(new SkBlockMemoryRefCnt(head))
         , fCurrent(head)
         , fSize(size)
         , fOffset(0)
         , fCurrentOffset(0) {}
 
     SkBlockMemoryStream(SkBlockMemoryRefCnt* headRef, size_t size)
         : fBlockMemory(SkRef(headRef)), fCurrent(fBlockMemory->fHead)
         , fSize(size) , fOffset(0), fCurrentOffset(0) { }
 
     size_t read(void* buffer, size_t rawCount) override {
         size_t count = rawCount;
         if (fOffset + count > fSize) {
             count = fSize - fOffset;
         }
         size_t bytesLeftToRead = count;
-        while (fCurrent != NULL) {
+        while (fCurrent != nullptr) {
             size_t bytesLeftInCurrent = fCurrent->written() - fCurrentOffset;
             size_t bytesFromCurrent = SkTMin(bytesLeftToRead, bytesLeftInCurrent);
             if (buffer) {
                 memcpy(buffer, fCurrent->start() + fCurrentOffset, bytesFromCurrent);
                 buffer = SkTAddOffset<void>(buffer, bytesFromCurrent);
             }
             if (bytesLeftToRead <= bytesFromCurrent) {
                 fCurrentOffset += bytesFromCurrent;
                 fOffset += count;
                 return count;
             }
             bytesLeftToRead -= bytesFromCurrent;
             fCurrent = fCurrent->fNext;
             fCurrentOffset = 0;
         }
         SkASSERT(false);
         return 0;
     }
 
     bool isAtEnd() const override {
         return fOffset == fSize;
     }
 
     bool peek(void* buff, size_t size) const override {
-        SkASSERT(buff != NULL);
+        SkASSERT(buff != nullptr);
         if (fOffset + size > fSize) {
             return false;
         }
         char* buffer = static_cast<char*>(buff);
         const SkDynamicMemoryWStream::Block* current = fCurrent;
         size_t currentOffset = fCurrentOffset;
         while (size) {
             SkASSERT(current);
             size_t bytesFromCurrent =
                     SkTMin(current->written() - currentOffset, size);
@@ skipping 48 matching lines @@
         that->fOffset = this->fOffset;
         that->fCurrentOffset = this->fCurrentOffset;
         return that.detach();
     }
 
     size_t getLength() const override {
         return fSize;
     }
 
     const void* getMemoryBase() override {
-        if (NULL == fBlockMemory->fHead->fNext) {
+        if (nullptr == fBlockMemory->fHead->fNext) {
             return fBlockMemory->fHead->start();
         }
-        return NULL;
+        return nullptr;
     }
 
 private:
     SkAutoTUnref<SkBlockMemoryRefCnt> const fBlockMemory;
     SkDynamicMemoryWStream::Block const * fCurrent;
     size_t const fSize;
     size_t fOffset;
     size_t fCurrentOffset;
 };
 
@@ skipping 31 matching lines @@
 #endif
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 
 static SkData* mmap_filename(const char path[]) {
     SkFILE* file = sk_fopen(path, kRead_SkFILE_Flag);
-    if (NULL == file) {
-        return NULL;
+    if (nullptr == file) {
+        return nullptr;
     }
 
     SkData* data = SkData::NewFromFILE(file);
     sk_fclose(file);
     return data;
 }
 
 SkStreamAsset* SkStream::NewFromFile(const char path[]) {
     SkAutoTUnref<SkData> data(mmap_filename(path));
     if (data.get()) {
         return new SkMemoryStream(data.get());
     }
 
     // If we get here, then our attempt at using mmap failed, so try normal
     // file access.
     SkFILEStream* stream = new SkFILEStream(path);
     if (!stream->isValid()) {
         delete stream;
-        stream = NULL;
+        stream = nullptr;
     }
     return stream;
 }
 
 // Declared in SkStreamPriv.h:
 size_t SkCopyStreamToStorage(SkAutoMalloc* storage, SkStream* stream) {
-    SkASSERT(storage != NULL);
-    SkASSERT(stream != NULL);
+    SkASSERT(storage != nullptr);
+    SkASSERT(stream != nullptr);
 
     if (stream->hasLength()) {
         const size_t length = stream->getLength();
         void* dst = storage->reset(length);
         if (stream->read(dst, length) != length) {
             return 0;
         }
         return length;
     }
 
     SkDynamicMemoryWStream tempStream;
     // Arbitrary buffer size.
     const size_t bufferSize = 256 * 1024; // 256KB
     char buffer[bufferSize];
     SkDEBUGCODE(size_t debugLength = 0;)
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
         SkDEBUGCODE(debugLength += bytesRead);
         SkASSERT(tempStream.bytesWritten() == debugLength);
     } while (!stream->isAtEnd());
     const size_t length = tempStream.bytesWritten();
     void* dst = storage->reset(length);
     tempStream.copyTo(dst);
     return length;
 }
 
 // Declared in SkStreamPriv.h:
 SkData* SkCopyStreamToData(SkStream* stream) {
-    SkASSERT(stream != NULL);
+    SkASSERT(stream != nullptr);
 
     if (stream->hasLength()) {
         return SkData::NewFromStream(stream, stream->getLength());
     }
 
     SkDynamicMemoryWStream tempStream;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
     return tempStream.copyToData();
 }
 
 SkStreamRewindable* SkStreamRewindableFromSkStream(SkStream* stream) {
     if (!stream) {
-        return NULL;
+        return nullptr;
     }
     SkAutoTDelete<SkStreamRewindable> dupStream(stream->duplicate());
     if (dupStream) {
         return dupStream.detach();
     }
     stream->rewind();
     if (stream->hasLength()) {
         size_t length = stream->getLength();
         if (stream->hasPosition()) {  // If stream has length, but can't rewind.
             length -= stream->getPosition();
@@ skipping 26 matching lines @@
     while (true) {
         count = input->read(scratch, sizeof(scratch));
         if (0 == count) {
             return true;
         }
         if (!out->write(scratch, count)) {
             return false;
         }
     }
 }