Style Change: NULL->nullptr

src/gpu/gl/SkNullGLContext.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 "gl/SkNullGLContext.h"
 #include "gl/GrGLInterface.h"
 #include "GrGLDefines.h"
 #include "GrGLNoOpInterface.h"
 #include "SkTDArray.h"
 #include "SkTLS.h"
 
 static SkNullGLContext::ContextState* current_context();
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 class BufferObj {
 public:
     
 
-    BufferObj(GrGLuint id) : fID(id), fDataPtr(NULL), fSize(0), fMapped(false) {}
+    BufferObj(GrGLuint id) : fID(id), fDataPtr(nullptr), fSize(0), fMapped(false) {}
     ~BufferObj() { delete[] fDataPtr; }
 
     void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) {
         if (fDataPtr) {
             SkASSERT(0 != fSize);
             delete[] fDataPtr;
         }
 
         fSize = size;
         fDataPtr = new char[size];
@@ skipping 14 matching lines @@
 };
 
 // This class maintains a sparsely populated array of buffer pointers.
 class BufferManager {
 public:
     
 
     BufferManager() : fFreeListHead(kFreeListEnd) {}
 
     ~BufferManager() {
-        // NULL out the entries that are really free list links rather than ptrs before deleting.
+        // nullptr out the entries that are really free list links rather than ptrs before deleting.
         intptr_t curr = fFreeListHead;
         while (kFreeListEnd != curr) {
             intptr_t next = reinterpret_cast<intptr_t>(fBuffers[SkToS32(curr)]);
-            fBuffers[SkToS32(curr)] = NULL;
+            fBuffers[SkToS32(curr)] = nullptr;
             curr = next;
         }
 
         fBuffers.deleteAll();
     }
 
     BufferObj* lookUp(GrGLuint id) {
         BufferObj* buffer = fBuffers[id];
         SkASSERT(buffer && buffer->id() == id);
         return buffer;
@@ skipping 173 matching lines @@
             break;
     }
 
     if (id > 0) {
         // We just ignore the offset and length here.
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         SkASSERT(!buffer->mapped());
         buffer->setMapped(true);
         return buffer->dataPtr();
     }
-    return NULL;
+    return nullptr;
 }
 
 GrGLvoid* GR_GL_FUNCTION_TYPE nullGLMapBuffer(GrGLenum target, GrGLenum access) {
     State* state = State::Get();
     GrGLuint id = 0;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             id = state->fCurrArrayBuffer;
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             id = state->fCurrElementArrayBuffer;
             break;
     }
 
     if (id > 0) {
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         SkASSERT(!buffer->mapped());
         buffer->setMapped(true);
         return buffer->dataPtr();
     }
 
     SkASSERT(false);
-    return NULL;            // no buffer bound to target
+    return nullptr;            // no buffer bound to target
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLFlushMappedBufferRange(GrGLenum target,
                                                           GrGLintptr offset,
                                                           GrGLsizeiptr length) {}
 
 
 GrGLboolean GR_GL_FUNCTION_TYPE nullGLUnmapBuffer(GrGLenum target) {
     State* state = State::Get();
     GrGLuint id = 0;
@@ skipping 201 matching lines @@
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
     return interface;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static void* create_tls() {
     State** current = new State*;
-    *current = NULL;
+    *current = nullptr;
     return current;
 }
 
 static void delete_tls(void* ctx) {
     State** current = static_cast<State**>(ctx);
     if (*current) {
         (*current)->unref();
     }
     delete current;
 }
@@ skipping 14 matching lines @@
 }
 
 #if GR_GL_PER_GL_FUNC_CALLBACK
 static void set_current_context_from_interface(const GrGLInterface* interface) {
     set_current_context(reinterpret_cast<State*>(interface->fCallbackData));
 }
 #endif
 
 SkNullGLContext* SkNullGLContext::Create(GrGLStandard forcedGpuAPI) {
     if (kGLES_GrGLStandard == forcedGpuAPI) {
-        return NULL;
+        return nullptr;
     }
     SkNullGLContext* ctx = new SkNullGLContext;
     if (!ctx->isValid()) {
         delete ctx;
-        return NULL;
+        return nullptr;
     }
     return ctx;
 }
 
 SkNullGLContext::SkNullGLContext() {
     fState = new ContextState;
     GrGLInterface* interface = create_null_interface(fState);
     this->init(interface);
 #if GR_GL_PER_GL_FUNC_CALLBACK
     interface->fCallback = set_current_context_from_interface;
     interface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(fState);
 #endif
 }
 
 SkNullGLContext::~SkNullGLContext() {
     this->teardown();
     fState->unref();
 }
 
 void SkNullGLContext::onPlatformMakeCurrent() const { set_current_context(fState); }