Style Change: NULL->nullptr

src/gpu/GrLayerCache.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
@@ skipping 140 matching lines @@
                   const SkMatrix& ctm,
                   const int* key,
                   int keySize,
                   const SkPaint* paint)
         : fKey(pictureID, ctm, key, keySize, true)
         , fStart(start)
         , fStop(stop)
         , fSrcIR(srcIR)
         , fDstIR(dstIR)
         , fOffset(SkIPoint::Make(0, 0))
-        , fPaint(paint ? new SkPaint(*paint) : NULL)
-        , fFilter(NULL)
-        , fTexture(NULL)
+        , fPaint(paint ? new SkPaint(*paint) : nullptr)
+        , fFilter(nullptr)
+        , fTexture(nullptr)
         , fRect(SkIRect::MakeEmpty())
-        , fPlot(NULL)
+        , fPlot(nullptr)
         , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID);
 
         if (fPaint) {
             if (fPaint->getImageFilter()) {
                 fFilter = SkSafeRef(fPaint->getImageFilter());
-                fPaint->setImageFilter(NULL);
+                fPaint->setImageFilter(nullptr);
             }
         }
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
         SkSafeUnref(fFilter);
         delete fPaint;
     }
 
@@ skipping 16 matching lines @@
     }
     GrTexture* texture() { return fTexture; }
     const SkPaint* paint() const { return fPaint; }
     const SkImageFilter* filter() const { return fFilter; }
     const SkIRect& rect() const { return fRect; }
 
     void setOffset(const SkIPoint& offset) { fOffset = offset; }
     const SkIPoint& offset() const { return fOffset; }
 
     void setPlot(GrPlot* plot) {
-        SkASSERT(NULL == plot || NULL == fPlot);
+        SkASSERT(nullptr == plot || nullptr == fPlot);
         fPlot = plot;
     }
     GrPlot* plot() { return fPlot; }
 
     bool isAtlased() const { return SkToBool(fPlot); }
 
     void setLocked(bool locked) { fLocked = locked; }
     bool locked() const { return fLocked; }
 
     SkDEBUGCODE(const GrPlot* plot() const { return fPlot; })
     SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;)
 
 private:
     const Key       fKey;
 
     // The "saveLayer" operation index of the cached layer
     const int  fStart;
     // The final "restore" operation index of the cached layer
     const int  fStop;
 
     // The layer's src rect (i.e., the portion of the source scene required
     // for filtering).
     const SkIRect   fSrcIR;
     // The layer's dest rect (i.e., where it will land in device space)
     const SkIRect   fDstIR;
     // Offset sometimes required by image filters
     SkIPoint        fOffset;
 
     // The paint used when dropping the layer down into the owning canvas.
-    // Can be NULL. This class makes a copy for itself.
+    // Can be nullptr. This class makes a copy for itself.
     SkPaint*  fPaint;
 
     // The imagefilter that needs to be applied to the layer prior to it being
     // composited with the rest of the scene.
     const SkImageFilter* fFilter;
 
     // fTexture is a ref on the atlasing texture for atlased layers and a
     // ref on a GrTexture for non-atlased textures.
     GrTexture*      fTexture;
 
     // For both atlased and non-atlased layers 'fRect' contains the  bound of
     // the layer in whichever texture it resides. It is empty when 'fTexture'
-    // is NULL.
+    // is nullptr.
     SkIRect         fRect;
 
     // For atlased layers, fPlot stores the atlas plot in which the layer rests.
-    // It is always NULL for non-atlased layers.
+    // It is always nullptr for non-atlased layers.
     GrPlot*         fPlot;
 
     // The number of actively hoisted layers using this cached image (e.g.,
     // extant GrHoistedLayers pointing at this object). This object will
     // be unlocked when the use count reaches 0.
     int             fUses;
 
     // For non-atlased layers 'fLocked' should always match "fTexture".
     // (i.e., if there is a texture it is locked).
     // For atlased layers, 'fLocked' is true if the layer is in a plot and
@@ skipping 134 matching lines @@
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif