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

SkRegion::Op --> SkCanvas::ClipOp (alias) --> SkClipOp

pre-CL needed in chrome : https://codereview.chromium.org/2355583002/

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2355483002

Review-Url: https://codereview.chromium.org/2355483002

13 files changed, 159 insertions, 146 deletions

diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 31af0a10f3..f492ccb4d0 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -342,8 +342,7 @@ public:
     bool next() {
         if (fMultiDeviceCS && fDevice) {
             // remove the previous device's bounds
-            fMultiDeviceCS->clipDevRect(compute_device_bounds(fDevice),
-                                        SkRegion::kDifference_Op);
+            fMultiDeviceCS->clipDevRect(compute_device_bounds(fDevice), SkCanvas::kDifference_Op);
         }
 
         // skip over recs with empty clips
@@ -1108,7 +1107,7 @@ bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveLayerFlags saveLayerFlag
 
     if (BoundsAffectsClip(saveLayerFlags)) {
         // Simplify the current clips since they will be applied properly during restore()
-        fClipStack->clipDevRect(ir, SkRegion::kReplace_Op);
+        fClipStack->clipDevRect(ir, kReplace_Op);
         fMCRec->fRasterClip.setRect(ir);
         fDeviceClipBounds = qr_clip_bounds(ir);
     }
@@ -1540,7 +1539,7 @@ sk_sp<SkLights> SkCanvas::getLights() const {
 
 //////////////////////////////////////////////////////////////////////////////
 
-void SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+void SkCanvas::clipRect(const SkRect& rect, ClipOp op, bool doAA) {
     if (!fAllowSoftClip) {
         doAA = false;
     }
@@ -1550,17 +1549,14 @@ void SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
     this->onClipRect(rect, op, edgeStyle);
 }
 
-void SkCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     const bool isScaleTrans = fMCRec->fMatrix.isScaleTranslate();
     SkRect devR;
     if (isScaleTrans) {
         fMCRec->fMatrix.mapRectScaleTranslate(&devR, rect);
     }
 
-    if (SkRegion::kIntersect_Op == op &&
-        kHard_ClipEdgeStyle == edgeStyle
-        && isScaleTrans)
-    {
+    if (kIntersect_Op == op && kHard_ClipEdgeStyle == edgeStyle && isScaleTrans) {
         if (devR.round().contains(fMCRec->fRasterClip.getBounds())) {
 #if 0
             SkDebugf("------- ignored clipRect [%g %g %g %g]\n",
@@ -1577,7 +1573,7 @@ void SkCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edg
     if (isScaleTrans) {
         const bool isAA = kSoft_ClipEdgeStyle == edgeStyle;
         fClipStack->clipDevRect(devR, op, isAA);
-        fMCRec->fRasterClip.op(devR, this->getTopLayerBounds(), op, isAA);
+        fMCRec->fRasterClip.op(devR, this->getTopLayerBounds(), (SkRegion::Op)op, isAA);
     } else {
         // since we're rotated or some such thing, we convert the rect to a path
         // and clip against that, since it can handle any matrix. However, to
@@ -1593,7 +1589,7 @@ void SkCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edg
     fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
 }
 
-void SkCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+void SkCanvas::clipRRect(const SkRRect& rrect, ClipOp op, bool doAA) {
     this->checkForDeferredSave();
     ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
     if (rrect.isRect()) {
@@ -1603,7 +1599,7 @@ void SkCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
     }
 }
 
-void SkCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     SkRRect transformedRRect;
     if (rrect.transform(fMCRec->fMatrix, &transformedRRect)) {
         AutoValidateClip avc(this);
@@ -1615,7 +1611,7 @@ void SkCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle
 
         fClipStack->clipDevRRect(transformedRRect, op, kSoft_ClipEdgeStyle == edgeStyle);
 
-        fMCRec->fRasterClip.op(transformedRRect, this->getTopLayerBounds(), op,
+        fMCRec->fRasterClip.op(transformedRRect, this->getTopLayerBounds(), (SkRegion::Op)op,
                                kSoft_ClipEdgeStyle == edgeStyle);
         fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
         return;
@@ -1628,7 +1624,7 @@ void SkCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle
     this->SkCanvas::onClipPath(path, op, edgeStyle);
 }
 
-void SkCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
+void SkCanvas::clipPath(const SkPath& path, ClipOp op, bool doAA) {
     this->checkForDeferredSave();
     ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
 
@@ -1653,7 +1649,7 @@ void SkCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     this->onClipPath(path, op, edgeStyle);
 }
 
-void SkCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
@@ -1688,19 +1684,19 @@ void SkCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edg
             edgeStyle = kSoft_ClipEdgeStyle;
         }
 
-        op = SkRegion::kReplace_Op;
+        op = kReplace_Op;
     }
 
-    fMCRec->fRasterClip.op(devPath, this->getTopLayerBounds(), op, edgeStyle);
+    fMCRec->fRasterClip.op(devPath, this->getTopLayerBounds(), (SkRegion::Op)op, edgeStyle);
     fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
 }
 
-void SkCanvas::clipRegion(const SkRegion& rgn, SkRegion::Op op) {
+void SkCanvas::clipRegion(const SkRegion& rgn, ClipOp op) {
     this->checkForDeferredSave();
     this->onClipRegion(rgn, op);
 }
 
-void SkCanvas::onClipRegion(const SkRegion& rgn, SkRegion::Op op) {
+void SkCanvas::onClipRegion(const SkRegion& rgn, ClipOp op) {
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
@@ -1709,7 +1705,7 @@ void SkCanvas::onClipRegion(const SkRegion& rgn, SkRegion::Op op) {
     // we have to ignore it, and use the region directly?
     fClipStack->clipDevRect(rgn.getBounds(), op);
 
-    fMCRec->fRasterClip.op(rgn, op);
+    fMCRec->fRasterClip.op(rgn, (SkRegion::Op)op);
     fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
 }
 
@@ -1732,7 +1728,7 @@ void SkCanvas::validateClip() const {
         switch (element->getType()) {
             case SkClipStack::Element::kRect_Type:
                 element->getRect().round(&ir);
-                tmpClip.op(ir, element->getOp());
+                tmpClip.op(ir, (SkRegion::Op)element->getOp());
                 break;
             case SkClipStack::Element::kEmpty_Type:
                 tmpClip.setEmpty();
@@ -1740,7 +1736,8 @@ void SkCanvas::validateClip() const {
             default: {
                 SkPath path;
                 element->asPath(&path);
-                tmpClip.op(path, this->getTopLayerBounds(), element->getOp(), element->isAA());
+                tmpClip.op(path, this->getTopLayerBounds(), (SkRegion::Op)element->getOp(),
+                           element->isAA());
                 break;
             }
         }
@@ -3451,3 +3448,19 @@ SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* p
     return this->makeSurface(info, props).release();
 }
 #endif
+
+/////////////////////////////////
+
+const SkCanvas::ClipOp SkCanvas::kDifference_Op;
+const SkCanvas::ClipOp SkCanvas::kIntersect_Op;
+const SkCanvas::ClipOp SkCanvas::kUnion_Op;
+const SkCanvas::ClipOp SkCanvas::kXOR_Op;
+const SkCanvas::ClipOp SkCanvas::kReverseDifference_Op;
+const SkCanvas::ClipOp SkCanvas::kReplace_Op;
+
+static_assert((int)SkRegion::kDifference_Op         == (int)kDifference_SkClipOp, "");
+static_assert((int)SkRegion::kIntersect_Op          == (int)kIntersect_SkClipOp, "");
+static_assert((int)SkRegion::kUnion_Op              == (int)kUnion_SkClipOp, "");
+static_assert((int)SkRegion::kXOR_Op                == (int)kXOR_SkClipOp, "");
+static_assert((int)SkRegion::kReverseDifference_Op  == (int)kReverseDifference_SkClipOp, "");
+static_assert((int)SkRegion::kReplace_Op            == (int)kReplace_SkClipOp, "");
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 30f5a46fac..0019077804 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -83,7 +83,7 @@ void SkClipStack::Element::replay(SkCanvasClipVisitor* visitor) const {
             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;
     }
 }
@@ -111,7 +111,7 @@ void SkClipStack::Element::invertShapeFillType() {
     }
 }
 
-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;
@@ -176,16 +176,16 @@ void SkClipStack::Element::checkEmpty() const {
     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 {
@@ -399,9 +399,9 @@ void SkClipStack::Element::updateBoundAndGenID(const Element* prior) {
             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;
             }
@@ -460,28 +460,28 @@ void SkClipStack::Element::updateBoundAndGenID(const Element* prior) {
 
     // 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;
     }
@@ -507,7 +507,7 @@ 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);
     }
 }
 
@@ -517,7 +517,7 @@ SkClipStack::SkClipStack(const SkIRect& r)
     if (!r.isEmpty()) {
         SkRect temp;
         temp.set(r);
-        this->clipDevRect(temp, SkRegion::kReplace_Op, false);
+        this->clipDevRect(temp, SkCanvas::kReplace_Op, false);
     }
 }
 
@@ -626,7 +626,7 @@ 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
@@ -638,7 +638,7 @@ bool SkClipStack::internalQuickContains(const SkRect& rect) const {
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
@@ -651,7 +651,7 @@ 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
@@ -663,7 +663,7 @@ bool SkClipStack::internalQuickContains(const SkRRect& rrect) const {
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
@@ -684,8 +684,8 @@ bool SkClipStack::asPath(SkPath *path) const {
             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);
@@ -736,7 +736,7 @@ void SkClipStack::pushElement(const Element& element) {
                     }
                     break;
             }
-        } else if (SkRegion::kReplace_Op == element.getOp()) {
+        } else if (SkCanvas::kReplace_Op == element.getOp()) {
             this->restoreTo(fSaveCount - 1);
             prior = (Element*) fDeque.back();
         }
@@ -745,17 +745,17 @@ void SkClipStack::pushElement(const 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);
 }
@@ -763,7 +763,7 @@ void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
 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);
@@ -789,7 +789,7 @@ 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;
@@ -874,13 +874,13 @@ bool SkClipStack::isRRect(const SkRect& bounds, SkRRect* rrect, bool* aa) const
         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;
@@ -889,12 +889,12 @@ bool SkClipStack::isRRect(const SkRect& bounds, SkRRect* rrect, bool* aa) const
             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;
                 }
             }
@@ -946,12 +946,12 @@ void SkClipStack::Element::dump() const {
         "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],
diff --git a/src/core/SkLiteDL.cpp b/src/core/SkLiteDL.cpp
index 227c2f30b6..3175447380 100644
--- a/src/core/SkLiteDL.cpp
+++ b/src/core/SkLiteDL.cpp
@@ -149,34 +149,34 @@ namespace {
 
     struct ClipPath final : Op {
         static const auto kType = Type::ClipPath;
-        ClipPath(const SkPath& path, SkRegion::Op op, bool aa) : path(path), op(op), aa(aa) {}
-        SkPath       path;
-        SkRegion::Op op;
-        bool         aa;
+        ClipPath(const SkPath& path, SkCanvas::ClipOp op, bool aa) : path(path), op(op), aa(aa) {}
+        SkPath           path;
+        SkCanvas::ClipOp op;
+        bool             aa;
         void draw(SkCanvas* c, const SkMatrix&) { c->clipPath(path, op, aa); }
         void makeThreadsafe() { make_threadsafe(&path, nullptr); }
     };
     struct ClipRect final : Op {
         static const auto kType = Type::ClipRect;
-        ClipRect(const SkRect& rect, SkRegion::Op op, bool aa) : rect(rect), op(op), aa(aa) {}
-        SkRect       rect;
-        SkRegion::Op op;
-        bool         aa;
+        ClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool aa) : rect(rect), op(op), aa(aa) {}
+        SkRect           rect;
+        SkCanvas::ClipOp op;
+        bool             aa;
         void draw(SkCanvas* c, const SkMatrix&) { c->clipRect(rect, op, aa); }
     };
     struct ClipRRect final : Op {
         static const auto kType = Type::ClipRRect;
-        ClipRRect(const SkRRect& rrect, SkRegion::Op op, bool aa) : rrect(rrect), op(op), aa(aa) {}
-        SkRRect      rrect;
-        SkRegion::Op op;
-        bool         aa;
+        ClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool aa) : rrect(rrect), op(op), aa(aa) {}
+        SkRRect          rrect;
+        SkCanvas::ClipOp op;
+        bool             aa;
         void draw(SkCanvas* c, const SkMatrix&) { c->clipRRect(rrect, op, aa); }
     };
     struct ClipRegion final : Op {
         static const auto kType = Type::ClipRegion;
-        ClipRegion(const SkRegion& region, SkRegion::Op op) : region(region), op(op) {}
-        SkRegion     region;
-        SkRegion::Op op;
+        ClipRegion(const SkRegion& region, SkCanvas::ClipOp op) : region(region), op(op) {}
+        SkRegion         region;
+        SkCanvas::ClipOp op;
         void draw(SkCanvas* c, const SkMatrix&) { c->clipRegion(region, op); }
     };
 
@@ -597,16 +597,16 @@ void SkLiteDL::setMatrix(const SkMatrix& matrix)   { this->push<SetMatrix>(0, ma
 void SkLiteDL::translate(SkScalar dx, SkScalar dy) { this->push<Translate>(0, dx, dy); }
 void SkLiteDL::translateZ(SkScalar dz) { this->push<TranslateZ>(0, dz); }
 
-void SkLiteDL::clipPath(const SkPath& path, SkRegion::Op op, bool aa) {
+void SkLiteDL::clipPath(const SkPath& path, SkCanvas::ClipOp op, bool aa) {
     this->push<ClipPath>(0, path, op, aa);
 }
-void SkLiteDL::clipRect(const SkRect& rect, SkRegion::Op op, bool aa) {
+void SkLiteDL::clipRect(const SkRect& rect, SkCanvas::ClipOp op, bool aa) {
     this->push<ClipRect>(0, rect, op, aa);
 }
-void SkLiteDL::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool aa) {
+void SkLiteDL::clipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool aa) {
     this->push<ClipRRect>(0, rrect, op, aa);
 }
-void SkLiteDL::clipRegion(const SkRegion& region, SkRegion::Op op) {
+void SkLiteDL::clipRegion(const SkRegion& region, SkCanvas::ClipOp op) {
     this->push<ClipRegion>(0, region, op);
 }
 
diff --git a/src/core/SkLiteDL.h b/src/core/SkLiteDL.h
index 8edd700e85..b18cc540dc 100644
--- a/src/core/SkLiteDL.h
+++ b/src/core/SkLiteDL.h
@@ -43,10 +43,10 @@ public:
     void translate(SkScalar, SkScalar);
     void translateZ(SkScalar);
 
-    void clipPath  (const   SkPath&, SkRegion::Op, bool aa);
-    void clipRect  (const   SkRect&, SkRegion::Op, bool aa);
-    void clipRRect (const  SkRRect&, SkRegion::Op, bool aa);
-    void clipRegion(const SkRegion&, SkRegion::Op);
+    void clipPath  (const   SkPath&, SkCanvas::ClipOp, bool aa);
+    void clipRect  (const   SkRect&, SkCanvas::ClipOp, bool aa);
+    void clipRRect (const  SkRRect&, SkCanvas::ClipOp, bool aa);
+    void clipRegion(const SkRegion&, SkCanvas::ClipOp);
 
     void drawPaint (const SkPaint&);
     void drawPath  (const SkPath&, const SkPaint&);
diff --git a/src/core/SkLiteRecorder.cpp b/src/core/SkLiteRecorder.cpp
index bc5ffbe052..77a1bd7ff3 100644
--- a/src/core/SkLiteRecorder.cpp
+++ b/src/core/SkLiteRecorder.cpp
@@ -40,19 +40,19 @@ void SkLiteRecorder::didConcat   (const SkMatrix& matrix)   { fDL->   concat(mat
 void SkLiteRecorder::didSetMatrix(const SkMatrix& matrix)   { fDL->setMatrix(matrix); }
 void SkLiteRecorder::didTranslate(SkScalar dx, SkScalar dy) { fDL->translate(dx, dy); }
 
-void SkLiteRecorder::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle style) {
     fDL->clipRect(rect, op, style==kSoft_ClipEdgeStyle);
     SkCanvas::onClipRect(rect, op, style);
 }
-void SkLiteRecorder::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle style) {
     fDL->clipRRect(rrect, op, style==kSoft_ClipEdgeStyle);
     SkCanvas::onClipRRect(rrect, op, style);
 }
-void SkLiteRecorder::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle style) {
     fDL->clipPath(path, op, style==kSoft_ClipEdgeStyle);
     SkCanvas::onClipPath(path, op, style);
 }
-void SkLiteRecorder::onClipRegion(const SkRegion& region, SkRegion::Op op) {
+void SkLiteRecorder::onClipRegion(const SkRegion& region, ClipOp op) {
     fDL->clipRegion(region, op);
     SkCanvas::onClipRegion(region, op);
 }
diff --git a/src/core/SkLiteRecorder.h b/src/core/SkLiteRecorder.h
index 7ec4f83bc5..be278549a6 100644
--- a/src/core/SkLiteRecorder.h
+++ b/src/core/SkLiteRecorder.h
@@ -31,10 +31,10 @@ public:
     void didSetMatrix(const SkMatrix&) override;
     void didTranslate(SkScalar, SkScalar) override;
 
-    void onClipRect  (const   SkRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRRect (const  SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipPath  (const   SkPath&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRegion(const SkRegion&, SkRegion::Op) override;
+    void onClipRect  (const   SkRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipRRect (const  SkRRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipPath  (const   SkPath&, ClipOp, ClipEdgeStyle) override;
+    void onClipRegion(const SkRegion&, ClipOp) override;
 
     void onDrawPaint (const SkPaint&) override;
     void onDrawPath  (const SkPath&, const SkPaint&) override;
diff --git a/src/core/SkPictureAnalyzer.cpp b/src/core/SkPictureAnalyzer.cpp
index b1d61aebba..a7a4d94496 100644
--- a/src/core/SkPictureAnalyzer.cpp
+++ b/src/core/SkPictureAnalyzer.cpp
@@ -38,11 +38,11 @@ void SkPictureGpuAnalyzer::analyzePicture(const SkPicture* picture) {
     fNumSlowPaths += picture->numSlowPaths();
 }
 
-void SkPictureGpuAnalyzer::analyzeClipPath(const SkPath& path, SkRegion::Op op, bool doAntiAlias) {
+void SkPictureGpuAnalyzer::analyzeClipPath(const SkPath& path, SkCanvas::ClipOp op, bool doAntiAlias) {
     const SkRecords::ClipPath clipOp = {
         SkIRect::MakeEmpty(), // Willie don't care.
         path,
-        SkRecords::RegionOpAndAA(op, doAntiAlias)
+        SkRecords::ClipOpAndAA(op, doAntiAlias)
     };
 
     SkPathCounter counter;
diff --git a/src/core/SkPictureFlat.h b/src/core/SkPictureFlat.h
index acd2d822b4..beb2dd8338 100644
--- a/src/core/SkPictureFlat.h
+++ b/src/core/SkPictureFlat.h
@@ -7,7 +7,7 @@
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
-
+#include "SkCanvas.h"
 #include "SkChecksum.h"
 #include "SkChunkAlloc.h"
 #include "SkReadBuffer.h"
@@ -126,15 +126,15 @@ enum SaveLayerRecFlatFlags {
 
 ///////////////////////////////////////////////////////////////////////////////
 // clipparams are packed in 5 bits
-//  doAA:1 | regionOp:4
+//  doAA:1 | clipOp:4
 
-static inline uint32_t ClipParams_pack(SkRegion::Op op, bool doAA) {
+static inline uint32_t ClipParams_pack(SkCanvas::ClipOp op, bool doAA) {
     unsigned doAABit = doAA ? 1 : 0;
     return (doAABit << 4) | op;
 }
 
-static inline SkRegion::Op ClipParams_unpackRegionOp(uint32_t packed) {
-    return (SkRegion::Op)(packed & 0xF);
+static inline SkCanvas::ClipOp ClipParams_unpackRegionOp(uint32_t packed) {
+    return (SkCanvas::ClipOp)(packed & 0xF);
 }
 
 static inline bool ClipParams_unpackDoAA(uint32_t packed) {
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index 4520b6d325..cc16855abf 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -126,11 +126,11 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
         case CLIP_PATH: {
             const SkPath& path = fPictureData->getPath(reader); 
             uint32_t packed = reader->readInt(); 
-            SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+            SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
             bool doAA = ClipParams_unpackDoAA(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
-            canvas->clipPath(path, regionOp, doAA);
+            canvas->clipPath(path, clipOp, doAA);
             if (canvas->isClipEmpty() && offsetToRestore) {
                 reader->skip(offsetToRestore - reader->offset());
             }
@@ -139,10 +139,10 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
             SkRegion region;
             reader->readRegion(&region);
             uint32_t packed = reader->readInt();
-            SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+            SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
-            canvas->clipRegion(region, regionOp);
+            canvas->clipRegion(region, clipOp);
             if (canvas->isClipEmpty() && offsetToRestore) {
                 reader->skip(offsetToRestore - reader->offset());
             }
@@ -151,11 +151,11 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
             SkRect rect;
             reader->readRect(&rect);
             uint32_t packed = reader->readInt();
-            SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+            SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
             bool doAA = ClipParams_unpackDoAA(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
-            canvas->clipRect(rect, regionOp, doAA);
+            canvas->clipRect(rect, clipOp, doAA);
             if (canvas->isClipEmpty() && offsetToRestore) {
                 reader->skip(offsetToRestore - reader->offset());
             }
@@ -164,11 +164,11 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
             SkRRect rrect;
             reader->readRRect(&rrect);
             uint32_t packed = reader->readInt();
-            SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+            SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
             bool doAA = ClipParams_unpackDoAA(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
-            canvas->clipRRect(rrect, regionOp, doAA);
+            canvas->clipRRect(rrect, clipOp, doAA);
             if (canvas->isClipEmpty() && offsetToRestore) {
                 reader->skip(offsetToRestore - reader->offset());
             }
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 5ee2e9fb35..4cba3b067f 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -230,15 +230,15 @@ void SkPictureRecord::didTranslateZ(SkScalar z) {
 #endif
 }
 
-static bool regionOpExpands(SkRegion::Op op) {
+static bool clipOpExpands(SkCanvas::ClipOp op) {
     switch (op) {
-        case SkRegion::kUnion_Op:
-        case SkRegion::kXOR_Op:
-        case SkRegion::kReverseDifference_Op:
-        case SkRegion::kReplace_Op:
+        case SkCanvas::kUnion_Op:
+        case SkCanvas::kXOR_Op:
+        case SkCanvas::kReverseDifference_Op:
+        case SkCanvas::kReplace_Op:
             return true;
-        case SkRegion::kIntersect_Op:
-        case SkRegion::kDifference_Op:
+        case SkCanvas::kIntersect_Op:
+        case SkCanvas::kDifference_Op:
             return false;
         default:
             SkDEBUGFAIL("unknown region op");
@@ -279,7 +279,7 @@ void SkPictureRecord::endRecording() {
     this->restoreToCount(fInitialSaveCount);
 }
 
-size_t SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
+size_t SkPictureRecord::recordRestoreOffsetPlaceholder(ClipOp op) {
     if (fRestoreOffsetStack.isEmpty()) {
         return -1;
     }
@@ -291,7 +291,7 @@ size_t SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
     // restore command is recorded.
     int32_t prevOffset = fRestoreOffsetStack.top();
 
-    if (regionOpExpands(op)) {
+    if (clipOpExpands(op)) {
         // Run back through any previous clip ops, and mark their offset to
         // be 0, disabling their ability to trigger a jump-to-restore, otherwise
         // they could hide this clips ability to expand the clip (i.e. go from
@@ -309,12 +309,12 @@ size_t SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
     return offset;
 }
 
-void SkPictureRecord::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipRect(const SkRect& rect, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
     this->recordClipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle);
     this->INHERITED::onClipRect(rect, op, edgeStyle);
 }
 
-size_t SkPictureRecord::recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+size_t SkPictureRecord::recordClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
     // id + rect + clip params
     size_t size = 1 * kUInt32Size + sizeof(rect) + 1 * kUInt32Size;
     // recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -331,12 +331,12 @@ size_t SkPictureRecord::recordClipRect(const SkRect& rect, SkRegion::Op op, bool
     return offset;
 }
 
-void SkPictureRecord::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
     this->recordClipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-size_t SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+size_t SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
     // op + rrect + clip params
     size_t size = 1 * kUInt32Size + SkRRect::kSizeInMemory + 1 * kUInt32Size;
     // recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -352,13 +352,13 @@ size_t SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkRegion::Op op, b
     return offset;
 }
 
-void SkPictureRecord::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipPath(const SkPath& path, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
     int pathID = this->addPathToHeap(path);
     this->recordClipPath(pathID, op, kSoft_ClipEdgeStyle == edgeStyle);
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-size_t SkPictureRecord::recordClipPath(int pathID, SkRegion::Op op, bool doAA) {
+size_t SkPictureRecord::recordClipPath(int pathID, SkCanvas::ClipOp op, bool doAA) {
     // op + path index + clip params
     size_t size = 3 * kUInt32Size;
     // recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -374,12 +374,12 @@ size_t SkPictureRecord::recordClipPath(int pathID, SkRegion::Op op, bool doAA) {
     return offset;
 }
 
-void SkPictureRecord::onClipRegion(const SkRegion& region, SkRegion::Op op) {
+void SkPictureRecord::onClipRegion(const SkRegion& region, ClipOp op) {
     this->recordClipRegion(region, op);
     this->INHERITED::onClipRegion(region, op);
 }
 
-size_t SkPictureRecord::recordClipRegion(const SkRegion& region, SkRegion::Op op) {
+size_t SkPictureRecord::recordClipRegion(const SkRegion& region, ClipOp op) {
     // op + clip params + region
     size_t size = 2 * kUInt32Size + region.writeToMemory(nullptr);
     // recordRestoreOffsetPlaceholder doesn't always write an offset
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index ac8058b31e..6d75609db9 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -76,7 +76,7 @@ protected:
 
 private:
     void handleOptimization(int opt);
-    size_t recordRestoreOffsetPlaceholder(SkRegion::Op);
+    size_t recordRestoreOffsetPlaceholder(SkCanvas::ClipOp);
     void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
 
     SkTDArray<int32_t> fRestoreOffsetStack;
@@ -205,10 +205,10 @@ protected:
                         const uint16_t indices[], int indexCount,
                         const SkPaint&) override;
 
-    void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRegion(const SkRegion&, SkRegion::Op) override;
+    void onClipRect(const SkRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipRRect(const SkRRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipPath(const SkPath&, ClipOp, ClipEdgeStyle) override;
+    void onClipRegion(const SkRegion&, ClipOp) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
 
@@ -231,10 +231,10 @@ protected:
     void recordConcat(const SkMatrix& matrix);
     void recordTranslate(const SkMatrix& matrix);
     void recordScale(const SkMatrix& matrix);
-    size_t recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
-    size_t recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
-    size_t recordClipPath(int pathID, SkRegion::Op op, bool doAA);
-    size_t recordClipRegion(const SkRegion& region, SkRegion::Op op);
+    size_t recordClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool doAA);
+    size_t recordClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA);
+    size_t recordClipPath(int pathID, SkCanvas::ClipOp op, bool doAA);
+    size_t recordClipRegion(const SkRegion& region, SkCanvas::ClipOp op);
     void recordSave();
     void recordSaveLayer(const SaveLayerRec&);
     void recordRestore(bool fillInSkips = true);
diff --git a/src/core/SkRecorder.cpp b/src/core/SkRecorder.cpp
index 4c09e514be..0c236716bc 100644
--- a/src/core/SkRecorder.cpp
+++ b/src/core/SkRecorder.cpp
@@ -402,25 +402,25 @@ void SkRecorder::didTranslateZ(SkScalar z) {
 #endif
 }
 
-void SkRecorder::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     INHERITED(onClipRect, rect, op, edgeStyle);
-    SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
+    SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
     APPEND(ClipRect, this->devBounds(), rect, opAA);
 }
 
-void SkRecorder::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     INHERITED(onClipRRect, rrect, op, edgeStyle);
-    SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
+    SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
     APPEND(ClipRRect, this->devBounds(), rrect, opAA);
 }
 
-void SkRecorder::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     INHERITED(onClipPath, path, op, edgeStyle);
-    SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
+    SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
     APPEND(ClipPath, this->devBounds(), path, opAA);
 }
 
-void SkRecorder::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkRecorder::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     INHERITED(onClipRegion, deviceRgn, op);
     APPEND(ClipRegion, this->devBounds(), deviceRgn, op);
 }
diff --git a/src/core/SkRecorder.h b/src/core/SkRecorder.h
index 3ab958b56d..8efae17c6e 100644
--- a/src/core/SkRecorder.h
+++ b/src/core/SkRecorder.h
@@ -132,10 +132,10 @@ public:
     void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
                      int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) override;
 
-    void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
-    void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
-    void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
-    void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override;
+    void onClipRect(const SkRect& rect, ClipOp, ClipEdgeStyle) override;
+    void onClipRRect(const SkRRect& rrect, ClipOp, ClipEdgeStyle) override;
+    void onClipPath(const SkPath& path, ClipOp, ClipEdgeStyle) override;
+    void onClipRegion(const SkRegion& deviceRgn, ClipOp) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;