Remove PLS path renderer

Change-Id: Ib727b0749a5a7da95832970e79804417e8b6a247
Reviewed-on: https://skia-review.googlesource.com/9300
Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

31 files changed, 41 insertions, 1534 deletions

diff --git a/src/gpu/GrDrawOpTest.cpp b/src/gpu/GrDrawOpTest.cpp
index 5d0aa56ee9..fcf70e0d7b 100644
--- a/src/gpu/GrDrawOpTest.cpp
+++ b/src/gpu/GrDrawOpTest.cpp
@@ -32,7 +32,6 @@ DRAW_OP_TEST_EXTERN(DIEllipseOp);
 DRAW_OP_TEST_EXTERN(EllipseOp);
 DRAW_OP_TEST_EXTERN(GrDrawAtlasOp);
 DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp);
-DRAW_OP_TEST_EXTERN(PLSPathOp);
 DRAW_OP_TEST_EXTERN(RRectOp);
 DRAW_OP_TEST_EXTERN(TesselatingPathOp);
 DRAW_OP_TEST_EXTERN(TextBlobOp);
@@ -56,8 +55,6 @@ std::unique_ptr<GrDrawOp> GrRandomDrawOp(SkRandom* random, GrContext* context) {
         DRAW_OP_TEST_ENTRY(EllipseOp),
         DRAW_OP_TEST_ENTRY(GrDrawAtlasOp),
         DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp),
-        // This currently hits an assert when the GrDisableColorXPFactory is randomly selected.
-        // DRAW_OP_TEST_ENTRY(PLSPathOp),
         DRAW_OP_TEST_ENTRY(RRectOp),
         DRAW_OP_TEST_ENTRY(TesselatingPathOp),
         DRAW_OP_TEST_ENTRY(TextBlobOp),
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 3abe8f8194..5b69ead462 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -376,7 +376,7 @@ public:
             const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) = 0;
 
     // Called by GrOpList when flushing.
-    // Provides a hook for post-flush actions (e.g. PLS reset and Vulkan command buffer submits).
+    // Provides a hook for post-flush actions (e.g. Vulkan command buffer submits).
     virtual void finishOpList() {}
 
     virtual GrFence SK_WARN_UNUSED_RESULT insertFence() = 0;
diff --git a/src/gpu/GrPLSGeometryProcessor.h b/src/gpu/GrPLSGeometryProcessor.h
deleted file mode 100644
index 0640af63f0..0000000000
--- a/src/gpu/GrPLSGeometryProcessor.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrPLSGeometryProcessor_DEFINED
-#define GrPLSGeometryProcessor_DEFINED
-
-#include "GrGeometryProcessor.h"
-
-/**
- * A minor extension to GrGeometryProcessor that adds bounds tracking for pixel local storage
- * purposes.
- */
-class GrPLSGeometryProcessor : public GrGeometryProcessor {
-public:
-    GrPixelLocalStorageState getPixelLocalStorageState() const override {
-        return GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState;
-    }
-
-    const SkRect& getBounds() const {
-       return fBounds;
-    }
-
-    void setBounds(SkRect& bounds) {
-       fBounds = bounds;
-    }
-
-private:
-    SkRect fBounds;
-};
-
-#endif
diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp
index b371c3ef75..6c8177f8e0 100644
--- a/src/gpu/GrPathRendererChain.cpp
+++ b/src/gpu/GrPathRendererChain.cpp
@@ -21,7 +21,6 @@
 #include "ops/GrDashLinePathRenderer.h"
 #include "ops/GrDefaultPathRenderer.h"
 #include "ops/GrMSAAPathRenderer.h"
-#include "ops/GrPLSPathRenderer.h"
 #include "ops/GrStencilAndCoverPathRenderer.h"
 #include "ops/GrTessellatingPathRenderer.h"
 
@@ -54,11 +53,6 @@ GrPathRendererChain::GrPathRendererChain(GrContext* context, const Options& opti
     if (options.fGpuPathRenderers & GpuPathRenderers::kAALinearizing) {
         fChain.push_back(sk_make_sp<GrAALinearizingConvexPathRenderer>());
     }
-    if (options.fGpuPathRenderers & GpuPathRenderers::kPLS) {
-        if (caps.shaderCaps()->plsPathRenderingSupport()) {
-            fChain.push_back(sk_make_sp<GrPLSPathRenderer>());
-        }
-    }
     if (options.fGpuPathRenderers & GpuPathRenderers::kDistanceField) {
         fChain.push_back(sk_make_sp<GrAADistanceFieldPathRenderer>());
     }
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index b9fe7b2c8b..f5b8fe9cf0 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -35,16 +35,6 @@ class GrGLSLPrimitiveProcessor;
 
 struct GrInitInvariantOutput;
 
-// Describes the state of pixel local storage with respect to the current draw.
-enum GrPixelLocalStorageState {
-    // The draw is actively updating PLS.
-    kDraw_GrPixelLocalStorageState,
-    // The draw is a "finish" operation which is reading from PLS and writing color.
-    kFinish_GrPixelLocalStorageState,
-    // The draw does not use PLS.
-    kDisabled_GrPixelLocalStorageState
-};
-
 /*
  * This class allows the GrPipeline to communicate information about the pipeline to a GrOp which
  * inform its decisions for GrPrimitiveProcessor setup. These are not properly part of the pipeline
@@ -167,10 +157,6 @@ public:
 
     virtual bool isPathRendering() const { return false; }
 
-    virtual GrPixelLocalStorageState getPixelLocalStorageState() const {
-        return kDisabled_GrPixelLocalStorageState;
-    }
-
     /**
      * If non-null, overrides the dest color returned by GrGLSLFragmentShaderBuilder::dstColor().
      */
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index c61fe8bc79..e5beca0382 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -38,11 +38,9 @@ GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
 void GrProcessorSet::FragmentProcessorAnalysis::internalReset(const GrPipelineInput& colorInput,
                                                               const GrPipelineInput coverageInput,
                                                               const GrProcessorSet& processors,
-                                                              bool usesPLSDstRead,
                                                               const GrFragmentProcessor* clipFP,
                                                               const GrCaps& caps) {
     GrProcOptInfo colorInfo(colorInput);
-    fUsesPLSDstRead = usesPLSDstRead;
     fCompatibleWithCoverageAsAlpha = !coverageInput.isLCDCoverage();
 
     const GrFragmentProcessor* const* fps = processors.fFragmentProcessors.get();
@@ -91,15 +89,14 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalReset(const GrPipelineIn
 void GrProcessorSet::FragmentProcessorAnalysis::reset(const GrPipelineInput& colorInput,
                                                       const GrPipelineInput coverageInput,
                                                       const GrProcessorSet& processors,
-                                                      bool usesPLSDstRead,
                                                       const GrAppliedClip& appliedClip,
                                                       const GrCaps& caps) {
-    this->internalReset(colorInput, coverageInput, processors, usesPLSDstRead,
+    this->internalReset(colorInput, coverageInput, processors,
                         appliedClip.clipCoverageFragmentProcessor(), caps);
 }
 
 GrProcessorSet::FragmentProcessorAnalysis::FragmentProcessorAnalysis(
         const GrPipelineInput& colorInput, const GrPipelineInput coverageInput, const GrCaps& caps)
         : FragmentProcessorAnalysis() {
-    this->internalReset(colorInput, coverageInput, GrProcessorSet(GrPaint()), false, nullptr, caps);
+    this->internalReset(colorInput, coverageInput, GrProcessorSet(GrPaint()), nullptr, caps);
 }
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index 722bc048bd..de8bd6944b 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -56,12 +56,12 @@ public:
     class FragmentProcessorAnalysis {
     public:
         FragmentProcessorAnalysis() = default;
-        // This version is used by a unit test that assumes no clip, no processors, and no PLS.
+        // This version is used by a unit test that assumes no clip and no fragment processors.
         FragmentProcessorAnalysis(const GrPipelineInput& colorInput,
                                   const GrPipelineInput coverageInput, const GrCaps&);
 
         void reset(const GrPipelineInput& colorInput, const GrPipelineInput coverageInput,
-                   const GrProcessorSet&, bool usesPLSDstRead, const GrAppliedClip&, const GrCaps&);
+                   const GrProcessorSet&, const GrAppliedClip&, const GrCaps&);
 
         int initialColorProcessorsToEliminate(GrColor* newInputColor) const {
             if (fInitialColorProcessorsToEliminate > 0) {
@@ -70,7 +70,6 @@ public:
             return fInitialColorProcessorsToEliminate;
         }
 
-        bool usesPLSDstRead() const { return fUsesPLSDstRead; }
         bool usesLocalCoords() const { return fUsesLocalCoords; }
         bool isCompatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; }
         bool isOutputColorOpaque() const {
@@ -89,13 +88,11 @@ public:
 
     private:
         void internalReset(const GrPipelineInput& colorInput, const GrPipelineInput coverageInput,
-                           const GrProcessorSet&, bool usesPLSDstRead,
-                           const GrFragmentProcessor* clipFP, const GrCaps&);
+                           const GrProcessorSet&, const GrFragmentProcessor* clipFP, const GrCaps&);
 
         enum class ColorType { kUnknown, kOpaqueConstant, kConstant, kOpaque };
         enum class CoverageType { kNone, kSingleChannel, kLCD };
 
-        bool fUsesPLSDstRead = false;
         bool fCompatibleWithCoverageAsAlpha = true;
         bool fUsesLocalCoords = false;
         CoverageType fCoverageType = CoverageType::kNone;
diff --git a/src/gpu/GrRenderTargetOpList.cpp b/src/gpu/GrRenderTargetOpList.cpp
index 6edab11beb..6a7f7573e0 100644
--- a/src/gpu/GrRenderTargetOpList.cpp
+++ b/src/gpu/GrRenderTargetOpList.cpp
@@ -298,18 +298,6 @@ void GrRenderTargetOpList::addDrawOp(const GrPipelineBuilder& pipelineBuilder,
     }
     args.fCaps = this->caps();
     args.fAnalysis = &analysis;
-    if (analysis.usesPLSDstRead()) {
-        int width = renderTargetContext->width();
-        int height = renderTargetContext->height();
-        SkIRect ibounds;
-        ibounds.fLeft = SkTPin(SkScalarFloorToInt(op->bounds().fLeft), 0, width);
-        ibounds.fTop = SkTPin(SkScalarFloorToInt(op->bounds().fTop), 0, height);
-        ibounds.fRight = SkTPin(SkScalarCeilToInt(op->bounds().fRight), 0, width);
-        ibounds.fBottom = SkTPin(SkScalarCeilToInt(op->bounds().fBottom), 0, height);
-        if (!appliedClip.addScissor(ibounds)) {
-            return;
-        }
-    }
 
     if (!renderTargetContext->accessRenderTarget()) {
         return;
diff --git a/src/gpu/GrShaderCaps.cpp b/src/gpu/GrShaderCaps.cpp
index 69af070bc7..e3e6b07361 100644
--- a/src/gpu/GrShaderCaps.cpp
+++ b/src/gpu/GrShaderCaps.cpp
@@ -47,7 +47,6 @@ GrShaderCaps::GrShaderCaps(const GrContextOptions& options) {
     fTexelBufferSupport = false;
     fImageLoadStoreSupport = false;
     fShaderPrecisionVaries = false;
-    fPLSPathRenderingSupport = false;
     fDropsTileOnZeroDivide = false;
     fFBFetchSupport = false;
     fFBFetchNeedsCustomOutput = false;
@@ -67,8 +66,6 @@ GrShaderCaps::GrShaderCaps(const GrContextOptions& options) {
     fExternalTextureSupport = false;
     fTexelFetchSupport = false;
 
-    fPixelLocalStorageSize = 0;
-
     fVersionDeclString = nullptr;
     fShaderDerivativeExtensionString = nullptr;
     fFragCoordConventionsExtensionString = nullptr;
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index a926812818..3b8a2bfb87 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -188,7 +188,7 @@ bool GrXPFactory::WillNeedDstTexture(const GrXPFactory* factory, const GrCaps& c
                                      const GrProcessorSet::FragmentProcessorAnalysis& analysis) {
     bool result;
     if (factory) {
-        result = !analysis.usesPLSDstRead() && !caps.shaderCaps()->dstReadInShaderSupport() &&
+        result = !caps.shaderCaps()->dstReadInShaderSupport() &&
                  factory->willReadDstInShader(caps, analysis);
     } else {
         result = GrPorterDuffXPFactory::WillSrcOverNeedDstTexture(caps, analysis);
@@ -197,14 +197,6 @@ bool GrXPFactory::WillNeedDstTexture(const GrXPFactory* factory, const GrCaps& c
     return result;
 }
 
-bool GrXPFactory::willReadDstInShader(const GrCaps& caps,
-                                      const FragmentProcessorAnalysis& analysis) const {
-    if (analysis.usesPLSDstRead()) {
-        return true;
-    }
-    return this->onWillReadDstInShader(caps, analysis);
-}
-
 GrXferProcessor* GrXPFactory::createXferProcessor(const FragmentProcessorAnalysis& analysis,
                                                   bool hasMixedSamples,
                                                   const DstTexture* dstTexture,
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index c00bcbeff2..d6d6fa33e3 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -325,14 +325,11 @@ private:
                                                    bool hasMixedSamples,
                                                    const DstTexture*) const = 0;
 
-    bool willReadDstInShader(const GrCaps& caps, const FragmentProcessorAnalysis& analysis) const;
-
     /**
      *  Returns true if the XP generated by this factory will explicitly read dst in the fragment
-     *  shader. This will not be called for draws that read from PLS since the dst color is always
-     *  available in such draws.
+     *  shader.
      */
-    virtual bool onWillReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const = 0;
+    virtual bool willReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const = 0;
 };
 #if defined(__GNUC__) || defined(__clang)
 #pragma GCC diagnostic pop
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp
index d86467e668..52ebaad309 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.cpp
+++ b/src/gpu/effects/GrCoverageSetOpXP.cpp
@@ -142,94 +142,6 @@ void CoverageSetOpXP::onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) cons
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class ShaderCSOXferProcessor : public GrXferProcessor {
-public:
-    ShaderCSOXferProcessor(const DstTexture* dstTexture,
-                           bool hasMixedSamples,
-                           SkRegion::Op regionOp,
-                           bool invertCoverage)
-        : INHERITED(dstTexture, true, hasMixedSamples)
-        , fRegionOp(regionOp)
-        , fInvertCoverage(invertCoverage) {
-        this->initClassID<ShaderCSOXferProcessor>();
-    }
-
-    const char* name() const override { return "Coverage Set Op Shader"; }
-
-    GrGLSLXferProcessor* createGLSLInstance() const override;
-
-    SkRegion::Op regionOp() const { return fRegionOp; }
-    bool invertCoverage() const { return fInvertCoverage; }
-
-private:
-    GrXferProcessor::OptFlags onGetOptimizations(const FragmentProcessorAnalysis&) const override {
-        // We never look at the color input
-        return GrXferProcessor::kIgnoreColor_OptFlag;
-    }
-
-    void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override;
-
-    bool onIsEqual(const GrXferProcessor& xpBase) const override {
-        const ShaderCSOXferProcessor& xp = xpBase.cast<ShaderCSOXferProcessor>();
-        return (fRegionOp == xp.fRegionOp &&
-                fInvertCoverage == xp.fInvertCoverage);
-    }
-
-    SkRegion::Op fRegionOp;
-    bool         fInvertCoverage;
-
-    typedef GrXferProcessor INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-class GLShaderCSOXferProcessor : public GrGLSLXferProcessor {
-public:
-    static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
-        const ShaderCSOXferProcessor& xp = processor.cast<ShaderCSOXferProcessor>();
-        b->add32(xp.regionOp());
-        uint32_t key = xp.invertCoverage() ?  0x0 : 0x1;
-        b->add32(key);
-    }
-
-private:
-    void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder* fragBuilder,
-                                 GrGLSLUniformHandler* uniformHandler,
-                                 const char* srcColor,
-                                 const char* srcCoverage,
-                                 const char* dstColor,
-                                 const char* outColor,
-                                 const char* outColorSecondary,
-                                 const GrXferProcessor& proc) override {
-        const ShaderCSOXferProcessor& xp = proc.cast<ShaderCSOXferProcessor>();
-
-        if (xp.invertCoverage()) {
-            fragBuilder->codeAppendf("%s = 1.0 - %s;", outColor, srcCoverage);
-        } else {
-            fragBuilder->codeAppendf("%s = %s;", outColor, srcCoverage);
-        }
-
-        GrGLSLBlend::AppendRegionOp(fragBuilder, outColor, dstColor, outColor, xp.regionOp());
-    }
-
-    void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {}
-
-    typedef GrGLSLXferProcessor INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-void ShaderCSOXferProcessor::onGetGLSLProcessorKey(const GrShaderCaps&,
-                                                   GrProcessorKeyBuilder* b) const {
-    GLShaderCSOXferProcessor::GenKey(*this, b);
-}
-
-GrGLSLXferProcessor* ShaderCSOXferProcessor::createGLSLInstance() const {
-    return new GLShaderCSOXferProcessor;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
 constexpr GrCoverageSetOpXPFactory::GrCoverageSetOpXPFactory(SkRegion::Op regionOp,
                                                              bool invertCoverage)
         : fRegionOp(regionOp), fInvertCoverage(invertCoverage) {}
@@ -328,9 +240,6 @@ GrXferProcessor* GrCoverageSetOpXPFactory::onCreateXferProcessor(
         return nullptr;
     }
 
-    if (analysis.usesPLSDstRead()) {
-        return new ShaderCSOXferProcessor(dst, hasMixedSamples, fRegionOp, fInvertCoverage);
-    }
     return CoverageSetOpXP::Create(fRegionOp, fInvertCoverage);
 }
 
diff --git a/src/gpu/effects/GrCoverageSetOpXP.h b/src/gpu/effects/GrCoverageSetOpXP.h
index ed6b9aa9f0..02db11b811 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.h
+++ b/src/gpu/effects/GrCoverageSetOpXP.h
@@ -41,7 +41,7 @@ private:
                                            bool hasMixedSamples,
                                            const DstTexture*) const override;
 
-    bool onWillReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override {
+    bool willReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override {
         return false;
     }
 
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index ccbab73f86..8895d7c02b 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -52,16 +52,11 @@ static constexpr GrBlendEquation hw_blend_equation(SkBlendMode mode) {
 #undef EQ_OFFSET
 }
 
-static bool can_use_hw_blend_equation(GrBlendEquation equation,
-                                      bool usePLSRead,
-                                      bool isLCDCoverage,
+static bool can_use_hw_blend_equation(GrBlendEquation equation, bool isLCDCoverage,
                                       const GrCaps& caps) {
     if (!caps.advancedBlendEquationSupport()) {
         return false;
     }
-    if (usePLSRead) {
-        return false;
-    }
     if (isLCDCoverage) {
         return false; // LCD coverage must be applied after the blend equation.
     }
@@ -334,7 +329,7 @@ private:
 
     bool willReadsDst(const FragmentProcessorAnalysis&) const override { return true; }
 
-    bool onWillReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override;
+    bool willReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override;
 
     GR_DECLARE_XP_FACTORY_TEST;
 
@@ -352,20 +347,16 @@ GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                                         bool hasMixedSamples,
                                                         const DstTexture* dstTexture) const {
     SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
-    if (can_use_hw_blend_equation(fHWBlendEquation, analysis.usesPLSDstRead(),
-                                  analysis.hasLCDCoverage(), caps)) {
+    if (can_use_hw_blend_equation(fHWBlendEquation, analysis.hasLCDCoverage(), caps)) {
         SkASSERT(!dstTexture || !dstTexture->texture());
         return new CustomXP(fMode, fHWBlendEquation);
     }
     return new CustomXP(dstTexture, hasMixedSamples, fMode);
 }
 
-bool CustomXPFactory::onWillReadDstInShader(const GrCaps& caps,
-                                            const FragmentProcessorAnalysis& analysis) const {
-    // This should not be called if we're using PLS dst read.
-    static constexpr bool kUsesPLSRead = false;
-    return !can_use_hw_blend_equation(fHWBlendEquation, kUsesPLSRead, analysis.hasLCDCoverage(),
-                                      caps);
+bool CustomXPFactory::willReadDstInShader(const GrCaps& caps,
+                                          const FragmentProcessorAnalysis& analysis) const {
+    return !can_use_hw_blend_equation(fHWBlendEquation, analysis.hasLCDCoverage(), caps);
 }
 
 GR_DEFINE_XP_FACTORY_TEST(CustomXPFactory);
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index 6bdf1885e9..f95cd9b81a 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -90,7 +90,6 @@ GrXferProcessor* GrDisableColorXPFactory::onCreateXferProcessor(
         const FragmentProcessorAnalysis& analysis,
         bool hasMixedSamples,
         const DstTexture* dst) const {
-    SkASSERT(!analysis.usesPLSDstRead());
     return DisableColorXP::Create();
 }
 
diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h
index b4cd00a599..6a9f2add17 100644
--- a/src/gpu/effects/GrDisableColorXP.h
+++ b/src/gpu/effects/GrDisableColorXP.h
@@ -28,7 +28,7 @@ private:
 
     constexpr GrDisableColorXPFactory() {}
 
-    bool onWillReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override {
+    bool willReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override {
         return false;
     }
 
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index 7378874da9..c7e61cace3 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -735,9 +735,6 @@ GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(
         const FragmentProcessorAnalysis& analysis,
         bool hasMixedSamples,
         const DstTexture* dstTexture) const {
-    if (analysis.usesPLSDstRead()) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fBlendMode);
-    }
     BlendFormula blendFormula;
     if (analysis.hasLCDCoverage()) {
         if (SkBlendMode::kSrcOver == fBlendMode && analysis.hasKnownOutputColor() &&
@@ -768,8 +765,8 @@ bool GrPorterDuffXPFactory::willReadsDst(const FragmentProcessorAnalysis& analys
     return (colorFormula.usesDstColor() || analysis.hasCoverage());
 }
 
-bool GrPorterDuffXPFactory::onWillReadDstInShader(const GrCaps& caps,
-                                                  const FragmentProcessorAnalysis& analysis) const {
+bool GrPorterDuffXPFactory::willReadDstInShader(const GrCaps& caps,
+                                                const FragmentProcessorAnalysis& analysis) const {
     if (caps.shaderCaps()->dualSourceBlendingSupport()) {
         return false;
     }
@@ -830,9 +827,6 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
         const FragmentProcessorAnalysis& analysis,
         bool hasMixedSamples,
         const GrXferProcessor::DstTexture* dstTexture) {
-    if (analysis.usesPLSDstRead()) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver);
-    }
 
     // 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
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.h b/src/gpu/effects/GrPorterDuffXferProcessor.h
index 6d7dc90fcf..b82c1068ff 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.h
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.h
@@ -52,7 +52,7 @@ private:
                                            bool hasMixedSamples,
                                            const DstTexture*) const override;
 
-    bool onWillReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override;
+    bool willReadDstInShader(const GrCaps&, const FragmentProcessorAnalysis&) const override;
 
     GR_DECLARE_XP_FACTORY_TEST;
     static void TestGetXPOutputTypes(const GrXferProcessor*, int* outPrimary, int* outSecondary);
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 0bcb7e817b..d2e18995a3 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -290,17 +290,6 @@ void GrGLCaps::init(const GrContextOptions& contextOptions,
             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
     }
 
-    if (ctxInfo.hasExtension("GL_EXT_shader_pixel_local_storage")) {
-        #define GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT 0x8F63
-        GR_GL_GetIntegerv(gli, GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT,
-                          &shaderCaps->fPixelLocalStorageSize);
-        shaderCaps->fPLSPathRenderingSupport = shaderCaps->fFBFetchSupport;
-    }
-    else {
-        shaderCaps->fPixelLocalStorageSize = 0;
-        shaderCaps->fPLSPathRenderingSupport = false;
-    }
-
     // Protect ourselves against tracking huge amounts of texture state.
     static const uint8_t kMaxSaneSamplers = 32;
     GrGLint maxSamplers;
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index cfbef9fd7a..bda1c16b59 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -16,7 +16,6 @@
 #include "GrGLTextureRenderTarget.h"
 #include "GrGpuResourcePriv.h"
 #include "GrMesh.h"
-#include "GrPLSGeometryProcessor.h"
 #include "GrPipeline.h"
 #include "GrRenderTargetPriv.h"
 #include "GrShaderCaps.h"
@@ -32,7 +31,6 @@
 #include "SkTemplates.h"
 #include "SkTypes.h"
 #include "builders/GrGLShaderStringBuilder.h"
-#include "glsl/GrGLSLPLSPathRendering.h"
 #include "instanced/GLInstancedRendering.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
@@ -206,8 +204,6 @@ GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context)
     , fTempDstFBOID(0)
     , fStencilClearFBOID(0)
     , fHWMaxUsedBufferTextureUnit(-1)
-    , fHWPLSEnabled(false)
-    , fPLSHasBeenUsed(false)
     , fHWMinSampleShading(0.0) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(fCopyPrograms); ++i) {
         fCopyPrograms[i].fProgram = 0;
@@ -216,7 +212,6 @@ GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context)
         fMipmapPrograms[i].fProgram = 0;
     }
     fWireRectProgram.fProgram = 0;
-    fPLSSetupProgram.fProgram = 0;
 
     SkASSERT(ctx);
     fCaps.reset(SkRef(ctx->caps()));
@@ -274,7 +269,6 @@ GrGLGpu::~GrGLGpu() {
     fCopyProgramArrayBuffer.reset();
     fMipmapProgramArrayBuffer.reset();
     fWireRectArrayBuffer.reset();
-    fPLSSetupProgram.fArrayBuffer.reset();
 
     if (0 != fHWProgramID) {
         // detach the current program so there is no confusion on OpenGL's part
@@ -308,129 +302,9 @@ GrGLGpu::~GrGLGpu() {
         GL_CALL(DeleteProgram(fWireRectProgram.fProgram));
     }
 
-    if (0 != fPLSSetupProgram.fProgram) {
-        GL_CALL(DeleteProgram(fPLSSetupProgram.fProgram));
-    }
-
     delete fProgramCache;
 }
 
-bool GrGLGpu::createPLSSetupProgram() {
-    if (!fPLSSetupProgram.fArrayBuffer) {
-        static const GrGLfloat vdata[] = {
-            0, 0,
-            0, 1,
-            1, 0,
-            1, 1
-        };
-        fPLSSetupProgram.fArrayBuffer.reset(GrGLBuffer::Create(this, sizeof(vdata),
-                                                               kVertex_GrBufferType,
-                                                               kStatic_GrAccessPattern, vdata));
-        if (!fPLSSetupProgram.fArrayBuffer) {
-            return false;
-        }
-    }
-
-    SkASSERT(!fPLSSetupProgram.fProgram);
-    GL_CALL_RET(fPLSSetupProgram.fProgram, CreateProgram());
-    if (!fPLSSetupProgram.fProgram) {
-        return false;
-    }
-
-    const GrShaderCaps* shaderCaps = this->caps()->shaderCaps();
-    const char* version = shaderCaps->versionDeclString();
-
-    GrShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
-    GrShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
-                               GrShaderVar::kUniform_TypeModifier);
-    GrShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
-    GrShaderVar uTexture("u_texture", kTexture2DSampler_GrSLType,
-                         GrShaderVar::kUniform_TypeModifier);
-    GrShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier);
-
-    SkString vshaderTxt(version);
-    if (shaderCaps->noperspectiveInterpolationSupport()) {
-        if (const char* extension = shaderCaps->noperspectiveInterpolationExtensionString()) {
-            vshaderTxt.appendf("#extension %s : require\n", extension);
-        }
-        vTexCoord.addModifier("noperspective");
-    }
-    aVertex.appendDecl(shaderCaps, &vshaderTxt);
-    vshaderTxt.append(";");
-    uTexCoordXform.appendDecl(shaderCaps, &vshaderTxt);
-    vshaderTxt.append(";");
-    uPosXform.appendDecl(shaderCaps, &vshaderTxt);
-    vshaderTxt.append(";");
-    vTexCoord.appendDecl(shaderCaps, &vshaderTxt);
-    vshaderTxt.append(";");
-
-    vshaderTxt.append(
-        "// PLS Setup Program VS\n"
-        "void main() {"
-        "  gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;"
-        "  gl_Position.zw = vec2(0, 1);"
-        "}"
-    );
-
-    SkString fshaderTxt(version);
-    if (shaderCaps->noperspectiveInterpolationSupport()) {
-        if (const char* extension = shaderCaps->noperspectiveInterpolationExtensionString()) {
-            fshaderTxt.appendf("#extension %s : require\n", extension);
-        }
-    }
-    fshaderTxt.append("#extension ");
-    fshaderTxt.append(shaderCaps->fbFetchExtensionString());
-    fshaderTxt.append(" : require\n");
-    fshaderTxt.append("#extension GL_EXT_shader_pixel_local_storage : require\n");
-    GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *shaderCaps, &fshaderTxt);
-    vTexCoord.setTypeModifier(GrShaderVar::kIn_TypeModifier);
-    vTexCoord.appendDecl(shaderCaps, &fshaderTxt);
-    fshaderTxt.append(";");
-    uTexture.appendDecl(shaderCaps, &fshaderTxt);
-    fshaderTxt.append(";");
-
-    fshaderTxt.appendf(
-        "// PLS Setup Program FS\n"
-        GR_GL_PLS_PATH_DATA_DECL
-        "void main() {\n"
-        "    " GR_GL_PLS_DSTCOLOR_NAME " = gl_LastFragColorARM;\n"
-        "    pls.windings = ivec4(0, 0, 0, 0);\n"
-        "}"
-    );
-
-    const char* str;
-    GrGLint length;
-
-    str = vshaderTxt.c_str();
-    length = SkToInt(vshaderTxt.size());
-    SkSL::Program::Settings settings;
-    settings.fCaps = shaderCaps;
-    SkSL::Program::Inputs inputs;
-    GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fPLSSetupProgram.fProgram,
-                                                  GR_GL_VERTEX_SHADER, &str, &length, 1, &fStats,
-                                                  settings, &inputs);
-    SkASSERT(inputs.isEmpty());
-
-    str = fshaderTxt.c_str();
-    length = SkToInt(fshaderTxt.size());
-    GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fPLSSetupProgram.fProgram,
-                                                  GR_GL_FRAGMENT_SHADER, &str, &length, 1, &fStats,
-                                                  settings, &inputs);
-    SkASSERT(inputs.isEmpty());
-
-    GL_CALL(LinkProgram(fPLSSetupProgram.fProgram));
-
-    GL_CALL_RET(fPLSSetupProgram.fPosXformUniform, GetUniformLocation(fPLSSetupProgram.fProgram,
-                                                                  "u_posXform"));
-
-    GL_CALL(BindAttribLocation(fPLSSetupProgram.fProgram, 0, "a_vertex"));
-
-    GL_CALL(DeleteShader(vshader));
-    GL_CALL(DeleteShader(fshader));
-
-    return true;
-}
-
 void GrGLGpu::disconnect(DisconnectType type) {
     INHERITED::disconnect(type);
     if (DisconnectType::kCleanup == type) {
@@ -459,9 +333,6 @@ void GrGLGpu::disconnect(DisconnectType type) {
         if (fWireRectProgram.fProgram) {
             GL_CALL(DeleteProgram(fWireRectProgram.fProgram));
         }
-        if (fPLSSetupProgram.fProgram) {
-            GL_CALL(DeleteProgram(fPLSSetupProgram.fProgram));
-        }
     } else {
         if (fProgramCache) {
             fProgramCache->abandon();
@@ -485,8 +356,6 @@ void GrGLGpu::disconnect(DisconnectType type) {
     }
     fWireRectProgram.fProgram = 0;
     fWireRectArrayBuffer.reset();
-    fPLSSetupProgram.fProgram = 0;
-    fPLSSetupProgram.fArrayBuffer.reset();
     if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
         this->glPathRendering()->disconnect(type);
     }
@@ -2672,25 +2541,6 @@ GrGpuCommandBuffer* GrGLGpu::createCommandBuffer(
     return new GrGLGpuCommandBuffer(this);
 }
 
-void GrGLGpu::finishOpList() {
-    if (fPLSHasBeenUsed) {
-        /* There is an ARM driver bug where if we use PLS, and then draw a frame which does not
-         * use PLS, it leaves garbage all over the place. As a workaround, we use PLS in a
-         * trivial way every frame. And since we use it every frame, there's never a point at which
-         * it becomes safe to stop using this workaround once we start.
-         */
-        this->disableScissor();
-        this->disableWindowRectangles();
-        // using PLS in the presence of MSAA results in GL_INVALID_OPERATION
-        this->flushHWAAState(nullptr, false, false);
-        SkASSERT(!fHWPLSEnabled);
-        SkASSERT(fMSAAEnabled != kYes_TriState);
-        GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        this->stampPLSSetupRect(SkRect::MakeXYWH(-100.0f, -100.0f, 0.01f, 0.01f));
-        GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-    }
-}
-
 void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bounds, bool disableSRGB) {
     SkASSERT(target);
 
@@ -2786,16 +2636,6 @@ void GrGLGpu::draw(const GrPipeline& pipeline,
     if (!this->flushGLState(pipeline, primProc, hasPoints)) {
         return;
     }
-    GrPixelLocalStorageState plsState = primProc.getPixelLocalStorageState();
-    if (!fHWPLSEnabled && plsState !=
-        GrPixelLocalStorageState::kDisabled_GrPixelLocalStorageState) {
-        GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        this->setupPixelLocalStorage(pipeline, primProc);
-        fHWPLSEnabled = true;
-    }
-    if (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
-        this->disableStencil();
-    }
 
     for (int i = 0; i < meshCount; ++i) {
         if (GrXferBarrierType barrierType = pipeline.xferBarrierType(*this->caps())) {
@@ -2840,16 +2680,6 @@ void GrGLGpu::draw(const GrPipeline& pipeline,
         } while ((nonInstMesh = iter.next()));
     }
 
-    if (fHWPLSEnabled && plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
-        // PLS draws always involve multiple draws, finishing up with a non-PLS
-        // draw that writes to the color buffer. That draw ends up here; we wait
-        // until after it is complete to actually disable PLS.
-        GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        fHWPLSEnabled = false;
-        this->disableScissor();
-        this->disableWindowRectangles();
-    }
-
 #if SWAP_PER_DRAW
     glFlush();
     #if defined(SK_BUILD_FOR_MAC)
@@ -2864,65 +2694,6 @@ void GrGLGpu::draw(const GrPipeline& pipeline,
 #endif
 }
 
-void GrGLGpu::stampPLSSetupRect(const SkRect& bounds) {
-    SkASSERT(this->caps()->shaderCaps()->plsPathRenderingSupport());
-
-    if (!fPLSSetupProgram.fProgram) {
-        if (!this->createPLSSetupProgram()) {
-            SkDebugf("Failed to create PLS setup program.\n");
-            return;
-        }
-    }
-
-    GL_CALL(UseProgram(fPLSSetupProgram.fProgram));
-    this->fHWVertexArrayState.setVertexArrayID(this, 0);
-
-    GrGLAttribArrayState* attribs = this->fHWVertexArrayState.bindInternalVertexArray(this);
-    attribs->set(this, 0, fPLSSetupProgram.fArrayBuffer.get(), kVec2f_GrVertexAttribType,
-                 2 * sizeof(GrGLfloat), 0);
-    attribs->disableUnusedArrays(this, 0x1);
-
-    GL_CALL(Uniform4f(fPLSSetupProgram.fPosXformUniform, bounds.width(), bounds.height(),
-                      bounds.left(), bounds.top()));
-
-    GrXferProcessor::BlendInfo blendInfo;
-    blendInfo.reset();
-    this->flushBlend(blendInfo, GrSwizzle());
-    this->flushColorWrite(true);
-    this->flushDrawFace(GrDrawFace::kBoth);
-    if (!fHWStencilSettings.isDisabled()) {
-        GL_CALL(Disable(GR_GL_STENCIL_TEST));
-    }
-    GL_CALL(DrawArrays(GR_GL_TRIANGLE_STRIP, 0, 4));
-    GL_CALL(UseProgram(fHWProgramID));
-    if (!fHWStencilSettings.isDisabled()) {
-        GL_CALL(Enable(GR_GL_STENCIL_TEST));
-    }
-}
-
-void GrGLGpu::setupPixelLocalStorage(const GrPipeline& pipeline,
-                                     const GrPrimitiveProcessor& primProc) {
-    fPLSHasBeenUsed = true;
-    const SkRect& bounds =
-            static_cast<const GrPLSGeometryProcessor&>(primProc).getBounds();
-    // setup pixel local storage -- this means capturing and storing the current framebuffer color
-    // and initializing the winding counts to zero
-    GrRenderTarget* rt = pipeline.getRenderTarget();
-    SkScalar width = SkIntToScalar(rt->width());
-    SkScalar height = SkIntToScalar(rt->height());
-    // dst rect edges in NDC (-1 to 1)
-    // having some issues with rounding, just expand the bounds by 1 and trust the scissor to keep
-    // it contained properly
-    GrGLfloat dx0 = 2.0f * (bounds.left() - 1) / width - 1.0f;
-    GrGLfloat dx1 = 2.0f * (bounds.right() + 1) / width - 1.0f;
-    GrGLfloat dy0 = -2.0f * (bounds.top() - 1) / height + 1.0f;
-    GrGLfloat dy1 = -2.0f * (bounds.bottom() + 1) / height + 1.0f;
-    SkRect deviceBounds = SkRect::MakeXYWH(dx0, dy0, dx1 - dx0, dy1 - dy0);
-
-    GL_CALL(Enable(GR_GL_FETCH_PER_SAMPLE_ARM));
-    this->stampPLSSetupRect(deviceBounds);
-}
-
 void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
     if (rt->needsResolve()) {
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 57068fb916..564ed7629a 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -144,8 +144,6 @@ public:
 
     void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override;
 
-    void finishOpList() override;
-
     GrFence SK_WARN_UNUSED_RESULT insertFence() override;
     bool waitFence(GrFence, uint64_t timeout) override;
     void deleteFence(GrFence) const override;
@@ -273,10 +271,6 @@ private:
                                       const SkIPoint& dstPoint);
     bool generateMipmap(GrGLTexture* texture, bool gammaCorrect);
 
-    void stampPLSSetupRect(const SkRect& bounds);
-
-    void setupPixelLocalStorage(const GrPipeline&, const GrPrimitiveProcessor&);
-
     static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
 
     class ProgramCache : public ::SkNoncopyable {
@@ -404,7 +398,6 @@ private:
     bool createCopyProgram(GrTexture* srcTexture);
     bool createMipmapProgram(int progIdx);
     bool createWireRectProgram();
-    bool createPLSSetupProgram();
 
     // GL program-related state
     ProgramCache*               fProgramCache;
@@ -647,15 +640,6 @@ private:
         return (wide ? 0x2 : 0x0) | (tall ? 0x1 : 0x0);
     }
 
-    struct {
-        GrGLuint          fProgram;
-        GrGLint           fPosXformUniform;
-        sk_sp<GrGLBuffer> fArrayBuffer;
-    }                                       fPLSSetupProgram;
-
-    bool                                    fHWPLSEnabled;
-    bool                                    fPLSHasBeenUsed;
-
     float                                   fHWMinSampleShading;
 
     typedef GrGpu INHERITED;
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index f09b66869f..d9e73f04e4 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -77,12 +77,9 @@ void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrPipeline
 
     this->setFragmentData(primProc, pipeline, &nextSamplerIdx);
 
-    if (primProc.getPixelLocalStorageState() !=
-        GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
-        const GrXferProcessor& xp = pipeline.getXferProcessor();
-        fXferProcessor->setData(fProgramDataManager, xp);
-        this->bindTextures(xp, pipeline.getAllowSRGBInputs(), &nextSamplerIdx);
-    }
+    const GrXferProcessor& xp = pipeline.getXferProcessor();
+    fXferProcessor->setData(fProgramDataManager, xp);
+    this->bindTextures(xp, pipeline.getAllowSRGBInputs(), &nextSamplerIdx);
 }
 
 void GrGLProgram::generateMipmaps(const GrPrimitiveProcessor& primProc,
@@ -93,12 +90,6 @@ void GrGLProgram::generateMipmaps(const GrPrimitiveProcessor& primProc,
     while (const GrFragmentProcessor* fp  = iter.next()) {
         this->generateMipmaps(*fp, pipeline.getAllowSRGBInputs());
     }
-
-    if (primProc.getPixelLocalStorageState() !=
-        GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
-        const GrXferProcessor& xp = pipeline.getXferProcessor();
-        this->generateMipmaps(xp, pipeline.getAllowSRGBInputs());
-    }
 }
 
 void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc,
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index f583420f29..a1f5173436 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -96,13 +96,6 @@ GrGLSLFragmentShaderBuilder::GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* p
 bool GrGLSLFragmentShaderBuilder::enableFeature(GLSLFeature feature) {
     const GrShaderCaps& shaderCaps = *fProgramBuilder->shaderCaps();
     switch (feature) {
-        case kPixelLocalStorage_GLSLFeature:
-            if (shaderCaps.pixelLocalStorageSize() <= 0) {
-                return false;
-            }
-            this->addFeature(1 << kPixelLocalStorage_GLSLFeature,
-                             "GL_EXT_shader_pixel_local_storage");
-            return true;
         case kMultisampleInterpolation_GLSLFeature:
             if (!shaderCaps.multisampleInterpolationSupport()) {
                 return false;
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
index ab806ea914..764f3bd812 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
@@ -29,7 +29,6 @@ public:
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
-        kPixelLocalStorage_GLSLFeature = kLastGLSLPrivateFeature + 1,
         kMultisampleInterpolation_GLSLFeature
     };
 
diff --git a/src/gpu/glsl/GrGLSLPLSPathRendering.h b/src/gpu/glsl/GrGLSLPLSPathRendering.h
deleted file mode 100644
index 60889e98d2..0000000000
--- a/src/gpu/glsl/GrGLSLPLSPathRendering.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#define GR_GL_PLS_DSTCOLOR_NAME  "pls.dstColor"
-#define GR_GL_PLS_PATH_DATA_DECL "__pixel_localEXT PLSData {\n"\
-                                 "    layout(rgba8i) ivec4 windings;\n"\
-                                 "    layout(rgba8) vec4 dstColor;\n"\
-                                 "} pls;\n"
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.cpp b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
index 385026a52d..1fcf0405f7 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
@@ -62,12 +62,8 @@ bool GrGLSLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor,
     this->emitAndInstallPrimProc(primProc, inputColor, inputCoverage);
 
     this->emitAndInstallFragProcs(inputColor, inputCoverage);
-    if (primProc.getPixelLocalStorageState() !=
-        GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
-        this->emitAndInstallXferProc(this->pipeline().getXferProcessor(), *inputColor,
-                                     *inputCoverage, primProc.getPixelLocalStorageState());
-        this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput());
-    }
+    this->emitAndInstallXferProc(this->pipeline().getXferProcessor(), *inputColor, *inputCoverage);
+    this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput());
 
     return this->checkSamplerCounts() && this->checkImageStorageCounts();
 }
@@ -217,8 +213,7 @@ void GrGLSLProgramBuilder::emitAndInstallFragProc(const GrFragmentProcessor& fp,
 
 void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                                   const GrGLSLExpr4& colorIn,
-                                                  const GrGLSLExpr4& coverageIn,
-                                                  GrPixelLocalStorageState plsState) {
+                                                  const GrGLSLExpr4& coverageIn) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
 
@@ -243,7 +238,6 @@ void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
     SkSTArray<2, ImageStorageHandle> imageStorageArray(xp.numImageStorages());
     this->emitSamplersAndImageStorages(xp, &texSamplers, &bufferSamplers, &imageStorageArray);
 
-    bool usePLSDstRead = (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState);
     GrGLSLXferProcessor::EmitArgs args(&fFS,
                                        this->uniformHandler(),
                                        this->shaderCaps(),
@@ -253,8 +247,7 @@ void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                        fFS.getSecondaryColorOutputName(),
                                        texSamplers.begin(),
                                        bufferSamplers.begin(),
-                                       imageStorageArray.begin(),
-                                       usePLSDstRead);
+                                       imageStorageArray.begin());
     fXferProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
index 321d81cad2..748664625f 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.h
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -154,8 +154,7 @@ private:
                                 GrGLSLExpr4* output);
     void emitAndInstallXferProc(const GrXferProcessor&,
                                 const GrGLSLExpr4& colorIn,
-                                const GrGLSLExpr4& coverageIn,
-                                GrPixelLocalStorageState plsState);
+                                const GrGLSLExpr4& coverageIn);
     void emitSamplersAndImageStorages(const GrProcessor& processor,
                                       SkTArray<SamplerHandle>* outTexSamplerHandles,
                                       SkTArray<SamplerHandle>* outBufferSamplerHandles,
diff --git a/src/gpu/glsl/GrGLSLXferProcessor.h b/src/gpu/glsl/GrGLSLXferProcessor.h
index 90c1bce5b2..b4bde37e30 100644
--- a/src/gpu/glsl/GrGLSLXferProcessor.h
+++ b/src/gpu/glsl/GrGLSLXferProcessor.h
@@ -35,20 +35,18 @@ public:
                  const char* outputSecondary,
                  const SamplerHandle* texSamplers,
                  const SamplerHandle* bufferSamplers,
-                 const ImageStorageHandle* imageStorages,
-                 const bool usePLSDstRead)
-            : fXPFragBuilder(fragBuilder)
-            , fUniformHandler(uniformHandler)
-            , fShaderCaps(caps)
-            , fXP(xp)
-            , fInputColor(inputColor)
-            , fInputCoverage(inputCoverage)
-            , fOutputPrimary(outputPrimary)
-            , fOutputSecondary(outputSecondary)
-            , fTexSamplers(texSamplers)
-            , fBufferSamplers(bufferSamplers)
-            , fImageStorages(imageStorages)
-            , fUsePLSDstRead(usePLSDstRead) {}
+                 const ImageStorageHandle* imageStorages)
+                : fXPFragBuilder(fragBuilder)
+                , fUniformHandler(uniformHandler)
+                , fShaderCaps(caps)
+                , fXP(xp)
+                , fInputColor(inputColor)
+                , fInputCoverage(inputCoverage)
+                , fOutputPrimary(outputPrimary)
+                , fOutputSecondary(outputSecondary)
+                , fTexSamplers(texSamplers)
+                , fBufferSamplers(bufferSamplers)
+                , fImageStorages(imageStorages) {}
 
         GrGLSLXPFragmentBuilder* fXPFragBuilder;
         GrGLSLUniformHandler* fUniformHandler;
@@ -61,7 +59,6 @@ public:
         const SamplerHandle* fTexSamplers;
         const SamplerHandle* fBufferSamplers;
         const ImageStorageHandle* fImageStorages;
-        bool fUsePLSDstRead;
     };
     /**
      * This is similar to emitCode() in the base class, except it takes a full shader builder.
diff --git a/src/gpu/ops/GrDrawOp.h b/src/gpu/ops/GrDrawOp.h
index 1512642bb4..18c218fc9a 100644
--- a/src/gpu/ops/GrDrawOp.h
+++ b/src/gpu/ops/GrDrawOp.h
@@ -70,8 +70,7 @@ public:
                            const GrCaps& caps) const {
         FragmentProcessorAnalysisInputs input;
         this->getFragmentProcessorAnalysisInputs(&input);
-        analysis->reset(*input.colorInput(), *input.coverageInput(), processors,
-                        input.usesPLSDstRead(), appliedClip, caps);
+        analysis->reset(*input.colorInput(), *input.coverageInput(), processors, appliedClip, caps);
     }
 
 protected:
@@ -121,14 +120,9 @@ protected:
         GrPipelineInput* colorInput() { return &fColorInput; }
         GrPipelineInput* coverageInput() { return &fCoverageInput; }
 
-        void setUsesPLSDstRead() { fUsesPLSDstRead = true; }
-
-        bool usesPLSDstRead() const { return fUsesPLSDstRead; }
-
     private:
         GrPipelineInput fColorInput;
         GrPipelineInput fCoverageInput;
-        bool fUsesPLSDstRead = false;
     };
 
 private:
diff --git a/src/gpu/ops/GrPLSPathRenderer.cpp b/src/gpu/ops/GrPLSPathRenderer.cpp
deleted file mode 100644
index ac2f4fcf2b..0000000000
--- a/src/gpu/ops/GrPLSPathRenderer.cpp
+++ /dev/null
@@ -1,946 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrPLSPathRenderer.h"
-
-#include "GrCaps.h"
-#include "GrContext.h"
-#include "GrDefaultGeoProcFactory.h"
-#include "GrDrawOpTest.h"
-#include "GrOpFlushState.h"
-#include "GrPLSGeometryProcessor.h"
-#include "GrPathUtils.h"
-#include "GrPipelineBuilder.h"
-#include "GrProcessor.h"
-#include "GrStyle.h"
-#include "GrTessellator.h"
-#include "SkChunkAlloc.h"
-#include "SkGeometry.h"
-#include "SkPathPriv.h"
-#include "SkString.h"
-#include "SkTSort.h"
-#include "SkTraceEvent.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "glsl/GrGLSLGeometryProcessor.h"
-#include "glsl/GrGLSLPLSPathRendering.h"
-#include "ops/GrMeshDrawOp.h"
-
-GrPLSPathRenderer::GrPLSPathRenderer() {
-}
-
-struct PLSVertex {
-    SkPoint  fPos;
-    // for triangles, these are the three triangle vertices
-    // for quads, vert1 is the texture UV coords, and vert2 and vert3 are the line segment
-    // comprising the flat edge of the quad
-    SkPoint  fVert1;
-    SkPoint  fVert2;
-    SkPoint  fVert3;
-    int fWinding;
-};
-typedef SkTArray<PLSVertex, true> PLSVertices;
-
-typedef SkTArray<SkPoint, true> FinishVertices;
-
-static const float kCubicTolerance = 0.5f;
-static const float kConicTolerance = 0.5f;
-
-static const float kBloatSize = 1.0f;
-
-static const float kBloatLimit = 640000.0f;
-
-#define kQuadNumVertices 5
-static void add_quad(SkPoint pts[3], PLSVertices& vertices) {
-    SkPoint normal = SkPoint::Make(pts[0].fY - pts[2].fY,
-                                   pts[2].fX - pts[0].fX);
-    normal.setLength(kBloatSize);
-    SkScalar cross = (pts[1] - pts[0]).cross(pts[2] - pts[0]);
-    if (cross < 0) {
-        normal = -normal;
-    }
-    PLSVertex quad[kQuadNumVertices];
-    quad[0].fPos = pts[0] + normal;
-    quad[1].fPos = pts[0] - normal;
-    quad[2].fPos = pts[1] - normal;
-    quad[3].fPos = pts[2] - normal;
-    quad[4].fPos = pts[2] + normal;
-    for (int i = 0; i < kQuadNumVertices; i++) {
-        quad[i].fWinding = cross < 0 ? 1 : -1;
-        if (cross > 0.0) {
-            quad[i].fVert2 = pts[0];
-            quad[i].fVert3 = pts[2];
-        }
-        else {
-            quad[i].fVert2 = pts[2];
-            quad[i].fVert3 = pts[0];
-        }
-    }
-    GrPathUtils::QuadUVMatrix DevToUV(pts);
-    DevToUV.apply<kQuadNumVertices, sizeof(PLSVertex), sizeof(SkPoint)>(quad);
-    for (int i = 2; i < kQuadNumVertices; i++) {
-        vertices.push_back(quad[0]);
-        vertices.push_back(quad[i - 1]);
-        vertices.push_back(quad[i]);
-    }
-}
-
-/* Used by bloat_tri; outsets a single point. */
-static bool outset(SkPoint* p1, SkPoint line1, SkPoint line2) {
-    // rotate the two line vectors 90 degrees to form the normals, and compute
-    // the dot product of the normals
-    SkScalar dotProd = line1.fY * line2.fY + line1.fX * line2.fX;
-    SkScalar lengthSq = 1.0f / ((1.0f - dotProd) / 2.0f);
-    if (lengthSq > kBloatLimit) {
-        return false;
-    }
-    SkPoint bisector = line1 + line2;
-    bisector.setLength(SkScalarSqrt(lengthSq) * kBloatSize);
-    *p1 += bisector;
-    return true;
-}
-
-/* Bloats a triangle so as to create a border kBloatSize pixels wide all around it. */
-static bool bloat_tri(SkPoint pts[3]) {
-    SkPoint line1 = pts[0] - pts[1];
-    line1.normalize();
-    SkPoint line2 = pts[0] - pts[2];
-    line2.normalize();
-    SkPoint line3 = pts[1] - pts[2];
-    line3.normalize();
-
-    SkPoint result[3];
-    result[0] = pts[0];
-    if (!outset(&result[0], line1, line2)) {
-        return false;
-    }
-    result[1] = pts[1];
-    if (!outset(&result[1], -line1, line3)) {
-        return false;
-    }
-    result[2] = pts[2];
-    if (!outset(&result[2], -line3, -line2)) {
-        return false;
-    }
-    pts[0] = result[0];
-    pts[1] = result[1];
-    pts[2] = result[2];
-    return true;
-}
-
-static bool get_geometry(const SkPath& path, const SkMatrix& m, PLSVertices& triVertices,
-                         PLSVertices& quadVertices, GrResourceProvider* resourceProvider,
-                         SkRect bounds) {
-    SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
-    SkScalar tol = GrPathUtils::scaleToleranceToSrc(screenSpaceTol, m, bounds);
-    int contourCnt;
-    int maxPts = GrPathUtils::worstCasePointCount(path, &contourCnt, tol);
-    if (maxPts <= 0) {
-        return 0;
-    }
-    SkPath linesOnlyPath;
-    linesOnlyPath.setFillType(path.getFillType());
-    SkSTArray<15, SkPoint, true> quadPoints;
-    SkPath::Iter iter(path, true);
-    bool done = false;
-    while (!done) {
-        SkPoint pts[4];
-        SkPath::Verb verb = iter.next(pts);
-        switch (verb) {
-            case SkPath::kMove_Verb:
-                SkASSERT(quadPoints.count() % 3 == 0);
-                for (int i = 0; i < quadPoints.count(); i += 3) {
-                    add_quad(&quadPoints[i], quadVertices);
-                }
-                quadPoints.reset();
-                m.mapPoints(&pts[0], 1);
-                linesOnlyPath.moveTo(pts[0]);
-                break;
-            case SkPath::kLine_Verb:
-                m.mapPoints(&pts[1], 1);
-                linesOnlyPath.lineTo(pts[1]);
-                break;
-            case SkPath::kQuad_Verb:
-                m.mapPoints(pts, 3);
-                linesOnlyPath.lineTo(pts[2]);
-                quadPoints.push_back(pts[0]);
-                quadPoints.push_back(pts[1]);
-                quadPoints.push_back(pts[2]);
-                break;
-            case SkPath::kCubic_Verb: {
-                m.mapPoints(pts, 4);
-                SkSTArray<15, SkPoint, true> quads;
-                GrPathUtils::convertCubicToQuads(pts, kCubicTolerance, &quads);
-                int count = quads.count();
-                for (int q = 0; q < count; q += 3) {
-                    linesOnlyPath.lineTo(quads[q + 2]);
-                    quadPoints.push_back(quads[q]);
-                    quadPoints.push_back(quads[q + 1]);
-                    quadPoints.push_back(quads[q + 2]);
-                }
-                break;
-            }
-            case SkPath::kConic_Verb: {
-                m.mapPoints(pts, 3);
-                SkScalar weight = iter.conicWeight();
-                SkAutoConicToQuads converter;
-                const SkPoint* quads = converter.computeQuads(pts, weight, kConicTolerance);
-                int count = converter.countQuads();
-                for (int i = 0; i < count; ++i) {
-                    linesOnlyPath.lineTo(quads[2 * i + 2]);
-                    quadPoints.push_back(quads[2 * i]);
-                    quadPoints.push_back(quads[2 * i + 1]);
-                    quadPoints.push_back(quads[2 * i + 2]);
-                }
-                break;
-            }
-            case SkPath::kClose_Verb:
-                linesOnlyPath.close();
-                break;
-            case SkPath::kDone_Verb:
-                done = true;
-                break;
-            default: SkASSERT(false);
-        }
-    }
-    SkASSERT(quadPoints.count() % 3 == 0);
-    for (int i = 0; i < quadPoints.count(); i += 3) {
-        add_quad(&quadPoints[i], quadVertices);
-    }
-
-    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-    GrUniqueKey key;
-    GrUniqueKey::Builder builder(&key, kDomain, 2);
-    builder[0] = path.getGenerationID();
-    builder[1] = path.getFillType();
-    builder.finish();
-    GrTessellator::WindingVertex* windingVertices;
-    int triVertexCount = GrTessellator::PathToVertices(linesOnlyPath, 0, bounds, &windingVertices);
-    if (triVertexCount > 0) {
-        for (int i = 0; i < triVertexCount; i += 3) {
-            SkPoint p1 = windingVertices[i].fPos;
-            SkPoint p2 = windingVertices[i + 1].fPos;
-            SkPoint p3 = windingVertices[i + 2].fPos;
-            int winding = windingVertices[i].fWinding;
-            SkASSERT(windingVertices[i + 1].fWinding == winding);
-            SkASSERT(windingVertices[i + 2].fWinding == winding);
-            SkScalar cross = (p2 - p1).cross(p3 - p1);
-            SkPoint bloated[3] = { p1, p2, p3 };
-            if (cross < 0.0f) {
-                SkTSwap(p1, p3);
-            }
-            if (bloat_tri(bloated)) {
-                triVertices.push_back({ bloated[0], p1, p2, p3, winding });
-                triVertices.push_back({ bloated[1], p1, p2, p3, winding });
-                triVertices.push_back({ bloated[2], p1, p2, p3, winding });
-            }
-            else {
-                SkScalar minX = SkTMin(p1.fX, SkTMin(p2.fX, p3.fX)) - 1.0f;
-                SkScalar minY = SkTMin(p1.fY, SkTMin(p2.fY, p3.fY)) - 1.0f;
-                SkScalar maxX = SkTMax(p1.fX, SkTMax(p2.fX, p3.fX)) + 1.0f;
-                SkScalar maxY = SkTMax(p1.fY, SkTMax(p2.fY, p3.fY)) + 1.0f;
-                triVertices.push_back({ { minX, minY }, p1, p2, p3, winding });
-                triVertices.push_back({ { maxX, minY }, p1, p2, p3, winding });
-                triVertices.push_back({ { minX, maxY }, p1, p2, p3, winding });
-                triVertices.push_back({ { maxX, minY }, p1, p2, p3, winding });
-                triVertices.push_back({ { maxX, maxY }, p1, p2, p3, winding });
-                triVertices.push_back({ { minX, maxY }, p1, p2, p3, winding });
-            }
-        }
-        delete[] windingVertices;
-    }
-    return triVertexCount > 0 || quadVertices.count() > 0;
-}
-
-class PLSAATriangleEffect : public GrPLSGeometryProcessor {
-public:
-
-    static GrPLSGeometryProcessor* Create(const SkMatrix& localMatrix,
-                                          bool usesLocalCoords) {
-        return new PLSAATriangleEffect(localMatrix, usesLocalCoords);
-    }
-
-    virtual ~PLSAATriangleEffect() {}
-
-    const char* name() const override { return "PLSAATriangle"; }
-
-    const Attribute* inPosition() const { return fInPosition; }
-    const Attribute* inVertex1() const { return fInVertex1; }
-    const Attribute* inVertex2() const { return fInVertex2; }
-    const Attribute* inVertex3() const { return fInVertex3; }
-    const Attribute* inWindings() const { return fInWindings; }
-    const SkMatrix& localMatrix() const { return fLocalMatrix; }
-    bool usesLocalCoords() const { return fUsesLocalCoords; }
-
-    class GLSLProcessor : public GrGLSLGeometryProcessor {
-    public:
-        GLSLProcessor(const GrGeometryProcessor&) {}
-
-        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
-            const PLSAATriangleEffect& te = args.fGP.cast<PLSAATriangleEffect>();
-            GrGLSLVertexBuilder* vsBuilder = args.fVertBuilder;
-            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
-            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
-
-            varyingHandler->emitAttributes(te);
-
-            this->setupPosition(vsBuilder, gpArgs, te.inPosition()->fName);
-
-            GrGLSLVertToFrag v1(kVec2f_GrSLType);
-            varyingHandler->addVarying("Vertex1", &v1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
-                                   v1.vsOut(),
-                                   te.inVertex1()->fName,
-                                   te.inVertex1()->fName);
-
-            GrGLSLVertToFrag v2(kVec2f_GrSLType);
-            varyingHandler->addVarying("Vertex2", &v2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
-                                   v2.vsOut(),
-                                   te.inVertex2()->fName,
-                                   te.inVertex2()->fName);
-
-            GrGLSLVertToFrag v3(kVec2f_GrSLType);
-            varyingHandler->addVarying("Vertex3", &v3, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
-                                   v3.vsOut(),
-                                   te.inVertex3()->fName,
-                                   te.inVertex3()->fName);
-
-            GrGLSLVertToFrag delta1(kVec2f_GrSLType);
-            varyingHandler->addVarying("delta1", &delta1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
-                                   delta1.vsOut(), v1.vsOut(), v2.vsOut(), v2.vsOut(), v1.vsOut());
-
-            GrGLSLVertToFrag delta2(kVec2f_GrSLType);
-            varyingHandler->addVarying("delta2", &delta2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
-                                   delta2.vsOut(), v2.vsOut(), v3.vsOut(), v3.vsOut(), v2.vsOut());
-
-            GrGLSLVertToFrag delta3(kVec2f_GrSLType);
-            varyingHandler->addVarying("delta3", &delta3, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
-                                   delta3.vsOut(), v3.vsOut(), v1.vsOut(), v1.vsOut(), v3.vsOut());
-
-            GrGLSLVertToFrag windings(kInt_GrSLType);
-            varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;",
-                                   windings.vsOut(), te.inWindings()->fName);
-
-            // emit transforms
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 te.inPosition()->fName, te.localMatrix(),
-                                 args.fFPCoordTransformHandler);
-
-            GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
-            SkAssertResult(fsBuilder->enableFeature(
-                           GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
-            fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
-            // Compute four subsamples, each shifted a quarter pixel along x and y from
-            // gl_FragCoord. The oriented box positioning of the subsamples is of course not
-            // optimal, but it greatly simplifies the math and this simplification is necessary for
-            // performance reasons.
-            fsBuilder->codeAppendf("highp vec2 firstSample = sk_FragCoord.xy - vec2(0.25);");
-            fsBuilder->codeAppendf("highp vec2 delta1 = %s;", delta1.fsIn());
-            fsBuilder->codeAppendf("highp vec2 delta2 = %s;", delta2.fsIn());
-            fsBuilder->codeAppendf("highp vec2 delta3 = %s;", delta3.fsIn());
-            // Check whether first sample is inside the triangle by computing three dot products. If
-            // all are < 0, we're inside. The first vector in each case is half of what it is
-            // "supposed" to be, because we re-use them later as adjustment factors for which half
-            // is the correct value, so we multiply the dots by two to compensate.
-            fsBuilder->codeAppendf("highp float d1 = dot(delta1, (firstSample - %s).yx) * 2.0;",
-                                   v1.fsIn());
-            fsBuilder->codeAppendf("highp float d2 = dot(delta2, (firstSample - %s).yx) * 2.0;",
-                                   v2.fsIn());
-            fsBuilder->codeAppendf("highp float d3 = dot(delta3, (firstSample - %s).yx) * 2.0;",
-                                   v3.fsIn());
-            fsBuilder->codeAppend("highp float dmax = max(d1, max(d2, d3));");
-            fsBuilder->codeAppendf("pls.windings[0] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
-            // for subsequent samples, we don't recalculate the entire dot product -- just adjust it
-            // to the value it would have if we did recompute it.
-            fsBuilder->codeAppend("d1 += delta1.x;");
-            fsBuilder->codeAppend("d2 += delta2.x;");
-            fsBuilder->codeAppend("d3 += delta3.x;");
-            fsBuilder->codeAppend("dmax = max(d1, max(d2, d3));");
-            fsBuilder->codeAppendf("pls.windings[1] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
-            fsBuilder->codeAppend("d1 += delta1.y;");
-            fsBuilder->codeAppend("d2 += delta2.y;");
-            fsBuilder->codeAppend("d3 += delta3.y;");
-            fsBuilder->codeAppend("dmax = max(d1, max(d2, d3));");
-            fsBuilder->codeAppendf("pls.windings[2] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
-            fsBuilder->codeAppend("d1 -= delta1.x;");
-            fsBuilder->codeAppend("d2 -= delta2.x;");
-            fsBuilder->codeAppend("d3 -= delta3.x;");
-            fsBuilder->codeAppend("dmax = max(d1, max(d2, d3));");
-            fsBuilder->codeAppendf("pls.windings[3] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
-        }
-
-        static inline void GenKey(const GrGeometryProcessor& gp,
-                                  const GrShaderCaps&,
-                                  GrProcessorKeyBuilder* b) {
-            const PLSAATriangleEffect& te = gp.cast<PLSAATriangleEffect>();
-            uint32_t key = 0;
-            key |= te.localMatrix().hasPerspective() ? 0x1 : 0x0;
-            b->add32(key);
-        }
-
-        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
-                     FPCoordTransformIter&& transformIter) override {
-            this->setTransformDataHelper(gp.cast<PLSAATriangleEffect>().fLocalMatrix, pdman,
-                                         &transformIter);
-        }
-
-    private:
-        typedef GrGLSLGeometryProcessor INHERITED;
-    };
-
-    virtual void getGLSLProcessorKey(const GrShaderCaps& caps,
-                                   GrProcessorKeyBuilder* b) const override {
-        GLSLProcessor::GenKey(*this, caps, b);
-    }
-
-    virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
-        return new GLSLProcessor(*this);
-    }
-
-private:
-    PLSAATriangleEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
-        : fLocalMatrix(localMatrix)
-        , fUsesLocalCoords(usesLocalCoords) {
-        this->initClassID<PLSAATriangleEffect>();
-        fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
-                                             kHigh_GrSLPrecision);
-        fInVertex1 = &this->addVertexAttrib("inVertex1", kVec2f_GrVertexAttribType,
-                                            kHigh_GrSLPrecision);
-        fInVertex2 = &this->addVertexAttrib("inVertex2", kVec2f_GrVertexAttribType,
-                                            kHigh_GrSLPrecision);
-        fInVertex3 = &this->addVertexAttrib("inVertex3", kVec2f_GrVertexAttribType,
-                                            kHigh_GrSLPrecision);
-        fInWindings = &this->addVertexAttrib("inWindings", kInt_GrVertexAttribType,
-                                             kLow_GrSLPrecision);
-    }
-
-    const Attribute* fInPosition;
-    const Attribute* fInVertex1;
-    const Attribute* fInVertex2;
-    const Attribute* fInVertex3;
-    const Attribute* fInWindings;
-    SkMatrix         fLocalMatrix;
-    bool             fUsesLocalCoords;
-
-    GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
-
-    typedef GrGeometryProcessor INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-/*
- * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
- * two components of the vertex attribute. Coverage is based on signed
- * distance with negative being inside, positive outside. The edge is specified in
- * window space (y-down). If either the third or fourth component of the interpolated
- * vertex coord is > 0 then the pixel is considered outside the edge. This is used to
- * attempt to trim to a portion of the infinite quad.
- * Requires shader derivative instruction support.
- */
-
-class PLSQuadEdgeEffect : public GrPLSGeometryProcessor {
-public:
-
-    static GrPLSGeometryProcessor* Create(const SkMatrix& localMatrix,
-                                          bool usesLocalCoords) {
-        return new PLSQuadEdgeEffect(localMatrix, usesLocalCoords);
-    }
-
-    virtual ~PLSQuadEdgeEffect() {}
-
-    const char* name() const override { return "PLSQuadEdge"; }
-
-    const Attribute* inPosition() const { return fInPosition; }
-    const Attribute* inUV() const { return fInUV; }
-    const Attribute* inEndpoint1() const { return fInEndpoint1; }
-    const Attribute* inEndpoint2() const { return fInEndpoint2; }
-    const Attribute* inWindings() const { return fInWindings; }
-    const SkMatrix& localMatrix() const { return fLocalMatrix; }
-    bool usesLocalCoords() const { return fUsesLocalCoords; }
-
-    class GLSLProcessor : public GrGLSLGeometryProcessor {
-    public:
-        GLSLProcessor(const GrGeometryProcessor&) {}
-
-        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
-            const PLSQuadEdgeEffect& qe = args.fGP.cast<PLSQuadEdgeEffect>();
-            GrGLSLVertexBuilder* vsBuilder = args.fVertBuilder;
-            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
-            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
-
-            // emit attributes
-            varyingHandler->emitAttributes(qe);
-
-            GrGLSLVertToFrag uv(kVec2f_GrSLType);
-            varyingHandler->addVarying("uv", &uv, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;", uv.vsOut(), qe.inUV()->fName);
-
-            GrGLSLVertToFrag ep1(kVec2f_GrSLType);
-            varyingHandler->addVarying("endpoint1", &ep1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep1.vsOut(),
-                                  qe.inEndpoint1()->fName, qe.inEndpoint1()->fName);
-
-            GrGLSLVertToFrag ep2(kVec2f_GrSLType);
-            varyingHandler->addVarying("endpoint2", &ep2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep2.vsOut(),
-                                  qe.inEndpoint2()->fName, qe.inEndpoint2()->fName);
-
-            GrGLSLVertToFrag delta(kVec2f_GrSLType);
-            varyingHandler->addVarying("delta", &delta, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
-                                   delta.vsOut(), ep1.vsOut(), ep2.vsOut(), ep2.vsOut(),
-                                   ep1.vsOut());
-
-            GrGLSLVertToFrag windings(kInt_GrSLType);
-            varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;",
-                                   windings.vsOut(), qe.inWindings()->fName);
-
-            // Setup position
-            this->setupPosition(vsBuilder, gpArgs, qe.inPosition()->fName);
-
-            // emit transforms
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 qe.inPosition()->fName, qe.localMatrix(),
-                                 args.fFPCoordTransformHandler);
-
-            GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
-            SkAssertResult(fsBuilder->enableFeature(
-                           GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
-            static const int QUAD_ARGS = 2;
-            GrShaderVar inQuadArgs[QUAD_ARGS] = {
-                GrShaderVar("dot", kFloat_GrSLType, 0, kHigh_GrSLPrecision),
-                GrShaderVar("uv", kVec2f_GrSLType, 0, kHigh_GrSLPrecision)
-            };
-            SkString inQuadName;
-
-            const char* inQuadCode = "if (uv.x * uv.x <= uv.y) {"
-                                     "return dot >= 0.0;"
-                                     "} else {"
-                                     "return false;"
-                                     "}";
-            fsBuilder->emitFunction(kBool_GrSLType, "in_quad", QUAD_ARGS, inQuadArgs, inQuadCode,
-                                    &inQuadName);
-            fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
-            // keep the derivative instructions outside the conditional
-            fsBuilder->codeAppendf("highp vec2 uvdX = dFdx(%s);", uv.fsIn());
-            fsBuilder->codeAppendf("highp vec2 uvdY = dFdy(%s);", uv.fsIn());
-            fsBuilder->codeAppend("highp vec2 uvIncX = uvdX * 0.45 + uvdY * -0.1;");
-            fsBuilder->codeAppend("highp vec2 uvIncY = uvdX * 0.1 + uvdY * 0.55;");
-            fsBuilder->codeAppendf("highp vec2 uv = %s.xy - uvdX * 0.35 - uvdY * 0.25;",
-                                   uv.fsIn());
-            fsBuilder->codeAppendf("highp vec2 firstSample = sk_FragCoord.xy - vec2(0.25);");
-            fsBuilder->codeAppendf("highp float d = dot(%s, (firstSample - %s).yx) * 2.0;",
-                                   delta.fsIn(), ep1.fsIn());
-            fsBuilder->codeAppendf("pls.windings[0] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
-                                   windings.fsIn());
-            fsBuilder->codeAppend("uv += uvIncX;");
-            fsBuilder->codeAppendf("d += %s.x;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[1] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
-                                   windings.fsIn());
-            fsBuilder->codeAppend("uv += uvIncY;");
-            fsBuilder->codeAppendf("d += %s.y;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[2] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
-                                   windings.fsIn());
-            fsBuilder->codeAppend("uv -= uvIncX;");
-            fsBuilder->codeAppendf("d -= %s.x;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[3] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
-                                   windings.fsIn());
-        }
-
-        static inline void GenKey(const GrGeometryProcessor& gp,
-                                  const GrShaderCaps&,
-                                  GrProcessorKeyBuilder* b) {
-            const PLSQuadEdgeEffect& qee = gp.cast<PLSQuadEdgeEffect>();
-            uint32_t key = 0;
-            key |= qee.usesLocalCoords() && qee.localMatrix().hasPerspective() ? 0x1 : 0x0;
-            b->add32(key);
-        }
-
-        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
-                             FPCoordTransformIter&& transformIter) override {
-            this->setTransformDataHelper(gp.cast<PLSQuadEdgeEffect>().fLocalMatrix, pdman,
-                                         &transformIter);
-        }
-
-    private:
-        typedef GrGLSLGeometryProcessor INHERITED;
-    };
-
-    virtual void getGLSLProcessorKey(const GrShaderCaps& caps,
-                                   GrProcessorKeyBuilder* b) const override {
-        GLSLProcessor::GenKey(*this, caps, b);
-    }
-
-    virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
-        return new GLSLProcessor(*this);
-    }
-
-private:
-    PLSQuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
-        : fLocalMatrix(localMatrix)
-        , fUsesLocalCoords(usesLocalCoords) {
-        this->initClassID<PLSQuadEdgeEffect>();
-        fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
-                                             kHigh_GrSLPrecision);
-        fInUV = &this->addVertexAttrib("inUV", kVec2f_GrVertexAttribType, kHigh_GrSLPrecision);
-        fInEndpoint1 = &this->addVertexAttrib("inEndpoint1", kVec2f_GrVertexAttribType,
-                                              kHigh_GrSLPrecision);
-        fInEndpoint2 = &this->addVertexAttrib("inEndpoint2", kVec2f_GrVertexAttribType,
-                                              kHigh_GrSLPrecision);
-        fInWindings  = &this->addVertexAttrib("inWindings", kInt_GrVertexAttribType,
-                                              kLow_GrSLPrecision);
-    }
-
-    const Attribute* fInPosition;
-    const Attribute* fInUV;
-    const Attribute* fInEndpoint1;
-    const Attribute* fInEndpoint2;
-    const Attribute* fInWindings;
-    SkMatrix         fLocalMatrix;
-    bool             fUsesLocalCoords;
-
-    GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
-
-    typedef GrGeometryProcessor INHERITED;
-};
-
-class PLSFinishEffect : public GrGeometryProcessor {
-public:
-
-    static GrGeometryProcessor* Create(GrColor color, bool useEvenOdd, const SkMatrix& localMatrix,
-                                       bool usesLocalCoords) {
-        return new PLSFinishEffect(color, useEvenOdd, localMatrix, usesLocalCoords);
-    }
-
-    virtual ~PLSFinishEffect() {}
-
-    const char* name() const override { return "PLSFinish"; }
-
-    const Attribute* inPosition() const { return fInPosition; }
-    GrColor color() const { return fColor; }
-    const SkMatrix& localMatrix() const { return fLocalMatrix; }
-    bool usesLocalCoords() const { return fUsesLocalCoords; }
-
-    GrPixelLocalStorageState getPixelLocalStorageState() const override {
-        return GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState;
-    }
-
-    const char* getDestColorOverride() const override {
-        return GR_GL_PLS_DSTCOLOR_NAME;
-    }
-
-    class GLSLProcessor : public GrGLSLGeometryProcessor {
-    public:
-        GLSLProcessor(const GrGeometryProcessor&) {}
-
-        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
-            const PLSFinishEffect& fe = args.fGP.cast<PLSFinishEffect>();
-            GrGLSLVertexBuilder* vsBuilder = args.fVertBuilder;
-            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
-            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
-
-            fUseEvenOdd = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                    kFloat_GrSLType, kLow_GrSLPrecision,
-                                                    "useEvenOdd");
-            const char* useEvenOdd = uniformHandler->getUniformCStr(fUseEvenOdd);
-
-            varyingHandler->emitAttributes(fe);
-            this->setupPosition(vsBuilder, gpArgs, fe.inPosition()->fName);
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 fe.inPosition()->fName, fe.localMatrix(),
-                                 args.fFPCoordTransformHandler);
-
-            GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
-            SkAssertResult(fsBuilder->enableFeature(
-                           GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
-            fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
-            fsBuilder->codeAppend("float coverage;");
-            fsBuilder->codeAppendf("if (%s != 0.0) {", useEvenOdd);
-            fsBuilder->codeAppend("coverage = float(abs(pls.windings[0]) % 2) * 0.25;");
-            fsBuilder->codeAppend("coverage += float(abs(pls.windings[1]) % 2) * 0.25;");
-            fsBuilder->codeAppend("coverage += float(abs(pls.windings[2]) % 2) * 0.25;");
-            fsBuilder->codeAppend("coverage += float(abs(pls.windings[3]) % 2) * 0.25;");
-            fsBuilder->codeAppend("} else {");
-            fsBuilder->codeAppend("coverage = pls.windings[0] != 0 ? 0.25 : 0.0;");
-            fsBuilder->codeAppend("coverage += pls.windings[1] != 0 ? 0.25 : 0.0;");
-            fsBuilder->codeAppend("coverage += pls.windings[2] != 0 ? 0.25 : 0.0;");
-            fsBuilder->codeAppend("coverage += pls.windings[3] != 0 ? 0.25 : 0.0;");
-            fsBuilder->codeAppend("}");
-            this->setupUniformColor(fsBuilder, uniformHandler, args.fOutputColor,
-                                    &fColorUniform);
-            fsBuilder->codeAppendf("%s = vec4(coverage);", args.fOutputCoverage);
-            fsBuilder->codeAppendf("%s = vec4(1.0, 0.0, 1.0, 1.0);", args.fOutputColor);
-        }
-
-        static inline void GenKey(const GrGeometryProcessor& gp,
-                                  const GrShaderCaps&,
-                                  GrProcessorKeyBuilder* b) {
-            const PLSFinishEffect& fe = gp.cast<PLSFinishEffect>();
-            uint32_t key = 0;
-            key |= fe.usesLocalCoords() && fe.localMatrix().hasPerspective() ? 0x1 : 0x0;
-            b->add32(key);
-        }
-
-        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
-                     FPCoordTransformIter&& transformIter) override {
-            const PLSFinishEffect& fe = gp.cast<PLSFinishEffect>();
-            pdman.set1f(fUseEvenOdd, fe.fUseEvenOdd);
-            if (fe.color() != fColor) {
-                GrGLfloat c[4];
-                GrColorToRGBAFloat(fe.color(), c);
-                pdman.set4fv(fColorUniform, 1, c);
-                fColor = fe.color();
-            }
-            this->setTransformDataHelper(fe.fLocalMatrix, pdman, &transformIter);
-        }
-
-    private:
-        GrColor fColor;
-        UniformHandle fColorUniform;
-        UniformHandle fUseEvenOdd;
-
-        typedef GrGLSLGeometryProcessor INHERITED;
-    };
-
-    virtual void getGLSLProcessorKey(const GrShaderCaps& caps,
-                                   GrProcessorKeyBuilder* b) const override {
-        GLSLProcessor::GenKey(*this, caps, b);
-    }
-
-    virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
-        return new GLSLProcessor(*this);
-    }
-
-private:
-    PLSFinishEffect(GrColor color, bool useEvenOdd, const SkMatrix& localMatrix,
-                    bool usesLocalCoords)
-        : fColor(color)
-        , fUseEvenOdd(useEvenOdd)
-        , fLocalMatrix(localMatrix)
-        , fUsesLocalCoords(usesLocalCoords) {
-        this->initClassID<PLSFinishEffect>();
-        fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
-                                             kHigh_GrSLPrecision);
-    }
-
-    const Attribute* fInPosition;
-    GrColor          fColor;
-    bool             fUseEvenOdd;
-    SkMatrix         fLocalMatrix;
-    bool             fUsesLocalCoords;
-
-    typedef GrGeometryProcessor INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-bool GrPLSPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-    // We have support for even-odd rendering, but are having some troublesome
-    // seams. Disable in the presence of even-odd for now.
-    SkPath path;
-    args.fShape->asPath(&path);
-    return args.fShaderCaps->shaderDerivativeSupport() && GrAAType::kCoverage == args.fAAType &&
-            args.fShape->style().isSimpleFill() && !path.isInverseFillType() &&
-            path.getFillType() == SkPath::FillType::kWinding_FillType;
-}
-
-class PLSPathOp final : public GrMeshDrawOp {
-public:
-    DEFINE_OP_CLASS_ID
-    static std::unique_ptr<GrDrawOp> Make(GrColor color, const SkPath& path,
-                                          const SkMatrix& viewMatrix) {
-        return std::unique_ptr<GrDrawOp>(new PLSPathOp(color, path, viewMatrix));
-    }
-
-    const char* name() const override { return "PLSPathOp"; }
-
-    SkString dumpInfo() const override {
-        SkString string;
-        string.printf("Color 0x%08x, UsesLocalCoords: %d\n", fColor, fUsesLocalCoords);
-        string.append(DumpPipelineInfo(*this->pipeline()));
-        string.append(INHERITED::dumpInfo());
-        return string;
-    }
-
-private:
-    PLSPathOp(GrColor color, const SkPath& path, const SkMatrix& viewMatrix)
-            : INHERITED(ClassID()), fColor(color), fPath(path), fViewMatrix(viewMatrix) {
-        // compute bounds
-        this->setTransformedBounds(path.getBounds(), fViewMatrix, HasAABloat::kYes,
-                                   IsZeroArea::kNo);
-    }
-
-    void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override {
-        input->colorInput()->setToConstant(fColor);
-        input->coverageInput()->setToUnknown();
-        input->setUsesPLSDstRead();
-    }
-
-    void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override {
-        optimizations.getOverrideColorIfSet(&fColor);
-
-        fUsesLocalCoords = optimizations.readsLocalCoords();
-    }
-
-    void onPrepareDraws(Target* target) const override {
-
-        SkMatrix invert;
-        if (fUsesLocalCoords && !fViewMatrix.invert(&invert)) {
-            SkDebugf("Could not invert viewmatrix\n");
-            return;
-        }
-
-        // Setup GrGeometryProcessors
-        sk_sp<GrPLSGeometryProcessor> triangleProcessor(
-                PLSAATriangleEffect::Create(invert, fUsesLocalCoords));
-        sk_sp<GrPLSGeometryProcessor> quadProcessor(
-                PLSQuadEdgeEffect::Create(invert, fUsesLocalCoords));
-
-        GrResourceProvider* rp = target->resourceProvider();
-        SkRect bounds;
-        this->bounds().roundOut(&bounds);
-        triangleProcessor->setBounds(bounds);
-        quadProcessor->setBounds(bounds);
-
-        // We use the fact that SkPath::transform path does subdivision based on
-        // perspective. Otherwise, we apply the view matrix when copying to the
-        // segment representation.
-        const SkMatrix* viewMatrix = &fViewMatrix;
-
-        // We avoid initializing the path unless we have to
-        const SkPath* pathPtr = &fPath;
-        SkTLazy<SkPath> tmpPath;
-        if (viewMatrix->hasPerspective()) {
-            SkPath* tmpPathPtr = tmpPath.init(*pathPtr);
-            tmpPathPtr->setIsVolatile(true);
-            tmpPathPtr->transform(*viewMatrix);
-            viewMatrix = &SkMatrix::I();
-            pathPtr = tmpPathPtr;
-        }
-
-        GrMesh mesh;
-
-        PLSVertices triVertices;
-        PLSVertices quadVertices;
-        if (!get_geometry(*pathPtr, *viewMatrix, triVertices, quadVertices, rp, bounds)) {
-            return;
-        }
-
-        if (triVertices.count()) {
-            const GrBuffer* triVertexBuffer;
-            int firstTriVertex;
-            size_t triStride = triangleProcessor->getVertexStride();
-            PLSVertex* triVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
-                    triStride, triVertices.count(), &triVertexBuffer, &firstTriVertex));
-            if (!triVerts) {
-                SkDebugf("Could not allocate vertices\n");
-                return;
-            }
-            for (int i = 0; i < triVertices.count(); ++i) {
-                triVerts[i] = triVertices[i];
-            }
-            mesh.init(kTriangles_GrPrimitiveType, triVertexBuffer, firstTriVertex,
-                      triVertices.count());
-            target->draw(triangleProcessor.get(), mesh);
-        }
-
-        if (quadVertices.count()) {
-            const GrBuffer* quadVertexBuffer;
-            int firstQuadVertex;
-            size_t quadStride = quadProcessor->getVertexStride();
-            PLSVertex* quadVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
-                    quadStride, quadVertices.count(), &quadVertexBuffer, &firstQuadVertex));
-            if (!quadVerts) {
-                SkDebugf("Could not allocate vertices\n");
-                return;
-            }
-            for (int i = 0; i < quadVertices.count(); ++i) {
-                quadVerts[i] = quadVertices[i];
-            }
-            mesh.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
-                      quadVertices.count());
-            target->draw(quadProcessor.get(), mesh);
-        }
-
-        sk_sp<GrGeometryProcessor> finishProcessor(
-                PLSFinishEffect::Create(fColor,
-                                        pathPtr->getFillType() ==
-                                                            SkPath::FillType::kEvenOdd_FillType,
-                                        invert,
-                                        fUsesLocalCoords));
-        const GrBuffer* rectVertexBuffer;
-        size_t finishStride = finishProcessor->getVertexStride();
-        int firstRectVertex;
-        static const int kRectVertexCount = 6;
-        SkPoint* rectVerts = reinterpret_cast<SkPoint*>(target->makeVertexSpace(
-                finishStride, kRectVertexCount, &rectVertexBuffer, &firstRectVertex));
-        if (!rectVerts) {
-            SkDebugf("Could not allocate vertices\n");
-            return;
-        }
-        rectVerts[0] = { bounds.fLeft, bounds.fTop };
-        rectVerts[1] = { bounds.fLeft, bounds.fBottom };
-        rectVerts[2] = { bounds.fRight, bounds.fBottom };
-        rectVerts[3] = { bounds.fLeft, bounds.fTop };
-        rectVerts[4] = { bounds.fRight, bounds.fTop };
-        rectVerts[5] = { bounds.fRight, bounds.fBottom };
-
-        mesh.init(kTriangles_GrPrimitiveType, rectVertexBuffer, firstRectVertex,
-                  kRectVertexCount);
-        target->draw(finishProcessor.get(), mesh);
-    }
-
-    bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
-        return false;
-    }
-
-    bool fUsesLocalCoords;
-
-    GrColor fColor;
-    SkPath fPath;
-    SkMatrix fViewMatrix;
-    typedef GrMeshDrawOp INHERITED;
-};
-
-SkDEBUGCODE(bool inPLSDraw = false;)
-bool GrPLSPathRenderer::onDrawPath(const DrawPathArgs& args) {
-    SkASSERT(!args.fShape->isEmpty());
-    SkASSERT(!inPLSDraw);
-    SkDEBUGCODE(inPLSDraw = true;)
-    SkPath path;
-    args.fShape->asPath(&path);
-
-    std::unique_ptr<GrDrawOp> op = PLSPathOp::Make(args.fPaint.getColor(), path, *args.fViewMatrix);
-    GrPipelineBuilder pipelineBuilder(std::move(args.fPaint), args.fAAType);
-    pipelineBuilder.setUserStencil(args.fUserStencilSettings);
-
-    args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, std::move(op));
-    SkDEBUGCODE(inPLSDraw = false;)
-    return true;
-
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if GR_TEST_UTILS
-
-DRAW_OP_TEST_DEFINE(PLSPathOp) {
-    GrColor color = GrRandomColor(random);
-    SkMatrix vm = GrTest::TestMatrixInvertible(random);
-    SkPath path = GrTest::TestPathConvex(random);
-
-    return PLSPathOp::Make(color, path, vm);
-}
-
-#endif
diff --git a/src/gpu/ops/GrPLSPathRenderer.h b/src/gpu/ops/GrPLSPathRenderer.h
deleted file mode 100644
index 39f21ba68c..0000000000
--- a/src/gpu/ops/GrPLSPathRenderer.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrPLSPathRenderer_DEFINED
-#define GrPLSPathRenderer_DEFINED
-
-#include "GrPathRenderer.h"
-
-/*
- * Renders arbitrary antialiased paths using pixel local storage as a scratch buffer. The overall
- * technique is very similar to the approach presented in "Resolution independent rendering of
- * deformable vector objects using graphics hardware" by Kokojima et al.
-
- * We first render the straight-line portions of the path (essentially pretending as if all segments
- * were kLine_Verb) as a triangle fan, using a fragment shader which updates the winding counts
- * appropriately. We then render the curved portions of the path using a Loop-Blinn shader which
- * calculates which portion of the triangle is covered by the quad (conics and cubics are split down
- * to quads). Where we diverge from Kokojima is that, instead of rendering into the stencil buffer
- * and using built-in MSAA to handle straight-line antialiasing, we use the pixel local storage area
- * and calculate the MSAA ourselves in the fragment shader. Essentially, we manually evaluate the
- * coverage of each pixel four times, storing four winding counts into the pixel local storage area,
- * and compute the final coverage based on those winding counts.
- *
- * Our approach is complicated by the need to perform antialiasing on straight edges as well,
- * without relying on hardware MSAA. We instead bloat the triangles to ensure complete coverage,
- * pass the original (un-bloated) vertices in to the fragment shader, and then have the fragment
- * shader use these vertices to evaluate whether a given sample is located within the triangle or
- * not. This gives us MSAA4 edges on triangles which line up nicely with no seams. We similarly face
- * problems on the back (flat) edges of quads, where we have to ensure that the back edge is
- * antialiased in the same way. Similar to the triangle case, we pass in the two (unbloated)
- * vertices defining the back edge of the quad and the fragment shader uses these vertex coordinates
- * to discard samples falling on the other side of the quad's back edge.
- */
-class GrPLSPathRenderer : public GrPathRenderer {
-public:
-    GrPLSPathRenderer();
-
-    bool onCanDrawPath(const CanDrawPathArgs& args) const override;
-
-protected:
-    bool onDrawPath(const DrawPathArgs& args) override;
-};
-
-#endif