Clean up CollectLayers code

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 "SkRecordDraw.h"
 #include "SkPatchUtils.h"
 
@@ skipping 168 matching lines @@
         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;
 
     unsigned currentOp() const { return fCurrentOp; }
     const SkMatrix& ctm() const { return *fCTM; }
-    const Bounds& currentClipBounds() const { return fCurrentClipBounds; }
     const Bounds& getBounds(unsigned index) const { return fBounds[index]; }
 
     // Adjust rect for all paints that may affect its geometry, then map it to identity space.
     Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const {
         // Inverted rectangles really confuse our BBHs.
         rect.sort();
 
         // Adjust the rect for its own paint.
         if (!AdjustForPaint(paint, &rect)) {
             // The paint could do anything to our bounds.  The only safe answer is the current clip.
@@ skipping 395 matching lines @@
     }
 
     template <typename T> void operator()(const T& op) {
         fFillBounds(op);
         this->trackSaveLayers(op);
     }
 
 private:
     struct SaveLayerInfo {
         SaveLayerInfo() { }
-        SaveLayerInfo(int opIndex, bool isSaveLayer, const SkPaint* paint, 
-                      const FillBounds::Bounds& clipBound)
+        SaveLayerInfo(int opIndex, bool isSaveLayer, const SkPaint* paint)
             : fStartIndex(opIndex)
             , fIsSaveLayer(isSaveLayer)
             , fHasNestedSaveLayer(false)
-            , fPaint(paint)
-            , fClipBound(clipBound) {
+            , fPaint(paint) {
         }
 
         int                fStartIndex;
         bool               fIsSaveLayer;
         bool               fHasNestedSaveLayer;
         const SkPaint*     fPaint;
-        FillBounds::Bounds fClipBound;
     };
 
     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();
 
         const GrAccelData* childData =
             static_cast<const GrAccelData*>(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);
 
-            FillBounds::Bounds newClip(fFillBounds.currentClipBounds());
-
-            if (!newClip.intersect(fFillBounds.adjustAndMap(src.fBounds, dp.paint))) {
+            FillBounds::Bounds newBound = fFillBounds.adjustAndMap(src.fBounds, dp.paint);
+            if (newBound.isEmpty()) {
                 continue;
             }
 
             this->updateStackForSaveLayer();
 
             GrAccelData::SaveLayerInfo& dst = fAccelData->addSaveLayerInfo();
 
             // 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 = newClip;
+            dst.fBounds = newBound;
             dst.fLocalMat = src.fLocalMat;
             dst.fPreMat = src.fPreMat;
             dst.fPreMat.postConcat(fFillBounds.ctm());
             if (src.fPaint) {
                 dst.fPaint = SkNEW_ARGS(SkPaint, (*src.fPaint));
             }
             dst.fSaveLayerOpID = src.fSaveLayerOpID;
             dst.fRestoreOpID = src.fRestoreOpID;
             dst.fHasNestedLayers = src.fHasNestedLayers;
             dst.fIsNested = fSaveLayersInStack > 0 || src.fIsNested;
@@ skipping 13 matching lines @@
             }
         }
     }
 
     void pushSaveLayerInfo(bool isSaveLayer, const SkPaint* paint) {
         if (isSaveLayer) {
             this->updateStackForSaveLayer();
             ++fSaveLayersInStack;
         }
 
-        fSaveLayerStack.push(SaveLayerInfo(fFillBounds.currentOp(), isSaveLayer, paint, 
-                                           fFillBounds.currentClipBounds()));
+        fSaveLayerStack.push(SaveLayerInfo(fFillBounds.currentOp(), isSaveLayer, paint));
     }
 
     void popSaveLayerInfo() {
         if (fSaveLayerStack.count() <= 0) {
             SkASSERT(false);
             return;
         }
 
         SaveLayerInfo sli;
         fSaveLayerStack.pop(&sli);
 
         if (!sli.fIsSaveLayer) {
             return;
         }
 
         --fSaveLayersInStack;
 
         GrAccelData::SaveLayerInfo& slInfo = fAccelData->addSaveLayerInfo();
 
         SkASSERT(NULL == slInfo.fPicture);  // This layer is in the top-most picture
 
         slInfo.fBounds = fFillBounds.getBounds(sli.fStartIndex);
-        slInfo.fBounds.intersect(sli.fClipBound);
         slInfo.fLocalMat = fFillBounds.ctm();
         slInfo.fPreMat = SkMatrix::I();
         if (sli.fPaint) {
             slInfo.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
         }
         slInfo.fSaveLayerOpID = sli.fStartIndex;
         slInfo.fRestoreOpID = fFillBounds.currentOp();
         slInfo.fHasNestedLayers = sli.fHasNestedSaveLayer;
         slInfo.fIsNested = fSaveLayersInStack > 0;
     }
@@ skipping 27 matching lines @@
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }
 #endif