Update from https://crrev.com/304121

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 651 matching lines @@
         gl_Position = matrix * a_position;
         v_texCoord =
             vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 #define BLEND_MODE_UNIFORMS "s_backdropTexture", "backdropRect"
-#define UNUSED_BLEND_MODE_UNIFORMS (is_default_blend_mode() ? 2 : 0)
+#define UNUSED_BLEND_MODE_UNIFORMS (!has_blend_mode() ? 2 : 0)
 #define BLEND_MODE_SET_LOCATIONS(X, POS)                   \
-  if (!is_default_blend_mode()) {                          \
+  if (has_blend_mode()) {                                  \
     DCHECK_LT(static_cast<size_t>(POS) + 1, arraysize(X)); \
     backdrop_location_ = locations[POS];                   \
     backdrop_rect_location_ = locations[POS + 1];          \
   }
 
 FragmentTexBlendMode::FragmentTexBlendMode()
     : backdrop_location_(-1),
       backdrop_rect_location_(-1),
-      blend_mode_(BlendModeNormal) {
+      blend_mode_(BlendModeNone) {
 }
 
 std::string FragmentTexBlendMode::SetBlendModeFunctions(
     std::string shader_string) const {
   if (shader_string.find("ApplyBlendMode") == std::string::npos)
     return shader_string;
 
-  if (is_default_blend_mode()) {
+  if (!has_blend_mode()) {
     return "#define ApplyBlendMode(X) (X)\n" + shader_string;
   }
 
   // clang-format off
   static const std::string kFunctionApplyBlendMode = SHADER0(
       // clang-format on
       uniform SamplerType s_backdropTexture;
       uniform TexCoordPrecision vec4 backdropRect;
 
       vec4 GetBackdropColor() {
@@ skipping 193 matching lines @@
   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 {
   switch (blend_mode_) {
+    case BlendModeNormal:
+      return "result.rgb = src.rgb + dst.rgb * (1.0 - src.a);";
+    case BlendModeScreen:
+      return "result.rgb = src.rgb + (1.0 - src.rgb) * dst.rgb;";
     case BlendModeLighten:
       return "result.rgb = max((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
     case BlendModeOverlay:
       return "result.rgb = hardLight(dst, src);";
     case BlendModeDarken:
       return "result.rgb = min((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
     case BlendModeColorDodge:
       return "result.r = getColorDodgeComponent(src.r, src.a, dst.r, dst.a);"
@@ skipping 41 matching lines @@
              "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;";
     case BlendModeLuminosity:
       return "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;";
-    default:
+    case BlendModeNone:
+    case NumBlendModes:
       NOTREACHED();
-      // simple alpha compositing
-      return "result.rgb = src.rgb * src.a + dst.rgb * dst.a * (1 - src.a)";
   }
+  return "result = vec4(1.0, 0.0, 0.0, 1.0);";
 }
 
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1), alpha_location_(-1) {
 }
 
 void FragmentTexAlphaBinding::Init(GLES2Interface* context,
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
@@ skipping 999 matching lines @@
         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;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 }  // namespace cc