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

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 327 matching lines @@
 
     ~SkDrawIter() {
         if (fMultiDeviceCS) {
             fMultiDeviceCS->restore();
         }
     }
 
     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
         while (fCurrLayer && fCurrLayer->fClip.isEmpty()) {
             fCurrLayer = fCurrLayer->fNext;
         }
 
         const DeviceCM* rec = fCurrLayer;
         if (rec && rec->fDevice) {
 
@@ skipping 744 matching lines @@
             }
             return false;
         }
     } else {    // no user bounds, so just use the clip
         ir = clipBounds;
     }
     SkASSERT(!ir.isEmpty());
 
     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);
     }
 
     if (intersection) {
         *intersection = ir;
     }
     return true;
 }
 
@@ skipping 411 matching lines @@
     this->fLights = lights;
 }
 
 sk_sp<SkLights> SkCanvas::getLights() const {
     return this->fLights;
 }
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
-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;
     }
 
 #ifdef SK_SUPPORT_PRECHECK_CLIPRECT
     // Check if we can quick-accept the clip call (and do nothing)
     //
     if (SkRegion::kIntersect_Op == op && !doAA && fMCRec->fMatrix.isScaleTranslate()) {

[f(malita), 2016/09/19 19:43:25]

kIntersect_Op

[reed1, 2016/09/19 20:42:50]

deleted

         SkRect devR;
         fMCRec->fMatrix.mapRectScaleTranslate(&devR, rect);
         // NOTE: this check is CTM specific, since we might round differently with a different
         //       CTM. Thus this is only 100% reliable if there is not global CTM scale to be
         //       applied later (i.e. if this is going into a picture).
         if (devR.round().contains(fMCRec->fRasterClip.getBounds())) {
 #if 0
             SkDebugf("ignored clipRect [%g %g %g %g]\n",
                      rect.left(), rect.top(), rect.right(), rect.bottom());
 #endif
             return;
         }
     }
 #endif
 
     this->checkForDeferredSave();
     ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
     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) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op) {

[f(malita), 2016/09/19 19:43:25]

kIntersect_Op

[reed1, 2016/09/19 20:42:50]

deleted

         if (fMCRec->fRasterClip.isEmpty()) {
             return;
         }
 
         if (this->quickReject(rect)) {
             fDeviceCMDirty = true;
             fCachedLocalClipBoundsDirty = true;
 
             fClipStack->clipEmpty();
             (void)fMCRec->fRasterClip.setEmpty();
             fDeviceClipBounds.setEmpty();
             return;
         }
     }
 #endif
 
     const bool isScaleTrans = fMCRec->fMatrix.isScaleTranslate();
     SkRect devR;
     if (isScaleTrans) {
         fMCRec->fMatrix.mapRectScaleTranslate(&devR, rect);
     }
 
 #ifndef SK_SUPPORT_PRECHECK_CLIPRECT
-    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",
                      rect.left(), rect.top(), rect.right(), rect.bottom());
 #endif
             return;
         }
     }
 #endif
 
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
 
     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);

[f(malita), 2016/09/19 19:43:25]

Maybe add static asserts for all ClipOp values matching SkRegion::Op vals
someplace?

[reed1, 2016/09/19 20:42:50]

Done.

     } 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
         // avoid recursion in the case where we are subclassed (e.g. Pictures)
         // we explicitly call "our" version of clipPath.
         SkPath  path;
 
         path.addRect(rect);
         path.setIsVolatile(true);
         this->SkCanvas::onClipPath(path, op, edgeStyle);
     }
 
     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()) {
         this->onClipRect(rrect.getBounds(), op, edgeStyle);
     } else {
         this->onClipRRect(rrect, op, edgeStyle);
     }
 }
 
-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);
 
         fDeviceCMDirty = true;
         if (!fAllowSoftClip) {
             edgeStyle = kHard_ClipEdgeStyle;
         }
 
         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;
     }
 
     SkPath path;
     path.addRRect(rrect);
     path.setIsVolatile(true);
     // call the non-virtual version
     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;
 
     if (!path.isInverseFillType() && fMCRec->fMatrix.rectStaysRect()) {
         SkRect r;
         if (path.isRect(&r)) {
             this->onClipRect(r, op, edgeStyle);
             return;
         }
         SkRRect rrect;
         if (path.isOval(&r)) {
             rrect.setOval(r);
             this->onClipRRect(rrect, op, edgeStyle);
             return;
         }
         if (path.isRRect(&rrect)) {
             this->onClipRRect(rrect, op, edgeStyle);
             return;
         }
     }
 
     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) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op && !path.isInverseFillType()) {

[f(malita), 2016/09/19 19:43:25]

kIntersect_Op

[reed1, 2016/09/19 20:42:50]

deleted

         if (fMCRec->fRasterClip.isEmpty()) {
             return;
         }
 
         if (this->quickReject(path.getBounds())) {
             fDeviceCMDirty = true;
             fCachedLocalClipBoundsDirty = true;
 
             fClipStack->clipEmpty();
             (void)fMCRec->fRasterClip.setEmpty();
@@ skipping 30 matching lines @@
 
     // if we called path.swap() we could avoid a deep copy of this path
     fClipStack->clipDevPath(devPath, op, kSoft_ClipEdgeStyle == edgeStyle);
 
     if (fAllowSimplifyClip) {
         bool clipIsAA = getClipStack()->asPath(&devPath);
         if (clipIsAA) {
             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;
 
     // todo: signal fClipStack that we have a region, and therefore (I guess)
     // 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());
 }
 
 #ifdef SK_DEBUG
 void SkCanvas::validateClip() const {
     // construct clipRgn from the clipstack
     const SkBaseDevice* device = this->getDevice();
     if (!device) {
         SkASSERT(this->isClipEmpty());
         return;
     }
 
     SkIRect ir;
     ir.set(0, 0, device->width(), device->height());
     SkRasterClip tmpClip(ir, fConservativeRasterClip);
 
     SkClipStack::B2TIter                iter(*fClipStack);
     const SkClipStack::Element* element;
     while ((element = iter.next()) != nullptr) {
         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();
                 break;
             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;
             }
         }
     }
 }
 #endif
 
 void SkCanvas::replayClips(ClipVisitor* visitor) const {
     SkClipStack::B2TIter                iter(*fClipStack);
     const SkClipStack::Element*         element;
@@ skipping 1690 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif
+
+/////////////////////////////////
+
+#ifdef SK_SUPPORT_LEGACY_CLIP_REGIONOPS
+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;
+#else
+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;
+#endif