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

tools/debugger/SkDebugCanvas.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvasPriv.h"
 #include "SkClipStack.h"
 #include "SkDebugCanvas.h"
@@ skipping 89 matching lines @@
     // rounded out. The following code creates a nearly maximal rect that will
     // not get collapsed by the coming conversions (Due to precision loss the
     // inset has to be surprisingly large).
     SkIRect largeIRect = SkIRect::MakeLargest();
     largeIRect.inset(1024, 1024);
     SkRect large = SkRect::Make(largeIRect);
 #ifdef SK_DEBUG
     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() {
     fCommandVector.deleteAll();
 }
 
 void SkDebugCanvas::addDrawCommand(SkDrawCommand* command) {
     fCommandVector.push(command);
 }
 
@@ skipping 27 matching lines @@
         }
         prev = bitmap.getColor(0,0);
     }
     return layer;
 }
 
 class SkDebugClipVisitor : public SkCanvas::ClipVisitor {
 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);
         p.setAntiAlias(doAA);
         fCanvas->drawPath(path, p);
     }
 
 protected:
     SkCanvas* fCanvas;
 
@@ skipping 32 matching lines @@
     int saveCount = canvas->save();
 
     SkRect windowRect = SkRect::MakeWH(SkIntToScalar(canvas->getBaseLayerSize().width()),
                                        SkIntToScalar(canvas->getBaseLayerSize().height()));
 
     bool pathOpsMode = getAllowSimplifyClip();
     canvas->setAllowSimplifyClip(pathOpsMode);
     canvas->clear(SK_ColorWHITE);
     canvas->resetMatrix();
     if (!windowRect.isEmpty()) {
-        canvas->clipRect(windowRect, SkRegion::kReplace_Op);
+        canvas->clipRect(windowRect, SkCanvas::kReplace_Op);
     }
     this->applyUserTransform(canvas);
 
     if (fPaintFilterCanvas) {
         fPaintFilterCanvas->addCanvas(canvas);
         canvas = fPaintFilterCanvas.get();
 
     }
 
     if (fMegaVizMode) {
@@ skipping 41 matching lines @@
         if (at && acb) {
             delete acb;
         }
 #endif
     }
 
     if (SkColorGetA(fClipVizColor) != 0) {
         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);
         canvas->restore();
     }
 
     if (fMegaVizMode) {
         canvas->save();
         // nuke the CTM
         canvas->resetMatrix();
         // turn off clipping
         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);
 
         canvas->replayClips(&visitor);
 
         canvas->restore();
     }
     if (pathOpsMode) {
         this->resetClipStackData();
         const SkClipStack* clipStack = canvas->getClipStack();
         SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
         const SkClipStack::Element* element;
         SkPath devPath;
         while ((element = iter.next())) {
             SkClipStack::Element::Type type = element->getType();
             SkPath operand;
             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);
             }
         }
         this->lastClipStackData(devPath);
     }
     fMatrix = canvas->getTotalMatrix();
     if (!canvas->getClipDeviceBounds(&fClip)) {
         fClip.setEmpty();
@@ skipping 200 matching lines @@
 void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkFilterQuality quality) {
     if (fOverrideFilterQuality == overrideTexFiltering && fFilterQuality == quality) {
         return;
     }
 
     fOverrideFilterQuality = overrideTexFiltering;
     fFilterQuality = quality;
     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));
 }
 
 void SkDebugCanvas::didConcat(const SkMatrix& matrix) {
     this->addDrawCommand(new SkConcatCommand(matrix));
     this->INHERITED::didConcat(matrix);
 }
 
 void SkDebugCanvas::onDrawAnnotation(const SkRect& rect, const char key[], SkData* value) {
     this->addDrawCommand(new SkDrawAnnotationCommand(rect, key, sk_ref_sp(value)));
@@ skipping 252 matching lines @@
                 fClipStackData.appendf("%s%s.close();<br>", kHTML4SpaceIndent, pathName);
                 break;
             default:
                 SkDEBUGFAIL("bad verb");
                 return;
         }
     }
 }
 
 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;
         }
         fCalledAddStackData = false;
     } else {
         fClipStackData.appendf("<br>static void test(skiatest::Reporter* reporter,"
             " const char* filename) {<br>");
         addPathData(fCalledAddStackData ? devPath : fSaveDevPath, "path");
         addPathData(operand, "pathB");
         fClipStackData.appendf("%stestPathOp(reporter, path, pathB, %s, filename);<br>",
             kHTML4SpaceIndent, gOpStrs[elementOp]);
         fClipStackData.appendf("}<br>");
         fCalledAddStackData = true;
     }
 }
 
 bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) {
     if (fCalledAddStackData) {
         fClipStackData.appendf("<br>");
         addPathData(devPath, "pathOut");
         return true;
     }
     return false;
 }