Create GLSL base class for ProgramDataManager

src/effects/SkColorCubeFilter.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorCubeFilter.h"
 #include "SkColorPriv.h"
 #include "SkOnce.h"
 #include "SkOpts.h"
 #include "SkReadBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkWriteBuffer.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
 #include "GrTexturePriv.h"
 #include "SkGr.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
+#include "glsl/GrGLSLProgramDataManager.h"
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace {
 
 int32_t SkNextColorCubeUniqueID() {
     static int32_t gColorCubeUniqueID;
     // do a loop in case our global wraps around, as we never want to return a 0
     int32_t genID;
     do {
@@ skipping 143 matching lines @@
     class GLProcessor : public GrGLFragmentProcessor {
     public:
         GLProcessor(const GrProcessor&);
         virtual ~GLProcessor();
 
         virtual void emitCode(EmitArgs&) override;
 
         static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 
     protected:
-        void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+        void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     private:
-        GrGLProgramDataManager::UniformHandle fColorCubeSizeUni;
-        GrGLProgramDataManager::UniformHandle fColorCubeInvSizeUni;
+        GrGLSLProgramDataManager::UniformHandle fColorCubeSizeUni;
+        GrGLSLProgramDataManager::UniformHandle fColorCubeInvSizeUni;
 
         typedef GrGLFragmentProcessor INHERITED;
     };
 
 private:
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const override;
 
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
@@ skipping 83 matching lines @@
     fsBuilder->codeAppendf("%s = vec4(mix(", args.fOutputColor);
     fsBuilder->appendTextureLookup(args.fSamplers[0], cCoords1);
     fsBuilder->codeAppend(".rgb, ");
     fsBuilder->appendTextureLookup(args.fSamplers[0], cCoords2);
 
     // Premultiply color by alpha. Note that the input alpha is not modified by this shader.
     fsBuilder->codeAppendf(".rgb, fract(%s.b)) * vec3(%s), %s.a);\n",
                            cubeIdx, nonZeroAlpha, args.fInputColor);
 }
 
-void GrColorCubeEffect::GLProcessor::onSetData(const GrGLProgramDataManager& pdman,
-                                             const GrProcessor& proc) {
+void GrColorCubeEffect::GLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
+                                               const GrProcessor& proc) {
     const GrColorCubeEffect& colorCube = proc.cast<GrColorCubeEffect>();
     SkScalar size = SkIntToScalar(colorCube.colorCubeSize());
     pdman.set1f(fColorCubeSizeUni, SkScalarToFloat(size));
     pdman.set1f(fColorCubeInvSizeUni, SkScalarToFloat(SkScalarInvert(size)));
 }
 
 void GrColorCubeEffect::GLProcessor::GenKey(const GrProcessor& proc,
                                             const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
 }
 
@@ skipping 18 matching lines @@
         if (textureCube) {
             context->textureProvider()->assignUniqueKeyToTexture(key, textureCube);
         } else {
             return nullptr;
         }
     }
 
     return GrColorCubeEffect::Create(textureCube);
 }
 #endif