Revert of 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 54 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_hints(&ds, &random);
         set_random_state(&ds, &random);
+        set_random_blend_func(&ds, &random);
         set_random_stencil(&ds, &random);
 
         GrDeviceCoordTexture dstCopy;
 
         // TODO take color off the PP when its installed
         GrColor color = ds.hasGeometryProcessor() ? ds.getGeometryProcessor()->getColor() :
                                                     GrColor_WHITE;
         uint8_t coverage = ds.hasGeometryProcessor() ? ds.getGeometryProcessor()->getCoverage() :
                                                        0xff;
         if (!this->setupDstReadIfNecessary(&ds, color, coverage, &dstCopy, NULL)) {
@@ skipping 49 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif