Hide GrPipelineBuilder from GrOvalRenderer

Limiting the reach of GrPipelineBuilder is always good.

GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1726223008

Review URL: https://codereview.chromium.org/1726223008

3 files changed, 47 insertions, 69 deletions

diff --git a/src/gpu/GrDrawContext.cpp b/src/gpu/GrDrawContext.cpp
index 03ccd4a326..b5c28190f2 100644
--- a/src/gpu/GrDrawContext.cpp
+++ b/src/gpu/GrDrawContext.cpp
@@ -494,23 +494,25 @@ void GrDrawContext::drawRRect(const GrClip& clip,
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
-    GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-    SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(pipelineBuilder,
-                                                                     color,
-                                                                     viewMatrix,
-                                                                     paint.isAntiAlias(),
-                                                                     rrect,
-                                                                     strokeInfo,
-                                                                     shaderCaps));
-    if (batch) {
-        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
-    } else {
-        SkPath path;
-        path.setIsVolatile(true);
-        path.addRRect(rrect);
-        this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
-                               paint.isAntiAlias(), path, strokeInfo);
+    if (should_apply_coverage_aa(paint, fRenderTarget)) {
+        GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+
+        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(color,
+                                                                         viewMatrix,
+                                                                         rrect,
+                                                                         strokeInfo,
+                                                                         shaderCaps));
+        if (batch) {
+            this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
+            return;
+        }
     }
+
+    SkPath path;
+    path.setIsVolatile(true);
+    path.addRRect(rrect);
+    this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -535,24 +537,25 @@ void GrDrawContext::drawOval(const GrClip& clip,
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
-
-    GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-    SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(pipelineBuilder,
-                                                                    color,
-                                                                    viewMatrix,
-                                                                    paint.isAntiAlias(),
-                                                                    oval,
-                                                                    strokeInfo,
-                                                                    shaderCaps));
-    if (batch) {
-        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
-    } else {
-        SkPath path;
-        path.setIsVolatile(true);
-        path.addOval(oval);
-        this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
-                               paint.isAntiAlias(), path, strokeInfo);
+    
+    if (should_apply_coverage_aa(paint, fRenderTarget)) {
+        GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
+        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(color,
+                                                                        viewMatrix,
+                                                                        oval,
+                                                                        strokeInfo,
+                                                                        shaderCaps));
+        if (batch) {
+            this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
+            return;
+        }
     }
+
+    SkPath path;
+    path.setIsVolatile(true);
+    path.addOval(oval);
+    this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
 void GrDrawContext::drawImageNine(const GrClip& clip,
@@ -680,10 +683,8 @@ void GrDrawContext::drawPath(const GrClip& clip,
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    if (!strokeInfo.isDashed()) {
-        bool useCoverageAA = should_apply_coverage_aa(paint, pipelineBuilder.getRenderTarget());
-
-        if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
+    if (should_apply_coverage_aa(paint, fRenderTarget) && !strokeInfo.isDashed()) {
+        if (strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
@@ -699,10 +700,8 @@ void GrDrawContext::drawPath(const GrClip& clip,
 
         if (isOval && !path.isInverseFillType()) {
             GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-            SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(pipelineBuilder,
-                                                                            color,
+            SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(color,
                                                                             viewMatrix,
-                                                                            paint.isAntiAlias(),
                                                                             ovalRect,
                                                                             strokeInfo,
                                                                             shaderCaps));
diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp
index 1c41f27b07..1fb214a260 100644
--- a/src/gpu/GrOvalRenderer.cpp
+++ b/src/gpu/GrOvalRenderer.cpp
@@ -11,7 +11,6 @@
 #include "GrBatchTest.h"
 #include "GrGeometryProcessor.h"
 #include "GrInvariantOutput.h"
-#include "GrPipelineBuilder.h"
 #include "GrProcessor.h"
 #include "GrResourceProvider.h"
 #include "SkRRect.h"
@@ -580,18 +579,11 @@ const GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(GrProcessorTestData*
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrDrawBatch* GrOvalRenderer::CreateOvalBatch(const GrPipelineBuilder& pipelineBuilder,
-                                             GrColor color,
+GrDrawBatch* GrOvalRenderer::CreateOvalBatch(GrColor color,
                                              const SkMatrix& viewMatrix,
-                                             bool useAA,
                                              const SkRect& oval,
                                              const SkStrokeRec& stroke,
                                              GrShaderCaps* shaderCaps) {
-    bool useCoverageAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
-    if (!useCoverageAA) {
-        return nullptr;
-    }
-
     // we can draw circles
     if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) {
         return CreateCircleBatch(color, viewMatrix, oval, stroke);
@@ -1890,23 +1882,13 @@ static GrDrawBatch* create_rrect_batch(GrColor color,
     }
 }
 
-GrDrawBatch* GrOvalRenderer::CreateRRectBatch(const GrPipelineBuilder& pipelineBuilder,
-                                              GrColor color,
+GrDrawBatch* GrOvalRenderer::CreateRRectBatch(GrColor color,
                                               const SkMatrix& viewMatrix,
-                                              bool useAA,
                                               const SkRRect& rrect,
                                               const SkStrokeRec& stroke,
                                               GrShaderCaps* shaderCaps) {
-    bool useCoverageAA = useAA && !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
-
-    // only anti-aliased rrects for now
-    if (!useCoverageAA) {
-        return nullptr;
-    }
-
     if (rrect.isOval()) {
-        return CreateOvalBatch(pipelineBuilder, color, viewMatrix, useAA,
-                               rrect.getBounds(), stroke, shaderCaps);
+        return CreateOvalBatch(color, viewMatrix, rrect.getBounds(), stroke, shaderCaps);
     }
 
     if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
diff --git a/src/gpu/GrOvalRenderer.h b/src/gpu/GrOvalRenderer.h
index d34398006f..2b5272004a 100644
--- a/src/gpu/GrOvalRenderer.h
+++ b/src/gpu/GrOvalRenderer.h
@@ -8,12 +8,13 @@
 #ifndef GrOvalRenderer_DEFINED
 #define GrOvalRenderer_DEFINED
 
-#include "GrPaint.h"
+#include "GrColor.h"
 
 class GrDrawBatch;
-class GrPipelineBuilder;
 class GrShaderCaps;
+class SkMatrix;
 struct SkRect;
+class SkRRect;
 class SkStrokeRec;
 
 /*
@@ -21,17 +22,13 @@ class SkStrokeRec;
  */
 class GrOvalRenderer {
 public:
-    static GrDrawBatch* CreateOvalBatch(const GrPipelineBuilder&,
-                                        GrColor,
+    static GrDrawBatch* CreateOvalBatch(GrColor,
                                         const SkMatrix& viewMatrix,
-                                        bool useAA,
                                         const SkRect& oval,
                                         const SkStrokeRec& stroke,
                                         GrShaderCaps* shaderCaps);
-    static GrDrawBatch* CreateRRectBatch(const GrPipelineBuilder&,
-                                         GrColor,
+    static GrDrawBatch* CreateRRectBatch(GrColor,
                                          const SkMatrix& viewMatrix,
-                                         bool useAA,
                                          const SkRRect& rrect,
                                          const SkStrokeRec& stroke,
                                          GrShaderCaps* shaderCaps);