add --writeChecksumBasedFilenames flag to render_pictures

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 26 matching lines @@
 namespace sk_tools {
 
 class TiledPictureRenderer;
 
 /**
  * Class for collecting image results (checksums) as we go.
  */
 class ImageResultsSummary {
 public:
     /**
+     * Adds this bitmap hash to the summary of results.
+     *
+     * @param testName name of the test
+     * @param hash hash to store
+     */
+    void add(const char *testName, uint64_t hash);
+
+    /**
      * Adds this bitmap's hash to the summary of results.
      *
      * @param testName name of the test
      * @param bitmap bitmap to store the hash of
      */
     void add(const char *testName, const SkBitmap& bitmap);
 
     /**
      * Writes the summary (as constructed so far) to a file.
      *
@@ skipping 41 matching lines @@
     };
 
     SK_COMPILE_ASSERT(!(kMaskFilter_DrawFilterFlag & SkPaint::kAllFlags), maskfilter_flag_must_be_greater);
     SK_COMPILE_ASSERT(!(kHinting_DrawFilterFlag & SkPaint::kAllFlags),
             hinting_flag_must_be_greater);
     SK_COMPILE_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 outputDir The output directory within which this renderer should write files,
+     *     or empty string if this renderer should not write files at all.
+     * @param intputFilename The name of the input file we are rendering.
+     * @param useChecksumBasedFilenames Whether to use checksum-based filenames when writing
+     *     bitmap images to disk.
      */
-    virtual void init(SkPicture* pict);
+    virtual void init(SkPicture* pict, const SkString& outputDir,
+                      const SkString& inputFilename, bool useChecksumBasedFilenames);
 
     /**
      *  Set the viewport so that only the portion listed gets drawn.
      */
     void setViewport(SkISize size) { fViewport = size; }
 
     /**
      *  Set the scale factor at which draw the picture.
      */
     void setScaleFactor(SkScalar scale) { fScaleFactor = scale; }
 
     /**
      * Perform any setup that should done prior to each iteration of render() which should not be
      * timed.
      */
     virtual void setup() {}
 
     /**
-     * Perform work that is to be timed. Typically this is rendering, but is also used for recording
-     * and preparing picture for playback by the subclasses which do those.
-     * If path is non-null, subclass implementations should call write().
-     * @param path If non-null, also write the output to the file specified by path. path should
-     *             have no extension; it will be added by write().
-     * @return bool True if rendering succeeded and, if path is non-null, the output was
-     *             successfully written to a file.
+     * Perform the work.  If this is being called within the context of bench_pictures,
+     * this is the step that will be timed.
+     *
+     * Typically "the work" is rendering an SkPicture into a bitmap, but in some subclasses
+     * it is recording the source SkPicture into another SkPicture.
+     *
+     * If fOutputDir has been specified, 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 fOutputDir had been specified, the output
+     *              was successfully written to a file.
      */
-    virtual bool render(const SkString* path, SkBitmap** out = NULL) = 0;
+    virtual bool render(SkBitmap** out = NULL) = 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.
@@ skipping 217 matching lines @@
 
 #if SK_SUPPORT_GPU
     virtual ~PictureRenderer() {
         SkSafeUnref(fGrContext);
     }
 #endif
 
 protected:
     SkAutoTUnref<SkCanvas> fCanvas;
     SkPicture*             fPicture;
+    bool                   fUseChecksumBasedFilenames;
     ImageResultsSummary*   fJsonSummaryPtr;
     SkDeviceTypes          fDeviceType;
     BBoxHierarchyType      fBBoxHierarchyType;
     DrawFilterFlags        fDrawFilters[SkDrawFilter::kTypeCount];
     SkString               fDrawFiltersConfig;
+    SkString               fOutputDir;
+    SkString               fInputFilename;
     SkTileGridPicture::TileGridInfo fGridInfo; // used when fBBoxHierarchyType is TileGrid
 
     void buildBBoxHierarchy();
 
     /**
      * Return the total width that should be drawn. If the viewport width has been set greater than
      * 0, this will be the minimum of the current SkPicture's width and the viewport's width.
      */
     int getViewWidth();
 
@@ skipping 25 matching lines @@
     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 {
-    virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
     virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
 
     virtual SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
 
 protected:
     virtual SkCanvas* setupCanvas(int width, int height) SK_OVERRIDE;
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE;
 };
 
 class PipePictureRenderer : public PictureRenderer {
 public:
-    virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE;
 
     typedef PictureRenderer INHERITED;
 };
 
 class SimplePictureRenderer : public PictureRenderer {
 public:
-    virtual void init(SkPicture* pict) SK_OVERRIDE;
+    virtual void init(SkPicture* pict, const SkString& outputDir,
+                      const SkString& inputFilename, bool useChecksumBasedFilenames) SK_OVERRIDE;
 
-    virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE;
 
     typedef PictureRenderer INHERITED;
 };
 
 class TiledPictureRenderer : public PictureRenderer {
 public:
     TiledPictureRenderer();
 
-    virtual void init(SkPicture* pict) SK_OVERRIDE;
+    virtual void init(SkPicture* pict, const SkString& outputDir,
+                      const SkString& inputFilename, bool useChecksumBasedFilenames) SK_OVERRIDE;
 
     /**
-     * Renders to tiles, rather than a single canvas. If a path is provided, a separate file is
+     * Renders to tiles, rather than a single canvas.
+     * If fOutputDir was provided, a separate file is
      * created for each tile, named "path0.png", "path1.png", etc.
      * Multithreaded mode currently does not support writing to a file.
      */
-    virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
     virtual void end() SK_OVERRIDE;
 
     void setTileWidth(int width) {
         fTileWidth = width;
     }
 
     int getTileWidth() const {
         return fTileWidth;
     }
@@ skipping 95 matching lines @@
 };
 
 class CloneData;
 
 class MultiCorePictureRenderer : public TiledPictureRenderer {
 public:
     explicit MultiCorePictureRenderer(int threadCount);
 
     ~MultiCorePictureRenderer();
 
-    virtual void init(SkPicture* pict) SK_OVERRIDE;
+    virtual void init(SkPicture* pict, const SkString& outputDir,
+                      const SkString& inputFilename, bool useChecksumBasedFilenames) SK_OVERRIDE;
 
     /**
      * Behaves like TiledPictureRenderer::render(), only using multiple threads.
      */
-    virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
     virtual void end() SK_OVERRIDE;
 
     virtual bool supportsTimingIndividualTiles() SK_OVERRIDE { return false; }
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE;
 
     const int            fNumThreads;
     SkTDArray<SkCanvas*> fCanvasPool;
     SkThreadPool         fThreadPool;
     SkPicture*           fPictureClones;
     CloneData**          fCloneData;
     SkCountdown          fCountdown;
 
     typedef TiledPictureRenderer INHERITED;
 };
 
 /**
  * This class does not do any rendering, but its render function executes turning an SkPictureRecord
  * into an SkPicturePlayback, which we want to time.
  */
 class PlaybackCreationRenderer : public PictureRenderer {
 public:
     virtual void setup() SK_OVERRIDE;
 
-    virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE;
 
     virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
 
     virtual SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
 
 private:
     SkAutoTUnref<SkPicture> fReplayer;
 
     virtual SkString getConfigNameInternal() SK_OVERRIDE;
 
     typedef PictureRenderer INHERITED;
 };
 
 extern PictureRenderer* CreateGatherPixelRefsRenderer();
 extern PictureRenderer* CreatePictureCloneRenderer();
 
 }
 
 #endif  // PictureRenderer_DEFINED