Don't ref/unref the static src-over xp

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"
@@ skipping 10 matching lines @@
     const GrPipelineBuilder& builder = *args.fPipelineBuilder;
 
     // Create XferProcessor from DS's XPFactory
     const GrXPFactory* xpFactory = builder.getXPFactory();
     SkAutoTUnref<GrXferProcessor> xferProcessor;
     if (xpFactory) {
         xferProcessor.reset(xpFactory->createXferProcessor(args.fOpts,
                                                            builder.hasMixedSamples(),
                                                            &args.fDstTexture,
                                                            *args.fCaps));
+        if (!xferProcessor) {
+            return nullptr;
+        }
     } else {
+        // This may return nullptr in the common case of src-over implemented using hw blending.
         xferProcessor.reset(GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
                                                                         *args.fCaps,
                                                                         args.fOpts,
                                                                         builder.hasMixedSamples(),
                                                                         &args.fDstTexture));
     }
-
-    if (!xferProcessor) {
-        return nullptr;
-    }
-
-    GrColor overrideColor = GrColor_ILLEGAL;
+   GrColor overrideColor = GrColor_ILLEGAL;
     if (args.fOpts.fColorPOI.firstEffectiveProcessorIndex() != 0) {
         overrideColor = args.fOpts.fColorPOI.inputColorToFirstEffectiveProccesor();
     }
 
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
 
-    optFlags = xferProcessor->getOptimizations(args.fOpts,
-                                               builder.getStencil().doesWrite(),
-                                               &overrideColor,
-                                               *args.fCaps);
+    const GrXferProcessor* xpForOpts = xferProcessor ? xferProcessor.get() : 
+                                                       &GrPorterDuffXPFactory::SimpleSrcOverXP();
+    optFlags = xpForOpts->getOptimizations(args.fOpts,
+                                           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) {
         return nullptr;
     }
 
     // No need to have an override color if it isn't even going to be used.
     if (SkToBool(GrXferProcessor::kIgnoreColor_OptFlag & optFlags)) {
@@ skipping 96 matching lines @@
         SkASSERT(rt->getLastDrawTarget());
         rt->getLastDrawTarget()->addDependency(texture);
     }
 }
 
 void GrPipeline::addDependenciesTo(GrRenderTarget* rt) const {
     for (int i = 0; i < fFragmentProcessors.count(); ++i) {
         add_dependencies_for_processor(fFragmentProcessors[i].get(), rt);
     }
 
-    if (fXferProcessor.get()) {
-        const GrXferProcessor* xfer = fXferProcessor.get();
+    const GrXferProcessor& xfer = this->getXferProcessor();
 
-        for (int i = 0; i < xfer->numTextures(); ++i) {
-            GrTexture* texture = xfer->textureAccess(i).getTexture();   
-            SkASSERT(rt->getLastDrawTarget());
-            rt->getLastDrawTarget()->addDependency(texture);
-        }
+    for (int i = 0; i < xfer.numTextures(); ++i) {
+        GrTexture* texture = xfer.textureAccess(i).getTexture();   
+        SkASSERT(rt->getLastDrawTarget());
+        rt->getLastDrawTarget()->addDependency(texture);
     }
 }
 
 void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelineBuilder,
                                                 GrXferProcessor::OptFlags flags,
                                                 const GrProcOptInfo& colorPOI,
                                                 const GrProcOptInfo& coveragePOI,
                                                 int* firstColorProcessorIdx,
                                                 int* firstCoverageProcessorIdx) {
     fIgnoresCoverage = SkToBool(flags & GrXferProcessor::kIgnoreCoverage_OptFlag);
-    fReadsFragPosition = fXferProcessor->willReadFragmentPosition();
+    fReadsFragPosition = this->getXferProcessor().willReadFragmentPosition();
 
     if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) ||
         (flags & GrXferProcessor::kOverrideColor_OptFlag)) {
         *firstColorProcessorIdx = pipelineBuilder.numColorFragmentProcessors();
     } else {
         if (colorPOI.readsFragPosition()) {
             fReadsFragPosition = true;
         }
     }
 
@@ skipping 15 matching lines @@
     if (a.getRenderTarget() != b.getRenderTarget() ||
         a.fFragmentProcessors.count() != b.fFragmentProcessors.count() ||
         a.fNumColorProcessors != b.fNumColorProcessors ||
         a.fScissorState != b.fScissorState ||
         a.fFlags != b.fFlags ||
         a.fStencilSettings != b.fStencilSettings ||
         a.fDrawFace != b.fDrawFace) {
         return false;
     }
 
-    if (!a.getXferProcessor()->isEqual(*b.getXferProcessor())) {
-        return false;
+    // Most of the time both are nullptr
+    if (a.fXferProcessor.get() || b.fXferProcessor.get()) {
+        if (!a.getXferProcessor().isEqual(b.getXferProcessor())) {
+            return false;
+        }
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }