Clean up clipping code a bit

src/core/SkClipStack.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 "SkCanvas.h"
 #include "SkClipStack.h"
 #include "SkPath.h"
@@ skipping 401 matching lines @@
                 fFiniteBoundType = kInsideOut_BoundsType;
             } else {
                 fFiniteBoundType = kNormal_BoundsType;
             }
             break;
         case kEmpty_Type:
             SkDEBUGFAIL("We shouldn't get here with an empty element.");
             break;
     }
 
     if (!fDoAA) {

[robertphillips, 2015/02/10 14:54:07]

Just FYI - if we replace the 0.45f oddness with an SkScalarRoundToScalar we get
an assert in the SW clip mask creation process where raster's idea of the clip
bounds differ from ours (i.e., it is trying to index to (-1, *) when creating
the mask).

[bsalomon, 2015/02/10 15:57:24]

eek, do we know why that happens?

-        // Here we mimic a non-anti-aliased scanline system. If there is
-        // no anti-aliasing we can integerize the bounding box to exclude
-        // fractional parts that won't be rendered.
-        // Note: the left edge is handled slightly differently below. We
-        // are a bit more generous in the rounding since we don't want to
-        // risk missing the left pixels when fLeft is very close to .5
         fFiniteBound.set(SkScalarFloorToScalar(fFiniteBound.fLeft+0.45f),
                          SkScalarRoundToScalar(fFiniteBound.fTop),
                          SkScalarRoundToScalar(fFiniteBound.fRight),
                          SkScalarRoundToScalar(fFiniteBound.fBottom));
     }
 
     // Now determine the previous Element's bound information taking into
     // account that there may be no previous clip
     SkRect prevFinite;
     SkClipStack::BoundsType prevType;
@@ skipping 176 matching lines @@
         return;
     }
 
     *canvFiniteBound = element->fFiniteBound;
     *boundType = element->fFiniteBoundType;
     if (isIntersectionOfRects) {
         *isIntersectionOfRects = element->fIsIntersectionOfRects;
     }
 }
 
-bool SkClipStack::intersectRectWithClip(SkRect* rect) const {
-    SkASSERT(rect);
-
-    SkRect bounds;
-    SkClipStack::BoundsType bt;
-    this->getBounds(&bounds, &bt);
-    if (bt == SkClipStack::kInsideOut_BoundsType) {
-        if (bounds.contains(*rect)) {
-            return false;
-        } else {
-            // If rect's x values are both within bound's x range we
-            // could clip here. Same for y. But we don't bother to check.
-            return true;
-        }
-    } else {
-        return rect->intersect(bounds);
-    }
-}
-
 bool SkClipStack::quickContains(const SkRect& rect) const {
 
     Iter iter(*this, Iter::kTop_IterStart);
     const Element* element = iter.prev();
     while (element != NULL) {
         if (SkRegion::kIntersect_Op != element->getOp() && SkRegion::kReplace_Op != element->getOp())
             return false;
         if (element->isInverseFilled()) {
             // Part of 'rect' could be trimmed off by the inverse-filled clip element
             if (SkRect::Intersects(element->getBounds(), rect)) {
@@ skipping 277 matching lines @@
 
 void SkClipStack::dump() const {
     B2TIter iter(*this);
     const Element* e;
     while ((e = iter.next())) {
         e->dump();
         SkDebugf("\n");
     }
 }
 #endif