Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/gl/GrGLProgramDesc.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrGLProgramDesc.h"
 
 #include "GrGLFragmentProcessor.h"
 #include "GrProcessor.h"
 #include "GrGLGpu.h"
 #include "GrPipeline.h"
 #include "SkChecksum.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 
 /**
  * Do we need to either map r,g,b->a or a->r. configComponentMask indicates which channels are
  * present in the texture's config. swizzleComponentMask indicates the channels present in the
  * shader swizzle.
  */
-static bool swizzle_requires_alpha_remapping(const GrGLCaps& caps,
+static bool swizzle_requires_alpha_remapping(const GrGLSLCaps& caps,
                                              uint32_t configComponentMask,
                                              uint32_t swizzleComponentMask) {
     if (caps.textureSwizzleSupport()) {
         // Any remapping is handled using texture swizzling not shader modifications.
         return false;
     }
     // check if the texture is alpha-only
     if (kA_GrColorComponentFlag == configComponentMask) {
         if (caps.textureRedSupport() && (kA_GrColorComponentFlag & swizzleComponentMask)) {
             // we must map the swizzle 'a's to 'r'.
             return true;
         }
         if (kRGB_GrColorComponentFlags & swizzleComponentMask) {
             // The 'r', 'g', and/or 'b's must be mapped to 'a' according to our semantics that
             // alpha-only textures smear alpha across all four channels when read.
             return true;
         }
     }
     return false;
 }
 
 static uint32_t gen_texture_key(const GrProcessor& proc, const GrGLCaps& caps) {
     uint32_t key = 0;
     int numTextures = proc.numTextures();
     for (int t = 0; t < numTextures; ++t) {
         const GrTextureAccess& access = proc.textureAccess(t);
         uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config());
-        if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) {
+        if (swizzle_requires_alpha_remapping(*caps.glslCaps(),
+                                             configComponentMask,
+                                             access.swizzleMask())) {
             key |= 1 << t;
         }
     }
     return key;
 }
 
 /**
  * A function which emits a meta key into the key builder.  This is required because shader code may
  * be dependent on properties of the effect that the effect itself doesn't use
  * in its key (e.g. the pixel format of textures used). So we create a meta-key for
@@ skipping 92 matching lines @@
     // --------DO NOT MOVE HEADER ABOVE THIS LINE--------------------------------------------------
     // Because header is a pointer into the dynamic array, we can't push any new data into the key
     // below here.
     KeyHeader* header = glDesc->atOffset<KeyHeader, kHeaderOffset>();
 
     // make sure any padding in the header is zeroed.
     memset(header, 0, kHeaderSize);
 
     if (pipeline.readsFragPosition()) {
         header->fFragPosKey =
-                GrGLFragmentShaderBuilder::KeyForFragmentPosition(pipeline.getRenderTarget(),
-                                                                  gpu->glCaps());
+                GrGLFragmentShaderBuilder::KeyForFragmentPosition(pipeline.getRenderTarget());
     } else {
         header->fFragPosKey = 0;
     }
     header->fSnapVerticesToPixelCenters = pipeline.snapVerticesToPixelCenters();
     header->fColorEffectCnt = pipeline.numColorFragmentProcessors();
     header->fCoverageEffectCnt = pipeline.numCoverageFragmentProcessors();
     glDesc->finalize();
     return true;
 }