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

gm/complexclip.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gm.h"
 #include "SkCanvas.h"
 //#include "SkParsePath.h"
 #include "SkPath.h"
@@ skipping 68 matching lines @@
         clipB.lineTo(SkIntToScalar(40),  SkIntToScalar(185));
         clipB.lineTo(SkIntToScalar(155), SkIntToScalar(100));
         clipB.close();
 
         SkPaint paint;
         paint.setAntiAlias(true);
         sk_tool_utils::set_portable_typeface(&paint);
         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));
         canvas->scale(3 * SK_Scalar1 / 4, 3 * SK_Scalar1 / 4);
 
         if (fDoSaveLayer) {
             // We want the layer to appear symmetric relative to actual
             // device boundaries so we need to "undo" the effect of the
             // scale and translate
             SkRect bounds = SkRect::MakeLTRB(
@@ skipping 16 matching lines @@
                 this->drawHairlines(canvas, path, clipA, clipB);
 
                 bool doInvA = SkToBool(invBits & 1);
                 bool doInvB = SkToBool(invBits & 2);
                 canvas->save();
                     // set clip
                     clipA.setFillType(doInvA ? SkPath::kInverseEvenOdd_FillType :
                                       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
                     // canvas.
                     if (fInvertDraw) {
                         SkRect rectClip = clipA.getBounds();
                         rectClip.join(path.getBounds());
                         rectClip.join(path.getBounds());
                         rectClip.outset(5, 5);
                         canvas->clipRect(rectClip);
@@ skipping 57 matching lines @@
 
 DEF_GM(return new ComplexClipGM(false, false, false);)
 DEF_GM(return new ComplexClipGM(false, false, true);)
 DEF_GM(return new ComplexClipGM(false, true, false);)
 DEF_GM(return new ComplexClipGM(false, true, true);)
 DEF_GM(return new ComplexClipGM(true, false, false);)
 DEF_GM(return new ComplexClipGM(true, false, true);)
 DEF_GM(return new ComplexClipGM(true, true, false);)
 DEF_GM(return new ComplexClipGM(true, true, true);)
 }