Style Change: NULL->nullptr

tools/PictureRenderer.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef PictureRenderer_DEFINED
 #define PictureRenderer_DEFINED
 
@@ skipping 65 matching lines @@
     static_assert(!(kHinting_DrawFilterFlag & SkPaint::kAllFlags),
                   "hinting_flag_must_be_greater");
     static_assert(!(kSlightHinting_DrawFilterFlag & SkPaint::kAllFlags),
                   "slight_hinting_flag_must_be_greater");
 
     /**
      * Called with each new SkPicture to render.
      *
      * @param pict The SkPicture to render.
      * @param writePath The output directory within which this renderer should write all images,
-     *     or NULL if this renderer should not write all images.
+     *     or nullptr if this renderer should not write all images.
      * @param mismatchPath The output directory within which this renderer should write any images
-     *     which do not match expectations, or NULL if this renderer should not write mismatches.
+     *     which do not match expectations, or nullptr if this renderer should not write mismatches.
      * @param inputFilename The name of the input file we are rendering.
      * @param useChecksumBasedFilenames Whether to use checksum-based filenames when writing
      *     bitmap images to disk.
      * @param useMultiPictureDraw true if MultiPictureDraw should be used for rendering
      */
     virtual void init(const SkPicture* pict,
                       const SkString* writePath,
                       const SkString* mismatchPath,
                       const SkString* inputFilename,
                       bool useChecksumBasedFilenames,
@@ skipping 32 matching lines @@
      *
      * If fWritePath has been specified, the result of the work will be written to that dir.
      * If fMismatchPath has been specified, and the actual image result differs from its
      * expectation, the result of the work will be written to that dir.
      *
      * @param out If non-null, the implementing subclass MAY allocate an SkBitmap, copy the
      *            output image into it, and return it here.  (Some subclasses ignore this parameter)
      * @return bool True if rendering succeeded and, if fWritePath had been specified, the output
      *              was successfully written to a file.
      */
-    virtual bool render(SkBitmap** out = NULL) = 0;
+    virtual bool render(SkBitmap** out = nullptr) = 0;
 
     /**
      * Called once finished with a particular SkPicture, before calling init again, and before
      * being done with this Renderer.
      */
     virtual void end();
 
     /**
      * If this PictureRenderer is actually a TiledPictureRender, return a pointer to this as a
      * TiledPictureRender so its methods can be called.
      */
-    virtual TiledPictureRenderer* getTiledRenderer() { return NULL; }
+    virtual TiledPictureRenderer* getTiledRenderer() { return nullptr; }
 
     /**
      * Resets the GPU's state. Does nothing if the backing is raster. For a GPU renderer, calls
      * flush, swapBuffers and, if callFinish is true, finish.
      * @param callFinish Whether to call finish.
      */
     void resetState(bool callFinish);
 
     /**
      * Remove all decoded textures from the CPU caches and all uploaded textures
      * from the GPU.
      */
     void purgeTextures();
 
     /**
      * Set the backend type. Returns true on success and false on failure.
      */
 #if SK_SUPPORT_GPU
     bool setDeviceType(SkDeviceTypes deviceType, GrGLStandard gpuAPI = kNone_GrGLStandard) {
 #else
     bool setDeviceType(SkDeviceTypes deviceType) {
 #endif
         fDeviceType = deviceType;
 #if SK_SUPPORT_GPU
         // In case this function is called more than once
         SkSafeUnref(fGrContext);
-        fGrContext = NULL;
+        fGrContext = nullptr;
         // Set to Native so it will have an initial value.
         GrContextFactory::GLContextType glContextType = GrContextFactory::kNative_GLContextType;
 #endif
         switch(deviceType) {
             case kBitmap_DeviceType:
                 return true;
 #if SK_SUPPORT_GPU
             case kGPU_DeviceType:
                 // Already set to GrContextFactory::kNative_GLContextType, above.
                 break;
@@ skipping 10 matching lines @@
                 glContextType = GrContextFactory::kMESA_GLContextType;
                 break;
 #endif
 #endif
             default:
                 // Invalid device type.
                 return false;
         }
 #if SK_SUPPORT_GPU
         fGrContext = fGrContextFactory.get(glContextType, gpuAPI);
-        if (NULL == fGrContext) {
+        if (nullptr == fGrContext) {
             return false;
         } else {
             fGrContext->ref();
             return true;
         }
 #endif
     }
 
 #if SK_SUPPORT_GPU
     void setSampleCount(int sampleCount) {
@@ skipping 161 matching lines @@
             case kAngle_DeviceType:
                 glContextType = GrContextFactory::kANGLE_GLContextType;
                 break;
 #endif
 #if SK_MESA
             case kMesa_DeviceType:
                 glContextType = GrContextFactory::kMESA_GLContextType;
                 break;
 #endif
             default:
-                return NULL;
+                return nullptr;
         }
         return fGrContextFactory.getGLContext(glContextType);
     }
 
     GrContext* getGrContext() {
         return fGrContext;
     }
 
     const GrContextOptions& getGrContextOptions() {
         return fGrContextFactory.getGlobalOptions();
     }
 #endif
 
     SkCanvas* getCanvas() {
         return fCanvas;
     }
 
     const SkPicture* getPicture() {
         return fPicture;
     }
 
 #if SK_SUPPORT_GPU
     explicit PictureRenderer(const GrContextOptions &opts)
 #else
     PictureRenderer()
 #endif
-        : fJsonSummaryPtr(NULL)
+        : fJsonSummaryPtr(nullptr)
         , fDeviceType(kBitmap_DeviceType)
         , fEnableWrites(false)
         , fBBoxHierarchyType(kNone_BBoxHierarchyType)
         , fHasDrawFilters(false)
         , fScaleFactor(SK_Scalar1)
 #if SK_SUPPORT_GPU
         , fGrContextFactory(opts)
-        , fGrContext(NULL)
+        , fGrContext(nullptr)
         , fSampleCount(0)
         , fUseDFText(false)
 #endif
         {
             sk_bzero(fDrawFilters, sizeof(fDrawFilters));
             fViewport.set(0, 0);
         }
 
 #if SK_SUPPORT_GPU
     virtual ~PictureRenderer() {
@@ skipping 35 matching lines @@
      * Scales the provided canvas to the scale factor set by setScaleFactor.
      */
     void scaleToScaleFactor(SkCanvas*);
 
     SkBBHFactory* getFactory();
     uint32_t recordFlags() const { return 0; }
     SkCanvas* setupCanvas();
     virtual SkCanvas* setupCanvas(int width, int height);
 
     /**
-     * Copy src to dest; if src==NULL, set dest to empty string.
+     * Copy src to dest; if src==nullptr, set dest to empty string.
      */
     static void CopyString(SkString* dest, const SkString* src);
 
 private:
     SkISize                fViewport;
     SkScalar               fScaleFactor;
 #if SK_SUPPORT_GPU
     GrContextFactory       fGrContextFactory;
     GrContext*             fGrContext;
     int                    fSampleCount;
     bool                   fUseDFText;
 #endif
 
     virtual SkString getConfigNameInternal() = 0;
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * This class does not do any rendering, but its render function executes recording, which we want
  * to time.
  */
 class RecordPictureRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
     RecordPictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
 #endif
 
-    bool render(SkBitmap** out = NULL) override;
+    bool render(SkBitmap** out = nullptr) override;
 
     SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
 
     SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
 
 protected:
     SkCanvas* setupCanvas(int width, int height) override;
 
 private:
     SkString getConfigNameInternal() override;
 
     typedef PictureRenderer INHERITED;
 };
 
 class PipePictureRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
     PipePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
 #endif
 
-    bool render(SkBitmap** out = NULL) override;
+    bool render(SkBitmap** out = nullptr) override;
 
 private:
     SkString getConfigNameInternal() override;
 
     typedef PictureRenderer INHERITED;
 };
 
 class SimplePictureRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
     SimplePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
 #endif
 
     virtual void init(const SkPicture* pict,
                       const SkString* writePath,
                       const SkString* mismatchPath,
                       const SkString* inputFilename,
                       bool useChecksumBasedFilenames,
                       bool useMultiPictureDraw) override;
 
-    bool render(SkBitmap** out = NULL) override;
+    bool render(SkBitmap** out = nullptr) override;
 
 private:
     SkString getConfigNameInternal() override;
 
     typedef PictureRenderer INHERITED;
 };
 
 class TiledPictureRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
     TiledPictureRenderer(const GrContextOptions &opts);
 #else
     TiledPictureRenderer();
 #endif
 
     virtual void init(const SkPicture* pict,
                       const SkString* writePath,
                       const SkString* mismatchPath,
                       const SkString* inputFilename,
                       bool useChecksumBasedFilenames,
                       bool useMultiPictureDraw) override;
 
     /**
      * Renders to tiles, rather than a single canvas.
      * If fWritePath was provided, a separate file is
      * created for each tile, named "path0.png", "path1.png", etc.
      */
-    bool render(SkBitmap** out = NULL) override;
+    bool render(SkBitmap** out = nullptr) override;
 
     void end() override;
 
     void setTileWidth(int width) {
         fTileWidth = width;
     }
 
     int getTileWidth() const {
         return fTileWidth;
     }
@@ skipping 102 matching lines @@
  * into an SkPicturePlayback, which we want to time.
  */
 class PlaybackCreationRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
     PlaybackCreationRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
 #endif
 
     void setup() override;
 
-    bool render(SkBitmap** out = NULL) override;
+    bool render(SkBitmap** out = nullptr) override;
 
     SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
 
     SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
 
 private:
     SkAutoTDelete<SkPictureRecorder> fRecorder;
 
     SkString getConfigNameInternal() override;
 
     typedef PictureRenderer INHERITED;
 };
 
 #if SK_SUPPORT_GPU
 extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContextOptions& opts);
 #else
 extern PictureRenderer* CreateGatherPixelRefsRenderer();
 #endif
 
 }
 
 #endif  // PictureRenderer_DEFINED