Create GLSL base class for ProgramDataManager

src/effects/SkMorphologyImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMorphologyImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkOpts.h"
 #include "SkReadBuffer.h"
 #include "SkRect.h"
 #include "SkWriteBuffer.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrInvariantOutput.h"
 #include "GrTexture.h"
 #include "effects/Gr1DKernelEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
+#include "glsl/GrGLSLProgramDataManager.h"
 #endif
 
 SkMorphologyImageFilter::SkMorphologyImageFilter(int radiusX,
                                                  int radiusY,
                                                  SkImageFilter* input,
                                                  const CropRect* cropRect)
     : INHERITED(1, &input, cropRect), fRadius(SkISize::Make(radiusX, radiusY)) {
 }
 
 void SkMorphologyImageFilter::flatten(SkWriteBuffer& buffer) const {
@@ skipping 221 matching lines @@
 
 class GrGLMorphologyEffect : public GrGLFragmentProcessor {
 public:
     GrGLMorphologyEffect(const GrProcessor&);
 
     virtual void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 
 protected:
-    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+    void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
     int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
 
     int                                   fRadius;
     Gr1DKernelEffect::Direction           fDirection;
     bool                                  fUseRange;
     GrMorphologyEffect::MorphologyType    fType;
-    GrGLProgramDataManager::UniformHandle fPixelSizeUni;
-    GrGLProgramDataManager::UniformHandle fRangeUni;
+    GrGLSLProgramDataManager::UniformHandle fPixelSizeUni;
+    GrGLSLProgramDataManager::UniformHandle fRangeUni;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 GrGLMorphologyEffect::GrGLMorphologyEffect(const GrProcessor& proc) {
     const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
     fRadius = m.radius();
     fDirection = m.direction();
     fUseRange = m.useRange();
     fType = m.type();
@@ skipping 70 matching lines @@
 void GrGLMorphologyEffect::GenKey(const GrProcessor& proc,
                                   const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
     uint32_t key = static_cast<uint32_t>(m.radius());
     key |= (m.type() << 8);
     key |= (m.direction() << 9);
     if (m.useRange()) key |= 1 << 10;
     b->add32(key);
 }
 
-void GrGLMorphologyEffect::onSetData(const GrGLProgramDataManager& pdman,
+void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                    const GrProcessor& proc) {
     const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
     GrTexture& texture = *m.texture(0);
     // the code we generated was for a specific kernel radius, direction and bound usage
     SkASSERT(m.radius() == fRadius);
     SkASSERT(m.direction() == fDirection);
     SkASSERT(m.useRange() == fUseRange);
 
     float pixelSize = 0.0f;
     switch (fDirection) {
@@ skipping 291 matching lines @@
                                          SkBitmap* result, SkIPoint* offset) const {
     return this->filterImageGPUGeneric(true, proxy, src, ctx, result, offset);
 }
 
 bool SkErodeImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                         SkBitmap* result, SkIPoint* offset) const {
     return this->filterImageGPUGeneric(false, proxy, src, ctx, result, offset);
 }
 
 #endif