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

include/core/SkClipStack.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkClipStack_DEFINED
 #define SkClipStack_DEFINED
 
@@ skipping 40 matching lines @@
         }
 
         Element(const SkRect& rect, SkRegion::Op op, bool doAA) {
             this->initRect(0, rect, op, doAA);
         }
 
         Element(const SkPath& path, SkRegion::Op op, bool doAA) {
             this->initPath(0, path, op, doAA);
         }
 
+        //<! Constructor for elements that are not stored in the clip stack.
+        Element(const SkRect& rect, SkRegion::Op op, bool doAA, int32_t genID) {
+            this->initRect(0, rect, op, doAA);
+            fGenID = genID;
+        }
+
         bool operator== (const Element& element) const {
             if (this == &element) {
                 return true;
             }
             if (fOp != element.fOp ||
                 fType != element.fType ||
                 fDoAA != element.fDoAA ||
                 fSaveCount != element.fSaveCount) {
                 return false;
             }
@@ skipping 31 matching lines @@
         void invertShapeFillType();
 
         //!< Sets the set operation represented by the element.
         void setOp(SkRegion::Op op) { fOp = op; }
 
         /** The GenID can be used by clip stack clients to cache representations of the clip. The
             ID corresponds to the set of clip elements up to and including this element within the
             stack not to the element itself. That is the same clip path in different stacks will
             have a different ID since the elements produce different clip result in the context of
             their stacks. */
-        int32_t getGenID() const { return fGenID; }
+        int32_t getGenID() const { SkASSERT(kInvalidGenID != fGenID); return fGenID; }
 
         /**
          * Gets the bounds of the clip element, either the rect or path bounds. (Whether the shape
          * is inverse filled is not considered.)
          */
         const SkRect& getBounds() const {
             static const SkRect kEmpty = { 0, 0, 0, 0 };
             switch (fType) {
                 case kRect_Type:
                     return fRect;
@@ skipping 186 matching lines @@
     // An optimized version of clipDevRect(emptyRect, kIntersect, ...)
     void clipEmpty();
 
     /**
      * isWideOpen returns true if the clip state corresponds to the infinite
      * plane (i.e., draws are not limited at all)
      */
     bool isWideOpen() const;
 
     /**
-     * Add a callback function that will be called whenever a clip state
-     * is no longer viable. This will occur whenever restore
-     * is called or when a clipDevRect or clipDevPath call updates the
-     * clip within an existing save/restore state. Each clip state is
-     * represented by a unique generation ID.
-     */
-    typedef void (*PFPurgeClipCB)(int genID, void* data);
-    void addPurgeClipCallback(PFPurgeClipCB callback, void* data) const;
-
-    /**
-     * Remove a callback added earlier via addPurgeClipCallback
-     */
-    void removePurgeClipCallback(PFPurgeClipCB callback, void* data) const;
-
-    /**
      * The generation ID has three reserved values to indicate special
      * (potentially ignorable) cases
      */
-    static const int32_t kInvalidGenID = 0;
+    static const int32_t kInvalidGenID = 0;     //!< Invalid id that is never returned by
+                                                //!< SkClipStack. Useful when caching clips
+                                                //!< based on GenID.
     static const int32_t kEmptyGenID = 1;       // no pixels writeable
     static const int32_t kWideOpenGenID = 2;    // all pixels writeable
 
     int32_t getTopmostGenID() const;
 
 public:
     class Iter {
     public:
         enum IterStart {
             kBottom_IterStart = SkDeque::Iter::kFront_IterStart,
@@ skipping 85 matching lines @@
     friend class Iter;
 
     SkDeque fDeque;
     int     fSaveCount;
 
     // Generation ID for the clip stack. This is incremented for each
     // clipDevRect and clipDevPath call. 0 is reserved to indicate an
     // invalid ID.
     static int32_t     gGenID;
 
-    struct ClipCallbackData {
-        PFPurgeClipCB   fCallback;
-        void*           fData;
-
-        friend bool operator==(const ClipCallbackData& a,
-                               const ClipCallbackData& b) {
-            return a.fCallback == b.fCallback && a.fData == b.fData;
-        }
-    };
-
-    mutable SkTDArray<ClipCallbackData> fCallbackData;
-
     /**
      * Restore the stack back to the specified save count.
      */
     void restoreTo(int saveCount);
 
     /**
-     * Invoke all the purge callbacks passing in element's generation ID.
-     */
-    void purgeClip(Element* element);
-
-    /**
      * Return the next unique generation ID.
      */
     static int32_t GetNextGenID();
 };
 
 #endif