[WIP Experiment] Implement mix-blend-mode in GLRenderer using shaders.

cc/output/shader.cc

Index: cc/output/shader.cc
diff --git a/cc/output/shader.cc b/cc/output/shader.cc
index 72d89d23c0983ac7ddb3ec44acb0809984f3a80f..d74cb034a77652245481647691a0da95843cae59 100644
--- a/cc/output/shader.cc
+++ b/cc/output/shader.cc
@@ -15,6 +15,11 @@
 #define VERTEX_SHADER(Src) SetVertexTexCoordPrecision(SHADER0(Src))
 #define FRAGMENT_SHADER(Src) SetFragmentTexCoordPrecision( \
     precision, SetFragmentSamplerType(sampler, SHADER0(Src)))
+#define FRAGMENT_BLENDMODE_SHADER(Src) \
+  SetFragmentTexCoordPrecision(        \
+      precision,                       \
+      SetFragmentSamplerType(sampler,  \
+                             SetBlendModeFunctions(blend_mode, SHADER0(Src))))
 
 using gpu::gles2::GLES2Interface;
 
@@ -626,27 +631,353 @@ std::string VertexShaderVideoTransform::GetShaderString() const {
   );  // NOLINT(whitespace/parens)
 }
 
+const char* FragmentTexBlendMode::kUniformBackdropTexture = "s_backdropTexture";
+const char* FragmentTexBlendMode::kUniformBackdropRect = "backdropRect";
+
+FragmentTexBlendMode::FragmentTexBlendMode()
+    : backdrop_location_(-1), backdrop_rect_location_(-1) {
+}
+
+std::string FragmentTexBlendMode::SetBlendModeFunctions(
+    SkXfermode::Mode blend_mode,
+    std::string shader_string) {
+  static const std::string kBlendModeFunctionsPlaceHolder(
+      "BlendColorFunctions");
+  auto placeholder_location =
+      shader_string.find(kBlendModeFunctionsPlaceHolder);
+  if (placeholder_location == std::string::npos)
+    return shader_string;
+
+  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)
+                    : (src.a * dst.a - 2.0 * (dst.a - dst.g) * (src.a - src.g));
+        result.b = (2.0 * src.b <= src.a)
+                    ? (2.0 * src.b * dst.b)
+                    : (src.a * dst.a - 2.0 * (dst.a - dst.b) * (src.a - src.b));
+        result.rgb += src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a);
+        return result;
+      }
+  );
+
+  static const std::string kFunctionColorDodgeComponent = SHADER0(
+      float getColorDodgeComponent(float srcc, float srca,
+                                   float dstc, float dsta) {
+        if (0.0 == dstc)
+          return srcc * (1.0 - dsta);
+        float d = srca - srcc;
+        if (0.0 == d)
+          return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+        d = min(dsta, dstc * srca / d);
+        return d * srca + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+      }
+  );
+
+  static const std::string kFunctionColorBurnComponent = SHADER0(
+      float getColorBurnComponent(float srcc, float srca,
+                                  float dstc, float dsta) {
+        if (dsta == dstc)
+          return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+        if (0.0 == srcc)
+          return dstc * (1.0 - srca);
+        float d = max(0.0, dsta - (dsta - dstc) * srca / srcc);
+        return srca * d + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+      }
+  );
+
+  static const std::string kFunctionSoftLightComponentPosDstAlpha = SHADER0(
+      float getSoftLightComponent(float srcc, float srca,
+                                  float dstc, float dsta) {
+        if (2.0 * srcc <= srca) {
+          return (dstc * dstc * (srca - 2.0 * srcc)) / dsta +
+                  (1.0 - dsta) * srcc + dstc * (-srca + 2.0 * srcc + 1.0);
+        } else if (4.0 * dstc <= dsta) {
+          float DSqd = dstc * dstc;
+          float DCub = DSqd * dstc;
+          float DaSqd = dsta * dsta;
+          float DaCub = DaSqd * dsta;
+          return (-DaCub * srcc +
+                  DaSqd * (srcc - dstc * (3.0 * srca - 6.0 * srcc - 1.0)) +
+                  12.0 * dsta * DSqd * (srca - 2.0 * srcc) -
+                  16.0 * DCub * (srca - 2.0 * srcc)) /
+                  DaSqd;
+        } else {
+          return -sqrt(dsta * dstc) * (srca - 2.0 * srcc) - dsta * srcc +
+                  dstc * (srca - 2.0 * srcc + 1.0) + srcc;
+        }
+      }
+  );
+
+  static const std::string kFunctionLum = SHADER0(
+      float luminance(vec3 color) {
+        return dot(vec3(0.3, 0.59, 0.11), color);
+      }
+      vec3 set_luminance(vec3 hueSat, float alpha, vec3 lumColor) {
+        float diff = luminance(lumColor - hueSat);
+        vec3 outColor = hueSat + diff;
+        float outLum = luminance(outColor);
+        float minComp = min(min(outColor.r, outColor.g), outColor.b);
+        float maxComp = max(max(outColor.r, outColor.g), outColor.b);
+        if (minComp < 0.0) {
+          outColor = outLum +
+                     ((outColor - vec3(outLum, outLum, outLum)) * outLum) /
+                         (outLum - minComp);
+        }
+        if (maxComp > alpha) {
+          outColor =
+              outLum +
+              ((outColor - vec3(outLum, outLum, outLum)) * (alpha - outLum)) /
+                  (maxComp - outLum);
+        }
+        return outColor;
+      }
+  );
+
+  static const std::string kFunctionSat = SHADER0(
+      float saturation(vec3 color) {
+        return max(max(color.r, color.g), color.b) -
+               min(min(color.r, color.g), color.b);
+      }
+      vec3 set_saturation_helper(float minComp,
+                                 float midComp,
+                                 float maxComp,
+                                 float sat) {
+        if (minComp < maxComp) {
+          vec3 result;
+          result.r = 0.0;
+          result.g = sat * (midComp - minComp) / (maxComp - minComp);
+          result.b = sat;
+          return result;
+        } else {
+          return vec3(0, 0, 0);
+        }
+      }
+      vec3 set_saturation(vec3 hueLumColor, vec3 satColor) {
+        float sat = saturation(satColor);
+        if (hueLumColor.r <= hueLumColor.g) {
+          if (hueLumColor.g <= hueLumColor.b) {
+            hueLumColor.rgb = set_saturation_helper(
+                hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);
+          } else if (hueLumColor.r <= hueLumColor.b) {
+            hueLumColor.rbg = set_saturation_helper(
+                hueLumColor.r, hueLumColor.b, hueLumColor.g, sat);
+          } else {
+            hueLumColor.brg = set_saturation_helper(
+                hueLumColor.b, hueLumColor.r, hueLumColor.g, sat);
+          }
+        } else if (hueLumColor.r <= hueLumColor.b) {
+          hueLumColor.grb = set_saturation_helper(
+              hueLumColor.g, hueLumColor.r, hueLumColor.b, sat);
+        } else if (hueLumColor.g <= hueLumColor.b) {
+          hueLumColor.gbr = set_saturation_helper(
+              hueLumColor.g, hueLumColor.b, hueLumColor.r, sat);
+        } else {
+          hueLumColor.bgr = set_saturation_helper(
+              hueLumColor.b, hueLumColor.g, hueLumColor.r, sat);
+        }
+        return hueLumColor;
+      }
+  );
+
+  static const std::string kHeaderBlending =
+      std::string("#define BackdropTextureUniform ") + kUniformBackdropTexture +
+      std::string("\n#define BackdropRectUniform ") + kUniformBackdropRect +
+      std::string("\n");
+
+  static const std::string kHeaderNoBlending = "\n#define blendColor(X) X\n";
+
+  std::string blend_mode_helper_functions;
+
+  static const std::string kCommonHeaderBlendingFunctions = SHADER0(
+      uniform SamplerType BackdropTextureUniform;
+      uniform TexCoordPrecision vec4 BackdropRectUniform;
+      vec4 getBackdropColor() {
+        TexCoordPrecision vec2 bgTexCoord =
+            gl_FragCoord.xy - BackdropRectUniform.xy;
+        bgTexCoord.x /= BackdropRectUniform.z;
+        bgTexCoord.y /= BackdropRectUniform.w;
+        return TextureLookup(BackdropTextureUniform, bgTexCoord);
+      }
+      vec4 blendColor(vec4 src) {
+        vec4 dst = getBackdropColor();
+        vec4 result;
+        result.a = src.a + (1.0 - src.a) * dst.a;
+        // result.rgb will be calculated inside the switch bellow.
+  );
+
+  std::string blend_mode_formula_rgb;
+
+  static const std::string kCommonFooterBlendingFunctions = SHADER0(
+        return result;
+      }
+  );
+
+  switch (blend_mode) {
+    case SkXfermode::kSrcOver_Mode:
+      // The default blend mode.
+      break;
+    case SkXfermode::kScreen_Mode:
+    case SkXfermode::kLighten_Mode:
+      // These blend modes are implemented using coefficients.
+      NOTREACHED();
+      break;
+    case SkXfermode::kOverlay_Mode:
+      blend_mode_helper_functions = kFunctionHardLight;
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = hardLight(dst, src);
+      );
+      break;
+    case SkXfermode::kDarken_Mode:
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = min((1.0 - src.a) * dst.rgb + src.rgb,
+                           (1.0 - dst.a) * src.rgb + dst.rgb);
+      );
+      break;
+    case SkXfermode::kColorDodge_Mode:
+      blend_mode_helper_functions = kFunctionColorDodgeComponent;
+      blend_mode_formula_rgb = SHADER0(
+          result.r = getColorDodgeComponent(src.r, src.a, dst.r, dst.a);
+          result.g = getColorDodgeComponent(src.g, src.a, dst.g, dst.a);
+          result.b = getColorDodgeComponent(src.b, src.a, dst.b, dst.a);
+      );
+      break;
+    case SkXfermode::kColorBurn_Mode:
+      blend_mode_helper_functions = kFunctionColorBurnComponent;
+      blend_mode_formula_rgb = SHADER0(
+          result.r = getColorBurnComponent(src.r, src.a, dst.r, dst.a);
+          result.g = getColorBurnComponent(src.g, src.a, dst.g, dst.a);
+          result.b = getColorBurnComponent(src.b, src.a, dst.b, dst.a);
+      );
+      break;
+    case SkXfermode::kHardLight_Mode:
+      blend_mode_helper_functions = kFunctionHardLight;
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = hardLight(src, dst);
+      );
+      break;
+    case SkXfermode::kSoftLight_Mode:
+      blend_mode_helper_functions = kFunctionSoftLightComponentPosDstAlpha;
+      blend_mode_formula_rgb = SHADER0(
+          if (0.0 == dst.a) {
+            result.rgba = src;
+          } else {
+            result.r = getSoftLightComponent(src.r, src.a, dst.r, dst.a);
+            result.g = getSoftLightComponent(src.g, src.a, dst.g, dst.a);
+            result.b = getSoftLightComponent(src.b, src.a, dst.b, dst.a);
+          }
+      );
+      break;
+    case SkXfermode::kDifference_Mode:
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = src.rgb + dst.rgb -
+                       2.0 * min(src.rgb * dst.a, dst.rgb * src.a);
+      );
+      break;
+    case SkXfermode::kExclusion_Mode:
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = dst.rgb + src.rgb - 2.0 * dst.rgb * src.rgb;
+      );
+      break;
+    case SkXfermode::kMultiply_Mode:
+      blend_mode_formula_rgb = SHADER0(
+          result.rgb = (1.0 - src.a) * dst.rgb +
+                       (1.0 - dst.a) * src.rgb + src.rgb * dst.rgb;
+      );
+      break;
+    case SkXfermode::kHue_Mode:
+      blend_mode_helper_functions = kFunctionLum + kFunctionSat;
+      blend_mode_formula_rgb = SHADER0(
+          vec4 dstSrcAlpha = dst * src.a;
+          result.rgb =
+              set_luminance(set_saturation(src.rgb * dst.a, dstSrcAlpha.rgb),
+                            dstSrcAlpha.a,
+                            dstSrcAlpha.rgb);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+      );
+      break;
+    case SkXfermode::kSaturation_Mode:
+      blend_mode_helper_functions = kFunctionLum + kFunctionSat;
+      blend_mode_formula_rgb = SHADER0(
+          vec4 dstSrcAlpha = dst * src.a;
+          result.rgb =
+              set_luminance(set_saturation(dstSrcAlpha.rgb, src.rgb * dst.a),
+                            dstSrcAlpha.a,
+                            dstSrcAlpha.rgb);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+      );
+      break;
+    case SkXfermode::kColor_Mode:
+      blend_mode_helper_functions = kFunctionLum;
+      blend_mode_formula_rgb = SHADER0(
+          vec4 srcDstAlpha = src * dst.a;
+          result.rgb =
+              set_luminance(srcDstAlpha.rgb, srcDstAlpha.a, dst.rgb * src.a);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+      );
+      break;
+    case SkXfermode::kLuminosity_Mode:
+      blend_mode_helper_functions = kFunctionLum;
+      blend_mode_formula_rgb = SHADER0(
+          vec4 srcDstAlpha = src * dst.a;
+          result.rgb =
+              set_luminance(dst.rgb * src.a, srcDstAlpha.a, srcDstAlpha.rgb);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+      );
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  if (blend_mode_formula_rgb.empty()) {
+    shader_string.replace(placeholder_location,
+                          kBlendModeFunctionsPlaceHolder.length(),
+                          std::string());
+    return kHeaderNoBlending + shader_string;
+  }
+
+  shader_string.replace(

[enne (OOO), 2014/09/24 22:07:56]

This is kind a bit sketchy.  Why can't your macro just stick these functions in
the right place in the same way that the precision macros do? Rather than
attempting to fix them up after the fact?

+      placeholder_location,
+      kBlendModeFunctionsPlaceHolder.length(),
+      blend_mode_helper_functions + kCommonHeaderBlendingFunctions +
+          blend_mode_formula_rgb + kCommonFooterBlendingFunctions);
+
+  return kHeaderBlending + shader_string;
+}
+
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
 void FragmentTexAlphaBinding::Init(GLES2Interface* context,
                                    unsigned program,
-                                   int* base_uniform_index) {
+                                   int* base_uniform_index,
+                                   bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
+    kUniformBackdropTexture,
+    kUniformBackdropRect
   };
   int locations[arraysize(uniforms)];
+  size_t count = arraysize(uniforms) - (needs_backdrop_texture ? 0 : 2);
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             count,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
+  if (needs_backdrop_texture) {
+    backdrop_location_ = locations[2];
+    backdrop_rect_location_ = locations[3];
+  }
 }
 
 FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
@@ -657,7 +988,8 @@ FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
 
 void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
                                               unsigned program,
-                                              int* base_uniform_index) {
+                                              int* base_uniform_index,
+                                              bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
@@ -699,21 +1031,26 @@ void FragmentTexOpaqueBinding::Init(GLES2Interface* context,
 }
 
 std::string FragmentShaderRGBATexAlpha::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
-  return FRAGMENT_SHADER(
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode blend_mode) const {
+  return FRAGMENT_BLENDMODE_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
+    BlendColorFunctions
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = texColor * alpha;
+      gl_FragColor = blendColor(texColor) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ -882,38 +1219,48 @@ FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
 
 void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
                                         unsigned program,
-                                        int* base_uniform_index) {
+                                        int* base_uniform_index,
+                                        bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
+    kUniformBackdropTexture,
+    kUniformBackdropRect
   };
   int locations[arraysize(uniforms)];
+  size_t count = arraysize(uniforms) - (needs_backdrop_texture ? 0 : 2);
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             count,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
+  if (needs_backdrop_texture) {
+    backdrop_location_ = locations[2];
+    backdrop_rect_location_ = locations[3];
+  }
 }
 
 std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
-  return FRAGMENT_SHADER(
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode blend_mode) const {
+  return FRAGMENT_BLENDMODE_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
-
+    BlendColorFunctions
     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 = texColor * alpha * aa;
+      gl_FragColor = blendColor(texColor) * alpha * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
@@ -999,7 +1346,8 @@ FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
 
 void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
                                           unsigned program,
-                                          int* base_uniform_index) {
+                                          int* base_uniform_index,
+                                          bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
@@ -1023,7 +1371,9 @@ void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ -1052,7 +1402,8 @@ FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
 
 void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
                                             unsigned program,
-                                            int* base_uniform_index) {
+                                            int* base_uniform_index,
+                                            bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
@@ -1076,7 +1427,9 @@ void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
 }
 
 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
@@ -1113,7 +1466,8 @@ FragmentShaderRGBATexAlphaMaskColorMatrixAA::
 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
     GLES2Interface* context,
     unsigned program,
-    int* base_uniform_index) {
+    int* base_uniform_index,
+    bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
@@ -1141,7 +1495,9 @@ void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
@@ -1181,9 +1537,10 @@ FragmentShaderRGBATexAlphaColorMatrixAA::
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
-      GLES2Interface* context,
-      unsigned program,
-      int* base_uniform_index) {
+    GLES2Interface* context,
+    unsigned program,
+    int* base_uniform_index,
+    bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
@@ -1205,7 +1562,9 @@ void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
 }
 
 std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
@@ -1240,7 +1599,8 @@ FragmentShaderRGBATexAlphaMaskColorMatrix::
 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
     GLES2Interface* context,
     unsigned program,
-    int* base_uniform_index) {
+    int* base_uniform_index,
+    bool needs_backdrop_texture) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
@@ -1268,7 +1628,9 @@ void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
-    TexCoordPrecision precision, SamplerType sampler) const {
+    TexCoordPrecision precision,
+    SamplerType sampler,
+    SkXfermode::Mode mode) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;