GrSkSLFP: "Kind" is always kPipelineStage

Change-Id: Ia32f0858bedae79ffa551ef6dde6e46d04436f5e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/259096
Auto-Submit: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/GrSkSLFPFactoryCache.h b/src/gpu/GrSkSLFPFactoryCache.h
index 180fcb0..08788c3 100644
--- a/src/gpu/GrSkSLFPFactoryCache.h
+++ b/src/gpu/GrSkSLFPFactoryCache.h
@@ -10,8 +10,8 @@
 
 #include <vector>
 #include "include/core/SkRefCnt.h"
-#include "src/sksl/ir/SkSLProgram.h"
 
+class GrShaderCaps;
 class GrSkSLFPFactory;
 
 // This is a cache used by GrSkSLFP to retain GrSkSLFPFactory instances, so we don't have to
@@ -24,8 +24,7 @@
     GrSkSLFPFactoryCache(sk_sp<const GrShaderCaps> shaderCaps) : fShaderCaps(shaderCaps) {}
     ~GrSkSLFPFactoryCache();
 
-    sk_sp<GrSkSLFPFactory> findOrCreate(int index, const char* name, const char* skSL,
-                                        SkSL::Program::Kind kind);
+    sk_sp<GrSkSLFPFactory> findOrCreate(int index, const char* name, const char* skSL);
 
 private:
     // Returns a factory by its numeric index, or null if no such factory exists. Indices are
diff --git a/src/gpu/effects/GrSkSLFP.cpp b/src/gpu/effects/GrSkSLFP.cpp
index 9d38281..7a9c193 100644
--- a/src/gpu/effects/GrSkSLFP.cpp
+++ b/src/gpu/effects/GrSkSLFP.cpp
@@ -18,13 +18,12 @@
 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
 #include "src/gpu/glsl/GrGLSLProgramBuilder.h"
 
-GrSkSLFPFactory::GrSkSLFPFactory(const char* name, const GrShaderCaps* shaderCaps, const char* sksl,
-                                 SkSL::Program::Kind kind)
-        : fKind(kind)
-        , fName(name) {
+GrSkSLFPFactory::GrSkSLFPFactory(const char* name, const GrShaderCaps* shaderCaps, const char* sksl)
+        : fName(name) {
     SkSL::Program::Settings settings;
     settings.fCaps = shaderCaps;
-    fBaseProgram = fCompiler.convertProgram(fKind, SkSL::String(sksl), settings);
+    fBaseProgram = fCompiler.convertProgram(SkSL::Program::kPipelineStage_Kind,
+                                            SkSL::String(sksl), settings);
     if (fCompiler.errorCount()) {
         SkDebugf("%s\n", fCompiler.errorText().c_str());
     }
@@ -378,29 +377,27 @@
 };
 
 std::unique_ptr<GrSkSLFP> GrSkSLFP::Make(GrContext_Base* context, int index, const char* name,
-                                         const char* sksl, const void* inputs,
-                                         size_t inputSize, SkSL::Program::Kind kind,
+                                         const char* sksl, const void* inputs, size_t inputSize,
                                          const SkMatrix* matrix) {
     return std::unique_ptr<GrSkSLFP>(new GrSkSLFP(context->priv().fpFactoryCache(),
-                                                  kind, index, name, sksl, SkString(),
+                                                  index, name, sksl, SkString(),
                                                   inputs, inputSize, matrix));
 }
 
 std::unique_ptr<GrSkSLFP> GrSkSLFP::Make(GrContext_Base* context, int index, const char* name,
                                          SkString sksl, const void* inputs, size_t inputSize,
-                                         SkSL::Program::Kind kind, const SkMatrix* matrix) {
+                                         const SkMatrix* matrix) {
     return std::unique_ptr<GrSkSLFP>(new GrSkSLFP(context->priv().fpFactoryCache(),
-                                                  kind, index, name, nullptr, std::move(sksl),
+                                                  index, name, nullptr, std::move(sksl),
                                                   inputs, inputSize, matrix));
 }
 
 GrSkSLFP::GrSkSLFP(sk_sp<GrSkSLFPFactoryCache> factoryCache,
-                   SkSL::Program::Kind kind, int index, const char* name, const char* sksl,
+                   int index, const char* name, const char* sksl,
                    SkString skslString, const void* inputs, size_t inputSize,
                    const SkMatrix* matrix)
         : INHERITED(kGrSkSLFP_ClassID, kNone_OptimizationFlags)
         , fFactoryCache(factoryCache)
-        , fKind(kind)
         , fIndex(index)
         , fName(name)
         , fSkSLString(skslString)
@@ -420,7 +417,6 @@
         : INHERITED(kGrSkSLFP_ClassID, kNone_OptimizationFlags)
         , fFactoryCache(other.fFactoryCache)
         , fFactory(other.fFactory)
-        , fKind(other.fKind)
         , fIndex(other.fIndex)
         , fName(other.fName)
         , fSkSLString(other.fSkSLString)
@@ -442,7 +438,7 @@
 
 void GrSkSLFP::createFactory() const {
     if (!fFactory) {
-        fFactory = fFactoryCache->findOrCreate(fIndex, fName, fSkSL, fKind);
+        fFactory = fFactoryCache->findOrCreate(fIndex, fName, fSkSL);
     }
 }
 
@@ -564,15 +560,13 @@
 GrSkSLFPFactoryCache::~GrSkSLFPFactoryCache() {}
 
 sk_sp<GrSkSLFPFactory> GrSkSLFPFactoryCache::findOrCreate(int index, const char* name,
-                                                          const char* skSL,
-                                                          SkSL::Program::Kind kind) {
+                                                          const char* skSL) {
     // acquire lock for checking/adding to cache
     SkAutoMutexExclusive ame(fCacheMutex);
 
     sk_sp<GrSkSLFPFactory> factory = this->get(index);
     if (!factory) {
-        factory = sk_sp<GrSkSLFPFactory>(new GrSkSLFPFactory(name, fShaderCaps.get(),
-                                                             skSL, kind));
+        factory = sk_sp<GrSkSLFPFactory>(new GrSkSLFPFactory(name, fShaderCaps.get(), skSL));
         this->set(index, factory);
     }
 
diff --git a/src/gpu/effects/GrSkSLFP.h b/src/gpu/effects/GrSkSLFP.h
index a5013b3..07d0af1 100644
--- a/src/gpu/effects/GrSkSLFP.h
+++ b/src/gpu/effects/GrSkSLFP.h
@@ -92,7 +92,6 @@
                    const char* sksl,
                    const void* inputs,
                    size_t inputSize,
-                   SkSL::Program::Kind kind = SkSL::Program::kPipelineStage_Kind,
                    const SkMatrix* matrix = nullptr);
 
     static std::unique_ptr<GrSkSLFP> Make(
@@ -102,7 +101,6 @@
                    SkString sksl,
                    const void* inputs,
                    size_t inputSize,
-                   SkSL::Program::Kind kind = SkSL::Program::kPipelineStage_Kind,
                    const SkMatrix* matrix = nullptr);
 
     const char* name() const override;
@@ -113,7 +111,7 @@
 
 private:
     GrSkSLFP(sk_sp<GrSkSLFPFactoryCache> factoryCache,
-             SkSL::Program::Kind kind, int fIndex, const char* name, const char* sksl,
+             int fIndex, const char* name, const char* sksl,
              SkString skslString, const void* inputs, size_t inputSize, const SkMatrix* matrix);
 
     GrSkSLFP(const GrSkSLFP& other);
@@ -130,8 +128,6 @@
 
     mutable sk_sp<GrSkSLFPFactory> fFactory;
 
-    SkSL::Program::Kind fKind;
-
     int fIndex;
 
     const char* fName;
@@ -176,14 +172,11 @@
      * the produced shaders to differ), so it is important to reuse the same factory instance for
      * the same shader in order to avoid repeatedly re-parsing the SkSL.
      */
-    GrSkSLFPFactory(const char* name, const GrShaderCaps* shaderCaps, const char* sksl,
-                    SkSL::Program::Kind kind = SkSL::Program::kPipelineStage_Kind);
+    GrSkSLFPFactory(const char* name, const GrShaderCaps* shaderCaps, const char* sksl);
 
     const SkSL::Program* getSpecialization(const SkSL::String& key, const void* inputs,
                                            size_t inputSize);
 
-    SkSL::Program::Kind fKind;
-
     const char* fName;
 
     SkSL::Compiler fCompiler;
diff --git a/src/shaders/SkRTShader.cpp b/src/shaders/SkRTShader.cpp
index 95cffe5..56e2c0d 100644
--- a/src/shaders/SkRTShader.cpp
+++ b/src/shaders/SkRTShader.cpp
@@ -141,8 +141,7 @@
         return nullptr;
     }
     return GrSkSLFP::Make(args.fContext, fUniqueID, "runtime-shader", fSkSL,
-                          fInputs->data(), fInputs->size(), SkSL::Program::kPipelineStage_Kind,
-                          &matrix);
+                          fInputs->data(), fInputs->size(), &matrix);
 }
 #endif