Avoid unnecessary GrShape->SkPath conversion in GrStencilAndCoverPathRenderer

src/gpu/batches/GrStencilAndCoverPathRenderer.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 "GrStencilAndCoverPathRenderer.h"
 #include "GrCaps.h"
@@ skipping 76 matching lines @@
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
                               "GrStencilAndCoverPathRenderer::onDrawPath");
     SkASSERT(!args.fPaint->isAntiAlias() || args.fDrawContext->isStencilBufferMultisampled());
     SkASSERT(!args.fShape->style().strokeRec().isHairlineStyle());
 
     const SkMatrix& viewMatrix = *args.fViewMatrix;
 
-    SkPath path;
-    args.fShape->asPath(&path);
 
-    SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fShape));
+    SkAutoTUnref<GrPath> path(get_gr_path(fResourceProvider, *args.fShape));
 
-    if (path.isInverseFillType()) {
+    if (args.fShape->inverseFilled()) {
         SkMatrix invert = SkMatrix::I();
         SkRect bounds =
             SkRect::MakeLTRB(0, 0,
                              SkIntToScalar(args.fDrawContext->width()),
                              SkIntToScalar(args.fDrawContext->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
         if (!viewMatrix.hasPerspective() && viewMatrix.invert(&vmi)) {
             vmi.mapRect(&bounds);
             // theoretically could set bloat = 0, instead leave it because of matrix inversion
             // precision.
             SkScalar bloat = viewMatrix.getMaxScale() * SK_ScalarHalf;
             bounds.outset(bloat, bloat);
         } else {
             if (!viewMatrix.invert(&invert)) {
                 return false;
             }
         }
         const SkMatrix& viewM = viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix;
 
         SkAutoTUnref<GrDrawBatch> coverBatch(
                 GrRectBatchFactory::CreateNonAAFill(args.fPaint->getColor(), viewM, bounds,
                                                     nullptr, &invert));
 
         // fake inverse with a stencil and cover
         args.fDrawContext->drawContextPriv().stencilPath(*args.fClip, args.fPaint->isAntiAlias(),
-                                                         viewMatrix, p);
+                                                         viewMatrix, path);
 
         {
             static constexpr GrUserStencilSettings kInvertedCoverPass(
                 GrUserStencilSettings::StaticInit<
                     0x0000,
                     // We know our rect will hit pixels outside the clip and the user bits will
                     // be 0 outside the clip. So we can't just fill where the user bits are 0. We
                     // also need to check that the clip bit is set.
                     GrUserStencilTest::kEqualIfInClip,
                     0xffff,
@@ skipping 13 matching lines @@
         static constexpr GrUserStencilSettings kCoverPass(
             GrUserStencilSettings::StaticInit<
                 0x0000,
                 GrUserStencilTest::kNotEqual,
                 0xffff,
                 GrUserStencilOp::kZero,
                 GrUserStencilOp::kKeep,
                 0xffff>()
         );
 
-        SkAutoTUnref<GrDrawBatch> batch(
-                GrDrawPathBatch::Create(viewMatrix, args.fPaint->getColor(), p->getFillType(), p));
+        SkAutoTUnref<GrDrawBatch> batch(GrDrawPathBatch::Create(viewMatrix, args.fPaint->getColor(),
+                                                                path));
 
         GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fPaint->isAntiAlias());
         pipelineBuilder.setUserStencil(&kCoverPass);
         if (args.fAntiAlias) {
             SkASSERT(args.fDrawContext->isStencilBufferMultisampled());
             pipelineBuilder.enableState(GrPipelineBuilder::kHWAntialias_Flag);
         }
 
         args.fDrawContext->drawBatch(pipelineBuilder, *args.fClip, batch);
     }
 
     return true;
 }