add SK_SUPPORT_PRECHECK_CLIPRECT experiment for clipRect

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 28 matching lines @@
 #include <new>
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrRenderTarget.h"
 #include "SkGr.h"
 #endif
 
 #define RETURN_ON_NULL(ptr)     do { if (nullptr == (ptr)) return; } while (0)
 
+//#define SK_SUPPORT_PRECHECK_CLIPRECT
+
 /*
  *  Return true if the drawing this rect would hit every pixels in the canvas.
  *
  *  Returns false if
  *  - rect does not contain the canvas' bounds
  *  - paint is not fill
  *  - paint would blur or otherwise change the coverage of the rect
  */
 bool SkCanvas::wouldOverwriteEntireSurface(const SkRect* rect, const SkPaint* paint,
                                            ShaderOverrideOpacity overrideOpacity) const {
@@ skipping 1456 matching lines @@
     this->didSetMatrix(matrix);
 }
 
 void SkCanvas::resetMatrix() {
     this->setMatrix(SkMatrix::I());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void SkCanvas::clipRect(const SkRect& rect, SkRegion::Op 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.rectStaysRect()) {
+        SkRect devR;
+        fMCRec->fMatrix.mapRect(&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) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op) {
         if (fMCRec->fRasterClip.isEmpty()) {
-            return false;
+            return;
         }
 
         if (this->quickReject(rect)) {
             fDeviceCMDirty = true;
             fCachedLocalClipBoundsDirty = true;
 
             fClipStack->clipEmpty();
-            return fMCRec->fRasterClip.setEmpty();
+            (void)fMCRec->fRasterClip.setEmpty();
+            return;
         }
     }
 #endif
 
-    if (!fAllowSoftClip) {
-        edgeStyle = kHard_ClipEdgeStyle;
-    }
-
     const bool rectStaysRect = fMCRec->fMatrix.rectStaysRect();
     SkRect devR;
     if (rectStaysRect) {
         fMCRec->fMatrix.mapRect(&devR, rect);
     }
 
-    // Check if we can quick-accept the clip call (and do nothing)
-    //
-    // TODO: investigate if a (conservative) version of this could be done in ::clipRect,
-    //       so that subclasses (like PictureRecording) didn't see unnecessary clips, which in turn
-    //       might allow lazy save/restores to eliminate entire save/restore blocks.
-    //
+#ifndef SK_SUPPORT_PRECHECK_CLIPRECT
     if (SkRegion::kIntersect_Op == op &&
         kHard_ClipEdgeStyle == edgeStyle
         && rectStaysRect)
     {
         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;
     fCachedLocalClipBoundsDirty = true;
 
     if (rectStaysRect) {
         const bool isAA = kSoft_ClipEdgeStyle == edgeStyle;
         fClipStack->clipDevRect(devR, op, isAA);
         fMCRec->fRasterClip.op(devR, this->getTopLayerBounds(), op, isAA);
@@ skipping 65 matching lines @@
         }
     }
 
     this->onClipPath(path, op, edgeStyle);
 }
 
 void SkCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op && !path.isInverseFillType()) {
         if (fMCRec->fRasterClip.isEmpty()) {
-            return false;
+            return;
         }
 
         if (this->quickReject(path.getBounds())) {
             fDeviceCMDirty = true;
             fCachedLocalClipBoundsDirty = true;
 
             fClipStack->clipEmpty();
-            return fMCRec->fRasterClip.setEmpty();
+            (void)fMCRec->fRasterClip.setEmpty();
+            return;
         }
     }
 #endif
 
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
     fCachedLocalClipBoundsDirty = true;
     if (!fAllowSoftClip) {
         edgeStyle = kHard_ClipEdgeStyle;
@@ skipping 1396 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