Small refactoring of layer discovery code

src/gpu/GrPictureUtils.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 "GrPictureUtils.h"
 
 #include "SkPaintPriv.h"
@@ skipping 11 matching lines @@
 // In practice, this is well large enough, and it has a few extra advantages:
 // it fits in an SkIRect, and we can munge it a little in both SkRect and
 // SKIRect space without worrying about overflow.
 static const SkRect kUnbounded = { -2e9f, -2e9f, 2e9f, 2e9f };
 
 namespace SkRecords {
 
 // SkRecord visitor to gather saveLayer/restore information.
 class CollectLayers : SkNoncopyable {
 public:
-    CollectLayers(const SkPicture* pict, GrAccelData* accelData)
-        : fPictureID(pict->uniqueID())
-        , fSaveLayersInStack(0)
+    CollectLayers(const SkRect& cullRect, const SkRecord& record,
+                  SkBBoxHierarchy* bbh, GrAccelData* accelData)
+        : fSaveLayersInStack(0)
         , fAccelData(accelData) {
 
         // 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.
         fCTM = &SkMatrix::I();
         fCurrentClipBounds = kUnbounded;
 
-        if (NULL == pict->fRecord.get()) {
-            return;
-        }
+        fBounds.reset(record.count());
 
-        fBounds.reset(pict->fRecord->count());
-
-        for (fCurrentOp = 0; fCurrentOp < pict->fRecord->count(); ++fCurrentOp) {
-            pict->fRecord->visit<void>(fCurrentOp, *this);
+        for (fCurrentOp = 0; fCurrentOp < record.count(); ++fCurrentOp) {
+            record.visit<void>(fCurrentOp, *this);
         }
 
         // 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()) {
@@ skipping 357 matching lines @@
         /* most ops aren't involved in saveLayers */
     }
     void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL); }
     void trackSaveLayers(const SaveLayer& sl) {
         this->pushSaveLayerInfo(true, sl.paint);
     }
     void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
     void trackSaveLayers(const DrawPicture& dp) {
         // For sub-pictures, we wrap their layer information within the parent
         // picture's rendering hierarchy
-        const GrAccelData* childData = GPUOptimize(dp.picture);
+        SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
+
+        const GrAccelData* childData = 
+            static_cast<const GrAccelData*>(dp.picture->EXPERIMENTAL_getAccelData(key));
+        if (!childData) {
+            childData = GPUOptimize(dp.picture);
+        }
 
         for (int i = 0; i < childData->numSaveLayers(); ++i) {
             const GrAccelData::SaveLayerInfo& src = childData->saveLayerInfo(i);
 
             Bounds newClip(fCurrentClipBounds);
 
             if (!newClip.intersect(this->adjustAndMap(src.fBounds, dp.paint))) {
                 continue;
             }
 
@@ skipping 132 matching lines @@
     unsigned 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<unsigned>   fControlIndices;
 
     //--------- LAYER HOISTING
     // Used to collect saveLayer information for layer hoisting
-    uint32_t              fPictureID;
     int                   fSaveLayersInStack;
     SkTDArray<SaveLayerInfo> fSaveLayerStack;
     GrAccelData*          fAccelData;
     //--------- LAYER HOISTING
 };
 
 } // namespace SkRecords
 
-// GPUOptimize is only intended to be called within the context of SkGpuDevice's
-// EXPERIMENTAL_optimize method.
+
+void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
+                           SkBBoxHierarchy* bbh, GrAccelData* data) {
+
+    SkRecords::CollectLayers collector(cullRect, record, bbh, data);
+}
+
 const GrAccelData* GPUOptimize(const SkPicture* pict) {
     if (NULL == pict || pict->cullRect().isEmpty()) {
         return NULL;
     }
 
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const GrAccelData* existing = 
                             static_cast<const GrAccelData*>(pict->EXPERIMENTAL_getAccelData(key));
     if (existing) {
         return existing;
     }
 
     SkAutoTUnref<GrAccelData> data(SkNEW_ARGS(GrAccelData, (key)));
 
     pict->EXPERIMENTAL_addAccelData(data);
 
-    SkRecords::CollectLayers collector(pict, data);
+    SkRecordComputeLayers(pict->cullRect(), *pict->fRecord, NULL, data);
 
     return data;
 }