Use SkRRect to store rects 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"
@@ skipping 14 matching lines @@
         fDoAA != element.fDoAA ||
         fSaveCount != element.fSaveCount) {
         return false;
     }
     switch (fType) {
         case kPath_Type:
             return fPath == element.fPath;
         case kRRect_Type:
             return fRRect == element.fRRect;
         case kRect_Type:
-            return fRect == element.fRect;
+            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(fRect);
+            fPath.addRect(this->getRect());
             fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kRRect_Type:
             fPath.reset();
             fPath.addRRect(fRRect);
             fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kPath_Type:
@@ skipping 25 matching lines @@
     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(fRect);
+            path->addRect(this->getRect());
             break;
         case kRRect_Type:
             path->reset();
             path->addRRect(fRRect);
             break;
         case kPath_Type:
             *path = fPath;
             break;
     }
 }
 
 void SkClipStack::Element::setEmpty() {
     fType = kEmpty_Type;
     fFiniteBound.setEmpty();
     fFiniteBoundType = kNormal_BoundsType;
     fIsIntersectionOfRects = false;
-    fRect.setEmpty();
     fRRect.setEmpty();
     fPath.reset();
     fGenID = kEmptyGenID;
     SkDEBUGCODE(this->checkEmpty();)
 }
 
 void SkClipStack::Element::checkEmpty() const {
     SkASSERT(fFiniteBound.isEmpty());
     SkASSERT(kNormal_BoundsType == fFiniteBoundType);
     SkASSERT(!fIsIntersectionOfRects);
@@ skipping 14 matching lines @@
 }
 
 bool SkClipStack::Element::rectRectIntersectAllowed(const SkRect& newR, bool newAA) const {
     SkASSERT(kRect_Type == fType);
 
     if (fDoAA == newAA) {
         // if the AA setting is the same there is no issue
         return true;
     }
 
-    if (!SkRect::Intersects(fRect, newR)) {
+    if (!SkRect::Intersects(this->getRect(), newR)) {
         // The calling code will correctly set the result to the empty clip
         return true;
     }
 
-    if (fRect.contains(newR)) {
+    if (this->getRect().contains(newR)) {
         // if the new rect carves out a portion of the old one there is no
         // issue
         return true;
     }
 
     // So either the two overlap in some complex manner or newR contains oldR.
     // In the first, case the edges will require different AA. In the second,
     // the AA setting that would be carried forward is incorrect (e.g., oldR
     // is AA while newR is BW but since newR contains oldR, oldR will be
     // drawn BW) since the new AA setting will predominate.
@@ skipping 174 matching lines @@
 void SkClipStack::Element::updateBoundAndGenID(const Element* prior) {
     // We set this first here but we may overwrite it later if we determine that the clip is
     // either wide-open or empty.
     fGenID = GetNextGenID();
 
     // First, optimistically update the current Element's bound information
     // with the current clip's bound
     fIsIntersectionOfRects = false;
     switch (fType) {
         case kRect_Type:
-            fFiniteBound = fRect;
+            fFiniteBound = this->getRect();
             fFiniteBoundType = kNormal_BoundsType;
 
             if (SkRegion::kReplace_Op == fOp ||
                 (SkRegion::kIntersect_Op == fOp && NULL == prior) ||
                 (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
-                    prior->rectRectIntersectAllowed(fRect, fDoAA))) {
+                    prior->rectRectIntersectAllowed(this->getRect(), fDoAA))) {
                 fIsIntersectionOfRects = true;
             }
             break;
         case kRRect_Type:
             fFiniteBound = fRRect.getBounds();
             fFiniteBoundType = kNormal_BoundsType;
             break;
         case kPath_Type:
             fFiniteBound = fPath.getBounds();
 
@@ skipping 262 matching lines @@
 
     if (NULL != prior) {
         if (prior->canBeIntersectedInPlace(fSaveCount, element.getOp())) {
             switch (prior->fType) {
                 case Element::kEmpty_Type:
                     SkDEBUGCODE(prior->checkEmpty();)
                     return;
                 case Element::kRect_Type:
                     if (Element::kRect_Type == element.getType()) {
                         if (prior->rectRectIntersectAllowed(element.getRect(), element.isAA())) {
-                            if (!prior->fRect.intersect(element.getRect())) {
+                            SkRect isectRect;
+                            if (!isectRect.intersect(prior->getRect(), element.getRect())) {
                                 prior->setEmpty();
                                 return;
                             }
 
+                            prior->fRRect.setRect(isectRect);
                             prior->fDoAA = element.isAA();
                             Element* priorPrior = (Element*) iter.prev();
                             prior->updateBoundAndGenID(priorPrior);
                             return;
                         }
                         break;
                     }
                     // fallthrough
                 default:
                     if (!SkRect::Intersects(prior->getBounds(), element.getBounds())) {
@@ skipping 142 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();
 }