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

tests/GLProgramsTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
 #include "SkTypes.h"
@@ skipping 166 matching lines @@
         return nullptr;
     }
 
     // TODO: need a real way to do this via the drawContext
     texture = drawContext->asTexture();
     context->textureProvider()->assignUniqueKeyToTexture(key, texture.get());
 
     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,
                                                           int minLevels, int maxLevels) {
     SkASSERT(1 <= minLevels);
     SkASSERT(minLevels <= maxLevels);
 
     // Return a leaf node if maxLevels is 1 or if we randomly chose to terminate.
     // If returning a leaf node, make sure that it doesn't have children (e.g. another
     // GrComposeEffect)
@@ skipping 28 matching lines @@
                                                                 std::move(otherChild), mode);
         SkASSERT(fp);
     } else {
         fp = GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(otherChild),
                                                                 std::move(minLevelsChild), mode);
         SkASSERT(fp);
     }
     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) {
         // A full tree with 5 levels (31 nodes) may exceed the max allowed length of the gl
         // 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);
 
         for (int s = 0; s < numProcs;) {
             sk_sp<GrFragmentProcessor> fp(GrProcessorTestFactory<GrFragmentProcessor>::Make(d));
             SkASSERT(fp);
 
             // 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);
     }
-    pipelineBuilder->enableState(state);
+    if (random->nextBool()) {
+        paint->setAntiAlias(true);
+    }
+    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,
             GrUserStencilTest::kAlways,
             0xffff,
             GrUserStencilOp::kReplace,
             GrUserStencilOp::kReplace,
             0xffff>()
     );
     static constexpr GrUserStencilSettings kDoesNotWriteStencil(
         GrUserStencilSettings::StaticInit<
             0xffff,
             GrUserStencilTest::kNever,
             0xffff,
             GrUserStencilOp::kKeep,
             GrUserStencilOp::kKeep,
             0xffff>()
     );
 
     if (random->nextBool()) {
-        pipelineBuilder->setUserStencil(&kDoesWriteStencil);
+        return &kDoesWriteStencil;
     } else {
-        pipelineBuilder->setUserStencil(&kDoesNotWriteStencil);
+        return &kDoesNotWriteStencil;
     }
 }
 
 bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
     GrDrawingManager* drawingManager = context->drawingManager();
 
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
@@ skipping 21 matching lines @@
     SkRandom random;
     static const int NUM_TESTS = 1024;
     for (int t = 0; t < NUM_TESTS; t++) {
         // setup random render target(can fail)
         sk_sp<GrDrawContext> drawContext(random_draw_context(context, &random, context->caps()));
         if (!drawContext) {
             SkDebugf("Could not allocate drawContext");
             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();
 
     // Validate that GrFPs work correctly without an input.
     sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kExact,
                                                              kRenderTargetWidth,
                                                              kRenderTargetHeight,
                                                              kRGBA_8888_GrPixelConfig));
     if (!drawContext) {
         SkDebugf("Could not allocate a drawContext");
         return false;
     }
 
     int fpFactoryCnt = GrProcessorTestFactory<GrFragmentProcessor>::Count();
     for (int i = 0; i < fpFactoryCnt; ++i) {
         // Since FP factories internally randomize, call each 10 times.
         for (int j = 0; j < 10; ++j) {
             SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
             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();
         }
     }
 
     return true;
 }
 
 static int get_glprograms_max_stages(GrContext* context) {
     GrGLGpu* gpu = static_cast<GrGLGpu*>(context->getGpu());
     /*
@@ skipping 58 matching lines @@
     GrContextOptions opts;
     opts.fSuppressPrints = true;
     sk_gpu_test::GrContextFactory debugFactory(opts);
     skiatest::RunWithGPUTestContexts(test_glprograms_native, &is_native_gl_context_type,
                                      reporter, &debugFactory);
     skiatest::RunWithGPUTestContexts(test_glprograms_other_contexts,
                                      &is_other_rendering_gl_context_type, reporter, &debugFactory);
 }
 
 #endif