Renames of processor analysis-related classes and method.

GrProcesserSet::FragmentProcessorAnalysis->GrProcessorSet::Analysis
GrPipelineAnalysisColor->GrProcessorAnalysisColor
GrPipelineAnalysisCoverage->GrProcessorAnalysisCoverage
GrMeshDrawOp::getFragmentProcessorAnalysisInputs->GrMeshDrawOp::getProcessorAnalysisInputs

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

50 files changed, 282 insertions, 290 deletions

diff --git a/gn/gpu.gni b/gn/gpu.gni
index a481cfd4ef..bf908378be 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -134,8 +134,6 @@ skia_gpu_sources = [
   "$_src/gpu/GrPreFlushResourceProvider.h",
   "$_src/gpu/GrPipeline.cpp",
   "$_src/gpu/GrPipeline.h",
-  "$_src/gpu/GrPipelineAnalysis.cpp",
-  "$_src/gpu/GrPipelineAnalysis.h",
   "$_src/gpu/GrPipelineBuilder.h",
   "$_src/gpu/GrPrimitiveProcessor.cpp",
   "$_src/gpu/GrPrimitiveProcessor.h",
@@ -144,6 +142,8 @@ skia_gpu_sources = [
   "$_src/gpu/GrProgramDesc.cpp",
   "$_src/gpu/GrProgramDesc.h",
   "$_src/gpu/GrProcessor.cpp",
+  "$_src/gpu/GrProcessorAnalysis.cpp",
+  "$_src/gpu/GrProcessorAnalysis.h",
   "$_src/gpu/GrProcessorUnitTest.cpp",
   "$_src/gpu/GrGpuResourceRef.cpp",
   "$_src/gpu/GrQuad.h",
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index fdec93ba9a..601cb3ca8c 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -8,7 +8,7 @@
 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrPipeline.h"
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index 3802faaa30..75d82d6f7d 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -57,10 +57,10 @@ public:
         uint32_t fFlags = 0;
         GrDrawFace fDrawFace = GrDrawFace::kBoth;
         const GrProcessorSet* fProcessors = nullptr;
-        GrPipelineAnalysisColor fInputColor;
-        GrPipelineAnalysisCoverage fInputCoverage = GrPipelineAnalysisCoverage::kNone;
+        GrProcessorAnalysisColor fInputColor;
+        GrProcessorAnalysisCoverage fInputCoverage = GrProcessorAnalysisCoverage::kNone;
         // This is only used for GrMeshDrawOp's legacy pipeline creation system.
-        const GrProcessorSet::FragmentProcessorAnalysis* fAnalysis = nullptr;
+        const GrProcessorSet::Analysis* fAnalysis = nullptr;
         const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused;
         const GrAppliedClip* fAppliedClip = nullptr;
         GrRenderTarget* fRenderTarget = nullptr;
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index 17e49c7d0c..ddccd99496 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -24,7 +24,7 @@
  * GrPrimitiveProcessor. These loops run on the CPU and to determine known properties of the final
  * color and coverage inputs to the GrXferProcessor in order to perform optimizations that preserve
  * correctness. The GrDrawOp seeds these loops with initial color and coverage, in its
- * getFragmentProcessorAnalysisInputs implementation. These seed values are processed by the
+ * getProcessorAnalysisInputs implementation. These seed values are processed by the
  * subsequent
  * stages of the rendering pipeline and the output is then fed back into the GrDrawOp in
  * the applyPipelineOptimizations call, where the op can use the information to inform decisions
diff --git a/src/gpu/GrPipelineAnalysis.cpp b/src/gpu/GrProcessorAnalysis.cpp
index 3512c940b0..317246d247 100644
--- a/src/gpu/GrPipelineAnalysis.cpp
+++ b/src/gpu/GrProcessorAnalysis.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
 #include "GrGeometryProcessor.h"
 #include "ops/GrDrawOp.h"
 
diff --git a/src/gpu/GrPipelineAnalysis.h b/src/gpu/GrProcessorAnalysis.h
index caf41b8a25..ad56ab4e2d 100644
--- a/src/gpu/GrPipelineAnalysis.h
+++ b/src/gpu/GrProcessorAnalysis.h
@@ -5,8 +5,8 @@
  * found in the LICENSE file.
  */
 
-#ifndef GrPipelineAnalysis_DEFINED
-#define GrPipelineAnalysis_DEFINED
+#ifndef GrProcessorAnalysis_DEFINED
+#define GrProcessorAnalysis_DEFINED
 
 #include "GrColor.h"
 
@@ -14,17 +14,17 @@ class GrDrawOp;
 class GrFragmentProcessor;
 class GrPrimitiveProcessor;
 
-class GrPipelineAnalysisColor {
+class GrProcessorAnalysisColor {
 public:
     enum class Opaque {
         kNo,
         kYes,
     };
 
-    GrPipelineAnalysisColor(Opaque opaque = Opaque::kNo)
+    GrProcessorAnalysisColor(Opaque opaque = Opaque::kNo)
             : fFlags(opaque == Opaque::kYes ? kIsOpaque_Flag : 0) {}
 
-    GrPipelineAnalysisColor(GrColor color) { this->setToConstant(color); }
+    GrProcessorAnalysisColor(GrColor color) { this->setToConstant(color); }
 
     void setToConstant(GrColor color) {
         fColor = color;
@@ -51,7 +51,7 @@ public:
         return false;
     }
 
-    bool operator==(const GrPipelineAnalysisColor& that) const {
+    bool operator==(const GrProcessorAnalysisColor& that) const {
         if (fFlags != that.fFlags) {
             return false;
         }
@@ -59,9 +59,9 @@ public:
     }
 
     /** The returned value reflects the common properties of the two inputs. */
-    static GrPipelineAnalysisColor Combine(const GrPipelineAnalysisColor& a,
-                                           const GrPipelineAnalysisColor& b) {
-        GrPipelineAnalysisColor result;
+    static GrProcessorAnalysisColor Combine(const GrProcessorAnalysisColor& a,
+                                            const GrProcessorAnalysisColor& b) {
+        GrProcessorAnalysisColor result;
         uint32_t commonFlags = a.fFlags & b.fFlags;
         if ((kColorIsKnown_Flag & commonFlags) && a.fColor == b.fColor) {
             result.fColor = a.fColor;
@@ -81,7 +81,7 @@ private:
     GrColor fColor;
 };
 
-enum class GrPipelineAnalysisCoverage { kNone, kSingleChannel, kLCD };
+enum class GrProcessorAnalysisCoverage { kNone, kSingleChannel, kLCD };
 
 /**
  * GrColorFragmentProcessorAnalysis gathers invariant data from a set of color fragment processor.
@@ -92,7 +92,7 @@ class GrColorFragmentProcessorAnalysis {
 public:
     GrColorFragmentProcessorAnalysis() = default;
 
-    GrColorFragmentProcessorAnalysis(const GrPipelineAnalysisColor& input)
+    GrColorFragmentProcessorAnalysis(const GrProcessorAnalysisColor& input)
             : GrColorFragmentProcessorAnalysis() {
         fAllProcessorsCompatibleWithCoverageAsAlpha = true;
         fIsOpaque = input.isOpaque();
@@ -103,7 +103,7 @@ public:
         }
     }
 
-    void reset(const GrPipelineAnalysisColor& input) {
+    void reset(const GrProcessorAnalysisColor& input) {
         *this = GrColorFragmentProcessorAnalysis(input);
     }
 
@@ -151,12 +151,12 @@ public:
         return SkTMax(0, fProcessorsVisitedWithKnownOutput);
     }
 
-    GrPipelineAnalysisColor outputColor() const {
+    GrProcessorAnalysisColor outputColor() const {
         if (fProcessorsVisitedWithKnownOutput != fTotalProcessorsVisited) {
-            return GrPipelineAnalysisColor(fIsOpaque ? GrPipelineAnalysisColor::Opaque::kYes
-                                                     : GrPipelineAnalysisColor::Opaque::kNo);
+            return GrProcessorAnalysisColor(fIsOpaque ? GrProcessorAnalysisColor::Opaque::kYes
+                                                      : GrProcessorAnalysisColor::Opaque::kNo);
         }
-        return GrPipelineAnalysisColor(fLastKnownOutputColor.toGrColor());
+        return GrProcessorAnalysisColor(fLastKnownOutputColor.toGrColor());
     }
 
 private:
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index b47a026bd5..21b20c7046 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -8,7 +8,6 @@
 #include "GrProcessorSet.h"
 #include "GrAppliedClip.h"
 #include "GrCaps.h"
-#include "GrPipelineAnalysis.h"
 #include "GrXferProcessor.h"
 
 GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
@@ -81,14 +80,13 @@ bool GrProcessorSet::operator==(const GrProcessorSet& that) const {
 
 //////////////////////////////////////////////////////////////////////////////
 
-void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
-        const GrPipelineAnalysisColor& colorInput,
-        const GrPipelineAnalysisCoverage coverageInput,
-        const GrProcessorSet& processors,
-        const GrFragmentProcessor* clipFP,
-        const GrCaps& caps) {
+void GrProcessorSet::Analysis::internalInit(const GrProcessorAnalysisColor& colorInput,
+                                            const GrProcessorAnalysisCoverage coverageInput,
+                                            const GrProcessorSet& processors,
+                                            const GrFragmentProcessor* clipFP,
+                                            const GrCaps& caps) {
     GrColorFragmentProcessorAnalysis colorInfo(colorInput);
-    fCompatibleWithCoverageAsAlpha = GrPipelineAnalysisCoverage::kLCD != coverageInput;
+    fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
     fValidInputColor = colorInput.isConstant(&fInputColor);
 
     const GrFragmentProcessor* const* fps =
@@ -117,7 +115,7 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
     fInitialColorProcessorsToEliminate = colorInfo.initialProcessorsToEliminate(&fInputColor);
     fValidInputColor |= SkToBool(fInitialColorProcessorsToEliminate);
 
-    GrPipelineAnalysisColor outputColor = colorInfo.outputColor();
+    GrProcessorAnalysisColor outputColor = colorInfo.outputColor();
     if (outputColor.isConstant(&fKnownOutputColor)) {
         fOutputColorType = static_cast<unsigned>(ColorType::kConstant);
     } else if (outputColor.isOpaque()) {
@@ -126,20 +124,20 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
         fOutputColorType = static_cast<unsigned>(ColorType::kUnknown);
     }
 
-    GrPipelineAnalysisCoverage outputCoverage;
-    if (GrPipelineAnalysisCoverage::kLCD == coverageInput) {
-        outputCoverage = GrPipelineAnalysisCoverage::kLCD;
-    } else if (hasCoverageFP || GrPipelineAnalysisCoverage::kSingleChannel == coverageInput) {
-        outputCoverage = GrPipelineAnalysisCoverage::kSingleChannel;
+    GrProcessorAnalysisCoverage outputCoverage;
+    if (GrProcessorAnalysisCoverage::kLCD == coverageInput) {
+        outputCoverage = GrProcessorAnalysisCoverage::kLCD;
+    } else if (hasCoverageFP || GrProcessorAnalysisCoverage::kSingleChannel == coverageInput) {
+        outputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
     } else {
-        outputCoverage = GrPipelineAnalysisCoverage::kNone;
+        outputCoverage = GrProcessorAnalysisCoverage::kNone;
     }
     fOutputCoverageType = static_cast<unsigned>(outputCoverage);
 
     GrXPFactory::AnalysisProperties props = GrXPFactory::GetAnalysisProperties(
             processors.fXPFactory, colorInfo.outputColor(), outputCoverage, caps);
     if (!processors.numCoverageFragmentProcessors() &&
-        GrPipelineAnalysisCoverage::kNone == coverageInput) {
+        GrProcessorAnalysisCoverage::kNone == coverageInput) {
         fCanCombineOverlappedStencilAndCover = SkToBool(
                 props & GrXPFactory::AnalysisProperties::kCanCombineOverlappedStencilAndCover);
     } else {
@@ -167,32 +165,31 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
     }
 }
 
-void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineAnalysisColor& colorInput,
-                                                     const GrPipelineAnalysisCoverage coverageInput,
-                                                     const GrProcessorSet& processors,
-                                                     const GrAppliedClip* appliedClip,
-                                                     const GrCaps& caps) {
+void GrProcessorSet::Analysis::init(const GrProcessorAnalysisColor& colorInput,
+                                    const GrProcessorAnalysisCoverage coverageInput,
+                                    const GrProcessorSet& processors,
+                                    const GrAppliedClip* appliedClip,
+                                    const GrCaps& caps) {
     const GrFragmentProcessor* clipFP =
             appliedClip ? appliedClip->clipCoverageFragmentProcessor() : nullptr;
     this->internalInit(colorInput, coverageInput, processors, clipFP, caps);
     fIsInitializedWithProcessorSet = true;
 }
 
-GrProcessorSet::FragmentProcessorAnalysis::FragmentProcessorAnalysis(
-        const GrPipelineAnalysisColor& colorInput,
-        const GrPipelineAnalysisCoverage coverageInput,
-        const GrXPFactory* factory,
-        const GrCaps& caps)
-        : FragmentProcessorAnalysis() {
+GrProcessorSet::Analysis::Analysis(const GrProcessorAnalysisColor& colorInput,
+                                   const GrProcessorAnalysisCoverage coverageInput,
+                                   const GrXPFactory* factory,
+                                   const GrCaps& caps)
+        : Analysis() {
     GrPaint paint;
     paint.setXPFactory(factory);
     this->internalInit(colorInput, coverageInput, GrProcessorSet(std::move(paint)), nullptr, caps);
 }
 
 void GrProcessorSet::analyzeAndEliminateFragmentProcessors(
-        FragmentProcessorAnalysis* analysis,
-        const GrPipelineAnalysisColor& colorInput,
-        const GrPipelineAnalysisCoverage coverageInput,
+        Analysis* analysis,
+        const GrProcessorAnalysisColor& colorInput,
+        const GrProcessorAnalysisCoverage coverageInput,
         const GrAppliedClip* clip,
         const GrCaps& caps) {
     analysis->init(colorInput, coverageInput, *this, clip, caps);
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index 4f9a1c3164..f63369c4d4 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -10,7 +10,7 @@
 
 #include "GrFragmentProcessor.h"
 #include "GrPaint.h"
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
 #include "SkTemplates.h"
 
 class GrAppliedClip;
@@ -58,40 +58,40 @@ public:
     bool operator!=(const GrProcessorSet& that) const { return !(*this == that); }
 
     /**
-     * This is used to track analysis of color and coverage values through the fragment processors.
+     * This is used to track analysis of color and coverage values through the processors.
      */
-    class FragmentProcessorAnalysis {
+    class Analysis {
     public:
         /**
-         * This constructor allows an op to record its initial color in a FragmentProcessorAnalysis
-         * member and then run analysis later when the analysis inputs are available. If the
-         * analysis produces color fragment processor elimination then the input color is replaced
-         * by the expected input to the first non-eliminated processor. Otherwise, the original
-         * input color is preserved. The only reason to use this is to save space on the op by not
-         * separately storing the initial color.
+         * This constructor allows an op to record its initial color in an Analysis member and then
+         * then run analysis later when the analysis inputs are available. If the analysis produces
+         * color fragment processor elimination then the input color is replaced by the expected
+         * input to the first non-eliminated processor. Otherwise, the original input color is
+         * preserved. The only reason to use this is to save space on the op by not separately
+         * storing the initial color.
          */
-        explicit FragmentProcessorAnalysis(GrColor initialColor) : FragmentProcessorAnalysis() {
+        explicit Analysis(GrColor initialColor) : Analysis() {
             fInputColor = initialColor;
             fValidInputColor = true;
         }
 
-        FragmentProcessorAnalysis()
+        Analysis()
                 : fIsInitializedWithProcessorSet(false)
                 , fCompatibleWithCoverageAsAlpha(true)
                 , fValidInputColor(false)
                 , fRequiresDstTexture(false)
                 , fCanCombineOverlappedStencilAndCover(true)
                 , fIgnoresInputColor(false)
-                , fOutputCoverageType(static_cast<unsigned>(GrPipelineAnalysisCoverage::kNone))
+                , fOutputCoverageType(static_cast<unsigned>(GrProcessorAnalysisCoverage::kNone))
                 , fOutputColorType(static_cast<unsigned>(ColorType::kUnknown))
                 , fInitialColorProcessorsToEliminate(0) {}
 
         // This version is used by a unit test that assumes no clip and no fragment processors.
-        FragmentProcessorAnalysis(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage,
-                                  const GrXPFactory*, const GrCaps&);
+        Analysis(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage, const GrXPFactory*,
+                 const GrCaps&);
 
-        void init(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage, const GrProcessorSet&,
-                  const GrAppliedClip*, const GrCaps&);
+        void init(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage,
+                  const GrProcessorSet&, const GrAppliedClip*, const GrCaps&);
 
         bool isInitializedWithProcessorSet() const { return fIsInitializedWithProcessorSet; }
 
@@ -128,20 +128,20 @@ public:
         }
         bool isCompatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; }
         bool isInputColorIgnored() const { return fIgnoresInputColor; }
-        GrPipelineAnalysisCoverage outputCoverage() const {
-            return static_cast<GrPipelineAnalysisCoverage>(fOutputCoverageType);
+        GrProcessorAnalysisCoverage outputCoverage() const {
+            return static_cast<GrProcessorAnalysisCoverage>(fOutputCoverageType);
         }
-        GrPipelineAnalysisColor outputColor() const {
+        GrProcessorAnalysisColor outputColor() const {
             switch (this->outputColorType()) {
                 case ColorType::kConstant:
                     return fKnownOutputColor;
                 case ColorType::kOpaque:
-                    return GrPipelineAnalysisColor::Opaque::kYes;
+                    return GrProcessorAnalysisColor::Opaque::kYes;
                 case ColorType::kUnknown:
-                    return GrPipelineAnalysisColor::Opaque::kNo;
+                    return GrProcessorAnalysisColor::Opaque::kNo;
             }
             SkFAIL("Unexpected color type");
-            return GrPipelineAnalysisColor::Opaque::kNo;
+            return GrProcessorAnalysisColor::Opaque::kNo;
         }
 
     private:
@@ -149,7 +149,7 @@ public:
 
         ColorType outputColorType() const { return static_cast<ColorType>(fOutputColorType); }
 
-        void internalInit(const GrPipelineAnalysisColor&, const GrPipelineAnalysisCoverage,
+        void internalInit(const GrProcessorAnalysisColor&, const GrProcessorAnalysisCoverage,
                           const GrProcessorSet&, const GrFragmentProcessor* clipFP, const GrCaps&);
 
         // MSVS 2015 won't pack a bool with an unsigned.
@@ -174,15 +174,15 @@ public:
 
         friend class GrProcessorSet;
     };
-    GR_STATIC_ASSERT(sizeof(FragmentProcessorAnalysis) == 2 * sizeof(GrColor) + sizeof(uint32_t));
+    GR_STATIC_ASSERT(sizeof(Analysis) == 2 * sizeof(GrColor) + sizeof(uint32_t));
 
-    void analyzeAndEliminateFragmentProcessors(FragmentProcessorAnalysis*,
-                                               const GrPipelineAnalysisColor& colorInput,
-                                               const GrPipelineAnalysisCoverage coverageInput,
+    void analyzeAndEliminateFragmentProcessors(Analysis*,
+                                               const GrProcessorAnalysisColor& colorInput,
+                                               const GrProcessorAnalysisCoverage coverageInput,
                                                const GrAppliedClip*, const GrCaps&);
 
 private:
-    // This absurdly large limit allows FragmentProcessorAnalysis and this to pack fields together.
+    // This absurdly large limit allows Analysis and this to pack fields together.
     static constexpr int kMaxColorProcessors = UINT8_MAX;
 
     enum Flags : uint16_t {
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 13413287d7..352cac90af 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1724,7 +1724,7 @@ uint32_t GrRenderTargetContext::addMeshDrawOp(const GrPipelineBuilder& pipelineB
         }
     }
 
-    GrProcessorSet::FragmentProcessorAnalysis analysis;
+    GrProcessorSet::Analysis analysis;
     op->analyzeProcessors(&analysis, pipelineBuilder.processors(), &appliedClip, *this->caps());
 
     GrPipeline::InitArgs args;
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index fb9005172e..1ce258c113 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -172,8 +172,8 @@ SkString GrXferProcessor::BlendInfo::dump() const {
 
 GrXPFactory::AnalysisProperties GrXPFactory::GetAnalysisProperties(
         const GrXPFactory* factory,
-        const GrPipelineAnalysisColor& color,
-        const GrPipelineAnalysisCoverage& coverage,
+        const GrProcessorAnalysisColor& color,
+        const GrProcessorAnalysisCoverage& coverage,
         const GrCaps& caps) {
     AnalysisProperties result;
     if (factory) {
@@ -189,8 +189,8 @@ GrXPFactory::AnalysisProperties GrXPFactory::GetAnalysisProperties(
     return result;
 }
 
-GrXferProcessor* GrXPFactory::createXferProcessor(const GrPipelineAnalysisColor& color,
-                                                  GrPipelineAnalysisCoverage coverage,
+GrXferProcessor* GrXPFactory::createXferProcessor(const GrProcessorAnalysisColor& color,
+                                                  GrProcessorAnalysisCoverage coverage,
                                                   bool hasMixedSamples,
                                                   const DstTexture* dstTexture,
                                                   const GrCaps& caps) const {
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index 2033aeab08..622f760f46 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -48,8 +48,6 @@ GR_STATIC_ASSERT(SkToBool(kNone_GrXferBarrierType) == false);
  */
 class GrXferProcessor : public GrProcessor {
 public:
-    using FragmentProcessorAnalysis = GrProcessorSet::FragmentProcessorAnalysis;
-
     /**
      * A texture that contains the dst pixel values and an integer coord offset from device space
      * to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
@@ -264,12 +262,10 @@ private:
 #endif
 class GrXPFactory {
 public:
-    using FragmentProcessorAnalysis = GrProcessorSet::FragmentProcessorAnalysis;
-
     typedef GrXferProcessor::DstTexture DstTexture;
 
-    GrXferProcessor* createXferProcessor(const GrPipelineAnalysisColor&,
-                                         GrPipelineAnalysisCoverage,
+    GrXferProcessor* createXferProcessor(const GrProcessorAnalysisColor&,
+                                         GrProcessorAnalysisCoverage,
                                          bool hasMixedSamples,
                                          const DstTexture*,
                                          const GrCaps& caps) const;
@@ -285,8 +281,8 @@ public:
     GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(AnalysisProperties);
 
     static AnalysisProperties GetAnalysisProperties(const GrXPFactory*,
-                                                    const GrPipelineAnalysisColor&,
-                                                    const GrPipelineAnalysisCoverage&,
+                                                    const GrProcessorAnalysisColor&,
+                                                    const GrProcessorAnalysisCoverage&,
                                                     const GrCaps&);
 
 protected:
@@ -294,8 +290,8 @@ protected:
 
 private:
     virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
-                                                   const GrPipelineAnalysisColor&,
-                                                   GrPipelineAnalysisCoverage,
+                                                   const GrProcessorAnalysisColor&,
+                                                   GrProcessorAnalysisCoverage,
                                                    bool hasMixedSamples,
                                                    const DstTexture*) const = 0;
 
@@ -303,8 +299,8 @@ private:
      * Subclass analysis implementation. This should not return kNeedsDstInTexture as that will be
      * inferred by the base class based on kReadsDstInShader and the caps.
      */
-    virtual AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
-                                                  const GrPipelineAnalysisCoverage&,
+    virtual AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+                                                  const GrProcessorAnalysisCoverage&,
                                                   const GrCaps&) const = 0;
 };
 #if defined(__GNUC__) || defined(__clang)
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp
index 4d514fb7bc..1319c1fe58 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.cpp
+++ b/src/gpu/effects/GrCoverageSetOpXP.cpp
@@ -219,8 +219,8 @@ const GrXPFactory* GrCoverageSetOpXPFactory::Get(SkRegion::Op regionOp, bool inv
 }
 
 GrXferProcessor* GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrCaps& caps,
-                                                                 const GrPipelineAnalysisColor&,
-                                                                 GrPipelineAnalysisCoverage,
+                                                                 const GrProcessorAnalysisColor&,
+                                                                 GrProcessorAnalysisCoverage,
                                                                  bool hasMixedSamples,
                                                                  const DstTexture*) const {
     // We don't support inverting coverage with mixed samples. We don't expect to ever want this in
diff --git a/src/gpu/effects/GrCoverageSetOpXP.h b/src/gpu/effects/GrCoverageSetOpXP.h
index 16ccf203b8..2e1feed01e 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.h
+++ b/src/gpu/effects/GrCoverageSetOpXP.h
@@ -30,12 +30,12 @@ public:
 private:
     constexpr GrCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage);
 
-    GrXferProcessor* onCreateXferProcessor(const GrCaps&, const GrPipelineAnalysisColor&,
-                                           GrPipelineAnalysisCoverage, bool hasMixedSamples,
+    GrXferProcessor* onCreateXferProcessor(const GrCaps&, const GrProcessorAnalysisColor&,
+                                           GrProcessorAnalysisCoverage, bool hasMixedSamples,
                                            const DstTexture*) const override;
 
-    AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
-                                          const GrPipelineAnalysisCoverage&,
+    AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+                                          const GrProcessorAnalysisCoverage&,
                                           const GrCaps&) const override {
         return AnalysisProperties::kIgnoresInputColor;
     }
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 04718d4087..5ac31d82d1 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -52,12 +52,12 @@ static constexpr GrBlendEquation hw_blend_equation(SkBlendMode mode) {
 #undef EQ_OFFSET
 }
 
-static bool can_use_hw_blend_equation(GrBlendEquation equation, GrPipelineAnalysisCoverage coverage,
-                                      const GrCaps& caps) {
+static bool can_use_hw_blend_equation(GrBlendEquation equation,
+                                      GrProcessorAnalysisCoverage coverage, const GrCaps& caps) {
     if (!caps.advancedBlendEquationSupport()) {
         return false;
     }
-    if (GrPipelineAnalysisCoverage::kLCD == coverage) {
+    if (GrProcessorAnalysisCoverage::kLCD == coverage) {
         return false; // LCD coverage must be applied after the blend equation.
     }
     if (caps.canUseAdvancedBlendEquation(equation)) {
@@ -213,12 +213,12 @@ public:
             : fMode(mode), fHWBlendEquation(hw_blend_equation(mode)) {}
 
 private:
-    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
-                                           GrPipelineAnalysisCoverage, bool hasMixedSamples,
+    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+                                           GrProcessorAnalysisCoverage, bool hasMixedSamples,
                                            const DstTexture*) const override;
 
-    AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
-                                          const GrPipelineAnalysisCoverage&,
+    AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+                                          const GrProcessorAnalysisCoverage&,
                                           const GrCaps&) const override;
 
     GR_DECLARE_XP_FACTORY_TEST;
@@ -233,8 +233,8 @@ private:
 #endif
 
 GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
-                                                        const GrPipelineAnalysisColor&,
-                                                        GrPipelineAnalysisCoverage coverage,
+                                                        const GrProcessorAnalysisColor&,
+                                                        GrProcessorAnalysisCoverage coverage,
                                                         bool hasMixedSamples,
                                                         const DstTexture* dstTexture) const {
     SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
@@ -246,7 +246,7 @@ GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
 }
 
 GrXPFactory::AnalysisProperties CustomXPFactory::analysisProperties(
-        const GrPipelineAnalysisColor&, const GrPipelineAnalysisCoverage& coverage,
+        const GrProcessorAnalysisColor&, const GrProcessorAnalysisCoverage& coverage,
         const GrCaps& caps) const {
     /*
       The general SVG blend equation is defined in the spec as follows:
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index 71a50ebd08..4780b28647 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -82,8 +82,8 @@ void DisableColorXP::onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const
 
 ///////////////////////////////////////////////////////////////////////////////
 GrXferProcessor* GrDisableColorXPFactory::onCreateXferProcessor(const GrCaps& caps,
-                                                                const GrPipelineAnalysisColor&,
-                                                                GrPipelineAnalysisCoverage,
+                                                                const GrProcessorAnalysisColor&,
+                                                                GrProcessorAnalysisCoverage,
                                                                 bool hasMixedSamples,
                                                                 const DstTexture* dst) const {
     return DisableColorXP::Create();
diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h
index 85ddb6152f..ccd85c773a 100644
--- a/src/gpu/effects/GrDisableColorXP.h
+++ b/src/gpu/effects/GrDisableColorXP.h
@@ -24,15 +24,15 @@ public:
 private:
     constexpr GrDisableColorXPFactory() {}
 
-    AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
-                                          const GrPipelineAnalysisCoverage&,
+    AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+                                          const GrProcessorAnalysisCoverage&,
                                           const GrCaps&) const override {
         return AnalysisProperties::kCompatibleWithAlphaAsCoverage |
                AnalysisProperties::kIgnoresInputColor;
     }
 
-    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
-                                           GrPipelineAnalysisCoverage, bool hasMixedSamples,
+    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+                                           GrProcessorAnalysisCoverage, bool hasMixedSamples,
                                            const DstTexture* dstTexture) const override;
 
     GR_DECLARE_XP_FACTORY_TEST;
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index f2b3d7c306..646f9426fc 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -10,8 +10,8 @@
 #include "GrBlend.h"
 #include "GrCaps.h"
 #include "GrPipeline.h"
-#include "GrPipelineAnalysis.h"
 #include "GrProcessor.h"
+#include "GrProcessorAnalysis.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "glsl/GrGLSLBlend.h"
@@ -521,7 +521,8 @@ GrGLSLXferProcessor* ShaderPDXferProcessor::createGLSLInstance() const {
 
 class PDLCDXferProcessor : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(SkBlendMode xfermode, const GrPipelineAnalysisColor& inputColor);
+    static GrXferProcessor* Create(SkBlendMode xfermode,
+                                   const GrProcessorAnalysisColor& inputColor);
 
     ~PDLCDXferProcessor() override;
 
@@ -603,7 +604,7 @@ PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha)
 }
 
 GrXferProcessor* PDLCDXferProcessor::Create(SkBlendMode xfermode,
-                                            const GrPipelineAnalysisColor& color) {
+                                            const GrProcessorAnalysisColor& color) {
     if (SkBlendMode::kSrcOver != xfermode) {
         return nullptr;
     }
@@ -699,12 +700,12 @@ const GrXPFactory* GrPorterDuffXPFactory::Get(SkBlendMode blendMode) {
 }
 
 GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
-                                                              const GrPipelineAnalysisColor& color,
-                                                              GrPipelineAnalysisCoverage coverage,
+                                                              const GrProcessorAnalysisColor& color,
+                                                              GrProcessorAnalysisCoverage coverage,
                                                               bool hasMixedSamples,
                                                               const DstTexture* dstTexture) const {
     BlendFormula blendFormula;
-    if (coverage == GrPipelineAnalysisCoverage::kLCD) {
+    if (coverage == GrProcessorAnalysisCoverage::kLCD) {
         if (SkBlendMode::kSrcOver == fBlendMode && color.isConstant() &&
             !caps.shaderCaps()->dualSourceBlendingSupport() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
@@ -716,7 +717,7 @@ GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps
         blendFormula = get_lcd_blend_formula(fBlendMode);
     } else {
         blendFormula =
-                get_blend_formula(color.isOpaque(), GrPipelineAnalysisCoverage::kNone != coverage,
+                get_blend_formula(color.isOpaque(), GrProcessorAnalysisCoverage::kNone != coverage,
                                   hasMixedSamples, fBlendMode);
     }
 
@@ -729,11 +730,11 @@ GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps
 }
 
 static inline GrXPFactory::AnalysisProperties analysis_properties(
-        const GrPipelineAnalysisColor& color, const GrPipelineAnalysisCoverage& coverage,
+        const GrProcessorAnalysisColor& color, const GrProcessorAnalysisCoverage& coverage,
         const GrCaps& caps, SkBlendMode mode) {
     using AnalysisProperties = GrXPFactory::AnalysisProperties;
     AnalysisProperties props = AnalysisProperties::kNone;
-    bool hasCoverage = GrPipelineAnalysisCoverage::kNone != coverage;
+    bool hasCoverage = GrProcessorAnalysisCoverage::kNone != coverage;
     auto formula = gBlendTable[color.isOpaque()][hasCoverage][(int)mode];
     if (formula.canTweakAlphaForCoverage()) {
         props |= AnalysisProperties::kCompatibleWithAlphaAsCoverage;
@@ -744,7 +745,7 @@ static inline GrXPFactory::AnalysisProperties analysis_properties(
         // affect the formula used. However, we don't expect to have mixed samples without dual
         // source blending.
         SkASSERT(!caps.usesMixedSamples());
-        if (GrPipelineAnalysisCoverage::kLCD == coverage) {
+        if (GrProcessorAnalysisCoverage::kLCD == coverage) {
             // Check for special case of srcover with a known color which can be done using the
             // blend constant.
             if (SkBlendMode::kSrcOver == mode && color.isConstant()) {
@@ -771,8 +772,8 @@ static inline GrXPFactory::AnalysisProperties analysis_properties(
 }
 
 GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::analysisProperties(
-        const GrPipelineAnalysisColor& color,
-        const GrPipelineAnalysisCoverage& coverage,
+        const GrProcessorAnalysisColor& color,
+        const GrProcessorAnalysisCoverage& coverage,
         const GrCaps& caps) const {
     return analysis_properties(color, coverage, caps, fBlendMode);
 }
@@ -810,15 +811,15 @@ const GrXferProcessor& GrPorterDuffXPFactory::SimpleSrcOverXP() {
 
 GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
         const GrCaps& caps,
-        const GrPipelineAnalysisColor& color,
-        GrPipelineAnalysisCoverage coverage,
+        const GrProcessorAnalysisColor& color,
+        GrProcessorAnalysisCoverage coverage,
         bool hasMixedSamples,
         const GrXferProcessor::DstTexture* dstTexture) {
     // We want to not make an xfer processor if possible. Thus for the simple case where we are not
     // doing lcd blending we will just use our global SimpleSrcOverXP. This slightly differs from
     // the general case where we convert a src-over blend that has solid coverage and an opaque
     // color to src-mode, which allows disabling of blending.
-    if (coverage != GrPipelineAnalysisCoverage::kLCD) {
+    if (coverage != GrProcessorAnalysisCoverage::kLCD) {
         // We return nullptr here, which our caller interprets as meaning "use SimpleSrcOverXP".
         // We don't simply return the address of that XP here because our caller would have to unref
         // it and since it is a global object and GrProgramElement's ref-cnting system is not thread
@@ -851,8 +852,8 @@ sk_sp<GrXferProcessor> GrPorterDuffXPFactory::CreateNoCoverageXP(SkBlendMode ble
 }
 
 GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::SrcOverAnalysisProperties(
-        const GrPipelineAnalysisColor& color,
-        const GrPipelineAnalysisCoverage& coverage,
+        const GrProcessorAnalysisColor& color,
+        const GrProcessorAnalysisCoverage& coverage,
         const GrCaps& caps) {
     return analysis_properties(color, coverage, caps, SkBlendMode::kSrcOver);
 }
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.h b/src/gpu/effects/GrPorterDuffXferProcessor.h
index 0d671a39e6..d42146a32d 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.h
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.h
@@ -24,8 +24,8 @@ public:
     /** Because src-over is so common we special case it for performance reasons. If this returns
         null then the SimpleSrcOverXP() below should be used. */
     static GrXferProcessor* CreateSrcOverXferProcessor(const GrCaps& caps,
-                                                       const GrPipelineAnalysisColor& color,
-                                                       GrPipelineAnalysisCoverage coverage,
+                                                       const GrProcessorAnalysisColor& color,
+                                                       GrProcessorAnalysisCoverage coverage,
                                                        bool hasMixedSamples,
                                                        const GrXferProcessor::DstTexture*);
 
@@ -36,19 +36,19 @@ public:
         by reference because it is global and its ref-cnting methods are not thread safe. */
     static const GrXferProcessor& SimpleSrcOverXP();
 
-    static AnalysisProperties SrcOverAnalysisProperties(const GrPipelineAnalysisColor&,
-                                                        const GrPipelineAnalysisCoverage&,
+    static AnalysisProperties SrcOverAnalysisProperties(const GrProcessorAnalysisColor&,
+                                                        const GrProcessorAnalysisCoverage&,
                                                         const GrCaps&);
 
 private:
     constexpr GrPorterDuffXPFactory(SkBlendMode);
 
-    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
-                                           GrPipelineAnalysisCoverage, bool hasMixedSamples,
+    GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+                                           GrProcessorAnalysisCoverage, bool hasMixedSamples,
                                            const DstTexture*) const override;
 
-    AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
-                                          const GrPipelineAnalysisCoverage&,
+    AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+                                          const GrProcessorAnalysisCoverage&,
                                           const GrCaps&) const override;
 
     GR_DECLARE_XP_FACTORY_TEST;
diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp
index f6ea6285d0..ad61eb6dfd 100644
--- a/src/gpu/instanced/InstancedRendering.cpp
+++ b/src/gpu/instanced/InstancedRendering.cpp
@@ -331,13 +331,13 @@ void InstancedRendering::Op::appendParamsTexel(SkScalar x, SkScalar y, SkScalar
 }
 
 bool InstancedRendering::Op::xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) {
-    GrProcessorSet::FragmentProcessorAnalysis analysis;
-    GrPipelineAnalysisCoverage coverageInput;
+    GrProcessorSet::Analysis analysis;
+    GrProcessorAnalysisCoverage coverageInput;
     if (GrAAType::kCoverage == fInfo.aaType() ||
         (GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
-        coverageInput = GrPipelineAnalysisCoverage::kSingleChannel;
+        coverageInput = GrProcessorAnalysisCoverage::kSingleChannel;
     } else {
-        coverageInput = GrPipelineAnalysisCoverage::kNone;
+        coverageInput = GrProcessorAnalysisCoverage::kNone;
     }
     fProcessors.analyzeAndEliminateFragmentProcessors(&analysis, this->getSingleInstance().fColor,
                                                       coverageInput, clip, caps);
@@ -407,7 +407,7 @@ bool InstancedRendering::Op::onCombineIfPossible(GrOp* other, const GrCaps& caps
     this->joinBounds(*that);
     fInfo = combinedInfo;
     fPixelLoad += that->fPixelLoad;
-    fAnalysisColor = GrPipelineAnalysisColor::Combine(fAnalysisColor, that->fAnalysisColor);
+    fAnalysisColor = GrProcessorAnalysisColor::Combine(fAnalysisColor, that->fAnalysisColor);
     // Adopt the other op's draws.
     fNumDraws += that->fNumDraws;
     fNumChangesInGeometry += that->fNumChangesInGeometry;
@@ -465,13 +465,13 @@ void InstancedRendering::Op::onExecute(GrOpFlushState* state) {
     state->gpu()->handleDirtyContext();
 
     const GrAppliedClip* clip = state->drawOpArgs().fAppliedClip;
-    GrPipelineAnalysisCoverage coverage;
+    GrProcessorAnalysisCoverage coverage;
     if (GrAAType::kCoverage == fInfo.aaType() ||
         (clip && clip->clipCoverageFragmentProcessor()) ||
         (GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
-        coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     } else {
-        coverage = GrPipelineAnalysisCoverage::kNone;
+        coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     GrPipeline pipeline;
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index 2fa433f465..caff08f483 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -151,7 +151,7 @@ protected:
         OpInfo fInfo;
         SkScalar fPixelLoad;
         GrProcessorSet fProcessors;
-        GrPipelineAnalysisColor fAnalysisColor;
+        GrProcessorAnalysisColor fAnalysisColor;
         SkSTArray<5, ParamsTexel, true> fParams;
         bool fIsTracked;
         int fNumDraws;
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 09d8267b25..3b0fd692f5 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -747,10 +747,10 @@ private:
         this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index 991912923e..b48ec0e7fe 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -203,10 +203,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(this->first()->color());
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void onPrepareDraws(Target* target) const override {
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index a243228298..9e1ac83c02 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -710,10 +710,10 @@ private:
                                    IsZeroArea::kYes);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index a62a41c911..b1f1f98f03 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -172,10 +172,10 @@ private:
         this->setTransformedBounds(bounds, viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fPaths[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 5866b0d1f3..ce0cef61bf 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -174,10 +174,10 @@ public:
 private:
     AAStrokeRectOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fRects[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
     void applyPipelineOptimizations(const PipelineOptimizations&) override;
     void onPrepareDraws(Target*) const override;
diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp
index 618414445c..85da29c4e1 100644
--- a/src/gpu/ops/GrAnalyticRectOp.cpp
+++ b/src/gpu/ops/GrAnalyticRectOp.cpp
@@ -269,10 +269,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index 903382add7..bf2745bda8 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -46,8 +46,8 @@ SkString GrAtlasTextOp::dumpInfo() const {
     return str;
 }
 
-void GrAtlasTextOp::getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                                       GrPipelineAnalysisCoverage* coverage) const {
+void GrAtlasTextOp::getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                               GrProcessorAnalysisCoverage* coverage) const {
     if (kColorBitmapMask_MaskType == fMaskType) {
         color->setToUnknown();
     } else {
@@ -56,14 +56,14 @@ void GrAtlasTextOp::getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*
     switch (fMaskType) {
         case kGrayscaleDistanceField_MaskType:
         case kGrayscaleCoverageMask_MaskType:
-            *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+            *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
             break;
         case kLCDCoverageMask_MaskType:
         case kLCDDistanceField_MaskType:
-            *coverage = GrPipelineAnalysisCoverage::kLCD;
+            *coverage = GrProcessorAnalysisCoverage::kLCD;
             break;
         case kColorBitmapMask_MaskType:
-            *coverage = GrPipelineAnalysisCoverage::kNone;
+            *coverage = GrProcessorAnalysisCoverage::kNone;
             break;
     }
 }
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index 9dc5631c76..452cfbd5a0 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -99,8 +99,8 @@ public:
     SkString dumpInfo() const override;
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*,
-                                            GrPipelineAnalysisCoverage*) const override;
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor*,
+                                    GrProcessorAnalysisCoverage*) const override;
     void applyPipelineOptimizations(const PipelineOptimizations&) override;
 
     struct FlushInfo {
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index e623007f8d..3e8c07e8cc 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -296,10 +296,10 @@ private:
         this->setTransformedBounds(bounds, combinedMatrix, aaBloat, zeroArea);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 79ad4843bd..f33fc66e08 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -132,11 +132,11 @@ private:
                         isHairline ? IsZeroArea::kYes : IsZeroArea::kNo);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = this->coverage() == 0xff ? GrPipelineAnalysisCoverage::kNone
-                                             : GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = this->coverage() == 0xff ? GrProcessorAnalysisCoverage::kNone
+                                             : GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h
index 1094db0c4d..7d60974350 100644
--- a/src/gpu/ops/GrDrawAtlasOp.h
+++ b/src/gpu/ops/GrDrawAtlasOp.h
@@ -39,14 +39,14 @@ private:
     GrDrawAtlasOp(GrColor color, const SkMatrix& viewMatrix, int spriteCount,
                   const SkRSXform* xforms, const SkRect* rects, const SkColor* colors);
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         if (this->hasColors()) {
             color->setToUnknown();
         } else {
             color->setToConstant(fGeoData[0].fColor);
         }
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void onPrepareDraws(Target*) const override;
diff --git a/src/gpu/ops/GrDrawPathOp.cpp b/src/gpu/ops/GrDrawPathOp.cpp
index 8bc1f83563..81a2de0dc8 100644
--- a/src/gpu/ops/GrDrawPathOp.cpp
+++ b/src/gpu/ops/GrDrawPathOp.cpp
@@ -38,7 +38,7 @@ void GrDrawPathOpBase::initPipeline(const GrOpFlushState& state, GrPipeline* pip
                     0xffff>()
     };
     GrPipeline::InitArgs args;
-    auto analysis = this->fragmentProcessorAnalysis();
+    auto analysis = this->processorAnalysis();
     args.fProcessors = &this->processors();
     args.fFlags = GrAA::kYes == fAA ? GrPipeline::kHWAntialias_Flag : 0;
     args.fUserStencil = &kCoverPass;
@@ -146,7 +146,7 @@ bool GrDrawPathRangeOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
         GrPathRendering::kWinding_FillType != that->fillType()) {
         return false;
     }
-    if (!this->fragmentProcessorAnalysis().canCombineOverlappedStencilAndCover()) {
+    if (!this->processorAnalysis().canCombineOverlappedStencilAndCover()) {
         return false;
     }
     fTotalPathCount += that->fTotalPathCount;
diff --git a/src/gpu/ops/GrDrawPathOp.h b/src/gpu/ops/GrDrawPathOp.h
index 78ed035bbe..0631adcdf6 100644
--- a/src/gpu/ops/GrDrawPathOp.h
+++ b/src/gpu/ops/GrDrawPathOp.h
@@ -29,7 +29,7 @@ protected:
         return FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil;
     }
     bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
-        return this->doFragmentProcessorAnalysis(caps, clip).requiresDstTexture();
+        return this->doProcessorAnalysis(caps, clip).requiresDstTexture();
     }
 
     void wasRecorded() override { fProcessorSet.makePendingExecution(); }
@@ -40,13 +40,13 @@ protected:
     GrPathRendering::FillType fillType() const { return fFillType; }
     const GrProcessorSet& processors() const { return fProcessorSet; }
     void initPipeline(const GrOpFlushState&, GrPipeline*);
-    const GrProcessorSet::FragmentProcessorAnalysis& doFragmentProcessorAnalysis(
-            const GrCaps& caps, const GrAppliedClip* clip) {
+    const GrProcessorSet::Analysis& doProcessorAnalysis(const GrCaps& caps,
+                                                        const GrAppliedClip* clip) {
         fProcessorSet.analyzeAndEliminateFragmentProcessors(
-                &fAnalysis, fAnalysis.inputColor(), GrPipelineAnalysisCoverage::kNone, clip, caps);
+                &fAnalysis, fAnalysis.inputColor(), GrProcessorAnalysisCoverage::kNone, clip, caps);
         return fAnalysis;
     }
-    const GrProcessorSet::FragmentProcessorAnalysis& fragmentProcessorAnalysis() const {
+    const GrProcessorSet::Analysis& processorAnalysis() const {
         SkASSERT(fAnalysis.isInitializedWithProcessorSet());
         return fAnalysis;
     }
@@ -56,7 +56,7 @@ private:
 
     SkMatrix fViewMatrix;
     GrProcessorSet fProcessorSet;
-    GrProcessorSet::FragmentProcessorAnalysis fAnalysis;
+    GrProcessorSet::Analysis fAnalysis;
     GrPathRendering::FillType fFillType;
     GrAA fAA;
 
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 6751009d37..1af49d2c12 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -74,14 +74,14 @@ GrDrawVerticesOp::GrDrawVerticesOp(sk_sp<SkVertices> vertices, GrPrimitiveType p
     this->setTransformedBounds(mesh.fVertices->bounds(), viewMatrix, HasAABloat::kNo, zeroArea);
 }
 
-void GrDrawVerticesOp::getFragmentProcessorAnalysisInputs(
-        GrPipelineAnalysisColor* color, GrPipelineAnalysisCoverage* coverage) const {
+void GrDrawVerticesOp::getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                                  GrProcessorAnalysisCoverage* coverage) const {
     if (this->requiresPerVertexColors()) {
         color->setToUnknown();
     } else {
         color->setToConstant(fMeshes[0].fColor);
     }
-    *coverage = GrPipelineAnalysisCoverage::kNone;
+    *coverage = GrProcessorAnalysisCoverage::kNone;
 }
 
 void GrDrawVerticesOp::applyPipelineOptimizations(const PipelineOptimizations& optimizations) {
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index 17e54b705a..2c4d1c905b 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -70,8 +70,8 @@ private:
                      GrRenderTargetContext::ColorArrayType, const SkMatrix& viewMatrix,
                      uint32_t flags = 0);
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override;
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override;
     void applyPipelineOptimizations(const PipelineOptimizations&) override;
     void onPrepareDraws(Target*) const override;
 
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 85ddd9d612..6dce60e987 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -61,10 +61,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToUnknown();
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& analysioptimizations) override {
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index 9f20808119..8cbe2a3a7d 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -259,10 +259,10 @@ private:
         this->setBounds(devBounds, HasAABloat::kNo, IsZeroArea::kNo);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fPaths[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrMeshDrawOp.h b/src/gpu/ops/GrMeshDrawOp.h
index 2632feb3b7..a8da29a39f 100644
--- a/src/gpu/ops/GrMeshDrawOp.h
+++ b/src/gpu/ops/GrMeshDrawOp.h
@@ -29,13 +29,13 @@ public:
      * Performs analysis of the fragment processors in GrProcessorSet and GrAppliedClip using the
      * initial color and coverage from this op's geometry processor.
      */
-    void analyzeProcessors(GrProcessorSet::FragmentProcessorAnalysis* analysis,
+    void analyzeProcessors(GrProcessorSet::Analysis* analysis,
                            const GrProcessorSet& processors,
                            const GrAppliedClip* appliedClip,
                            const GrCaps& caps) const {
-        GrPipelineAnalysisColor inputColor;
-        GrPipelineAnalysisCoverage inputCoverage;
-        this->getFragmentProcessorAnalysisInputs(&inputColor, &inputCoverage);
+        GrProcessorAnalysisColor inputColor;
+        GrProcessorAnalysisCoverage inputCoverage;
+        this->getProcessorAnalysisInputs(&inputColor, &inputCoverage);
         analysis->init(inputColor, inputCoverage, processors, appliedClip, caps);
     }
 
@@ -61,11 +61,11 @@ protected:
     GrMeshDrawOp(uint32_t classID);
     /**
      * This is a legacy class only used by GrMeshDrawOp and will be removed. It presents some
-     * aspects of GrProcessorSet::FragmentProcessorAnalysis to GrMeshDrawOp subclasses.
+     * aspects of GrProcessorSet::Analysis to GrMeshDrawOp subclasses.
      */
     class PipelineOptimizations {
     public:
-        PipelineOptimizations(const GrProcessorSet::FragmentProcessorAnalysis& analysis) {
+        PipelineOptimizations(const GrProcessorSet::Analysis& analysis) {
             fFlags = 0;
             if (analysis.getInputColorOverrideAndColorProcessorEliminationCount(&fOverrideColor) >=
                 0) {
@@ -161,11 +161,11 @@ private:
      * Provides information about the GrPrimitiveProccesor color and coverage outputs which become
      * inputs to the first color and coverage fragment processors.
      */
-    virtual void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*,
-                                                    GrPipelineAnalysisCoverage*) const = 0;
+    virtual void getProcessorAnalysisInputs(GrProcessorAnalysisColor*,
+                                            GrProcessorAnalysisCoverage*) const = 0;
 
     /**
-     * After GrPipeline analysis is complete this is called so that the op can use the analysis
+     * After processor analysis is complete this is called so that the op can use the analysis
      * results when constructing its GrPrimitiveProcessor.
      */
     virtual void applyPipelineOptimizations(const PipelineOptimizations&) = 0;
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 66a85156ba..c5227945b3 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -110,10 +110,10 @@ public:
 private:
     NonAAFillRectOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fRects[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
index 9ccc743ef0..a7c445c170 100644
--- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
@@ -130,10 +130,10 @@ public:
 private:
     NonAAFillRectPerspectiveOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fRects[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index 940afee780..ffabad1dd5 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -102,10 +102,10 @@ public:
 private:
     NonAAStrokeRectOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void onPrepareDraws(Target* target) const override {
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index de4e4ea2f7..5ede5e152a 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -805,10 +805,10 @@ public:
 private:
     CircleOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1257,10 +1257,10 @@ public:
 private:
     EllipseOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1472,10 +1472,10 @@ public:
 private:
     DIEllipseOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1788,10 +1788,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -2152,10 +2152,10 @@ public:
 private:
     EllipticalRRectOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index 88f96bf40c..ba153a62e2 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -77,10 +77,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fRegions[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kNone;
+        *coverage = GrProcessorAnalysisCoverage::kNone;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 56855a1324..9b2bc824c9 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -142,10 +142,10 @@ public:
 private:
     ShadowCircleOp() : INHERITED(ClassID()) {}
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fCircles[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -563,10 +563,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fGeoData[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 408bcfefe7..ced9b4ebd7 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -199,10 +199,10 @@ private:
 
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fShapes[0].fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 96fe8ab251..9f3b1d6e1d 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -180,10 +180,10 @@ public:
     }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrTestMeshDrawOp.h b/src/gpu/ops/GrTestMeshDrawOp.h
index 8273abaed8..5ca4af754f 100644
--- a/src/gpu/ops/GrTestMeshDrawOp.h
+++ b/src/gpu/ops/GrTestMeshDrawOp.h
@@ -33,10 +33,10 @@ protected:
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToConstant(fColor);
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index 9268dd4d0b..a2ba9167bb 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -59,10 +59,9 @@ class GrPorterDuffTest {
 public:
     struct XPInfo {
         XPInfo(skiatest::Reporter* reporter, SkBlendMode xfermode, const GrCaps& caps,
-               GrPipelineAnalysisColor inputColor, GrPipelineAnalysisCoverage inputCoverage) {
+               GrProcessorAnalysisColor inputColor, GrProcessorAnalysisCoverage inputCoverage) {
             const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
-            GrProcessorSet::FragmentProcessorAnalysis analysis(inputColor, inputCoverage, xpf,
-                                                               caps);
+            GrProcessorSet::Analysis analysis(inputColor, inputCoverage, xpf, caps);
             fCompatibleWithCoverageAsAlpha = analysis.isCompatibleWithCoverageAsAlpha();
             fCanCombineOverlappedStencilAndCover = analysis.canCombineOverlappedStencilAndCover();
             fIgnoresInputColor = analysis.isInputColorIgnored();
@@ -89,8 +88,8 @@ public:
 };
 
 static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
-    GrPipelineAnalysisColor inputColor = GrPipelineAnalysisColor::Opaque::kNo;
-    GrPipelineAnalysisCoverage inputCoverage = GrPipelineAnalysisCoverage::kLCD;
+    GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kNo;
+    GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kLCD;
 
     for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
         SkBlendMode xfermode = static_cast<SkBlendMode>(m);
@@ -268,8 +267,8 @@ static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps)
     }
 }
 static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
-    GrPipelineAnalysisColor inputColor = GrPipelineAnalysisColor::Opaque::kNo;
-    GrPipelineAnalysisCoverage inputCoverage = GrPipelineAnalysisCoverage::kSingleChannel;
+    GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kNo;
+    GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
 
     for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
         SkBlendMode xfermode = static_cast<SkBlendMode>(m);
@@ -448,8 +447,8 @@ static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const
 }
 
 static void test_color_not_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
-    GrPipelineAnalysisColor inputColor(GrColorPackRGBA(229, 0, 154, 240));
-    GrPipelineAnalysisCoverage inputCoverage = GrPipelineAnalysisCoverage::kNone;
+    GrProcessorAnalysisColor inputColor(GrColorPackRGBA(229, 0, 154, 240));
+    GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kNone;
 
     for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
         SkBlendMode xfermode = static_cast<SkBlendMode>(m);
@@ -628,8 +627,8 @@ static void test_color_not_opaque_no_coverage(skiatest::Reporter* reporter, cons
 }
 
 static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
-    GrPipelineAnalysisColor inputColor = GrPipelineAnalysisColor::Opaque::kYes;
-    GrPipelineAnalysisCoverage inputCoverage = GrPipelineAnalysisCoverage::kSingleChannel;
+    GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kYes;
+    GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
 
     for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
         SkBlendMode xfermode = static_cast<SkBlendMode>(m);
@@ -807,8 +806,8 @@ static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const
 }
 
 static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
-    GrPipelineAnalysisColor inputColor = GrPipelineAnalysisColor::Opaque::kYes;
-    GrPipelineAnalysisCoverage inputCoverage = GrPipelineAnalysisCoverage::kNone;
+    GrProcessorAnalysisColor inputColor = GrProcessorAnalysisColor::Opaque::kYes;
+    GrProcessorAnalysisCoverage inputCoverage = GrProcessorAnalysisCoverage::kNone;
 
     for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
         SkBlendMode xfermode = static_cast<SkBlendMode>(m);
@@ -989,8 +988,8 @@ static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const Gr
 
 static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const GrCaps& caps) {
     const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(SkBlendMode::kSrcOver);
-    GrPipelineAnalysisColor color = GrColorPackRGBA(123, 45, 67, 221);
-    GrPipelineAnalysisCoverage coverage = GrPipelineAnalysisCoverage::kLCD;
+    GrProcessorAnalysisColor color = GrColorPackRGBA(123, 45, 67, 221);
+    GrProcessorAnalysisCoverage coverage = GrProcessorAnalysisCoverage::kLCD;
     SkASSERT(!(GrXPFactory::GetAnalysisProperties(xpf, color, coverage, caps) &
                GrXPFactory::AnalysisProperties::kRequiresDstTexture));
     sk_sp<GrXferProcessor> xp(xpf->createXferProcessor(color, coverage, false, nullptr, caps));
@@ -1030,20 +1029,19 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, /*factory*/) {
     fakeDstTexture.setTexture(
         ctx->resourceProvider()->wrapBackendTexture(fakeDesc, kBorrow_GrWrapOwnership));
 
-    static const GrPipelineAnalysisColor colorInputs[] = {
-            GrPipelineAnalysisColor::Opaque::kNo, GrPipelineAnalysisColor::Opaque::kYes,
-            GrPipelineAnalysisColor(GrColorPackRGBA(0, 82, 17, 100)),
-            GrPipelineAnalysisColor(GrColorPackRGBA(0, 82, 17, 255))};
+    static const GrProcessorAnalysisColor colorInputs[] = {
+            GrProcessorAnalysisColor::Opaque::kNo, GrProcessorAnalysisColor::Opaque::kYes,
+            GrProcessorAnalysisColor(GrColorPackRGBA(0, 82, 17, 100)),
+            GrProcessorAnalysisColor(GrColorPackRGBA(0, 82, 17, 255))};
 
     for (const auto& colorInput : colorInputs) {
-        for (GrPipelineAnalysisCoverage coverageType :
-             {GrPipelineAnalysisCoverage::kSingleChannel, GrPipelineAnalysisCoverage::kNone}) {
+        for (GrProcessorAnalysisCoverage coverageType :
+             {GrProcessorAnalysisCoverage::kSingleChannel, GrProcessorAnalysisCoverage::kNone}) {
             for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
                 SkBlendMode xfermode = static_cast<SkBlendMode>(m);
                 const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
-                GrProcessorSet::FragmentProcessorAnalysis analysis;
-                analysis = GrProcessorSet::FragmentProcessorAnalysis(colorInput, coverageType, xpf,
-                                                                     caps);
+                GrProcessorSet::Analysis analysis;
+                analysis = GrProcessorSet::Analysis(colorInput, coverageType, xpf, caps);
                 GrXferProcessor::DstTexture* dstTexture =
                         analysis.requiresDstTexture() ? &fakeDstTexture : nullptr;
                 sk_sp<GrXferProcessor> xp(xpf->createXferProcessor(colorInput, coverageType, false,
diff --git a/tests/PreFlushCallbackTest.cpp b/tests/PreFlushCallbackTest.cpp
index 7c4092cca2..e5acae9e42 100644
--- a/tests/PreFlushCallbackTest.cpp
+++ b/tests/PreFlushCallbackTest.cpp
@@ -64,10 +64,10 @@ protected:
     SkRect  fRect;
 
 private:
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToUnknown();
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp
index 2b4e3494a8..337c8b93cf 100644
--- a/tests/PrimitiveProcessorTest.cpp
+++ b/tests/PrimitiveProcessorTest.cpp
@@ -40,10 +40,10 @@ private:
         this->setBounds(SkRect::MakeWH(1.f, 1.f), HasAABloat::kNo, IsZeroArea::kNo);
     }
 
-    void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
-                                            GrPipelineAnalysisCoverage* coverage) const override {
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                    GrProcessorAnalysisCoverage* coverage) const override {
         color->setToUnknown();
-        *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+        *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
     }
 
     void applyPipelineOptimizations(const PipelineOptimizations&) override {}