abstract name of clipping ops, to transtion to a more restricted set

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 "SkAtomics.h"
 #include "SkCanvas.h"
 #include "SkClipStack.h"
@@ skipping 65 matching lines @@
         case kPath_Type:
             visitor->clipPath(this->getPath(), this->getOp(), this->isAA());
             break;
         case kRRect_Type:
             visitor->clipRRect(this->getRRect(), this->getOp(), this->isAA());
             break;
         case kRect_Type:
             visitor->clipRect(this->getRect(), this->getOp(), this->isAA());
             break;
         case kEmpty_Type:
-            visitor->clipRect(kEmptyRect, SkRegion::kIntersect_Op, false);
+            visitor->clipRect(kEmptyRect, SkCanvas::kIntersect_Op, false);
             break;
     }
 }
 
 void SkClipStack::Element::invertShapeFillType() {
     switch (fType) {
         case kRect_Type:
             fPath.init();
             fPath.get()->addRect(this->getRect());
             fPath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kRRect_Type:
             fPath.init();
             fPath.get()->addRRect(fRRect);
             fPath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
             fType = kPath_Type;
             break;
         case kPath_Type:
             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,
+void SkClipStack::Element::initPath(int saveCount, const SkPath& path, SkCanvas::ClipOp op,
                                     bool doAA) {
     if (!path.isInverseFillType()) {
         SkRect r;
         if (path.isRect(&r)) {
             this->initRect(saveCount, r, op, doAA);
             return;
         }
         SkRect ovalRect;
         if (path.isOval(&ovalRect)) {
             SkRRect rrect;
@@ skipping 44 matching lines @@
 
 void SkClipStack::Element::checkEmpty() const {
     SkASSERT(fFiniteBound.isEmpty());
     SkASSERT(kNormal_BoundsType == fFiniteBoundType);
     SkASSERT(!fIsIntersectionOfRects);
     SkASSERT(kEmptyGenID == fGenID);
     SkASSERT(fRRect.isEmpty());
     SkASSERT(!fPath.isValid());
 }
 
-bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkRegion::Op op) const {
+bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkCanvas::ClipOp op) const {
     if (kEmpty_Type == fType &&
-        (SkRegion::kDifference_Op == op || SkRegion::kIntersect_Op == op)) {
+        (SkCanvas::kDifference_Op == op || SkCanvas::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 &&
-            SkRegion::kIntersect_Op == op &&
-            (SkRegion::kIntersect_Op == fOp || SkRegion::kReplace_Op == fOp);
+            SkCanvas::kIntersect_Op == op &&
+            (SkCanvas::kIntersect_Op == fOp || SkCanvas::kReplace_Op == fOp);
 }
 
 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;
     }
 
@@ skipping 193 matching lines @@
     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 = this->getRect();
             fFiniteBoundType = kNormal_BoundsType;
 
-            if (SkRegion::kReplace_Op == fOp ||
-                (SkRegion::kIntersect_Op == fOp && nullptr == prior) ||
-                (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
+            if (SkCanvas::kReplace_Op == fOp ||
+                (SkCanvas::kIntersect_Op == fOp && nullptr == prior) ||
+                (SkCanvas::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.get()->getBounds();
@@ skipping 38 matching lines @@
         combination = (FillCombo) (combination | 0x02);
     }
 
     SkASSERT(kInvPrev_InvCur_FillCombo == combination ||
                 kInvPrev_Cur_FillCombo == combination ||
                 kPrev_InvCur_FillCombo == combination ||
                 kPrev_Cur_FillCombo == combination);
 
     // Now integrate with clip with the prior clips
     switch (fOp) {
-        case SkRegion::kDifference_Op:
+        case SkCanvas::kDifference_Op:
             this->combineBoundsDiff(combination, prevFinite);
             break;
-        case SkRegion::kXOR_Op:
+        case SkCanvas::kXOR_Op:
             this->combineBoundsXOR(combination, prevFinite);
             break;
-        case SkRegion::kUnion_Op:
+        case SkCanvas::kUnion_Op:
             this->combineBoundsUnion(combination, prevFinite);
             break;
-        case SkRegion::kIntersect_Op:
+        case SkCanvas::kIntersect_Op:
             this->combineBoundsIntersection(combination, prevFinite);
             break;
-        case SkRegion::kReverseDifference_Op:
+        case SkCanvas::kReverseDifference_Op:
             this->combineBoundsRevDiff(combination, prevFinite);
             break;
-        case SkRegion::kReplace_Op:
+        case SkCanvas::kReplace_Op:
             // Replace just ignores everything prior
             // The current clip's bound information is already filled in
             // so nothing to do
             break;
         default:
-            SkDebugf("SkRegion::Op error\n");
+            SkDebugf("SkCanvas::ClipOp error\n");
             SkASSERT(0);
             break;
     }
 }
 
 // This constant determines how many Element's are allocated together as a block in
 // the deque. As such it needs to balance allocating too much memory vs.
 // incurring allocation/deallocation thrashing. It should roughly correspond to
 // the deepest save/restore stack we expect to see.
 static const int kDefaultElementAllocCnt = 8;
 
 SkClipStack::SkClipStack()
     : fDeque(sizeof(Element), kDefaultElementAllocCnt)
     , fSaveCount(0) {
 }
 
 SkClipStack::SkClipStack(const SkClipStack& b)
     : fDeque(sizeof(Element), kDefaultElementAllocCnt) {
     *this = b;
 }
 
 SkClipStack::SkClipStack(const SkRect& r)
     : fDeque(sizeof(Element), kDefaultElementAllocCnt)
     , fSaveCount(0) {
     if (!r.isEmpty()) {
-        this->clipDevRect(r, SkRegion::kReplace_Op, false);
+        this->clipDevRect(r, SkCanvas::kReplace_Op, false);
     }
 }
 
 SkClipStack::SkClipStack(const SkIRect& r)
     : fDeque(sizeof(Element), kDefaultElementAllocCnt)
     , fSaveCount(0) {
     if (!r.isEmpty()) {
         SkRect temp;
         temp.set(r);
-        this->clipDevRect(temp, SkRegion::kReplace_Op, false);
+        this->clipDevRect(temp, SkCanvas::kReplace_Op, false);
     }
 }
 
 SkClipStack::~SkClipStack() {
     reset();
 }
 
 SkClipStack& SkClipStack::operator=(const SkClipStack& b) {
     if (this == &b) {
         return *this;
@@ skipping 88 matching lines @@
     if (isIntersectionOfRects) {
         *isIntersectionOfRects = element->fIsIntersectionOfRects;
     }
 }
 
 bool SkClipStack::internalQuickContains(const SkRect& rect) const {
 
     Iter iter(*this, Iter::kTop_IterStart);
     const Element* element = iter.prev();
     while (element != nullptr) {
-        if (SkRegion::kIntersect_Op != element->getOp() && SkRegion::kReplace_Op != element->getOp())
+        if (SkCanvas::kIntersect_Op != element->getOp() && SkCanvas::kReplace_Op != element->getOp())
             return false;
         if (element->isInverseFilled()) {
             // Part of 'rect' could be trimmed off by the inverse-filled clip element
             if (SkRect::Intersects(element->getBounds(), rect)) {
                 return false;
             }
         } else {
             if (!element->contains(rect)) {
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
     }
     return true;
 }
 
 bool SkClipStack::internalQuickContains(const SkRRect& rrect) const {
 
     Iter iter(*this, Iter::kTop_IterStart);
     const Element* element = iter.prev();
     while (element != nullptr) {
-        if (SkRegion::kIntersect_Op != element->getOp() && SkRegion::kReplace_Op != element->getOp())
+        if (SkCanvas::kIntersect_Op != element->getOp() && SkCanvas::kReplace_Op != element->getOp())
             return false;
         if (element->isInverseFilled()) {
             // Part of 'rrect' could be trimmed off by the inverse-filled clip element
             if (SkRect::Intersects(element->getBounds(), rrect.getBounds())) {
                 return false;
             }
         } else {
             if (!element->contains(rrect)) {
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
     }
     return true;
 }
 
 bool SkClipStack::asPath(SkPath *path) const {
     bool isAA = false;
 
     path->reset();
     path->setFillType(SkPath::kInverseEvenOdd_FillType);
 
     SkClipStack::Iter iter(*this, SkClipStack::Iter::kBottom_IterStart);
     while (const SkClipStack::Element* element = iter.next()) {
         SkPath operand;
         if (element->getType() != SkClipStack::Element::kEmpty_Type) {
             element->asPath(&operand);
         }
 
-        SkRegion::Op elementOp = element->getOp();
-        if (elementOp == SkRegion::kReplace_Op) {
+        SkCanvas::ClipOp elementOp = element->getOp();
+        if (elementOp == SkCanvas::kReplace_Op) {
             *path = operand;
         } else {
             Op(*path, operand, (SkPathOp)elementOp, path);
         }
 
         // if the prev and curr clips disagree about aa -vs- not, favor the aa request.
         // perhaps we need an API change to avoid this sort of mixed-signals about
         // clipping.
         isAA = (isAA || element->isAA());
     }
@@ skipping 30 matching lines @@
                         break;
                     }
                     // fallthrough
                 default:
                     if (!SkRect::Intersects(prior->getBounds(), element.getBounds())) {
                         prior->setEmpty();
                         return;
                     }
                     break;
             }
-        } else if (SkRegion::kReplace_Op == element.getOp()) {
+        } else if (SkCanvas::kReplace_Op == element.getOp()) {
             this->restoreTo(fSaveCount - 1);
             prior = (Element*) fDeque.back();
         }
     }
     Element* newElement = new (fDeque.push_back()) Element(element);
     newElement->updateBoundAndGenID(prior);
 }
 
-void SkClipStack::clipDevRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+void SkClipStack::clipDevRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
     Element element(fSaveCount, rrect, op, doAA);
     this->pushElement(element);
 }
 
-void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+void SkClipStack::clipDevRect(const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
     Element element(fSaveCount, rect, op, doAA);
     this->pushElement(element);
 }
 
-void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
+void SkClipStack::clipDevPath(const SkPath& path, SkCanvas::ClipOp op, bool doAA) {
     Element element(fSaveCount, path, op, doAA);
     this->pushElement(element);
 }
 
 void SkClipStack::clipEmpty() {
     Element* element = (Element*) fDeque.back();
 
-    if (element && element->canBeIntersectedInPlace(fSaveCount, SkRegion::kIntersect_Op)) {
+    if (element && element->canBeIntersectedInPlace(fSaveCount, SkCanvas::kIntersect_Op)) {
         element->setEmpty();
     }
     new (fDeque.push_back()) Element(fSaveCount);
 
     ((Element*)fDeque.back())->fGenID = kEmptyGenID;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkClipStack::Iter::Iter() : fStack(nullptr) {
 }
 
 SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
     : fStack(&stack) {
     this->reset(stack, startLoc);
 }
 
 const SkClipStack::Element* SkClipStack::Iter::next() {
     return (const SkClipStack::Element*)fIter.next();
 }
 
 const SkClipStack::Element* SkClipStack::Iter::prev() {
     return (const SkClipStack::Element*)fIter.prev();
 }
 
-const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkRegion::Op op) {
+const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkCanvas::ClipOp op) {
 
     if (nullptr == fStack) {
         return nullptr;
     }
 
     fIter.reset(fStack->fDeque, SkDeque::Iter::kBack_IterStart);
 
     const SkClipStack::Element* element = nullptr;
 
     for (element = (const SkClipStack::Element*) fIter.prev();
@@ skipping 64 matching lines @@
     // it is an rrect.
     int cnt = fDeque.count();
     if (!cnt || cnt > 5) {
         return false;
     }
     const Element* back = static_cast<const Element*>(fDeque.back());
     if (back->getType() != SkClipStack::Element::kRect_Type &&
         back->getType() != SkClipStack::Element::kRRect_Type) {
         return false;
     }
-    if (back->getOp() == SkRegion::kReplace_Op) {
+    if (back->getOp() == SkCanvas::kReplace_Op) {
         *rrect = back->asRRect();
         *aa = back->isAA();
         return true;
     }
 
-    if (back->getOp() == SkRegion::kIntersect_Op) {
+    if (back->getOp() == SkCanvas::kIntersect_Op) {
         SkRect backBounds;
         if (!backBounds.intersect(bounds, back->asRRect().rect())) {
             return false;
         }
         if (cnt > 1) {
             SkDeque::Iter iter(fDeque, SkDeque::Iter::kBack_IterStart);
             SkAssertResult(static_cast<const Element*>(iter.prev()) == back);
             while (const Element* prior = (const Element*)iter.prev()) {
-                if ((prior->getOp() != SkRegion::kIntersect_Op &&
-                     prior->getOp() != SkRegion::kReplace_Op) ||
+                if ((prior->getOp() != SkCanvas::kIntersect_Op &&
+                     prior->getOp() != SkCanvas::kReplace_Op) ||
                     !prior->contains(backBounds)) {
                     return false;
                 }
-                if (prior->getOp() == SkRegion::kReplace_Op) {
+                if (prior->getOp() == SkCanvas::kReplace_Op) {
                     break;
                 }
             }
         }
         *rrect = back->asRRect();
         *aa = back->isAA();
         return true;
     }
     return false;
 }
@@ skipping 31 matching lines @@
     static_assert(SK_ARRAY_COUNT(kTypeStrings) == kTypeCnt, "type_str");
 
     static const char* kOpStrings[] = {
         "difference",
         "intersect",
         "union",
         "xor",
         "reverse-difference",
         "replace",
     };
-    static_assert(0 == SkRegion::kDifference_Op, "op_str");
-    static_assert(1 == SkRegion::kIntersect_Op, "op_str");
-    static_assert(2 == SkRegion::kUnion_Op, "op_str");
-    static_assert(3 == SkRegion::kXOR_Op, "op_str");
-    static_assert(4 == SkRegion::kReverseDifference_Op, "op_str");
-    static_assert(5 == SkRegion::kReplace_Op, "op_str");
+    static_assert(0 == SkCanvas::kDifference_Op, "op_str");
+    static_assert(1 == SkCanvas::kIntersect_Op, "op_str");
+    static_assert(2 == SkCanvas::kUnion_Op, "op_str");
+    static_assert(3 == SkCanvas::kXOR_Op, "op_str");
+    static_assert(4 == SkCanvas::kReverseDifference_Op, "op_str");
+    static_assert(5 == SkCanvas::kReplace_Op, "op_str");
     static_assert(SK_ARRAY_COUNT(kOpStrings) == SkRegion::kOpCnt, "op_str");
 
     SkDebugf("Type: %s, Op: %s, AA: %s, Save Count: %d\n", kTypeStrings[fType],
              kOpStrings[fOp], (fDoAA ? "yes" : "no"), fSaveCount);
     switch (fType) {
         case kEmpty_Type:
             SkDebugf("\n");
             break;
         case kRect_Type:
             this->getRect().dump();
@@ skipping 11 matching lines @@
 
 void SkClipStack::dump() const {
     B2TIter iter(*this);
     const Element* e;
     while ((e = iter.next())) {
         e->dump();
         SkDebugf("\n");
     }
 }
 #endif