Create xfer processor backend.

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 103 matching lines @@
     SkAutoTUnref<GrTexture> texture(context->findAndRefTexture(texDesc, cacheId, &params));
     if (!texture) {
         texture.reset(context->createTexture(&params, texDesc, cacheId, 0, 0));
         if (!texture) {
             return NULL;
         }
     }
     return SkRef(texture->asRenderTarget());
 }
 
+static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps, GrDrawState* ds,
+                           SkRandom* random, GrTexture* dummyTextures[]) {
+    SkAutoTUnref<const GrXPFactory> xpf(
+        GrProcessorTestFactory<GrXPFactory>::CreateStage(random, context, caps, dummyTextures));
+    SkASSERT(xpf);
+    ds->setXPFactory(xpf.get());
+}
+
 static void set_random_gp(GrContext* context,
                           const GrDrawTargetCaps& caps,
                           GrDrawState* ds,
                           SkRandom* random,
                           GrTexture* dummyTextures[]) {
     SkAutoTUnref<const GrGeometryProcessor> gp(
             GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(random,
                                                                      context,
                                                                      caps,
                                                                      dummyTextures));
@@ skipping 116 matching lines @@
 }
 
 static void set_random_state(GrDrawState* ds, SkRandom* random) {
     int state = 0;
     for (int i = 1; i <= GrDrawState::kLast_StateBit; i <<= 1) {
         state |= random->nextBool() * i;
     }
     ds->enableState(state);
 }
 
-// this function will randomly pick non-self referencing blend modes
-static void set_random_blend_func(GrDrawState* ds, SkRandom* random) {
-    GrBlendCoeff src;
-    do {
-        src = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
-    } while (GrBlendCoeffRefsSrc(src));
-
-    GrBlendCoeff dst;
-    do {
-        dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
-    } while (GrBlendCoeffRefsDst(dst));
-
-    GrXPFactory* xpFactory = GrPorterDuffXPFactory::Create(src, dst);
-    ds->setXPFactory(xpFactory)->unref();
-}
-
 // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
 static void set_random_stencil(GrDrawState* ds, SkRandom* random) {
     GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil,
                                  kReplace_StencilOp,
                                  kReplace_StencilOp,
                                  kAlways_StencilFunc,
                                  0xffff,
                                  0xffff,
                                  0xffff);
     GR_STATIC_CONST_SAME_STENCIL(kDoesNotWriteStencil,
@@ skipping 79 matching lines @@
         bool hasGeometryProcessor = !usePathRendering;
         if (hasGeometryProcessor) {
             set_random_gp(fContext, gpu->glCaps(), &ds, &random, dummyTextures);
         }
         set_random_color_coverage_stages(gpu,
                                          &ds,
                                          maxStages - hasGeometryProcessor,
                                          usePathRendering,
                                          &random,
                                          dummyTextures);
+ 
+        // creates a random xfer processor factory on the draw state 
+        set_random_xpf(fContext, gpu->glCaps(), &ds, &random, dummyTextures);
+
         set_random_color(&ds, &random);
         set_random_coverage(&ds, &random);
         set_random_hints(&ds, &random);
         set_random_state(&ds, &random);
-        set_random_blend_func(&ds, &random);
         set_random_stencil(&ds, &random);
 
         GrDeviceCoordTexture dstCopy;
 
         if (!this->setupDstReadIfNecessary(&ds, &dstCopy, NULL)) {
             SkDebugf("Couldn't setup dst read texture");
             return false;
         }
 
         // create optimized draw state, setup readDst texture if required, and build a descriptor
@@ skipping 44 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif