Remove unneeded GrGLSLTransformedCoordsArray type

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 GrGLSLFragmentProcessor_DEFINED
 #define GrGLSLFragmentProcessor_DEFINED
 
 #include "GrFragmentProcessor.h"
-#include "glsl/GrGLSLProcessorTypes.h"
+#include "GrShaderVar.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLSampler.h"
 
 class GrProcessor;
 class GrProcessorKeyBuilder;
 class GrGLSLCaps;
 class GrGLSLFPBuilder;
 class GrGLSLFPFragmentBuilder;
 class GrGLSLUniformHandler;
 
 class GrGLSLFragmentProcessor {
 public:
     GrGLSLFragmentProcessor() {}
 
     virtual ~GrGLSLFragmentProcessor() {
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             delete fChildProcessors[i];
         }
     }
 
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
     typedef GrGLSLProgramDataManager::UniformHandle SamplerHandle;
 
     /** 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
         stages.
 
-        @param builder      Interface used to emit code in the shaders.
-        @param processor    The processor that generated this program stage.
-        @param key          The key that was computed by GenKey() from the generating GrProcessor.
-        @param outputColor  A predefined vec4 in the FS in which the stage should place its output
-                            color (or coverage).
-        @param inputColor   A vec4 that holds the input color to the stage in the FS. This may be
-                            nullptr in which case the implied input is solid white (all ones).
-                            TODO: Better system for communicating optimization info (e.g. input
-                            color is solid white, trans black, known to be opaque, etc.) that allows
-                            the processor to communicate back similar known info about its output.
-        @param samplers     Contains one entry for each GrTextureAccess of the GrProcessor. These
-                            can be passed to the builder to emit texture reads in the generated
-                            code.
+        @param fragBuilder       Interface used to emit code in the shaders.
+        @param fp                The processor that generated this program stage.
+        @param key               The key that was computed by GenKey() from the generating
+                                 GrProcessor.
+        @param outputColor       A predefined vec4 in the FS in which the stage should place its
+                                 output color (or coverage).
+        @param inputColor        A vec4 that holds the input color to the stage in the FS. This may
+                                 be nullptr in which case the implied input is solid white (all
+                                 ones). TODO: Better system for communicating optimization info
+                                 (e.g. input color is solid white, trans black, known to be opaque,
+                                 etc.) that allows the processor to communicate back similar known
+                                 info about its output.
+        @param transformedCoords Fragment shader variables containing the coords computed using
+                                 each of the GrFragmentProcessor's Coord Transforms.
+        @param texSamplers       Contains one entry for each GrTextureAccess of the GrProcessor.
+                                 These can be passed to the builder to emit texture reads in the
+                                 generated code.
+        @param bufferSamplers    Contains one entry for each GrBufferAccess of the GrProcessor.
+                                 These can be passed to the builder to emit buffer reads in the
+                                 generated code.
      */
-
     struct EmitArgs {
         EmitArgs(GrGLSLFPFragmentBuilder* fragBuilder,
                  GrGLSLUniformHandler* uniformHandler,
                  const GrGLSLCaps* caps,
                  const GrFragmentProcessor& fp,
                  const char* outputColor,
                  const char* inputColor,
-                 const GrGLSLTransformedCoordsArray& coords,
+                 const SkTArray<GrShaderVar>& transformedCoords,
                  const SamplerHandle* texSamplers,
                  const SamplerHandle* bufferSamplers,
                  bool gpImplementsDistanceVector)
             : fFragBuilder(fragBuilder)
             , fUniformHandler(uniformHandler)
             , fGLSLCaps(caps)
             , fFp(fp)
             , fOutputColor(outputColor)
             , fInputColor(inputColor)
-            , fCoords(coords)
+            , fTransformedCoords(transformedCoords)
             , fTexSamplers(texSamplers)
             , fBufferSamplers(bufferSamplers)
-            , fGpImplementsDistanceVector(gpImplementsDistanceVector){}
+            , fGpImplementsDistanceVector(gpImplementsDistanceVector) {}
         GrGLSLFPFragmentBuilder* fFragBuilder;
         GrGLSLUniformHandler* fUniformHandler;
         const GrGLSLCaps* fGLSLCaps;
         const GrFragmentProcessor& fFp;
         const char* fOutputColor;
         const char* fInputColor;
-        const GrGLSLTransformedCoordsArray& fCoords;
+        const SkTArray<GrShaderVar>& fTransformedCoords;
         const SamplerHandle* fTexSamplers;
         const SamplerHandle* fBufferSamplers;
         bool fGpImplementsDistanceVector;
     };
 
     virtual void emitCode(EmitArgs&) = 0;
 
     void setData(const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor);
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
@@ skipping 29 matching lines @@
 
 private:
     void internalEmitChild(int, const char*, const char*, EmitArgs&);
 
     SkTArray<GrGLSLFragmentProcessor*, true> fChildProcessors;
 
     friend class GrFragmentProcessor;
 };
 
 #endif