Make all GrFragmentProcessors GL independent.

src/gpu/glsl/GrGLSLFragmentProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#ifndef GrGLFragmentProcessor_DEFINED
-#define GrGLFragmentProcessor_DEFINED
+#ifndef GrGLSLFragmentProcessor_DEFINED
+#define GrGLSLFragmentProcessor_DEFINED
 
 #include "glsl/GrGLSLProcessorTypes.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
 
 class GrProcessor;
 class GrProcessorKeyBuilder;
 class GrGLSLFPBuilder;
 class GrGLSLCaps;
 
-class GrGLFragmentProcessor {
+class GrGLSLFragmentProcessor {
 public:
-    GrGLFragmentProcessor() {}
+    GrGLSLFragmentProcessor() {}
 
-    virtual ~GrGLFragmentProcessor() {
+    virtual ~GrGLSLFragmentProcessor() {
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             delete fChildProcessors[i];
         }
     }
 
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
     typedef GrGLSLTextureSampler::TextureSamplerArray TextureSamplerArray;
 
     /** Called when the program stage should insert its code into the shaders. The code in each
         shader will be in its own block ({}) and so locally scoped names will not collide across
@@ skipping 36 matching lines @@
     };
 
     virtual void emitCode(EmitArgs&) = 0;
 
     void setData(const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor);
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
 
     int numChildProcessors() const { return fChildProcessors.count(); }
 
-    GrGLFragmentProcessor* childProcessor(int index) const {
+    GrGLSLFragmentProcessor* childProcessor(int index) const {
         return fChildProcessors[index];
     }
 
     /** Will emit the code of a child proc in its own scope. Pass in the parent's EmitArgs and
      *  emitChild will automatically extract the coords and samplers of that child and pass them
      *  on to the child's emitCode(). Also, any uniforms or functions emitted by the child will
      *  have their names mangled to prevent redefinitions. The output color name is also mangled
      *  therefore in an in/out param. It will be declared in mangled form by emitChild(). It is
      *  legal to pass nullptr as inputColor, since all fragment processors are required to work
      *  without an input color.
      */
     void emitChild(int childIndex, const char* inputColor, SkString* outputColor,
                    EmitArgs& parentArgs);
 
     /** Variation that uses the parent's output color variable to hold the child's output.*/
     void emitChild(int childIndex, const char* inputColor, EmitArgs& parentArgs);
 
 protected:
-    /** A GrGLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
+    /** A GrGLSLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
     the same stage key; this function reads data from a GrFragmentProcessor and uploads any
     uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor
-    parameter is guaranteed to be of the same type that created this GrGLFragmentProcessor and
-    to have an identical processor key as the one that created this GrGLFragmentProcessor.  */
+    parameter is guaranteed to be of the same type that created this GrGLSLFragmentProcessor and
+    to have an identical processor key as the one that created this GrGLSLFragmentProcessor.  */
     // TODO update this to pass in GrFragmentProcessor
     virtual void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) {}
 
 private:
     void internalEmitChild(int, const char*, const char*, EmitArgs&);
 
-    SkTArray<GrGLFragmentProcessor*, true> fChildProcessors;
+    SkTArray<GrGLSLFragmentProcessor*, true> fChildProcessors;
 
     friend class GrFragmentProcessor;
 };
 
 #endif