Revert of Replace GrStrokeInfo with GrStyle.

include/gpu/GrDrawContext.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawContext_DEFINED
 #define GrDrawContext_DEFINED
 
@@ skipping 10 matching lines @@
 class GrContext;
 class GrDrawBatch;
 class GrDrawContextPriv;
 class GrDrawPathBatchBase;
 class GrDrawingManager;
 class GrDrawTarget;
 class GrPaint;
 class GrPathProcessor;
 class GrPipelineBuilder;
 class GrRenderTarget;
-class GrStyle;
+class GrStrokeInfo;
 class GrSurface;
 class SkDrawFilter;
 struct SkIPoint;
 struct SkIRect;
 class SkMatrix;
 class SkPaint;
 class SkPath;
 struct SkPoint;
 struct SkRect;
 class SkRRect;
 struct SkRSXform;
 class SkTextBlob;
 
 /*
  * A helper object to orchestrate draws
  */
 class SK_API GrDrawContext : public SkRefCnt {
 public:
     ~GrDrawContext() override;
 
     bool copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint);
 
     // TODO: it is odd that we need both the SkPaint in the following 3 methods.
     // We should extract the text parameters from SkPaint and pass them separately
-    // akin to GrStyle (GrTextInfo?)
+    // akin to GrStrokeInfo (GrTextInfo?)
     virtual void drawText(const GrClip&,  const GrPaint&, const SkPaint&,
                           const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                           SkScalar x, SkScalar y, const SkIRect& clipBounds);
     virtual void drawPosText(const GrClip&, const GrPaint&, const SkPaint&,
                              const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                              const SkScalar pos[], int scalarsPerPosition,
                              const SkPoint& offset, const SkIRect& clipBounds);
     virtual void drawTextBlob(const GrClip&, const SkPaint&,
                               const SkMatrix& viewMatrix, const SkTextBlob*,
                               SkScalar x, SkScalar y,
@@ skipping 16 matching lines @@
 
     /**
      *  Draw everywhere (respecting the clip) with the paint.
      */
     void drawPaint(const GrClip&, const GrPaint&, const SkMatrix& viewMatrix);
 
     /**
      *  Draw the rect using a paint.
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
-     *  @param style        The style to apply. Null means fill. Currently path effects are not
-     *                      allowed.
+     *  @param strokeInfo   the stroke information (width, join, cap), and.
+     *                      the dash information (intervals, count, phase).
+     *                      If strokeInfo == NULL, then the rect is filled.
+     *                      Otherwise, if stroke width == 0, then the stroke
+     *                      is always a single pixel thick, else the rect is
+     *                      mitered/beveled stroked based on stroke width.
      *  The rects coords are used to access the paint (through texture matrix)
      */
     void drawRect(const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect&,
-                  const GrStyle* style  = nullptr);
+                  const GrStrokeInfo* strokeInfo = nullptr);
 
     /**
      * Maps a rectangle of shader coordinates to a rectangle and fills that rectangle.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix which applies to rectToDraw
      * @param rectToDraw    the rectangle to draw
      * @param localRect     the rectangle of shader coordinates applied to rectToDraw
      */
     void fillRectToRect(const GrClip&,
@@ skipping 10 matching lines @@
                                  const SkMatrix& viewMatrix,
                                  const SkRect& rect,
                                  const SkMatrix& localMatrix);
 
     /**
      *  Draw a roundrect using a paint.
      *
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
      *  @param rrect        the roundrect to draw
-     *  @param style        style to apply to the rrect. Currently path effects are not allowed.
+     *  @param strokeInfo   the stroke information (width, join, cap) and
+     *                      the dash information (intervals, count, phase).
      */
     void drawRRect(const GrClip&,
                    const GrPaint&,
                    const SkMatrix& viewMatrix,
                    const SkRRect& rrect,
-                   const GrStyle& style);
+                   const GrStrokeInfo&);
 
     /**
      *  Shortcut for drawing an SkPath consisting of nested rrects using a paint.
      *  Does not support stroking. The result is undefined if outer does not contain
      *  inner.
      *
      *  @param paint        describes how to color pixels.
      *  @param viewMatrix   transformation matrix
      *  @param outer        the outer roundrect
      *  @param inner        the inner roundrect
      */
     void drawDRRect(const GrClip&,
                     const GrPaint&,
                     const SkMatrix& viewMatrix,
                     const SkRRect& outer,
                     const SkRRect& inner);
 
     /**
      * Draws a path.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix
      * @param path          the path to draw
-     * @param style         style to apply to the path.
+     * @param strokeInfo    the stroke information (width, join, cap) and
+     *                      the dash information (intervals, count, phase).
      */
     void drawPath(const GrClip&,
                   const GrPaint&,
                   const SkMatrix& viewMatrix,
                   const SkPath&,
-                  const GrStyle& style);
+                  const GrStrokeInfo&);
 
     /**
      * Draws vertices with a paint.
      *
      * @param   paint           describes how to color pixels.
      * @param   viewMatrix      transformation matrix
      * @param   primitiveType   primitives type to draw.
      * @param   vertexCount     number of vertices.
      * @param   positions       array of vertex positions, required.
      * @param   texCoords       optional array of texture coordinates used
@@ skipping 34 matching lines @@
                    const SkRSXform xform[],
                    const SkRect texRect[],
                    const SkColor colors[]);
     
     /**
      * Draws an oval.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix
      * @param oval          the bounding rect of the oval.
-     * @param style         style to apply to the oval. Currently path effects are not allowed.
+     * @param strokeInfo    the stroke information (width, join, cap) and
+     *                      the dash information (intervals, count, phase).
      */
     void drawOval(const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect& oval,
-                  const GrStyle& style);
+                  const GrStrokeInfo& strokeInfo);
 
     /**
      *  Draw the image stretched differentially to fit into dst.
      *  center is a rect within the image, and logically divides the image
      *  into 9 sections (3x3). For example, if the middle pixel of a [5x5]
      *  image is the "center", then the center-rect should be [2, 2, 3, 3].
      *
      *  If the dst is >= the image size, then...
      *  - The 4 corners are not stretched at all.
      *  - The sides are stretched in only one axis.
@@ skipping 64 matching lines @@
                           const SkRRect& origInner);
 
     GrDrawBatch* getFillRectBatch(const GrPaint& paint,
                                   const SkMatrix& viewMatrix,
                                   const SkRect& rect);
 
     void internalDrawPath(const GrClip& clip,
                           const GrPaint& paint,
                           const SkMatrix& viewMatrix,
                           const SkPath& path,
-                          const GrStyle& style);
+                          const GrStrokeInfo& strokeInfo);
 
     // This entry point allows the GrTextContext-derived classes to add their batches to
     // the drawTarget.
     void drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch);
 
     GrDrawTarget* getDrawTarget();
 
     GrDrawingManager*                 fDrawingManager;
     sk_sp<GrRenderTarget>             fRenderTarget;
 
     // In MDB-mode the drawTarget can be closed by some other drawContext that has picked
     // it up. For this reason, the drawTarget should only ever be accessed via 'getDrawTarget'.
     GrDrawTarget*                     fDrawTarget;
     SkAutoTDelete<GrAtlasTextContext> fAtlasTextContext;
     GrContext*                        fContext;
 
     SkSurfaceProps                    fSurfaceProps;
     GrAuditTrail*                     fAuditTrail;
 
     // In debug builds we guard against improper thread handling
     SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
 };
 
 #endif