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

src/core/SkLiteDL.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDrawFilter.h"
@@ skipping 131 matching lines @@
         SkScalar dz;
         void draw(SkCanvas* c, const SkMatrix&) {
         #ifdef SK_EXPERIMENTAL_SHADOWING
             c->translateZ(dz);
         #endif
         }
     };
 
     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); }
     };
 
     struct DrawPaint final : Op {
         static const auto kType = Type::DrawPaint;
         DrawPaint(const SkPaint& paint) : paint(paint) {}
         SkPaint paint;
         void draw(SkCanvas* c, const SkMatrix&) { c->drawPaint(paint); }
     };
     struct DrawPath final : Op {
@@ skipping 400 matching lines @@
 void SkLiteDL::saveLayer(const SkRect* bounds, const SkPaint* paint,
                          const SkImageFilter* backdrop, SkCanvas::SaveLayerFlags flags) {
     this->push<SaveLayer>(0, bounds, paint, backdrop, flags);
 }
 
 void SkLiteDL::   concat(const SkMatrix& matrix)   { this->push   <Concat>(0, matrix); }
 void SkLiteDL::setMatrix(const SkMatrix& matrix)   { this->push<SetMatrix>(0, matrix); }
 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);
 }
 
 void SkLiteDL::drawPaint(const SkPaint& paint) {
     this->push<DrawPaint>(0, paint);
 }
 void SkLiteDL::drawPath(const SkPath& path, const SkPaint& paint) {
     this->push<DrawPath>(0, path, paint);
 }
 void SkLiteDL::drawRect(const SkRect& rect, const SkPaint& paint) {
@@ skipping 202 matching lines @@
         SkRect bounds = this->getBounds();
         canvas->saveLayer(&bounds, paint);
             this->draw(canvas, matrix);
         canvas->restore();
     };
 
     // TODO: single-draw specializations
 
     return fallback_plan();
 }