The great shader refactor: Delete instances of GetShaderSource

cc/output/shader.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 11 matching lines @@
                 "String passed to StripLambda must be at least 8 characters");
   DCHECK_EQ(strncmp("[]() {", shader, 6), 0);
   DCHECK_EQ(shader[size - 2], '}');
   return std::string(shader + 6, shader + size - 2);
 }
 
 // Shaders are passed in with lambda syntax, which tricks clang-format into
 // handling them correctly. StipLambda removes this.
 #define SHADER0(Src) StripLambda(#Src)
 #define VERTEX_SHADER(Head, Body) SetVertexShaderDefines(Head + Body)
-#define FRAGMENT_SHADER(Head, Body) \
-  SetFragmentTexCoordPrecision(     \
-      precision,                    \
-      SetFragmentSamplerType(sampler, SetBlendModeFunctions(Head + Body)))
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 namespace {
 
 static void GetProgramUniformLocations(GLES2Interface* context,
                                        unsigned program,
                                        size_t count,
@@ skipping 716 matching lines @@
                             "backdropRect"
 #define UNUSED_BLEND_MODE_UNIFORMS (!has_blend_mode() ? 3 : 0)
 #define BLEND_MODE_SET_LOCATIONS(X, POS)                   \
   if (has_blend_mode()) {                                  \
     DCHECK_LT(static_cast<size_t>(POS) + 2, arraysize(X)); \
     backdrop_location_ = locations[POS];                   \
     original_backdrop_location_ = locations[POS + 1];      \
     backdrop_rect_location_ = locations[POS + 2];          \
   }
 
-FragmentTexBlendMode::FragmentTexBlendMode()
+FragmentShaderBase::FragmentShaderBase()
     : backdrop_location_(-1),
       original_backdrop_location_(-1),
       backdrop_rect_location_(-1),
       blend_mode_(BLEND_MODE_NONE),
-      mask_for_background_(false) {
+      mask_for_background_(false) {}
+
+std::string FragmentShaderBase::GetShaderString(TexCoordPrecision precision,
+                                                SamplerType sampler) const {
+  return SetFragmentTexCoordPrecision(
+      precision, SetFragmentSamplerType(
+                     sampler, SetBlendModeFunctions(GetShaderSource())));
 }
 
-std::string FragmentTexBlendMode::SetBlendModeFunctions(
+std::string FragmentShaderBase::SetBlendModeFunctions(
     const std::string& shader_string) const {
   if (shader_string.find("ApplyBlendMode") == std::string::npos)
     return shader_string;
 
   if (!has_blend_mode()) {
     return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
@@ skipping 31 matching lines @@
       vec4 dst = GetBackdropColor(mask);
       return Blend(src, dst);
     }
   });
 
   return "precision mediump float;" + GetHelperFunctions() +
          GetBlendFunction() + kUniforms + mixFunction +
          kFunctionApplyBlendMode + shader_string;
 }
 
-std::string FragmentTexBlendMode::GetHelperFunctions() const {
+std::string FragmentShaderBase::GetHelperFunctions() const {
   static const std::string kFunctionHardLight = SHADER0([]() {
     vec3 hardLight(vec4 src, vec4 dst) {
       vec3 result;
       result.r =
           (2.0 * src.r <= src.a)
               ? (2.0 * src.r * dst.r)
               : (src.a * dst.a - 2.0 * (dst.a - dst.r) * (src.a - src.r));
       result.g =
           (2.0 * src.g <= src.a)
               ? (2.0 * src.g * dst.g)
@@ skipping 140 matching lines @@
     case BLEND_MODE_SATURATION:
       return kFunctionLum + kFunctionSat;
     case BLEND_MODE_COLOR:
     case BLEND_MODE_LUMINOSITY:
       return kFunctionLum;
     default:
       return std::string();
   }
 }
 
-std::string FragmentTexBlendMode::GetBlendFunction() const {
+std::string FragmentShaderBase::GetBlendFunction() const {
   return "vec4 Blend(vec4 src, vec4 dst) {"
          "    vec4 result;"
          "    result.a = src.a + (1.0 - src.a) * dst.a;" +
          GetBlendFunctionBodyForRGB() +
          "    return result;"
          "}";
 }
 
-std::string FragmentTexBlendMode::GetBlendFunctionBodyForRGB() const {
+std::string FragmentShaderBase::GetBlendFunctionBodyForRGB() const {
   switch (blend_mode_) {
     case BLEND_MODE_NORMAL:
       return "result.rgb = src.rgb + dst.rgb * (1.0 - src.a);";
     case BLEND_MODE_SCREEN:
       return "result.rgb = src.rgb + (1.0 - src.rgb) * dst.rgb;";
     case BLEND_MODE_LIGHTEN:
       return "result.rgb = max((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
     case BLEND_MODE_OVERLAY:
       return "result.rgb = hardLight(dst, src);";
@@ skipping 123 matching lines @@
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
 }
 
-std::string FragmentShaderRGBATexAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlpha::GetShaderHead() {
+std::string FragmentShaderRGBATexAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
-  });
-}
-
-std::string FragmentShaderRGBATexAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = ApplyBlendMode(texColor * alpha, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexAlpha::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->backdrop = backdrop_location();
   locations->backdrop_rect = backdrop_rect_location();
 }
 
-std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderHead() {
+std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
-  });
-}
-
-std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       gl_FragColor = ApplyBlendMode(texColor * alpha, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexColorMatrixAlpha::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->color_matrix = color_matrix_location();
   locations->color_offset = color_offset_location();
   locations->backdrop = backdrop_location();
   locations->backdrop_rect = backdrop_rect_location();
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderHead() {
+std::string FragmentShaderRGBATexVaryingAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderHead() {
+std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
     : background_color_location_(-1), sampler_location_(-1) {
@@ skipping 14 matching lines @@
                              locations,
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   DCHECK_NE(sampler_location_, -1);
 
   background_color_location_ = locations[1];
   DCHECK_NE(background_color_location_, -1);
 }
 
-std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderHead() {
+std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform vec4 background_color;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor += background_color * (1.0 - texColor.a);
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
-std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderHead() {
+std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderSource()
+    const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform vec4 background_color;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
       texColor += background_color * (1.0 - texColor.a);
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
-std::string FragmentShaderRGBATexOpaque::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexOpaque::GetShaderHead() {
+std::string FragmentShaderRGBATexOpaque::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATexOpaque::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.rgb, 1.0);
     }
   });
 }
 
-std::string FragmentShaderRGBATex::GetShaderString(TexCoordPrecision precision,
-                                                   SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATex::GetShaderHead() {
+std::string FragmentShaderRGBATex::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATex::GetShaderBody() {
-  return SHADER0([]() {
     void main() { gl_FragColor = TextureLookup(s_texture, v_texCoord); }
   });
 }
 
-std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderHead() {
+std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
-  });
-}
-
-std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor =
           vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
     }
   });
 }
 
-std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderHead() {
+std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
     }
   });
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1), alpha_location_(-1) {
 }
@@ skipping 10 matching lines @@
                              program,
                              arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   BLEND_MODE_SET_LOCATIONS(locations, 2);
 }
 
-std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaAA::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = ApplyBlendMode(texColor * alpha * aa, 0.0);
     }
   });
 }
 
@@ skipping 23 matching lines @@
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   fragment_tex_transform_location_ = locations[2];
 }
 
-std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexClampAlphaAA::GetShaderHead() {
+std::string FragmentShaderRGBATexClampAlphaAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform TexCoordPrecision vec4 fragmentTexTransform;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexClampAlphaAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
       vec4 texColor = TextureLookup(s_texture, texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * aa;
     }
   });
 }
 
-std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderHead() {
+std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform TexCoordPrecision vec4 fragmentTexTransform;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
       vec4 texColor = TextureLookup(s_texture, texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor =
           vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha * aa;
@@ skipping 28 matching lines @@
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   BLEND_MODE_SET_LOCATIONS(locations, 5);
 }
 
-std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaMask::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaMask::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform sampler2D s_texture;
     uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaMask::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       gl_FragColor = ApplyBlendMode(
           texColor * alpha * maskColor.w, maskColor.w);
     }
   });
@@ skipping 40 matching lines @@
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   BLEND_MODE_SET_LOCATIONS(locations, 5);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform sampler2D s_texture;
     uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = ApplyBlendMode(
@@ skipping 50 matching lines @@
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
   BLEND_MODE_SET_LOCATIONS(locations, 7);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderSource()
+    const {
   return SHADER0([]() {
     precision mediump float;
     uniform sampler2D s_texture;
     uniform SamplerType s_mask;
     uniform vec2 maskTexCoordScale;
     uniform vec2 maskTexCoordOffset;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
@@ skipping 44 matching lines @@
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
   BLEND_MODE_SET_LOCATIONS(locations, 4);
 }
 
-std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
@@ skipping 44 matching lines @@
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
   BLEND_MODE_SET_LOCATIONS(locations, 7);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
-    TexCoordPrecision precision,
-    SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderHead() {
+std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform sampler2D s_texture;
     uniform SamplerType s_mask;
     uniform vec2 maskTexCoordScale;
     uniform vec2 maskTexCoordOffset;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
-  });
-}
-
-std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
@@ skipping 84 matching lines @@
     resource_offset_location_ = locations[7];
   } else {
     yuv_matrix_location_ = locations[8];
     yuv_adj_location_ = locations[9];
   }
   alpha_location_ = locations[10];
   ya_clamp_rect_location_ = locations[11];
   uv_clamp_rect_location_ = locations[12];
 }
 
-std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
-                                                    SamplerType sampler) const {
+std::string FragmentShaderYUVVideo::GetShaderSource() const {
   std::string head = SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_yaTexCoord;
     varying TexCoordPrecision vec2 v_uvTexCoord;
     uniform SamplerType y_texture;
     uniform float alpha;
     uniform vec4 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
@@ skipping 66 matching lines @@
       vec2 ya_clamped =
           max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
       float y_raw = TextureLookup(y_texture, ya_clamped).x;
       vec2 uv_clamped =
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
-  return FRAGMENT_SHADER(head, functions);
+  return head + functions;
 }
 
 FragmentShaderColor::FragmentShaderColor() : color_location_(-1) {
 }
 
 void FragmentShaderColor::Init(GLES2Interface* context,
                                unsigned program,
                                int* base_uniform_index) {
   static const char* uniforms[] = {
       "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
-std::string FragmentShaderColor::GetShaderString(TexCoordPrecision precision,
-                                                 SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderColor::GetShaderHead() {
+std::string FragmentShaderColor::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform vec4 color;
-  });
-}
-
-std::string FragmentShaderColor::GetShaderBody() {
-  return SHADER0([]() {
     void main() { gl_FragColor = color; }
   });
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA() : color_location_(-1) {
 }
 
 void FragmentShaderColorAA::Init(GLES2Interface* context,
                                  unsigned program,
                                  int* base_uniform_index) {
   static const char* uniforms[] = {
       "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
-std::string FragmentShaderColorAA::GetShaderString(TexCoordPrecision precision,
-                                                   SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderColorAA::GetShaderHead() {
+std::string FragmentShaderColorAA::GetShaderSource() const {
   return SHADER0([]() {
     precision mediump float;
     uniform vec4 color;
     varying vec4 edge_dist[2];  // 8 edge distances.
-  });
-}
-
-std::string FragmentShaderColorAA::GetShaderBody() {
-  return SHADER0([]() {
     void main() {
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = color * aa;
     }
   });
 }
 
 }  // namespace cc