GLProgramsTest can now randomly create a tree of GrFragmentProcessors instead of a linear pipeline

tests/GLProgramsTest.cpp

Index: tests/GLProgramsTest.cpp
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 16745e5669d673dd0ddc18d0b3772e0de69e7297..51619d401d307bc502412006ca16fce8eeeda985 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -22,6 +22,7 @@
 #include "GrXferProcessor.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
+#include "SkComposeShader.h"
 #include "Test.h"
 
 #include "batches/GrDrawBatch.h"
@@ -136,23 +137,84 @@ static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestDa
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
+static GrFragmentProcessor* create_random_proc_tree(GrProcessorTestData* d,

[tomhudson, 2015/08/25 19:29:24]

So what's d really doing here? Looks like it's carrying a random number
generator around, and otherwise unused? The while() loop with
GrProcessorTestFactory::CreateStage() is really obscure and hard to trust.

+                                                    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)
+    const float terminateProbability = 0.3f;
+    if (1 == minLevels) {
+        bool terminate = (1 == maxLevels) || (d->fRandom->nextF() < terminateProbability);
+        if (terminate) {
+            GrFragmentProcessor* fp;
+            while (true) {
+                fp = GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d);
+                SkASSERT(fp);
+                if (0 == fp->numChildProcessors()) {
+                    break;
+                }
+                fp->unref();
+            }
+            return fp;
+        }
+    }
+    // If we didn't terminate, choose either the left or right subtree to fulfill
+    // the minLevels requirement of this tree; the other child can have as few levels as it wants.
+    // Also choose a random xfer mode that's supported by GrComposeEffect.
+    if (minLevels > 1) {
+        --minLevels;
+    }
+    SkAutoTUnref<GrFragmentProcessor> minLevelsChild(
+            create_random_proc_tree(d, minLevels, maxLevels - 1));
+    SkAutoTUnref<GrFragmentProcessor> otherChild(
+            create_random_proc_tree(d, 1, maxLevels - 1));
+    SkXfermode::Mode mode;
+    do {
+        mode = static_cast<SkXfermode::Mode>(
+                                d->fRandom->nextRangeU(0, SkXfermode::Mode::kLastCoeffMode));
+    } while (mode == SkXfermode::Mode::kClear_Mode);
+
+    GrFragmentProcessor* fp;
+    if (d->fRandom->nextF() < 0.5f) {
+        fp = GrComposeEffect::Create(minLevelsChild, otherChild, mode);
+    } else {
+        fp = GrComposeEffect::Create(otherChild, minLevelsChild, mode);
+    }
+    return fp;
+}
+
 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;) {
+    // 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.

[tomhudson, 2015/08/25 19:29:24]

A one-level tree will just be a leaf node with no ComposeEffect,
meaning we've got an effective 0.625f chance of a linear pipeline and a 0.475f
chance of a tree?

[wangyix, 2015/08/25 19:48:01]

Good point. It may be better to have create_random_proc_tree() always return a
tree with 2 or more levels.  This may also address your comment about the
while-loop with GrProcessorTestFactory::CreateStage() above: we can make the
base case return a two-level tree by calling GrComposeEffect::TestCreate()
instead of having the base case return a random non-compose processor.  This
lets us reuse the code within GrComposeEffect::TestCreate() that searchs for
non-compose procs to use as children.

+        const int maxTreeLevels = 4;
         SkAutoTUnref<const GrFragmentProcessor> fp(
-                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);
+                                        create_random_proc_tree(d, 1, maxTreeLevels));
+        pipelineBuilder->addColorProcessor(fp);

[tomhudson, 2015/08/25 19:29:24]

No coverage? Or am I missing something?

+    } else {
+        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(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;
         }
-        ++s;
     }
 }