Pass dashing information to path rasterizers.

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrPathUtils.h"
 #include "GrPipelineBuilder.h"
 #include "GrProcessor.h"
+#include "GrStrokeInfo.h"
 #include "SkGeometry.h"
 #include "SkStroke.h"
 #include "SkTemplates.h"
 
 #include "effects/GrBezierEffect.h"
 
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
 // bloat_quad. Quadratics and conics share an index buffer
 
@@ skipping 599 matching lines @@
 }
 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAHairLinePathRenderer::canDrawPath(const GrDrawTarget* target,
                                            const GrPipelineBuilder* pipelineBuilder,
                                            const SkMatrix& viewMatrix,
                                            const SkPath& path,
-                                           const SkStrokeRec& stroke,
+                                           const GrStrokeInfo& stroke,
                                            bool antiAlias) const {
     if (!antiAlias) {
         return false;
     }
 
-    if (!IsStrokeHairlineOrEquivalent(stroke, viewMatrix, NULL)) {
+    if (!IsStrokeHairlineOrEquivalent(stroke.getStrokeRec(), viewMatrix, NULL)) {
         return false;
     }
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
@@ skipping 365 matching lines @@
             }
         }
     }
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
                                           GrPipelineBuilder* pipelineBuilder,
                                           GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
-                                          const SkStrokeRec& stroke,
+                                          const GrStrokeInfo& stroke,
                                           bool) {
     if (!fLinesIndexBuffer || !fQuadsIndexBuffer) {
         SkDebugf("unable to allocate indices\n");
         return false;
     }
 
     SkScalar hairlineCoverage;
     uint8_t newCoverage = 0xff;
-    if (IsStrokeHairlineOrEquivalent(stroke, viewMatrix, &hairlineCoverage)) {
+    if (IsStrokeHairlineOrEquivalent(stroke.getStrokeRec(), viewMatrix, &hairlineCoverage)) {
         newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
     }
 
     SkIRect devClipBounds;
     pipelineBuilder->clip().getConservativeBounds(pipelineBuilder->getRenderTarget(),
                                                   &devClipBounds);
 
     // This outset was determined experimentally by running skps and gms.  It probably could be a
     // bit tighter
     SkRect devRect = path.getBounds();
     viewMatrix.mapRect(&devRect);
     devRect.outset(2, 2);
 
     AAHairlineBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fCoverage = newCoverage;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPath = path;
     SkDEBUGCODE(geometry.fDevBounds = devRect;)
     geometry.fDevClipBounds = devClipBounds;
 
     SkAutoTUnref<GrBatch> batch(AAHairlineBatch::Create(geometry, fLinesIndexBuffer,
                                                         fQuadsIndexBuffer));
     target->drawBatch(pipelineBuilder, batch, &devRect);
 
     return true;
 }