Disable the save/clip/restore peephole optimization when a bounding hierarchy is used

src/core/SkPictureRecord.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPictureRecord.h"
 #include "SkTSearch.h"
 #include "SkPixelRef.h"
@@ skipping 504 matching lines @@
     return true;
 }
 
 typedef bool (*PictureRecordOptProc)(SkWriter32* writer, int32_t offset,
                                      SkPaintDictionary* paintDict);
 enum PictureRecordOptType {
     kRewind_OptType,  // Optimization rewinds the command stream
     kCollapseSaveLayer_OptType,  // Optimization eliminates a save/restore pair
 };
 
+enum PictureRecordOptFlags {
+    kSkipIfBBoxHierarchy_Flag = 0x1,  // Optimization should be skipped if the
+                                      // SkPicture has a bounding box hierarchy.
+};
+
 struct PictureRecordOpt {
     PictureRecordOptProc fProc;
     PictureRecordOptType fType;
+    unsigned fFlags;
 };
 /*
  * A list of the optimizations that are tried upon seeing a restore
  * TODO: add a real API for such optimizations
  *       Add the ability to fire optimizations on any op (not just RESTORE)
  */
 static const PictureRecordOpt gPictureRecordOpts[] = {
-    { collapse_save_clip_restore, kRewind_OptType },
-    { remove_save_layer1,         kCollapseSaveLayer_OptType },
-    { remove_save_layer2,         kCollapseSaveLayer_OptType }
+    // 'collapse_save_clip_restore' is skipped if there is a BBoxHierarchy
+    // because it is redundant with the state traversal optimization in
+    // SkPictureStateTree, and applying the optimization introduces significant
+    // record time overhead because it requires rewinding contents that were
+    // recorded into the BBoxHierarchy.
+    { collapse_save_clip_restore, kRewind_OptType, kSkipIfBBoxHierarchy_Flag },
+    { remove_save_layer1,         kCollapseSaveLayer_OptType, 0 },
+    { remove_save_layer2,         kCollapseSaveLayer_OptType, 0 }
 };
 
 // This is called after an optimization has been applied to the command stream
 // in order to adjust the contents and state of the bounding box hierarchy and
 // state tree to reflect the optimization.
 static void apply_optimization_to_bbh(PictureRecordOptType opt, SkPictureStateTree* stateTree,
                                       SkBBoxHierarchy* boundingHierarchy) {
     switch (opt) {
     case kCollapseSaveLayer_OptType:
         if (NULL != stateTree) {
@@ skipping 27 matching lines @@
     }
 
     if (fRestoreOffsetStack.count() == fFirstSavedLayerIndex) {
         fFirstSavedLayerIndex = kNoSavedLayerIndex;
     }
 
     uint32_t initialOffset, size;
     size_t opt = 0;
     if (!(fRecordFlags & SkPicture::kDisableRecordOptimizations_RecordingFlag)) {
         for (opt = 0; opt < SK_ARRAY_COUNT(gPictureRecordOpts); ++opt) {
+            if (0 != (gPictureRecordOpts[opt].fFlags & kSkipIfBBoxHierarchy_Flag)
+                && NULL != fBoundingHierarchy) {
+                continue;
+            }
             if ((*gPictureRecordOpts[opt].fProc)(&fWriter, fRestoreOffsetStack.top(), &fPaints)) {
                 // Some optimization fired so don't add the RESTORE
                 size = 0;
                 initialOffset = fWriter.bytesWritten();
                 apply_optimization_to_bbh(gPictureRecordOpts[opt].fType,
                                           fStateTree, fBoundingHierarchy);
                 break;
             }
         }
     }
@@ skipping 906 matching lines @@
 void SkPictureRecord::validateRegions() const {
     int count = fRegions.count();
     SkASSERT((unsigned) count < 0x1000);
     for (int index = 0; index < count; index++) {
         const SkFlatData* region = fRegions[index];
         SkASSERT(region);
 //        region->validate();
     }
 }
 #endif