Move GrBatchFlushState from GrDrawTarget to GrDrawingManager

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"
 
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
 #include "GrAutoLocaleSetter.h"
 #include "GrBatchTest.h"
 #include "GrContextFactory.h"
+#include "GrDrawingManager.h"
 #include "GrInvariantOutput.h"
 #include "GrPipeline.h"
 #include "GrResourceProvider.h"
 #include "GrTest.h"
 #include "GrXferProcessor.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
 #include "Test.h"
 
 #include "batches/GrDrawBatch.h"
@@ skipping 265 matching lines @@
                                  0xffff,
                                  0xffff);
 
     if (random->nextBool()) {
         pipelineBuilder->setStencil(kDoesWriteStencil);
     } else {
         pipelineBuilder->setStencil(kDoesNotWriteStencil);
     }
 }
 
-bool GrDrawTarget::programUnitTest(GrContext* context, int maxStages) {
+bool GrDrawingManager::ProgramUnitTest(GrContext* context, GrDrawTarget* drawTarget, int maxStages) {
+
+    GrDrawingManager* drawingManager = context->drawingManager();
+
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
     dummyDesc.fWidth = 34;
     dummyDesc.fHeight = 18;
     SkAutoTUnref<GrTexture> dummyTexture1(
         context->textureProvider()->createTexture(dummyDesc, false, nullptr, 0));
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
@@ skipping 13 matching lines @@
     GrScissorState scissor;
 
     // wide open clip
     GrClip clip;
 
     SkRandom random;
     static const int NUM_TESTS = 2048;
     for (int t = 0; t < NUM_TESTS; t++) {
         // setup random render target(can fail)
         SkAutoTUnref<GrRenderTarget> rt(random_render_target(
-            context->textureProvider(), &random, this->caps()));
+            context->textureProvider(), &random, context->caps()));
         if (!rt.get()) {
             SkDebugf("Could not allocate render target");
             return false;
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setRenderTarget(rt.get());
         pipelineBuilder.setClip(clip);
 
         SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
         SkASSERT(batch);
 
-        GrProcessorTestData ptd(&random, context, fGpu->caps(), dummyTextures);
+        GrProcessorTestData ptd(&random, context, context->caps(), dummyTextures);
         set_random_color_coverage_stages(&pipelineBuilder, &ptd, maxStages);
         set_random_xpf(&pipelineBuilder, &ptd);
         set_random_state(&pipelineBuilder, &random);
         set_random_stencil(&pipelineBuilder, &random);
 
-        this->drawBatch(pipelineBuilder, batch);
+        drawTarget->drawBatch(pipelineBuilder, batch);
     }
     // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
-    this->flush();
+    drawingManager->flush();
 
     // Validate that GrFPs work correctly without an input.
     GrSurfaceDesc rtDesc;
     rtDesc.fWidth = kRenderTargetWidth;
     rtDesc.fHeight = kRenderTargetHeight;
     rtDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     rtDesc.fConfig = kRGBA_8888_GrPixelConfig;
     SkAutoTUnref<GrRenderTarget> rt(
-        fContext->textureProvider()->createTexture(rtDesc, false)->asRenderTarget());
+        context->textureProvider()->createTexture(rtDesc, false)->asRenderTarget());
     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, this->caps(), dummyTextures);
+            GrProcessorTestData ptd(&random, context, context->caps(), dummyTextures);
             GrPipelineBuilder builder;
             builder.setXPFactory(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
             builder.setRenderTarget(rt);
             builder.setClip(clip);
 
             SkAutoTUnref<const GrFragmentProcessor> fp(
                 GrProcessorTestFactory<GrFragmentProcessor>::CreateIdx(i, &ptd));
             SkAutoTUnref<const GrFragmentProcessor> blockFP(
                 BlockInputFragmentProcessor::Create(fp));
             builder.addColorFragmentProcessor(blockFP);
 
-            this->drawBatch(builder, batch);
-            this->flush();
+            drawTarget->drawBatch(builder, batch);
+            drawingManager->flush();
         }
     }
 
     return true;
 }
 
 DEF_GPUTEST(GLPrograms, reporter, factory) {
     // Set a locale that would cause shader compilation to fail because of , as decimal separator.
     // skbug 3330
 #ifdef SK_BUILD_FOR_WIN
@@ skipping 32 matching lines @@
                 maxStages = 2;
             }
 #endif
 #if SK_COMMAND_BUFFER
             // Some long shaders run out of temporary registers in the D3D compiler on ANGLE.
             // TODO(hendrikw): This only needs to happen with the ANGLE comand buffer backend.
             if (type == GrContextFactory::kCommandBuffer_GLContextType) {
                 maxStages = 2;
             }
 #endif
-            GrTestTarget target;
-            context->getTestTarget(&target);
-            REPORTER_ASSERT(reporter, target.target()->programUnitTest(context, maxStages));
+            GrTestTarget testTarget;
+            context->getTestTarget(&testTarget);
+            REPORTER_ASSERT(reporter, GrDrawingManager::ProgramUnitTest(
+                                            context, testTarget.target(), maxStages));
         }
     }
 }
 
 #endif