New API for computing optimization invariants.

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) {
+                                 GrXPOverridesForBatch* overrides) {
     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.fColorPOI,
                                                            args.fCoveragePOI,
                                                            builder.hasMixedSamples(),
                                                            &args.fDstTexture,
@@ skipping 79 matching lines @@
     }
 
     for (int i = firstCoverageProcessorIdx; i < builder.numCoverageFragmentProcessors();
          ++i, ++currFPIdx) {
         const GrFragmentProcessor* fp = builder.getCoverageFragmentProcessor(i);
         pipeline->fFragmentProcessors[currFPIdx].reset(fp);
         usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
     }
 
     // Setup info we need to pass to GrPrimitiveProcessors that are used with this GrPipeline.
-    opts->fFlags = 0;
+    overrides->fFlags = 0;
     if (!SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag)) {
-        opts->fFlags |= GrPipelineOptimizations::kReadsColor_Flag;
+        overrides->fFlags |= GrXPOverridesForBatch::kReadsColor_Flag;
     }
     if (GrColor_ILLEGAL != overrideColor) {
-        opts->fFlags |= GrPipelineOptimizations::kUseOverrideColor_Flag;
-        opts->fOverrideColor = overrideColor;
+        overrides->fFlags |= GrXPOverridesForBatch::kUseOverrideColor_Flag;
+        overrides->fOverrideColor = overrideColor;
     }
     if (!SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag)) {
-        opts->fFlags |= GrPipelineOptimizations::kReadsCoverage_Flag;
+        overrides->fFlags |= GrXPOverridesForBatch::kReadsCoverage_Flag;
     }
     if (usesLocalCoords) {
-        opts->fFlags |= GrPipelineOptimizations::kReadsLocalCoords_Flag;
+        overrides->fFlags |= GrXPOverridesForBatch::kReadsLocalCoords_Flag;
     }
     if (SkToBool(optFlags & GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag)) {
-        opts->fFlags |= GrPipelineOptimizations::kCanTweakAlphaForCoverage_Flag; 
+        overrides->fFlags |= GrXPOverridesForBatch::kCanTweakAlphaForCoverage_Flag; 
     }
 
     GrXPFactory::InvariantBlendedColor blendedColor;
     if (xpFactory) {
         xpFactory->getInvariantBlendedColor(args.fColorPOI, &blendedColor);
     } else {
         GrPorterDuffXPFactory::SrcOverInvariantBlendedColor(args.fColorPOI.color(),
                                                             args.fColorPOI.validFlags(),
                                                             args.fColorPOI.isOpaque(),
                                                             &blendedColor); 
     }
     if (blendedColor.fWillBlendWithDst) {
-        opts->fFlags |= GrPipelineOptimizations::kWillColorBlendWithDst_Flag;
+        overrides->fFlags |= GrXPOverridesForBatch::kWillColorBlendWithDst_Flag;
     }
 
     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);
     }
@@ skipping 68 matching lines @@
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }