SkRecord refactor: fill bounds array instead of BBH directly

src/core/SkRecordDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
@@ skipping 132 matching lines @@
 // non-drawing ("control") ops inside are exactly the union of the bounds of
 // the drawing ops inside that block.
 //
 // To implement this, we keep a stack of active Save blocks.  As we consume ops
 // inside the Save/Restore block, drawing ops are unioned with the bounds of
 // the block, and control ops are stashed away for later.  When we finish the
 // block with a Restore, our bounds are complete, and we go back and fill them
 // in for all the control ops we stashed away.
 class FillBounds : SkNoncopyable {
 public:
-    FillBounds(const SkRect& cullRect, const SkRecord& record)
+    FillBounds(const SkRect& cullRect, const SkRecord& record, SkRect bounds[])
         : fNumRecords(record.count())
         , fCullRect(cullRect)
-        , fBounds(record.count())
-    {
-        // Calculate bounds for all ops.  This won't go quite in order, so we'll need
-        // to store the bounds separately then feed them in to the BBH later in order.
+        , fBounds(bounds) {
         fCTM = &SkMatrix::I();
         fCurrentClipBounds = fCullRect;
     }
 
-    void setCurrentOp(int currentOp) { fCurrentOp = currentOp; }
-
-    void cleanUp(SkBBoxHierarchy* bbh) {
+    void cleanUp() {
         // If we have any lingering unpaired Saves, simulate restores to make
         // sure all ops in those Save blocks have their bounds calculated.
         while (!fSaveStack.isEmpty()) {
             this->popSaveBlock();
         }
 
         // Any control ops not part of any Save/Restore block draw everywhere.
         while (!fControlIndices.isEmpty()) {
             this->popControl(fCullRect);
         }
+    }
 
-        // Finally feed all stored bounds into the BBH.  They'll be returned in this order.
-        if (bbh) {
-            bbh->insert(fBounds.get(), fNumRecords);
-        }
-    }
+    void setCurrentOp(int currentOp) { fCurrentOp = currentOp; }
+
 
     template <typename T> void operator()(const T& op) {
         this->updateCTM(op);
         this->updateClipBounds(op);
         this->trackBounds(op);
     }
 
     // In this file, SkRect are in local coordinates, Bounds are translated back to identity space.
     typedef SkRect Bounds;
 
@@ skipping 380 matching lines @@
         }
         return true;
     }
 
     const int fNumRecords;
 
     // We do not guarantee anything for operations outside of the cull rect
     const SkRect fCullRect;
 
     // Conservative identity-space bounds for each op in the SkRecord.
-    SkAutoTMalloc<Bounds> fBounds;
+    Bounds* fBounds;
 
     // We walk fCurrentOp through the SkRecord, as we go using updateCTM()
     // and updateClipBounds() to maintain the exact CTM (fCTM) and conservative
     // identity-space bounds of the current clip (fCurrentClipBounds).
     int fCurrentOp;
     const SkMatrix* fCTM;
     Bounds fCurrentClipBounds;
 
     // Used to track the bounds of Save/Restore blocks and the control ops inside them.
     SkTDArray<SaveBounds> fSaveStack;
     SkTDArray<int>   fControlIndices;
 };
 
 // SkRecord visitor to gather saveLayer/restore information.
 class CollectLayers : SkNoncopyable {
 public:
-    CollectLayers(const SkRect& cullRect, const SkRecord& record,
+    CollectLayers(const SkRect& cullRect, const SkRecord& record, SkRect bounds[],
                   const SkBigPicture::SnapshotArray* pictList, SkLayerInfo* accelData)
         : fSaveLayersInStack(0)
         , fAccelData(accelData)
         , fPictList(pictList)
-        , fFillBounds(cullRect, record)
+        , fFillBounds(cullRect, record, bounds)
     {}
 
-    void setCurrentOp(int currentOp) { fFillBounds.setCurrentOp(currentOp); }
-
-    void cleanUp(SkBBoxHierarchy* bbh) {
+    void cleanUp() {
         // fFillBounds must perform its cleanUp first so that all the bounding
         // boxes associated with unbalanced restores are updated (prior to
         // fetching their bound in popSaveLayerInfo).
-        fFillBounds.cleanUp(bbh);
-
+        fFillBounds.cleanUp();
         while (!fSaveLayerStack.isEmpty()) {
             this->popSaveLayerInfo();
         }
     }
 
+    void setCurrentOp(int currentOp) { fFillBounds.setCurrentOp(currentOp); }
+
+
     template <typename T> void operator()(const T& op) {
         fFillBounds(op);
         this->trackSaveLayers(op);
     }
 
 private:
     struct SaveLayerInfo {
         SaveLayerInfo() { }
         SaveLayerInfo(int opIndex, bool isSaveLayer, const SkRect* bounds, const SkPaint* paint)
             : fStartIndex(opIndex)
@@ skipping 154 matching lines @@
     // The op code indices of all the currently active saveLayers
     SkTDArray<int>           fSaveLayerOpStack;
     SkLayerInfo*             fAccelData;
     const SkBigPicture::SnapshotArray* fPictList;
 
     SkRecords::FillBounds fFillBounds;
 };
 
 }  // namespace SkRecords
 
-void SkRecordFillBounds(const SkRect& cullRect, const SkRecord& record, SkBBoxHierarchy* bbh) {
-    SkRecords::FillBounds visitor(cullRect, record);
-
+void SkRecordFillBounds(const SkRect& cullRect, const SkRecord& record, SkRect bounds[]) {
+    SkRecords::FillBounds visitor(cullRect, record, bounds);
     for (int curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
-
-    visitor.cleanUp(bbh);
+    visitor.cleanUp();
 }
 
-void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
-                           const SkBigPicture::SnapshotArray* pictList, SkBBoxHierarchy* bbh,
-                           SkLayerInfo* data) {
-    SkRecords::CollectLayers visitor(cullRect, record, pictList, data);
-
+void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record, SkRect bounds[],
+                           const SkBigPicture::SnapshotArray* pictList, SkLayerInfo* data) {
+    SkRecords::CollectLayers visitor(cullRect, record, bounds, pictList, data);
     for (int curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
-
-    visitor.cleanUp(bbh);
+    visitor.cleanUp();
 }