Use SkTLazy to hold path in SkClipStack::Element

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
 
 #include "SkDeque.h"
 #include "SkPath.h"
 #include "SkRect.h"
 #include "SkRRect.h"
 #include "SkRegion.h"
 #include "SkTDArray.h"
+#include "SkTLazy.h"
 
 
 // Because a single save/restore state can have multiple clips, this class
 // stores the stack depth (fSaveCount) and clips (fDeque) separately.
 // Each clip in fDeque stores the stack state to which it belongs
 // (i.e., the fSaveCount in force when it was added). Restores are thus
 // implemented by removing clips from fDeque that have an fSaveCount larger
 // then the freshly decremented count.
 class SK_API SkClipStack {
 public:
@@ skipping 19 matching lines @@
             kRRect_Type,
             //!< This element combines a path with the current clip using a set operation
             kPath_Type,
         };
 
         Element() {
             this->initCommon(0, SkRegion::kReplace_Op, false);
             this->setEmpty();
         }
 
+        Element(const Element&);
+
         Element(const SkRect& rect, SkRegion::Op op, bool doAA) {
             this->initRect(0, rect, op, doAA);
         }
 
         Element(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
             this->initRRect(0, rrect, op, doAA);
         }
 
         Element(const SkPath& path, SkRegion::Op op, bool doAA) {
             this->initPath(0, path, op, doAA);
         }
 
         bool operator== (const Element& element) const;
         bool operator!= (const Element& element) const { return !(*this == element); }
 
         //!< Call to get the type of the clip element.
         Type getType() const { return fType; }
 
         //!< Call if getType() is kPath to get the path.
-        const SkPath& getPath() const { SkASSERT(kPath_Type == fType); return fPath; }
+        const SkPath& getPath() const { SkASSERT(kPath_Type == fType); return *fPath.get(); }
 
         //!< Call if getType() is kRRect to get the round-rect.
         const SkRRect& getRRect() const { SkASSERT(kRRect_Type == fType); return fRRect; }
 
         //!< Call if getType() is kRect to get the rect.
         const SkRect& getRect() const {
             SkASSERT(kRect_Type == fType && (fRRect.isRect() || fRRect.isEmpty()));
             return fRRect.getBounds();
         }
 
@@ skipping 24 matching lines @@
          * 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:  // fallthrough
                 case kRRect_Type:
                     return fRRect.getBounds();
                 case kPath_Type:
-                    return fPath.getBounds();
+                    return fPath.get()->getBounds();
                 case kEmpty_Type:
                     return kEmpty;
                 default:
                     SkDEBUGFAIL("Unexpected type.");
                     return kEmpty;
             }
         }
 
         /**
          * Conservatively checks whether the clip shape contains the rect param. (Whether the shape
          * is inverse filled is not considered.)
          */
         bool contains(const SkRect& rect) const {
             switch (fType) {
                 case kRect_Type:
                     return this->getRect().contains(rect);
                 case kRRect_Type:
                     return fRRect.contains(rect);
                 case kPath_Type:
-                    return fPath.conservativelyContainsRect(rect);
+                    return fPath.get()->conservativelyContainsRect(rect);
                 case kEmpty_Type:
                     return false;
                 default:
                     SkDEBUGFAIL("Unexpected type.");
                     return false;
             }
         }
 
         /**
          * Is the clip shape inverse filled.
          */
         bool isInverseFilled() const {
-            return kPath_Type == fType && fPath.isInverseFillType();
+            return kPath_Type == fType && fPath.get()->isInverseFillType();
         }
 
     private:
         friend class SkClipStack;
 
-        SkPath          fPath;
+        SkTLazy<SkPath> fPath;
         SkRRect         fRRect;
         int             fSaveCount; // save count of stack when this element was added.
         SkRegion::Op    fOp;
         Type            fType;
         bool            fDoAA;
 
         /* fFiniteBoundType and fFiniteBound are used to incrementally update the clip stack's
            bound. When fFiniteBoundType is kNormal_BoundsType, fFiniteBound represents the
            conservative bounding box of the pixels that aren't clipped (i.e., any pixels that can be
            drawn to are inside the bound). When fFiniteBoundType is kInsideOut_BoundsType (which
@@ skipping 269 matching lines @@
      */
     void restoreTo(int saveCount);
 
     /**
      * Return the next unique generation ID.
      */
     static int32_t GetNextGenID();
 };
 
 #endif