Use SkTLazy to hold path in SkClipStack::Element

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"
 
 #include <new>
 
 
 // 0-2 are reserved for invalid, empty & wide-open
 static const int32_t kFirstUnreservedGenID = 3;
 int32_t SkClipStack::gGenID = kFirstUnreservedGenID;
 
+SkClipStack::Element::Element(const Element& that) {
+    switch (that.getType()) {
+        case kEmpty_Type:
+            fPath.reset();
+            break;
+        case kRect_Type: // Rect uses rrect
+        case kRRect_Type:
+            fPath.reset();
+            fRRect = that.fRRect;
+            break;
+        case kPath_Type:
+            fPath.set(that.getPath());
+            break;
+    }
+
+    fSaveCount = that.fSaveCount;
+    fOp = that.fOp;
+    fType = that.fType;
+    fDoAA = that.fDoAA;
+    fFiniteBoundType = that.fFiniteBoundType;
+    fFiniteBound = that.fFiniteBound;
+    fIsIntersectionOfRects = that.fIsIntersectionOfRects;
+    fGenID = that.fGenID;
+}
+
 bool SkClipStack::Element::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;
     }
     switch (fType) {
         case kPath_Type:
-            return fPath == element.fPath;
+            return this->getPath() == element.getPath();
         case kRRect_Type:
             return fRRect == element.fRRect;
         case kRect_Type:
             return this->getRect() == element.getRect();
         case kEmpty_Type:
             return true;
         default:
             SkDEBUGFAIL("Unexpected type.");
             return false;
     }
 }
 
 void SkClipStack::Element::invertShapeFillType() {
     switch (fType) {
         case kRect_Type:
-            fPath.reset();
-            fPath.addRect(this->getRect());
-            fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
+            fPath.init();
+            fPath.get()->addRect(this->getRect());
+            fPath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kRRect_Type:
-            fPath.reset();
-            fPath.addRRect(fRRect);
-            fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
+            fPath.init();
+            fPath.get()->addRRect(fRRect);
+            fPath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kPath_Type:
-            fPath.toggleInverseFillType();
+            fPath.get()->toggleInverseFillType();
             break;
         case kEmpty_Type:
             // Should this set to an empty, inverse filled path?
             break;
     }
 }
 
 void SkClipStack::Element::initPath(int saveCount, const SkPath& path, SkRegion::Op op,
                                     bool doAA) {
     if (!path.isInverseFillType()) {
         if (SkPath::kNone_PathAsRect != path.asRect()) {
             this->initRect(saveCount, path.getBounds(), op, doAA);
             return;
         }
         SkRect ovalRect;
         if (path.isOval(&ovalRect)) {
             SkRRect rrect;
             rrect.setOval(ovalRect);
             this->initRRect(saveCount, rrect, op, doAA);
             return;
         }
     }
-    fPath = path;
+    fPath.set(path);
     fType = kPath_Type;
     this->initCommon(saveCount, op, doAA);
 }
 
 void SkClipStack::Element::asPath(SkPath* path) const {
     switch (fType) {
         case kEmpty_Type:
             path->reset();
             break;
         case kRect_Type:
             path->reset();
             path->addRect(this->getRect());
             break;
         case kRRect_Type:
             path->reset();
             path->addRRect(fRRect);
             break;
         case kPath_Type:
-            *path = fPath;
+            *path = *fPath.get();
             break;
     }
 }
 
 void SkClipStack::Element::setEmpty() {
     fType = kEmpty_Type;
     fFiniteBound.setEmpty();
     fFiniteBoundType = kNormal_BoundsType;
     fIsIntersectionOfRects = false;
     fRRect.setEmpty();
     fPath.reset();
     fGenID = kEmptyGenID;
     SkDEBUGCODE(this->checkEmpty();)
 }
 
 void SkClipStack::Element::checkEmpty() const {
     SkASSERT(fFiniteBound.isEmpty());
     SkASSERT(kNormal_BoundsType == fFiniteBoundType);
     SkASSERT(!fIsIntersectionOfRects);
     SkASSERT(kEmptyGenID == fGenID);
-    SkASSERT(fPath.isEmpty());
+    SkASSERT(!fPath.isValid());
 }
 
 bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkRegion::Op op) const {
     if (kEmpty_Type == fType &&
         (SkRegion::kDifference_Op == op || SkRegion::kIntersect_Op == op)) {
         return true;
     }
     // Only clips within the same save/restore frame (as captured by
     // the save count) can be merged
     return  fSaveCount == saveCount &&
@@ skipping 217 matching lines @@
                 (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
                     prior->rectRectIntersectAllowed(this->getRect(), fDoAA))) {
                 fIsIntersectionOfRects = true;
             }
             break;
         case kRRect_Type:
             fFiniteBound = fRRect.getBounds();
             fFiniteBoundType = kNormal_BoundsType;
             break;
         case kPath_Type:
-            fFiniteBound = fPath.getBounds();
+            fFiniteBound = fPath.get()->getBounds();
 
-            if (fPath.isInverseFillType()) {
+            if (fPath.get()->isInverseFillType()) {
                 fFiniteBoundType = kInsideOut_BoundsType;
             } else {
                 fFiniteBoundType = kNormal_BoundsType;
             }
             break;
         case kEmpty_Type:
             SkDEBUGFAIL("We shouldn't get here with an empty element.");
             break;
     }
 
@@ skipping 420 matching lines @@
         return kWideOpenGenID;
     }
 
     const Element* back = static_cast<const Element*>(fDeque.back());
     if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty()) {
         return kWideOpenGenID;
     }
 
     return back->getGenID();
 }