Split GrPipelineInput into separate color and coverage types, the latter of which is just an enum.

Assign names that indicate that they aren't just for the input phase since I plan to use them at the boundary between FPs and XPs as well.

Renamed GrProcOptInfo to GrColorFragmentProcessorAnalysis. This is now only used on the color side and the new name seems clearer to me.

Change GrMeshDrawOp::getFragmentProcessorAnalysisInputs to use the new color/coverage types directly rather than a class that has been reduced to simply bundling them together.

Change-Id: If93bae74c9d590486eecdf63f302418c96deab65
Reviewed-on: https://skia-review.googlesource.com/10161
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>

1 files changed, 30 insertions, 26 deletions

diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index a8423b6894..4a508921b1 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -8,7 +8,7 @@
 #include "GrProcessorSet.h"
 #include "GrAppliedClip.h"
 #include "GrCaps.h"
-#include "GrProcOptInfo.h"
+#include "GrPipelineAnalysis.h"
 
 GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
     fXPFactory = paint.fXPFactory;
@@ -80,13 +80,14 @@ bool GrProcessorSet::operator==(const GrProcessorSet& that) const {
 
 //////////////////////////////////////////////////////////////////////////////
 
-void GrProcessorSet::FragmentProcessorAnalysis::internalInit(const GrPipelineInput& colorInput,
-                                                             const GrPipelineInput coverageInput,
-                                                             const GrProcessorSet& processors,
-                                                             const GrFragmentProcessor* clipFP,
-                                                             const GrCaps& caps) {
-    GrProcOptInfo colorInfo(colorInput);
-    fCompatibleWithCoverageAsAlpha = !coverageInput.isLCDCoverage();
+void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
+        const GrPipelineAnalysisColor& colorInput,
+        const GrPipelineAnalysisCoverage coverageInput,
+        const GrProcessorSet& processors,
+        const GrFragmentProcessor* clipFP,
+        const GrCaps& caps) {
+    GrColorFragmentProcessorAnalysis colorInfo(colorInput);
+    fCompatibleWithCoverageAsAlpha = GrPipelineAnalysisCoverage::kLCD != coverageInput;
     fValidInputColor = colorInput.isConstant(&fInputColor);
 
     const GrFragmentProcessor* const* fps =
@@ -115,27 +116,27 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalInit(const GrPipelineInp
     fInitialColorProcessorsToEliminate = colorInfo.initialProcessorsToEliminate(&fInputColor);
     fValidInputColor |= SkToBool(fInitialColorProcessorsToEliminate);
 
-    bool opaque = colorInfo.isOpaque();
-    if (colorInfo.hasKnownOutputColor(&fKnownOutputColor)) {
-        fOutputColorType = static_cast<unsigned>(opaque ? ColorType::kOpaqueConstant
-                                                        : ColorType::kConstant);
-    } else if (opaque) {
+    GrPipelineAnalysisColor outputColor = colorInfo.outputColor();
+    if (outputColor.isConstant(&fKnownOutputColor)) {
+        fOutputColorType = static_cast<unsigned>(outputColor.isOpaque() ? ColorType::kOpaqueConstant
+                                                                        : ColorType::kConstant);
+    } else if (outputColor.isOpaque()) {
         fOutputColorType = static_cast<unsigned>(ColorType::kOpaque);
     } else {
         fOutputColorType = static_cast<unsigned>(ColorType::kUnknown);
     }
 
-    if (coverageInput.isLCDCoverage()) {
-        fOutputCoverageType = static_cast<unsigned>(CoverageType::kLCD);
+    if (GrPipelineAnalysisCoverage::kLCD == coverageInput) {
+        fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kLCD);
+    } else if (hasCoverageFP || GrPipelineAnalysisCoverage::kSingleChannel == coverageInput) {
+        fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kSingleChannel);
     } else {
-        fOutputCoverageType = hasCoverageFP || !coverageInput.isSolidWhite()
-                                      ? static_cast<unsigned>(CoverageType::kSingleChannel)
-                                      : static_cast<unsigned>(CoverageType::kNone);
+        fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kNone);
     }
 }
 
-void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineInput& colorInput,
-                                                     const GrPipelineInput coverageInput,
+void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineAnalysisColor& colorInput,
+                                                     const GrPipelineAnalysisCoverage coverageInput,
                                                      const GrProcessorSet& processors,
                                                      const GrAppliedClip* appliedClip,
                                                      const GrCaps& caps) {
@@ -146,16 +147,19 @@ void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineInput& colo
 }
 
 GrProcessorSet::FragmentProcessorAnalysis::FragmentProcessorAnalysis(
-        const GrPipelineInput& colorInput, const GrPipelineInput coverageInput, const GrCaps& caps)
+        const GrPipelineAnalysisColor& colorInput,
+        const GrPipelineAnalysisCoverage coverageInput,
+        const GrCaps& caps)
         : FragmentProcessorAnalysis() {
     this->internalInit(colorInput, coverageInput, GrProcessorSet(GrPaint()), nullptr, caps);
 }
 
-void GrProcessorSet::analyzeAndEliminateFragmentProcessors(FragmentProcessorAnalysis* analysis,
-                                                           const GrPipelineInput& colorInput,
-                                                           const GrPipelineInput coverageInput,
-                                                           const GrAppliedClip* clip,
-                                                           const GrCaps& caps) {
+void GrProcessorSet::analyzeAndEliminateFragmentProcessors(
+        FragmentProcessorAnalysis* analysis,
+        const GrPipelineAnalysisColor& colorInput,
+        const GrPipelineAnalysisCoverage coverageInput,
+        const GrAppliedClip* clip,
+        const GrCaps& caps) {
     analysis->init(colorInput, coverageInput, *this, clip, caps);
     if (analysis->fInitialColorProcessorsToEliminate > 0) {
         for (unsigned i = 0; i < analysis->fInitialColorProcessorsToEliminate; ++i) {