fix up test create functions

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
 
@@ skipping 75 matching lines @@
     bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override { }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
 
-GrFragmentProcessor* BigKeyProcessor::TestCreate(SkRandom*,
-                                                 GrContext*,
-                                                 const GrCaps&,
-                                                 GrTexture*[]) {
+GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
     return BigKeyProcessor::Create();
 }
 
 /*
  * Begin test code
  */
 static const int kRenderTargetHeight = 1;
 static const int kRenderTargetWidth = 1;
 
 static GrRenderTarget* random_render_target(GrTextureProvider* textureProvider, SkRandom* random,
@@ skipping 19 matching lines @@
     GrTexture* texture = textureProvider->findAndRefTextureByUniqueKey(key);
     if (!texture) {
         texture = textureProvider->createTexture(texDesc, true);
         if (texture) {
             textureProvider->assignUniqueKeyToTexture(key, texture);
         }
     }
     return texture ? texture->asRenderTarget() : NULL;
 }
 
-static void set_random_xpf(GrContext* context, const GrCaps& caps,
-                           GrPipelineBuilder* pipelineBuilder, SkRandom* random,
-                           GrTexture* dummyTextures[]) {
-    SkAutoTUnref<const GrXPFactory> xpf(
-        GrProcessorTestFactory<GrXPFactory>::CreateStage(random, context, caps, dummyTextures));
+static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
+    SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::CreateStage(d));
     SkASSERT(xpf);
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
-static void set_random_color_coverage_stages(GrGpu* gpu,
-                                             GrPipelineBuilder* pipelineBuilder,
-                                             int maxStages,
-                                             SkRandom* random,
-                                             GrTexture* dummyTextures[]) {
-    int numProcs = random->nextULessThan(maxStages + 1);
-    int numColorProcs = random->nextULessThan(numProcs + 1);
+static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
+                                             GrProcessorTestData* d, int maxStages) {
+    int numProcs = d->fRandom->nextULessThan(maxStages + 1);
+    int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
 
     for (int s = 0; s < numProcs;) {
         SkAutoTUnref<const GrFragmentProcessor> fp(
-                GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(random,
-                                                                         gpu->getContext(),
-                                                                         *gpu->caps(),
-                                                                         dummyTextures));
+                GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
         SkASSERT(fp);
 
         // finally add the stage to the correct pipeline in the drawstate
         if (s < numColorProcs) {
             pipelineBuilder->addColorProcessor(fp);
         } else {
             pipelineBuilder->addCoverageProcessor(fp);
         }
         ++s;
     }
@@ skipping 77 matching lines @@
             return false;
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setRenderTarget(rt.get());
         pipelineBuilder.setClip(clip);
 
         SkAutoTUnref<GrBatch> batch(GrRandomBatch(&random, context));
         SkASSERT(batch);
 
-        set_random_color_coverage_stages(fGpu,
-                                         &pipelineBuilder,
-                                         maxStages,
-                                         &random,
-                                         dummyTextures);
-
-        // creates a random xfer processor factory on the draw state 
-        set_random_xpf(context, *fGpu->caps(), &pipelineBuilder, &random, dummyTextures);
-
+        GrShaderDataManager shaderDataManager;
+        GrProcessorTestData ptd(&random, context, &shaderDataManager, fGpu->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);
     }
 
     // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
     this->flush();
     return true;
 }
@@ skipping 38 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(context, maxStages));
         }
     }
 }
 
 #endif