In SkDraw::drawRect, use SkPath for huge rects.

src/core/SkScan_Path.cpp

 /*
  * Copyright 2006 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 "SkScanPriv.h"
 #include "SkBlitter.h"
 #include "SkEdge.h"
@@ skipping 527 matching lines @@
     tmp.fBottom = cr.fBottom;
     if (!tmp.isEmpty()) {
         blitter->blitRectRegion(tmp, clip);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  If the caller is drawing an inverse-fill path, then it pass true for
- *  skipRejectTest, so we don't abort drawing just because the src bounds (ir)
+ *  skipRejectTest, so we don't abort drawing just because the src bounds
  *  is outside of the clip.
  */
 SkScanClipper::SkScanClipper(SkBlitter* blitter, const SkRegion* clip,
-                             const SkIRect& ir, bool skipRejectTest) {
+                             const SkIRect& bounds, bool skipRejectTest, bool boundsIsTruncated) {
     fBlitter = nullptr;     // null means blit nothing
     fClipRect = nullptr;
 
     if (clip) {
         fClipRect = &clip->getBounds();
-        if (!skipRejectTest && !SkIRect::Intersects(*fClipRect, ir)) { // completely clipped out
+        if (!skipRejectTest && !SkIRect::Intersects(*fClipRect, bounds)) { // completely clipped out
             return;
         }
 
         if (clip->isRect()) {
-            if (fClipRect->contains(ir)) {
+            if (!boundsIsTruncated && fClipRect->contains(bounds)) {
                 fClipRect = nullptr;
             } else {
                 // only need a wrapper blitter if we're horizontally clipped
-                if (fClipRect->fLeft > ir.fLeft || fClipRect->fRight < ir.fRight) {
+                if (boundsIsTruncated ||
+                    fClipRect->fLeft > bounds.fLeft || fClipRect->fRight < bounds.fRight) {
                     fRectBlitter.init(blitter, *fClipRect);
                     blitter = &fRectBlitter;
                 }
             }
         } else {
             fRgnBlitter.init(blitter, clip);
             blitter = &fRgnBlitter;
         }
     }
     fBlitter = blitter;
@@ skipping 24 matching lines @@
     double floorXX = floor(xx);
     return (int)floorXX - (xx == floorXX);
 }
 
 /**
   *  Variant of SkRect::round() that explicitly performs the rounding step (i.e. floor(x + 0.5))
   *  using double instead of SkScalar (float). It does this by calling SkDScalarRoundToInt(),
   *  which may be slower than calling SkScalarRountToInt(), but gives slightly more accurate
   *  results. Also rounds top and left using double, flooring when the fraction is exactly 0.5f.
   *
+  *  When src has huge coordinates, clips dst by clip and returns true.
+  *
   *  e.g.
   *      SkScalar left = 0.5f;
   *      int ileft = SkScalarRoundToInt(left);
   *      SkASSERT(0 == ileft);  // <--- fails
   *      int ileft = round_down_to_int(left);
   *      SkASSERT(0 == ileft);  // <--- succeeds
   *      SkScalar right = 0.49999997f;
   *      int iright = SkScalarRoundToInt(right);
   *      SkASSERT(0 == iright);  // <--- fails
   *      iright = SkDScalarRoundToInt(right);
   *      SkASSERT(0 == iright);  // <--- succeeds
   */
-static void round_asymmetric_to_int(const SkRect& src, SkIRect* dst) {
+static bool round_asymmetric_to_int(const SkRect& src, const SkIRect& clip, SkIRect* dst) {
     SkASSERT(dst);
-    dst->set(round_down_to_int(src.fLeft), round_down_to_int(src.fTop),
-             SkDScalarRoundToInt(src.fRight), SkDScalarRoundToInt(src.fBottom));
+    static const int32_t kLimit = 32767;
+    const SkIRect max = SkIRect::MakeLTRB(-kLimit, -kLimit, kLimit, kLimit);
+    if (max.contains(src)) {
+        dst->set(round_down_to_int(src.fLeft), round_down_to_int(src.fTop),
+                 SkDScalarRoundToInt(src.fRight), SkDScalarRoundToInt(src.fBottom));
+        return false;
+    }
+    SkRect clipped;
+    if (clipped.intersect(src, SkRect::Make(clip))) {
+        dst->set(round_down_to_int(clipped.fLeft), round_down_to_int(clipped.fTop),
+                 SkDScalarRoundToInt(clipped.fRight), SkDScalarRoundToInt(clipped.fBottom));
+    } else {
+        dst->setEmpty();
+    }
+    return true;
 }
 
 void SkScan::FillPath(const SkPath& path, const SkRegion& origClip,
                       SkBlitter* blitter) {
     if (origClip.isEmpty()) {
         return;
     }
 
     // Our edges are fixed-point, and don't like the bounds of the clip to
     // exceed that. Here we trim the clip just so we don't overflow later on
     const SkRegion* clipPtr = &origClip;
     SkRegion finiteClip;
     if (clip_to_limit(origClip, &finiteClip)) {
         if (finiteClip.isEmpty()) {
             return;
         }
         clipPtr = &finiteClip;
     }
         // don't reference "origClip" any more, just use clipPtr
 
     SkIRect ir;
     // We deliberately call round_asymmetric_to_int() instead of round(), since we can't afford
     // to generate a bounds that is tighter than the corresponding SkEdges. The edge code basically
     // converts the floats to fixed, and then "rounds". If we called round() instead of
     // round_asymmetric_to_int() here, we could generate the wrong ir for values like 0.4999997.
-    round_asymmetric_to_int(path.getBounds(), &ir);
+    bool irIsClipped = round_asymmetric_to_int(path.getBounds(), clipPtr->getBounds(), &ir);
     if (ir.isEmpty()) {
         if (path.isInverseFillType()) {
             blitter->blitRegion(*clipPtr);
         }
         return;
     }
 
-    SkScanClipper clipper(blitter, clipPtr, ir, path.isInverseFillType());
+    SkScanClipper clipper(blitter, clipPtr, ir, path.isInverseFillType(), irIsClipped);
 
     blitter = clipper.getBlitter();
     if (blitter) {
         // we have to keep our calls to blitter in sorted order, so we
         // must blit the above section first, then the middle, then the bottom.
         if (path.isInverseFillType()) {
             sk_blit_above(blitter, ir, *clipPtr);
         }
         sk_fill_path(path, clipper.getClipRect(), blitter, ir.fTop, ir.fBottom,
                      0, *clipPtr);
@@ skipping 96 matching lines @@
         clipRgn = &wrap.getRgn();
         blitter = wrap.getBlitter();
     }
 
     SkScanClipper clipper(blitter, clipRgn, ir);
     blitter = clipper.getBlitter();
     if (blitter) {
         sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
     }
 }