Revert of Replace GrStrokeInfo with GrStyle.

src/gpu/gl/GrGLPath.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 "GrGLPath.h"
 #include "GrGLPathRendering.h"
 #include "GrGLGpu.h"
-#include "GrStyle.h"
 
 namespace {
 inline GrGLubyte verb_to_gl_path_cmd(SkPath::Verb verb) {
     static const GrGLubyte gTable[] = {
         GR_GL_MOVE_TO,
         GR_GL_LINE_TO,
         GR_GL_QUADRATIC_CURVE_TO,
         GR_GL_CONIC_CURVE_TO,
         GR_GL_CUBIC_CURVE_TO,
         GR_GL_CLOSE_PATH,
@@ skipping 223 matching lines @@
         SkDEBUGCODE(verify_floats(&pathCoords[0], pathCoords.count()));
         GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
                                                     pathCoords.count(), GR_GL_FLOAT,
                                                     &pathCoords[0]));
         return;
     }
 #endif
     SkAssertResult(init_path_object_for_general_path<false>(gpu, pathID, skPath));
 }
 
-void GrGLPath::InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const SkStrokeRec& stroke) {
+void GrGLPath::InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const GrStrokeInfo& stroke) {
+    SkASSERT(stroke.needToApply());
+    SkASSERT(!stroke.isDashed());
     SkASSERT(!stroke.isHairlineStyle());
     GR_GL_CALL(gpu->glInterface(),
                PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
     GR_GL_CALL(gpu->glInterface(),
                PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(stroke.getMiter())));
     GrGLenum join = join_to_gl_join(stroke.getJoin());
     GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_JOIN_STYLE, join));
     GrGLenum cap = cap_to_gl_cap(stroke.getCap());
     GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_END_CAPS, cap));
     GR_GL_CALL(gpu->glInterface(), PathParameterf(pathID, GR_GL_PATH_STROKE_BOUND, 0.02f));
 }
 
 void GrGLPath::InitPathObjectEmptyPath(GrGLGpu* gpu, GrGLuint pathID) {
     GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, 0, nullptr, 0, GR_GL_FLOAT, nullptr));
 }
 
-GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStyle& style)
-    : INHERITED(gpu, origSkPath, style),
+GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& origStroke)
+    : INHERITED(gpu, origSkPath, origStroke),
       fPathID(gpu->glPathRendering()->genPaths(1)) {
 
     if (origSkPath.isEmpty()) {
         InitPathObjectEmptyPath(gpu, fPathID);
         fShouldStroke = false;
         fShouldFill = false;
     } else {
         const SkPath* skPath = &origSkPath;
         SkTLazy<SkPath> tmpPath;
-        SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
+        const GrStrokeInfo* stroke = &origStroke;
+        GrStrokeInfo tmpStroke(SkStrokeRec::kFill_InitStyle);
 
-        if (style.pathEffect()) {
+        if (stroke->isDashed()) {
             // Skia stroking and NVPR stroking differ with respect to dashing
             // pattern.
-            // Convert a dashing (or other path effect) to either a stroke or a fill.
-            if (style.applyPathEffectToPath(tmpPath.init(), &stroke, *skPath, SK_Scalar1)) {
+            // Convert a dashing to either a stroke or a fill.
+            if (stroke->applyDashToPath(tmpPath.init(), &tmpStroke, *skPath)) {
                 skPath = tmpPath.get();
+                stroke = &tmpStroke;
             }
-        } else {
-            stroke = style.strokeRec();
         }
 
         bool didInit = false;
-        if (stroke.needToApply() && stroke.getCap() != SkPaint::kButt_Cap) {
+        if (stroke->needToApply() && stroke->getCap() != SkPaint::kButt_Cap) {
             // Skia stroking and NVPR stroking differ with respect to stroking
             // end caps of empty subpaths.
             // Convert stroke to fill if path contains empty subpaths.
             didInit = InitPathObjectPathDataCheckingDegenerates(gpu, fPathID, *skPath);
             if (!didInit) {
                 if (!tmpPath.isValid()) {
                     tmpPath.init();
                 }
-                SkAssertResult(stroke.applyToPath(tmpPath.get(), *skPath));
+                SkAssertResult(stroke->applyToPath(tmpPath.get(), *skPath));
                 skPath = tmpPath.get();
-                stroke.setFillStyle();
+                tmpStroke.setFillStyle();
+                stroke = &tmpStroke;
             }
         }
 
         if (!didInit) {
             InitPathObjectPathData(gpu, fPathID, *skPath);
         }
 
-        fShouldStroke = stroke.needToApply();
-        fShouldFill = stroke.isFillStyle() ||
-                stroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
+        fShouldStroke = stroke->needToApply();
+        fShouldFill = stroke->isFillStyle() ||
+                stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;
 
         fFillType = convert_skpath_filltype(skPath->getFillType());
         fBounds = skPath->getBounds();
-        SkScalar radius = stroke.getInflationRadius();
-        fBounds.outset(radius, radius);
+
         if (fShouldStroke) {
-            InitPathObjectStroke(gpu, fPathID, stroke);
+            InitPathObjectStroke(gpu, fPathID, *stroke);
+
+            // FIXME: try to account for stroking, without rasterizing the stroke.
+            fBounds.outset(stroke->getWidth(), stroke->getWidth());
         }
     }
 
     this->registerWithCache(SkBudgeted::kYes);
 }
 
 void GrGLPath::onRelease() {
     if (0 != fPathID) {
         static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
         fPathID = 0;
     }
 
     INHERITED::onRelease();
 }
 
 void GrGLPath::onAbandon() {
     fPathID = 0;
 
     INHERITED::onAbandon();
 }