Background filters are affected by masks

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 329 matching lines @@
     void main() {
       int quad_index = int(a_index * 0.25);  // NOLINT
       gl_Position = matrix[quad_index] * a_position;
       TexCoordPrecision vec4 texTrans = texTransform[quad_index];
       v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
       v_alpha = opacity[int(a_index)];  // NOLINT
     }
   });
 }
 
+void VertexShaderPosTexTransform::FillLocations(
+    ShaderLocations* locations) const {
+  locations->matrix = matrix_location();
+  locations->tex_transform = tex_transform_location();
+}
+
 std::string VertexShaderPosTexIdentity::GetShaderString() const {
   return VERTEX_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string VertexShaderPosTexIdentity::GetShaderHead() {
   return SHADER0([]() {
     attribute vec4 a_position;
     varying TexCoordPrecision vec2 v_texCoord;
   });
 }
@@ skipping 193 matching lines @@
                           dot(edge[2], screen_pos), dot(edge[3], screen_pos)) *
                      gl_Position.w;
       edge_dist[1] = vec4(dot(edge[4], screen_pos), dot(edge[5], screen_pos),
                           dot(edge[6], screen_pos), dot(edge[7], screen_pos)) *
                      gl_Position.w;
       v_texCoord = (pos.xy + vec2(0.5)) * texTrans.zw + texTrans.xy;
     }
   });
 }
 
+void VertexShaderQuadTexTransformAA::FillLocations(
+    ShaderLocations* locations) const {
+  locations->quad = quad_location();
+  locations->edge = edge_location();
+  locations->viewport = viewport_location();
+  locations->matrix = matrix_location();
+  locations->tex_transform = tex_transform_location();
+}
+
+
 VertexShaderTile::VertexShaderTile()
     : matrix_location_(-1),
       quad_location_(-1),
       vertex_tex_transform_location_(-1) {
 }
 
 void VertexShaderTile::Init(GLES2Interface* context,
                             unsigned program,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
@@ skipping 142 matching lines @@
 std::string VertexShaderVideoTransform::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       gl_Position = matrix * a_position;
       v_texCoord =
           vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
     }
   });
 }
 
-#define BLEND_MODE_UNIFORMS "s_backdropTexture", "backdropRect"
-#define UNUSED_BLEND_MODE_UNIFORMS (!has_blend_mode() ? 2 : 0)
+#define BLEND_MODE_UNIFORMS "s_backdropTexture", \
+                            "s_originalBackdropTexture", \
+                            "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) + 1, arraysize(X)); \
+    DCHECK_LT(static_cast<size_t>(POS) + 2, arraysize(X)); \
     backdrop_location_ = locations[POS];                   \
-    backdrop_rect_location_ = locations[POS + 1];          \
+    original_backdrop_location_ = locations[POS + 1];      \
+    backdrop_rect_location_ = locations[POS + 2];          \
   }
 
 FragmentTexBlendMode::FragmentTexBlendMode()
     : backdrop_location_(-1),
+      original_backdrop_location_(-1),
       backdrop_rect_location_(-1),
-      blend_mode_(BLEND_MODE_NONE) {
+      blend_mode_(BLEND_MODE_NONE),
+      mask_for_background_(false) {
 }
 
 std::string FragmentTexBlendMode::SetBlendModeFunctions(
     std::string shader_string) const {
   if (shader_string.find("ApplyBlendMode") == std::string::npos)
     return shader_string;
 
   if (!has_blend_mode()) {
-    return "#define ApplyBlendMode(X) (X)\n" + shader_string;
+    return "#define ApplyBlendMode(X) (X)\n"
+           "#define ApplyBlendModeWithMask(X, Y) (X)\n" +
+           shader_string;
   }
 
   static const std::string kFunctionApplyBlendMode = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
+    uniform sampler2D s_originalBackdropTexture;
     uniform TexCoordPrecision vec4 backdropRect;
 
     vec4 GetBackdropColor() {
       TexCoordPrecision vec2 bgTexCoord = gl_FragCoord.xy - backdropRect.xy;
       bgTexCoord.x /= backdropRect.z;
       bgTexCoord.y /= backdropRect.w;
       return texture2D(s_backdropTexture, bgTexCoord);
     }
 
     vec4 ApplyBlendMode(vec4 src) {
       vec4 dst = GetBackdropColor();
       return Blend(src, dst);
     }
+
+    vec4 GetBackdropColorWithMask(float mask) {
+      TexCoordPrecision vec2 bgTexCoord = gl_FragCoord.xy - backdropRect.xy;
+      bgTexCoord.x /= backdropRect.z;
+      bgTexCoord.y /= backdropRect.w;
+      vec4 backdrop = texture2D(s_backdropTexture, bgTexCoord);
+      vec4 original_backdrop = texture2D(s_originalBackdropTexture, bgTexCoord);
+      return mix(original_backdrop, backdrop, mask);
+    }
+
+    vec4 ApplyBlendModeWithMask(vec4 src, float mask) {
+      vec4 dst = GetBackdropColorWithMask(mask);
+      return Blend(src, dst);
+    }
   });
 
   return "precision mediump float;" + GetHelperFunctions() +
          GetBlendFunction() + kFunctionApplyBlendMode + shader_string;
 }
 
 std::string FragmentTexBlendMode::GetHelperFunctions() const {
   static const std::string kFunctionHardLight = SHADER0([]() {
     vec3 hardLight(vec4 src, vec4 dst) {
       vec3 result;
@@ skipping 324 matching lines @@
 
 std::string FragmentShaderRGBATexAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = ApplyBlendMode(texColor * alpha);
     }
   });
 }
 
+void FragmentShaderRGBATexAlpha::FillLocations(
+    ShaderLocations* locations) const {
+  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() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ skipping 11 matching lines @@
       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);
     }
   });
 }
 
+void FragmentShaderRGBATexColorMatrixAlpha::FillLocations(
+    ShaderLocations* locations) const {
+  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() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ skipping 249 matching lines @@
     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);
     }
   });
 }
 
+void FragmentShaderRGBATexAlphaAA::FillLocations(
+    ShaderLocations* locations) const {
+  locations->alpha = alpha_location();
+  locations->backdrop = backdrop_location();
+  locations->backdrop_rect = backdrop_rect_location();
+}
+
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       fragment_tex_transform_location_(-1) {
 }
 
 void FragmentTexClampAlphaAABinding::Init(GLES2Interface* context,
                                           unsigned program,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
@@ skipping 107 matching lines @@
   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());
+  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody(mask_for_background()));
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderHead() {
   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() {
+std::string FragmentShaderRGBATexAlphaMask::GetShaderBody(
+    bool mask_for_background) {
   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);
-    }
-  });
+                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord); }) +
+  (mask_for_background
+  ? SHADER0([]() { gl_FragColor = ApplyBlendModeWithMask(
+                       texColor * alpha * maskColor.w, maskColor.w); })
+  : SHADER0([]() { gl_FragColor = ApplyBlendMode(
+                       texColor * alpha * maskColor.w); })) +
+  SHADER0([]() {}});
+}
+
+void FragmentShaderRGBATexAlphaMask::FillLocations(
+    ShaderLocations* locations) const {
+  locations->mask_sampler = mask_sampler_location();
+  locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
+  locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
+  locations->alpha = alpha_location();
+  locations->backdrop = backdrop_location();
+  locations->backdrop_rect = backdrop_rect_location();
+  if (mask_for_background())
+    locations->original_backdrop = original_backdrop_location();
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
       mask_tex_coord_offset_location_(-1) {
 }
 
@@ skipping 20 matching lines @@
   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());
+  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody(mask_for_background()));
 }
 
 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderHead() {
   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() {
+std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderBody(
+    bool mask_for_background) {
   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);
+                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(texColor * alpha * maskColor.w * aa);
-    }
-  });
+      float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0); }) +
+  (mask_for_background
+  ? SHADER0([]() { gl_FragColor = ApplyBlendModeWithMask(
+                       texColor * alpha * maskColor.w * aa, maskColor.w); })
+  : SHADER0([]() { gl_FragColor = ApplyBlendMode(
+                       texColor * alpha * maskColor.w * aa); })) +
+  SHADER0([]() {}});
+}
+
+void FragmentShaderRGBATexAlphaMaskAA::FillLocations(
+    ShaderLocations* locations) const {
+  locations->mask_sampler = mask_sampler_location();
+  locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
+  locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
+  locations->alpha = alpha_location();
+  locations->backdrop = backdrop_location();
+  locations->backdrop_rect = backdrop_rect_location();
+  if (mask_for_background())
+    locations->original_backdrop = original_backdrop_location();
 }
 
 FragmentShaderRGBATexAlphaMaskColorMatrixAA::
     FragmentShaderRGBATexAlphaMaskColorMatrixAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
       color_matrix_location_(-1),
       color_offset_location_(-1) {
@@ skipping 27 matching lines @@
   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());
+  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody(mask_for_background()));
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderHead() {
   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() {
+std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderBody(
+    bool mask_for_background) {
   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);
+                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(texColor * alpha * maskColor.w * aa);
-    }
-  });
+      float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0); }) +
+  (mask_for_background
+  ? SHADER0([]() { gl_FragColor = ApplyBlendModeWithMask(
+                       texColor * alpha * maskColor.w * aa, maskColor.w); })
+  : SHADER0([]() { gl_FragColor = ApplyBlendMode(
+                       texColor * alpha * maskColor.w * aa); })) +
+  SHADER0([]() {}});
+}
+
+void FragmentShaderRGBATexAlphaMaskColorMatrixAA::FillLocations(
+    ShaderLocations* locations) const {
+  locations->alpha = alpha_location();
+  locations->mask_sampler = mask_sampler_location();
+  locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
+  locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
+  locations->color_matrix = color_matrix_location();
+  locations->color_offset = color_offset_location();
+  locations->backdrop = backdrop_location();
+  locations->backdrop_rect = backdrop_rect_location();
+  if (mask_for_background())
+    locations->original_backdrop = original_backdrop_location();
 }
 
 FragmentShaderRGBATexAlphaColorMatrixAA::
     FragmentShaderRGBATexAlphaColorMatrixAA()
     : sampler_location_(-1),
       alpha_location_(-1),
       color_matrix_location_(-1),
       color_offset_location_(-1) {
 }
 
@@ skipping 46 matching lines @@
       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);
       gl_FragColor = ApplyBlendMode(texColor * alpha * aa);
     }
   });
 }
 
+void FragmentShaderRGBATexAlphaColorMatrixAA::FillLocations(
+    ShaderLocations* locations) const {
+  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();
+}
+
 FragmentShaderRGBATexAlphaMaskColorMatrix::
     FragmentShaderRGBATexAlphaMaskColorMatrix()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1) {
 }
 
 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(GLES2Interface* context,
                                                      unsigned program,
@@ skipping 22 matching lines @@
   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());
+  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody(mask_for_background()));
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderHead() {
   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() {
+std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderBody(
+    bool mask_for_background) {
   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);
-      vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
-      gl_FragColor = ApplyBlendMode(texColor * alpha * maskColor.w);
-    }
-  });
+                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord); }) +
+  (mask_for_background
+  ? SHADER0([]() { gl_FragColor = ApplyBlendModeWithMask(
+                       texColor * alpha * maskColor.w, maskColor.w); })
+  : SHADER0([]() { gl_FragColor = ApplyBlendMode(
+                       texColor * alpha * maskColor.w); })) +
+  SHADER0([]() {}});
+}
+
+void FragmentShaderRGBATexAlphaMaskColorMatrix::FillLocations(
+    ShaderLocations* locations) const {
+  locations->mask_sampler = mask_sampler_location();
+  locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
+  locations->mask_tex_coord_offset = mask_tex_coord_offset_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();
+  if (mask_for_background())
+    locations->original_backdrop = original_backdrop_location();
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1),
       clamp_rect_location_(-1) {
@@ skipping 274 matching lines @@
       vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
       vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
       float picker = abs(coord.x - coord.y);  // NOLINT
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   });
 }
 
 }  // namespace cc