Use GLES2Interface for shaders and programs

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"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
-#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
 #define SHADER0(Src) #Src
 #define VERTEX_SHADER(Src) SetVertexTexCoordPrecision(SHADER0(Src))
 #define FRAGMENT_SHADER(Src) SetFragmentTexCoordPrecision( \
     precision, SetFragmentSamplerType(sampler, SHADER0(Src)))
 
-using blink::WebGraphicsContext3D;
+using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 namespace {
 
-static void GetProgramUniformLocations(WebGraphicsContext3D* context,
+static void GetProgramUniformLocations(GLES2Interface* context,
                                        unsigned program,
                                        size_t count,
                                        const char** uniforms,
                                        int* locations,
                                        int* base_uniform_index) {
   for (size_t i = 0; i < count; i++) {
     locations[i] = (*base_uniform_index)++;
-    context->bindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
+    context->BindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
   }
 }
 
 static std::string SetFragmentTexCoordPrecision(
     TexCoordPrecision requested_precision, std::string shader_string) {
   switch (requested_precision) {
     case TexCoordPrecisionHigh:
       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
       return
           "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
@@ skipping 20 matching lines @@
 
 static std::string SetVertexTexCoordPrecision(const char* shader_string) {
   // We unconditionally use highp in the vertex shader since
   // we are unlikely to be vertex shader bound when drawing large quads.
   // Also, some vertex shaders mutate the texture coordinate in such a
   // way that the effective precision might be lower than expected.
   return "#define TexCoordPrecision highp\n" +
       std::string(shader_string);
 }
 
-TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
                                             int *highp_threshold_cache,
                                             int highp_threshold_min,
                                             int x, int y) {
   if (*highp_threshold_cache == 0) {
     // Initialize range and precision with minimum spec values for when
     // GetShaderPrecisionFormat is a test stub.
     // TODO(brianderson): Implement better stubs of GetShaderPrecisionFormat
     // everywhere.
     GLint range[2] = { 14, 14 };
     GLint precision = 10;
-    GLC(context, context->getShaderPrecisionFormat(GL_FRAGMENT_SHADER,
+    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 TexCoordPrecisionHigh;
   return TexCoordPrecisionMedium;
 }
@@ skipping 30 matching lines @@
       return shader_string;
     default:
       NOTREACHED();
       break;
   }
   return shader_string;
 }
 
 }  // namespace
 
-TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
                                             int *highp_threshold_cache,
                                             int highp_threshold_min,
                                             gfx::Point max_coordinate) {
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache, highp_threshold_min,
                                    max_coordinate.x(), max_coordinate.y());
 }
 
-TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
                                             int *highp_threshold_cache,
                                             int highp_threshold_min,
                                             gfx::Size max_size) {
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache, highp_threshold_min,
                                    max_size.width(), max_size.height());
 }
 
 VertexShaderPosTex::VertexShaderPosTex()
       : matrix_location_(-1) {}
 
-void VertexShaderPosTex::Init(WebGraphicsContext3D* context,
+void VertexShaderPosTex::Init(GLES2Interface* context,
                               unsigned program,
                               int* base_uniform_index) {
   static const char* uniforms[] = {
       "matrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
@@ skipping 13 matching lines @@
       gl_Position = matrix * a_position;
       v_texCoord = a_texCoord;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPosTexYUVStretch::VertexShaderPosTexYUVStretch()
     : matrix_location_(-1),
       tex_scale_location_(-1) {}
 
-void VertexShaderPosTexYUVStretch::Init(WebGraphicsContext3D* context,
+void VertexShaderPosTexYUVStretch::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texScale",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
@@ skipping 16 matching lines @@
     void main() {
         gl_Position = matrix * a_position;
         v_texCoord = a_texCoord * texScale;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPos::VertexShaderPos()
     : matrix_location_(-1) {}
 
-void VertexShaderPos::Init(WebGraphicsContext3D* context,
+void VertexShaderPos::Init(GLES2Interface* context,
                            unsigned program,
                            int* base_uniform_index) {
   static const char* uniforms[] = {
       "matrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
@@ skipping 11 matching lines @@
         gl_Position = matrix * a_position;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPosTexTransform::VertexShaderPosTexTransform()
     : matrix_location_(-1),
       tex_transform_location_(-1),
       vertex_opacity_location_(-1) {}
 
-void VertexShaderPosTexTransform::Init(WebGraphicsContext3D* context,
+void VertexShaderPosTexTransform::Init(GLES2Interface* context,
                                        unsigned program,
                                        int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texTransform",
     "opacity",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
@@ skipping 35 matching lines @@
       gl_Position = a_position;
       v_texCoord = (a_position.xy + vec2(1.0)) * 0.5;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderQuad::VertexShaderQuad()
     : matrix_location_(-1),
       quad_location_(-1) {}
 
-void VertexShaderQuad::Init(WebGraphicsContext3D* context,
+void VertexShaderQuad::Init(GLES2Interface* context,
                             unsigned program,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "quad",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
@@ skipping 36 matching lines @@
   );  // NOLINT(whitespace/parens)
 #endif
 }
 
 VertexShaderQuadAA::VertexShaderQuadAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1) {}
 
-void VertexShaderQuadAA::Init(WebGraphicsContext3D* context,
+void VertexShaderQuadAA::Init(GLES2Interface* context,
                             unsigned program,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
   };
   int locations[arraysize(uniforms)];
 
@@ skipping 36 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderQuadTexTransformAA::VertexShaderQuadTexTransformAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1),
       tex_transform_location_(-1) {}
 
-void VertexShaderQuadTexTransformAA::Init(WebGraphicsContext3D* context,
+void VertexShaderQuadTexTransformAA::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
     "texTrans",
   };
   int locations[arraysize(uniforms)];
@@ skipping 39 matching lines @@
       v_texCoord = (pos.xy + vec2(0.5)) * texTrans.zw + texTrans.xy;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderTile::VertexShaderTile()
     : matrix_location_(-1),
       quad_location_(-1),
       vertex_tex_transform_location_(-1) {}
 
-void VertexShaderTile::Init(WebGraphicsContext3D* context,
+void VertexShaderTile::Init(GLES2Interface* context,
                             unsigned program,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "quad",
     "vertexTexTransform",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
@@ skipping 23 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderTileAA::VertexShaderTileAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1),
       vertex_tex_transform_location_(-1) {}
 
-void VertexShaderTileAA::Init(WebGraphicsContext3D* context,
+void VertexShaderTileAA::Init(GLES2Interface* context,
                               unsigned program,
                               int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
     "vertexTexTransform",
   };
   int locations[arraysize(uniforms)];
@@ skipping 38 matching lines @@
                           dot(edge[7], screen_pos)) * gl_Position.w;
       v_texCoord = pos.xy * vertexTexTransform.zw + vertexTexTransform.xy;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderVideoTransform::VertexShaderVideoTransform()
     : matrix_location_(-1),
       tex_matrix_location_(-1) {}
 
-void VertexShaderVideoTransform::Init(WebGraphicsContext3D* context,
+void VertexShaderVideoTransform::Init(GLES2Interface* context,
                                       unsigned program,
                                       int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texMatrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
@@ skipping 17 matching lines @@
         v_texCoord =
             vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
-void FragmentTexAlphaBinding::Init(WebGraphicsContext3D* context,
+void FragmentTexAlphaBinding::Init(GLES2Interface* context,
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
 }
 
 FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       color_matrix_location_(-1),
       color_offset_location_(-1) {}
 
-void FragmentTexColorMatrixAlphaBinding::Init(WebGraphicsContext3D* context,
+void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
                                               unsigned program,
                                               int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
 }
 
 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
     : sampler_location_(-1) {}
 
-void FragmentTexOpaqueBinding::Init(WebGraphicsContext3D* context,
+void FragmentTexOpaqueBinding::Init(GLES2Interface* context,
                                     unsigned program,
                                     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
@@ skipping 65 matching lines @@
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
     : background_color_location_(-1),
       sampler_location_(-1) {
 }
 
-void FragmentTexBackgroundBinding::Init(WebGraphicsContext3D* context,
+void FragmentTexBackgroundBinding::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "background_color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
@@ skipping 92 matching lines @@
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
-void FragmentShaderRGBATexAlphaAA::Init(WebGraphicsContext3D* context,
+void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
@@ skipping 22 matching lines @@
       gl_FragColor = texColor * alpha * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       fragment_tex_transform_location_(-1) {}
 
-void FragmentTexClampAlphaAABinding::Init(WebGraphicsContext3D* context,
+void FragmentTexClampAlphaAABinding::Init(GLES2Interface* context,
                                           unsigned program,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "fragmentTexTransform",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
@@ skipping 53 matching lines @@
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1) {}
 
-void FragmentShaderRGBATexAlphaMask::Init(WebGraphicsContext3D* context,
+void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
                                           unsigned program,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
   };
   int locations[arraysize(uniforms)];
@@ skipping 32 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
       mask_tex_coord_offset_location_(-1) {}
 
-void FragmentShaderRGBATexAlphaMaskAA::Init(WebGraphicsContext3D* context,
+void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
                                             unsigned program,
                                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
   };
   int locations[arraysize(uniforms)];
@@ skipping 40 matching lines @@
 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) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
-    WebGraphicsContext3D* context,
+    GLES2Interface* context,
     unsigned program,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
@@ skipping 49 matching lines @@
 }
 
 FragmentShaderRGBATexAlphaColorMatrixAA::
     FragmentShaderRGBATexAlphaColorMatrixAA()
         : sampler_location_(-1),
           alpha_location_(-1),
           color_matrix_location_(-1),
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
-      WebGraphicsContext3D* context,
+      GLES2Interface* context,
       unsigned program,
       int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
@@ skipping 36 matching lines @@
 }
 
 FragmentShaderRGBATexAlphaMaskColorMatrix::
     FragmentShaderRGBATexAlphaMaskColorMatrix()
         : sampler_location_(-1),
           mask_sampler_location_(-1),
           alpha_location_(-1),
           mask_tex_coord_scale_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
-    WebGraphicsContext3D* context,
+    GLES2Interface* context,
     unsigned program,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
@@ skipping 44 matching lines @@
 }
 
 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) {}
 
-void FragmentShaderYUVVideo::Init(WebGraphicsContext3D* context,
+void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
     "y_texture",
     "u_texture",
     "v_texture",
     "alpha",
     "yuv_matrix",
     "yuv_adj",
   };
@@ skipping 39 matching lines @@
 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       a_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1) {
 }
 
-void FragmentShaderYUVAVideo::Init(WebGraphicsContext3D* context,
+void FragmentShaderYUVAVideo::Init(GLES2Interface* context,
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "a_texture",
       "alpha",
       "cc_matrix",
       "yuv_adj",
@@ skipping 36 matching lines @@
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColor::FragmentShaderColor()
     : color_location_(-1) {}
 
-void FragmentShaderColor::Init(WebGraphicsContext3D* context,
+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),
@@ skipping 10 matching lines @@
     uniform vec4 color;
     void main() {
       gl_FragColor = color;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA()
     : color_location_(-1) {}
 
-void FragmentShaderColorAA::Init(WebGraphicsContext3D* context,
+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),
@@ skipping 17 matching lines @@
       gl_FragColor = color * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderCheckerboard::FragmentShaderCheckerboard()
     : alpha_location_(-1),
       tex_transform_location_(-1),
       frequency_location_(-1) {}
 
-void FragmentShaderCheckerboard::Init(WebGraphicsContext3D* context,
+void FragmentShaderCheckerboard::Init(GLES2Interface* context,
                                       unsigned program,
                                       int* base_uniform_index) {
   static const char* uniforms[] = {
     "alpha",
     "texTransform",
     "frequency",
     "color",
   };
   int locations[arraysize(uniforms)];
 
@@ skipping 27 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace cc