Don't create a GXPFactory when blend is SrcOver

src/gpu/GrPipeline.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPipeline.h"
 
 #include "GrCaps.h"
 #include "GrDrawTarget.h"
 #include "GrGpu.h"
 #include "GrPipelineBuilder.h"
 #include "GrProcOptInfo.h"
 #include "GrXferProcessor.h"
 
 #include "batches/GrBatch.h"
 
 GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
                                  GrPipelineOptimizations* opts) {
     const GrPipelineBuilder& builder = *args.fPipelineBuilder;
 
     // Create XferProcessor from DS's XPFactory
-    SkAutoTUnref<GrXferProcessor> xferProcessor(
-        builder.getXPFactory()->createXferProcessor(args.fColorPOI, args.fCoveragePOI,
-                                                    builder.hasMixedSamples(), &args.fDstTexture,
-                                                    *args.fCaps));
+    const GrXPFactory* xpFactory = builder.getXPFactory();
+    GrXferProcessor* xferProcessor;

[bsalomon, 2015/11/23 20:19:52]

Why not

SkAutoTUnref xferProcessor;
if (xpFactory) {
  xferProcessor.reset(...);
} else {
  xferProcessor.reset(...);
}

?

Not a big deal, just curious.

[egdaniel, 2015/11/23 20:49:04]

Done.

+    if (xpFactory) {
+        xferProcessor = xpFactory->createXferProcessor(args.fColorPOI, args.fCoveragePOI,
+                                                       builder.hasMixedSamples(), &args.fDstTexture,
+                                                       *args.fCaps);
+    } else {
+        xferProcessor = GrCreateSrcOverXferProcessor(*args.fCaps, args.fColorPOI, args.fCoveragePOI,
+                                                     builder.hasMixedSamples(), &args.fDstTexture);
+    }
+
     if (!xferProcessor) {
         return nullptr;
     }
 
     GrColor overrideColor = GrColor_ILLEGAL;
     if (args.fColorPOI.firstEffectiveProcessorIndex() != 0) {
         overrideColor = args.fColorPOI.inputColorToFirstEffectiveProccesor();
     }
 
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
 
     optFlags = xferProcessor->getOptimizations(args.fColorPOI,
                                                 args.fCoveragePOI,
                                                 builder.getStencil().doesWrite(),
                                                 &overrideColor,
                                                 *args.fCaps);
 
     // When path rendering the stencil settings are not always set on the GrPipelineBuilder
     // so we must check the draw type. In cases where we will skip drawing we simply return a
     // null GrPipeline.
     if (GrXferProcessor::kSkipDraw_OptFlag & optFlags) {
+        xferProcessor->unref();
         return nullptr;
     }
 
     // No need to have an override color if it isn't even going to be used.
     if (SkToBool(GrXferProcessor::kIgnoreColor_OptFlag & optFlags)) {
         overrideColor = GrColor_ILLEGAL;
     }
 
     GrPipeline* pipeline = new (memory) GrPipeline;
-    pipeline->fXferProcessor.reset(xferProcessor.get());
+    pipeline->fXferProcessor.reset(xferProcessor);
 
     pipeline->fRenderTarget.reset(builder.fRenderTarget.get());
     SkASSERT(pipeline->fRenderTarget);
     pipeline->fScissorState = *args.fScissor;
     pipeline->fStencilSettings = builder.getStencil();
     pipeline->fDrawFace = builder.getDrawFace();
 
     pipeline->fFlags = 0;
     if (builder.isHWAntialias()) {
         pipeline->fFlags |= kHWAA_Flag;
@@ skipping 47 matching lines @@
         opts->fFlags |= GrPipelineOptimizations::kReadsCoverage_Flag;
     }
     if (usesLocalCoords) {
         opts->fFlags |= GrPipelineOptimizations::kReadsLocalCoords_Flag;
     }
     if (SkToBool(optFlags & GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag)) {
         opts->fFlags |= GrPipelineOptimizations::kCanTweakAlphaForCoverage_Flag; 
     }
 
     GrXPFactory::InvariantBlendedColor blendedColor;
-    builder.fXPFactory->getInvariantBlendedColor(args.fColorPOI, &blendedColor);
+    if (xpFactory) {
+        xpFactory->getInvariantBlendedColor(args.fColorPOI, &blendedColor);
+    } else {
+       GrSrcOverInvariantBlendedColor(args.fColorPOI.color(),
+                                      args.fColorPOI.validFlags(),
+                                      args.fColorPOI.isOpaque(),
+                                      &blendedColor); 
+    }
     if (blendedColor.fWillBlendWithDst) {
         opts->fFlags |= GrPipelineOptimizations::kWillColorBlendWithDst_Flag;
     }
 
+    xferProcessor->unref();
     return pipeline;
 }
 
 static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) {
     for (int i = 0; i < proc->numChildProcessors(); ++i) {
         // need to recurse
         add_dependencies_for_processor(&proc->childProcessor(i), rt);
     }
 
     for (int i = 0; i < proc->numTextures(); ++i) {
@@ skipping 66 matching lines @@
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }