SkRecord refactor: fill bounds array instead of BBH directly

src/core/SkPictureRecorder.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 "SkBigPicture.h"
 #include "SkData.h"
 #include "SkDrawable.h"
@@ skipping 54 matching lines @@
 
     if (fBBH && (fFlags & kComputeSaveLayerInfo_RecordFlag)) {
         saveLayerData.reset(new SkLayerInfo);
     }
 
     SkDrawableList* drawableList = fRecorder->getDrawableList();
     SkBigPicture::SnapshotArray* pictList =
         drawableList ? drawableList->newDrawableSnapshot() : nullptr;
 
     if (fBBH.get()) {
+        SkAutoTMalloc<SkRect> bounds(fRecord->count());
         if (saveLayerData) {
-            SkRecordComputeLayers(fCullRect, *fRecord, pictList, fBBH.get(), saveLayerData);
+            SkRecordComputeLayers(fCullRect, *fRecord, bounds, pictList, saveLayerData);
         } else {
-            SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
+            SkRecordFillBounds(fCullRect, *fRecord, bounds);
         }
+        fBBH->insert(bounds, fRecord->count());
+
+        // Now that we've calculated content bounds, we can update fCullRect, often trimming it.
+        // TODO: get updated fCullRect from bounds instead of forcing the BBH to return it?
         SkRect bbhBound = fBBH->getRootBound();
         SkASSERT((bbhBound.isEmpty() || fCullRect.contains(bbhBound))
             || (bbhBound.isEmpty() && fCullRect.isEmpty()));
         fCullRect = bbhBound;
     }
 
     size_t subPictureBytes = fRecorder->approxBytesUsedBySubPictures();
     for (int i = 0; pictList && i < pictList->count(); i++) {
         subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
     }
@@ skipping 56 matching lines @@
 
     SkPicture* onNewPictureSnapshot() override {
         SkBigPicture::SnapshotArray* pictList = nullptr;
         if (fDrawableList) {
             // TODO: should we plumb-down the BBHFactory and recordFlags from our host
             //       PictureRecorder?
             pictList = fDrawableList->newDrawableSnapshot();
         }
 
         SkAutoTUnref<SkLayerInfo> saveLayerData;
-
         if (fBBH && fDoSaveLayerInfo) {
+            // TODO: can we avoid work by not allocating / filling these bounds?
+            SkAutoTMalloc<SkRect> scratchBounds(fRecord->count());
             saveLayerData.reset(new SkLayerInfo);
 
-            SkBBoxHierarchy* bbh = nullptr;    // we've already computed fBBH (received in constructor)
-            // TODO: update saveLayer info computation to reuse the already computed
-            // bounds in 'fBBH'
-            SkRecordComputeLayers(fBounds, *fRecord, pictList, bbh, saveLayerData);
+            SkRecordComputeLayers(fBounds, *fRecord, scratchBounds, pictList, saveLayerData);
         }
 
         size_t subPictureBytes = 0;
         for (int i = 0; pictList && i < pictList->count(); i++) {
             subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
         }
         // SkBigPicture will take ownership of a ref on both fRecord and fBBH.
         // We're not willing to give up our ownership, so we must ref them for SkPicture.
         return new SkBigPicture(fBounds, SkRef(fRecord.get()), pictList, SkSafeRef(fBBH.get()),
                                 saveLayerData.detach(), subPictureBytes);
     }
 };
 
 SkDrawable* SkPictureRecorder::endRecordingAsDrawable() {
     fActivelyRecording = false;
     fRecorder->flushMiniRecorder();
     fRecorder->restoreToCount(1);  // If we were missing any restores, add them now.
 
     // TODO: delay as much of this work until just before first playback?
     SkRecordOptimize(fRecord);
 
     if (fBBH.get()) {
-        SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
+        SkAutoTMalloc<SkRect> bounds(fRecord->count());
+        SkRecordFillBounds(fCullRect, *fRecord, bounds);
+        fBBH->insert(bounds, fRecord->count());
     }
 
     SkDrawable* drawable =
             new SkRecordedDrawable(fRecord, fBBH, fRecorder->detachDrawableList(), fCullRect,
                                    SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag));
 
     // release our refs now, so only the drawable will be the owner.
     fRecord.reset(nullptr);
     fBBH.reset(nullptr);
 
     return drawable;
 }