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

tests/ClipStackTest.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 "Test.h"
 #include "SkClipStack.h"
 #include "SkPath.h"
@@ skipping 15 matching lines @@
 
     // Build up a clip stack with a path, an empty clip, and a rect.
     s.save();
     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
 
     SkPath p;
     p.moveTo(5, 6);
     p.lineTo(7, 8);
     p.lineTo(5, 9);
     p.close();
-    s.clipDevPath(p, SkRegion::kIntersect_Op, doAA);
+    s.clipDevPath(p, SkCanvas::kIntersect_Op, doAA);
 
     s.save();
     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
 
     SkRect r = SkRect::MakeLTRB(1, 2, 3, 4);
-    s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kIntersect_Op, doAA);
     r = SkRect::MakeLTRB(10, 11, 12, 13);
-    s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kIntersect_Op, doAA);
 
     s.save();
     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
 
     r = SkRect::MakeLTRB(14, 15, 16, 17);
-    s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kUnion_Op, doAA);
 
     // Test that assignment works.
     SkClipStack copy = s;
     REPORTER_ASSERT(reporter, s == copy);
 
     // Test that different save levels triggers not equal.
     s.restore();
     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
     REPORTER_ASSERT(reporter, s != copy);
 
     // Test that an equal, but not copied version is equal.
     s.save();
     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
     r = SkRect::MakeLTRB(14, 15, 16, 17);
-    s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kUnion_Op, doAA);
     REPORTER_ASSERT(reporter, s == copy);
 
     // Test that a different op on one level triggers not equal.
     s.restore();
     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
     s.save();
     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
     r = SkRect::MakeLTRB(14, 15, 16, 17);
-    s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kIntersect_Op, doAA);
     REPORTER_ASSERT(reporter, s != copy);
 
     // Test that version constructed with rect-path rather than a rect is still considered equal.
     s.restore();
     s.save();
     SkPath rp;
     rp.addRect(r);
-    s.clipDevPath(rp, SkRegion::kUnion_Op, doAA);
+    s.clipDevPath(rp, SkCanvas::kUnion_Op, doAA);
     REPORTER_ASSERT(reporter, s == copy);
 
     // Test that different rects triggers not equal.
     s.restore();
     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
     s.save();
     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
 
     r = SkRect::MakeLTRB(24, 25, 26, 27);
-    s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
+    s.clipDevRect(r, SkCanvas::kUnion_Op, doAA);
     REPORTER_ASSERT(reporter, s != copy);
 
     // Sanity check
     s.restore();
     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
 
     copy.restore();
     REPORTER_ASSERT(reporter, 2 == copy.getSaveCount());
     REPORTER_ASSERT(reporter, s == copy);
     s.restore();
     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
     copy.restore();
     REPORTER_ASSERT(reporter, 1 == copy.getSaveCount());
     REPORTER_ASSERT(reporter, s == copy);
 
     // Test that different paths triggers not equal.
     s.restore();
     REPORTER_ASSERT(reporter, 0 == s.getSaveCount());
     s.save();
     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
 
     p.addRect(r);
-    s.clipDevPath(p, SkRegion::kIntersect_Op, doAA);
+    s.clipDevPath(p, SkCanvas::kIntersect_Op, doAA);
     REPORTER_ASSERT(reporter, s != copy);
 }
 
 static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
                          int count) {
     SkClipStack::B2TIter iter(stack);
     int counter = 0;
     while (iter.next()) {
         counter += 1;
     }
     REPORTER_ASSERT(reporter, count == counter);
 }
 
 // Exercise the SkClipStack's bottom to top and bidirectional iterators
 // (including the skipToTopmost functionality)
 static void test_iterators(skiatest::Reporter* reporter) {
     SkClipStack stack;
 
     static const SkRect gRects[] = {
         { 0,   0,  40,  40 },
         { 60,  0, 100,  40 },
         { 0,  60,  40, 100 },
         { 60, 60, 100, 100 }
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRects); i++) {
         // the union op will prevent these from being fused together
-        stack.clipDevRect(gRects[i], SkRegion::kUnion_Op, false);
+        stack.clipDevRect(gRects[i], SkCanvas::kUnion_Op, false);
     }
 
     assert_count(reporter, stack, 4);
 
     // bottom to top iteration
     {
         const SkClipStack::Element* element = nullptr;
 
         SkClipStack::B2TIter iter(stack);
         int i;
@@ skipping 20 matching lines @@
 
         SkASSERT(i == -1);
     }
 
     // skipToTopmost
     {
         const SkClipStack::Element* element = nullptr;
 
         SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
 
-        element = iter.skipToTopmost(SkRegion::kUnion_Op);
+        element = iter.skipToTopmost(SkCanvas::kUnion_Op);
         REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
         REPORTER_ASSERT(reporter, element->getRect() == gRects[3]);
     }
 }
 
 // Exercise the SkClipStack's getConservativeBounds computation
 static void test_bounds(skiatest::Reporter* reporter, SkClipStack::Element::Type primType) {
     static const int gNumCases = 20;
     static const SkRect gAnswerRectsBW[gNumCases] = {
         // A op B
@@ skipping 18 matching lines @@
         { 0, 0, 100, 100 },
 
         // invA op invB
         { 0, 0, 100, 100 },
         { 40, 40, 80, 80 },
         { 0, 0, 100, 100 },
         { 10, 10, 80, 80 },
         { 10, 10, 50, 50 },
     };
 
-    static const SkRegion::Op gOps[] = {
-        SkRegion::kIntersect_Op,
-        SkRegion::kDifference_Op,
-        SkRegion::kUnion_Op,
-        SkRegion::kXOR_Op,
-        SkRegion::kReverseDifference_Op
+    static const SkCanvas::ClipOp gOps[] = {
+        SkCanvas::kIntersect_Op,
+        SkCanvas::kDifference_Op,
+        SkCanvas::kUnion_Op,
+        SkCanvas::kXOR_Op,
+        SkCanvas::kReverseDifference_Op
     };
 
     SkRect rectA, rectB;
 
     rectA.iset(10, 10, 50, 50);
     rectB.iset(40, 40, 80, 80);
 
     SkRRect rrectA, rrectB;
     rrectA.setOval(rectA);
     rrectB.setRectXY(rectB, SkIntToScalar(1), SkIntToScalar(2));
@@ skipping 19 matching lines @@
             pathA.setFillType(doInvA ? SkPath::kInverseEvenOdd_FillType :
                                        SkPath::kEvenOdd_FillType);
             pathB.setFillType(doInvB ? SkPath::kInverseEvenOdd_FillType :
                                        SkPath::kEvenOdd_FillType);
 
             switch (primType) {
                 case SkClipStack::Element::kEmpty_Type:
                     SkDEBUGFAIL("Don't call this with kEmpty.");
                     break;
                 case SkClipStack::Element::kRect_Type:
-                    stack.clipDevRect(rectA, SkRegion::kIntersect_Op, false);
+                    stack.clipDevRect(rectA, SkCanvas::kIntersect_Op, false);
                     stack.clipDevRect(rectB, gOps[op], false);
                     break;
                 case SkClipStack::Element::kRRect_Type:
-                    stack.clipDevRRect(rrectA, SkRegion::kIntersect_Op, false);
+                    stack.clipDevRRect(rrectA, SkCanvas::kIntersect_Op, false);
                     stack.clipDevRRect(rrectB, gOps[op], false);
                     break;
                 case SkClipStack::Element::kPath_Type:
-                    stack.clipDevPath(pathA, SkRegion::kIntersect_Op, false);
+                    stack.clipDevPath(pathA, SkCanvas::kIntersect_Op, false);
                     stack.clipDevPath(pathB, gOps[op], false);
                     break;
             }
 
             REPORTER_ASSERT(reporter, !stack.isWideOpen());
             REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
 
             stack.getConservativeBounds(0, 0, 100, 100, &devClipBound,
                                         &isIntersectionOfRects);
 
             if (SkClipStack::Element::kRect_Type == primType) {
                 REPORTER_ASSERT(reporter, isIntersectionOfRects ==
-                        (gOps[op] == SkRegion::kIntersect_Op));
+                        (gOps[op] == SkCanvas::kIntersect_Op));
             } else {
                 REPORTER_ASSERT(reporter, !isIntersectionOfRects);
             }
 
             SkASSERT(testCase < gNumCases);
             REPORTER_ASSERT(reporter, devClipBound == gAnswerRectsBW[testCase]);
             ++testCase;
 
             stack.restore();
         }
@@ skipping 27 matching lines @@
         SkClipStack stack;
 
         SkPath clipA, clipB;
 
         clipA.addRoundRect(rectA, SkIntToScalar(5), SkIntToScalar(5));
         clipA.setFillType(SkPath::kInverseEvenOdd_FillType);
 
         clipB.addRoundRect(rectB, SkIntToScalar(5), SkIntToScalar(5));
         clipB.setFillType(SkPath::kInverseEvenOdd_FillType);
 
-        stack.clipDevPath(clipA, SkRegion::kReplace_Op, false);
-        stack.clipDevPath(clipB, SkRegion::kUnion_Op, false);
+        stack.clipDevPath(clipA, SkCanvas::kReplace_Op, false);
+        stack.clipDevPath(clipB, SkCanvas::kUnion_Op, false);
 
         REPORTER_ASSERT(reporter, stack.isWideOpen());
         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
     }
 
     // Test out union w/ a wide open clip
     {
         SkClipStack stack;
 
-        stack.clipDevRect(rectA, SkRegion::kUnion_Op, false);
+        stack.clipDevRect(rectA, SkCanvas::kUnion_Op, false);
 
         REPORTER_ASSERT(reporter, stack.isWideOpen());
         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
     }
 
     // Test out empty difference from a wide open clip
     {
         SkClipStack stack;
 
         SkRect emptyRect;
         emptyRect.setEmpty();
 
-        stack.clipDevRect(emptyRect, SkRegion::kDifference_Op, false);
+        stack.clipDevRect(emptyRect, SkCanvas::kDifference_Op, false);
 
         REPORTER_ASSERT(reporter, stack.isWideOpen());
         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
     }
 
     // Test out return to wide open
     {
         SkClipStack stack;
 
         stack.save();
 
-        stack.clipDevRect(rectA, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rectA, SkCanvas::kReplace_Op, false);
 
         REPORTER_ASSERT(reporter, !stack.isWideOpen());
         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
 
         stack.restore();
 
         REPORTER_ASSERT(reporter, stack.isWideOpen());
         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
     }
 }
@@ skipping 13 matching lines @@
 }
 
 static void test_rect_inverse_fill(skiatest::Reporter* reporter) {
     // non-intersecting rectangles
     SkRect rect  = SkRect::MakeLTRB(0, 0, 10, 10);
 
     SkPath path;
     path.addRect(rect);
     path.toggleInverseFillType();
     SkClipStack stack;
-    stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+    stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
 
     SkRect bounds;
     SkClipStack::BoundsType boundsType;
     stack.getBounds(&bounds, &boundsType);
     REPORTER_ASSERT(reporter, SkClipStack::kInsideOut_BoundsType == boundsType);
     REPORTER_ASSERT(reporter, bounds == rect);
 }
 
 static void test_rect_replace(skiatest::Reporter* reporter) {
     SkRect rect = SkRect::MakeWH(100, 100);
     SkRect rect2 = SkRect::MakeXYWH(50, 50, 100, 100);
 
     SkRect bound;
     SkClipStack::BoundsType type;
     bool isIntersectionOfRects;
 
     // Adding a new rect with the replace operator should not increase
     // the stack depth. BW replacing BW.
     {
         SkClipStack stack;
         REPORTER_ASSERT(reporter, 0 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 
     // Adding a new rect with the replace operator should not increase
     // the stack depth. AA replacing AA.
     {
         SkClipStack stack;
         REPORTER_ASSERT(reporter, 0 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, true);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, true);
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 
     // Adding a new rect with the replace operator should not increase
     // the stack depth. BW replacing AA replacing BW.
     {
         SkClipStack stack;
         REPORTER_ASSERT(reporter, 0 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, true);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 
     // Make sure replace clip rects don't collapse too much.
     {
         SkClipStack stack;
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
-        stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
+        stack.clipDevRect(rect2, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.save();
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 2 == count(stack));
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
         REPORTER_ASSERT(reporter, bound == rect);
         stack.restore();
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.save();
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 2 == count(stack));
         stack.restore();
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.save();
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
-        stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
+        stack.clipDevRect(rect2, SkCanvas::kIntersect_Op, false);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 2 == count(stack));
         stack.restore();
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 }
 
 // Simplified path-based version of test_rect_replace.
 static void test_path_replace(skiatest::Reporter* reporter) {
     SkRect rect = SkRect::MakeWH(100, 100);
     SkPath path;
     path.addCircle(50, 50, 50);
 
     // Replace operation doesn't grow the stack.
     {
         SkClipStack stack;
         REPORTER_ASSERT(reporter, 0 == count(stack));
-        stack.clipDevPath(path, SkRegion::kReplace_Op, false);
+        stack.clipDevPath(path, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevPath(path, SkRegion::kReplace_Op, false);
+        stack.clipDevPath(path, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 
     // Replacing rect with path.
     {
         SkClipStack stack;
-        stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kReplace_Op, true);
         REPORTER_ASSERT(reporter, 1 == count(stack));
-        stack.clipDevPath(path, SkRegion::kReplace_Op, true);
+        stack.clipDevPath(path, SkCanvas::kReplace_Op, true);
         REPORTER_ASSERT(reporter, 1 == count(stack));
     }
 }
 
 // Test out SkClipStack's merging of rect clips. In particular exercise
 // merging of aa vs. bw rects.
 static void test_rect_merging(skiatest::Reporter* reporter) {
 
     SkRect overlapLeft  = SkRect::MakeLTRB(10, 10, 50, 50);
     SkRect overlapRight = SkRect::MakeLTRB(40, 40, 80, 80);
 
     SkRect nestedParent = SkRect::MakeLTRB(10, 10, 90, 90);
     SkRect nestedChild  = SkRect::MakeLTRB(40, 40, 60, 60);
 
     SkRect bound;
     SkClipStack::BoundsType type;
     bool isIntersectionOfRects;
 
     // all bw overlapping - should merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(overlapLeft, SkCanvas::kReplace_Op, false);
 
-        stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(overlapRight, SkCanvas::kIntersect_Op, false);
 
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, isIntersectionOfRects);
     }
 
     // all aa overlapping - should merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(overlapLeft, SkCanvas::kReplace_Op, true);
 
-        stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, true);
+        stack.clipDevRect(overlapRight, SkCanvas::kIntersect_Op, true);
 
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, isIntersectionOfRects);
     }
 
     // mixed overlapping - should _not_ merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(overlapLeft, SkCanvas::kReplace_Op, true);
 
-        stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(overlapRight, SkCanvas::kIntersect_Op, false);
 
         REPORTER_ASSERT(reporter, 2 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, !isIntersectionOfRects);
     }
 
     // mixed nested (bw inside aa) - should merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, true);
+        stack.clipDevRect(nestedParent, SkCanvas::kReplace_Op, true);
 
-        stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(nestedChild, SkCanvas::kIntersect_Op, false);
 
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, isIntersectionOfRects);
     }
 
     // mixed nested (aa inside bw) - should merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(nestedParent, SkCanvas::kReplace_Op, false);
 
-        stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, true);
+        stack.clipDevRect(nestedChild, SkCanvas::kIntersect_Op, true);
 
         REPORTER_ASSERT(reporter, 1 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, isIntersectionOfRects);
     }
 
     // reverse nested (aa inside bw) - should _not_ merge
     {
         SkClipStack stack;
 
-        stack.clipDevRect(nestedChild, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(nestedChild, SkCanvas::kReplace_Op, false);
 
-        stack.clipDevRect(nestedParent, SkRegion::kIntersect_Op, true);
+        stack.clipDevRect(nestedParent, SkCanvas::kIntersect_Op, true);
 
         REPORTER_ASSERT(reporter, 2 == count(stack));
 
         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 
         REPORTER_ASSERT(reporter, !isIntersectionOfRects);
     }
 }
 
 static void test_quickContains(skiatest::Reporter* reporter) {
     SkRect testRect = SkRect::MakeLTRB(10, 10, 40, 40);
     SkRect insideRect = SkRect::MakeLTRB(20, 20, 30, 30);
     SkRect intersectingRect = SkRect::MakeLTRB(25, 25, 50, 50);
     SkRect outsideRect = SkRect::MakeLTRB(0, 0, 50, 50);
     SkRect nonIntersectingRect = SkRect::MakeLTRB(100, 100, 110, 110);
 
     SkPath insideCircle;
     insideCircle.addCircle(25, 25, 5);
     SkPath intersectingCircle;
     intersectingCircle.addCircle(25, 40, 10);
     SkPath outsideCircle;
     outsideCircle.addCircle(25, 25, 50);
     SkPath nonIntersectingCircle;
     nonIntersectingCircle.addCircle(100, 100, 5);
 
     {
         SkClipStack stack;
-        stack.clipDevRect(outsideRect, SkRegion::kDifference_Op, false);
+        stack.clipDevRect(outsideRect, SkCanvas::kDifference_Op, false);
         // return false because quickContains currently does not care for kDifference_Op
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     // Replace Op tests
     {
         SkClipStack stack;
-        stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(outsideRect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(insideRect, SkCanvas::kIntersect_Op, false);
         stack.save(); // To prevent in-place substitution by replace OP
-        stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(outsideRect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
         stack.restore();
     }
 
     {
         SkClipStack stack;
-        stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(outsideRect, SkCanvas::kIntersect_Op, false);
         stack.save(); // To prevent in-place substitution by replace OP
-        stack.clipDevRect(insideRect, SkRegion::kReplace_Op, false);
+        stack.clipDevRect(insideRect, SkCanvas::kReplace_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
         stack.restore();
     }
 
     // Verify proper traversal of multi-element clip
     {
         SkClipStack stack;
-        stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(insideRect, SkCanvas::kIntersect_Op, false);
         // Use a path for second clip to prevent in-place intersection
-        stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(outsideCircle, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     // Intersect Op tests with rectangles
     {
         SkClipStack stack;
-        stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(outsideRect, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(insideRect, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevRect(intersectingRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(intersectingRect, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevRect(nonIntersectingRect, SkRegion::kIntersect_Op, false);
+        stack.clipDevRect(nonIntersectingRect, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     // Intersect Op tests with circle paths
     {
         SkClipStack stack;
-        stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(outsideCircle, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevPath(insideCircle, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(insideCircle, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevPath(intersectingCircle, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(intersectingCircle, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
-        stack.clipDevPath(nonIntersectingCircle, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(nonIntersectingCircle, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     // Intersect Op tests with inverse filled rectangles
     {
         SkClipStack stack;
         SkPath path;
         path.addRect(outsideRect);
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path;
         path.addRect(insideRect);
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path;
         path.addRect(intersectingRect);
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path;
         path.addRect(nonIntersectingRect);
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
     }
 
     // Intersect Op tests with inverse filled circles
     {
         SkClipStack stack;
         SkPath path = outsideCircle;
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path = insideCircle;
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path = intersectingCircle;
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
     }
 
     {
         SkClipStack stack;
         SkPath path = nonIntersectingCircle;
         path.toggleInverseFillType();
-        stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
+        stack.clipDevPath(path, SkCanvas::kIntersect_Op, false);
         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
     }
 }
 
 static void set_region_to_stack(const SkClipStack& stack, const SkIRect& bounds, SkRegion* region) {
     region->setRect(bounds);
     SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
     while (const SkClipStack::Element *element = iter.next()) {
         SkRegion elemRegion;
         SkRegion boundsRgn(bounds);
         SkPath path;
 
         switch (element->getType()) {
             case SkClipStack::Element::kEmpty_Type:
                 elemRegion.setEmpty();
                 break;
             default:
                 element->asPath(&path);
                 elemRegion.setPath(path, boundsRgn);
                 break;
         }
-        region->op(elemRegion, element->getOp());
+        region->op(elemRegion, (SkRegion::Op)element->getOp());
     }
 }
 
 static void test_invfill_diff_bug(skiatest::Reporter* reporter) {
     SkClipStack stack;
-    stack.clipDevRect({10, 10, 20, 20}, SkRegion::kIntersect_Op, false);
+    stack.clipDevRect({10, 10, 20, 20}, SkCanvas::kIntersect_Op, false);
 
     SkPath path;
     path.addRect({30, 10, 40, 20});
     path.setFillType(SkPath::kInverseWinding_FillType);
-    stack.clipDevPath(path, SkRegion::kDifference_Op, false);
+    stack.clipDevPath(path, SkCanvas::kDifference_Op, false);
 
     REPORTER_ASSERT(reporter, SkClipStack::kEmptyGenID == stack.getTopmostGenID());
 
     SkRect stackBounds;
     SkClipStack::BoundsType stackBoundsType;
     stack.getBounds(&stackBounds, &stackBoundsType);
 
     REPORTER_ASSERT(reporter, stackBounds.isEmpty());
     REPORTER_ASSERT(reporter, SkClipStack::kNormal_BoundsType == stackBoundsType);
 
     SkRegion region;
     set_region_to_stack(stack, {0, 0, 50, 30}, &region);
 
     REPORTER_ASSERT(reporter, region.isEmpty());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 // Functions that add a shape to the clip stack. The shape is computed from a rectangle.
 // AA is always disabled since the clip stack reducer can cause changes in aa rasterization of the
 // stack. A fractional edge repeated in different elements may be rasterized fewer times using the
 // reduced stack.
 typedef void (*AddElementFunc) (const SkRect& rect,
                                 bool invert,
-                                SkRegion::Op op,
+                                SkCanvas::ClipOp op,
                                 SkClipStack* stack,
                                 bool doAA);
 
-static void add_round_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack,
+static void add_round_rect(const SkRect& rect, bool invert, SkCanvas::ClipOp op, SkClipStack* stack,
                            bool doAA) {
     SkScalar rx = rect.width() / 10;
     SkScalar ry = rect.height() / 20;
     if (invert) {
         SkPath path;
         path.addRoundRect(rect, rx, ry);
         path.setFillType(SkPath::kInverseWinding_FillType);
         stack->clipDevPath(path, op, doAA);
     } else {
         SkRRect rrect;
         rrect.setRectXY(rect, rx, ry);
         stack->clipDevRRect(rrect, op, doAA);
     }
 };
 
-static void add_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack,
+static void add_rect(const SkRect& rect, bool invert, SkCanvas::ClipOp op, SkClipStack* stack,
                      bool doAA) {
     if (invert) {
         SkPath path;
         path.addRect(rect);
         path.setFillType(SkPath::kInverseWinding_FillType);
         stack->clipDevPath(path, op, doAA);
     } else {
         stack->clipDevRect(rect, op, doAA);
     }
 };
 
-static void add_oval(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack,
+static void add_oval(const SkRect& rect, bool invert, SkCanvas::ClipOp op, SkClipStack* stack,
                      bool doAA) {
     SkPath path;
     path.addOval(rect);
     if (invert) {
         path.setFillType(SkPath::kInverseWinding_FillType);
     }
     stack->clipDevPath(path, op, doAA);
 };
 
 static void add_elem_to_stack(const SkClipStack::Element& element, SkClipStack* stack) {
@@ skipping 25 matching lines @@
     enum {
         kNumTests = 250,
         kMinElemsPerTest = 1,
         kMaxElemsPerTest = 50,
     };
 
     // min/max size of a clip element as a fraction of kBounds.
     static const SkScalar kMinElemSizeFrac = SK_Scalar1 / 5;
     static const SkScalar kMaxElemSizeFrac = SK_Scalar1;
 
-    static const SkRegion::Op kOps[] = {
-        SkRegion::kDifference_Op,
-        SkRegion::kIntersect_Op,
-        SkRegion::kUnion_Op,
-        SkRegion::kXOR_Op,
-        SkRegion::kReverseDifference_Op,
-        SkRegion::kReplace_Op,
+    static const SkCanvas::ClipOp kOps[] = {
+        SkCanvas::kDifference_Op,
+        SkCanvas::kIntersect_Op,
+        SkCanvas::kUnion_Op,
+        SkCanvas::kXOR_Op,
+        SkCanvas::kReverseDifference_Op,
+        SkCanvas::kReplace_Op,
     };
 
     // Replace operations short-circuit the optimizer. We want to make sure that we test this code
     // path a little bit but we don't want it to prevent us from testing many longer traversals in
     // the optimizer.
     static const int kReplaceDiv = 4 * kMaxElemsPerTest;
 
     // We want to test inverse fills. However, they are quite rare in practice so don't over do it.
     static const SkScalar kFractionInverted = SK_Scalar1 / kMaxElemsPerTest;
 
     static const SkScalar kFractionAntialiased = 0.25;
 
     static const AddElementFunc kElementFuncs[] = {
         add_rect,
         add_round_rect,
         add_oval,
     };
 
     SkRandom r;
 
     for (int i = 0; i < kNumTests; ++i) {
         SkString testCase;
         testCase.printf("Iteration %d", i);
 
         // Randomly generate a clip stack.
         SkClipStack stack;
         int numElems = r.nextRangeU(kMinElemsPerTest, kMaxElemsPerTest);
         bool doAA = r.nextBiasedBool(kFractionAntialiased);
         for (int e = 0; e < numElems; ++e) {
-            SkRegion::Op op = kOps[r.nextULessThan(SK_ARRAY_COUNT(kOps))];
-            if (op == SkRegion::kReplace_Op) {
+            SkCanvas::ClipOp op = kOps[r.nextULessThan(SK_ARRAY_COUNT(kOps))];
+            if (op == SkCanvas::kReplace_Op) {
                 if (r.nextU() % kReplaceDiv) {
                     --e;
                     continue;
                 }
             }
 
             // saves can change the clip stack behavior when an element is added.
             bool doSave = r.nextBool();
 
             SkSize size = SkSize::Make(
@@ skipping 64 matching lines @@
             // whether the result is bounded or not, the whole plane should start outside the clip.
             reducedStack.clipEmpty();
         }
         for (ElementList::Iter iter(reduced->elements()); iter.get(); iter.next()) {
             add_elem_to_stack(*iter.get(), &reducedStack);
         }
 
         SkIRect ibounds = reduced->hasIBounds() ? reduced->ibounds() : kIBounds;
 
         // GrReducedClipStack assumes that the final result is clipped to the returned bounds
-        reducedStack.clipDevRect(ibounds, SkRegion::kIntersect_Op);
-        stack.clipDevRect(ibounds, SkRegion::kIntersect_Op);
+        reducedStack.clipDevRect(ibounds, SkCanvas::kIntersect_Op);
+        stack.clipDevRect(ibounds, SkCanvas::kIntersect_Op);
 
         // convert both the original stack and reduced stack to SkRegions and see if they're equal
         SkRegion region;
         set_region_to_stack(stack, ibounds, &region);
 
         SkRegion reducedRegion;
         set_region_to_stack(reducedStack, ibounds, &reducedRegion);
 
         REPORTER_ASSERT_MESSAGE(reporter, region == reducedRegion, testCase.c_str());
 
         reduced->~GrReducedClip();
     }
 }
 
 #ifdef SK_BUILD_FOR_WIN
     #define SUPPRESS_VISIBILITY_WARNING
 #else
     #define SUPPRESS_VISIBILITY_WARNING __attribute__((visibility("hidden")))
 #endif
 
 static void test_reduced_clip_stack_genid(skiatest::Reporter* reporter) {
     {
         SkClipStack stack;
-        stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op, true);
-        stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkRegion::kReplace_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkCanvas::kReplace_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkCanvas::kReplace_Op, true);
         SkRect bounds = SkRect::MakeXYWH(0, 0, 100, 100);
 
         SkAlignedSTStorage<1, GrReducedClip> storage;
         memset(storage.get(), 0, sizeof(GrReducedClip));
         GR_STATIC_ASSERT(0 == SkClipStack::kInvalidGenID);
         const GrReducedClip* reduced = new (storage.get()) GrReducedClip(stack, bounds);
 
         REPORTER_ASSERT(reporter, reduced->elements().count() == 1);
         // Clips will be cached based on the generation id. Make sure the gen id is valid.
         REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reduced->elementsGenID());
 
         reduced->~GrReducedClip();
     }
     {
         SkClipStack stack;
 
         // Create a clip with following 25.3, 25.3 boxes which are 25 apart:
         //  A  B
         //  C  D
 
-        stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kReplace_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkCanvas::kReplace_Op, true);
         int32_t genIDA = stack.getTopmostGenID();
-        stack.clipDevRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkCanvas::kUnion_Op, true);
         int32_t genIDB = stack.getTopmostGenID();
-        stack.clipDevRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkCanvas::kUnion_Op, true);
         int32_t genIDC = stack.getTopmostGenID();
-        stack.clipDevRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
+        stack.clipDevRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkCanvas::kUnion_Op, true);
         int32_t genIDD = stack.getTopmostGenID();
 
 
 #define IXYWH SkIRect::MakeXYWH
 #define XYWH SkRect::MakeXYWH
 
         SkIRect stackBounds = IXYWH(0, 0, 76, 76);
 
         // The base test is to test each rect in two ways:
         // 1) The box dimensions. (Should reduce to "all in", no elements).
@@ skipping 58 matching lines @@
             REPORTER_ASSERT(reporter, reduced.hasIBounds());
             SkASSERT(reduced.hasIBounds());
             REPORTER_ASSERT(reporter, reduced.ibounds() == testCases[i].clipIRect);
             SkASSERT(reduced.ibounds() == testCases[i].clipIRect);
         }
     }
 }
 
 static void test_reduced_clip_stack_no_aa_crash(skiatest::Reporter* reporter) {
     SkClipStack stack;
-    stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op);
-    stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkRegion::kReplace_Op);
+    stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkCanvas::kReplace_Op);
+    stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkCanvas::kReplace_Op);
     SkRect bounds = SkRect::MakeXYWH(0, 0, 100, 100);
 
     // At the time, this would crash.
     const GrReducedClip reduced(stack, bounds);
     REPORTER_ASSERT(reporter, reduced.elements().isEmpty());
 }
 
 enum class ClipMethod {
     kSkipDraw,
     kIgnoreClip,
@@ skipping 79 matching lines @@
     constexpr SkScalar kMaxScale = 3;
     constexpr int kNumIters = 8;
 
     SkString name;
     SkRandom rand;
 
     for (int i = 0; i < kNumIters; ++i) {
         // Pixel-aligned rect (iior=true).
         name.printf("Pixel-aligned rect test, iter %i", i);
         SkClipStack stack;
-        stack.clipDevRect(alignedRect, SkRegion::kIntersect_Op, true);
+        stack.clipDevRect(alignedRect, SkCanvas::kIntersect_Op, true);
         test_aa_query(reporter, name, stack, m, {IL, IT, IR, IB}, ClipMethod::kIgnoreClip);
         test_aa_query(reporter, name, stack, m, {IL, IT-1, IR, IT}, ClipMethod::kSkipDraw);
         test_aa_query(reporter, name, stack, m, {IL, IT-2, IR, IB}, ClipMethod::kScissor);
 
         // Rect (iior=true).
         name.printf("Rect test, iter %i", i);
         stack.reset();
-        stack.clipDevRect(rect, SkRegion::kIntersect_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kIntersect_Op, true);
         test_aa_query(reporter, name, stack, m, {L, T,  R, B}, ClipMethod::kIgnoreClip);
         test_aa_query(reporter, name, stack, m, {L-.1f, T, L, B}, ClipMethod::kSkipDraw);
         test_aa_query(reporter, name, stack, m, {L-.1f, T, L+.1f, B}, ClipMethod::kAAElements, 1);
 
         // Difference rect (iior=false, inside-out bounds).
         name.printf("Difference rect test, iter %i", i);
         stack.reset();
-        stack.clipDevRect(rect, SkRegion::kDifference_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kDifference_Op, true);
         test_aa_query(reporter, name, stack, m, {L, T, R, B}, ClipMethod::kSkipDraw);
         test_aa_query(reporter, name, stack, m, {L, T-.1f, R, T}, ClipMethod::kIgnoreClip);
         test_aa_query(reporter, name, stack, m, {L, T-.1f, R, T+.1f}, ClipMethod::kAAElements, 1);
 
         // Complex clip (iior=false, normal bounds).
         name.printf("Complex clip test, iter %i", i);
         stack.reset();
-        stack.clipDevRect(rect, SkRegion::kIntersect_Op, true);
-        stack.clipDevRect(innerRect, SkRegion::kXOR_Op, true);
+        stack.clipDevRect(rect, SkCanvas::kIntersect_Op, true);
+        stack.clipDevRect(innerRect, SkCanvas::kXOR_Op, true);
         test_aa_query(reporter, name, stack, m, {l, t, r, b}, ClipMethod::kSkipDraw);
         test_aa_query(reporter, name, stack, m, {r-.1f, t, R, b}, ClipMethod::kAAElements, 1);
         test_aa_query(reporter, name, stack, m, {r-.1f, t, R+.1f, b}, ClipMethod::kAAElements, 2);
         test_aa_query(reporter, name, stack, m, {r, t, R+.1f, b}, ClipMethod::kAAElements, 1);
         test_aa_query(reporter, name, stack, m, {r, t, R, b}, ClipMethod::kIgnoreClip);
         test_aa_query(reporter, name, stack, m, {R, T, R+.1f, B}, ClipMethod::kSkipDraw);
 
         // Complex clip where outer rect is pixel aligned (iior=false, normal bounds).
         name.printf("Aligned Complex clip test, iter %i", i);
         stack.reset();
-        stack.clipDevRect(alignedRect, SkRegion::kIntersect_Op, true);
-        stack.clipDevRect(innerRect, SkRegion::kXOR_Op, true);
+        stack.clipDevRect(alignedRect, SkCanvas::kIntersect_Op, true);
+        stack.clipDevRect(innerRect, SkCanvas::kXOR_Op, true);
         test_aa_query(reporter, name, stack, m, {l, t, r, b}, ClipMethod::kSkipDraw);
         test_aa_query(reporter, name, stack, m, {l, b-.1f, r, IB}, ClipMethod::kAAElements, 1);
         test_aa_query(reporter, name, stack, m, {l, b-.1f, r, IB+.1f}, ClipMethod::kAAElements, 1);
         test_aa_query(reporter, name, stack, m, {l, b, r, IB+.1f}, ClipMethod::kAAElements, 0);
         test_aa_query(reporter, name, stack, m, {l, b, r, IB}, ClipMethod::kIgnoreClip);
         test_aa_query(reporter, name, stack, m, {IL, IB, IR, IB+.1f}, ClipMethod::kSkipDraw);
 
         // Apply random transforms and try again. This ensures the clip stack reduction is hardened
         // against FP rounding error.
         SkScalar sx = rand.nextRangeScalar(kMinScale, kMaxScale);
@@ skipping 20 matching lines @@
     REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
     assert_count(reporter, stack, 0);
 
     static const SkIRect gRects[] = {
         { 0, 0, 100, 100 },
         { 25, 25, 125, 125 },
         { 0, 0, 1000, 1000 },
         { 0, 0, 75, 75 }
     };
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRects); i++) {
-        stack.clipDevRect(gRects[i], SkRegion::kIntersect_Op);
+        stack.clipDevRect(gRects[i], SkCanvas::kIntersect_Op);
     }
 
     // all of the above rects should have been intersected, leaving only 1 rect
     SkClipStack::B2TIter iter(stack);
     const SkClipStack::Element* element = iter.next();
     SkRect answer;
     answer.iset(25, 25, 75, 75);
 
     REPORTER_ASSERT(reporter, element);
     REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
-    REPORTER_ASSERT(reporter, SkRegion::kIntersect_Op == element->getOp());
+    REPORTER_ASSERT(reporter, SkCanvas::kIntersect_Op == element->getOp());
     REPORTER_ASSERT(reporter, element->getRect() == answer);
     // now check that we only had one in our iterator
     REPORTER_ASSERT(reporter, !iter.next());
 
     stack.reset();
     REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
     assert_count(reporter, stack, 0);
 
     test_assign_and_comparison(reporter);
     test_iterators(reporter);
     test_bounds(reporter, SkClipStack::Element::kRect_Type);
     test_bounds(reporter, SkClipStack::Element::kRRect_Type);
     test_bounds(reporter, SkClipStack::Element::kPath_Type);
     test_isWideOpen(reporter);
     test_rect_merging(reporter);
     test_rect_replace(reporter);
     test_rect_inverse_fill(reporter);
     test_path_replace(reporter);
     test_quickContains(reporter);
     test_invfill_diff_bug(reporter);
 #if SK_SUPPORT_GPU
     test_reduced_clip_stack(reporter);
     test_reduced_clip_stack_genid(reporter);
     test_reduced_clip_stack_no_aa_crash(reporter);
     test_reduced_clip_stack_aa(reporter);
 #endif
 }