Move GrPipelineBuilder out of gms & reduce use of GrPipelineBuilder.h

Just another step in reining in the GrPLB

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2086293006

Review-Url: https://codereview.chromium.org/2086293006

diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index ae1c37f..0c568d0 100644 (file)
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -188,14 +188,13 @@ protected:
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
-                    GrPipelineBuilder pipelineBuilder;
-                    pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    GrPaint grPaint;
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
 
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                 }
                 ++col;
                 if (numCols == col) {
@@ -320,14 +319,13 @@ protected:
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
-                    GrPipelineBuilder pipelineBuilder;
-                    pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    GrPaint grPaint;
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
 
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                 }
                 ++col;
                 if (numCols == col) {
@@ -527,16 +525,15 @@ protected:
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
-                    GrPipelineBuilder pipelineBuilder;
-                    pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    GrPaint grPaint;
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                     GrPathUtils::QuadUVMatrix DevToUV(pts);
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierQuadTestBatch(gp, bounds, color, DevToUV));
 
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                 }
                 ++col;
                 if (numCols == col) {

diff --git a/gm/bigrrectaaeffect.cpp b/gm/bigrrectaaeffect.cpp
index 924704a..7f79a34 100644 (file)
--- a/gm/bigrrectaaeffect.cpp
+++ b/gm/bigrrectaaeffect.cpp
@@ -9,7 +9,6 @@
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrDrawContextPriv.h"
-#include "GrPipelineBuilder.h"
 #include "SkRRect.h"
 #include "batches/GrDrawBatch.h"
 #include "batches/GrRectBatchFactory.h"
@@ -74,15 +73,15 @@ protected:
                 paint.setColor(SK_ColorWHITE);
                 canvas->drawRect(testBounds, paint);
 
-                GrPipelineBuilder pipelineBuilder;
-                pipelineBuilder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                GrPaint grPaint;
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                 SkRRect rrect = fRRect;
                 rrect.offset(SkIntToScalar(x + kGap), SkIntToScalar(y + kGap));
                 sk_sp<GrFragmentProcessor> fp(GrRRectEffect::Make(edgeType, rrect));
                 SkASSERT(fp);
                 if (fp) {
-                    pipelineBuilder.addCoverageFragmentProcessor(std::move(fp));
+                    grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                     SkRect bounds = testBounds;
                     bounds.offset(SkIntToScalar(x), SkIntToScalar(y));
@@ -90,7 +89,7 @@ protected:
                     SkAutoTUnref<GrDrawBatch> batch(
                             GrRectBatchFactory::CreateNonAAFill(0xff000000, SkMatrix::I(), bounds,
                                                                 nullptr, nullptr));
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                 }
             canvas->restore();
             x = x + fTestOffsetX;

diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp
index 8ae93a4..32d03a0 100644 (file)
--- a/gm/constcolorprocessor.cpp
+++ b/gm/constcolorprocessor.cpp
@@ -13,7 +13,6 @@
 
 #include "GrContext.h"
 #include "GrDrawContextPriv.h"
-#include "GrPipelineBuilder.h"
 #include "SkGrPriv.h"
 #include "SkGradientShader.h"
 #include "batches/GrDrawBatch.h"
@@ -107,13 +106,12 @@ protected:
                     GrColor color = kColors[procColor];
                     sk_sp<GrFragmentProcessor> fp(GrConstColorProcessor::Make(color, mode));
 
-                    GrPipelineBuilder pipelineBuilder(grPaint, drawContext->mustUseHWAA(grPaint));
-                    pipelineBuilder.addColorFragmentProcessor(std::move(fp));
+                    grPaint.addColorFragmentProcessor(std::move(fp));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                             GrRectBatchFactory::CreateNonAAFill(grPaint.getColor(), viewMatrix,
                                                                 renderRect, nullptr, nullptr));
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
 
                     // Draw labels for the input to the processor and the processor to the right of
                     // the test rect. The input label appears above the processor label.

diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index 3f8ae09..a5c2904 100644 (file)
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -178,13 +178,13 @@ protected:
                     continue;
                 }
 
-                GrPipelineBuilder pipelineBuilder;
-                pipelineBuilder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
-                pipelineBuilder.addCoverageFragmentProcessor(std::move(fp));
+                GrPaint grPaint;
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                 SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(p.getBounds(), 0xff000000));
 
-                drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
 
                 x += SkScalarCeilToScalar(path->getBounds().width() + kDX);
             }
@@ -217,13 +217,13 @@ protected:
                     continue;
                 }
 
-                GrPipelineBuilder pipelineBuilder;
-                pipelineBuilder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
-                pipelineBuilder.addCoverageFragmentProcessor(std::move(fp));
+                GrPaint grPaint;
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                 SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(rect, 0xff000000));
 
-                drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
 
                 x += SkScalarCeilToScalar(rect.width() + kDX);
             }

diff --git a/gm/dcshader.cpp b/gm/dcshader.cpp
index 2b179a0..3ed6dc1 100644 (file)
--- a/gm/dcshader.cpp
+++ b/gm/dcshader.cpp
@@ -9,6 +9,7 @@
 #if SK_SUPPORT_GPU
 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
+#include "GrInvariantOutput.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"

diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index e104aea..0f3ac56 100644 (file)
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -101,16 +101,15 @@ protected:
                     canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
                     if (kEffect_Type == fType) {
 #if SK_SUPPORT_GPU
-                        GrPipelineBuilder pipelineBuilder;
-                        pipelineBuilder.setXPFactory(
-                            GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                        GrPaint grPaint;
+                        grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
                         SkRRect rrect = fRRects[curRRect];
                         rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
                         GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et;
                         sk_sp<GrFragmentProcessor> fp(GrRRectEffect::Make(edgeType, rrect));
                         if (fp) {
-                            pipelineBuilder.addCoverageFragmentProcessor(std::move(fp));
+                            grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                             SkRect bounds = rrect.getBounds();
                             bounds.outset(2.f, 2.f);
@@ -118,8 +117,7 @@ protected:
                             SkAutoTUnref<GrDrawBatch> batch(
                                     GrRectBatchFactory::CreateNonAAFill(0xff000000, SkMatrix::I(),
                                                                         bounds, nullptr, nullptr));
-                            drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder,
-                                                                                 batch);
+                            drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                         } else {
                             drew = false;
                         }

diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp
index cac2b9c..3680006 100644 (file)
--- a/gm/texturedomaineffect.cpp
+++ b/gm/texturedomaineffect.cpp
@@ -112,9 +112,8 @@ protected:
                 SkScalar x = kDrawPad + kTestPad;
                 for (int m = 0; m < GrTextureDomain::kModeCount; ++m) {
                     GrTextureDomain::Mode mode = (GrTextureDomain::Mode) m;
-                    GrPipelineBuilder pipelineBuilder;
-                    pipelineBuilder.setXPFactory(
-                        GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    GrPaint grPaint;
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
                     sk_sp<GrFragmentProcessor> fp(
                         GrTextureDomainEffect::Make(texture, textureMatrices[tm],
                                                 GrTextureDomain::MakeTexelDomain(texture,
@@ -125,12 +124,12 @@ protected:
                         continue;
                     }
                     const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y);
-                    pipelineBuilder.addColorFragmentProcessor(std::move(fp));
+                    grPaint.addColorFragmentProcessor(std::move(fp));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                             GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix,
                                                                 renderRect, nullptr, nullptr));
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                     x += renderRect.width() + kTestPad;
                 }
                 y += renderRect.height() + kTestPad;

diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp
index a153c99..0be3008 100644 (file)
--- a/gm/yuvtorgbeffect.cpp
+++ b/gm/yuvtorgbeffect.cpp
@@ -13,7 +13,6 @@
 
 #include "GrContext.h"
 #include "GrDrawContextPriv.h"
-#include "GrPipelineBuilder.h"
 #include "SkBitmap.h"
 #include "SkGr.h"
 #include "SkGradientShader.h"
@@ -113,19 +112,19 @@ protected:
                                        {1, 2, 0}, {2, 0, 1}, {2, 1, 0}};
 
             for (int i = 0; i < 6; ++i) {
-                GrPipelineBuilder pipelineBuilder;
-                pipelineBuilder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                GrPaint grPaint;
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
                 sk_sp<GrFragmentProcessor> fp(GrYUVEffect::MakeYUVToRGB(
                     texture[indices[i][0]], texture[indices[i][1]], texture[indices[i][2]], sizes,
                     static_cast<SkYUVColorSpace>(space), false));
                 if (fp) {
                     SkMatrix viewMatrix;
                     viewMatrix.setTranslate(x, y);
-                    pipelineBuilder.addColorFragmentProcessor(std::move(fp));
+                    grPaint.addColorFragmentProcessor(std::move(fp));
                     SkAutoTUnref<GrDrawBatch> batch(
                             GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix,
                                                                 renderRect, nullptr, nullptr));
-                    drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
                 }
                 x += renderRect.width() + kTestPad;
             }
@@ -225,18 +224,18 @@ protected:
             SkScalar y = kDrawPad + kTestPad + space * kColorSpaceOffset;
             SkScalar x = kDrawPad + kTestPad;
 
-            GrPipelineBuilder pipelineBuilder;
-            pipelineBuilder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+            GrPaint grPaint;
+            grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
             sk_sp<GrFragmentProcessor> fp(
                 GrYUVEffect::MakeYUVToRGB(texture[0], texture[1], texture[2], sizes,
                                           static_cast<SkYUVColorSpace>(space), true));
             if (fp) {
                 SkMatrix viewMatrix;
                 viewMatrix.setTranslate(x, y);
-                pipelineBuilder.addColorFragmentProcessor(fp);
+                grPaint.addColorFragmentProcessor(fp);
                 SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(
                     GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr));
-                drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+                drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
             }
         }
     }

diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h
index 0c71f7c..948ae62 100644 (file)
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipMaskManager.h
@@ -7,20 +7,24 @@
 #ifndef GrClipMaskManager_DEFINED
 #define GrClipMaskManager_DEFINED
 
-#include "GrPipelineBuilder.h"
 #include "GrReducedClip.h"
 #include "SkClipStack.h"
 #include "SkTypes.h"
 
 class GrAppliedClip;
 class GrClipStackClip;
+class GrContext;
 class GrDrawContext;
 class GrFixedClip;
 class GrPathRenderer;
 class GrPathRendererChain;
+class GrPipelineBuilder;
 class GrResourceProvider;
 class GrTexture;
 class GrTextureProvider;
+class GrUniqueKey;
+struct GrUserStencilSettings;
+
 
 /**
  * The clip mask creator handles the generation of the clip mask. If anti

diff --git a/src/gpu/GrDrawContextPriv.h b/src/gpu/GrDrawContextPriv.h
index 0641e9f..8087bcf 100644 (file)
--- a/src/gpu/GrDrawContextPriv.h
+++ b/src/gpu/GrDrawContextPriv.h
@@ -50,9 +50,10 @@ public:
                             const SkMatrix& viewMatrix,
                             const SkPath&);
 
-    void testingOnly_drawBatch(const GrPipelineBuilder& pipelineBuilder,
+    void testingOnly_drawBatch(const GrPaint&,
                                GrDrawBatch* batch,
-                               const GrClip* = nullptr);
+                               const GrUserStencilSettings* = nullptr,
+                               bool snapToCenters = false);
 
 private:
     explicit GrDrawContextPriv(GrDrawContext* drawContext) : fDrawContext(drawContext) {}

diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrDrawTarget.h
index d43a930..64c8a33 100644 (file)
--- a/src/gpu/GrDrawTarget.h
+++ b/src/gpu/GrDrawTarget.h
@@ -13,7 +13,6 @@
 #include "GrPathProcessor.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrPathRendering.h"
-#include "GrPipelineBuilder.h"
 #include "GrXferProcessor.h"
 
 #include "batches/GrDrawBatch.h"
@@ -36,6 +35,7 @@ class GrClip;
 class GrCaps;
 class GrPath;
 class GrDrawPathBatchBase;
+class GrPipelineBuilder;
 
 class GrDrawTarget final : public SkRefCnt {
 public:

diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index f8528a1..5164b71 100644 (file)
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -9,7 +9,6 @@
 #define GrGpu_DEFINED
 
 #include "GrGpuCommandBuffer.h"
-#include "GrPipelineBuilder.h"
 #include "GrProgramDesc.h"
 #include "GrSwizzle.h"
 #include "GrAllocator.h"
@@ -22,6 +21,7 @@
 class GrBatchTracker;
 class GrBuffer;
 class GrContext;
+struct GrContextOptions;
 class GrGLContext;
 class GrMesh;
 class GrNonInstancedVertices;

diff --git a/src/gpu/GrGpuCommandBuffer.cpp b/src/gpu/GrGpuCommandBuffer.cpp
index f79cb0f..af0993e 100644 (file)
--- a/src/gpu/GrGpuCommandBuffer.cpp
+++ b/src/gpu/GrGpuCommandBuffer.cpp
@@ -7,6 +7,7 @@
 
 #include "GrGpuCommandBuffer.h"
 
+#include "GrCaps.h"
 #include "GrGpu.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrRenderTarget.h"

diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index 3fd70a3..a17eb09 100644 (file)
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -13,7 +13,9 @@
 #include "GrGpu.h"
 #include "GrNonAtomicRef.h"
 #include "GrPendingProgramElement.h"
+#include "GrPipelineBuilder.h"
 #include "GrPrimitiveProcessor.h"
+#include "GrProcOptInfo.h"
 #include "GrProgramDesc.h"
 #include "GrStencilSettings.h"
 #include "GrTypesPriv.h"

diff --git a/src/gpu/GrResourceCache.cpp b/src/gpu/GrResourceCache.cpp
index db97e35..71e40f1 100644 (file)
--- a/src/gpu/GrResourceCache.cpp
+++ b/src/gpu/GrResourceCache.cpp
@@ -7,6 +7,8 @@
 
 
 #include "GrResourceCache.h"
+
+#include "GrCaps.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrTracing.h"
 #include "SkChecksum.h"

diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index fac4e62..107c77e 100644 (file)
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -10,7 +10,6 @@
 
 #include "SkAutoPixmapStorage.h"
 #include "GrColor.h"
-#include "GrPipelineBuilder.h"
 #include "SkBitmap.h"
 #include "SkDraw.h"
 #include "SkMatrix.h"
@@ -19,10 +18,13 @@
 #include "SkTypes.h"
 
 class GrClip;
+class GrPaint;
 class GrTextureProvider;
+class GrStyle;
 class GrTexture;
 class SkPath;
 class SkStrokeRec;
+struct GrUserStencilSettings;
 
 /**
  * The GrSWMaskHelper helps generate clip masks using the software rendering

diff --git a/src/gpu/GrTextureParamsAdjuster.cpp b/src/gpu/GrTextureParamsAdjuster.cpp
index 1657fb9..7774391 100644 (file)
--- a/src/gpu/GrTextureParamsAdjuster.cpp
+++ b/src/gpu/GrTextureParamsAdjuster.cpp
@@ -20,6 +20,7 @@
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #include "effects/GrBicubicEffect.h"
+#include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef GrTextureProducer::CopyParams CopyParams;

diff --git a/src/gpu/GrTextureProvider.cpp b/src/gpu/GrTextureProvider.cpp
index 69792ed..00494da 100644 (file)
--- a/src/gpu/GrTextureProvider.cpp
+++ b/src/gpu/GrTextureProvider.cpp
@@ -6,6 +6,8 @@
  */
 
 #include "GrTextureProvider.h"
+
+#include "GrCaps.h"
 #include "GrTexturePriv.h"
 #include "GrResourceCache.h"
 #include "GrGpu.h"

diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index 910b873..76e0ba0 100644 (file)
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -7,7 +7,6 @@
 
 #include "GrXferProcessor.h"
 #include "GrPipeline.h"
-#include "GrPipelineBuilder.h"
 #include "GrProcOptInfo.h"
 #include "gl/GrGLCaps.h"
 

diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
index c175fc6..27c8437 100644 (file)
--- a/src/gpu/glsl/GrGLSLProgramBuilder.h
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -10,6 +10,7 @@
 
 #include "GrGeometryProcessor.h"
 #include "GrGpu.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryShaderBuilder.h"
 #include "glsl/GrGLSLPrimitiveProcessor.h"

diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 7ce71c6..171ed61 100644 (file)
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -184,10 +184,10 @@ static sk_sp<GrDrawContext> random_draw_context(GrContext* context,
     return drawContext;
 }
 
-static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
+static void set_random_xpf(GrPaint* paint, GrProcessorTestData* d) {
     sk_sp<GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::Make(d));
     SkASSERT(xpf);
-    pipelineBuilder->setXPFactory(std::move(xpf));
+    paint->setXPFactory(std::move(xpf));
 }
 
 static sk_sp<GrFragmentProcessor> create_random_proc_tree(GrProcessorTestData* d,
@@ -236,8 +236,9 @@ static sk_sp<GrFragmentProcessor> create_random_proc_tree(GrProcessorTestData* d
     return fp;
 }
 
-static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
-                                             GrProcessorTestData* d, int maxStages) {
+static void set_random_color_coverage_stages(GrPaint* paint,
+                                             GrProcessorTestData* d,
+                                             int maxStages) {
     // Randomly choose to either create a linear pipeline of procs or create one proc tree
     const float procTreeProbability = 0.5f;
     if (d->fRandom->nextF() < procTreeProbability) {
@@ -245,7 +246,7 @@ static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
         // processor key; maxTreeLevels should be a number from 1 to 4 inclusive.
         const int maxTreeLevels = 4;
         sk_sp<GrFragmentProcessor> fp(create_random_proc_tree(d, 2, maxTreeLevels));
-        pipelineBuilder->addColorFragmentProcessor(std::move(fp));
+        paint->addColorFragmentProcessor(std::move(fp));
     } else {
         int numProcs = d->fRandom->nextULessThan(maxStages + 1);
         int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
@@ -256,32 +257,30 @@ static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
 
             // finally add the stage to the correct pipeline in the drawstate
             if (s < numColorProcs) {
-                pipelineBuilder->addColorFragmentProcessor(std::move(fp));
+                paint->addColorFragmentProcessor(std::move(fp));
             } else {
-                pipelineBuilder->addCoverageFragmentProcessor(std::move(fp));
+                paint->addCoverageFragmentProcessor(std::move(fp));
             }
             ++s;
         }
     }
 }
 
-static void set_random_state(GrPipelineBuilder* pipelineBuilder,
-                             GrDrawContext* drawContext,
-                             SkRandom* random) {
-    int state = 0;
-    for (int i = 1; i <= GrPipelineBuilder::kLast_Flag; i <<= 1) {
-        state |= random->nextBool() * i;
+static bool set_random_state(GrPaint* paint, SkRandom* random) {
+    if (random->nextBool()) {
+        paint->setDisableOutputConversionToSRGB(true);
     }
-
-    // If we don't have an MSAA rendertarget then we have to disable useHWAA
-    if ((state | GrPipelineBuilder::kHWAntialias_Flag) && !drawContext->isUnifiedMultisampled()) {
-        state &= ~GrPipelineBuilder::kHWAntialias_Flag;
+    if (random->nextBool()) {
+        paint->setAllowSRGBInputs(true);
+    }
+    if (random->nextBool()) {
+        paint->setAntiAlias(true);
     }
-    pipelineBuilder->enableState(state);
+    return random->nextBool();
 }
 
 // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
-static void set_random_stencil(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
+static const GrUserStencilSettings* get_random_stencil(SkRandom* random) {
     static constexpr GrUserStencilSettings kDoesWriteStencil(
         GrUserStencilSettings::StaticInit<
             0xffff,
@@ -302,9 +301,9 @@ static void set_random_stencil(GrPipelineBuilder* pipelineBuilder, SkRandom* ran
     );
 
     if (random->nextBool()) {
-        pipelineBuilder->setUserStencil(&kDoesWriteStencil);
+        return &kDoesWriteStencil;
     } else {
-        pipelineBuilder->setUserStencil(&kDoesNotWriteStencil);
+        return &kDoesNotWriteStencil;
     }
 }
 
@@ -346,19 +345,19 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
             return false;
         }
 
-        GrPipelineBuilder pipelineBuilder;
+        GrPaint grPaint;
 
         SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
         SkASSERT(batch);
 
         GrProcessorTestData ptd(&random, context, context->caps(),
                                 drawContext.get(), dummyTextures);
-        set_random_color_coverage_stages(&pipelineBuilder, &ptd, maxStages);
-        set_random_xpf(&pipelineBuilder, &ptd);
-        set_random_state(&pipelineBuilder, drawContext.get(), &random);
-        set_random_stencil(&pipelineBuilder, &random);
+        set_random_color_coverage_stages(&grPaint, &ptd, maxStages);
+        set_random_xpf(&grPaint, &ptd);
+        bool snapToCenters = set_random_state(&grPaint, &random);
+        const GrUserStencilSettings* uss = get_random_stencil(&random);
 
-        drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
+        drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch, uss, snapToCenters);
     }
     // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
     drawingManager->flush();
@@ -381,16 +380,16 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
             SkASSERT(batch);
             GrProcessorTestData ptd(&random, context, context->caps(),
                                     drawContext.get(), dummyTextures);
-            GrPipelineBuilder builder;
-            builder.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+            GrPaint grPaint;
+            grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
 
             sk_sp<GrFragmentProcessor> fp(
                 GrProcessorTestFactory<GrFragmentProcessor>::MakeIdx(i, &ptd));
             sk_sp<GrFragmentProcessor> blockFP(
                 BlockInputFragmentProcessor::Make(std::move(fp)));
-            builder.addColorFragmentProcessor(std::move(blockFP));
+            grPaint.addColorFragmentProcessor(std::move(blockFP));
 
-            drawContext->drawContextPriv().testingOnly_drawBatch(builder, batch);
+            drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
             drawingManager->flush();
         }
     }

diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp
index 5ef4994..6d5be09 100644 (file)
--- a/tests/PrimitiveProcessorTest.cpp
+++ b/tests/PrimitiveProcessorTest.cpp
@@ -122,10 +122,10 @@ DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
     REPORTER_ASSERT(reporter, context->getGpu()->stats()->numFailedDraws() == 0);
 #endif
     SkAutoTUnref<GrDrawBatch> batch;
-    GrPipelineBuilder pb;
+    GrPaint grPaint;
     // This one should succeed.
     batch.reset(new Batch(attribCnt));
-    drawContext->drawContextPriv().testingOnly_drawBatch(pb, batch);
+    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
     context->flush();
 #if GR_GPU_STATS
     REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 1);
@@ -134,7 +134,7 @@ DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
     context->resetGpuStats();
     // This one should fail.
     batch.reset(new Batch(attribCnt+1));
-    drawContext->drawContextPriv().testingOnly_drawBatch(pb, batch);
+    drawContext->drawContextPriv().testingOnly_drawBatch(grPaint, batch);
     context->flush();
 #if GR_GPU_STATS
     REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 0);

diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index dca47ba..6a637ef 100644 (file)
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -234,19 +234,24 @@ void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newT
     SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fDrawContext->fSingleOwner);)
 #define RETURN_IF_ABANDONED        if (fDrawContext->fDrawingManager->wasAbandoned()) { return; }
 
-void GrDrawContextPriv::testingOnly_drawBatch(const GrPipelineBuilder& pipelineBuilder,
+void GrDrawContextPriv::testingOnly_drawBatch(const GrPaint& paint,
                                               GrDrawBatch* batch,
-                                              const GrClip* clip) {
+                                              const GrUserStencilSettings* uss,
+                                              bool snapToCenters) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::testingOnly_drawBatch");
 
-    if (clip) {
-        fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, *clip, batch);
-    } else {
-        fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, GrNoClip(), batch);
+    GrPipelineBuilder pipelineBuilder(paint, fDrawContext->mustUseHWAA(paint));
+    if (uss) {
+        pipelineBuilder.setUserStencil(uss);
     }
+    if (snapToCenters) {
+        pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag, true);
+    }
+
+    fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, GrNoClip(), batch);
 }
 
 #undef ASSERT_SINGLE_OWNER