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

src/core/SkScan_AntiPath.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 "SkPath.h"
@@ skipping 565 matching lines @@
                     (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT));
     }
 
 #ifdef SK_DEBUG
     fCurrX = x + width;
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static bool fitsInsideLimit(const SkRect& r, SkScalar max) {
-    const SkScalar min = -max;
-    return  r.fLeft > min && r.fTop > min &&
-            r.fRight < max && r.fBottom < max;
-}
-
 static int overflows_short_shift(int value, int shift) {
     const int s = 16 + shift;
     return (SkLeftShift(value, s) >> s) - value;
 }
 
 /**
   Would any of the coordinates of this rectangle not fit in a short,
   when left-shifted by shift?
 */
-static int rect_overflows_short_shift(SkIRect rect, int shift) {
+static int rect_overflows_short_shift(SkIRect rect) {
     SkASSERT(!overflows_short_shift(8191, SHIFT));
     SkASSERT(overflows_short_shift(8192, SHIFT));
     SkASSERT(!overflows_short_shift(32767, 0));
     SkASSERT(overflows_short_shift(32768, 0));
 
     // Since we expect these to succeed, we bit-or together
     // for a tiny extra bit of speed.
     return overflows_short_shift(rect.fLeft, SHIFT) |
            overflows_short_shift(rect.fRight, SHIFT) |
            overflows_short_shift(rect.fTop, SHIFT) |
            overflows_short_shift(rect.fBottom, SHIFT);
 }
 
-static bool safeRoundOut(const SkRect& src, SkIRect* dst, int32_t maxInt) {
-    const SkScalar maxScalar = SkIntToScalar(maxInt);
-
-    if (fitsInsideLimit(src, maxScalar)) {
+// When src has huge coordinates, clips dst by clip and returns true.
+static bool roundOutClipped(const SkRect& src, const SkIRect& clip, SkIRect* dst) {
+    static const int32_t kLimit = (SK_MaxS32 >> SHIFT) - 1;
+    const SkIRect max = SkIRect::MakeLTRB(-kLimit, -kLimit, kLimit, kLimit);
+    if (max.contains(src)) {
         src.roundOut(dst);
-        return true;
+        return false;
     }
-    return false;
+    SkRect clipped;
+    if (clipped.intersect(src, SkRect::Make(clip))) {
+        clipped.roundOut(dst);
+    } else {
+        dst->setEmpty();
+    }
+    return true;
 }
 
 void SkScan::AntiFillPath(const SkPath& path, const SkRegion& origClip,
                           SkBlitter* blitter, bool forceRLE) {
     if (origClip.isEmpty()) {
         return;
     }
 
     const bool isInverse = path.isInverseFillType();
     SkIRect ir;
 
-    if (!safeRoundOut(path.getBounds(), &ir, SK_MaxS32 >> SHIFT)) {
-#if 0
-        const SkRect& r = path.getBounds();
-        SkDebugf("--- bounds can't fit in SkIRect\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
-#endif
-        return;
-    }
+    bool irIsClipped = roundOutClipped(path.getBounds(), origClip.getBounds(), &ir);
     if (ir.isEmpty()) {
         if (isInverse) {
             blitter->blitRegion(origClip);
         }
         return;
     }
 
     // If the intersection of the path bounds and the clip bounds
     // will overflow 32767 when << by SHIFT, we can't supersample,
     // so draw without antialiasing.
     SkIRect clippedIR;
     if (isInverse) {
        // If the path is an inverse fill, it's going to fill the entire
        // clip, and we care whether the entire clip exceeds our limits.
        clippedIR = origClip.getBounds();
     } else {
        if (!clippedIR.intersect(ir, origClip.getBounds())) {
            return;
        }
     }
-    if (rect_overflows_short_shift(clippedIR, SHIFT)) {
+    if (rect_overflows_short_shift(clippedIR)) {
         SkScan::FillPath(path, origClip, blitter);
         return;
     }
 
     // Our antialiasing can't handle a clip larger than 32767, so we restrict
     // the clip to that limit here. (the runs[] uses int16_t for its index).
     //
     // A more general solution (one that could also eliminate the need to
     // disable aa based on ir bounds (see overflows_short_shift) would be
     // to tile the clip/target...
     SkRegion tmpClipStorage;
     const SkRegion* clipRgn = &origClip;
     {
         static const int32_t kMaxClipCoord = 32767;
         const SkIRect& bounds = origClip.getBounds();
         if (bounds.fRight > kMaxClipCoord || bounds.fBottom > kMaxClipCoord) {
             SkIRect limit = { 0, 0, kMaxClipCoord, kMaxClipCoord };
             tmpClipStorage.op(origClip, limit, SkRegion::kIntersect_Op);
             clipRgn = &tmpClipStorage;
         }
     }
     // for here down, use clipRgn, not origClip
 
-    SkScanClipper   clipper(blitter, clipRgn, ir);
+    SkScanClipper   clipper(blitter, clipRgn, ir, /* skipRejectTest */ false, irIsClipped);
     const SkIRect*  clipRect = clipper.getClipRect();
 
     if (clipper.getBlitter() == nullptr) { // clipped out
         if (isInverse) {
             blitter->blitRegion(*clipRgn);
         }
         return;
     }
 
     // now use the (possibly wrapped) blitter
     blitter = clipper.getBlitter();
 
     if (isInverse) {
         sk_blit_above(blitter, ir, *clipRgn);
     }
 
     SkIRect superRect, *superClipRect = nullptr;
 
     if (clipRect) {
         superRect.set(SkLeftShift(clipRect->fLeft, SHIFT),
                       SkLeftShift(clipRect->fTop, SHIFT),
                       SkLeftShift(clipRect->fRight, SHIFT),
                       SkLeftShift(clipRect->fBottom, SHIFT));
         superClipRect = &superRect;
     }
 
-    SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
-
     // MaskSuperBlitter can't handle drawing outside of ir, so we can't use it
     // if we're an inverse filltype
-    if (!isInverse && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
+    if (!isInverse && !irIsClipped && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
         MaskSuperBlitter    superBlit(blitter, ir, *clipRgn, isInverse);
         SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     } else {
         SuperBlitter    superBlit(blitter, ir, *clipRgn, isInverse);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     }
 
     if (isInverse) {
         sk_blit_below(blitter, ir, *clipRgn);
@@ skipping 32 matching lines @@
         AntiFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         SkScan::AntiFillPath(path, tmp, &aaBlitter, true);
     }
 }