Avoid using SkPathEffect::DashInfo in GrStrokeInfo

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatch.h"
@@ skipping 23 matching lines @@
     if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
         return false;
     }
 
     // May be able to relax this to include skew. As of now cannot do perspective
     // because of the non uniform scaling of bloating a rect
     if (!viewMatrix.preservesRightAngles()) {
         return false;
     }
 
-    if (!strokeInfo.isDashed() || 2 != strokeInfo.dashCount()) {
+    if (!strokeInfo.isDashed() || 2 != strokeInfo.getDashCount()) {
         return false;
     }
 
-    const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
-    if (0 == info.fIntervals[0] && 0 == info.fIntervals[1]) {
+    const SkScalar* intervals = strokeInfo.getDashIntervals();
+    if (0 == intervals[0] && 0 == intervals[1]) {
         return false;
     }
 
     SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
     // Current we do don't handle Round or Square cap dashes
-    if (SkPaint::kRound_Cap == cap && info.fIntervals[0] != 0.f) {
+    if (SkPaint::kRound_Cap == cap && intervals[0] != 0.f) {
         return false;
     }
 
     return true;
 }
 
 namespace {
 struct DashLineVertex {
     SkPoint fPos;
     SkPoint fDashPos;
@@ skipping 630 matching lines @@
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 
 bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target,
                                    GrPipelineBuilder* pipelineBuilder, GrColor color,
                                    const SkMatrix& viewMatrix, const SkPoint pts[2],
                                    bool useAA, const GrStrokeInfo& strokeInfo) {
-    const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
+    const SkScalar* intervals = strokeInfo.getDashIntervals();
+    SkScalar phase = strokeInfo.getDashPhase();
 
     SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
 
     DashBatch::Geometry geometry;
     geometry.fSrcStrokeWidth = strokeInfo.getStrokeRec().getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
-    SkASSERT(info.fPhase >= 0 && info.fPhase < info.fIntervals[0] + info.fIntervals[1]);
+    SkASSERT(phase >= 0 && phase < intervals[0] + intervals[1]);
 
     // Rotate the src pts so they are aligned horizontally with pts[0].fX < pts[1].fX
     if (pts[0].fY != pts[1].fY || pts[0].fX > pts[1].fX) {
         SkMatrix rotMatrix;
         align_to_x_axis(pts, &rotMatrix, geometry.fPtsRot);
         if(!rotMatrix.invert(&geometry.fSrcRotInv)) {
             SkDebugf("Failed to create invertible rotation matrix!\n");
             return false;
         }
     } else {
         geometry.fSrcRotInv.reset();
         memcpy(geometry.fPtsRot, pts, 2 * sizeof(SkPoint));
     }
 
     // Scale corrections of intervals and stroke from view matrix
     calc_dash_scaling(&geometry.fParallelScale, &geometry.fPerpendicularScale, viewMatrix,
                       geometry.fPtsRot);
 
-    SkScalar offInterval = info.fIntervals[1] * geometry.fParallelScale;
+    SkScalar offInterval = intervals[1] * geometry.fParallelScale;
     SkScalar strokeWidth = geometry.fSrcStrokeWidth * geometry.fPerpendicularScale;
 
     if (SkPaint::kSquare_Cap == cap && 0 != geometry.fSrcStrokeWidth) {
         // add cap to on interveal and remove from off interval
         offInterval -= strokeWidth;
     }
 
     DashAAMode aaMode = pipelineBuilder->getRenderTarget()->isMultisampled() ? kMSAA_DashAAMode :
                         useAA ? kEdgeAA_DashAAMode : kBW_DashAAMode;
 
     // TODO we can do a real rect call if not using fulldash(ie no off interval, not using AA)
     bool fullDash = offInterval > 0.f || aaMode != kBW_DashAAMode;
 
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
-    geometry.fPhase = info.fPhase;
-    geometry.fIntervals[0] = info.fIntervals[0];
-    geometry.fIntervals[1] = info.fIntervals[1];
+    geometry.fPhase = phase;
+    geometry.fIntervals[0] = intervals[0];
+    geometry.fIntervals[1] = intervals[1];
 
     SkAutoTUnref<GrBatch> batch(DashBatch::Create(geometry, cap, aaMode, fullDash));
     target->drawBatch(pipelineBuilder, batch);
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
@@ skipping 510 matching lines @@
     switch (cap) {
         case kRound_DashCap:
             return DashingCircleEffect::Create(color, dashAAMode, localMatrix);
         case kNonRound_DashCap:
             return DashingLineEffect::Create(color, dashAAMode, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }