Style Change: NULL->nullptr

src/gpu/GrGeometryBuffer.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGeometryBuffer_DEFINED
@@ skipping 30 matching lines @@
      * to draw from the buffer while it is mapped. It is an error to call map
      * on an already mapped buffer. It may fail if the backend doesn't support
      * mapping the buffer. If the buffer is CPU backed then it will always
      * succeed and is a free operation. Must be matched by an unmap() call.
      * Currently only one map at a time is supported (no nesting of
      * map/unmap).
      *
      * Note that buffer mapping does not go through GrContext and therefore is
      * not serialized with other operations.
      *
-     * @return a pointer to the data or NULL if the map fails.
+     * @return a pointer to the data or nullptr if the map fails.
      */
      void* map() { return (fMapPtr = this->onMap()); }
 
     /**
      * Unmaps the buffer.
      *
      * The pointer returned by the previous map call will no longer be valid.
      */
      void unmap() {
          SkASSERT(fMapPtr);
          this->onUnmap();
-         fMapPtr = NULL;
+         fMapPtr = nullptr;
      }
 
     /**
-     * Returns the same ptr that map() returned at time of map or NULL if the
+     * Returns the same ptr that map() returned at time of map or nullptr if the
      * is not mapped.
      *
-     * @return ptr to mapped buffer data or NULL if buffer is not mapped.
+     * @return ptr to mapped buffer data or nullptr if buffer is not mapped.
      */
      void* mapPtr() const { return fMapPtr; }
 
     /**
      Queries whether the buffer has been mapped.
 
      @return true if the buffer is mapped, false otherwise.
      */
      bool isMapped() const { return SkToBool(fMapPtr); }
 
@@ skipping 13 matching lines @@
      */
     bool updateData(const void* src, size_t srcSizeInBytes) {
         SkASSERT(!this->isMapped());
         SkASSERT(srcSizeInBytes <= fGpuMemorySize);
         return this->onUpdateData(src, srcSizeInBytes);
     }
 
 protected:
     GrGeometryBuffer(GrGpu* gpu, size_t gpuMemorySize, bool dynamic, bool cpuBacked)
         : INHERITED(gpu, kCached_LifeCycle)
-        , fMapPtr(NULL)
+        , fMapPtr(nullptr)
         , fGpuMemorySize(gpuMemorySize)
         , fDynamic(dynamic)
         , fCPUBacked(cpuBacked) {}
 
 private:
     virtual size_t onGpuMemorySize() const { return fGpuMemorySize; }
 
     virtual void* onMap() = 0;
     virtual void onUnmap() = 0;
     virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) = 0;
 
     void*    fMapPtr;
     size_t   fGpuMemorySize;
     bool     fDynamic;
     bool     fCPUBacked;
 
     typedef GrGpuResource INHERITED;
 };
 
 #endif