Style Change: NULL->nullptr

src/gpu/gl/debug/GrGLCreateDebugInterface.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 "gl/GrGLInterface.h"
@@ skipping 66 matching lines @@
                                                GrGLsizeiptr size,
                                                const GrGLvoid* data,
                                                GrGLenum usage) {
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
     GrAlwaysAssert(size >= 0);
     GrAlwaysAssert(GR_GL_STREAM_DRAW == usage ||
                    GR_GL_STATIC_DRAW == usage ||
                    GR_GL_DYNAMIC_DRAW == usage);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glBufferData");
             break;
@@ skipping 136 matching lines @@
      for (unsigned int i = 0;
           i < GrDebugGL::getInstance()->getMaxTextureUnits();
           ++i) {
          GrTextureUnitObj *pTU = GrDebugGL::getInstance()->getTextureUnit(i);
 
          if (pTU->getTexture()) {
              for (int j = 0; j < n; ++j) {
 
                  if (textures[j] == pTU->getTexture()->getID()) {
                      // this ID is the current texture - revert the binding to 0
-                     pTU->setTexture(NULL);
+                     pTU->setTexture(nullptr);
                  }
              }
          }
      }
 
      // TODO: fuse the following block with DeleteRenderBuffers?
      // Open GL will remove a deleted render buffer from the active
      // frame buffer but not from any other frame buffer
      if (GrDebugGL::getInstance()->getFrameBuffer()) {
 
          GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->getFrameBuffer();
 
          for (int i = 0; i < n; ++i) {
 
              if (frameBuffer->getColor() &&
                  textures[i] == frameBuffer->getColor()->getID()) {
-                 frameBuffer->setColor(NULL);
+                 frameBuffer->setColor(nullptr);
              }
              if (frameBuffer->getDepth() &&
                  textures[i] == frameBuffer->getDepth()->getID()) {
-                 frameBuffer->setDepth(NULL);
+                 frameBuffer->setDepth(nullptr);
              }
              if (frameBuffer->getStencil() &&
                  textures[i] == frameBuffer->getStencil()->getID()) {
-                 frameBuffer->setStencil(NULL);
+                 frameBuffer->setStencil(nullptr);
              }
          }
      }
 
      // then actually "delete" the buffers
      for (int i = 0; i < n; ++i) {
          GrTextureObj *buffer = GR_FIND(textures[i],
                                         GrTextureObj,
                                         GrDebugGL::kTexture_ObjTypes);
          GrAlwaysAssert(buffer);
@@ skipping 11 matching lines @@
  GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteFramebuffers(GrGLsizei n,
                                                         const GrGLuint *frameBuffers) {
 
      // first potentially unbind the buffers
      if (GrDebugGL::getInstance()->getFrameBuffer()) {
          for (int i = 0; i < n; ++i) {
 
              if (frameBuffers[i] ==
                  GrDebugGL::getInstance()->getFrameBuffer()->getID()) {
                  // this ID is the current frame buffer - rebind to the default
-                 GrDebugGL::getInstance()->setFrameBuffer(NULL);
+                 GrDebugGL::getInstance()->setFrameBuffer(nullptr);
              }
          }
      }
 
      // then actually "delete" the buffers
      for (int i = 0; i < n; ++i) {
          GrFrameBufferObj *buffer = GR_FIND(frameBuffers[i],
                                             GrFrameBufferObj,
                                             GrDebugGL::kFrameBuffer_ObjTypes);
          GrAlwaysAssert(buffer);
 
          GrAlwaysAssert(!buffer->getDeleted());
          buffer->deleteAction();
      }
  }
 
  GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteRenderbuffers(GrGLsizei n,
                                                          const GrGLuint *renderBuffers) {
 
      // first potentially unbind the buffers
      if (GrDebugGL::getInstance()->getRenderBuffer()) {
          for (int i = 0; i < n; ++i) {
 
              if (renderBuffers[i] ==
                  GrDebugGL::getInstance()->getRenderBuffer()->getID()) {
                  // this ID is the current render buffer - make no
                  // render buffer be bound
-                 GrDebugGL::getInstance()->setRenderBuffer(NULL);
+                 GrDebugGL::getInstance()->setRenderBuffer(nullptr);
              }
          }
      }
 
      // TODO: fuse the following block with DeleteTextures?
      // Open GL will remove a deleted render buffer from the active frame
      // buffer but not from any other frame buffer
      if (GrDebugGL::getInstance()->getFrameBuffer()) {
 
          GrFrameBufferObj *frameBuffer =
                                GrDebugGL::getInstance()->getFrameBuffer();
 
          for (int i = 0; i < n; ++i) {
 
              if (frameBuffer->getColor() &&
                  renderBuffers[i] == frameBuffer->getColor()->getID()) {
-                 frameBuffer->setColor(NULL);
+                 frameBuffer->setColor(nullptr);
              }
              if (frameBuffer->getDepth() &&
                  renderBuffers[i] == frameBuffer->getDepth()->getID()) {
-                 frameBuffer->setDepth(NULL);
+                 frameBuffer->setDepth(nullptr);
              }
              if (frameBuffer->getStencil() &&
                  renderBuffers[i] == frameBuffer->getStencil()->getID()) {
-                 frameBuffer->setStencil(NULL);
+                 frameBuffer->setStencil(nullptr);
              }
          }
      }
 
      // then actually "delete" the buffers
      for (int i = 0; i < n; ++i) {
          GrRenderBufferObj *buffer = GR_FIND(renderBuffers[i],
                                              GrRenderBufferObj,
                                              GrDebugGL::kRenderBuffer_ObjTypes);
          GrAlwaysAssert(buffer);
@@ skipping 180 matching lines @@
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteVertexArrays(GrGLsizei n, const GrGLuint* ids) {
     for (GrGLsizei i = 0; i < n; ++i) {
         GrVertexArrayObj* array =
             GR_FIND(ids[i], GrVertexArrayObj, GrDebugGL::kVertexArray_ObjTypes);
         GrAlwaysAssert(array);
 
         // Deleting the current vertex array binds object 0
         if (GrDebugGL::getInstance()->getVertexArray() == array) {
-            GrDebugGL::getInstance()->setVertexArray(NULL);
+            GrDebugGL::getInstance()->setVertexArray(nullptr);
         }
 
         if (array->getRefCount()) {
             // someone is still using this vertex array so we can't delete it here
             array->setMarkedForDeletion();
         } else {
             array->deleteAction();
         }
     }
 }
@@ skipping 26 matching lines @@
 }
 
 // deleting a bound buffer has the side effect of binding 0
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteBuffers(GrGLsizei n, const GrGLuint* ids) {
     // first potentially unbind the buffers
     for (int i = 0; i < n; ++i) {
 
         if (GrDebugGL::getInstance()->getArrayBuffer() &&
             ids[i] == GrDebugGL::getInstance()->getArrayBuffer()->getID()) {
             // this ID is the current array buffer
-            GrDebugGL::getInstance()->setArrayBuffer(NULL);
+            GrDebugGL::getInstance()->setArrayBuffer(nullptr);
         }
         if (GrDebugGL::getInstance()->getElementArrayBuffer() &&
             ids[i] ==
                 GrDebugGL::getInstance()->getElementArrayBuffer()->getID()) {
             // this ID is the current element array buffer
-            GrDebugGL::getInstance()->setElementArrayBuffer(NULL);
+            GrDebugGL::getInstance()->setElementArrayBuffer(nullptr);
         }
     }
 
     // then actually "delete" the buffers
     for (int i = 0; i < n; ++i) {
         GrBufferObj *buffer = GR_FIND(ids[i],
                                       GrBufferObj,
                                       GrDebugGL::kBuffer_ObjTypes);
         GrAlwaysAssert(buffer);
 
         GrAlwaysAssert(!buffer->getDeleted());
         buffer->deleteAction();
     }
 }
 
 // map a buffer to the caller's address space
 GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBufferRange(GrGLenum target, GrGLintptr offset,
                                                     GrGLsizeiptr length, GrGLbitfield access) {
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
     // We only expect read access and we expect that the buffer or range is always invalidated.
     GrAlwaysAssert(!SkToBool(GR_GL_MAP_READ_BIT & access));
     GrAlwaysAssert((GR_GL_MAP_INVALIDATE_BUFFER_BIT | GR_GL_MAP_INVALIDATE_RANGE_BIT) & access);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glMapBufferRange");
             break;
     }
 
     if (buffer) {
         GrAlwaysAssert(offset >= 0 && offset + length <= buffer->getSize());
         GrAlwaysAssert(!buffer->getMapped());
         buffer->setMapped(offset, length);
         return buffer->getDataPtr() + offset;
     }
 
     GrAlwaysAssert(false);
-    return NULL;        // no buffer bound to the target
+    return nullptr;        // no buffer bound to the target
 }
 
 GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target, GrGLenum access) {
     GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glMapBuffer");
             break;
     }
 
     return debugGLMapBufferRange(target, 0, buffer->getSize(),
                                  GR_GL_MAP_WRITE_BIT | GR_GL_MAP_INVALIDATE_BUFFER_BIT);
 }
 
 // remove a buffer from the caller's address space
 // TODO: check if the "access" method from "glMapBuffer" was honored
 GrGLboolean GR_GL_FUNCTION_TYPE debugGLUnmapBuffer(GrGLenum target) {
 
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glUnmapBuffer");
             break;
     }
 
     if (buffer) {
         GrAlwaysAssert(buffer->getMapped());
         buffer->resetMapped();
         return GR_GL_TRUE;
     }
 
     GrAlwaysAssert(false);
     return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLFlushMappedBufferRange(GrGLenum target,
                                                            GrGLintptr offset,
                                                            GrGLsizeiptr length) {
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glUnmapBuffer");
             break;
@@ skipping 10 matching lines @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetBufferParameteriv(GrGLenum target,
                                                          GrGLenum value,
                                                          GrGLint* params) {
 
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
     GrAlwaysAssert(GR_GL_BUFFER_SIZE == value ||
                    GR_GL_BUFFER_USAGE == value);
 
-    GrBufferObj *buffer = NULL;
+    GrBufferObj *buffer = nullptr;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
     }
 
     GrAlwaysAssert(buffer);
@@ skipping 21 matching lines @@
 };
 } // end of namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 struct GrDebugGLInterface : public GrGLInterface {
 
 public:
     
 
     GrDebugGLInterface()
-        : fWrapped(NULL) {
+        : fWrapped(nullptr) {
         GrDebugGL::staticRef();
     }
 
     virtual ~GrDebugGLInterface() {
         GrDebugGL::staticUnRef();
     }
 
     void setWrapped(GrGLInterface *interface) {
         fWrapped.reset(interface);
     }
@@ skipping 182 matching lines @@
     functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity;
 
     functions->fBindFragDataLocationIndexed =
                                     noOpGLBindFragDataLocationIndexed;
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
 
     return interface;
 }