The great shader refactor: Clean up GLRenderer

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 <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 126 matching lines @@
       return shader_string;
     default:
       NOTREACHED();
       break;
   }
   return shader_string;
 }
 
 }  // namespace
 
-ShaderLocations::ShaderLocations() {
-}
-
 TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
                                             int* highp_threshold_cache,
                                             int highp_threshold_min,
                                             const gfx::Point& max_coordinate) {
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache,
                                    highp_threshold_min,
                                    max_coordinate.x(),
                                    max_coordinate.y());
 }
@@ skipping 73 matching lines @@
   if (has_vertex_opacity_)
     vertex_opacity_location_ = locations[index++];
   if (aa_mode_ == USE_AA) {
     viewport_location_ = locations[index++];
     edge_location_ = locations[index++];
   }
   if (position_source_ == POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM)
     quad_location_ = locations[index++];
 }
 
-void VertexShaderBase::FillLocations(ShaderLocations* locations) const {
-  locations->quad = quad_location();
-  locations->edge = edge_location();
-  locations->viewport = viewport_location();
-  locations->matrix = matrix_location();
-  locations->vertex_tex_transform = vertex_tex_transform_location();
-}
-
 std::string VertexShaderBase::GetShaderString() const {
   // 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.
   std::string header = "#define TexCoordPrecision highp\n";
   std::string source = "void main() {\n";
 
   // Define the size of quads for attribute indexed uniform arrays.
   if (use_uniform_arrays_) {
@@ skipping 208 matching lines @@
       if (has_rgba_fragment_tex_transform_)
         fragment_tex_transform_location_ = locations[index++];
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       color_location_ = locations[index++];
       break;
   }
   DCHECK_EQ(index, locations.size());
 }
 
-void FragmentShaderBase::FillLocations(ShaderLocations* locations) const {
-  if (has_blend_mode()) {
-    locations->backdrop = backdrop_location_;
-    locations->backdrop_rect = backdrop_rect_location_;
-  }
-  if (mask_for_background_)
-    locations->original_backdrop = original_backdrop_location_;
-  if (mask_mode_ != NO_MASK) {
-    locations->mask_sampler = mask_sampler_location_;
-    locations->mask_tex_coord_scale = mask_tex_coord_scale_location_;
-    locations->mask_tex_coord_offset = mask_tex_coord_offset_location_;
-  }
-  if (has_color_matrix_) {
-    locations->color_matrix = color_matrix_location_;
-    locations->color_offset = color_offset_location_;
-  }
-  if (has_uniform_alpha_)
-    locations->alpha = alpha_location_;
-  switch (input_color_type_) {
-    case INPUT_COLOR_SOURCE_RGBA_TEXTURE:
-      locations->sampler = sampler_location_;
-      break;
-    case INPUT_COLOR_SOURCE_UNIFORM:
-      break;
-  }
-}
-
 std::string FragmentShaderBase::SetBlendModeFunctions(
     const std::string& shader_string) const {
   if (shader_string.find("ApplyBlendMode") == std::string::npos)
     return shader_string;
 
   if (!has_blend_mode()) {
     return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
@@ skipping 553 matching lines @@
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return head + functions;
 }
 
 }  // namespace cc