Beginning to refactor nvpr code

src/gpu/GrStencilAndCoverPathRenderer.cpp

Index: src/gpu/GrStencilAndCoverPathRenderer.cpp
diff --git a/src/gpu/GrStencilAndCoverPathRenderer.cpp b/src/gpu/GrStencilAndCoverPathRenderer.cpp
index 5f55c1a21412eaa43c523f96afbe52049013dbb3..6ed4b9e61c3e3dc40a8a7d7b4afaaf1a992816f3 100644
--- a/src/gpu/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/GrStencilAndCoverPathRenderer.cpp
@@ -14,6 +14,22 @@
 #include "GrPath.h"
 #include "SkStrokeRec.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(GrContext* context) {
     SkASSERT(context);
     SkASSERT(context->getGpu());
@@ -44,10 +60,10 @@ bool GrStencilAndCoverPathRenderer::canDrawPath(const SkPath& path,
            target->getDrawState().getStencil().isDisabled();
 }
 
-GrPathRenderer::StencilSupport GrStencilAndCoverPathRenderer::onGetStencilSupport(
-                                                        const SkPath&,
-                                                        const SkStrokeRec& ,
-                                                        const GrDrawTarget*) const {
+GrPathRenderer::StencilSupport
+GrStencilAndCoverPathRenderer::onGetStencilSupport(const SkPath&,
+                                                   const SkStrokeRec& ,
+                                                   const GrDrawTarget*) const {
     return GrPathRenderer::kStencilOnly_StencilSupport;
 }
 
@@ -67,7 +83,7 @@ void GrStencilAndCoverPathRenderer::onStencilPath(const SkPath& path,
                                                   GrDrawTarget* target) {
     SkASSERT(!path.isInverseFillType());
     SkAutoTUnref<GrPath> p(get_gr_path(fGpu, path, stroke));
-    target->stencilPath(p, path.getFillType());
+    target->stencilPath(p, convert_skpath_filltype(path.getFillType()));
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const SkPath& path,
@@ -94,7 +110,27 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const SkPath& path,
             0x0000,
             0xffff);
 
-        *drawState->stencil() = kInvertedStencilPass;
+        drawState->setStencil(kInvertedStencilPass);

[Kimmo Kinnunen, 2014/11/03 20:39:12]

So this hunk was intentionally moved from here down to path rendering
implementation.
The conceptual rationale was that since we have this abstract implementation of
general "stencil and cover path renderer", it would be conceivable that there
would be another implementation that would have the ability to fill inverted
paths. Thus the method here should be used only for NVPR, where we lack inverse
fills. Whether the lack of inverse fills is an inherent property of the STC
algorithm or not, that I'm not expert on.

The practical reason this was moved is that this causes different thing to be
recorded. E.g when recording and replaying InOrderDrawBuffer, this actually
erases the knowledge about path being drawn. Whether that is a bad thing or not,
is of course debatable. My initial thought was and is that I find it a bit
surprising, but I'm no expert and haven't really thought about it..

The actual rationale to address the above practical reason was, if  recall
correctly, to avoid a crash. The original drawSimpleRect had NULL parameter that
affected the DST copy. There was some convolution wrt the if conditions around
the subject that then triggered badness. 

The original commit is at:
https://codereview.chromium.org/22686002/

The move happened at patch #8. 
The DST copy problem is described in the late comments.

[bsalomon, 2014/11/03 20:46:07]

This CL arose out a of a desire to make GrGpu no longer be a sublcass of
GrDrawTarget. GrGpu will no longer have a drawRect method. It will only be able
to execute draws that have been processed by a GrDT. The drawRect call had to
move somewhere upstack.

I agree that we lost a little bit of extensibility here. If NVPR or some similar
extension added support for inverse fills we'd have to revisit this.

[joshualitt, 2014/11/03 20:51:46]

Ahh, so I should explain.  It seems very possible to provide inverse fill at the
driver level.  We are kind of hoping one day to have a solution in the NVPR
driver itself.  Still, the reason I did this is because we are moving to a world
where GPU itself can no longer issue draw calls and ALL draw calls will go
through some kind of draw buffering.  As a result, we can no longer have a late
draw at the GrGLPathRendering level, as was the case with inverse fills.

If future hardware path rendering solutions do perform inverse fills, we'll
still have the decision about whether to do a 'true' inverse fill, or a stencil
+ draw simple rect made at the level of the StencilAndCoverPathRenderer itself.

Its good to see whatever may have effected the earlier patch, ie the crash,
seems to have been resolved.  Thanks for providing the link to the original
commit, it looks like the code I have here should be correct.

+
+        // fake inverse with a stencil and cover
+        target->stencilPath(p, convert_skpath_filltype(path.getFillType()));
+
+        GrDrawState::AutoViewMatrixRestore avmr;
+        SkRect bounds = SkRect::MakeLTRB(0, 0,
+                                         SkIntToScalar(drawState->getRenderTarget()->width()),
+                                         SkIntToScalar(drawState->getRenderTarget()->height()));
+        SkMatrix vmi;
+        // mapRect through persp matrix may not be correct
+        if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
+            vmi.mapRect(&bounds);
+            // theoretically could set bloat = 0, instead leave it because of matrix inversion
+            // precision.
+            SkScalar bloat = drawState->getViewMatrix().getMaxScale() * SK_ScalarHalf;
+            bounds.outset(bloat, bloat);
+        } else {
+            avmr.setIdentity(drawState);
+        }
+        target->drawSimpleRect(bounds);
     } else {
         GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
             kZero_StencilOp,
@@ -104,11 +140,10 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const SkPath& path,
             0x0000,
             0xffff);
 
-        *drawState->stencil() = kStencilPass;
+        drawState->setStencil(kStencilPass);
+        target->drawPath(p, convert_skpath_filltype(path.getFillType()));
     }
 
-    target->drawPath(p, path.getFillType());
-
     target->drawState()->stencil()->setDisabled();
     return true;
 }