Use correct fill type and bounds for NVPR paths that are stroked with Skia

src/gpu/gl/GrGLPath.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLPath.h"
 #include "GrGLPathRendering.h"
@@ skipping 161 matching lines @@
         SkDEBUGCODE(numCoords += num_coords(verb));
         pathCoords.push_back_n(coordsForVerb, coords);
     }
     SkASSERT(verbCnt == pathCommands.count());
     SkASSERT(numCoords == pathCoords.count());
 
     GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
                                                 pathCoords.count(), GR_GL_FLOAT, &pathCoords[0]));
     return true;
 }
+
+/*
+ * For now paths only natively support winding and even odd fill types
+ */
+static GrPathRendering::FillType convert_skpath_filltype(SkPath::FillType fill) {
+    switch (fill) {
+        default:
+            SkFAIL("Incomplete Switch\n");
+        case SkPath::kWinding_FillType:
+        case SkPath::kInverseWinding_FillType:
+            return GrPathRendering::kWinding_FillType;
+        case SkPath::kEvenOdd_FillType:
+        case SkPath::kInverseEvenOdd_FillType:
+            return GrPathRendering::kEvenOdd_FillType;
+    }
+}
+
 } // namespace
 
 bool GrGLPath::InitPathObjectPathDataCheckingDegenerates(GrGLGpu* gpu, GrGLuint pathID,
                                                          const SkPath& skPath) {
     return init_path_object_for_general_path<true>(gpu, pathID, skPath);
 }
 
 void GrGLPath::InitPathObjectPathData(GrGLGpu* gpu,
                                       GrGLuint pathID,
                                       const SkPath& skPath) {
@@ skipping 93 matching lines @@
         }
 
         if (!didInit) {
             InitPathObjectPathData(gpu, fPathID, *skPath);
         }
 
         fShouldStroke = stroke->needToApply();
         fShouldFill = stroke->isFillStyle() ||
                 stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;
 
+        fFillType = convert_skpath_filltype(skPath->getFillType());
+        fBounds = skPath->getBounds();
+
         if (fShouldStroke) {
             InitPathObjectStroke(gpu, fPathID, *stroke);
 
             // FIXME: try to account for stroking, without rasterizing the stroke.
             fBounds.outset(stroke->getWidth(), stroke->getWidth());
         }
     }
 
     this->registerWithCache();
 }
 
 void GrGLPath::onRelease() {
     if (0 != fPathID && this->shouldFreeResources()) {
         static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
         fPathID = 0;
     }
 
     INHERITED::onRelease();
 }
 
 void GrGLPath::onAbandon() {
     fPathID = 0;
 
     INHERITED::onAbandon();
 }