Call write() within render_pictures but not bench_pictures

tools/PictureRenderer.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 "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 380 matching lines @@
     SkGPipeWriter writer;
     SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
     pipeCanvas->drawPicture(*fPicture);
     writer.endRecording();
     fCanvas->flush();
     if (NULL != out) {
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, fPicture->width(), fPicture->height());
         fCanvas->readPixels(*out, 0, 0);
     }
-    return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
-                 fUseChecksumBasedFilenames);
+    if (fEnableWrites) {
+        return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
+                     fUseChecksumBasedFilenames);
+    } else {
+        return true;
+    }
 }
 
 SkString PipePictureRenderer::getConfigNameInternal() {
     return SkString("pipe");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void SimplePictureRenderer::init(SkPicture* picture, const SkString* writePath,
                                  const SkString* mismatchPath, const SkString* inputFilename,
                                  bool useChecksumBasedFilenames) {
     INHERITED::init(picture, writePath, mismatchPath, inputFilename, useChecksumBasedFilenames);
     this->buildBBoxHierarchy();
 }
 
 bool SimplePictureRenderer::render(SkBitmap** out) {
     SkASSERT(fCanvas.get() != NULL);
     SkASSERT(NULL != fPicture);
     if (NULL == fCanvas.get() || NULL == fPicture) {
         return false;
     }
 
     fCanvas->drawPicture(*fPicture);
     fCanvas->flush();
     if (NULL != out) {
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, fPicture->width(), fPicture->height());
         fCanvas->readPixels(*out, 0, 0);
     }
-    return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
-                 fUseChecksumBasedFilenames);
+    if (fEnableWrites) {
+        return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
+                     fUseChecksumBasedFilenames);
+    } else {
+        return true;
+    }
 }
 
 SkString SimplePictureRenderer::getConfigNameInternal() {
     return SkString("simple");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 TiledPictureRenderer::TiledPictureRenderer()
     : fTileWidth(kDefaultTileWidth)
@@ skipping 189 matching lines @@
 
     SkBitmap bitmap;
     if (out){
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, fPicture->width(), fPicture->height());
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
     bool success = true;
     for (int i = 0; i < fTileRects.count(); ++i) {
         draw_tile_to_canvas(fCanvas, fTileRects[i], fPicture);
-        success &= write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
-                         fUseChecksumBasedFilenames, &i);
+        if (fEnableWrites) {
+            success &= write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
+                             fUseChecksumBasedFilenames, &i);
+        }
         if (NULL != out) {
             if (fCanvas->readPixels(&bitmap, 0, 0)) {
                 // Add this tile to the entire bitmap.
                 bitmapCopyAtOffset(bitmap, *out, SkScalarFloorToInt(fTileRects[i].left()),
                                    SkScalarFloorToInt(fTileRects[i].top()));
             } else {
                 success = false;
             }
         }
     }
@@ skipping 38 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 // Holds all of the information needed to draw a set of tiles.
 class CloneData : public SkRunnable {
 
 public:
     CloneData(SkPicture* clone, SkCanvas* canvas, SkTDArray<SkRect>& rects, int start, int end,
               SkRunnable* done, ImageResultsAndExpectations* jsonSummaryPtr,
-              bool useChecksumBasedFilenames)
+              bool useChecksumBasedFilenames, bool enableWrites)
         : fClone(clone)
         , fCanvas(canvas)
+        , fEnableWrites(enableWrites)
         , fRects(rects)
         , fStart(start)
         , fEnd(end)
         , fSuccess(NULL)
         , fDone(done)
         , fJsonSummaryPtr(jsonSummaryPtr)
         , fUseChecksumBasedFilenames(useChecksumBasedFilenames) {
         SkASSERT(fDone != NULL);
     }
 
     virtual void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1024 * 1024);
 
         SkBitmap bitmap;
         if (fBitmap != NULL) {
             // All tiles are the same size.
             setup_bitmap(&bitmap, SkScalarFloorToInt(fRects[0].width()), SkScalarFloorToInt(fRects[0].height()));
         }
 
         for (int i = fStart; i < fEnd; i++) {
             draw_tile_to_canvas(fCanvas, fRects[i], fClone);
-            if (!write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
-                       fUseChecksumBasedFilenames, &i)
-                && fSuccess != NULL) {
-                *fSuccess = false;
-                // If one tile fails to write to a file, do not continue drawing the rest.
-                break;
-            }
-            if (fBitmap != NULL) {
-                if (fCanvas->readPixels(&bitmap, 0, 0)) {
-                    SkAutoLockPixels alp(*fBitmap);
-                    bitmapCopyAtOffset(bitmap, fBitmap, SkScalarFloorToInt(fRects[i].left()),
-                                       SkScalarFloorToInt(fRects[i].top()));
-                } else {
+            if (fEnableWrites) {
+                if (!write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
+                           fUseChecksumBasedFilenames, &i)
+                    && fSuccess != NULL) {
                     *fSuccess = false;
-                    // If one tile fails to read pixels, do not continue drawing the rest.
+                    // If one tile fails to write to a file, do not continue drawing the rest.
                     break;
                 }
+                if (fBitmap != NULL) {
+                    if (fCanvas->readPixels(&bitmap, 0, 0)) {
+                        SkAutoLockPixels alp(*fBitmap);
+                        bitmapCopyAtOffset(bitmap, fBitmap, SkScalarFloorToInt(fRects[i].left()),
+                                           SkScalarFloorToInt(fRects[i].top()));
+                    } else {
+                        *fSuccess = false;
+                        // If one tile fails to read pixels, do not continue drawing the rest.
+                        break;
+                    }
+                }
             }
         }
         fDone->run();
     }
 
     void setPathsAndSuccess(const SkString& writePath, const SkString& mismatchPath,
                             const SkString& inputFilename, bool* success) {
         fWritePath.set(writePath);
         fMismatchPath.set(mismatchPath);
         fInputFilename.set(inputFilename);
         fSuccess = success;
     }
 
     void setBitmap(SkBitmap* bitmap) {
         fBitmap = bitmap;
     }
 
 private:
     // All pointers unowned.
     SkPicture*         fClone;      // Picture to draw from. Each CloneData has a unique one which
                                     // is threadsafe.
     SkCanvas*          fCanvas;     // Canvas to draw to. Reused for each tile.
+    bool               fEnableWrites; // TODO(epoger): Temporary hack; see declaration of
+                                      // fEnableWrites in PictureRenderer.h.
     SkString           fWritePath;  // If not empty, write all results into this directory.
     SkString           fMismatchPath;  // If not empty, write all unexpected results into this dir.
     SkString           fInputFilename; // Filename of input SkPicture file.
     SkTDArray<SkRect>& fRects;      // All tiles of the picture.
     const int          fStart;      // Range of tiles drawn by this thread.
     const int          fEnd;
     bool*              fSuccess;    // Only meaningful if path is non-null. Shared by all threads,
                                     // and only set to false upon failure to write to a PNG.
     SkRunnable*        fDone;
     SkBitmap*          fBitmap;
@@ skipping 30 matching lines @@
         if (i == fNumThreads-1) {
             // The last set will use the original SkPicture.
             pic = fPicture;
         } else {
             pic = &fPictureClones[i];
         }
         const int start = i * chunkSize;
         const int end = SkMin32(start + chunkSize, fTileRects.count());
         fCloneData[i] = SkNEW_ARGS(CloneData,
                                    (pic, fCanvasPool[i], fTileRects, start, end, &fCountdown,
-                                    fJsonSummaryPtr, useChecksumBasedFilenames));
+                                    fJsonSummaryPtr, useChecksumBasedFilenames, fEnableWrites));
     }
 }
 
 bool MultiCorePictureRenderer::render(SkBitmap** out) {
     bool success = true;
     if (!fWritePath.isEmpty() || !fMismatchPath.isEmpty()) {
         for (int i = 0; i < fNumThreads-1; i++) {
             fCloneData[i]->setPathsAndSuccess(fWritePath, fMismatchPath, fInputFilename, &success);
         }
     }
@@ skipping 122 matching lines @@
     virtual SkString getConfigNameInternal() SK_OVERRIDE {
         return SkString("picture_clone");
     }
 };
 
 PictureRenderer* CreatePictureCloneRenderer() {
     return SkNEW(PictureCloneRenderer);
 }
 
 } // namespace sk_tools