Revert "Make GrAtlasTextOp a non-legacy GrMeshDrawOp"

This reverts commit 434a58ab5fefcc1b86588c7fce898b1e5bd248ba.

Reason for revert: <INSERT REASONING HERE>

Original change's description:
> Make GrAtlasTextOp a non-legacy GrMeshDrawOp
> 
> Change-Id: Ib9eaf149100b0ccecf1c18a755263f2579b8e6f6
> Reviewed-on: https://skia-review.googlesource.com/23482
> Reviewed-by: Jim Van Verth <jvanverth@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>

TBR=jvanverth@google.com,bsalomon@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: I7fd8503b4e0c297b2cfaf979545354aa58d1f989
Reviewed-on: https://skia-review.googlesource.com/23760
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

2 files changed, 49 insertions, 62 deletions

diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index a7b4967143..9c4172ceaf 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -34,45 +34,40 @@ SkString GrAtlasTextOp::dumpInfo() const {
                     fGeoData[i].fBlob->runCount());
     }
 
-    str += fProcessors.dumpProcessors();
-    str += INHERITED::dumpInfo();
+    str.append(DumpPipelineInfo(*this->pipeline()));
+    str.append(INHERITED::dumpInfo());
     return str;
 }
 
-GrDrawOp::FixedFunctionFlags GrAtlasTextOp::fixedFunctionFlags() const {
-    return FixedFunctionFlags::kNone;
-}
-
-GrDrawOp::RequiresDstTexture GrAtlasTextOp::finalize(const GrCaps& caps,
-                                                     const GrAppliedClip* clip) {
-    GrProcessorAnalysisCoverage coverage;
-    GrProcessorAnalysisColor color;
+void GrAtlasTextOp::getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+                                               GrProcessorAnalysisCoverage* coverage) const {
     if (kColorBitmapMask_MaskType == fMaskType) {
-        color.setToUnknown();
+        color->setToUnknown();
     } else {
-        color.setToConstant(fColor);
+        color->setToConstant(fColor);
     }
     switch (fMaskType) {
         case kGrayscaleCoverageMask_MaskType:
         case kAliasedDistanceField_MaskType:
         case kGrayscaleDistanceField_MaskType:
-            coverage = GrProcessorAnalysisCoverage::kSingleChannel;
+            *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
             break;
         case kLCDCoverageMask_MaskType:
         case kLCDDistanceField_MaskType:
         case kLCDBGRDistanceField_MaskType:
-            coverage = GrProcessorAnalysisCoverage::kLCD;
+            *coverage = GrProcessorAnalysisCoverage::kLCD;
             break;
         case kColorBitmapMask_MaskType:
-            coverage = GrProcessorAnalysisCoverage::kNone;
+            *coverage = GrProcessorAnalysisCoverage::kNone;
             break;
     }
-    auto analysis = fProcessors.finalize(color, coverage, clip, false, caps, &fColor);
-    fUsesLocalCoords = analysis.usesLocalCoords();
-    fCanCombineOnTouchOrOverlap =
-            !analysis.requiresDstTexture() &&
-            !(fProcessors.xferProcessor() && fProcessors.xferProcessor()->xferBarrierType(caps));
-    return analysis.requiresDstTexture() ? RequiresDstTexture::kYes : RequiresDstTexture::kNo;
+}
+
+void GrAtlasTextOp::applyPipelineOptimizations(const PipelineOptimizations& optimizations) {
+    optimizations.getOverrideColorIfSet(&fGeoData[0].fColor);
+
+    fColor = fGeoData[0].fColor;
+    fUsesLocalCoords = optimizations.readsLocalCoords();
 }
 
 void GrAtlasTextOp::onPrepareDraws(Target* target) const {
@@ -93,16 +88,15 @@ void GrAtlasTextOp::onPrepareDraws(Target* target) const {
     GrMaskFormat maskFormat = this->maskFormat();
 
     FlushInfo flushInfo;
-    flushInfo.fPipeline = target->makePipeline(fSRGBFlags, &fProcessors);
     if (this->usesDistanceFields()) {
         flushInfo.fGeometryProcessor =
                 this->setupDfProcessor(this->viewMatrix(),
                                        fLuminanceColor, this->color(), std::move(proxy));
     } else {
         GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode);
-        flushInfo.fGeometryProcessor =
-                GrBitmapTextGeoProc::Make(this->color(), std::move(proxy), params, maskFormat,
-                                          localMatrix, this->usesLocalCoords());
+        flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
+                this->color(), std::move(proxy), params,
+                maskFormat, localMatrix, this->usesLocalCoords());
     }
 
     flushInfo.fGlyphsToFlush = 0;
@@ -151,18 +145,15 @@ void GrAtlasTextOp::flush(GrLegacyMeshDrawOp::Target* target, FlushInfo* flushIn
     mesh.setIndexedPatterned(flushInfo->fIndexBuffer.get(), kIndicesPerGlyph, kVerticesPerGlyph,
                              flushInfo->fGlyphsToFlush, maxGlyphsPerDraw);
     mesh.setVertexData(flushInfo->fVertexBuffer.get(), flushInfo->fVertexOffset);
-    target->draw(flushInfo->fGeometryProcessor.get(), flushInfo->fPipeline, mesh);
+    target->draw(flushInfo->fGeometryProcessor.get(), this->pipeline(), mesh);
     flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
     flushInfo->fGlyphsToFlush = 0;
 }
 
 bool GrAtlasTextOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
     GrAtlasTextOp* that = t->cast<GrAtlasTextOp>();
-    if (fProcessors != that->fProcessors) {
-        return false;
-    }
-
-    if (!fCanCombineOnTouchOrOverlap && GrRectsTouchOrOverlap(this->bounds(), that->bounds())) {
+    if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                that->bounds(), caps)) {
         return false;
     }
 
@@ -248,8 +239,9 @@ sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(const SkMatrix& viewM
                 GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(
                         redCorrection, greenCorrection, blueCorrection);
 
-        return GrDistanceFieldLCDTextGeoProc::Make(color, viewMatrix, std::move(proxy), params,
-                                                   widthAdjust, flags, this->usesLocalCoords());
+        return GrDistanceFieldLCDTextGeoProc::Make(color, viewMatrix, std::move(proxy),
+                                                   params, widthAdjust, flags,
+                                                   this->usesLocalCoords());
     } else {
 #ifdef SK_GAMMA_APPLY_TO_A8
         float correction = 0;
@@ -258,8 +250,10 @@ sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(const SkMatrix& viewM
             correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift,
                                                              fUseGammaCorrectDistanceTable);
         }
-        return GrDistanceFieldA8TextGeoProc::Make(color, viewMatrix, std::move(proxy), params,
-                                                  correction, flags, this->usesLocalCoords());
+        return GrDistanceFieldA8TextGeoProc::Make(color,
+                                                  viewMatrix, std::move(proxy),
+                                                  params, correction, flags,
+                                                  this->usesLocalCoords());
 #else
         return GrDistanceFieldA8TextGeoProc::Make(color,
                                                   viewMatrix, std::move(proxy),
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index 449f1fa0ab..24166a19d9 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -9,10 +9,11 @@
 #define GrAtlasTextOp_DEFINED
 
 #include "ops/GrMeshDrawOp.h"
+
 #include "text/GrAtlasTextContext.h"
 #include "text/GrDistanceFieldAdjustTable.h"
 
-class GrAtlasTextOp final : public GrMeshDrawOp {
+class GrAtlasTextOp final : public GrLegacyMeshDrawOp {
 public:
     DEFINE_OP_CLASS_ID
 
@@ -36,9 +37,9 @@ public:
         GrColor fColor;
     };
 
-    static std::unique_ptr<GrAtlasTextOp> MakeBitmap(GrPaint&& paint, GrMaskFormat maskFormat,
-                                                     int glyphCount, GrAtlasGlyphCache* fontCache) {
-        std::unique_ptr<GrAtlasTextOp> op(new GrAtlasTextOp(std::move(paint)));
+    static std::unique_ptr<GrAtlasTextOp> MakeBitmap(GrMaskFormat maskFormat, int glyphCount,
+                                                     GrAtlasGlyphCache* fontCache) {
+        std::unique_ptr<GrAtlasTextOp> op(new GrAtlasTextOp);
 
         op->fFontCache = fontCache;
         switch (maskFormat) {
@@ -60,11 +61,11 @@ public:
     }
 
     static std::unique_ptr<GrAtlasTextOp> MakeDistanceField(
-            GrPaint&& paint, int glyphCount, GrAtlasGlyphCache* fontCache,
+            int glyphCount, GrAtlasGlyphCache* fontCache,
             const GrDistanceFieldAdjustTable* distanceAdjustTable,
             bool useGammaCorrectDistanceTable, SkColor luminanceColor, bool isLCD, bool useBGR,
             bool isAntiAliased) {
-        std::unique_ptr<GrAtlasTextOp> op(new GrAtlasTextOp(std::move(paint)));
+        std::unique_ptr<GrAtlasTextOp> op(new GrAtlasTextOp);
 
         op->fFontCache = fontCache;
         op->fMaskType = !isAntiAliased ? kAliasedDistanceField_MaskType
@@ -99,28 +100,23 @@ public:
 
     SkString dumpInfo() const override;
 
-    FixedFunctionFlags fixedFunctionFlags() const override;
-
-    RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override;
-
 private:
-    GrAtlasTextOp(GrPaint&& paint)
-            : INHERITED(ClassID())
-            , fColor(paint.getColor())
-            , fSRGBFlags(GrPipeline::SRGBFlagsFromPaint(paint))
-            , fProcessors(std::move(paint)) {}
+    void getProcessorAnalysisInputs(GrProcessorAnalysisColor*,
+                                    GrProcessorAnalysisCoverage*) const override;
+    void applyPipelineOptimizations(const PipelineOptimizations&) override;
 
     struct FlushInfo {
         sk_sp<const GrBuffer> fVertexBuffer;
         sk_sp<const GrBuffer> fIndexBuffer;
         sk_sp<GrGeometryProcessor> fGeometryProcessor;
-        const GrPipeline* fPipeline;
         int fGlyphsToFlush;
         int fVertexOffset;
     };
 
     void onPrepareDraws(Target* target) const override;
 
+    GrAtlasTextOp() : INHERITED(ClassID()) {}  // initialized in factory functions.
+
     GrMaskFormat maskFormat() const {
         switch (fMaskType) {
             case kLCDCoverageMask_MaskType:
@@ -163,9 +159,14 @@ private:
     sk_sp<GrGeometryProcessor> setupDfProcessor(const SkMatrix& viewMatrix, SkColor luminanceColor,
                                                 GrColor color, sk_sp<GrTextureProxy> proxy) const;
 
+    GrColor fColor;
+    bool fUsesLocalCoords;
+    int fNumGlyphs;
 
     // The minimum number of Geometry we will try to allocate.
     enum { kMinGeometryAllocated = 4 };
+    SkAutoSTMalloc<kMinGeometryAllocated, Geometry> fGeoData;
+    int fGeoCount;
 
     enum MaskType {
         kGrayscaleCoverageMask_MaskType,
@@ -175,18 +176,10 @@ private:
         kGrayscaleDistanceField_MaskType,
         kLCDDistanceField_MaskType,
         kLCDBGRDistanceField_MaskType,
-    };
+    } fMaskType;
 
-    SkAutoSTMalloc<kMinGeometryAllocated, Geometry> fGeoData;
-    GrColor fColor;
-    uint32_t fSRGBFlags;
-    GrProcessorSet fProcessors;
-    bool fUsesLocalCoords;
-    bool fCanCombineOnTouchOrOverlap;
-    int fGeoCount;
-    int fNumGlyphs;
-    MaskType fMaskType;
     GrAtlasGlyphCache* fFontCache;
+
     // Distance field properties
     sk_sp<const GrDistanceFieldAdjustTable> fDistanceAdjustTable;
     SkColor fLuminanceColor;
@@ -194,7 +187,7 @@ private:
 
     friend class GrBlobRegenHelper;  // Needs to trigger flushes
 
-    typedef GrMeshDrawOp INHERITED;
+    typedef GrLegacyMeshDrawOp INHERITED;
 };
 
 /*