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

src/pdf/SkPDFDevice.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 "SkPDFDevice.h"
 
 #include "SkAdvancedTypefaceMetrics.h"
@@ skipping 158 matching lines @@
 // enums so region_op_to_pathops_op can do a straight passthrough cast.
 // If these are failing, it may be necessary to make region_op_to_pathops_op
 // do more.
 static_assert(SkRegion::kDifference_Op == (int)kDifference_SkPathOp, "region_pathop_mismatch");
 static_assert(SkRegion::kIntersect_Op == (int)kIntersect_SkPathOp, "region_pathop_mismatch");
 static_assert(SkRegion::kUnion_Op == (int)kUnion_SkPathOp, "region_pathop_mismatch");
 static_assert(SkRegion::kXOR_Op == (int)kXOR_SkPathOp, "region_pathop_mismatch");
 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;
 }
 
 /* Uses Path Ops to calculate a vector SkPath clip from a clip stack.
  * Returns true if successful, or false if not successful.
  * If successful, the resulting clip is stored in outClipPath.
  * If not successful, outClipPath is undefined, and a fallback method
  * should be used.
  */
 static bool get_clip_stack_path(const SkMatrix& transform,
@@ skipping 10 matching lines @@
         SkPath entryPath;
         if (SkClipStack::Element::kEmpty_Type == clipEntry->getType()) {
             outClipPath->reset();
             outClipPath->setFillType(SkPath::kInverseWinding_FillType);
             continue;
         } else {
             clipEntry->asPath(&entryPath);
         }
         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());
             if (!Op(*outClipPath, entryPath, op, outClipPath)) {
                 return false;
             }
         }
     }
 
     if (outClipPath->isInverseFillType()) {
@@ skipping 1523 matching lines @@
     if (clipStack == nullptr) {
         if (clipRegion == fExistingClipRegion) {
             clipStack = &fExistingClipStack;
         } else {
             // GraphicStackState::updateClip expects the clip stack to have
             // fExistingClip as a prefix, so start there, then set the clip
             // to the passed region.
             synthesizedClipStack = fExistingClipStack;
             SkPath clipPath;
             clipRegion.getBoundaryPath(&clipPath);
-            synthesizedClipStack.clipDevPath(clipPath, SkRegion::kReplace_Op,
+            synthesizedClipStack.clipDevPath(clipPath, SkCanvas::kReplace_Op,
                                              false);
             clipStack = &synthesizedClipStack;
         }
     }
 
     SkXfermode::Mode xfermode = SkXfermode::kSrcOver_Mode;
     if (paint.getXfermode()) {
         paint.getXfermode()->asMode(&xfermode);
     }
 
@@ skipping 542 matching lines @@
 }
 
 sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkImage* image) {
     return SkSpecialImage::MakeFromImage(SkIRect::MakeWH(image->width(), image->height()),
                                          image->makeNonTextureImage());
 }
 
 sk_sp<SkSpecialImage> SkPDFDevice::snapSpecial() {
     return nullptr;
 }