Rename GrAccelData to SkLayerInfo and move it to src/core

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"
 
-#if SK_SUPPORT_GPU
-#include "GrPictureUtils.h"
-#endif
-
 void SkRecordDraw(const SkRecord& record,
                   SkCanvas* canvas,
                   const SkBBoxHierarchy* bbh,
                   SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     if (bbh) {
         // Draw only ops that affect pixels in the canvas's current clip.
         // The SkRecord and BBH were recorded in identity space.  This canvas
         // is not necessarily in that same space.  getClipBounds() returns us
@@ skipping 538 matching lines @@
     // identity-space bounds of the current clip (fCurrentClipBounds).
     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;
 };
 
-#if SK_SUPPORT_GPU
 // SkRecord visitor to gather saveLayer/restore information.
 class CollectLayers : SkNoncopyable {
 public:
-    CollectLayers(const SkRect& cullRect, const SkRecord& record, GrAccelData* accelData)
+    CollectLayers(const SkRect& cullRect, const SkRecord& record, SkLayerInfo* accelData)
         : fSaveLayersInStack(0)
         , fAccelData(accelData)
         , fFillBounds(cullRect, record) {
     }
 
     void setCurrentOp(unsigned currentOp) { fFillBounds.setCurrentOp(currentOp); }
 
     void cleanUp(SkBBoxHierarchy* bbh) {
         // fFillBounds must perform its cleanUp first so that all the bounding
         // boxes associated with unbalanced restores are updated (prior to
@@ skipping 29 matching lines @@
     template <typename T> void trackSaveLayers(const T& op) {
         /* 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
-        SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
+        SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
 
-        const GrAccelData* childData =
-            static_cast<const GrAccelData*>(dp.picture->EXPERIMENTAL_getAccelData(key));
+        const SkLayerInfo* childData =
+            static_cast<const SkLayerInfo*>(dp.picture->EXPERIMENTAL_getAccelData(key));
         if (!childData) {
             // If the child layer hasn't been generated with saveLayer data we
             // assume the worst (i.e., that it does contain layers which nest
             // inside existing layers). Layers within sub-pictures that don't
             // have saveLayer data cannot be hoisted.
             // TODO: could the analysis data be use to fine tune this?
             this->updateStackForSaveLayer();
             return;
         }
 
-        for (int i = 0; i < childData->numSaveLayers(); ++i) {
-            const GrAccelData::SaveLayerInfo& src = childData->saveLayerInfo(i);
+        for (int i = 0; i < childData->numBlocks(); ++i) {
+            const SkLayerInfo::BlockInfo& src = childData->block(i);
 
             FillBounds::Bounds newBound = fFillBounds.adjustAndMap(src.fBounds, dp.paint);
             if (newBound.isEmpty()) {
                 continue;
             }
 
             this->updateStackForSaveLayer();
 
-            GrAccelData::SaveLayerInfo& dst = fAccelData->addSaveLayerInfo();
+            SkLayerInfo::BlockInfo& dst = fAccelData->addBlock();
 
             // If src.fPicture is NULL the layer is in dp.picture; otherwise
             // it belongs to a sub-picture.
             dst.fPicture = src.fPicture ? src.fPicture : static_cast<const SkPicture*>(dp.picture);
             dst.fPicture->ref();
             dst.fBounds = newBound;
             dst.fLocalMat = src.fLocalMat;
             dst.fPreMat = src.fPreMat;
             dst.fPreMat.postConcat(fFillBounds.ctm());
             if (src.fPaint) {
@@ skipping 37 matching lines @@
 
         SaveLayerInfo sli;
         fSaveLayerStack.pop(&sli);
 
         if (!sli.fIsSaveLayer) {
             return;
         }
 
         --fSaveLayersInStack;
 
-        GrAccelData::SaveLayerInfo& slInfo = fAccelData->addSaveLayerInfo();
+        SkLayerInfo::BlockInfo& block = fAccelData->addBlock();
 
-        SkASSERT(NULL == slInfo.fPicture);  // This layer is in the top-most picture
+        SkASSERT(NULL == block.fPicture);  // This layer is in the top-most picture
 
-        slInfo.fBounds = fFillBounds.getBounds(sli.fStartIndex);
-        slInfo.fLocalMat = fFillBounds.ctm();
-        slInfo.fPreMat = SkMatrix::I();
+        block.fBounds = fFillBounds.getBounds(sli.fStartIndex);
+        block.fLocalMat = fFillBounds.ctm();
+        block.fPreMat = SkMatrix::I();
         if (sli.fPaint) {
-            slInfo.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
+            block.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
         }
-        slInfo.fSaveLayerOpID = sli.fStartIndex;
-        slInfo.fRestoreOpID = fFillBounds.currentOp();
-        slInfo.fHasNestedLayers = sli.fHasNestedSaveLayer;
-        slInfo.fIsNested = fSaveLayersInStack > 0;
+        block.fSaveLayerOpID = sli.fStartIndex;
+        block.fRestoreOpID = fFillBounds.currentOp();
+        block.fHasNestedLayers = sli.fHasNestedSaveLayer;
+        block.fIsNested = fSaveLayersInStack > 0;
     }
 
     // Used to collect saveLayer information for layer hoisting
     int                   fSaveLayersInStack;
     SkTDArray<SaveLayerInfo> fSaveLayerStack;
-    GrAccelData*          fAccelData;
+    SkLayerInfo*          fAccelData;
 
     SkRecords::FillBounds fFillBounds;
 };
-#endif
 
 }  // namespace SkRecords
 
 void SkRecordFillBounds(const SkRect& cullRect, const SkRecord& record, SkBBoxHierarchy* bbh) {
     SkRecords::FillBounds visitor(cullRect, record);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }
 
-#if SK_SUPPORT_GPU
 void SkRecordComputeLayers(const SkRect& cullRect, const SkRecord& record,
-                           SkBBoxHierarchy* bbh, GrAccelData* data) {
+                           SkBBoxHierarchy* bbh, SkLayerInfo* data) {
     SkRecords::CollectLayers visitor(cullRect, record, data);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }
-#endif