From: kkinnunen <kkinnunen@nvidia.com>
Date: Tue, 8 Dec 2015 07:39:01 +0000 (-0800)
Subject: Use correct fill type and bounds for NVPR paths that are stroked with Skia
X-Git-Tag: submit/tizen/20180928.044319~184^2~442
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c6e7a13489eda2abf7a03ea8de3a4abbab1c597d;p=platform%2Fupstream%2FlibSkiaSharp.git

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

When using NVPR, sometimes paths must be stroked by Skia and then drawn
with fill using NVPR. In these cases, use the fill type and bounds of
the stroked path, not the original path.

Fixes degeneratesegments for nvprmsaa backends.

BUG=skia:4608

Review URL: https://codereview.chromium.org/1504753003
---

diff --git a/src/gpu/GrPath.h b/src/gpu/GrPath.h
index 2edfd4cb5e..09d317ef2f 100644
--- a/src/gpu/GrPath.h
+++ b/src/gpu/GrPath.h
@@ -10,19 +10,19 @@
 
 #include "GrGpuResource.h"
 #include "GrStrokeInfo.h"
+#include "GrPathRendering.h"
 #include "SkPath.h"
 #include "SkRect.h"
 
 class GrPath : public GrGpuResource {
 public:
-    
-
     /**
      * Initialize to a path with a fixed stroke. Stroke must not be hairline.
      */
     GrPath(GrGpu* gpu, const SkPath& skPath, const GrStrokeInfo& stroke)
         : INHERITED(gpu, kCached_LifeCycle)
-        , fBounds(skPath.getBounds())
+        , fBounds(SkRect::MakeEmpty())
+        , fFillType(GrPathRendering::kWinding_FillType)
 #ifdef SK_DEBUG
         , fSkPath(skPath)
         , fStroke(stroke)
@@ -35,12 +35,15 @@ public:
 
     const SkRect& getBounds() const { return fBounds; }
 
+    GrPathRendering::FillType getFillType() const { return fFillType; }
 #ifdef SK_DEBUG
     bool isEqualTo(const SkPath& path, const GrStrokeInfo& stroke) const;
 #endif
 
 protected:
+    // Subclass should init these.
     SkRect fBounds;
+    GrPathRendering::FillType fFillType;
 #ifdef SK_DEBUG
     SkPath fSkPath;
     GrStrokeInfo fStroke;
diff --git a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
index a11d2b4683..cf5db3fc63 100644
--- a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp
@@ -16,22 +16,6 @@
 #include "GrResourceProvider.h"
 #include "GrStrokeInfo.h"
 
-/*
- * 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;
-    }
-}
-
 GrPathRenderer* GrStencilAndCoverPathRenderer::Create(GrResourceProvider* resourceProvider,
                                                       const GrCaps& caps) {
     if (caps.shaderCaps()->pathRenderingSupport()) {
@@ -80,8 +64,7 @@ static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const SkPath& s
 void GrStencilAndCoverPathRenderer::onStencilPath(const StencilPathArgs& args) {
     SkASSERT(!args.fPath->isInverseFillType());
     SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fPath, *args.fStroke));
-    args.fTarget->stencilPath(*args.fPipelineBuilder, *args.fViewMatrix, p,
-                              convert_skpath_filltype(args.fPath->getFillType()));
+    args.fTarget->stencilPath(*args.fPipelineBuilder, *args.fViewMatrix, p, p->getFillType());
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
@@ -114,8 +97,7 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
         pipelineBuilder->setStencil(kInvertedStencilPass);
 
         // fake inverse with a stencil and cover
-        args.fTarget->stencilPath(*pipelineBuilder, viewMatrix, p,
-                                  convert_skpath_filltype(path.getFillType()));
+        args.fTarget->stencilPath(*pipelineBuilder, viewMatrix, p, p->getFillType());
 
         SkMatrix invert = SkMatrix::I();
         SkRect bounds =
@@ -149,8 +131,7 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
             0xffff);
 
         pipelineBuilder->setStencil(kStencilPass);
-        args.fTarget->drawPath(*pipelineBuilder, viewMatrix, args.fColor, p,
-                               convert_skpath_filltype(path.getFillType()));
+        args.fTarget->drawPath(*pipelineBuilder, viewMatrix, args.fColor, p, p->getFillType());
     }
 
     pipelineBuilder->stencil()->setDisabled();
diff --git a/src/gpu/gl/GrGLPath.cpp b/src/gpu/gl/GrGLPath.cpp
index d1fc39dffc..067b74e154 100644
--- a/src/gpu/gl/GrGLPath.cpp
+++ b/src/gpu/gl/GrGLPath.cpp
@@ -179,6 +179,23 @@ inline bool init_path_object_for_general_path(GrGLGpu* gpu, GrGLuint pathID,
                                                 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,
@@ -292,6 +309,9 @@ GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& o
         fShouldFill = stroke->isFillStyle() ||
                 stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;
 
+        fFillType = convert_skpath_filltype(skPath->getFillType());
+        fBounds = skPath->getBounds();
+
         if (fShouldStroke) {
             InitPathObjectStroke(gpu, fPathID, *stroke);