account for inverse-paths when we prealloc storage in the rgn-builder

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"
 #include "SkTDArray.h"
 #include "SkPath.h"
 
 class SkRgnBuilder : public SkBlitter {
 public:
     virtual ~SkRgnBuilder();
 
     // returns true if it could allocate the working storage needed
-    bool init(int maxHeight, int maxTransitions);
+    bool init(int maxHeight, int maxTransitions, bool pathIsInverse);
 
     void done() {
         if (fCurrScanline != NULL) {
             fCurrScanline->fXCount = (SkRegion::RunType)((int)(fCurrXPtr - fCurrScanline->firstX()));
             if (!this->collapsWithPrev()) { // flush the last line
                 fCurrScanline = fCurrScanline->nextScanline();
             }
         }
     }
 
@@ skipping 63 matching lines @@
             return true;
         }
         return false;
     }
 };
 
 SkRgnBuilder::~SkRgnBuilder() {
     sk_free(fStorage);
 }
 
-bool SkRgnBuilder::init(int maxHeight, int maxTransitions) {
+bool SkRgnBuilder::init(int maxHeight, int maxTransitions, bool pathIsInverse) {
     if ((maxHeight | maxTransitions) < 0) {
         return false;
     }
 
     Sk64 count, size;
 
+    if (pathIsInverse) {
+        // allow for additional X transitions to "invert" each scanline
+        // [ L' ... normal transitions ... R' ]
+        //
+        maxTransitions += 2;
+    }
+
     // compute the count with +1 and +3 slop for the working buffer
     count.setMul(maxHeight + 1, 3 + maxTransitions);
+
+    if (pathIsInverse) {
+        // allow for two "empty" rows for the top and bottom
+        //      [ Y, 1, L, R, S] == 5 (*2 for top and bottom)
+        count.add(10);
+    }
+
     if (!count.is32() || count.isNeg()) {
         return false;
     }
     fStorageCount = count.get32();
 
     size.setMul(fStorageCount, sizeof(SkRegion::RunType));
     if (!size.is32() || size.isNeg()) {
         return false;
     }
-
+    
     fStorage = (SkRegion::RunType*)sk_malloc_flags(size.get32(), 0);
     if (NULL == fStorage) {
         return false;
     }
 
     fCurrScanline = NULL;    // signal empty collection
     fPrevScanline = NULL;    // signal first scanline
     return true;
 }
 
@@ skipping 171 matching lines @@
     clipTransitions = clip.count_runtype_values(&clipTop, &clipBot);
 
     int top = SkMax32(pathTop, clipTop);
     int bot = SkMin32(pathBot, clipBot);
 
     if (top >= bot)
         return this->setEmpty();
 
     SkRgnBuilder builder;
 
-    if (!builder.init(bot - top, SkMax32(pathTransitions, clipTransitions))) {
+    if (!builder.init(bot - top,
+                      SkMax32(pathTransitions, clipTransitions),
+                      path.isInverseFillType())) {
         // can't allocate working space, so return false
         return this->setEmpty();
     }
 
     SkScan::FillPath(path, clip, &builder);
     builder.done();
 
     int count = builder.computeRunCount();
     if (count == 0) {
         return this->setEmpty();
@@ skipping 166 matching lines @@
 #endif
 
     path->incReserve(count << 1);
     do {
         SkASSERT(count > 1);
         count -= extract_path(start, stop, path);
     } while (count > 0);
 
     return true;
 }