Make AALinearizingConvexPathRenderer able to handle stroke and fill

src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAALinearizingConvexPathRenderer.h"
 
 #include "GrAAConvexTessellator.h"
@@ skipping 32 matching lines @@
     if (!args.fShape->knownToBeConvex()) {
         return false;
     }
     if (args.fShape->style().pathEffect()) {
         return false;
     }
     if (args.fShape->inverseFilled()) {
         return false;
     }
     const SkStrokeRec& stroke = args.fShape->style().strokeRec();
-    if (stroke.getStyle() == SkStrokeRec::kStroke_Style) {
+
+    if (stroke.getStyle() == SkStrokeRec::kStroke_Style ||
+        stroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style) {
         if (!args.fViewMatrix->isSimilarity()) {
             return false;
         }
         SkScalar strokeWidth = args.fViewMatrix->getMaxScale() * stroke.getWidth();
-        return strokeWidth >= 1.0f && strokeWidth <= kMaxStrokeWidth &&
+        if (strokeWidth < 1.0f && stroke.getStyle() == SkStrokeRec::kStroke_Style) {
+            return false;
+        }
+        return strokeWidth <= kMaxStrokeWidth &&
                args.fShape->knownToBeClosed() &&
                stroke.getJoin() != SkPaint::Join::kRound_Join;
     }
     return stroke.getStyle() == SkStrokeRec::kFill_Style;
 }
 
 // extract the result vertices and indices from the GrAAConvexTessellator
 static void extract_verts(const GrAAConvexTessellator& tess,
                           void* vertices,
                           size_t vertexStride,
@@ skipping 50 matching lines @@
 }
 
 class AAFlatteningConvexPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     AAFlatteningConvexPathBatch(GrColor color,
                                 const SkMatrix& viewMatrix,
                                 const SkPath& path,
                                 SkScalar strokeWidth,
+                                SkStrokeRec::Style style,
                                 SkPaint::Join join,
                                 SkScalar miterLimit) : INHERITED(ClassID()) {
-        fGeoData.emplace_back(Geometry{color, viewMatrix, path, strokeWidth, join, miterLimit});
+        fGeoData.emplace_back(Geometry{ color, viewMatrix, path,
+                                        strokeWidth, style, join, miterLimit });
 
         // compute bounds
         SkRect bounds = path.getBounds();
         SkScalar w = strokeWidth;
         if (w > 0) {
             w /= 2;
             // If the half stroke width is < 1 then we effectively fallback to bevel joins.
             if (SkPaint::kMiter_Join == join && w > 1.f) {
                 w *= miterLimit;
             }
@@ skipping 80 matching lines @@
         int instanceCount = fGeoData.count();
 
         int vertexCount = 0;
         int indexCount = 0;
         int maxVertices = DEFAULT_BUFFER_SIZE;
         int maxIndices = DEFAULT_BUFFER_SIZE;
         uint8_t* vertices = (uint8_t*) sk_malloc_throw(maxVertices * vertexStride);
         uint16_t* indices = (uint16_t*) sk_malloc_throw(maxIndices * sizeof(uint16_t));
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& args = fGeoData[i];
-            GrAAConvexTessellator tess(args.fStrokeWidth, args.fJoin, args.fMiterLimit);
+            GrAAConvexTessellator tess(args.fStyle, args.fStrokeWidth,
+                                       args.fJoin, args.fMiterLimit);
 
             if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
                 continue;
             }
 
             int currentIndices = tess.numIndices();
             SkASSERT(currentIndices <= UINT16_MAX);
             if (indexCount + currentIndices > UINT16_MAX) {
                 // if we added the current instance, we would overflow the indices we can store in a
                 // uint16_t. Draw what we've got so far and reset.
@@ skipping 59 matching lines @@
         bool fCoverageIgnored;
         bool fLinesOnly;
         bool fCanTweakAlphaForCoverage;
     };
 
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkPath fPath;
         SkScalar fStrokeWidth;
+        SkStrokeRec::Style fStyle;
         SkPaint::Join fJoin;
         SkScalar fMiterLimit;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
                               "GrAALinearizingConvexPathRenderer::onDrawPath");
     SkASSERT(!args.fDrawContext->isUnifiedMultisampled());
     SkASSERT(!args.fShape->isEmpty());
+    SkASSERT(!args.fShape->style().pathEffect());
 
     SkPath path;
     args.fShape->asPath(&path);
     bool fill = args.fShape->style().isSimpleFill();
     const SkStrokeRec& stroke = args.fShape->style().strokeRec();
     SkScalar strokeWidth = fill ? -1.0f : stroke.getWidth();
     SkPaint::Join join = fill ? SkPaint::Join::kMiter_Join : stroke.getJoin();
     SkScalar miterLimit = stroke.getMiter();
 
     SkAutoTUnref<GrDrawBatch> batch(new AAFlatteningConvexPathBatch(args.fPaint->getColor(),
                                                                     *args.fViewMatrix,
-                                                                    path, strokeWidth, join,
-                                                                    miterLimit));
+                                                                    path, strokeWidth,
+                                                                    stroke.getStyle(),
+                                                                    join, miterLimit));
 
     GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fDrawContext->drawBatch(pipelineBuilder, *args.fClip, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(AAFlatteningConvexPathBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPathConvex(random);
-    SkScalar strokeWidth = random->nextBool() ? -1.f : 2.f;
+
+    SkStrokeRec::Style styles[3] = { SkStrokeRec::kFill_Style,
+                                     SkStrokeRec::kStroke_Style, 
+                                     SkStrokeRec::kStrokeAndFill_Style };
+
+    SkStrokeRec::Style style = styles[random->nextU() % 3];
+
+    SkScalar strokeWidth = -1.f;
     SkPaint::Join join = SkPaint::kMiter_Join;
     SkScalar miterLimit = 0.5f;
-    return new AAFlatteningConvexPathBatch(color, viewMatrix, path, strokeWidth, join, miterLimit);
+
+    if (SkStrokeRec::kFill_Style != style) {
+        strokeWidth = random->nextRangeF(1.0f, 10.0f);
+        if (random->nextBool()) {
+            join = SkPaint::kMiter_Join;
+        } else {
+            join = SkPaint::kBevel_Join;
+        }
+        miterLimit = random->nextRangeF(0.5f, 2.0f);
+    }
+
+    return new AAFlatteningConvexPathBatch(color, viewMatrix, path, strokeWidth, 
+                                           style, join, miterLimit);
 }
 
 #endif