Revert of Replace GrStrokeInfo with GrStyle.

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"
 #include "GrContext.h"
 #include "GrDrawPathBatch.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrRenderTarget.h"
 #include "GrResourceProvider.h"
-#include "GrStyle.h"
+#include "GrStrokeInfo.h"
 #include "batches/GrRectBatchFactory.h"
 
 GrPathRenderer* GrStencilAndCoverPathRenderer::Create(GrResourceProvider* resourceProvider,
                                                       const GrCaps& caps) {
     if (caps.shaderCaps()->pathRenderingSupport()) {
         return new GrStencilAndCoverPathRenderer(resourceProvider);
     } else {
         return nullptr;
     }
 }
 
 GrStencilAndCoverPathRenderer::GrStencilAndCoverPathRenderer(GrResourceProvider* resourceProvider)
     : fResourceProvider(resourceProvider) {
 }
 
 bool GrStencilAndCoverPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    // GrPath doesn't support hairline paths. Also, an arbitrary path effect could change
-    // the style type to hairline.
-    if (!args.fStyle->hasNonDashPathEffect() || args.fStyle->strokeRec().isHairlineStyle()) {
+    if (args.fStroke->isHairlineStyle()) {
         return false;
     }
     if (!args.fIsStencilDisabled) {
         return false;
     }
     if (args.fAntiAlias) {
         return args.fIsStencilBufferMSAA;
     } else {
         return true; // doesn't do per-path AA, relies on the target having MSAA
     }
 }
 
 static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const SkPath& skPath,
-                           const GrStyle& style) {
+                           const GrStrokeInfo& stroke) {
     GrUniqueKey key;
     bool isVolatile;
-    GrPath::ComputeKey(skPath, style, &key, &isVolatile);
+    GrPath::ComputeKey(skPath, stroke, &key, &isVolatile);
     SkAutoTUnref<GrPath> path(
         static_cast<GrPath*>(resourceProvider->findAndRefResourceByUniqueKey(key)));
     if (!path) {
-        path.reset(resourceProvider->createPath(skPath, style));
+        path.reset(resourceProvider->createPath(skPath, stroke));
         if (!isVolatile) {
             resourceProvider->assignUniqueKeyToResource(key, path);
         }
     } else {
-        SkASSERT(path->isEqualTo(skPath, style));
+        SkASSERT(path->isEqualTo(skPath, stroke));
     }
     return path.release();
 }
 
 void GrStencilAndCoverPathRenderer::onStencilPath(const StencilPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
                               "GrStencilAndCoverPathRenderer::onStencilPath");
     SkASSERT(!args.fPath->isInverseFillType());
-    SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fPath, GrStyle::SimpleFill()));
+    SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fPath, GrStrokeInfo::FillInfo()));
     args.fTarget->stencilPath(*args.fPipelineBuilder, *args.fViewMatrix, p, p->getFillType());
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
                               "GrStencilAndCoverPathRenderer::onDrawPath");
-    SkASSERT(!args.fStyle->strokeRec().isHairlineStyle());
+    SkASSERT(!args.fStroke->isHairlineStyle());
     const SkPath& path = *args.fPath;
     GrPipelineBuilder* pipelineBuilder = args.fPipelineBuilder;
     const SkMatrix& viewMatrix = *args.fViewMatrix;
 
     SkASSERT(pipelineBuilder->getStencil().isDisabled());
 
     if (args.fAntiAlias) {
         SkASSERT(pipelineBuilder->getRenderTarget()->isStencilBufferMultisampled());
         pipelineBuilder->enableState(GrPipelineBuilder::kHWAntialias_Flag);
     }
 
-    SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, path, *args.fStyle));
+    SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, path, *args.fStroke));
 
     if (path.isInverseFillType()) {
         static constexpr GrStencilSettings kInvertedStencilPass(
             kKeep_StencilOp,
             kZero_StencilOp,
             // 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.
             kEqualIfInClip_StencilFunc,
             0xffff,
@@ skipping 42 matching lines @@
 
         pipelineBuilder->setStencil(kStencilPass);
         SkAutoTUnref<GrDrawPathBatchBase> batch(
                 GrDrawPathBatch::Create(viewMatrix, args.fColor, p->getFillType(), p));
         args.fTarget->drawPathBatch(*pipelineBuilder, batch);
     }
 
     pipelineBuilder->stencil()->setDisabled();
     return true;
 }