remove dead code around SK_ENABLE_CLIP_QUICKREJECT

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 32 matching lines @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrRenderTarget.h"
 #include "SkGrPriv.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 51 matching lines @@
 
 static bool gTreatSpriteAsBitmap;
 void SkCanvas::Internal_Private_SetTreatSpriteAsBitmap(bool spriteAsBitmap) {
     gTreatSpriteAsBitmap = spriteAsBitmap;
 }
 bool SkCanvas::Internal_Private_GetTreatSpriteAsBitmap() {
     return gTreatSpriteAsBitmap;
 }
 
 // experimental for faster tiled drawing...
-//#define SK_ENABLE_CLIP_QUICKREJECT
 //#define SK_TRACE_SAVERESTORE
 
 #ifdef SK_TRACE_SAVERESTORE
     static int gLayerCounter;
     static void inc_layer() { ++gLayerCounter; printf("----- inc layer %d\n", gLayerCounter); }
     static void dec_layer() { --gLayerCounter; printf("----- dec layer %d\n", gLayerCounter); }
 
     static int gRecCounter;
     static void inc_rec() { ++gRecCounter; printf("----- inc rec %d\n", gRecCounter); }
     static void dec_rec() { --gRecCounter; printf("----- dec rec %d\n", gRecCounter); }
@@ skipping 1404 matching lines @@
 }
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
 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.isScaleTranslate()) {
-        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) {
-#ifdef SK_ENABLE_CLIP_QUICKREJECT
-    if (SkRegion::kIntersect_Op == op) {
-        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 (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);
     } else {
@@ skipping 65 matching lines @@
         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) {
-#ifdef SK_ENABLE_CLIP_QUICKREJECT
-    if (SkRegion::kIntersect_Op == op && !path.isInverseFillType()) {
-        if (fMCRec->fRasterClip.isEmpty()) {
-            return;
-        }
-
-        if (this->quickReject(path.getBounds())) {
-            fDeviceCMDirty = true;
-            fCachedLocalClipBoundsDirty = true;
-
-            fClipStack->clipEmpty();
-            (void)fMCRec->fRasterClip.setEmpty();
-            fDeviceClipBounds.setEmpty();
-            return;
-        }
-    }
-#endif
-
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
     if (!fAllowSoftClip) {
         edgeStyle = kHard_ClipEdgeStyle;
     }
 
     SkPath devPath;
     if (fMCRec->fMatrix.isIdentity()) {
         devPath = path;
@@ skipping 1777 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