Rename some processor functions from GL to GLSL

include/gpu/GrFragmentProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrFragmentProcessor_DEFINED
 #define GrFragmentProcessor_DEFINED
 
@@ skipping 45 matching lines @@
     static const GrFragmentProcessor* RunInSeries(const GrFragmentProcessor*[], int cnt);
 
     GrFragmentProcessor()
         : INHERITED()
         , fUsesLocalCoords(false)
         , fNumTexturesExclChildren(0)
         , fNumTransformsExclChildren(0) {}
 
     ~GrFragmentProcessor() override;
 
-    GrGLSLFragmentProcessor* createGLInstance() const;
+    GrGLSLFragmentProcessor* createGLSLInstance() const;
 
-    void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
-        this->onGetGLProcessorKey(caps, b);
+    void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
+        this->onGetGLSLProcessorKey(caps, b);
         for (int i = 0; i < fChildProcessors.count(); ++i) {
-            fChildProcessors[i]->getGLProcessorKey(caps, b);
+            fChildProcessors[i]->getGLSLProcessorKey(caps, b);
         }
     }
 
     int numTexturesExclChildren() const { return fNumTexturesExclChildren; }
 
     int numTransformsExclChildren() const { return fNumTransformsExclChildren; }
 
     int numTransforms() const { return fCoordTransforms.count(); }
 
     /** Returns the coordinate transformation at index. index must be valid according to
@@ skipping 15 matching lines @@
     const GrFragmentProcessor& childProcessor(int index) const { return *fChildProcessors[index]; }
 
     /** Do any of the coordtransforms for this processor require local coords? */
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     /** Returns true if this and other processor conservatively draw identically. It can only return
         true when the two processor are of the same subclass (i.e. they return the same object from
         from getFactory()).
 
         A return value of true from isEqual() should not be used to test whether the processor would
-        generate the same shader code. To test for identical code generation use getGLProcessorKey*/
+        generate the same shader code. To test for identical code generation use getGLSLProcessorKey
+     */
     bool isEqual(const GrFragmentProcessor& that, bool ignoreCoordTransforms) const;
 
     /**
      * This function is used to perform optimizations. When called the invarientOuput param
      * indicate whether the input components to this processor in the FS will have known values.
      * In inout the validFlags member is a bitfield of GrColorComponentFlags. The isSingleComponent
      * member indicates whether the input will be 1 or 4 bytes. The function updates the members of
      * inout to indicate known values of its output. A component of the color member only has
      * meaning if the corresponding bit in validFlags is set.
      */
@@ skipping 41 matching lines @@
      * procs' output invariants; computeInvariantOutput will not be recursive.
      */
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
 
 private:
     void notifyRefCntIsZero() const final;
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrFragmentProcessor; caller is responsible for deleting
         the object. */
-    virtual GrGLSLFragmentProcessor* onCreateGLInstance() const = 0;
+    virtual GrGLSLFragmentProcessor* onCreateGLSLInstance() const = 0;
 
     /** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
-    virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
-                                     GrProcessorKeyBuilder* b) const = 0;
+    virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
+                                       GrProcessorKeyBuilder* b) const = 0;
 
     /**
      * Subclass implements this to support isEqual(). It will only be called if it is known that
      * the two processors are of the same subclass (i.e. they return the same object from
      * getFactory()). The processor subclass should not compare its coord transforms as that will
      * be performed automatically in the non-virtual isEqual().
      */
     virtual bool onIsEqual(const GrFragmentProcessor&) const = 0;
 
     bool hasSameTransforms(const GrFragmentProcessor&) const;
@@ skipping 29 matching lines @@
     int                                          fNumTransformsExclChildren;
 
     // TODO: These must convert their processors to pending-execution refs when the parent is
     // converted (do this automatically in GrProgramElement?).
     SkTArray<const GrFragmentProcessor*, true>   fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif