diff --git a/bench/AAClipBench.cpp b/bench/AAClipBench.cpp
index 657b6ff..f91216e 100644
--- a/bench/AAClipBench.cpp
+++ b/bench/AAClipBench.cpp
@@ -59,9 +59,9 @@
             canvas->save();
 #if 1
             if (fDoPath) {
-                canvas->clipPath(fClipPath, SkRegion::kReplace_Op, fDoAA);
+                canvas->clipPath(fClipPath, SkCanvas::kReplace_Op, fDoAA);
             } else {
-                canvas->clipRect(fClipRect, SkRegion::kReplace_Op, fDoAA);
+                canvas->clipRect(fClipRect, SkCanvas::kReplace_Op, fDoAA);
             }
 
             canvas->drawRect(fDrawRect, paint);
@@ -130,8 +130,8 @@
             SkASSERT(path.isConvex());
 
             canvas->clipPath(path,
-                             0 == depth ? SkRegion::kReplace_Op :
-                                          SkRegion::kIntersect_Op,
+                             0 == depth ? SkCanvas::kReplace_Op :
+                                          SkCanvas::kIntersect_Op,
                              fDoAA);
 
             if (kNestingDepth == depth) {
diff --git a/gm/aaclip.cpp b/gm/aaclip.cpp
index cb8418b..d657669 100644
--- a/gm/aaclip.cpp
+++ b/gm/aaclip.cpp
@@ -85,7 +85,7 @@
     canvas->drawRect(target, borderPaint);
     target.inset(SkIntToScalar(2), SkIntToScalar(2));
     canvas->drawRect(target, backgroundPaint);
-    canvas->clipRect(target, SkRegion::kIntersect_Op, true);
+    canvas->clipRect(target, SkCanvas::kIntersect_Op, true);
     target.inset(SkIntToScalar(-4), SkIntToScalar(-4));
     canvas->drawRect(target, foregroundPaint);
     canvas->restore();
diff --git a/gm/bigblurs.cpp b/gm/bigblurs.cpp
index 8cad70d..ee5ccd1 100644
--- a/gm/bigblurs.cpp
+++ b/gm/bigblurs.cpp
@@ -80,7 +80,7 @@
                                                        SkIntToScalar(kCloseUpSize),
                                                        SkIntToScalar(kCloseUpSize));
 
-                    canvas->clipRect(clipRect, SkRegion::kReplace_Op, false);
+                    canvas->clipRect(clipRect, SkCanvas::kReplace_Op, false);
 
                     canvas->translate(desiredX-origins[k].fX,
                                       desiredY-origins[k].fY);
diff --git a/gm/blurredclippedcircle.cpp b/gm/blurredclippedcircle.cpp
index bf49cd6..a087064 100644
--- a/gm/blurredclippedcircle.cpp
+++ b/gm/blurredclippedcircle.cpp
@@ -45,18 +45,18 @@
             SkRect clipRect1 = SkRect::MakeLTRB(0, 0,
                                                 SkIntToScalar(kWidth), SkIntToScalar(kHeight));
 
-            canvas->clipRect(clipRect1, SkRegion::kIntersect_Op, false);
+            canvas->clipRect(clipRect1);
 
             canvas->save();
 
-                canvas->clipRect(clipRect1, SkRegion::kIntersect_Op, false);
+                canvas->clipRect(clipRect1);
                 canvas->drawRect(clipRect1, whitePaint);
 
                 canvas->save();
 
                     SkRect clipRect2 = SkRect::MakeLTRB(8, 8, 288, 288);
                     SkRRect clipRRect = SkRRect::MakeOval(clipRect2);
-                    canvas->clipRRect(clipRRect, SkRegion::kDifference_Op, true);
+                    canvas->clipRRect(clipRRect, SkCanvas::kDifference_Op, true);
 
                     SkRect r = SkRect::MakeLTRB(4, 4, 292, 292);
                     SkRRect rr = SkRRect::MakeOval(r);
diff --git a/gm/circularclips.cpp b/gm/circularclips.cpp
index 2691971..39be1a5 100644
--- a/gm/circularclips.cpp
+++ b/gm/circularclips.cpp
@@ -36,13 +36,13 @@
     }
 
     void onDraw(SkCanvas* canvas) override {
-        SkRegion::Op ops[] = {
-            SkRegion::kDifference_Op,
-            SkRegion::kIntersect_Op,
-            SkRegion::kUnion_Op,
-            SkRegion::kXOR_Op,
-            SkRegion::kReverseDifference_Op,
-            SkRegion::kReplace_Op,
+        SkCanvas::ClipOp ops[] = {
+            SkCanvas::kDifference_Op,
+            SkCanvas::kIntersect_Op,
+            SkCanvas::kUnion_Op,
+            SkCanvas::kXOR_Op,
+            SkCanvas::kReverseDifference_Op,
+            SkCanvas::kReplace_Op,
         };
 
         SkRect rect = SkRect::MakeLTRB(fX1 - fR, fY - fR, fX2 + fR, fY + fR);
@@ -54,8 +54,8 @@
         canvas->save();
         canvas->scale(10, 10);
         canvas->translate(-((fX1 + fX2)/2 - fR), -(fY - 2*fR/3));
-        canvas->clipPath(fCircle1, SkRegion::kReplace_Op, true);
-        canvas->clipPath(fCircle2, SkRegion::kIntersect_Op, true);
+        canvas->clipPath(fCircle1, SkCanvas::kReplace_Op, true);
+        canvas->clipPath(fCircle2, SkCanvas::kIntersect_Op, true);
 
         canvas->drawRect(rect, fillPaint);
 
@@ -73,7 +73,7 @@
             for (size_t op = 0; op < SK_ARRAY_COUNT(ops); op++) {
                 canvas->save();
 
-                canvas->clipPath(fCircle1, SkRegion::kReplace_Op);
+                canvas->clipPath(fCircle1, SkCanvas::kReplace_Op);
                 canvas->clipPath(fCircle2, ops[op]);
 
                 canvas->drawRect(rect, fillPaint);
diff --git a/gm/clip_strokerect.cpp b/gm/clip_strokerect.cpp
index f4183b1..814455d 100644
--- a/gm/clip_strokerect.cpp
+++ b/gm/clip_strokerect.cpp
@@ -36,7 +36,7 @@
         SkRect rect = SkRect::MakeXYWH(20, 0, 100, 20);
 
         canvas->save();
-        canvas->clipRect(rect, SkRegion::kReplace_Op, true);
+        canvas->clipRect(rect, SkCanvas::kReplace_Op, true);
         canvas->drawRect(r, p);
         canvas->restore();
 
@@ -54,7 +54,7 @@
         SkRect rect2 = SkRect::MakeXYWH(20, 120, 100, 19);
 
         canvas->save();
-        canvas->clipRect(rect2, SkRegion::kReplace_Op, true);
+        canvas->clipRect(rect2, SkCanvas::kReplace_Op, true);
         canvas->drawRect(r2, p);
         canvas->restore();
 
diff --git a/gm/complexclip.cpp b/gm/complexclip.cpp
index ec22204..fb94957 100644
--- a/gm/complexclip.cpp
+++ b/gm/complexclip.cpp
@@ -86,14 +86,14 @@
         paint.setTextSize(SkIntToScalar(20));
 
         constexpr struct {
-            SkRegion::Op fOp;
-            const char*  fName;
+            SkCanvas::ClipOp fOp;
+            const char*      fName;
         } gOps[] = { //extra spaces in names for measureText
-            {SkRegion::kIntersect_Op,         "Isect "},
-            {SkRegion::kDifference_Op,        "Diff " },
-            {SkRegion::kUnion_Op,             "Union "},
-            {SkRegion::kXOR_Op,               "Xor "  },
-            {SkRegion::kReverseDifference_Op, "RDiff "}
+            {SkCanvas::kIntersect_Op,         "Isect "},
+            {SkCanvas::kDifference_Op,        "Diff " },
+            {SkCanvas::kUnion_Op,             "Union "},
+            {SkCanvas::kXOR_Op,               "Xor "  },
+            {SkCanvas::kReverseDifference_Op, "RDiff "}
         };
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
@@ -130,7 +130,7 @@
                                       SkPath::kEvenOdd_FillType);
                     clipB.setFillType(doInvB ? SkPath::kInverseEvenOdd_FillType :
                                       SkPath::kEvenOdd_FillType);
-                    canvas->clipPath(clipA, SkRegion::kIntersect_Op, fDoAAClip);
+                    canvas->clipPath(clipA, SkCanvas::kIntersect_Op, fDoAAClip);
                     canvas->clipPath(clipB, gOps[op].fOp, fDoAAClip);
 
                     // In the inverse case we need to prevent the draw from covering the whole
diff --git a/gm/complexclip2.cpp b/gm/complexclip2.cpp
index 2994e68..3180f66 100644
--- a/gm/complexclip2.cpp
+++ b/gm/complexclip2.cpp
@@ -83,13 +83,13 @@
         fPaths[4].addRoundRect(fRects[4], 5, 5);
         fRectColors[4] = SK_ColorCYAN;
 
-        SkRegion::Op ops[] = {
-            SkRegion::kDifference_Op,
-            SkRegion::kIntersect_Op,
-            SkRegion::kUnion_Op,
-            SkRegion::kXOR_Op,
-            SkRegion::kReverseDifference_Op,
-            SkRegion::kReplace_Op,
+        SkCanvas::ClipOp ops[] = {
+            SkCanvas::kDifference_Op,
+            SkCanvas::kIntersect_Op,
+            SkCanvas::kUnion_Op,
+            SkCanvas::kXOR_Op,
+            SkCanvas::kReverseDifference_Op,
+            SkCanvas::kReplace_Op,
         };
 
         SkRandom r;
@@ -200,7 +200,7 @@
     SkRRect fRRects[5];
     SkPath fPaths[5];
     SkColor fRectColors[5];
-    SkRegion::Op fOps[kRows * kCols][5];
+    SkCanvas::ClipOp fOps[kRows * kCols][5];
     SkScalar fWidth;
     SkScalar fHeight;
     SkScalar fTotalWidth;
diff --git a/gm/complexclip3.cpp b/gm/complexclip3.cpp
index 1deb446..fd8cd35 100644
--- a/gm/complexclip3.cpp
+++ b/gm/complexclip3.cpp
@@ -52,14 +52,14 @@
         paint.setTextSize(SkIntToScalar(20));
 
         constexpr struct {
-            SkRegion::Op fOp;
-            const char*  fName;
+            SkCanvas::ClipOp fOp;
+            const char*      fName;
         } gOps[] = {
-            {SkRegion::kIntersect_Op,         "I"},
-            {SkRegion::kDifference_Op,        "D" },
-            {SkRegion::kUnion_Op,             "U"},
-            {SkRegion::kXOR_Op,               "X"  },
-            {SkRegion::kReverseDifference_Op, "R"}
+            {SkCanvas::kIntersect_Op,         "I"},
+            {SkCanvas::kDifference_Op,        "D" },
+            {SkCanvas::kUnion_Op,             "U"},
+            {SkCanvas::kXOR_Op,               "X"  },
+            {SkCanvas::kReverseDifference_Op, "R"}
         };
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
@@ -84,7 +84,7 @@
                                                SkPath::kEvenOdd_FillType);
                         secondClip->setFillType(doInvB ? SkPath::kInverseEvenOdd_FillType :
                                                 SkPath::kEvenOdd_FillType);
-                        canvas->clipPath(*firstClip, SkRegion::kIntersect_Op, doAAA);
+                        canvas->clipPath(*firstClip, SkCanvas::kIntersect_Op, doAAA);
                         canvas->clipPath(*secondClip, gOps[op].fOp, doAAB);
 
                         // draw rect clipped
diff --git a/gm/complexclip_blur_tiled.cpp b/gm/complexclip_blur_tiled.cpp
index 979c7e7..31db174 100644
--- a/gm/complexclip_blur_tiled.cpp
+++ b/gm/complexclip_blur_tiled.cpp
@@ -52,7 +52,7 @@
                 SkRect rect = SkRect::MakeWH(WIDTH, HEIGHT);
                 tileCanvas->saveLayer(&rect, &blurPaint);
                 SkRRect rrect = SkRRect::MakeRectXY(rect.makeInset(20, 20), 25, 25);
-                tileCanvas->clipRRect(rrect, SkRegion::kDifference_Op, true);
+                tileCanvas->clipRRect(rrect, SkCanvas::kDifference_Op, true);
                 SkPaint paint;
                 tileCanvas->drawRect(rect, paint);
                 tileCanvas->restore();
diff --git a/gm/convexpolyclip.cpp b/gm/convexpolyclip.cpp
index 9681faa..5116955 100644
--- a/gm/convexpolyclip.cpp
+++ b/gm/convexpolyclip.cpp
@@ -173,7 +173,7 @@
                         canvas->save();
                     }
                     canvas->translate(x, y);
-                    clip->setOnCanvas(canvas, SkRegion::kIntersect_Op, SkToBool(aa));
+                    clip->setOnCanvas(canvas, SkCanvas::kIntersect_Op, SkToBool(aa));
                     canvas->drawBitmap(fBmp, 0, 0);
                     canvas->restore();
                     x += fBmp.width() + kMargin;
@@ -199,7 +199,7 @@
                     SkPath closedClipPath;
                     clip->asClosedPath(&closedClipPath);
                     canvas->drawPath(closedClipPath, clipOutlinePaint);
-                    clip->setOnCanvas(canvas, SkRegion::kIntersect_Op, SkToBool(aa));
+                    clip->setOnCanvas(canvas, SkCanvas::kIntersect_Op, SkToBool(aa));
                     canvas->scale(1.f, 1.8f);
                     canvas->drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1,
                                      0, 1.5f * txtPaint.getTextSize(),
@@ -227,7 +227,7 @@
 
         Clip () : fClipType(kNone_ClipType) {}
 
-        void setOnCanvas(SkCanvas* canvas, SkRegion::Op op, bool aa) const {
+        void setOnCanvas(SkCanvas* canvas, SkCanvas::ClipOp op, bool aa) const {
             switch (fClipType) {
                 case kPath_ClipType:
                     canvas->clipPath(fPath, op, aa);
diff --git a/gm/distantclip.cpp b/gm/distantclip.cpp
index 07594e7..f4931dd 100644
--- a/gm/distantclip.cpp
+++ b/gm/distantclip.cpp
@@ -39,7 +39,7 @@
         SkRect r = SkRect::MakeXYWH(-kExtents, kOffset - kExtents, 2 * kExtents, 2 * kExtents);
         SkPath p;
         p.addRoundRect(r, 5, 5);
-        rec->clipPath(p, SkRegion::kIntersect_Op, true);
+        rec->clipPath(p, SkCanvas::kIntersect_Op, true);
         rec->drawColor(SK_ColorGREEN);
         rec->restore();
         sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp
index fcb82a7..3e8d39a 100644
--- a/gm/imagefilters.cpp
+++ b/gm/imagefilters.cpp
@@ -122,7 +122,7 @@
     for (int i = 0; i < count; ++i) {
         canvas->save();
         SkRRect rr = SkRRect::MakeRectXY(r.makeOffset(dx, dy), 20, 20);
-        canvas->clipRRect(rr, SkRegion::kIntersect_Op, true);
+        canvas->clipRRect(rr, SkCanvas::kIntersect_Op, true);
         canvas->saveLayer({ &rr.getBounds(), nullptr, filters[i].get(), 0 });
         canvas->drawColor(0x40FFFFFF);
         canvas->restore();
diff --git a/gm/megalooper.cpp b/gm/megalooper.cpp
index 6f071cb..86dd617 100644
--- a/gm/megalooper.cpp
+++ b/gm/megalooper.cpp
@@ -91,8 +91,8 @@
         outerClip.offset(x, y);
 
         canvas->save();
-        canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
-        canvas->clipRect(innerClip, SkRegion::kDifference_Op);
+        canvas->clipRect(outerClip, SkCanvas::kIntersect_Op);
+        canvas->clipRect(innerClip, SkCanvas::kDifference_Op);
 
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -146,8 +146,8 @@
             rect.offset(x, y);
 
             canvas->save();
-                canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
-                canvas->clipRect(rect, SkRegion::kDifference_Op);
+                canvas->clipRect(outerClip, SkCanvas::kIntersect_Op);
+                canvas->clipRect(rect, SkCanvas::kDifference_Op);
 
                 // move the rect to where we want the blur to appear
                 rect.offset(gBlurOffsets[i]);
@@ -195,8 +195,8 @@
         paint.setLooper(create4Looper(-kOffsetToOutsideClip-kHalfSquareSize, 0));
 
         canvas->save();
-            canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
-            canvas->clipRect(rect, SkRegion::kDifference_Op);
+            canvas->clipRect(outerClip, SkCanvas::kIntersect_Op);
+            canvas->clipRect(rect, SkCanvas::kDifference_Op);
 
             rect.offset(SkIntToScalar(kOffsetToOutsideClip+kHalfSquareSize), 0);
             canvas->drawRect(rect, paint);
diff --git a/gm/path_stroke_with_zero_length.cpp b/gm/path_stroke_with_zero_length.cpp
index c69fe5c..9c05541 100644
--- a/gm/path_stroke_with_zero_length.cpp
+++ b/gm/path_stroke_with_zero_length.cpp
@@ -167,7 +167,7 @@
         } else {
             fClipS.transform(clipM, &clip);
         }
-        canvas->clipPath(clip, SkRegion::kIntersect_Op, true);
+        canvas->clipPath(clip, SkCanvas::kIntersect_Op, true);
         canvas->scale(scale, scale);
         canvas->drawBitmap(offscreen, (bounds.fLeft - 17) / scale,
                     (bounds.fTop - 20 + 420) / scale);
@@ -180,7 +180,7 @@
             clipM.postTranslate(bounds.fLeft - 17 - 275, bounds.fTop - 24.5f + 420);
             SkPath clip;
             fClipR.transform(clipM, &clip);
-            canvas->clipPath(clip, SkRegion::kIntersect_Op, true);
+            canvas->clipPath(clip, SkCanvas::kIntersect_Op, true);
             canvas->scale(10.f, 10.f);
             canvas->drawBitmap(offscreen, (bounds.fLeft - 17 - 275
                     + (index >= 5 ? 5 : 0)) / scale, (bounds.fTop - 20 + 420) / scale);
diff --git a/gm/pathopsinverse.cpp b/gm/pathopsinverse.cpp
index 0c88632..176bc76 100644
--- a/gm/pathopsinverse.cpp
+++ b/gm/pathopsinverse.cpp
@@ -75,7 +75,7 @@
                 two.addRect(40, 40, 100, 100);
                 canvas->save();
                 canvas->translate(0, SkIntToScalar(yPos));
-                canvas->clipRect(SkRect::MakeWH(110, 110), SkRegion::kIntersect_Op, true);
+                canvas->clipRect(SkRect::MakeWH(110, 110), SkCanvas::kIntersect_Op, true);
                 canvas->drawPath(one, fOnePaint);
                 canvas->drawPath(one, fOutlinePaint);
                 canvas->drawPath(two, fTwoPaint);
@@ -87,7 +87,7 @@
                     Op(one, two, (SkPathOp) op, &result);
                     canvas->save();
                     canvas->translate(SkIntToScalar(xPos), SkIntToScalar(yPos));
-                    canvas->clipRect(SkRect::MakeWH(110, 110), SkRegion::kIntersect_Op, true);
+                    canvas->clipRect(SkRect::MakeWH(110, 110), SkCanvas::kIntersect_Op, true);
                     canvas->drawPath(result, fOpPaint[op]);
                     canvas->drawPath(result, fOutlinePaint);
                     canvas->restore();
diff --git a/gm/pathopsskpclip.cpp b/gm/pathopsskpclip.cpp
index 4e575ca..77ba84c 100644
--- a/gm/pathopsskpclip.cpp
+++ b/gm/pathopsskpclip.cpp
@@ -42,9 +42,9 @@
             SkIntToScalar(700)
         };
         p.addRoundRect(r, SkIntToScalar(50), SkIntToScalar(50));
-        rec->clipPath(p, SkRegion::kIntersect_Op, true);
+        rec->clipPath(p, SkCanvas::kIntersect_Op, true);
         rec->translate(SkIntToScalar(250), SkIntToScalar(250));
-        rec->clipPath(p, SkRegion::kIntersect_Op, true);
+        rec->clipPath(p, SkCanvas::kIntersect_Op, true);
         rec->drawColor(0xffff0000);
         sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
 
diff --git a/gm/rrectclipdrawpaint.cpp b/gm/rrectclipdrawpaint.cpp
index 172facc..74b5783 100644
--- a/gm/rrectclipdrawpaint.cpp
+++ b/gm/rrectclipdrawpaint.cpp
@@ -21,14 +21,14 @@
 
     const SkRect layerRect = SkRect::MakeWH(256.f, 256.f);
     canvas->saveLayer(layerRect, nullptr);
-    canvas->clipRRect(rrect, SkRegion::kIntersect_Op, true);
+    canvas->clipRRect(rrect, SkCanvas::kIntersect_Op, true);
     canvas->drawPaint(p);
     canvas->restore();
 
     canvas->concat(zoomOut);
     p.setColor(SK_ColorBLUE);
     canvas->saveLayer(layerRect, nullptr);
-    canvas->clipRRect(rrect, SkRegion::kIntersect_Op, false);
+    canvas->clipRRect(rrect, SkCanvas::kIntersect_Op, false);
     canvas->drawPaint(p);
     canvas->restore();
 
@@ -38,7 +38,7 @@
                                              SkShader::kClamp_TileMode));
     canvas->concat(zoomOut);
     canvas->saveLayer(layerRect, nullptr);
-    canvas->clipRRect(rrect, SkRegion::kIntersect_Op, true);
+    canvas->clipRRect(rrect, SkCanvas::kIntersect_Op, true);
     canvas->drawPaint(p);
     canvas->restore();
 
@@ -47,7 +47,7 @@
                                              SkShader::kClamp_TileMode));
     canvas->concat(zoomOut);
     canvas->saveLayer(layerRect, nullptr);
-    canvas->clipRRect(rrect, SkRegion::kIntersect_Op, false);
+    canvas->clipRRect(rrect, SkCanvas::kIntersect_Op, false);
     canvas->drawPaint(p);
     canvas->restore();
 }
diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index 63b6dbc..46c1c67 100644
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -124,7 +124,7 @@
 #endif
                     } else if (kBW_Clip_Type == fType || kAA_Clip_Type == fType) {
                         bool aaClip = (kAA_Clip_Type == fType);
-                        canvas->clipRRect(fRRects[curRRect], SkRegion::kReplace_Op, aaClip);
+                        canvas->clipRRect(fRRects[curRRect], SkCanvas::kReplace_Op, aaClip);
                         canvas->drawRect(kMaxTileBound, paint);
                     } else {
                         canvas->drawRRect(fRRects[curRRect], paint);
diff --git a/gm/samplerstress.cpp b/gm/samplerstress.cpp
index 64a42b9..83916bc 100644
--- a/gm/samplerstress.cpp
+++ b/gm/samplerstress.cpp
@@ -108,7 +108,7 @@
         SkPath path;
         path.addRoundRect(temp, SkIntToScalar(5), SkIntToScalar(5));
 
-        canvas->clipPath(path, SkRegion::kReplace_Op, true); // AA is on
+        canvas->clipPath(path, SkCanvas::kReplace_Op, true); // AA is on
 
         canvas->drawText("M", 1,
                          SkIntToScalar(100), SkIntToScalar(100),
diff --git a/gm/simpleaaclip.cpp b/gm/simpleaaclip.cpp
index b5aa3ae..87dc687 100644
--- a/gm/simpleaaclip.cpp
+++ b/gm/simpleaaclip.cpp
@@ -67,12 +67,12 @@
         INHERITED::setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
     }
 
-    void buildRgn(SkAAClip* clip, SkRegion::Op op) {
+    void buildRgn(SkAAClip* clip, SkCanvas::ClipOp op) {
         clip->setPath(fBasePath, nullptr, true);
 
         SkAAClip clip2;
         clip2.setPath(fRectPath, nullptr, true);
-        clip->op(clip2, op);
+        clip->op(clip2, (SkRegion::Op)op);
     }
 
     void drawOrig(SkCanvas* canvas) {
@@ -85,7 +85,7 @@
         canvas->drawRect(fRect, paint);
     }
 
-    void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
+    void drawRgnOped(SkCanvas* canvas, SkCanvas::ClipOp op, SkColor color) {
 
         SkAAClip clip;
 
@@ -97,7 +97,7 @@
         paint_rgn(canvas, clip, paint);
     }
 
-    void drawPathsOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
+    void drawPathsOped(SkCanvas* canvas, SkCanvas::ClipOp op, SkColor color) {
 
         this->drawOrig(canvas);
 
@@ -106,11 +106,11 @@
         // create the clip mask with the supplied boolean op
         if (kPath_GeomType == fGeomType) {
             // path-based case
-            canvas->clipPath(fBasePath, SkRegion::kReplace_Op, true);
+            canvas->clipPath(fBasePath, SkCanvas::kReplace_Op, true);
             canvas->clipPath(fRectPath, op, true);
         } else {
             // rect-based case
-            canvas->clipRect(fBase, SkRegion::kReplace_Op, true);
+            canvas->clipRect(fBase, SkCanvas::kReplace_Op, true);
             canvas->clipRect(fRect, op, true);
         }
 
@@ -144,14 +144,14 @@
         const struct {
             SkColor         fColor;
             const char*     fName;
-            SkRegion::Op    fOp;
+            SkCanvas::ClipOp fOp;
         } gOps[] = {
-            { SK_ColorBLACK,    "Difference", SkRegion::kDifference_Op    },
-            { SK_ColorRED,      "Intersect",  SkRegion::kIntersect_Op     },
-            { sk_tool_utils::color_to_565(0xFF008800), "Union", SkRegion::kUnion_Op },
-            { SK_ColorGREEN,    "Rev Diff",   SkRegion::kReverseDifference_Op },
-            { SK_ColorYELLOW,   "Replace",    SkRegion::kReplace_Op       },
-            { SK_ColorBLUE,     "XOR",        SkRegion::kXOR_Op           },
+            { SK_ColorBLACK,    "Difference", SkCanvas::kDifference_Op    },
+            { SK_ColorRED,      "Intersect",  SkCanvas::kIntersect_Op     },
+            { sk_tool_utils::color_to_565(0xFF008800), "Union", SkCanvas::kUnion_Op },
+            { SK_ColorGREEN,    "Rev Diff",   SkCanvas::kReverseDifference_Op },
+            { SK_ColorYELLOW,   "Replace",    SkCanvas::kReplace_Op       },
+            { SK_ColorBLUE,     "XOR",        SkCanvas::kXOR_Op           },
         };
 
         SkPaint textPaint;
diff --git a/gm/skbug1719.cpp b/gm/skbug1719.cpp
index ec7818c..2fa6be8 100644
--- a/gm/skbug1719.cpp
+++ b/gm/skbug1719.cpp
@@ -65,6 +65,6 @@
                                    SkBlurMaskFilter::kHighQuality_BlurFlag));
         paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkXfermode::kSrcIn_Mode));
 
-        canvas->clipPath(clipPath, SkRegion::kIntersect_Op, true);
+        canvas->clipPath(clipPath, SkCanvas::kIntersect_Op, true);
         canvas->drawPath(drawPath, paint);
 }
diff --git a/gm/windowrectangles.cpp b/gm/windowrectangles.cpp
index 7917bc4..f1a7356 100644
--- a/gm/windowrectangles.cpp
+++ b/gm/windowrectangles.cpp
@@ -42,19 +42,19 @@
     canvas->saveLayer(SkRect::Make(kLayerRect), nullptr);
 
     SkClipStack stack;
-    stack.clipDevRect(SkRect::MakeXYWH(370.75, 80.25, 149, 100), SkRegion::kDifference_Op, false);
-    stack.clipDevRect(SkRect::MakeXYWH(80.25, 420.75, 150, 100), SkRegion::kDifference_Op, true);
+    stack.clipDevRect(SkRect::MakeXYWH(370.75, 80.25, 149, 100), SkCanvas::kDifference_Op, false);
+    stack.clipDevRect(SkRect::MakeXYWH(80.25, 420.75, 150, 100), SkCanvas::kDifference_Op, true);
     stack.clipDevRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(200, 200, 200, 200), 60, 45),
-                       SkRegion::kDifference_Op, true);
+                       SkCanvas::kDifference_Op, true);
 
     SkRRect nine;
     nine.setNinePatch(SkRect::MakeXYWH(550 - 30.25 - 100, 370.75, 100, 150), 12, 35, 23, 20);
-    stack.clipDevRRect(nine, SkRegion::kDifference_Op, true);
+    stack.clipDevRRect(nine, SkCanvas::kDifference_Op, true);
 
     SkRRect complx;
     SkVector complxRadii[4] = {{6, 4}, {8, 12}, {16, 24}, {48, 32}};
     complx.setRectRadii(SkRect::MakeXYWH(80.25, 80.75, 100, 149), complxRadii);
-    stack.clipDevRRect(complx, SkRegion::kDifference_Op, false);
+    stack.clipDevRRect(complx, SkCanvas::kDifference_Op, false);
 
     this->onCoverClipStack(stack, canvas);
 
@@ -77,7 +77,7 @@
  */
 class ReplayClipStackVisitor final : public SkCanvasClipVisitor {
 public:
-    typedef SkRegion::Op Op;
+    typedef SkCanvas::ClipOp Op;
     ReplayClipStackVisitor(SkCanvas* canvas) : fCanvas(canvas) {}
     void clipRect(const SkRect& r, Op op, bool aa) override { fCanvas->clipRect(r, op, aa); }
     void clipRRect(const SkRRect& rr, Op op, bool aa) override { fCanvas->clipRRect(rr, op, aa); }
diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi
index 2937f84..8727ed1 100644
--- a/gyp/skia_for_android_framework_defines.gypi
+++ b/gyp/skia_for_android_framework_defines.gypi
@@ -31,6 +31,7 @@
       'SK_IGNORE_GPU_DITHER',
       'SK_SUPPORT_LEGACY_PICTUREINSTALLPIXELREF',
       'SK_SUPPORT_LEGACY_STREAM_DATA',
+      'SK_SUPPORT_LEGACY_CLIP_REGIONOPS',
     ],
   },
 }
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index d28d0f1..acb52c9 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -10,6 +10,7 @@
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
+#include "SkClipOp.h"
 #include "SkDeque.h"
 #include "SkImage.h"
 #include "SkPaint.h"
@@ -41,6 +42,8 @@
 class SkSurface_Base;
 class SkTextBlob;
 
+//#define SK_SUPPORT_LEGACY_CLIP_REGIONOPS
+
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
@@ -60,8 +63,27 @@
     enum PrivateSaveLayerFlags {
         kDontClipToLayer_PrivateSaveLayerFlag   = 1U << 31,
     };
-    
+
 public:
+#ifdef SK_SUPPORT_LEGACY_CLIP_REGIONOPS
+    typedef SkRegion::Op ClipOp;
+
+    static const ClipOp kDifference_Op         = SkRegion::kDifference_Op;
+    static const ClipOp kIntersect_Op          = SkRegion::kIntersect_Op;
+    static const ClipOp kUnion_Op              = SkRegion::kUnion_Op;
+    static const ClipOp kXOR_Op                = SkRegion::kXOR_Op;
+    static const ClipOp kReverseDifference_Op  = SkRegion::kReverseDifference_Op;
+    static const ClipOp kReplace_Op            = SkRegion::kReplace_Op;
+#else
+    typedef SkClipOp ClipOp;
+
+    static const ClipOp kDifference_Op         = kDifference_SkClipOp;
+    static const ClipOp kIntersect_Op          = kIntersect_SkClipOp;
+    static const ClipOp kUnion_Op              = kUnion_SkClipOp;
+    static const ClipOp kXOR_Op                = kXOR_SkClipOp;
+    static const ClipOp kReverseDifference_Op  = kReverseDifference_SkClipOp;
+    static const ClipOp kReplace_Op            = kReplace_SkClipOp;
+#endif
     /**
      *  Attempt to allocate raster canvas, matching the ImageInfo, that will draw directly into the
      *  specified pixels. To access the pixels after drawing to them, the caller should call
@@ -477,9 +499,7 @@
      *  @param op The region op to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipRect(const SkRect& rect,
-                  SkRegion::Op op = SkRegion::kIntersect_Op,
-                  bool doAntiAlias = false);
+    void clipRect(const SkRect& rect, ClipOp op = kIntersect_Op, bool doAntiAlias = false);
 
     /**
      *  Modify the current clip with the specified SkRRect.
@@ -487,9 +507,7 @@
      *  @param op The region op to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipRRect(const SkRRect& rrect,
-                   SkRegion::Op op = SkRegion::kIntersect_Op,
-                   bool doAntiAlias = false);
+    void clipRRect(const SkRRect& rrect, ClipOp op = kIntersect_Op, bool doAntiAlias = false);
 
     /**
      *  Modify the current clip with the specified path.
@@ -497,9 +515,7 @@
      *  @param op The region op to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipPath(const SkPath& path,
-                  SkRegion::Op op = SkRegion::kIntersect_Op,
-                  bool doAntiAlias = false);
+    void clipPath(const SkPath& path, ClipOp op = kIntersect_Op, bool doAntiAlias = false);
 
     /** EXPERIMENTAL -- only used for testing
         Set to false to force clips to be hard, even if doAntiAlias=true is
@@ -523,17 +539,7 @@
         @param deviceRgn    The region to apply to the current clip
         @param op The region op to apply to the current clip
     */
-    void clipRegion(const SkRegion& deviceRgn,
-                    SkRegion::Op op = SkRegion::kIntersect_Op);
-
-    /** Helper for clipRegion(rgn, kReplace_Op). Sets the current clip to the
-        specified region. This does not intersect or in any other way account
-        for the existing clip region.
-        @param deviceRgn The region to copy into the current clip.
-    */
-    void setClipRegion(const SkRegion& deviceRgn) {
-        this->clipRegion(deviceRgn, SkRegion::kReplace_Op);
-    }
+    void clipRegion(const SkRegion& deviceRgn, ClipOp op = kIntersect_Op);
 
     /** Return true if the specified rectangle, after being transformed by the
         current matrix, would lie completely outside of the current clip. Call
@@ -1466,10 +1472,10 @@
         kSoft_ClipEdgeStyle
     };
 
-    virtual void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle);
-    virtual void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle);
-    virtual void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle);
-    virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op);
+    virtual void onClipRect(const SkRect& rect, ClipOp, ClipEdgeStyle);
+    virtual void onClipRRect(const SkRRect& rrect, ClipOp, ClipEdgeStyle);
+    virtual void onClipPath(const SkPath& path, ClipOp, ClipEdgeStyle);
+    virtual void onClipRegion(const SkRegion& deviceRgn, ClipOp);
 
     virtual void onDiscard();
 
@@ -1732,9 +1738,9 @@
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
-    virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
-    virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
-    virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
+    virtual void clipRect(const SkRect&, SkCanvas::ClipOp, bool antialias) = 0;
+    virtual void clipRRect(const SkRRect&, SkCanvas::ClipOp, bool antialias) = 0;
+    virtual void clipPath(const SkPath&, SkCanvas::ClipOp, bool antialias) = 0;
 };
 
 #endif
diff --git a/include/core/SkClipOp.h b/include/core/SkClipOp.h
new file mode 100644
index 0000000..2e4fbbf
--- /dev/null
+++ b/include/core/SkClipOp.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkClipOp_DEFINED
+#define SkClipOp_DEFINED
+
+#include "SkTypes.h"
+
+// these kept in SkRegion::Op order for now ...
+enum SkClipOp {
+    kDifference_SkClipOp    = 0,
+    kIntersect_SkClipOp     = 1,
+
+    // Goal: remove these, since they can grow the current clip
+
+    kUnion_SkClipOp         = 2,
+    kXOR_SkClipOp           = 3,
+    kReverseDifference_SkClipOp = 4,
+    kReplace_SkClipOp       = 5,
+};
+
+#endif
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index f34283d..1fb7b5c 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -1,13 +1,14 @@
-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #ifndef SkClipStack_DEFINED
 #define SkClipStack_DEFINED
 
+#include "SkCanvas.h"
 #include "SkDeque.h"
 #include "SkPath.h"
 #include "SkRect.h"
@@ -53,21 +54,21 @@
         static const int kTypeCnt = kLastType + 1;
 
         Element() {
-            this->initCommon(0, SkRegion::kReplace_Op, false);
+            this->initCommon(0, SkCanvas::kReplace_Op, false);
             this->setEmpty();
         }
 
         Element(const Element&);
 
-        Element(const SkRect& rect, SkRegion::Op op, bool doAA) {
+        Element(const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             this->initRect(0, rect, op, doAA);
         }
 
-        Element(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        Element(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             this->initRRect(0, rrect, op, doAA);
         }
 
-        Element(const SkPath& path, SkRegion::Op op, bool doAA) {
+        Element(const SkPath& path, SkCanvas::ClipOp op, bool doAA) {
             this->initPath(0, path, op, doAA);
         }
 
@@ -93,7 +94,7 @@
         }
 
         //!< Call if getType() is not kEmpty to get the set operation used to combine this element.
-        SkRegion::Op getOp() const { return fOp; }
+        SkCanvas::ClipOp getOp() const { return fOp; }
 
         //!< Call to get the element as a path, regardless of its type.
         void asPath(SkPath* path) const;
@@ -109,7 +110,7 @@
         void invertShapeFillType();
 
         //!< Sets the set operation represented by the element.
-        void setOp(SkRegion::Op op) { fOp = op; }
+        void setOp(SkCanvas::ClipOp op) { fOp = op; }
 
         /** The GenID can be used by clip stack clients to cache representations of the clip. The
             ID corresponds to the set of clip elements up to and including this element within the
@@ -201,7 +202,7 @@
         SkTLazy<SkPath> fPath;
         SkRRect         fRRect;
         int             fSaveCount; // save count of stack when this element was added.
-        SkRegion::Op    fOp;
+        SkCanvas::ClipOp fOp;
         Type            fType;
         bool            fDoAA;
 
@@ -225,23 +226,23 @@
         int                     fGenID;
 
         Element(int saveCount) {
-            this->initCommon(saveCount, SkRegion::kReplace_Op, false);
+            this->initCommon(saveCount, SkCanvas::kReplace_Op, false);
             this->setEmpty();
         }
 
-        Element(int saveCount, const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             this->initRRect(saveCount, rrect, op, doAA);
         }
 
-        Element(int saveCount, const SkRect& rect, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             this->initRect(saveCount, rect, op, doAA);
         }
 
-        Element(int saveCount, const SkPath& path, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkPath& path, SkCanvas::ClipOp op, bool doAA) {
             this->initPath(saveCount, path, op, doAA);
         }
 
-        void initCommon(int saveCount, SkRegion::Op op, bool doAA) {
+        void initCommon(int saveCount, SkCanvas::ClipOp op, bool doAA) {
             fSaveCount = saveCount;
             fOp = op;
             fDoAA = doAA;
@@ -253,13 +254,13 @@
             fGenID = kInvalidGenID;
         }
 
-        void initRect(int saveCount, const SkRect& rect, SkRegion::Op op, bool doAA) {
+        void initRect(int saveCount, const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             fRRect.setRect(rect);
             fType = kRect_Type;
             this->initCommon(saveCount, op, doAA);
         }
 
-        void initRRect(int saveCount, const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        void initRRect(int saveCount, const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             SkRRect::Type type = rrect.getType();
             fRRect = rrect;
             if (SkRRect::kRect_Type == type || SkRRect::kEmpty_Type == type) {
@@ -270,13 +271,13 @@
             this->initCommon(saveCount, op, doAA);
         }
 
-        void initPath(int saveCount, const SkPath& path, SkRegion::Op op, bool doAA);
+        void initPath(int saveCount, const SkPath& path, SkCanvas::ClipOp op, bool doAA);
 
         void setEmpty();
 
         // All Element methods below are only used within SkClipStack.cpp
         inline void checkEmpty() const;
-        inline bool canBeIntersectedInPlace(int saveCount, SkRegion::Op op) const;
+        inline bool canBeIntersectedInPlace(int saveCount, SkCanvas::ClipOp op) const;
         /* This method checks to see if two rect clips can be safely merged into one. The issue here
           is that to be strictly correct all the edges of the resulting rect must have the same
           anti-aliasing. */
@@ -347,14 +348,14 @@
      */
     bool asPath(SkPath* path) const;
 
-    void clipDevRect(const SkIRect& ir, SkRegion::Op op) {
+    void clipDevRect(const SkIRect& ir, SkCanvas::ClipOp op) {
         SkRect r;
         r.set(ir);
         this->clipDevRect(r, op, false);
     }
-    void clipDevRect(const SkRect&, SkRegion::Op, bool doAA);
-    void clipDevRRect(const SkRRect&, SkRegion::Op, bool doAA);
-    void clipDevPath(const SkPath&, SkRegion::Op, bool doAA);
+    void clipDevRect(const SkRect&, SkCanvas::ClipOp, bool doAA);
+    void clipDevRRect(const SkRRect&, SkCanvas::ClipOp, bool doAA);
+    void clipDevPath(const SkPath&, SkCanvas::ClipOp, bool doAA);
     // An optimized version of clipDevRect(emptyRect, kIntersect, ...)
     void clipEmpty();
 
@@ -425,7 +426,7 @@
          * Moves the iterator to the topmost element with the specified RegionOp and returns that
          * element. If no clip element with that op is found, the first element is returned.
          */
-        const Element* skipToTopmost(SkRegion::Op op);
+        const Element* skipToTopmost(SkCanvas::ClipOp op);
 
         /**
          * Restarts the iterator on a clip stack.
diff --git a/include/core/SkPictureAnalyzer.h b/include/core/SkPictureAnalyzer.h
index c46ca1e..62dac30 100644
--- a/include/core/SkPictureAnalyzer.h
+++ b/include/core/SkPictureAnalyzer.h
@@ -8,6 +8,7 @@
 #ifndef SkPictureAnalyzer_DEFINED
 #define SkPictureAnalyzer_DEFINED
 
+#include "SkCanvas.h"
 #include "SkRefCnt.h"
 #include "SkRegion.h"
 #include "SkTypes.h"
@@ -36,7 +37,7 @@
     /**
      *  Process an explicit clipPath op.
      */
-    void analyzeClipPath(const SkPath&, SkRegion::Op, bool doAntiAlias);
+    void analyzeClipPath(const SkPath&, SkCanvas::ClipOp, bool doAntiAlias);
 
     /**
      *  Reset all accumulated stats.
diff --git a/include/gpu/GrPaint.h b/include/gpu/GrPaint.h
index 0085604..6120348 100644
--- a/include/gpu/GrPaint.h
+++ b/include/gpu/GrPaint.h
@@ -99,7 +99,7 @@
         fXPFactory = GrPorterDuffXPFactory::Make(mode);
     }
 
-    void setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage = false); 
+    void setCoverageSetOpXPFactory(SkRegion::Op, bool invertCoverage = false);
 
     /**
      * Appends an additional color processor to the color computation.
diff --git a/include/private/SkRecords.h b/include/private/SkRecords.h
index 2800a96..f2cade5 100644
--- a/include/private/SkRecords.h
+++ b/include/private/SkRecords.h
@@ -190,30 +190,30 @@
         SkScalar dy);
 RECORD(TranslateZ, 0, SkScalar z);
 
-struct RegionOpAndAA {
-    RegionOpAndAA() {}
-    RegionOpAndAA(SkRegion::Op op, bool aa) : op(op), aa(aa) {}
-    SkRegion::Op op : 31;  // This really only needs to be 3, but there's no win today to do so.
-    unsigned     aa :  1;  // MSVC won't pack an enum with an bool, so we call this an unsigned.
+struct ClipOpAndAA {
+    ClipOpAndAA() {}
+    ClipOpAndAA(SkCanvas::ClipOp op, bool aa) : op(op), aa(aa) {}
+    SkCanvas::ClipOp op : 31;  // This really only needs to be 3, but there's no win today to do so.
+    unsigned         aa :  1;  // MSVC won't pack an enum with an bool, so we call this an unsigned.
 };
-static_assert(sizeof(RegionOpAndAA) == 4, "RegionOpAndAASize");
+static_assert(sizeof(ClipOpAndAA) == 4, "ClipOpAndAASize");
 
 RECORD(ClipPath, 0,
         SkIRect devBounds;
         PreCachedPath path;
-        RegionOpAndAA opAA);
+        ClipOpAndAA opAA);
 RECORD(ClipRRect, 0,
         SkIRect devBounds;
         SkRRect rrect;
-        RegionOpAndAA opAA);
+        ClipOpAndAA opAA);
 RECORD(ClipRect, 0,
         SkIRect devBounds;
         SkRect rect;
-        RegionOpAndAA opAA);
+        ClipOpAndAA opAA);
 RECORD(ClipRegion, 0,
         SkIRect devBounds;
         SkRegion region;
-        SkRegion::Op op);
+        SkCanvas::ClipOp op);
 
 // While not strictly required, if you have an SkPaint, it's fastest to put it first.
 RECORD(DrawArc, kDraw_Tag|kHasPaint_Tag,
diff --git a/include/utils/SkDumpCanvas.h b/include/utils/SkDumpCanvas.h
index baf509f..e111853 100644
--- a/include/utils/SkDumpCanvas.h
+++ b/include/utils/SkDumpCanvas.h
@@ -117,10 +117,10 @@
                         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;
     void onDrawAnnotation(const SkRect&, const char key[], SkData* value) override;
diff --git a/include/utils/SkLuaCanvas.h b/include/utils/SkLuaCanvas.h
index a823a47..ac29f6f 100644
--- a/include/utils/SkLuaCanvas.h
+++ b/include/utils/SkLuaCanvas.h
@@ -63,10 +63,10 @@
                         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;
 
diff --git a/include/utils/SkNWayCanvas.h b/include/utils/SkNWayCanvas.h
index 2c93df9..4e7f422 100644
--- a/include/utils/SkNWayCanvas.h
+++ b/include/utils/SkNWayCanvas.h
@@ -76,10 +76,10 @@
                               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;
     void onDrawAnnotation(const SkRect&, const char[], SkData*) override;
diff --git a/public.bzl b/public.bzl
index fb8edb0..1a6021f 100644
--- a/public.bzl
+++ b/public.bzl
@@ -613,6 +613,7 @@
     "SK_SUPPORT_LEGACY_PICTUREINSTALLPIXELREF",
     "SK_SUPPORT_LEGACY_STREAM_DATA",
     "SK_SUPPORT_LEGACY_TEXTBLOB_BUILDER",
+    "SK_SUPPORT_LEGACY_CLIP_REGIONOPS",
 ]
 
 ################################################################################
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index ee2b6e3..33b38c0 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -1349,7 +1349,7 @@
 
     if (fUseClip) {
         canvas->drawColor(0xFFFF88FF);
-        canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true);
+        canvas->clipPath(fClipPath, SkCanvas::kIntersect_Op, true);
     }
 
     // Install a flags filter proxy canvas if needed
diff --git a/samplecode/SampleClip.cpp b/samplecode/SampleClip.cpp
index 16390d8..06bd717 100644
--- a/samplecode/SampleClip.cpp
+++ b/samplecode/SampleClip.cpp
@@ -143,7 +143,7 @@
             canvas->save();
             for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); ++i) {
                 canvas->save();
-                canvas->clipPath(clipPath, SkRegion::kIntersect_Op, SkToBool(aa));
+                canvas->clipPath(clipPath, SkCanvas::kIntersect_Op, SkToBool(aa));
 //                canvas->drawColor(SK_ColorWHITE);
                 gProc[i](canvas, SkToBool(aa));
                 canvas->restore();
diff --git a/samplecode/SampleClipDrawMatch.cpp b/samplecode/SampleClipDrawMatch.cpp
index b010ad0..ddb9f66 100644
--- a/samplecode/SampleClipDrawMatch.cpp
+++ b/samplecode/SampleClipDrawMatch.cpp
@@ -164,43 +164,43 @@
 
         switch (fGeom) {
         case kRect_Geometry:
-            canvas->clipRect(create_rect(offset), SkRegion::kReplace_Op, useAA);
+            canvas->clipRect(create_rect(offset), SkCanvas::kReplace_Op, useAA);
             break;
         case kRRect_Geometry:
-            canvas->clipRRect(create_rrect(offset), SkRegion::kReplace_Op, useAA);
+            canvas->clipRRect(create_rrect(offset), SkCanvas::kReplace_Op, useAA);
             break;
         case kCircle_Geometry:
-            canvas->clipRRect(create_circle(offset), SkRegion::kReplace_Op, useAA);
+            canvas->clipRRect(create_circle(offset), SkCanvas::kReplace_Op, useAA);
             break;
         case kConvexPath_Geometry:
-            canvas->clipPath(create_convex_path(offset), SkRegion::kReplace_Op, useAA);
+            canvas->clipPath(create_convex_path(offset), SkCanvas::kReplace_Op, useAA);
             break;
         case kConcavePath_Geometry:
-            canvas->clipPath(create_concave_path(offset), SkRegion::kReplace_Op, useAA);
+            canvas->clipPath(create_concave_path(offset), SkCanvas::kReplace_Op, useAA);
             break;
         case kRectAndRect_Geometry: {
             SkRect r = create_rect(offset);
             r.offset(fSign * kXlate, fSign * kXlate);
-            canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
-            canvas->clipRect(create_rect(offset), SkRegion::kIntersect_Op, useAA);
+            canvas->clipRect(r, SkCanvas::kReplace_Op, true); // AA here forces shader clips
+            canvas->clipRect(create_rect(offset), SkCanvas::kIntersect_Op, useAA);
             } break;
         case kRectAndRRect_Geometry: {
             SkRect r = create_rect(offset);
             r.offset(fSign * kXlate, fSign * kXlate);
-            canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
-            canvas->clipRRect(create_rrect(offset), SkRegion::kIntersect_Op, useAA);
+            canvas->clipRect(r, SkCanvas::kReplace_Op, true); // AA here forces shader clips
+            canvas->clipRRect(create_rrect(offset), SkCanvas::kIntersect_Op, useAA);
             } break;
         case kRectAndConvex_Geometry: {
             SkRect r = create_rect(offset);
             r.offset(fSign * kXlate, fSign * kXlate);
-            canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
-            canvas->clipPath(create_convex_path(offset), SkRegion::kIntersect_Op, useAA);
+            canvas->clipRect(r, SkCanvas::kReplace_Op, true); // AA here forces shader clips
+            canvas->clipPath(create_convex_path(offset), SkCanvas::kIntersect_Op, useAA);
             } break;
         case kRectAndConcave_Geometry: {
             SkRect r = create_rect(offset);
             r.offset(fSign * kXlate, fSign * kXlate);
-            canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
-            canvas->clipPath(create_concave_path(offset), SkRegion::kIntersect_Op, useAA);
+            canvas->clipRect(r, SkCanvas::kReplace_Op, true); // AA here forces shader clips
+            canvas->clipPath(create_concave_path(offset), SkCanvas::kIntersect_Op, useAA);
             } break;
         }
 
diff --git a/samplecode/SampleComplexClip.cpp b/samplecode/SampleComplexClip.cpp
index aab759c..7439d91 100644
--- a/samplecode/SampleComplexClip.cpp
+++ b/samplecode/SampleComplexClip.cpp
@@ -79,14 +79,14 @@
         canvas->drawPath(clipB, paint);
 
         static const struct {
-            SkRegion::Op fOp;
-            const char*  fName;
+            SkCanvas::ClipOp fOp;
+            const char*      fName;
         } gOps[] = { //extra spaces in names for measureText
-            {SkRegion::kIntersect_Op,         "Isect "},
-            {SkRegion::kDifference_Op,        "Diff " },
-            {SkRegion::kUnion_Op,             "Union "},
-            {SkRegion::kXOR_Op,               "Xor "  },
-            {SkRegion::kReverseDifference_Op, "RDiff "}
+            {SkCanvas::kIntersect_Op,         "Isect "},
+            {SkCanvas::kDifference_Op,        "Diff " },
+            {SkCanvas::kUnion_Op,             "Union "},
+            {SkCanvas::kXOR_Op,               "Xor "  },
+            {SkCanvas::kReverseDifference_Op, "RDiff "}
         };
 
         canvas->translate(0, SkIntToScalar(40));
diff --git a/samplecode/SampleFatBits.cpp b/samplecode/SampleFatBits.cpp
index a1ef3ad..8da6058 100644
--- a/samplecode/SampleFatBits.cpp
+++ b/samplecode/SampleFatBits.cpp
@@ -258,7 +258,7 @@
         fMinSurface->getCanvas()->save();
         SkRect r = fClipRect;
         r.inset(SK_Scalar1/3, SK_Scalar1/3);
-        fMinSurface->getCanvas()->clipRect(r, SkRegion::kIntersect_Op, true);
+        fMinSurface->getCanvas()->clipRect(r, SkCanvas::kIntersect_Op, true);
     }
     fMinSurface->getCanvas()->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint);
     if (fUseClip) {
diff --git a/samplecode/SampleIdentityScale.cpp b/samplecode/SampleIdentityScale.cpp
index b6af3ce..8d1bc36 100644
--- a/samplecode/SampleIdentityScale.cpp
+++ b/samplecode/SampleIdentityScale.cpp
@@ -65,7 +65,7 @@
           SkRect r = { 100, 100, 356, 356 };
           SkPath clipPath;
           clipPath.addRoundRect(r, SkIntToScalar(5), SkIntToScalar(5));
-          canvas->clipPath(clipPath, SkRegion::kIntersect_Op, SkToBool(1));
+          canvas->clipPath(clipPath, SkCanvas::kIntersect_Op, SkToBool(1));
           text = "Scaled = 0";
         }
         canvas->drawBitmap( fBM, 100, 100, &paint );
diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp
index 4386976..52e6593 100644
--- a/samplecode/SampleLayers.cpp
+++ b/samplecode/SampleLayers.cpp
@@ -255,7 +255,7 @@
         m.postTranslate(fCenter.x(), fCenter.y());
         path.transform(m);
 
-        canvas->clipPath(path, SkRegion::kIntersect_Op, true);
+        canvas->clipPath(path, SkCanvas::kIntersect_Op, true);
         const SkRect bounds = path.getBounds();
 
         SkPaint paint;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 31af0a1..f492ccb 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -342,8 +342,7 @@
     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 @@
 
     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 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-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 @@
     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 @@
     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 @@
     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::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 @@
 
         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 @@
     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 @@
     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 @@
             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 @@
     // 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 @@
         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 @@
             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 @@
     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 30f5a46..0019077 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -83,7 +83,7 @@
             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::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 @@
     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 @@
             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 @@
 
     // 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 @@
     : 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 @@
     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 @@
     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 @@
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
@@ -651,7 +651,7 @@
     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 @@
                 return false;
             }
         }
-        if (SkRegion::kReplace_Op == element->getOp()) {
+        if (SkCanvas::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
@@ -684,8 +684,8 @@
             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 @@
                     }
                     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 @@
     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::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 @@
     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 @@
         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 @@
             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 @@
         "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 227c2f3..3175447 100644
--- a/src/core/SkLiteDL.cpp
+++ b/src/core/SkLiteDL.cpp
@@ -149,34 +149,34 @@
 
     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::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 8edd700..b18cc54 100644
--- a/src/core/SkLiteDL.h
+++ b/src/core/SkLiteDL.h
@@ -43,10 +43,10 @@
     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 bc5ffbe..77a1bd7 100644
--- a/src/core/SkLiteRecorder.cpp
+++ b/src/core/SkLiteRecorder.cpp
@@ -40,19 +40,19 @@
 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 7ec4f83..be27854 100644
--- a/src/core/SkLiteRecorder.h
+++ b/src/core/SkLiteRecorder.h
@@ -31,10 +31,10 @@
     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 b1d61ae..a7a4d94 100644
--- a/src/core/SkPictureAnalyzer.cpp
+++ b/src/core/SkPictureAnalyzer.cpp
@@ -38,11 +38,11 @@
     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 acd2d82..beb2dd8 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 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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 4520b6d..cc16855 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -126,11 +126,11 @@
         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 @@
             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 @@
             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 @@
             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 5ee2e9f..4cba3b0 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -230,15 +230,15 @@
 #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 @@
     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 @@
     // 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 @@
     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 @@
     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 @@
     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 @@
     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 ac8058b..6d75609 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -76,7 +76,7 @@
 
 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 @@
                         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 @@
     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 4c09e51..0c23671 100644
--- a/src/core/SkRecorder.cpp
+++ b/src/core/SkRecorder.cpp
@@ -402,25 +402,25 @@
 #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 3ab958b..8efae17 100644
--- a/src/core/SkRecorder.h
+++ b/src/core/SkRecorder.h
@@ -132,10 +132,10 @@
     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;
 
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index 8721dd7..c82482d 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -125,7 +125,7 @@
                          &paint);
     }
 
-    canvas->clipRect(SkRect::Make(foregroundBounds), SkRegion::kDifference_Op);
+    canvas->clipRect(SkRect::Make(foregroundBounds), SkCanvas::kDifference_Op);
     paint.setColor(SK_ColorTRANSPARENT);
     canvas->drawPaint(paint);
 
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index d6ad1d9..d85db11 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -181,10 +181,10 @@
     for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
 
-        SkRegion::Op op = element->getOp();
+        SkCanvas::ClipOp op = element->getOp();
         bool invert = element->isInverseFilled();
         bool needsStencil = invert ||
-                            SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op;
+                            SkCanvas::kIntersect_Op == op || SkCanvas::kReverseDifference_Op == op;
 
         if (PathNeedsSWRenderer(context, hasUserStencilSettings,
                                 drawContext, translate, element, nullptr, needsStencil)) {
@@ -205,7 +205,7 @@
     SkSTArray<kMaxAnalyticElements, sk_sp<GrFragmentProcessor>> fps;
     ElementList::Iter iter(elements);
     while (iter.get()) {
-        SkRegion::Op op = iter.get()->getOp();
+        SkCanvas::ClipOp op = iter.get()->getOp();
         bool invert;
         bool skip = false;
         switch (op) {
@@ -450,14 +450,14 @@
 
     for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
-        SkRegion::Op op = element->getOp();
+        SkCanvas::ClipOp op = element->getOp();
 
-        if (SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
+        if (SkCanvas::kIntersect_Op == op || SkCanvas::kReverseDifference_Op == op) {
             // Intersect and reverse difference require modifying pixels outside of the geometry
             // that is being "drawn". In both cases we erase all the pixels outside of the geometry
             // but leave the pixels inside the geometry alone. For reverse difference we invert all
             // the pixels before clearing the ones outside the geometry.
-            if (SkRegion::kReverseDifference_Op == op) {
+            if (SkCanvas::kReverseDifference_Op == op) {
                 SkRect temp = SkRect::Make(reducedClip.ibounds());
                 // invert the entire scene
                 helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF);
@@ -473,12 +473,12 @@
         // The other ops (union, xor, diff) only affect pixels inside
         // the geometry so they can just be drawn normally
         if (Element::kRect_Type == element->getType()) {
-            helper.drawRect(element->getRect(), op, element->isAA(), 0xFF);
+            helper.drawRect(element->getRect(), (SkRegion::Op)op, element->isAA(), 0xFF);
         } else {
             SkPath path;
             element->asPath(&path);
             GrShape shape(path, GrStyle::SimpleFill());
-            helper.drawShape(shape, op, element->isAA(), 0xFF);
+            helper.drawShape(shape, (SkRegion::Op)op, element->isAA(), 0xFF);
         }
     }
 
diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp
index 89690d3..4a912d3 100644
--- a/src/gpu/GrReducedClip.cpp
+++ b/src/gpu/GrReducedClip.cpp
@@ -74,7 +74,7 @@
         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;
 
@@ -146,7 +146,7 @@
         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()) {
@@ -172,7 +172,7 @@
                     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.
@@ -205,7 +205,7 @@
                     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.
@@ -228,7 +228,7 @@
                     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
@@ -250,7 +250,7 @@
                     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
@@ -275,7 +275,7 @@
                 }
                 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
@@ -325,9 +325,9 @@
 
             // 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()) {
@@ -336,11 +336,11 @@
                 // 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;
@@ -359,36 +359,36 @@
         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;
@@ -401,11 +401,11 @@
                         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;
@@ -430,12 +430,12 @@
     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) {
@@ -445,7 +445,7 @@
     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;
         }
 
@@ -536,7 +536,7 @@
             break;
         case Element::kRect_Type:
             return dc->drawContextPriv().drawAndStencilRect(clip, ss,
-                                                            element->getOp(),
+                                                            (SkRegion::Op)element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(),
                                                             viewMatrix, element->getRect());
@@ -549,7 +549,7 @@
             }
 
             return dc->drawContextPriv().drawAndStencilPath(clip, ss,
-                                                            element->getOp(),
+                                                            (SkRegion::Op)element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(), viewMatrix, path);
             break;
@@ -608,7 +608,7 @@
     // 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
@@ -722,7 +722,7 @@
         // 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;
diff --git a/src/pdf/SkPDFCanvas.cpp b/src/pdf/SkPDFCanvas.cpp
index 4ef1922..0fc242b 100644
--- a/src/pdf/SkPDFCanvas.cpp
+++ b/src/pdf/SkPDFCanvas.cpp
@@ -19,15 +19,15 @@
  *  we intercept all clip calls to ensure that the clip stays BW (i.e. never antialiased), since
  *  an antialiased clip won't build a SkRegion (it builds SkAAClip).
  */
-void SkPDFCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPDFCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipRect(rect, op, kHard_ClipEdgeStyle);
 }
 
-void SkPDFCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPDFCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipRRect(rrect, op, kHard_ClipEdgeStyle);
 }
 
-void SkPDFCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPDFCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipPath(path, op, kHard_ClipEdgeStyle);
 }
 
diff --git a/src/pdf/SkPDFCanvas.h b/src/pdf/SkPDFCanvas.h
index 5040e98..ead13c3 100644
--- a/src/pdf/SkPDFCanvas.h
+++ b/src/pdf/SkPDFCanvas.h
@@ -17,9 +17,9 @@
     ~SkPDFCanvas();
 
 protected:
-    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 onClipRect(const SkRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipRRect(const SkRRect&, ClipOp, ClipEdgeStyle) override;
+    void onClipPath(const SkPath&, ClipOp, ClipEdgeStyle) override;
 
     void onDrawBitmapNine(const SkBitmap&, const SkIRect&, const SkRect&,
                           const SkPaint*) override;
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 0e54bfd..5299d70 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -176,9 +176,9 @@
 static_assert(SkRegion::kReverseDifference_Op == (int)kReverseDifference_SkPathOp,
               "region_pathop_mismatch");
 
-static SkPathOp region_op_to_pathops_op(SkRegion::Op op) {
+static SkPathOp region_op_to_pathops_op(SkCanvas::ClipOp op) {
     SkASSERT(op >= 0);
-    SkASSERT(op <= SkRegion::kReverseDifference_Op);
+    SkASSERT(op <= SkCanvas::kReverseDifference_Op);
     return (SkPathOp)op;
 }
 
@@ -209,7 +209,7 @@
         }
         entryPath.transform(transform);
 
-        if (SkRegion::kReplace_Op == clipEntry->getOp()) {
+        if (SkCanvas::kReplace_Op == clipEntry->getOp()) {
             *outClipPath = entryPath;
         } else {
             SkPathOp op = region_op_to_pathops_op(clipEntry->getOp());
@@ -1753,7 +1753,7 @@
             synthesizedClipStack = fExistingClipStack;
             SkPath clipPath;
             clipRegion.getBoundaryPath(&clipPath);
-            synthesizedClipStack.clipDevPath(clipPath, SkRegion::kReplace_Op,
+            synthesizedClipStack.clipDevPath(clipPath, SkCanvas::kReplace_Op,
                                              false);
             clipStack = &synthesizedClipStack;
         }
diff --git a/src/pipe/SkPipeCanvas.cpp b/src/pipe/SkPipeCanvas.cpp
index 224451f..21b7267 100644
--- a/src/pipe/SkPipeCanvas.cpp
+++ b/src/pipe/SkPipeCanvas.cpp
@@ -318,21 +318,21 @@
     this->INHERITED::didSetMatrix(matrix);
 }
 
-void SkPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPipeCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     fStream->write32(pack_verb(SkPipeVerb::kClipRect, ((unsigned)op << 1) | edgeStyle));
     fStream->write(&rect, 4 * sizeof(SkScalar));
 
     this->INHERITED::onClipRect(rect, op, edgeStyle);
 }
 
-void SkPipeCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPipeCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     fStream->write32(pack_verb(SkPipeVerb::kClipRRect, ((unsigned)op << 1) | edgeStyle));
     write_rrect(fStream, rrect);
 
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-void SkPipeCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkPipeCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     SkPipeWriter writer(this);
     writer.write32(pack_verb(SkPipeVerb::kClipPath, ((unsigned)op << 1) | edgeStyle));
     writer.writePath(path);
@@ -340,7 +340,7 @@
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-void SkPipeCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkPipeCanvas::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     SkPipeWriter writer(this);
     writer.write32(pack_verb(SkPipeVerb::kClipRegion, (unsigned)op << 1));
     writer.writeRegion(deviceRgn);
diff --git a/src/pipe/SkPipeCanvas.h b/src/pipe/SkPipeCanvas.h
index 82e54fc..50d76ed 100644
--- a/src/pipe/SkPipeCanvas.h
+++ b/src/pipe/SkPipeCanvas.h
@@ -140,10 +140,10 @@
                               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;
     void onDrawAnnotation(const SkRect&, const char[], SkData*) override;
diff --git a/src/pipe/SkPipeReader.cpp b/src/pipe/SkPipeReader.cpp
index e0ca373..7157813 100644
--- a/src/pipe/SkPipeReader.cpp
+++ b/src/pipe/SkPipeReader.cpp
@@ -268,21 +268,21 @@
 
 static void clipRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
     SkASSERT(SkPipeVerb::kClipRect == unpack_verb(packedVerb));
-    SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+    SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
     bool isAA = unpack_verb_extra(packedVerb) & 1;
     canvas->clipRect(*skip<SkRect>(reader), op, isAA);
 }
 
 static void clipRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
     SkASSERT(SkPipeVerb::kClipRRect == unpack_verb(packedVerb));
-    SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+    SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
     bool isAA = unpack_verb_extra(packedVerb) & 1;
     canvas->clipRRect(read_rrect(reader), op, isAA);
 }
 
 static void clipPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
     SkASSERT(SkPipeVerb::kClipPath == unpack_verb(packedVerb));
-    SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+    SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
     bool isAA = unpack_verb_extra(packedVerb) & 1;
     SkPath path;
     reader.readPath(&path);
@@ -291,7 +291,7 @@
 
 static void clipRegion_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
     SkASSERT(SkPipeVerb::kClipRegion == unpack_verb(packedVerb));
-    SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+    SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
     SkRegion region;
     reader.readRegion(&region);
     canvas->clipRegion(region, op);
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index d4d18da..99e8246 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -730,7 +730,7 @@
         draw.fMatrix->mapRect(&devClipRect, dst);
 
         adjustedClipStack = *draw.fClipStack;
-        adjustedClipStack.clipDevRect(devClipRect, SkRegion::kIntersect_Op, paint.isAntiAlias());
+        adjustedClipStack.clipDevRect(devClipRect, SkCanvas::kIntersect_Op, paint.isAntiAlias());
         adjustedDraw.fClipStack = &adjustedClipStack;
     }
 
diff --git a/src/utils/SkCanvasStack.cpp b/src/utils/SkCanvasStack.cpp
index a5a483d..58607d7 100644
--- a/src/utils/SkCanvasStack.cpp
+++ b/src/utils/SkCanvasStack.cpp
@@ -53,7 +53,7 @@
 void SkCanvasStack::clipToZOrderedBounds() {
     SkASSERT(fList.count() == fCanvasData.count());
     for (int i = 0; i < fList.count(); ++i) {
-        fList[i]->clipRegion(fCanvasData[i].requiredClip, SkRegion::kIntersect_Op);
+        fList[i]->clipRegion(fCanvasData[i].requiredClip);
     }
 }
 
@@ -76,22 +76,22 @@
     this->SkCanvas::didSetMatrix(matrix);
 }
 
-void SkCanvasStack::onClipRect(const SkRect& r, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvasStack::onClipRect(const SkRect& r, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipRect(r, op, edgeStyle);
     this->clipToZOrderedBounds();
 }
 
-void SkCanvasStack::onClipRRect(const SkRRect& rr, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvasStack::onClipRRect(const SkRRect& rr, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipRRect(rr, op, edgeStyle);
     this->clipToZOrderedBounds();
 }
 
-void SkCanvasStack::onClipPath(const SkPath& p, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkCanvasStack::onClipPath(const SkPath& p, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->INHERITED::onClipPath(p, op, edgeStyle);
     this->clipToZOrderedBounds();
 }
 
-void SkCanvasStack::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkCanvasStack::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     SkASSERT(fList.count() == fCanvasData.count());
     for (int i = 0; i < fList.count(); ++i) {
         SkRegion tempRegion;
diff --git a/src/utils/SkCanvasStack.h b/src/utils/SkCanvasStack.h
index 300bcd3..762ab9f 100644
--- a/src/utils/SkCanvasStack.h
+++ b/src/utils/SkCanvasStack.h
@@ -31,10 +31,10 @@
 protected:
     void didSetMatrix(const SkMatrix&) 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;
 
 private:
     void clipToZOrderedBounds();
diff --git a/src/utils/SkCanvasStateUtils.cpp b/src/utils/SkCanvasStateUtils.cpp
index 4ef5e2f..cc8ea43 100644
--- a/src/utils/SkCanvasStateUtils.cpp
+++ b/src/utils/SkCanvasStateUtils.cpp
@@ -142,15 +142,15 @@
     bool failed() { return fFailed; }
 
     // ClipVisitor
-    void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) override {
+    void clipRect(const SkRect& rect, SkCanvas::ClipOp op, bool antialias) override {
         fFailed |= antialias;
     }
 
-    void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) override {
+    void clipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool antialias) override {
         fFailed |= antialias;
     }
 
-    void clipPath(const SkPath&, SkRegion::Op, bool antialias) override {
+    void clipPath(const SkPath&, SkCanvas::ClipOp, bool antialias) override {
         fFailed |= antialias;
     }
 
@@ -284,7 +284,7 @@
     }
 
     canvas->setMatrix(matrix);
-    canvas->setClipRegion(clip);
+    canvas->clipRegion(clip, SkCanvas::kReplace_Op);
 }
 
 static SkCanvas* create_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) {
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index d2f95d9..c8af14c 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -99,7 +99,7 @@
         case kClipRect_Type:
             fCanvas->clipRect(rec.fData.fBounds);
             this->INHERITED::onClipRect(rec.fData.fBounds,
-                                        SkRegion::kIntersect_Op, kHard_ClipEdgeStyle);
+                                        kIntersect_Op, kHard_ClipEdgeStyle);
             break;
         case kTrans_Type:
         case kScaleTrans_Type: {
@@ -272,8 +272,8 @@
     this->INHERITED::didSetMatrix(matrix);
 }
 
-void SkDeferredCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
-    if (SkRegion::kIntersect_Op == op) {
+void SkDeferredCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
+    if (kIntersect_Op == op) {
         this->push_cliprect(rect);
     } else {
         this->flush_all();
@@ -282,19 +282,19 @@
     }
 }
 
-void SkDeferredCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDeferredCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->flush_all();
     fCanvas->clipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-void SkDeferredCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDeferredCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->flush_all();
     fCanvas->clipPath(path, op, kSoft_ClipEdgeStyle == edgeStyle);
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-void SkDeferredCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkDeferredCanvas::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     this->flush_all();
     fCanvas->clipRegion(deviceRgn, op);
     this->INHERITED::onClipRegion(deviceRgn, op);
diff --git a/src/utils/SkDeferredCanvas.h b/src/utils/SkDeferredCanvas.h
index faa3d66..05ad4cf 100644
--- a/src/utils/SkDeferredCanvas.h
+++ b/src/utils/SkDeferredCanvas.h
@@ -86,10 +86,10 @@
                      int count, SkXfermode::Mode mode,
                      const SkRect* cull, const SkPaint* paint) 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 onDrawDrawable(SkDrawable*, const SkMatrix*) override;
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
diff --git a/src/utils/SkDumpCanvas.cpp b/src/utils/SkDumpCanvas.cpp
index ca18864..fcb24d2 100644
--- a/src/utils/SkDumpCanvas.cpp
+++ b/src/utils/SkDumpCanvas.cpp
@@ -105,7 +105,7 @@
     }
 }
 
-static const char* toString(SkRegion::Op op) {
+static const char* toString(SkCanvas::ClipOp op) {
     static const char* gOpNames[] = {
         "DIFF", "SECT", "UNION", "XOR", "RDIFF", "REPLACE"
     };
@@ -258,7 +258,7 @@
     return kSoft_ClipEdgeStyle == edgeStyle ? "AA" : "BW";
 }
 
-void SkDumpCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDumpCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     SkString str;
     toString(rect, &str);
     this->dump(kClip_Verb, nullptr, "clipRect(%s %s %s)", str.c_str(), toString(op),
@@ -266,7 +266,7 @@
     this->INHERITED::onClipRect(rect, op, edgeStyle);
 }
 
-void SkDumpCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDumpCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     SkString str;
     toString(rrect, &str);
     this->dump(kClip_Verb, nullptr, "clipRRect(%s %s %s)", str.c_str(), toString(op),
@@ -274,7 +274,7 @@
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-void SkDumpCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDumpCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     SkString str;
     toString(path, &str);
     this->dump(kClip_Verb, nullptr, "clipPath(%s %s %s)", str.c_str(), toString(op),
@@ -282,7 +282,7 @@
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-void SkDumpCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkDumpCanvas::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     SkString str;
     toString(deviceRgn, &str);
     this->dump(kClip_Verb, nullptr, "clipRegion(%s %s)", str.c_str(),
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 117cb8a..d9beaed 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -405,7 +405,7 @@
             this->pushPath(element.getPath(), "path");
             break;
     }
-    this->pushString(region_op(element.getOp()), "op");
+    this->pushString(region_op((SkRegion::Op)element.getOp()), "op");
     this->pushBool(element.isAA(), "aa");
     CHECK_SETFIELD(key);
 }
diff --git a/src/utils/SkLuaCanvas.cpp b/src/utils/SkLuaCanvas.cpp
index 3883924..6b769f0 100644
--- a/src/utils/SkLuaCanvas.cpp
+++ b/src/utils/SkLuaCanvas.cpp
@@ -135,28 +135,28 @@
     this->INHERITED::didSetMatrix(matrix);
 }
 
-void SkLuaCanvas::onClipRect(const SkRect& r, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkLuaCanvas::onClipRect(const SkRect& r, ClipOp op, ClipEdgeStyle edgeStyle) {
     AUTO_LUA("clipRect");
     lua.pushRect(r, "rect");
     lua.pushBool(kSoft_ClipEdgeStyle == edgeStyle, "aa");
     this->INHERITED::onClipRect(r, op, edgeStyle);
 }
 
-void SkLuaCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkLuaCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     AUTO_LUA("clipRRect");
     lua.pushRRect(rrect, "rrect");
     lua.pushBool(kSoft_ClipEdgeStyle == edgeStyle, "aa");
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-void SkLuaCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkLuaCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     AUTO_LUA("clipPath");
     lua.pushPath(path, "path");
     lua.pushBool(kSoft_ClipEdgeStyle == edgeStyle, "aa");
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-void SkLuaCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkLuaCanvas::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     AUTO_LUA("clipRegion");
     this->INHERITED::onClipRegion(deviceRgn, op);
 }
diff --git a/src/utils/SkNWayCanvas.cpp b/src/utils/SkNWayCanvas.cpp
index 1cd3dc4..e19e7a8 100644
--- a/src/utils/SkNWayCanvas.cpp
+++ b/src/utils/SkNWayCanvas.cpp
@@ -100,7 +100,7 @@
     this->INHERITED::didSetMatrix(matrix);
 }
 
-void SkNWayCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkNWayCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     Iter iter(fList);
     while (iter.next()) {
         iter->clipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle);
@@ -108,7 +108,7 @@
     this->INHERITED::onClipRect(rect, op, edgeStyle);
 }
 
-void SkNWayCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkNWayCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     Iter iter(fList);
     while (iter.next()) {
         iter->clipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
@@ -116,7 +116,7 @@
     this->INHERITED::onClipRRect(rrect, op, edgeStyle);
 }
 
-void SkNWayCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkNWayCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     Iter iter(fList);
     while (iter.next()) {
         iter->clipPath(path, op, kSoft_ClipEdgeStyle == edgeStyle);
@@ -124,7 +124,7 @@
     this->INHERITED::onClipPath(path, op, edgeStyle);
 }
 
-void SkNWayCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+void SkNWayCanvas::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
     Iter iter(fList);
     while (iter.next()) {
         iter->clipRegion(deviceRgn, op);
diff --git a/tests/CanvasStateTest.cpp b/tests/CanvasStateTest.cpp
index cd7a418..d9abd9d 100644
--- a/tests/CanvasStateTest.cpp
+++ b/tests/CanvasStateTest.cpp
@@ -304,7 +304,7 @@
     SkRRect roundRect;
     roundRect.setOval(SkRect::MakeWH(5, 5));
 
-    canvas.clipRRect(roundRect, SkRegion::kIntersect_Op, true);
+    canvas.clipRRect(roundRect, SkCanvas::kIntersect_Op, true);
 
     SkSetErrorCallback(error_callback, nullptr);
 
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index b209d0d..5964297 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -173,13 +173,13 @@
 public:
     Canvas2CanvasClipVisitor(SkCanvas* target) : fTarget(target) {}
 
-    void clipRect(const SkRect& r, SkRegion::Op op, bool aa) override {
+    void clipRect(const SkRect& r, SkCanvas::ClipOp op, bool aa) override {
         fTarget->clipRect(r, op, aa);
     }
-    void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) override {
+    void clipRRect(const SkRRect& r, SkCanvas::ClipOp op, bool aa) override {
         fTarget->clipRRect(r, op, aa);
     }
-    void clipPath(const SkPath& p, SkRegion::Op op, bool aa) override {
+    void clipPath(const SkPath& p, SkCanvas::ClipOp op, bool aa) override {
         fTarget->clipPath(p, op, aa);
     }
 
@@ -299,7 +299,7 @@
 SIMPLE_TEST_STEP(SetMatrix, setMatrix(d.fMatrix));
 SIMPLE_TEST_STEP(ClipRect, clipRect(d.fRect));
 SIMPLE_TEST_STEP(ClipPath, clipPath(d.fPath));
-SIMPLE_TEST_STEP(ClipRegion, clipRegion(d.fRegion, SkRegion::kReplace_Op));
+SIMPLE_TEST_STEP(ClipRegion, clipRegion(d.fRegion, SkCanvas::kReplace_Op));
 SIMPLE_TEST_STEP(Clear, clear(d.fColor));
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/tests/ClipBoundsTest.cpp b/tests/ClipBoundsTest.cpp
index ae2c027..0373b89 100644
--- a/tests/ClipBoundsTest.cpp
+++ b/tests/ClipBoundsTest.cpp
@@ -26,7 +26,7 @@
     // create a clip stack that will (trivially) reduce to a single rect that
     // is larger than the screen
     SkClipStack stack;
-    stack.clipDevRect(clipRect, SkRegion::kReplace_Op, false);
+    stack.clipDevRect(clipRect, SkCanvas::kReplace_Op, false);
 
     bool isIntersectionOfRects = true;
     SkRect devStackBounds;
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 394835b..5d6cf32 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -33,21 +33,21 @@
     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;
@@ -62,7 +62,7 @@
     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.
@@ -71,7 +71,7 @@
     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.
@@ -79,7 +79,7 @@
     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.
@@ -89,7 +89,7 @@
     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
@@ -112,7 +112,7 @@
     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);
 }
 
@@ -140,7 +140,7 @@
 
     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);
@@ -181,7 +181,7 @@
 
         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]);
     }
@@ -220,12 +220,12 @@
         { 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;
@@ -265,15 +265,15 @@
                     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;
             }
@@ -286,7 +286,7 @@
 
             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);
             }
@@ -334,8 +334,8 @@
         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());
@@ -345,7 +345,7 @@
     {
         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());
@@ -358,7 +358,7 @@
         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());
@@ -370,7 +370,7 @@
 
         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());
@@ -404,7 +404,7 @@
     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;
@@ -426,9 +426,9 @@
     {
         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));
     }
 
@@ -437,9 +437,9 @@
     {
         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));
     }
 
@@ -448,23 +448,23 @@
     {
         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);
@@ -472,16 +472,16 @@
         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));
@@ -498,18 +498,18 @@
     {
         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));
     }
 }
@@ -532,9 +532,9 @@
     {
         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));
 
@@ -547,9 +547,9 @@
     {
         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));
 
@@ -562,9 +562,9 @@
     {
         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));
 
@@ -577,9 +577,9 @@
     {
         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));
 
@@ -592,9 +592,9 @@
     {
         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));
 
@@ -607,9 +607,9 @@
     {
         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));
 
@@ -637,7 +637,7 @@
 
     {
         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));
     }
@@ -645,24 +645,24 @@
     // 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();
     }
@@ -670,59 +670,59 @@
     // 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));
     }
 
@@ -732,7 +732,7 @@
         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));
     }
 
@@ -741,7 +741,7 @@
         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));
     }
 
@@ -750,7 +750,7 @@
         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));
     }
 
@@ -759,7 +759,7 @@
         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));
     }
 
@@ -768,7 +768,7 @@
         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));
     }
 
@@ -776,7 +776,7 @@
         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));
     }
 
@@ -784,7 +784,7 @@
         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));
     }
 
@@ -792,7 +792,7 @@
         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));
     }
 }
@@ -814,18 +814,18 @@
                 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());
 
@@ -851,11 +851,11 @@
 // 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;
@@ -871,7 +871,7 @@
     }
 };
 
-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;
@@ -883,7 +883,7 @@
     }
 };
 
-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);
@@ -929,13 +929,13 @@
     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
@@ -965,8 +965,8 @@
         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;
@@ -1051,8 +1051,8 @@
         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;
@@ -1076,8 +1076,8 @@
 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;
@@ -1098,13 +1098,13 @@
         //  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();
 
 
@@ -1183,8 +1183,8 @@
 
 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.
@@ -1284,7 +1284,7 @@
         // 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);
@@ -1292,7 +1292,7 @@
         // 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);
@@ -1300,7 +1300,7 @@
         // 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);
@@ -1308,8 +1308,8 @@
         // 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);
@@ -1320,8 +1320,8 @@
         // 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);
@@ -1362,7 +1362,7 @@
         { 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
@@ -1373,7 +1373,7 @@
 
     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());
diff --git a/tests/DrawPathTest.cpp b/tests/DrawPathTest.cpp
index 9038406..87d51b1 100644
--- a/tests/DrawPathTest.cpp
+++ b/tests/DrawPathTest.cpp
@@ -339,7 +339,7 @@
     };
     SkRRect rr;
     rr.setRectRadii(r, radii);
-    canvas->clipRRect(rr, SkRegion::kIntersect_Op, false);
+    canvas->clipRRect(rr);
 
     SkRect r2 = SkRect::MakeLTRB(0, 33, 1102, 33554464);
     canvas->drawRect(r2, p);
diff --git a/tests/GrShapeTest.cpp b/tests/GrShapeTest.cpp
index 6e1901f..36ebd7b 100644
--- a/tests/GrShapeTest.cpp
+++ b/tests/GrShapeTest.cpp
@@ -52,7 +52,7 @@
     SkMatrix matrix;
     matrix.setRectToRect(bounds, clip, SkMatrix::kFill_ScaleToFit);
     clip.outset(SkIntToScalar(kTol), SkIntToScalar(kTol));
-    surface->getCanvas()->clipRect(clip, SkRegion::kDifference_Op);
+    surface->getCanvas()->clipRect(clip, SkCanvas::kDifference_Op);
     surface->getCanvas()->concat(matrix);
     SkPaint whitePaint;
     whitePaint.setColor(SK_ColorWHITE);
diff --git a/tests/PictureBBHTest.cpp b/tests/PictureBBHTest.cpp
index deb299a..b8698bc 100644
--- a/tests/PictureBBHTest.cpp
+++ b/tests/PictureBBHTest.cpp
@@ -75,11 +75,9 @@
 
     void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) override {
         // intersect with out of bounds rect -> empty clip.
-        playbackCanvas.clipRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
-            SkIntToScalar(1), SkIntToScalar(1)), SkRegion::kIntersect_Op);
+        playbackCanvas.clipRect(SkRect::MakeXYWH(10, 10, 1, 1));
         SkPaint paint;
-        recordingCanvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
-            SkIntToScalar(3), SkIntToScalar(3)), paint);
+        recordingCanvas.drawRect(SkRect::MakeWH(3, 3), paint);
     }
 
     virtual ~EmptyClipPictureBBHTest() { }
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 6ab57c0..425d14f 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -288,7 +288,7 @@
         for (int i = 0; i < 50; ++i) {
             canvas->clipPath(convexClip);
             canvas->clipPath(concaveClip);
-            canvas->clipPath(convexClip, SkRegion::kIntersect_Op, true);
+            canvas->clipPath(convexClip, SkCanvas::kIntersect_Op, true);
             canvas->drawRect(SkRect::MakeWH(100, 100), SkPaint());
         }
     }
@@ -300,7 +300,7 @@
     {
         const SkPath concaveClip = make_concave_path();
         for (int i = 0; i < 50; ++i) {
-            canvas->clipPath(concaveClip, SkRegion::kIntersect_Op, true);
+            canvas->clipPath(concaveClip, SkCanvas::kIntersect_Op, true);
             canvas->drawRect(SkRect::MakeWH(100, 100), SkPaint());
         }
     }
@@ -399,7 +399,7 @@
     SkRect clipRect = SkRect::MakeWH(2, 2);
     SkRect drawRect = SkRect::MakeWH(10, 10);
     canvas->save();
-        canvas->clipRect(clipRect, SkRegion::kReplace_Op);
+        canvas->clipRect(clipRect, SkCanvas::kReplace_Op);
         canvas->translate(1.0f, 1.0f);
         SkPaint p;
         p.setColor(SK_ColorGREEN);
@@ -737,7 +737,7 @@
     // Testing conservative-raster-clip that is enabled by PictureRecord
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(invPath, SkRegion::kIntersect_Op);
+        canvas->clipPath(invPath);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
@@ -747,8 +747,8 @@
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(invPath, SkRegion::kIntersect_Op);
+        canvas->clipPath(path);
+        canvas->clipPath(invPath);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
@@ -758,8 +758,8 @@
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(invPath, SkRegion::kUnion_Op);
+        canvas->clipPath(path);
+        canvas->clipPath(invPath, SkCanvas::kUnion_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
@@ -769,7 +769,7 @@
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kDifference_Op);
+        canvas->clipPath(path, SkCanvas::kDifference_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
@@ -779,7 +779,7 @@
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kReverseDifference_Op);
+        canvas->clipPath(path, SkCanvas::kReverseDifference_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         // True clip is actually empty in this case, but the best
         // determination we can make using only bounds as input is that the
@@ -792,8 +792,8 @@
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(path2, SkRegion::kXOR_Op);
+        canvas->clipPath(path, SkCanvas::kIntersect_Op);
+        canvas->clipPath(path2, SkCanvas::kXOR_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 6 == clipBounds.fLeft);
@@ -841,28 +841,22 @@
         , fClipCount(0){
     }
 
-    virtual void onClipRect(const SkRect& r,
-                            SkRegion::Op op,
-                            ClipEdgeStyle edgeStyle) override {
+    void onClipRect(const SkRect& r, ClipOp op, ClipEdgeStyle edgeStyle) override {
         fClipCount += 1;
         this->INHERITED::onClipRect(r, op, edgeStyle);
     }
 
-    virtual void onClipRRect(const SkRRect& rrect,
-                             SkRegion::Op op,
-                             ClipEdgeStyle edgeStyle)override {
+    void onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle)override {
         fClipCount += 1;
         this->INHERITED::onClipRRect(rrect, op, edgeStyle);
     }
 
-    virtual void onClipPath(const SkPath& path,
-                            SkRegion::Op op,
-                            ClipEdgeStyle edgeStyle) override {
+    void onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) override {
         fClipCount += 1;
         this->INHERITED::onClipPath(path, op, edgeStyle);
     }
 
-    void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override {
+    void onClipRegion(const SkRegion& deviceRgn, ClipOp op) override {
         fClipCount += 1;
         this->INHERITED::onClipRegion(deviceRgn, op);
     }
@@ -879,9 +873,9 @@
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(10, 10);
 
-    canvas->clipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op);
+    canvas->clipRect(SkRect::MakeEmpty(), SkCanvas::kReplace_Op);
     // The following expanding clip should not be skipped.
-    canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op);
+    canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkCanvas::kUnion_Op);
     // Draw something so the optimizer doesn't just fold the world.
     SkPaint p;
     p.setColor(SK_ColorBLUE);
@@ -1235,14 +1229,14 @@
     const SkPath convexClip = make_convex_path();
     const SkPath concaveClip = make_concave_path();
     for (int i = 0; i < 50; ++i) {
-        analyzer.analyzeClipPath(convexClip, SkRegion::kIntersect_Op, false);
-        analyzer.analyzeClipPath(convexClip, SkRegion::kIntersect_Op, true);
-        analyzer.analyzeClipPath(concaveClip, SkRegion::kIntersect_Op, false);
+        analyzer.analyzeClipPath(convexClip, SkCanvas::kIntersect_Op, false);
+        analyzer.analyzeClipPath(convexClip, SkCanvas::kIntersect_Op, true);
+        analyzer.analyzeClipPath(concaveClip, SkCanvas::kIntersect_Op, false);
     }
     REPORTER_ASSERT(r, analyzer.suitableForGpuRasterization());
 
     for (int i = 0; i < 50; ++i) {
-        analyzer.analyzeClipPath(concaveClip, SkRegion::kIntersect_Op, true);
+        analyzer.analyzeClipPath(concaveClip, SkCanvas::kIntersect_Op, true);
     }
     REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization());
 }
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index c1fa4d2..5fbaf9b 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -8,7 +8,6 @@
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkMathPriv.h"
-#include "SkRegion.h"
 #include "SkSurface.h"
 #include "Test.h"
 
@@ -112,7 +111,7 @@
 static void fill_src_canvas(SkCanvas* canvas) {
     canvas->save();
     canvas->setMatrix(SkMatrix::I());
-    canvas->clipRect(DEV_RECT_S, SkRegion::kReplace_Op);
+    canvas->clipRect(DEV_RECT_S, SkCanvas::kReplace_Op);
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     canvas->drawBitmap(make_src_bitmap(), 0, 0, &paint);
diff --git a/tests/SkLiteDLTest.cpp b/tests/SkLiteDLTest.cpp
index 70a9077..f3fccc8 100644
--- a/tests/SkLiteDLTest.cpp
+++ b/tests/SkLiteDLTest.cpp
@@ -13,7 +13,7 @@
     sk_sp<SkLiteDL> p { SkLiteDL::New({2,2,3,3}) };
 
     p->save();
-        p->clipRect(SkRect{2,3,4,5}, SkRegion::kIntersect_Op, true);
+        p->clipRect(SkRect{2,3,4,5}, SkCanvas::kIntersect_Op, true);
         p->drawRect(SkRect{0,0,9,9}, SkPaint{});
     p->restore();
 }
@@ -27,7 +27,7 @@
     rec.reset(p.get());
 
     c->save();
-        c->clipRect(SkRect{2,3,4,5}, SkRegion::kIntersect_Op, true);
+        c->clipRect(SkRect{2,3,4,5}, SkCanvas::kIntersect_Op, true);
         c->drawRect(SkRect{0,0,9,9}, SkPaint{});
     c->restore();
 }
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 1839a40..c59aa2d 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -8,7 +8,6 @@
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkMathPriv.h"
-#include "SkRegion.h"
 #include "SkSurface.h"
 #include "Test.h"
 #include "sk_tool_utils.h"
@@ -121,7 +120,7 @@
     }
     canvas->save();
     canvas->setMatrix(SkMatrix::I());
-    canvas->clipRect(DEV_RECT_S, SkRegion::kReplace_Op);
+    canvas->clipRect(DEV_RECT_S, SkCanvas::kReplace_Op);
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     canvas->drawBitmap(bmp, 0, 0, &paint);
diff --git a/tools/debugger/SkDebugCanvas.cpp b/tools/debugger/SkDebugCanvas.cpp
index 4c633ab..f15c68c 100644
--- a/tools/debugger/SkDebugCanvas.cpp
+++ b/tools/debugger/SkDebugCanvas.cpp
@@ -107,7 +107,7 @@
     SkASSERT(!large.roundOut().isEmpty());
 #endif
     // call the base class' version to avoid adding a draw command
-    this->INHERITED::onClipRect(large, SkRegion::kReplace_Op, kHard_ClipEdgeStyle);
+    this->INHERITED::onClipRect(large, kReplace_Op, kHard_ClipEdgeStyle);
 }
 
 SkDebugCanvas::~SkDebugCanvas() {
@@ -155,21 +155,21 @@
 public:
     SkDebugClipVisitor(SkCanvas* canvas) : fCanvas(canvas) {}
 
-    void clipRect(const SkRect& r, SkRegion::Op, bool doAA) override {
+    void clipRect(const SkRect& r, SkCanvas::ClipOp, bool doAA) override {
         SkPaint p;
         p.setColor(SK_ColorRED);
         p.setStyle(SkPaint::kStroke_Style);
         p.setAntiAlias(doAA);
         fCanvas->drawRect(r, p);
     }
-    void clipRRect(const SkRRect& rr, SkRegion::Op, bool doAA) override {
+    void clipRRect(const SkRRect& rr, SkCanvas::ClipOp, bool doAA) override {
         SkPaint p;
         p.setColor(SK_ColorGREEN);
         p.setStyle(SkPaint::kStroke_Style);
         p.setAntiAlias(doAA);
         fCanvas->drawRRect(rr, p);
     }
-    void clipPath(const SkPath& path, SkRegion::Op, bool doAA) override {
+    void clipPath(const SkPath& path, SkCanvas::ClipOp, bool doAA) override {
         SkPaint p;
         p.setColor(SK_ColorBLUE);
         p.setStyle(SkPaint::kStroke_Style);
@@ -222,7 +222,7 @@
     canvas->clear(SK_ColorWHITE);
     canvas->resetMatrix();
     if (!windowRect.isEmpty()) {
-        canvas->clipRect(windowRect, SkRegion::kReplace_Op);
+        canvas->clipRect(windowRect, SkCanvas::kReplace_Op);
     }
     this->applyUserTransform(canvas);
 
@@ -284,7 +284,7 @@
         canvas->save();
         #define LARGE_COORD 1000000000
         canvas->clipRect(SkRect::MakeLTRB(-LARGE_COORD, -LARGE_COORD, LARGE_COORD, LARGE_COORD),
-                       SkRegion::kReverseDifference_Op);
+                       SkCanvas::kReverseDifference_Op);
         SkPaint clipPaint;
         clipPaint.setColor(fClipVizColor);
         canvas->drawPaint(clipPaint);
@@ -299,7 +299,7 @@
         if (!windowRect.isEmpty()) {
             SkRect r = windowRect;
             r.outset(SK_Scalar1, SK_Scalar1);
-            canvas->clipRect(r, SkRegion::kReplace_Op);
+            canvas->clipRect(r, SkCanvas::kReplace_Op);
         }
         // visualize existing clips
         SkDebugClipVisitor visitor(canvas);
@@ -320,9 +320,9 @@
             if (type != SkClipStack::Element::kEmpty_Type) {
                element->asPath(&operand);
             }
-            SkRegion::Op elementOp = element->getOp();
+            SkCanvas::ClipOp elementOp = element->getOp();
             this->addClipStackData(devPath, operand, elementOp);
-            if (elementOp == SkRegion::kReplace_Op) {
+            if (elementOp == SkCanvas::kReplace_Op) {
                 devPath = operand;
             } else {
                 Op(devPath, operand, (SkPathOp) elementOp, &devPath);
@@ -543,19 +543,19 @@
     this->updatePaintFilterCanvas();
 }
 
-void SkDebugCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDebugCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->addDrawCommand(new SkClipPathCommand(path, op, kSoft_ClipEdgeStyle == edgeStyle));
 }
 
-void SkDebugCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDebugCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->addDrawCommand(new SkClipRectCommand(rect, op, kSoft_ClipEdgeStyle == edgeStyle));
 }
 
-void SkDebugCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+void SkDebugCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
     this->addDrawCommand(new SkClipRRectCommand(rrect, op, kSoft_ClipEdgeStyle == edgeStyle));
 }
 
-void SkDebugCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) {
+void SkDebugCanvas::onClipRegion(const SkRegion& region, ClipOp op) {
     this->addDrawCommand(new SkClipRegionCommand(region, op));
 }
 
@@ -828,8 +828,8 @@
 }
 
 void SkDebugCanvas::addClipStackData(const SkPath& devPath, const SkPath& operand,
-                                     SkRegion::Op elementOp) {
-    if (elementOp == SkRegion::kReplace_Op) {
+                                     SkCanvas::ClipOp elementOp) {
+    if (elementOp == SkCanvas::kReplace_Op) {
         if (!lastClipStackData(devPath)) {
             fSaveDevPath = operand;
         }
diff --git a/tools/debugger/SkDebugCanvas.h b/tools/debugger/SkDebugCanvas.h
index 6a3d925..5d00799 100644
--- a/tools/debugger/SkDebugCanvas.h
+++ b/tools/debugger/SkDebugCanvas.h
@@ -248,10 +248,10 @@
                          const SkPaint*, SrcRectConstraint) override;
     void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
                           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& region, 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& region, ClipOp) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
 
@@ -310,7 +310,7 @@
 
     void resetClipStackData() { fClipStackData.reset(); fCalledAddStackData = false; }
 
-    void addClipStackData(const SkPath& devPath, const SkPath& operand, SkRegion::Op elementOp);
+    void addClipStackData(const SkPath& devPath, const SkPath& operand, ClipOp elementOp);
     void addPathData(const SkPath& path, const char* pathName);
     bool lastClipStackData(const SkPath& devPath);
     void outputConicPoints(const SkPoint* pts, SkScalar weight);
diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index 75978d4..35e9201 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -573,19 +573,19 @@
     return Json::Value("<unimplemented>");
 }
 
-static Json::Value make_json_regionop(SkRegion::Op op) {
+static Json::Value make_json_regionop(SkCanvas::ClipOp op) {
     switch (op) {
-        case SkRegion::kDifference_Op:
+        case SkCanvas::kDifference_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_DIFFERENCE);
-        case SkRegion::kIntersect_Op:
+        case SkCanvas::kIntersect_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_INTERSECT);
-        case SkRegion::kUnion_Op:
+        case SkCanvas::kUnion_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_UNION);
-        case SkRegion::kXOR_Op:
+        case SkCanvas::kXOR_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_XOR);
-        case SkRegion::kReverseDifference_Op:
+        case SkCanvas::kReverseDifference_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE);
-        case SkRegion::kReplace_Op:
+        case SkCanvas::kReplace_Op:
             return Json::Value(SKDEBUGCANVAS_REGIONOP_REPLACE);
         default:
             SkASSERT(false);
@@ -1605,28 +1605,28 @@
     }
 }
 
-SkRegion::Op get_json_regionop(Json::Value& jsonOp) {
+SkCanvas::ClipOp get_json_clipop(Json::Value& jsonOp) {
     const char* op = jsonOp.asCString();
     if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_DIFFERENCE)) {
-        return SkRegion::kDifference_Op;
+        return SkCanvas::kDifference_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_INTERSECT)) {
-        return SkRegion::kIntersect_Op;
+        return SkCanvas::kIntersect_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_UNION)) {
-        return SkRegion::kUnion_Op;
+        return SkCanvas::kUnion_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_XOR)) {
-        return SkRegion::kXOR_Op;
+        return SkCanvas::kXOR_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE)) {
-        return SkRegion::kReverseDifference_Op;
+        return SkCanvas::kReverseDifference_Op;
     }
     else if (!strcmp(op, SKDEBUGCANVAS_REGIONOP_REPLACE)) {
-        return SkRegion::kReplace_Op;
+        return SkCanvas::kReplace_Op;
     }
     SkASSERT(false);
-    return SkRegion::kIntersect_Op;
+    return SkCanvas::kIntersect_Op;
 }
 
 SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kDrawClear_OpType) {
@@ -1649,14 +1649,14 @@
     return new SkClearCommand(get_json_color(color));
 }
 
-SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA)
+SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkCanvas::ClipOp op, bool doAA)
     : INHERITED(kClipPath_OpType) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::PathToString(path));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
+    fInfo.push(SkObjectParser::ClipOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
@@ -1681,17 +1681,17 @@
                                                UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
-    return new SkClipPathCommand(path, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
+    return new SkClipPathCommand(path, get_json_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
-SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op)
+SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkCanvas::ClipOp op)
     : INHERITED(kClipRegion_OpType) {
     fRegion = region;
     fOp = op;
 
     fInfo.push(SkObjectParser::RegionToString(region));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
+    fInfo.push(SkObjectParser::ClipOpToString(op));
 }
 
 void SkClipRegionCommand::execute(SkCanvas* canvas) const {
@@ -1711,14 +1711,14 @@
     return nullptr;
 }
 
-SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA)
+SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkCanvas::ClipOp op, bool doAA)
     : INHERITED(kClipRect_OpType) {
     fRect = rect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RectToString(rect));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
+    fInfo.push(SkObjectParser::ClipOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
@@ -1742,18 +1742,18 @@
                                                UrlDataManager& urlDataManager) {
     SkRect rect;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect);
-    return new SkClipRectCommand(rect, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
+    return new SkClipRectCommand(rect, get_json_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
-SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA)
+SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA)
     : INHERITED(kClipRRect_OpType) {
     fRRect = rrect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
+    fInfo.push(SkObjectParser::ClipOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
@@ -1779,7 +1779,7 @@
     SkRRect rrect;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rrect);
     return new SkClipRRectCommand(rrect,
-                                  get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
+                                  get_json_clipop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]),
                                   command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
diff --git a/tools/debugger/SkDrawCommand.h b/tools/debugger/SkDrawCommand.h
index 07dd477..27b56e2 100644
--- a/tools/debugger/SkDrawCommand.h
+++ b/tools/debugger/SkDrawCommand.h
@@ -174,69 +174,69 @@
 
 class SkClipPathCommand : public SkDrawCommand {
 public:
-    SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);
+    SkClipPathCommand(const SkPath& path, SkCanvas::ClipOp op, bool doAA);
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
     static SkClipPathCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    SkPath       fPath;
-    SkRegion::Op fOp;
-    bool         fDoAA;
+    SkPath           fPath;
+    SkCanvas::ClipOp fOp;
+    bool             fDoAA;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkClipRegionCommand : public SkDrawCommand {
 public:
-    SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);
+    SkClipRegionCommand(const SkRegion& region, SkCanvas::ClipOp op);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
     static SkClipRegionCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
 private:
-    SkRegion     fRegion;
-    SkRegion::Op fOp;
+    SkRegion         fRegion;
+    SkCanvas::ClipOp fOp;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkClipRectCommand : public SkDrawCommand {
 public:
-    SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);
+    SkClipRectCommand(const SkRect& rect, SkCanvas::ClipOp op, bool doAA);
     void execute(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
     static SkClipRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
     const SkRect& rect() const { return fRect; }
-    SkRegion::Op op() const { return fOp; }
+    SkCanvas::ClipOp op() const { return fOp; }
     bool doAA() const { return fDoAA; }
 
 private:
-    SkRect       fRect;
-    SkRegion::Op fOp;
-    bool         fDoAA;
+    SkRect           fRect;
+    SkCanvas::ClipOp fOp;
+    bool             fDoAA;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkClipRRectCommand : public SkDrawCommand {
 public:
-    SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);
+    SkClipRRectCommand(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA);
     void execute(SkCanvas* canvas) const override;
     bool render(SkCanvas* canvas) const override;
     Json::Value toJSON(UrlDataManager& urlDataManager) const override;
     static SkClipRRectCommand* fromJSON(Json::Value& command, UrlDataManager& urlDataManager);
 
     const SkRRect& rrect() const { return fRRect; }
-    SkRegion::Op op() const { return fOp; }
+    SkCanvas::ClipOp op() const { return fOp; }
     bool doAA() const { return fDoAA; }
 
 private:
-    SkRRect      fRRect;
-    SkRegion::Op fOp;
-    bool         fDoAA;
+    SkRRect          fRRect;
+    SkCanvas::ClipOp fOp;
+    bool             fDoAA;
 
     typedef SkDrawCommand INHERITED;
 };
diff --git a/tools/debugger/SkObjectParser.cpp b/tools/debugger/SkObjectParser.cpp
index 3642783..5f0e5f8 100644
--- a/tools/debugger/SkObjectParser.cpp
+++ b/tools/debugger/SkObjectParser.cpp
@@ -313,19 +313,19 @@
     return mRRect;
 }
 
-SkString* SkObjectParser::RegionOpToString(SkRegion::Op op) {
+SkString* SkObjectParser::ClipOpToString(SkCanvas::ClipOp op) {
     SkString* mOp = new SkString("SkRegion::Op: ");
-    if (op == SkRegion::kDifference_Op) {
+    if (op == SkCanvas::kDifference_Op) {
         mOp->append("kDifference_Op");
-    } else if (op == SkRegion::kIntersect_Op) {
+    } else if (op == SkCanvas::kIntersect_Op) {
         mOp->append("kIntersect_Op");
-    } else if (op == SkRegion::kUnion_Op) {
+    } else if (op == SkCanvas::kUnion_Op) {
         mOp->append("kUnion_Op");
-    } else if (op == SkRegion::kXOR_Op) {
+    } else if (op == SkCanvas::kXOR_Op) {
         mOp->append("kXOR_Op");
-    } else if (op == SkRegion::kReverseDifference_Op) {
+    } else if (op == SkCanvas::kReverseDifference_Op) {
         mOp->append("kReverseDifference_Op");
-    } else if (op == SkRegion::kReplace_Op) {
+    } else if (op == SkCanvas::kReplace_Op) {
         mOp->append("kReplace_Op");
     } else {
         mOp->append("Unknown Type");
diff --git a/tools/debugger/SkObjectParser.h b/tools/debugger/SkObjectParser.h
index 9bdfad5..11baf12 100644
--- a/tools/debugger/SkObjectParser.h
+++ b/tools/debugger/SkObjectParser.h
@@ -101,7 +101,7 @@
         Returns a string representation of the SkRegion enum.
         @param op  SkRegion::op enum
      */
-    static SkString* RegionOpToString(SkRegion::Op op);
+    static SkString* ClipOpToString(SkCanvas::ClipOp op);
 
     /**
         Returns a string representation of the SkRegion.