Revert "Avoid re-rendering stencil clip for every draw with reducable clip stack"

src/core/SkClipStack.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkClipStack.h"
 #include "SkPath.h"
 #include "SkThread.h"
@@ skipping 434 matching lines @@
     fSaveCount -= 1;
     restoreTo(fSaveCount);
 }
 
 void SkClipStack::restoreTo(int saveCount) {
     while (!fDeque.empty()) {
         Element* element = (Element*)fDeque.back();
         if (element->fSaveCount <= saveCount) {
             break;
         }
+        this->purgeClip(element);
         element->~Element();
         fDeque.pop_back();
     }
 }
 
 void SkClipStack::getBounds(SkRect* canvFiniteBound,
                             BoundsType* boundType,
                             bool* isIntersectionOfRects) const {
     SkASSERT(NULL != canvFiniteBound && NULL != boundType);
 
@@ skipping 67 matching lines @@
     Element* element = (Element*) iter.prev();
 
     if (NULL != element) {
         if (element->canBeIntersectedInPlace(fSaveCount, op)) {
             switch (element->fType) {
                 case Element::kEmpty_Type:
                     element->checkEmpty();
                     return;
                 case Element::kRect_Type:
                     if (element->rectRectIntersectAllowed(rect, doAA)) {
+                        this->purgeClip(element);
                         if (!element->fRect.intersect(rect)) {
                             element->setEmpty();
                             return;
                         }
 
                         element->fDoAA = doAA;
                         Element* prev = (Element*) iter.prev();
                         element->updateBoundAndGenID(prev);
                         return;
                     }
                     break;
                 case Element::kPath_Type:
                     if (!SkRect::Intersects(element->fPath.getBounds(), rect)) {
+                        this->purgeClip(element);
                         element->setEmpty();
                         return;
                     }
                     break;
             }
         } else if (SkRegion::kReplace_Op == op) {
             this->restoreTo(fSaveCount - 1);
             element = (Element*) fDeque.back();
         }
     }
     new (fDeque.push_back()) Element(fSaveCount, rect, op, doAA);
     ((Element*) fDeque.back())->updateBoundAndGenID(element);
+
+    if (element && element->fSaveCount == fSaveCount) {
+        this->purgeClip(element);
+    }
 }
 
 void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     SkRect alt;
     if (path.isRect(&alt) && !path.isInverseFillType()) {
         return this->clipDevRect(alt, op, doAA);
     }
 
     Element* element = (Element*)fDeque.back();
     if (NULL != element) {
         if (element->canBeIntersectedInPlace(fSaveCount, op)) {
             const SkRect& pathBounds = path.getBounds();
             switch (element->fType) {
                 case Element::kEmpty_Type:
                     element->checkEmpty();
                     return;
                 case Element::kRect_Type:
                     if (!SkRect::Intersects(element->fRect, pathBounds)) {
+                        this->purgeClip(element);
                         element->setEmpty();
                         return;
                     }
                     break;
                 case Element::kPath_Type:
                     if (!SkRect::Intersects(element->fPath.getBounds(), pathBounds)) {
+                        this->purgeClip(element);
                         element->setEmpty();
                         return;
                     }
                     break;
             }
         } else if (SkRegion::kReplace_Op == op) {
             this->restoreTo(fSaveCount - 1);
             element = (Element*) fDeque.back();
         }
     }
     new (fDeque.push_back()) Element(fSaveCount, path, op, doAA);
     ((Element*) fDeque.back())->updateBoundAndGenID(element);
+
+    if (element && element->fSaveCount == fSaveCount) {
+        this->purgeClip(element);
+    }
 }
 
 void SkClipStack::clipEmpty() {
 
     Element* element = (Element*) fDeque.back();
 
     if (element && element->canBeIntersectedInPlace(fSaveCount, SkRegion::kIntersect_Op)) {
         switch (element->fType) {
             case Element::kEmpty_Type:
                 element->checkEmpty();
                 return;
             case Element::kRect_Type:
             case Element::kPath_Type:
+                this->purgeClip(element);
                 element->setEmpty();
                 return;
         }
     }
     new (fDeque.push_back()) Element(fSaveCount);
 
+    if (element && element->fSaveCount == fSaveCount) {
+        this->purgeClip(element);
+    }
     ((Element*)fDeque.back())->fGenID = kEmptyGenID;
 }
 
 bool SkClipStack::isWideOpen() const {
-    return this->getTopmostGenID() == kWideOpenGenID;
+    if (0 == fDeque.count()) {
+        return true;
+    }
+
+    const Element* back = (const Element*) fDeque.back();
+    return kWideOpenGenID == back->fGenID ||
+           (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkClipStack::Iter::Iter() : fStack(NULL) {
 }
 
 SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
     : fStack(&stack) {
     this->reset(stack, startLoc);
@@ skipping 73 matching lines @@
     }
 
     // but is converted to device space here
     temp.offset(SkIntToScalar(offsetX), SkIntToScalar(offsetY));
 
     if (!devBounds->intersect(temp)) {
         devBounds->setEmpty();
     }
 }
 
+void SkClipStack::addPurgeClipCallback(PFPurgeClipCB callback, void* data) const {
+    ClipCallbackData temp = { callback, data };
+    fCallbackData.append(1, &temp);
+}
+
+void SkClipStack::removePurgeClipCallback(PFPurgeClipCB callback, void* data) const {
+    ClipCallbackData temp = { callback, data };
+    int index = fCallbackData.find(temp);
+    if (index >= 0) {
+        fCallbackData.removeShuffle(index);
+    }
+}
+
+// The clip state represented by 'element' will never be used again. Purge it.
+void SkClipStack::purgeClip(Element* element) {
+    SkASSERT(NULL != element);
+    if (element->fGenID >= 0 && element->fGenID < kFirstUnreservedGenID) {
+        return;
+    }
+
+    for (int i = 0; i < fCallbackData.count(); ++i) {
+        (*fCallbackData[i].fCallback)(element->fGenID, fCallbackData[i].fData);
+    }
+
+    // Invalidate element's gen ID so handlers can detect already handled records
+    element->fGenID = kInvalidGenID;
+}
+
 int32_t SkClipStack::GetNextGenID() {
     // TODO: handle overflow.
     return sk_atomic_inc(&gGenID);
 }
 
 int32_t SkClipStack::getTopmostGenID() const {
+
     if (fDeque.empty()) {
-        return kWideOpenGenID;
+        return kInvalidGenID;
     }
 
-    const Element* back = static_cast<const Element*>(fDeque.back());
-    if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty()) {
-        return kWideOpenGenID;
-    }
-
-    return back->getGenID();
+    Element* element = (Element*)fDeque.back();
+    return element->fGenID;
 }