Revert of Replace GrStrokeInfo with GrStyle.

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 "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
-#include "GrStyle.h"
+#include "GrStrokeInfo.h"
 #include "SkGr.h"
 #include "batches/GrVertexBatch.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
-bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStyle& style,
+bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
                                       const SkMatrix& viewMatrix) {
     // Pts must be either horizontal or vertical in src space
     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 (!style.isDashed() || 2 != style.dashIntervalCnt()) {
+    if (!strokeInfo.isDashed() || 2 != strokeInfo.getDashCount()) {
         return false;
     }
 
-    const SkScalar* intervals = style.dashIntervals();
+    const SkScalar* intervals = strokeInfo.getDashIntervals();
     if (0 == intervals[0] && 0 == intervals[1]) {
         return false;
     }
 
-    SkPaint::Cap cap = style.strokeRec().getCap();
+    SkPaint::Cap cap = strokeInfo.getCap();
     // Current we do don't handle Round or Square cap dashes
     if (SkPaint::kRound_Cap == cap && intervals[0] != 0.f) {
         return false;
     }
 
     return true;
 }
 
 namespace {
 struct DashLineVertex {
@@ skipping 618 matching lines @@
     static const int kVertsPerDash = 4;
     static const int kIndicesPerDash = 6;
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 static GrDrawBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
-                                 bool useAA, const GrStyle& style, bool msaaRT) {
-    SkASSERT(GrDashingEffect::CanDrawDashLine(pts, style, viewMatrix));
-    const SkScalar* intervals = style.dashIntervals();
-    SkScalar phase = style.dashPhase();
+                                 bool useAA, const GrStrokeInfo& strokeInfo, bool msaaRT) {
+    const SkScalar* intervals = strokeInfo.getDashIntervals();
+    SkScalar phase = strokeInfo.getDashPhase();
 
-    SkPaint::Cap cap = style.strokeRec().getCap();
+    SkPaint::Cap cap = strokeInfo.getCap();
 
     DashBatch::Geometry geometry;
-    geometry.fSrcStrokeWidth = style.strokeRec().getWidth();
+    geometry.fSrcStrokeWidth = strokeInfo.getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
     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");
@@ skipping 29 matching lines @@
     geometry.fIntervals[1] = intervals[1];
 
     return DashBatch::Create(geometry, cap, aaMode, fullDash);
 }
 
 GrDrawBatch* GrDashingEffect::CreateDashLineBatch(GrColor color,
                                                   const SkMatrix& viewMatrix,
                                                   const SkPoint pts[2],
                                                   bool useAA,
                                                   bool msaaIsEnabled,
-                                                  const GrStyle& style) {
-    return create_batch(color, viewMatrix, pts, useAA, style, msaaIsEnabled);
+                                                  const GrStrokeInfo& strokeInfo) {
+    return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaIsEnabled);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
 
 /*
  * This effect will draw a dotted line (defined as a dashed lined with round caps and no on
  * interval). The radius of the dots is given by the strokeWidth and the spacing by the DashInfo.
  * Both of the previous two parameters are in device space. This effect also requires the setting of
@@ skipping 520 matching lines @@
 
     }
 
     // phase is 0 < sum (i0, i1)
     SkScalar phase = random->nextRangeScalar(0, intervals[0] + intervals[1]);
 
     SkPaint p;
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SkIntToScalar(1));
     p.setStrokeCap(cap);
-    p.setPathEffect(GrTest::TestDashPathEffect::Make(intervals, 2, phase));
 
-    GrStyle style(p);
+    GrStrokeInfo strokeInfo(p);
 
-    return create_batch(color, viewMatrix, pts, useAA, style, msaaRT);
+    SkPathEffect::DashInfo info;
+    info.fIntervals = intervals;
+    info.fCount = 2;
+    info.fPhase = phase;
+    SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
+    SkASSERT(success);
+
+    return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif