Create GLSLUniformHandler class for gpu backend

src/gpu/glsl/GrGLSLXferProcessor.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSLXferProcessor_DEFINED
 #define GrGLSLXferProcessor_DEFINED
 
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
 
 class GrXferProcessor;
+class GrGLSLCaps;
+class GrGLSLUniformHandler;
 class GrGLSLXPBuilder;
 class GrGLSLXPFragmentBuilder;
-class GrGLSLCaps;
 
 class GrGLSLXferProcessor {
 public:
     GrGLSLXferProcessor() {}
     virtual ~GrGLSLXferProcessor() {}
 
     typedef GrGLSLTextureSampler::TextureSamplerArray TextureSamplerArray;
     struct EmitArgs {
-        EmitArgs(GrGLSLXPBuilder* pb,
-                 GrGLSLXPFragmentBuilder* fragBuilder,
+        EmitArgs(GrGLSLXPFragmentBuilder* fragBuilder,
+                 GrGLSLUniformHandler* uniformHandler,
                  const GrGLSLCaps* caps,
                  const GrXferProcessor& xp,
                  const char* inputColor,
                  const char* inputCoverage,
                  const char* outputPrimary,
                  const char* outputSecondary,
                  const TextureSamplerArray& samplers)
-            : fPB(pb)
-            , fXPFragBuilder(fragBuilder)
+            : fXPFragBuilder(fragBuilder)
+            , fUniformHandler(uniformHandler)
             , fGLSLCaps(caps)
             , fXP(xp)
             , fInputColor(inputColor)
             , fInputCoverage(inputCoverage)
             , fOutputPrimary(outputPrimary)
             , fOutputSecondary(outputSecondary)
             , fSamplers(samplers) {}
 
-        GrGLSLXPBuilder* fPB;
         GrGLSLXPFragmentBuilder* fXPFragBuilder;
+        GrGLSLUniformHandler* fUniformHandler;
         const GrGLSLCaps* fGLSLCaps;
         const GrXferProcessor& fXP;
         const char* fInputColor;
         const char* fInputCoverage;
         const char* fOutputPrimary;
         const char* fOutputSecondary;
         const TextureSamplerArray& fSamplers;
     };
     /**
      * This is similar to emitCode() in the base class, except it takes a full shader builder.
@@ skipping 18 matching lines @@
      */
     virtual void emitOutputsForBlendState(const EmitArgs&) {
         SkFAIL("emitOutputsForBlendState not implemented.");
     }
 
     /**
      * Called by emitCode() when the XP will perform a dst read. This method only needs to supply
      * the blending logic. The base class applies coverage. A subclass only needs to implement this
      * method if it can construct a GrXferProcessor that reads the dst color.
      */
-    virtual void emitBlendCodeForDstRead(GrGLSLXPBuilder*,
-                                         GrGLSLXPFragmentBuilder*,
+    virtual void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder*,
+                                         GrGLSLUniformHandler*,
                                          const char* srcColor,
                                          const char* srcCoverage,
                                          const char* dstColor,
                                          const char* outColor,
                                          const char* outColorSecondary,
                                          const GrXferProcessor&) {
         SkFAIL("emitBlendCodeForDstRead not implemented.");
     }
 
     virtual void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) = 0;
 
     GrGLSLProgramDataManager::UniformHandle fDstTopLeftUni;
     GrGLSLProgramDataManager::UniformHandle fDstScaleUni;
 };
 #endif