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

src/gpu/GrReducedClip.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrReducedClip.h"
 
 #include "GrAppliedClip.h"
@@ skipping 56 matching lines @@
             return;
         }
 
         SkRect tightBounds;
         SkAssertResult(tightBounds.intersect(stackBounds, queryBounds));
         fIBounds = GrClip::GetPixelIBounds(tightBounds);
         SkASSERT(!fIBounds.isEmpty()); // Empty should have been blocked by IsOutsideClip above.
         fHasIBounds = true;
 
         // Implement the clip with an AA rect element.
-        fElements.addToHead(stackBounds, SkRegion::kReplace_Op, true/*doAA*/);
+        fElements.addToHead(stackBounds, SkCanvas::kReplace_Op, true/*doAA*/);
         fElementsGenID = stack.getTopmostGenID();
         fRequiresAA = true;
 
         fInitialState = InitialState::kAllOut;
         return;
     }
 
     SkRect tighterQuery = queryBounds;
     if (SkClipStack::kNormal_BoundsType == stackBoundsType) {
         // Tighten the query by introducing a new clip at the stack's pixel boundaries. (This new
@@ skipping 51 matching lines @@
         }
         if (SkClipStack::kWideOpenGenID == element->getGenID()) {
             initialTriState = InitialTriState::kAllIn;
             break;
         }
 
         bool skippable = false;
         bool isFlip = false; // does this op just flip the in/out state of every point in the bounds
 
         switch (element->getOp()) {
-            case SkRegion::kDifference_Op:
+            case SkCanvas::kDifference_Op:
                 // check if the shape subtracted either contains the entire bounds (and makes
                 // the clip empty) or is outside the bounds and therefore can be skipped.
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     }
                 } else {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         skippable = true;
                     } else if (fWindowRects.count() < maxWindowRectangles && !embiggens &&
                                !element->isAA() && Element::kRect_Type == element->getType()) {
                         this->addWindowRectangle(element->getRect(), false);
                         skippable = true;
                     }
                 }
                 if (!skippable) {
                     emsmallens = true;
                 }
                 break;
-            case SkRegion::kIntersect_Op:
+            case SkCanvas::kIntersect_Op:
                 // check if the shape intersected contains the entire bounds and therefore can
                 // be skipped or it is outside the entire bounds and therefore makes the clip
                 // empty.
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         skippable = true;
                     }
@@ skipping 12 matching lines @@
                         if (!this->intersectIBounds(nonaaRect)) {
                             return;
                         }
                         skippable = true;
                     }
                 }
                 if (!skippable) {
                     emsmallens = true;
                 }
                 break;
-            case SkRegion::kUnion_Op:
+            case SkCanvas::kUnion_Op:
                 // If the union-ed shape contains the entire bounds then after this element
                 // the bounds is entirely inside the clip. If the union-ed shape is outside the
                 // bounds then this op can be skipped.
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         initialTriState = InitialTriState::kAllIn;
                         skippable = true;
                     }
                 } else {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllIn;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         skippable = true;
                     }
                 }
                 if (!skippable) {
                     embiggens = true;
                 }
                 break;
-            case SkRegion::kXOR_Op:
+            case SkCanvas::kXOR_Op:
                 // If the bounds is entirely inside the shape being xor-ed then the effect is
                 // to flip the inside/outside state of every point in the bounds. We may be
                 // able to take advantage of this in the forward pass. If the xor-ed shape
                 // doesn't intersect the bounds then it can be skipped.
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         isFlip = true;
                     }
                 } else {
                     if (element->contains(relaxedQueryBounds)) {
                         isFlip = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         skippable = true;
                     }
                 }
                 if (!skippable) {
                     emsmallens = embiggens = true;
                 }
                 break;
-            case SkRegion::kReverseDifference_Op:
+            case SkCanvas::kReverseDifference_Op:
                 // When the bounds is entirely within the rev-diff shape then this behaves like xor
                 // and reverses every point inside the bounds. If the shape is completely outside
                 // the bounds then we know after this element is applied that the bounds will be
                 // all outside the current clip.B
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         isFlip = true;
                     }
                 } else {
                     if (element->contains(relaxedQueryBounds)) {
                         isFlip = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     }
                 }
                 if (!skippable) {
                     emsmallens = embiggens = true;
                 }
                 break;
 
-            case SkRegion::kReplace_Op:
+            case SkCanvas::kReplace_Op:
                 // Replace will always terminate our walk. We will either begin the forward walk
                 // at the replace op or detect here than the shape is either completely inside
                 // or completely outside the bounds. In this latter case it can be skipped by
                 // setting the correct value for initialTriState.
                 if (element->isInverseFilled()) {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         initialTriState = InitialTriState::kAllIn;
@@ skipping 29 matching lines @@
                 break;
         }
         if (!skippable) {
             if (0 == fElements.count()) {
                 // This will be the last element. Record the stricter genID.
                 fElementsGenID = element->getGenID();
             }
 
             // if it is a flip, change it to a bounds-filling rect
             if (isFlip) {
-                SkASSERT(SkRegion::kXOR_Op == element->getOp() ||
-                         SkRegion::kReverseDifference_Op == element->getOp());
-                fElements.addToHead(SkRect::Make(fIBounds), SkRegion::kReverseDifference_Op, false);
+                SkASSERT(SkCanvas::kXOR_Op == element->getOp() ||
+                         SkCanvas::kReverseDifference_Op == element->getOp());
+                fElements.addToHead(SkRect::Make(fIBounds), SkCanvas::kReverseDifference_Op, false);
             } else {
                 Element* newElement = fElements.addToHead(*element);
                 if (newElement->isAA()) {
                     ++numAAElements;
                 }
                 // Intersecting an inverse shape is the same as differencing the non-inverse shape.
                 // Replacing with an inverse shape is the same as setting initialState=kAllIn and
                 // differencing the non-inverse shape.
-                bool isReplace = SkRegion::kReplace_Op == newElement->getOp();
+                bool isReplace = SkCanvas::kReplace_Op == newElement->getOp();
                 if (newElement->isInverseFilled() &&
-                    (SkRegion::kIntersect_Op == newElement->getOp() || isReplace)) {
+                    (SkCanvas::kIntersect_Op == newElement->getOp() || isReplace)) {
                     newElement->invertShapeFillType();
-                    newElement->setOp(SkRegion::kDifference_Op);
+                    newElement->setOp(SkCanvas::kDifference_Op);
                     if (isReplace) {
                         SkASSERT(InitialTriState::kAllOut == initialTriState);
                         initialTriState = InitialTriState::kAllIn;
                     }
                 }
             }
         }
     }
 
     if ((InitialTriState::kAllOut == initialTriState && !embiggens) ||
         (InitialTriState::kAllIn == initialTriState && !emsmallens)) {
         fElements.reset();
         numAAElements = 0;
     } else {
         Element* element = fElements.headIter().get();
         while (element) {
             bool skippable = false;
             switch (element->getOp()) {
-                case SkRegion::kDifference_Op:
+                case SkCanvas::kDifference_Op:
                     // subtracting from the empty set yields the empty set.
                     skippable = InitialTriState::kAllOut == initialTriState;
                     break;
-                case SkRegion::kIntersect_Op:
+                case SkCanvas::kIntersect_Op:
                     // intersecting with the empty set yields the empty set
                     if (InitialTriState::kAllOut == initialTriState) {
                         skippable = true;
                     } else {
                         // We can clear to zero and then simply draw the clip element.
                         initialTriState = InitialTriState::kAllOut;
-                        element->setOp(SkRegion::kReplace_Op);
+                        element->setOp(SkCanvas::kReplace_Op);
                     }
                     break;
-                case SkRegion::kUnion_Op:
+                case SkCanvas::kUnion_Op:
                     if (InitialTriState::kAllIn == initialTriState) {
                         // unioning the infinite plane with anything is a no-op.
                         skippable = true;
                     } else {
                         // unioning the empty set with a shape is the shape.
-                        element->setOp(SkRegion::kReplace_Op);
+                        element->setOp(SkCanvas::kReplace_Op);
                     }
                     break;
-                case SkRegion::kXOR_Op:
+                case SkCanvas::kXOR_Op:
                     if (InitialTriState::kAllOut == initialTriState) {
                         // xor could be changed to diff in the kAllIn case, not sure it's a win.
-                        element->setOp(SkRegion::kReplace_Op);
+                        element->setOp(SkCanvas::kReplace_Op);
                     }
                     break;
-                case SkRegion::kReverseDifference_Op:
+                case SkCanvas::kReverseDifference_Op:
                     if (InitialTriState::kAllIn == initialTriState) {
                         // subtracting the whole plane will yield the empty set.
                         skippable = true;
                         initialTriState = InitialTriState::kAllOut;
                     } else {
                         // this picks up flips inserted in the backwards pass.
                         skippable = element->isInverseFilled() ?
                             GrClip::IsOutsideClip(element->getBounds(), queryBounds) :
                             element->contains(relaxedQueryBounds);
                         if (skippable) {
                             initialTriState = InitialTriState::kAllIn;
                         } else {
-                            element->setOp(SkRegion::kReplace_Op);
+                            element->setOp(SkCanvas::kReplace_Op);
                         }
                     }
                     break;
-                case SkRegion::kReplace_Op:
+                case SkCanvas::kReplace_Op:
                     skippable = false; // we would have skipped it in the backwards walk if we
                                        // could've.
                     break;
                 default:
                     SkDEBUGFAIL("Unexpected op.");
                     break;
             }
             if (!skippable) {
                 break;
             } else {
                 if (element->isAA()) {
                     --numAAElements;
                 }
                 fElements.popHead();
                 element = fElements.headIter().get();
             }
         }
     }
     fRequiresAA = numAAElements > 0;
 
     SkASSERT(InitialTriState::kUnknown != initialTriState);
     fInitialState = static_cast<GrReducedClip::InitialState>(initialTriState);
 }
 
-static bool element_is_pure_subtract(SkRegion::Op op) {
+static bool element_is_pure_subtract(SkCanvas::ClipOp op) {
     SkASSERT(op >= 0);
-    return op <= SkRegion::kIntersect_Op;
+    return op <= SkCanvas::kIntersect_Op;
 
-    GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
-    GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
+    GR_STATIC_ASSERT(0 == SkCanvas::kDifference_Op);
+    GR_STATIC_ASSERT(1 == SkCanvas::kIntersect_Op);
 }
 
 void GrReducedClip::addInteriorWindowRectangles(int maxWindowRectangles) {
     SkASSERT(fWindowRects.count() < maxWindowRectangles);
     // Walk backwards through the element list and add window rectangles to the interiors of
     // "difference" elements. Quit if we encounter an element that may grow the clip.
     ElementList::Iter iter(fElements, ElementList::Iter::kTail_IterStart);
     for (; iter.get() && element_is_pure_subtract(iter.get()->getOp()); iter.prev()) {
         const Element* element = iter.get();
-        if (SkRegion::kDifference_Op != element->getOp()) {
+        if (SkCanvas::kDifference_Op != element->getOp()) {
             continue;
         }
 
         if (Element::kRect_Type == element->getType()) {
             SkASSERT(element->isAA());
             this->addWindowRectangle(element->getRect(), true);
             if (fWindowRects.count() >= maxWindowRectangles) {
                 return;
             }
             continue;
@@ skipping 70 matching lines @@
                             const SkMatrix& viewMatrix,
                             const SkClipStack::Element* element) {
 
     // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
             break;
         case Element::kRect_Type:
             return dc->drawContextPriv().drawAndStencilRect(clip, ss,
-                                                            element->getOp(),
+                                                            (SkRegion::Op)element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(),
                                                             viewMatrix, element->getRect());
             break;
         default: {
             SkPath path;
             element->asPath(&path);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
 
             return dc->drawContextPriv().drawAndStencilPath(clip, ss,
-                                                            element->getOp(),
+                                                            (SkRegion::Op)element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(), viewMatrix, path);
             break;
         }
     }
 
     return false;
 }
 
 static void draw_element(GrDrawContext* dc,
@@ skipping 38 matching lines @@
     GrColor initialCoverage = InitialState::kAllIn == this->initialState() ? -1 : 0;
     dc->drawContextPriv().clear(clip, initialCoverage, true);
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip space.
     SkMatrix translate;
     translate.setTranslate(SkIntToScalar(-fIBounds.left()), SkIntToScalar(-fIBounds.top()));
 
     // walk through each clip element and perform its set op
     for (ElementList::Iter iter(fElements); iter.get(); iter.next()) {
         const Element* element = iter.get();
-        SkRegion::Op op = element->getOp();
+        SkRegion::Op op = (SkRegion::Op)element->getOp();
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             // draw directly into the result with the stencil set to make the pixels affected
             // by the clip shape be non-zero.
             static constexpr GrUserStencilSettings kStencilInElement(
                  GrUserStencilSettings::StaticInit<
                      0xffff,
                      GrUserStencilTest::kAlways,
                      0xffff,
                      GrUserStencilOp::kReplace,
@@ skipping 93 matching lines @@
     for (ElementList::Iter iter(fElements); iter.get(); iter.next()) {
         const Element* element = iter.get();
         bool useHWAA = element->isAA() && drawContext->isStencilBufferMultisampled();
 
         bool fillInverted = false;
 
         // This will be used to determine whether the clip shape can be rendered into the
         // stencil with arbitrary stencil settings.
         GrPathRenderer::StencilSupport stencilSupport;
 
-        SkRegion::Op op = element->getOp();
+        SkRegion::Op op = (SkRegion::Op)element->getOp();
 
         GrPathRenderer* pr = nullptr;
         SkPath clipPath;
         if (Element::kRect_Type == element->getType()) {
             stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
             fillInverted = false;
         } else {
             element->asPath(&clipPath);
             fillInverted = clipPath.isInverseFillType();
             if (fillInverted) {
@@ skipping 104 matching lines @@
                 // The view matrix is setup to do clip space -> stencil space translation, so
                 // draw rect in clip space.
                 drawContext->drawContextPriv().stencilRect(stencilClip, *pass,
                                                            false, viewMatrix,
                                                            SkRect::Make(fIBounds));
             }
         }
     }
     return true;
 }