add --writeChecksumBasedFilenames flag to render_pictures

tools/CopyTilesRenderer.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 "picture_utils.h"
 #include "CopyTilesRenderer.h"
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "SkImageEncoder.h"
 #include "SkPicture.h"
 #include "SkPixelRef.h"
 #include "SkRect.h"
 #include "SkString.h"
 
 namespace sk_tools {
     CopyTilesRenderer::CopyTilesRenderer(int x, int y)
     : fXTilesPerLargeTile(x)
     , fYTilesPerLargeTile(y) {
     }
-    void CopyTilesRenderer::init(SkPicture* pict) {
+    void CopyTilesRenderer::init(SkPicture* pict, const SkString& outputDir,
+                                 const SkString& inputFilename, bool useChecksumBasedFilenames) {

[robertphillips, 2014/03/19 14:42:36]

I think this should call INHERITED::init

[epoger, 2014/03/19 15:20:29]

I disagree, but I'm not 100% certain about it.

INHERITED::init() would call fCanvas.reset(this->setupCanvas()), instead of (or
in addition to) fCanvas.reset(this->INHERITED::setupCanvas(fLargeTileWidth,
fLargeTileHeight)), and this init() intentionally avoids allocating a large
canvas.

[robertphillips, 2014/03/19 16:06:50]

You're right. We probably want a comment like the one in
TiledPictureRenderer::init though, i.e.:

// Do not call INHERITED::init(), which would create a (potentially large)
canvas which is not   
// used by bench_pictures.

[epoger, 2014/03/19 16:48:26]

Done.

         SkASSERT(pict != NULL);
         // Only work with absolute widths (as opposed to percentages).
         SkASSERT(this->getTileWidth() != 0 && this->getTileHeight() != 0);
         fPicture = pict;
+        fOutputDir.set(outputDir);
+        fInputFilename.set(inputFilename);
+        fUseChecksumBasedFilenames = useChecksumBasedFilenames;
         fPicture->ref();
         this->buildBBoxHierarchy();
         // In order to avoid allocating a large canvas (particularly important for GPU), create one
         // canvas that is a multiple of the tile size, and draw portions of the picture.
         fLargeTileWidth = fXTilesPerLargeTile * this->getTileWidth();
         fLargeTileHeight = fYTilesPerLargeTile * this->getTileHeight();
         fCanvas.reset(this->INHERITED::setupCanvas(fLargeTileWidth, fLargeTileHeight));
     }
 
-    bool CopyTilesRenderer::render(const SkString* path, SkBitmap** out) {
+    bool CopyTilesRenderer::render(SkBitmap** out) {
         int i = 0;
         bool success = true;
         SkBitmap dst;
         for (int x = 0; x < this->getViewWidth(); x += fLargeTileWidth) {
             for (int y = 0; y < this->getViewHeight(); y += fLargeTileHeight) {
                 SkAutoCanvasRestore autoRestore(fCanvas, true);
                 // Translate so that we draw the correct portion of the picture.
                 // Perform a postTranslate so that the scaleFactor does not interfere with the
                 // positioning.
                 SkMatrix mat(fCanvas->getTotalMatrix());
                 mat.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
                 fCanvas->setMatrix(mat);
                 // Draw the picture
                 fCanvas->drawPicture(*fPicture);
                 // Now extract the picture into tiles
                 const SkBitmap& baseBitmap = fCanvas->getDevice()->accessBitmap(false);
                 SkIRect subset;
                 for (int tileY = 0; tileY < fLargeTileHeight; tileY += this->getTileHeight()) {
                     for (int tileX = 0; tileX < fLargeTileWidth; tileX += this->getTileWidth()) {
                         subset.set(tileX, tileY, tileX + this->getTileWidth(),
                                    tileY + this->getTileHeight());
                         SkDEBUGCODE(bool extracted =)
                         baseBitmap.extractSubset(&dst, subset);
                         SkASSERT(extracted);
-                        if (path != NULL) {
-                            // Similar to writeAppendNumber in PictureRenderer.cpp, but just encodes
+                        if (!fOutputDir.isEmpty()) {
+                            // Similar to write() in PictureRenderer.cpp, but just encodes
                             // a bitmap directly.
-                            SkString pathWithNumber(*path);
+                            // TODO: Share more common code with write() to do this, to properly
+                            // write out the JSON summary, etc.
+                            SkString pathWithNumber;
+                            make_filepath(&pathWithNumber, fOutputDir, fInputFilename);
+                            pathWithNumber.remove(pathWithNumber.size() - 4, 4);
                             pathWithNumber.appendf("%i.png", i++);
                             SkBitmap copy;
 #if SK_SUPPORT_GPU
                             if (isUsingGpuDevice()) {
                                 dst.pixelRef()->readPixels(&copy, &subset);
                             } else {
 #endif
                                 dst.copyTo(&copy);
 #if SK_SUPPORT_GPU
                             }
 #endif
                             success &= SkImageEncoder::EncodeFile(pathWithNumber.c_str(), copy,
                                                                   SkImageEncoder::kPNG_Type, 100);
                         }
                     }
                 }
             }
         }
         return success;
     }
 
     SkString CopyTilesRenderer::getConfigNameInternal() {
         return SkString("copy_tiles");
     }
 }