Style Change: NULL->nullptr

src/utils/debugger/SkDebugCanvas.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 "SkClipStack.h"
 #include "SkColorPriv.h"
 #include "SkDebugCanvas.h"
@@ skipping 32 matching lines @@
             idx = 7 - (SkColorGetB(dst)+21)/42;
         } else { // 7-9
             idx = 10 - (SkColorGetG(dst)+22)/45;
         }
         ++idx;
         SkASSERT(idx < (int)SK_ARRAY_COUNT(gTable));
 
         return gTable[idx];
     }
 
-    Factory getFactory() const override { return NULL; }
+    Factory getFactory() const override { return nullptr; }
 #ifndef SK_IGNORE_TO_STRING
     void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
 #endif
 };
 
 class DebugPaintFilterCanvas : public SkPaintFilterCanvas {
 public:
     DebugPaintFilterCanvas(int width,
                            int height,
                            bool overdrawViz,
                            bool overrideFilterQuality,
                            SkFilterQuality quality)
         : INHERITED(width, height)
-        , fOverdrawXfermode(overdrawViz ? new OverdrawXfermode : NULL)
+        , fOverdrawXfermode(overdrawViz ? new OverdrawXfermode : nullptr)
         , fOverrideFilterQuality(overrideFilterQuality)
         , fFilterQuality(quality) {}
 
 protected:
     void onFilterPaint(SkPaint* paint, Type) const override {
-        if (NULL != fOverdrawXfermode.get()) {
+        if (nullptr != fOverdrawXfermode.get()) {
             paint->setAntiAlias(false);
             paint->setXfermode(fOverdrawXfermode.get());
         }
 
         if (fOverrideFilterQuality) {
             paint->setFilterQuality(fFilterQuality);
         }
     }
 
     void onDrawPicture(const SkPicture* picture,
                        const SkMatrix* matrix,
                        const SkPaint* paint) override {
         // We need to replay the picture onto this canvas in order to filter its internal paints.
         this->SkCanvas::onDrawPicture(picture, matrix, paint);
     }
 
 private:
     SkAutoTUnref<SkXfermode> fOverdrawXfermode;
 
     bool fOverrideFilterQuality;
     SkFilterQuality fFilterQuality;
 
     typedef SkPaintFilterCanvas INHERITED;
 };
 
 }
 
 SkDebugCanvas::SkDebugCanvas(int width, int height)
         : INHERITED(width, height)
-        , fPicture(NULL)
+        , fPicture(nullptr)
         , fFilter(false)
         , fMegaVizMode(false)
         , fOverdrawViz(false)
         , fOverrideFilterQuality(false)
         , fFilterQuality(kNone_SkFilterQuality) {
     fUserMatrix.reset();
 
     // SkPicturePlayback uses the base-class' quickReject calls to cull clipped
     // operations. This can lead to problems in the debugger which expects all
     // the operations in the captured skp to appear in the debug canvas. To
@@ skipping 238 matching lines @@
 const SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() const {
     return fCommandVector;
 }
 
 SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() {
     return fCommandVector;
 }
 
 void SkDebugCanvas::updatePaintFilterCanvas() {
     if (!fOverdrawViz && !fOverrideFilterQuality) {
-        fPaintFilterCanvas.reset(NULL);
+        fPaintFilterCanvas.reset(nullptr);
         return;
     }
 
     const SkImageInfo info = this->imageInfo();
     fPaintFilterCanvas.reset(new DebugPaintFilterCanvas(info.width(), info.height(), fOverdrawViz,
                                                         fOverrideFilterQuality, fFilterQuality));
 }
 
 void SkDebugCanvas::setOverdrawViz(bool overdrawViz) {
     if (fOverdrawViz == overdrawViz) {
@@ skipping 135 matching lines @@
                                 const SkPoint texCoords[4], SkXfermode* xmode,
                                 const SkPaint& paint) {
     this->addDrawCommand(new SkDrawPatchCommand(cubics, colors, texCoords, xmode, paint));
 }
 
 void SkDebugCanvas::onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
                                    const SkPoint texs[], const SkColor colors[],
                                    SkXfermode*, const uint16_t indices[], int indexCount,
                                    const SkPaint& paint) {
     this->addDrawCommand(new SkDrawVerticesCommand(vmode, vertexCount, vertices,
-                         texs, colors, NULL, indices, indexCount, paint));
+                         texs, colors, nullptr, indices, indexCount, paint));
 }
 
 void SkDebugCanvas::willRestore() {
     this->addDrawCommand(new SkRestoreCommand());
     this->INHERITED::willRestore();
 }
 
 void SkDebugCanvas::willSave() {
     this->addDrawCommand(new SkSaveCommand());
     this->INHERITED::willSave();
@@ skipping 134 matching lines @@
 }
 
 bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) {
     if (fCalledAddStackData) {
         fClipStackData.appendf("<br>");
         addPathData(devPath, "pathOut");
         return true;
     }
     return false;
 }