Style Change: NULL->nullptr

src/gpu/GrAtlas.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrContext.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrTracing.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // for testing
 #define FONT_CACHE_STATS 0
 #if FONT_CACHE_STATS
 static int g_UploadCount = 0;
 #endif
 
 GrPlot::GrPlot() 
     : fID(-1)
-    , fTexture(NULL)
-    , fRects(NULL)
-    , fAtlas(NULL)
+    , fTexture(nullptr)
+    , fRects(nullptr)
+    , fAtlas(nullptr)
     , fBytesPerPixel(1)
     , fDirty(false)
     , fBatchUploads(false)
 {
     fOffset.set(0, 0);
 }
 
 GrPlot::~GrPlot() {
     delete[] fPlotData;
-    fPlotData = NULL;
+    fPlotData = nullptr;
     delete fRects;
 }
 
 void GrPlot::init(GrAtlas* atlas, int id, int offX, int offY, int width, int height, size_t bpp,
                   bool batchUploads) {
     fID = id;
     fRects = GrRectanizer::Factory(width, height);
     fAtlas = atlas;
     fOffset.set(offX * width, offY * height);
     fBytesPerPixel = bpp;
-    fPlotData = NULL;
+    fPlotData = nullptr;
     fDirtyRect.setEmpty();
     fDirty = false;
     fBatchUploads = batchUploads;
 }
 
 static inline void adjust_for_offset(SkIPoint16* loc, const SkIPoint16& offset) {
     loc->fX += offset.fX;
     loc->fY += offset.fY;
 }
 
 bool GrPlot::addSubImage(int width, int height, const void* image, SkIPoint16* loc) {
     float percentFull = fRects->percentFull();
     if (!fRects->addRect(width, height, loc)) {
         return false;
     }
 
     // if batching uploads, create backing memory on first use
     // once the plot is nearly full we will revert to uploading each subimage individually
     int plotWidth = fRects->width();
     int plotHeight = fRects->height();
-    if (fBatchUploads && NULL == fPlotData && 0.0f == percentFull) {
+    if (fBatchUploads && nullptr == fPlotData && 0.0f == percentFull) {
         fPlotData = new unsigned char[fBytesPerPixel * plotWidth * plotHeight];
         memset(fPlotData, 0, fBytesPerPixel*plotWidth*plotHeight);
     }
 
     // if we have backing memory, copy to the memory and set for future upload
     if (fPlotData) {
         const unsigned char* imagePtr = (const unsigned char*) image;
         // point ourselves at the right starting spot
         unsigned char* dataPtr = fPlotData;
         dataPtr += fBytesPerPixel*plotWidth*loc->fY;
@@ skipping 35 matching lines @@
 GrAtlas::GrAtlas(GrGpu* gpu, GrPixelConfig config, GrSurfaceFlags flags,
                  const SkISize& backingTextureSize,
                  int numPlotsX, int numPlotsY, bool batchUploads) {
     fGpu = SkRef(gpu);
     fPixelConfig = config;
     fFlags = flags;
     fBackingTextureSize = backingTextureSize;
     fNumPlotsX = numPlotsX;
     fNumPlotsY = numPlotsY;
     fBatchUploads = batchUploads;
-    fTexture = NULL;
+    fTexture = nullptr;
 
     int textureWidth = fBackingTextureSize.width();
     int textureHeight = fBackingTextureSize.height();
 
     int plotWidth = textureWidth / fNumPlotsX;
     int plotHeight = textureHeight / fNumPlotsY;
 
     SkASSERT(plotWidth * fNumPlotsX == textureWidth);
     SkASSERT(plotHeight * fNumPlotsY == textureHeight);
 
@@ skipping 43 matching lines @@
     for (int i = usage->fPlots.count()-1; i >= 0; --i) {
         GrPlot* plot = usage->fPlots[i];
         // client may have plots from more than one atlas, must check for ours before adding
         if (this == plot->fAtlas && plot->addSubImage(width, height, image, loc)) {
             this->makeMRU(plot);
             return plot;
         }
     }
 
     // before we get a new plot, make sure we have a backing texture
-    if (NULL == fTexture) {
+    if (nullptr == fTexture) {
         // TODO: Update this to use the cache rather than directly creating a texture.
         GrSurfaceDesc desc;
         desc.fFlags = fFlags;
         desc.fWidth = fBackingTextureSize.width();
         desc.fHeight = fBackingTextureSize.height();
         desc.fConfig = fPixelConfig;
 
-        fTexture = fGpu->createTexture(desc, true, NULL, 0);
-        if (NULL == fTexture) {
-            return NULL;
+        fTexture = fGpu->createTexture(desc, true, nullptr, 0);
+        if (nullptr == fTexture) {
+            return nullptr;
         }
     }
 
     // now look through all allocated plots for one we can share, in MRU order
     GrPlotList::Iter plotIter;
     plotIter.init(fPlotList, GrPlotList::Iter::kHead_IterStart);
     GrPlot* plot;
     while ((plot = plotIter.get())) {
         // make sure texture is set for quick lookup
         plot->fTexture = fTexture;
         if (plot->addSubImage(width, height, image, loc)) {
             this->makeMRU(plot);
             // new plot for atlas, put at end of array
             SkASSERT(!usage->fPlots.contains(plot));
             *(usage->fPlots.append()) = plot;
             return plot;
         }
         plotIter.next();
     }
 
     // If the above fails, then the current plot list has no room
-    return NULL;
+    return nullptr;
 }
 
 void GrAtlas::RemovePlot(ClientPlotUsage* usage, const GrPlot* plot) {
     int index = usage->fPlots.find(const_cast<GrPlot*>(plot));
     if (index >= 0) {
         usage->fPlots.remove(index);
     }
 }