reformatting shader.cc and shader.h

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 314 matching lines @@
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame& frame,
                                       const CheckerboardDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   SkColor color = quad->color;
   GLC(Context(),
-      Context()->uniform4f(program->fragment_shader().colorLocation(),
+      Context()->uniform4f(program->fragment_shader().color_location(),
                            SkColorGetR(color) * (1.0f / 255.0f),
                            SkColorGetG(color) * (1.0f / 255.0f),
                            SkColorGetB(color) * (1.0f / 255.0f),
                            1));
 
   const int checkerboard_width = 16;
   float frequency = 1.0f / checkerboard_width;
 
   gfx::Rect tile_rect = quad->rect;
   float tex_offset_x = tile_rect.x() % checkerboard_width;
   float tex_offset_y = tile_rect.y() % checkerboard_width;
   float tex_scale_x = tile_rect.width();
   float tex_scale_y = tile_rect.height();
   GLC(Context(),
-      Context()->uniform4f(program->fragment_shader().texTransformLocation(),
+      Context()->uniform4f(program->fragment_shader().tex_transform_location(),
                            tex_offset_x,
                            tex_offset_y,
                            tex_scale_x,
                            tex_scale_y));
 
   GLC(Context(),
-      Context()->uniform1f(program->fragment_shader().frequencyLocation(),
+      Context()->uniform1f(program->fragment_shader().frequency_location(),
                            frequency));
 
-  SetShaderOpacity(quad->opacity(), program->fragment_shader().alphaLocation());
+  SetShaderOpacity(quad->opacity(),
+                   program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
-                   program->vertex_shader().matrixLocation());
+                   program->vertex_shader().matrix_location());
 }
 
 void GLRenderer::DrawDebugBorderQuad(const DrawingFrame& frame,
                                      const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
   const DebugBorderProgram* program = GetDebugBorderProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   // Use the full quad_rect for debug quads to not move the edges based on
   // partial swaps.
   gfx::Rect layer_rect = quad->rect;
   gfx::Transform render_matrix = quad->quadTransform();
   render_matrix.Translate(0.5f * layer_rect.width() + layer_rect.x(),
                           0.5f * layer_rect.height() + layer_rect.y());
   render_matrix.Scale(layer_rect.width(), layer_rect.height());
   GLRenderer::ToGLMatrix(&gl_matrix[0],
                          frame.projection_matrix * render_matrix);
   GLC(Context(),
       Context()->uniformMatrix4fv(
-          program->vertex_shader().matrixLocation(), 1, false, &gl_matrix[0]));
+          program->vertex_shader().matrix_location(), 1, false, &gl_matrix[0]));
 
   SkColor color = quad->color;
   float alpha = SkColorGetA(color) * (1.0f / 255.0f);
 
   GLC(Context(),
-      Context()->uniform4f(program->fragment_shader().colorLocation(),
+      Context()->uniform4f(program->fragment_shader().color_location(),
                            (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
                            (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
                            (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
                            alpha));
 
   GLC(Context(), Context()->lineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(Context(),
@@ skipping 317 matching lines @@
   int shader_mask_tex_coord_offset_location = -1;
   int shader_matrix_location = -1;
   int shader_alpha_location = -1;
   int shader_tex_transform_location = -1;
   int shader_tex_scale_location = -1;
 
   if (use_aa && mask_texture_id) {
     const RenderPassMaskProgramAA* program = GetRenderPassMaskProgramAA();
     SetUseProgram(program->program());
     GLC(Context(),
-        Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+        Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
-    shader_quad_location = program->vertex_shader().pointLocation();
-    shader_edge_location = program->fragment_shader().edgeLocation();
+    shader_quad_location = program->vertex_shader().point_location();
+    shader_edge_location = program->fragment_shader().edge_location();
     shader_mask_sampler_location =
-        program->fragment_shader().maskSamplerLocation();
+        program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
-        program->fragment_shader().maskTexCoordScaleLocation();
+        program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
-        program->fragment_shader().maskTexCoordOffsetLocation();
-    shader_matrix_location = program->vertex_shader().matrixLocation();
-    shader_alpha_location = program->fragment_shader().alphaLocation();
-    shader_tex_scale_location = program->vertex_shader().texScaleLocation();
+        program->fragment_shader().mask_tex_coord_offset_location();
+    shader_matrix_location = program->vertex_shader().matrix_location();
+    shader_alpha_location = program->fragment_shader().alpha_location();
+    shader_tex_scale_location = program->vertex_shader().tex_scale_location();
   } else if (!use_aa && mask_texture_id) {
     const RenderPassMaskProgram* program = GetRenderPassMaskProgram();
     SetUseProgram(program->program());
     GLC(Context(),
-        Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+        Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_mask_sampler_location =
-        program->fragment_shader().maskSamplerLocation();
+        program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
-        program->fragment_shader().maskTexCoordScaleLocation();
+        program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
-        program->fragment_shader().maskTexCoordOffsetLocation();
-    shader_matrix_location = program->vertex_shader().matrixLocation();
-    shader_alpha_location = program->fragment_shader().alphaLocation();
+        program->fragment_shader().mask_tex_coord_offset_location();
+    shader_matrix_location = program->vertex_shader().matrix_location();
+    shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
-        program->vertex_shader().texTransformLocation();
+        program->vertex_shader().tex_transform_location();
   } else if (use_aa && !mask_texture_id) {
     const RenderPassProgramAA* program = GetRenderPassProgramAA();
     SetUseProgram(program->program());
     GLC(Context(),
-        Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+        Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
-    shader_quad_location = program->vertex_shader().pointLocation();
-    shader_edge_location = program->fragment_shader().edgeLocation();
-    shader_matrix_location = program->vertex_shader().matrixLocation();
-    shader_alpha_location = program->fragment_shader().alphaLocation();
-    shader_tex_scale_location = program->vertex_shader().texScaleLocation();
+    shader_quad_location = program->vertex_shader().point_location();
+    shader_edge_location = program->fragment_shader().edge_location();
+    shader_matrix_location = program->vertex_shader().matrix_location();
+    shader_alpha_location = program->fragment_shader().alpha_location();
+    shader_tex_scale_location = program->vertex_shader().tex_scale_location();
   } else {
     const RenderPassProgram* program = GetRenderPassProgram();
     SetUseProgram(program->program());
     GLC(Context(),
-        Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+        Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
-    shader_matrix_location = program->vertex_shader().matrixLocation();
-    shader_alpha_location = program->fragment_shader().alphaLocation();
+    shader_matrix_location = program->vertex_shader().matrix_location();
+    shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
-        program->vertex_shader().texTransformLocation();
+        program->vertex_shader().tex_transform_location();
   }
 
   float tex_scale_x =
       quad->rect.width() / static_cast<float>(contents_texture->size().width());
   float tex_scale_y = quad->rect.height() /
                       static_cast<float>(contents_texture->size().height());
   DCHECK_LE(tex_scale_x, 1.0f);
   DCHECK_LE(tex_scale_y, 1.0f);
 
   if (shader_tex_transform_location != -1) {
@@ skipping 60 matching lines @@
   unsigned color_location;
   unsigned point_location;
   unsigned tex_scale_location;
   unsigned edge_location;
 };
 
 template<class T>
 static void SolidColorUniformLocation(T program,
                                       SolidColorProgramUniforms* uniforms) {
   uniforms->program = program->program();
-  uniforms->matrix_location = program->vertex_shader().matrixLocation();
-  uniforms->color_location = program->fragment_shader().colorLocation();
-  uniforms->point_location = program->vertex_shader().pointLocation();
-  uniforms->tex_scale_location = program->vertex_shader().texScaleLocation();
-  uniforms->edge_location = program->fragment_shader().edgeLocation();
+  uniforms->matrix_location = program->vertex_shader().matrix_location();
+  uniforms->color_location = program->fragment_shader().color_location();
+  uniforms->point_location = program->vertex_shader().point_location();
+  uniforms->tex_scale_location = program->vertex_shader().tex_scale_location();
+  uniforms->edge_location = program->fragment_shader().edge_location();
 }
 
 bool GLRenderer::SetupQuadForAntialiasing(
     const gfx::Transform& device_transform,
     const DrawQuad* quad,
     gfx::QuadF* local_quad,
     float edge[24]) const {
   gfx::Rect tile_rect = quad->visible_rect;
 
   bool clipped = false;
@@ skipping 139 matching lines @@
   unsigned edge_location;
   unsigned matrix_location;
   unsigned alpha_location;
   unsigned point_location;
 };
 
 template <class T>
 static void TileUniformLocation(T program, TileProgramUniforms* uniforms) {
   uniforms->program = program->program();
   uniforms->vertex_tex_transform_location =
-      program->vertex_shader().vertexTexTransformLocation();
-  uniforms->matrix_location = program->vertex_shader().matrixLocation();
-  uniforms->point_location = program->vertex_shader().pointLocation();
+      program->vertex_shader().vertex_tex_transform_location();
+  uniforms->matrix_location = program->vertex_shader().matrix_location();
+  uniforms->point_location = program->vertex_shader().point_location();
 
-  uniforms->sampler_location = program->fragment_shader().samplerLocation();
-  uniforms->alpha_location = program->fragment_shader().alphaLocation();
+  uniforms->sampler_location = program->fragment_shader().sampler_location();
+  uniforms->alpha_location = program->fragment_shader().alpha_location();
   uniforms->fragment_tex_transform_location =
-      program->fragment_shader().fragmentTexTransformLocation();
-  uniforms->edge_location = program->fragment_shader().edgeLocation();
+      program->fragment_shader().fragment_tex_transform_location();
+  uniforms->edge_location = program->fragment_shader().edge_location();
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame& frame,
                               const TileDrawQuad* quad) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = quad->tex_coord_rect;
   float tex_to_geom_scale_x = quad->rect.width() / tex_coord_rect.width();
   float tex_to_geom_scale_y = quad->rect.height() / tex_coord_rect.height();
 
@@ skipping 154 matching lines @@
   GLC(Context(), Context()->activeTexture(GL_TEXTURE2));
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, u_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
   GLC(Context(), Context()->activeTexture(GL_TEXTURE3));
   ResourceProvider::ScopedSamplerGL v_plane_lock(
       resource_provider_, v_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
 
   SetUseProgram(program->program());
 
   GLC(Context(),
-      Context()->uniform2f(program->vertex_shader().texScaleLocation(),
+      Context()->uniform2f(program->vertex_shader().tex_scale_location(),
                            quad->tex_scale.width(),
                            quad->tex_scale.height()));
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().yTextureLocation(), 1));
+      Context()->uniform1i(program->fragment_shader().y_texture_location(), 1));
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().uTextureLocation(), 2));
+      Context()->uniform1i(program->fragment_shader().u_texture_location(), 2));
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().vTextureLocation(), 3));
+      Context()->uniform1i(program->fragment_shader().v_texture_location(), 3));
 
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
   float yuv_to_rgb[9] = {
       1.164f, 1.164f, 1.164f,
       0.0f, -.391f, 2.018f,
       1.596f, -.813f, 0.0f,
   };
   GLC(Context(),
       Context()->uniformMatrix3fv(
-          program->fragment_shader().yuvMatrixLocation(), 1, 0, yuv_to_rgb));
+          program->fragment_shader().yuv_matrix_location(), 1, 0, yuv_to_rgb));
 
   // These values map to 16, 128, and 128 respectively, and are computed
   // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
   // They are used in the YUV to RGBA conversion formula:
   //   Y - 16   : Gives 16 values of head and footroom for overshooting
   //   U - 128  : Turns unsigned U into signed U [-128,127]
   //   V - 128  : Turns unsigned V into signed V [-128,127]
   float yuv_adjust[3] = { -0.0625f, -0.5f, -0.5f, };
   GLC(Context(),
       Context()->uniform3fv(
-          program->fragment_shader().yuvAdjLocation(), 1, yuv_adjust));
+          program->fragment_shader().yuv_adj_location(), 1, yuv_adjust));
 
-  SetShaderOpacity(quad->opacity(), program->fragment_shader().alphaLocation());
+  SetShaderOpacity(quad->opacity(),
+                   program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
-                   program->vertex_shader().matrixLocation());
+                   program->vertex_shader().matrix_location());
 
   // Reset active texture back to texture 0.
   GLC(Context(), Context()->activeTexture(GL_TEXTURE0));
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame& frame,
                                      const StreamVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
 
   DCHECK(capabilities_.using_egl_image);
 
   const VideoStreamTextureProgram* program = GetVideoStreamTextureProgram();
   SetUseProgram(program->program());
 
   ToGLMatrix(&gl_matrix[0], quad->matrix);
   GLC(Context(),
       Context()->uniformMatrix4fv(
-          program->vertex_shader().texMatrixLocation(), 1, false, gl_matrix));
+          program->vertex_shader().tex_matrix_location(), 1, false, gl_matrix));
 
   GLC(Context(),
       Context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->texture_id));
 
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+      Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
-  SetShaderOpacity(quad->opacity(), program->fragment_shader().alphaLocation());
+  SetShaderOpacity(quad->opacity(),
+                   program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
-                   program->vertex_shader().matrixLocation());
+                   program->vertex_shader().matrix_location());
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     DCHECK(program && (program->initialized() || context->isContextLost()));
     program_id = program->program();
-    sampler_location = program->fragment_shader().samplerLocation();
-    matrix_location = program->vertex_shader().matrixLocation();
-    alpha_location = program->fragment_shader().alphaLocation();
+    sampler_location = program->fragment_shader().sampler_location();
+    matrix_location = program->vertex_shader().matrix_location();
+    alpha_location = program->fragment_shader().alpha_location();
   }
   int program_id;
   int sampler_location;
   int matrix_location;
   int alpha_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     TextureProgramBinding::Set(program, context);
-    tex_transform_location = program->vertex_shader().texTransformLocation();
-    vertex_opacity_location = program->vertex_shader().vertexOpacityLocation();
+    tex_transform_location = program->vertex_shader().tex_transform_location();
+    vertex_opacity_location =
+        program->vertex_shader().vertex_opacity_location();
   }
   int tex_transform_location;
   int vertex_opacity_location;
 };
 
 void GLRenderer::FlushTextureQuadCache() {
   // Check to see if we have anything to draw.
   if (draw_cache_.program_id == 0)
     return;
 
@@ skipping 305 matching lines @@
 void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame& frame,
                                           int texture_id,
                                           gfx::Rect rect,
                                           const gfx::Transform& draw_matrix) {
   const RenderPassProgram* program = GetRenderPassProgram();
 
   GLC(Context(), Context()->bindTexture(GL_TEXTURE_2D, texture_id));
 
   SetUseProgram(program->program());
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
+      Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
   GLC(Context(),
-      Context()->uniform4f(program->vertex_shader().texTransformLocation(),
+      Context()->uniform4f(program->vertex_shader().tex_transform_location(),
                            0.0f,
                            0.0f,
                            1.0f,
                            1.0f));
-  SetShaderOpacity(1, program->fragment_shader().alphaLocation());
+  SetShaderOpacity(1, program->fragment_shader().alpha_location());
   DrawQuadGeometry(
-      frame, draw_matrix, rect, program->vertex_shader().matrixLocation());
+      frame, draw_matrix, rect, program->vertex_shader().matrix_location());
 }
 
 void GLRenderer::Finish() {
   TRACE_EVENT0("cc", "GLRenderer::finish");
   context_->finish();
 }
 
 bool GLRenderer::SwapBuffers() {
   DCHECK(visible_);
   DCHECK(!is_backbuffer_discarded_);
@@ skipping 577 matching lines @@
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc