Make AALinearizingConvexPathRenderer able to handle stroke and fill

src/gpu/batches/GrAAConvexTessellator.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 GrAAConvexTessellator_DEFINED
 #define GrAAConvexTessellator_DEFINED
 
 #include "SkColor.h"
 #include "SkPaint.h"
 #include "SkPoint.h"
 #include "SkScalar.h"
+#include "SkStrokeRec.h"
 #include "SkTDArray.h"
 
 class SkCanvas;
 class SkMatrix;
 class SkPath;
 
 //#define GR_AA_CONVEX_TESSELLATOR_VIZ 1
 
 // device space distance which we inset / outset points in order to create the soft antialiased edge
 static const SkScalar kAntialiasingRadius = 0.5f;
 
 class GrAAConvexTessellator;
 
 // The AAConvexTessellator holds the global pool of points and the triangulation
 // that connects them. It also drives the tessellation process.
 // The outward facing normals of the original polygon are stored (in 'fNorms') to service
 // computeDepthFromEdge requests.
 class GrAAConvexTessellator {
 public:
-    GrAAConvexTessellator(SkScalar strokeWidth = -1.0f,
+    GrAAConvexTessellator(SkStrokeRec::Style style = SkStrokeRec::kFill_Style,
+                          SkScalar strokeWidth = -1.0f,
                           SkPaint::Join join = SkPaint::Join::kBevel_Join,
                           SkScalar miterLimit = 0.0f)
         : fSide(SkPoint::kOn_Side)
         , fStrokeWidth(strokeWidth)
+        , fStyle(style)
         , fJoin(join)
         , fMiterLimit(miterLimit) {
     }
 
     SkPoint::Side side() const { return fSide; }
 
     bool tessellate(const SkMatrix& m, const SkPath& path);
 
     // The next five should only be called after tessellate to extract the result
     int numPts() const { return fPts.count(); }
@@ skipping 80 matching lines @@
         void rewind() { fPts.rewind(); }
 
         int numPts() const { return fPts.count(); }
 
         void addIdx(int index, int origEdgeId) {
             struct PointData* pt = fPts.push();
             pt->fIndex = index;
             pt->fOrigEdgeId = origEdgeId;
         }
 
+        // Upgrade this ring so that it can behave like an originating ring
+        void makeOriginalRing() {
+            for (int i = 0; i < fPts.count(); ++i) {
+                fPts[i].fOrigEdgeId = fPts[i].fIndex;
+            }            
+        }
+
         // init should be called after all the indices have been added (via addIdx)
         void init(const GrAAConvexTessellator& tess);
         void init(const SkTDArray<SkVector>& norms, const SkTDArray<SkVector>& bisectors);
 
         const SkPoint& norm(int index) const { return fPts[index].fNorm; }
         const SkPoint& bisector(int index) const { return fPts[index].fBisector; }
         int index(int index) const { return fPts[index].fIndex; }
         int origEdgeID(int index) const { return fPts[index].fOrigEdgeId; }
         void setOrigEdgeId(int index, int id) { fPts[index].fOrigEdgeId = id; }
 
@@ skipping 111 matching lines @@
 
     Ring                  fInitialRing;
 #if GR_AA_CONVEX_TESSELLATOR_VIZ
     // When visualizing save all the rings
     SkTDArray<Ring*>      fRings;
 #else
     Ring                  fRings[2];
 #endif
     CandidateVerts        fCandidateVerts;
 
-    // < 0 means filling rather than stroking
+    // the stroke width is only used for stroke or stroke-and-fill styles
     SkScalar              fStrokeWidth;
+    SkStrokeRec::Style    fStyle;
 
     SkPaint::Join         fJoin;
 
     SkScalar              fMiterLimit;
 
     SkTDArray<SkPoint>    fPointBuffer;
 };
 
 
 #endif