Modifying the behavior of render_pictures --validate to test the effect of bbh.

tools/render_pictures_main.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 "CopyTilesRenderer.h"
 #include "SkBitmap.h"
 #include "SkBitmapFactory.h"
@@ skipping 17 matching lines @@
 DEFINE_int32(clone, 0, "Clone the picture n times before rendering.");
 DECLARE_bool(deferImageDecoding);
 DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
              "by more than this amount are considered errors, though all diffs are reported. "
              "Requires --validate.");
 DECLARE_string(r);
 DEFINE_string(w, "", "Directory to write the rendered images.");
 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
             "file, instead of an image for each tile.");
 DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
-            "the picture rendered in simple mode.");
+            "the picture rendered in simple mode. When used in conjunction with --bbh, results "
+            "are validated against the picture rendered in the same mode, but without the bbh.");
 
 static void make_output_filepath(SkString* path, const SkString& dir,
                                  const SkString& name) {
     sk_tools::make_filepath(path, dir, name);
     // Remove ".skp"
     path->remove(path->size() - 4, 4);
 }
 
 #include "SkData.h"
 #include "SkLruImageCache.h"
@@ skipping 86 matching lines @@
 static inline int getByte(uint32_t value, int index) {
     SkASSERT(0 <= index && index < 4);
     return (value >> (index * 8)) & 0xFF;
 }
 
 static int MaxByteDiff(uint32_t v1, uint32_t v2) {
     return SkMax32(SkMax32(abs(getByte(v1, 0) - getByte(v2, 0)), abs(getByte(v1, 1) - getByte(v2, 1))),
                    SkMax32(abs(getByte(v1, 2) - getByte(v2, 2)), abs(getByte(v1, 3) - getByte(v2, 3))));
 }
 
+namespace {
+class AutoRestoreBbhType {
+public:
+    AutoRestoreBbhType() {
+        fRenderer = NULL;
+    }
+
+    void set(sk_tools::PictureRenderer* renderer,
+             sk_tools::PictureRenderer::BBoxHierarchyType bbhType) {
+        fRenderer = renderer;
+        fSavedBbhType = renderer->getBBoxHierarchyType();
+        renderer->setBBoxHierarchyType(bbhType);
+    }
+
+    ~AutoRestoreBbhType() {
+        if (NULL != fRenderer) {
+            fRenderer->setBBoxHierarchyType(fSavedBbhType);
+        }
+    }
+
+private:
+    sk_tools::PictureRenderer* fRenderer;
+    sk_tools::PictureRenderer::BBoxHierarchyType fSavedBbhType;
+};
+}
+
 static bool render_picture(const SkString& inputPath, const SkString* outputDir,
                            sk_tools::PictureRenderer& renderer) {
     int diffs[256] = {0};
     SkBitmap* bitmap = NULL;
     bool success = render_picture(inputPath,
         FLAGS_writeWholeImage ? NULL : outputDir,
         renderer,
         FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
 
     if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
         SkDebugf("Failed to draw the picture.\n");
         SkDELETE(bitmap);
         return false;
     }
 
     if (FLAGS_validate) {
         SkBitmap* referenceBitmap = NULL;
-        sk_tools::SimplePictureRenderer referenceRenderer;
-        success = render_picture(inputPath, NULL, referenceRenderer,
+        sk_tools::PictureRenderer* referenceRenderer;
+        // If the renderer uses a BBoxHierarchy, then the reference renderer
+        // will be the same renderer, without the bbh. 
+        AutoRestoreBbhType arbbh;
+        if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
+            renderer.getBBoxHierarchyType()) {
+            referenceRenderer = &renderer;
+            referenceRenderer->ref();  // to match auto unref below
+            arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
+        } else {
+            referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer);
+        }
+        SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
+
+        success = render_picture(inputPath, NULL, *referenceRenderer,
                                  &referenceBitmap);
 
         if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
             SkDebugf("Failed to draw the reference picture.\n");
             SkDELETE(bitmap);
             SkDELETE(referenceBitmap);
             return false;
         }
 
         if (success && (bitmap->width() != referenceBitmap->width())) {
@@ skipping 149 matching lines @@
 #endif
 #endif
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif