Prevent overflow by falling back to non-AA

src/core/SkScan_AAAPath.cpp

 /*
  * Copyright 2016 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 "SkAntiRun.h"
 #include "SkBlitter.h"
 #include "SkEdge.h"
@@ skipping 1194 matching lines @@
         aaa_walk_convex_edges(&headEdge, blitter, start_y, stop_y,
                               rect.fLeft << 16, rect.fRight << 16, isUsingMask,
                               forceRLE);
     } else {
         SkFAIL("Concave AAA is not yet implemented!");
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+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) {
+    SkASSERT(!overflows_short_shift(8191, 2));
+    SkASSERT(overflows_short_shift(8192, 2));
+    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, 2) |
+           overflows_short_shift(rect.fRight, 2) |
+           overflows_short_shift(rect.fTop, 2) |
+           overflows_short_shift(rect.fBottom, 2);
+}
+
 void SkScan::AAAFillPath(const SkPath& path, const SkRegion& origClip, SkBlitter* blitter,
                          bool forceRLE) {
     if (origClip.isEmpty()) {
         return;
     }
     if (path.isInverseFillType() || !path.isConvex()) {
         // Fall back as we only implemented the algorithm for convex shapes yet.
         SkScan::AntiFillPath(path, origClip, blitter, forceRLE);
         return;
     }
@@ skipping 11 matching lines @@
     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 the intersection of the path bounds and the clip bounds
+    // will overflow 32767 when << by 2, our SkFixed will overflow,
+    // so draw without antialiasing.
+    if (rect_overflows_short_shift(clippedIR, 2)) {
+        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;
     {
@@ skipping 55 matching lines @@
         AAAFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         AAAFillPath(path, tmp, &aaBlitter, true);
     }
 }