Handle paths that do not report empty, but have no edges.

src/core/SkRegion_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 "SkRegionPriv.h"
 #include "SkBlitter.h"
 #include "SkScan.h"
@@ skipping 250 matching lines @@
         2,  //  kQuad_VerbB
         2,  //  kConic_VerbB
         3,  //  kCubic_Verb
         0,  //  kClose_Verb
         0   //  kDone_Verb
     };
     SkASSERT((unsigned)verb < SK_ARRAY_COUNT(gPathVerbToMaxEdges));
     return gPathVerbToMaxEdges[verb];
 }
 
-
+// If returns 0, ignore itop and ibot
 static int count_path_runtype_values(const SkPath& path, int* itop, int* ibot) {
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     int maxEdges = 0;
     SkScalar    top = SkIntToScalar(SK_MaxS16);
     SkScalar    bot = SkIntToScalar(SK_MinS16);
 
     while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
         maxEdges += verb_to_max_edges(verb);
 
         int lastIndex = verb_to_initial_last_index(verb);
         if (lastIndex > 0) {
             for (int i = 1; i <= lastIndex; i++) {
                 if (top > pts[i].fY) {
                     top = pts[i].fY;
                 } else if (bot < pts[i].fY) {
                     bot = pts[i].fY;
                 }
             }
         } else if (SkPath::kMove_Verb == verb) {
             if (top > pts[0].fY) {
                 top = pts[0].fY;
             } else if (bot < pts[0].fY) {
                 bot = pts[0].fY;
             }
         }
     }
+    if (0 == maxEdges) {
+        return 0;   // we have only moves+closes
+    }
+
     SkASSERT(top <= bot);
-
     *itop = SkScalarRoundToInt(top);
     *ibot = SkScalarRoundToInt(bot);
     return maxEdges;
 }
 
+static bool check_inverse_on_empty_return(SkRegion* dst, const SkPath& path, const SkRegion& clip) {
+    if (path.isInverseFillType()) {
+        return dst->set(clip);
+    } else {
+        return dst->setEmpty();
+    }
+}
+
 bool SkRegion::setPath(const SkPath& path, const SkRegion& clip) {
     SkDEBUGCODE(this->validate();)
 
     if (clip.isEmpty()) {
         return this->setEmpty();
     }
 
     if (path.isEmpty()) {
-        if (path.isInverseFillType()) {
-            return this->set(clip);
-        } else {
-            return this->setEmpty();
-        }
+        return check_inverse_on_empty_return(this, path, clip);
     }
 
     //  compute worst-case rgn-size for the path
     int pathTop, pathBot;
     int pathTransitions = count_path_runtype_values(path, &pathTop, &pathBot);
+    if (0 == pathTransitions) {
+        return check_inverse_on_empty_return(this, path, clip);
+    }
+
     int clipTop, clipBot;
-    int clipTransitions;
-
-    clipTransitions = clip.count_runtype_values(&clipTop, &clipBot);
+    int clipTransitions = clip.count_runtype_values(&clipTop, &clipBot);
 
     int top = SkMax32(pathTop, clipTop);
     int bot = SkMin32(pathBot, clipBot);
-
-    if (top >= bot)
-        return this->setEmpty();
+    if (top >= bot) {
+        return check_inverse_on_empty_return(this, path, clip);
+    }
 
     SkRgnBuilder builder;
 
     if (!builder.init(bot - top,
                       SkMax32(pathTransitions, clipTransitions),
                       path.isInverseFillType())) {
         // can't allocate working space, so return false
         return this->setEmpty();
     }
 
@@ skipping 172 matching lines @@
 #endif
 
     path->incReserve(count << 1);
     do {
         SkASSERT(count > 1);
         count -= extract_path(start, stop, path);
     } while (count > 0);
 
     return true;
 }