cull edges that are to the right of the clip

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 415 matching lines @@
 //
 // clipRect (if no null) has already been shifted up
 //
 void sk_fill_path(const SkPath& path, const SkIRect* clipRect, SkBlitter* blitter,
                   int start_y, int stop_y, int shiftEdgesUp, const SkRegion& clipRgn) {
     SkASSERT(blitter);
 
     SkEdgeBuilder   builder;
 
     // If we're convex, then we need both edges, even the right edge is past the clip
-    const bool cullToTheRight = !path.isConvex();
+    const bool canCullToTheRight = !path.isConvex();
 
-    int count = builder.build(path, clipRect, shiftEdgesUp, cullToTheRight);
+    int count = builder.build(path, clipRect, shiftEdgesUp, canCullToTheRight);
+    SkASSERT(count >= 0);
+
     SkEdge**    list = builder.edgeList();
 
-    if (count < 2) {
+    if (0 == count) {

[caryclark, 2015/02/09 16:06:30]

I don't mind this pattern -- but is it preferable to 

       if (!count) {

?

         if (path.isInverseFillType()) {
             /*
              *  Since we are in inverse-fill, our caller has already drawn above
              *  our top (start_y) and will draw below our bottom (stop_y). Thus
              *  we need to restrict our drawing to the intersection of the clip
              *  and those two limits.
              */
             SkIRect rect = clipRgn.getBounds();
             if (rect.fTop < start_y) {
                 rect.fTop = start_y;
             }
             if (rect.fBottom > stop_y) {
                 rect.fBottom = stop_y;
             }
             if (!rect.isEmpty()) {
                 blitter->blitRect(rect.fLeft << shiftEdgesUp,
                                   rect.fTop << shiftEdgesUp,
                                   rect.width() << shiftEdgesUp,
                                   rect.height() << shiftEdgesUp);
             }
         }
-
         return;
     }
 
     SkEdge headEdge, tailEdge, *last;
     // this returns the first and last edge after they're sorted into a dlink list
     SkEdge* edge = sort_edges(list, count, &last);
 
     headEdge.fPrev = NULL;
     headEdge.fNext = edge;
     headEdge.fFirstY = kEDGE_HEAD_Y;
@@ skipping 19 matching lines @@
     InverseBlitter  ib;
     PrePostProc     proc = NULL;
 
     if (path.isInverseFillType()) {
         ib.setBlitter(blitter, clipRgn.getBounds(), shiftEdgesUp);
         blitter = &ib;
         proc = PrePostInverseBlitterProc;
     }
 
     if (path.isConvex() && (NULL == proc)) {
+        SkASSERT(count >= 2);   // convex walker does not handle missing right edges
         walk_convex_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, NULL);
     } else {
         int rightEdge;
         if (clipRect) {
             rightEdge = clipRect->right();
         } else {
             rightEdge = SkScalarRoundToInt(path.getBounds().right()) << shiftEdgesUp;
         }
         
         walk_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, proc, rightEdge);
@@ skipping 217 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);
     }
 }