Pass dashing information to path rasterizers.

experimental/StrokePathRenderer/GrStrokePathRenderer.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 "GrStrokePathRenderer.h"
 
 #include "GrDrawTarget.h"
@@ skipping 36 matching lines @@
             res.x() < GrMin(x3, x4) || res.x() > GrMax(x3, x4) ||
             res.y() < GrMin(y1, y2) || res.y() > GrMax(y1, y2) ||
             res.y() < GrMin(y3, y4) || res.y() > GrMax(y3, y4)) ?
             kOut_IntersectionType : kIn_IntersectionType;
 }
 
 GrStrokePathRenderer::GrStrokePathRenderer() {
 }
 
 bool GrStrokePathRenderer::canDrawPath(const SkPath& path,
-                                       const SkStrokeRec& stroke,
+                                       const GrStrokeInfo& stroke,
                                        const GrDrawTarget* target,
                                        bool antiAlias) const {
     // FIXME : put the proper condition once GrDrawTarget::isOpaque is implemented
     const bool isOpaque = true; // target->isOpaque();
 
     // FIXME : remove this requirement once we have AA circles and implement the
     //         circle joins/caps appropriately in the ::onDrawPath() function.
     const bool requiresAACircle = (stroke.getCap()  == SkPaint::kRound_Cap) ||
                                   (stroke.getJoin() == SkPaint::kRound_Join);
 
     // Indices being stored in uint16, we don't want to overflow the indices capacity
     static const int maxVBSize = 1 << 16;
     const int maxNbVerts = (path.countPoints() + 1) * 5;
 
     // Check that the path contains no curved lines, only straight lines
     static const uint32_t unsupportedMask = SkPath::kQuad_SegmentMask | SkPath::kCubic_SegmentMask;
 
     // Must not be filled nor hairline nor semi-transparent
     // Note : May require a check to path.isConvex() if AA is supported
-    return ((stroke.getStyle() == SkStrokeRec::kStroke_Style) && (maxNbVerts < maxVBSize) &&
-            !path.isInverseFillType() && isOpaque && !requiresAACircle && !antiAlias &&
-            ((path.getSegmentMasks() & unsupportedMask) == 0));
+    return ((stroke.getStrokeRec()->getStyle() == SkStrokeRec::kStroke_Style) &&
+            (maxNbVerts < maxVBSize) && !path.isInverseFillType() && isOpaque &&
+            !requiresAACircle && !antiAlias && ((path.getSegmentMasks() & unsupportedMask) == 0));
 }
 
 bool GrStrokePathRenderer::onDrawPath(const SkPath& origPath,
-                                      const SkStrokeRec& stroke,
+                                      const GrStrokeInfo& stroke,
                                       GrDrawTarget* target,
                                       bool antiAlias) {
     if (origPath.isEmpty()) {
         return true;
     }
 
     SkScalar width = stroke.getWidth();
     if (width <= 0) {
         return false;
     }
@@ skipping 197 matching lines @@
     if (vCount > 0) {
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             0,        // start vertex
                             0,        // start index
                             vCount,
                             iCount);
     }
 
     return true;
 }