Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

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 34 matching lines @@
   for (size_t i = 0; i < count; i++) {
     locations[i] = (*base_uniform_index)++;
     context->BindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
   }
 }
 
 static std::string SetFragmentTexCoordPrecision(
     TexCoordPrecision requested_precision,
     std::string shader_string) {
   switch (requested_precision) {
-    case TEX_COORD_PRECISION_HIGH:
+    case TexCoordPrecisionHigh:
       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
       return "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
              "  #define TexCoordPrecision highp\n"
              "#else\n"
              "  #define TexCoordPrecision mediump\n"
              "#endif\n" +
              shader_string;
-    case TEX_COORD_PRECISION_MEDIUM:
+    case TexCoordPrecisionMedium:
       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
       return "#define TexCoordPrecision mediump\n" + shader_string;
-    case TEX_COORD_PRECISION_NA:
+    case TexCoordPrecisionNA:
       DCHECK_EQ(shader_string.find("TexCoordPrecision"), std::string::npos);
       DCHECK_EQ(shader_string.find("texture2D"), std::string::npos);
       DCHECK_EQ(shader_string.find("texture2DRect"), std::string::npos);
       return shader_string;
     default:
       NOTREACHED();
       break;
   }
   return shader_string;
 }
@@ skipping 20 matching lines @@
     GLint range[2] = {14, 14};
     GLint precision = 10;
     GLC(context,
         context->GetShaderPrecisionFormat(
             GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT, range, &precision));
     *highp_threshold_cache = 1 << precision;
   }
 
   int highp_threshold = std::max(*highp_threshold_cache, highp_threshold_min);
   if (x > highp_threshold || y > highp_threshold)
-    return TEX_COORD_PRECISION_HIGH;
-  return TEX_COORD_PRECISION_MEDIUM;
+    return TexCoordPrecisionHigh;
+  return TexCoordPrecisionMedium;
 }
 
 static std::string SetFragmentSamplerType(SamplerType requested_type,
                                           std::string shader_string) {
   switch (requested_type) {
-    case SAMPLER_TYPE_2D:
+    case SamplerType2D:
       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
       return "#define SamplerType sampler2D\n"
              "#define TextureLookup texture2D\n" +
              shader_string;
-    case SAMPLER_TYPE_2D_RECT:
+    case SamplerType2DRect:
       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
       return "#extension GL_ARB_texture_rectangle : require\n"
              "#define SamplerType sampler2DRect\n"
              "#define TextureLookup texture2DRect\n" +
              shader_string;
-    case SAMPLER_TYPE_EXTERNAL_OES:
+    case SamplerTypeExternalOES:
       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
       return "#extension GL_OES_EGL_image_external : require\n"
              "#define SamplerType samplerExternalOES\n"
              "#define TextureLookup texture2D\n" +
              shader_string;
-    case SAMPLER_TYPE_NA:
+    case SamplerTypeNA:
       DCHECK_EQ(shader_string.find("SamplerType"), std::string::npos);
       DCHECK_EQ(shader_string.find("TextureLookup"), std::string::npos);
       return shader_string;
     default:
       NOTREACHED();
       break;
   }
   return shader_string;
 }
 
@@ skipping 582 matching lines @@
 #define BLEND_MODE_SET_LOCATIONS(X, POS)                   \
   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_(BLEND_MODE_NONE) {
+      blend_mode_(BlendModeNone) {
 }
 
 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;
   }
@@ skipping 153 matching lines @@
                                                 hueLumColor.r, sat);
       } else {
         hueLumColor.bgr = set_saturation_helper(hueLumColor.b, hueLumColor.g,
                                                 hueLumColor.r, sat);
       }
       return hueLumColor;
     }
   });
 
   switch (blend_mode_) {
-    case BLEND_MODE_OVERLAY:
-    case BLEND_MODE_HARD_LIGHT:
+    case BlendModeOverlay:
+    case BlendModeHardLight:
       return kFunctionHardLight;
-    case BLEND_MODE_COLOR_DODGE:
+    case BlendModeColorDodge:
       return kFunctionColorDodgeComponent;
-    case BLEND_MODE_COLOR_BURN:
+    case BlendModeColorBurn:
       return kFunctionColorBurnComponent;
-    case BLEND_MODE_SOFT_LIGHT:
+    case BlendModeSoftLight:
       return kFunctionSoftLightComponentPosDstAlpha;
-    case BLEND_MODE_HUE:
-    case BLEND_MODE_SATURATION:
+    case BlendModeHue:
+    case BlendModeSaturation:
       return kFunctionLum + kFunctionSat;
-    case BLEND_MODE_COLOR:
-    case BLEND_MODE_LUMINOSITY:
+    case BlendModeColor:
+    case BlendModeLuminosity:
       return kFunctionLum;
     default:
       return std::string();
   }
 }
 
 std::string FragmentTexBlendMode::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 {
   switch (blend_mode_) {
-    case BLEND_MODE_NORMAL:
+    case BlendModeNormal:
       return "result.rgb = src.rgb + dst.rgb * (1.0 - src.a);";
-    case BLEND_MODE_SCREEN:
+    case BlendModeScreen:
       return "result.rgb = src.rgb + (1.0 - src.rgb) * dst.rgb;";
-    case BLEND_MODE_LIGHTEN:
+    case BlendModeLighten:
       return "result.rgb = max((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
-    case BLEND_MODE_OVERLAY:
+    case BlendModeOverlay:
       return "result.rgb = hardLight(dst, src);";
-    case BLEND_MODE_DARKEN:
+    case BlendModeDarken:
       return "result.rgb = min((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
-    case BLEND_MODE_COLOR_DODGE:
+    case BlendModeColorDodge:
       return "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);";
-    case BLEND_MODE_COLOR_BURN:
+    case BlendModeColorBurn:
       return "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);";
-    case BLEND_MODE_HARD_LIGHT:
+    case BlendModeHardLight:
       return "result.rgb = hardLight(src, dst);";
-    case BLEND_MODE_SOFT_LIGHT:
+    case BlendModeSoftLight:
       return "if (0.0 == dst.a) {"
              "  result.rgb = src.rgb;"
              "} 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);"
              "}";
-    case BLEND_MODE_DIFFERENCE:
+    case BlendModeDifference:
       return "result.rgb = src.rgb + dst.rgb -"
              "    2.0 * min(src.rgb * dst.a, dst.rgb * src.a);";
-    case BLEND_MODE_EXCLUSION:
+    case BlendModeExclusion:
       return "result.rgb = dst.rgb + src.rgb - 2.0 * dst.rgb * src.rgb;";
-    case BLEND_MODE_MULTIPLY:
+    case BlendModeMultiply:
       return "result.rgb = (1.0 - src.a) * dst.rgb +"
              "    (1.0 - dst.a) * src.rgb + src.rgb * dst.rgb;";
-    case BLEND_MODE_HUE:
+    case BlendModeHue:
       return "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;";
-    case BLEND_MODE_SATURATION:
+    case BlendModeSaturation:
       return "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;";
-    case BLEND_MODE_COLOR:
+    case BlendModeColor:
       return "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;";
-    case BLEND_MODE_LUMINOSITY:
+    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;";
-    case BLEND_MODE_NONE:
+    case BlendModeNone:
+    case NumBlendModes:
       NOTREACHED();
   }
   return "result = vec4(1.0, 0.0, 0.0, 1.0);";
 }
 
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1), alpha_location_(-1) {
 }
 
 void FragmentTexAlphaBinding::Init(GLES2Interface* context,
@@ skipping 1122 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