The great shader refactor: Delete all of the subclasses

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 377 matching lines @@
     HDR("varying TexCoordPrecision vec2 dummy_varying;");
     SRC("dummy_varying = dummy_uniform;");
   }
 
   source += "}\n";
   return header + source;
 }
 
 FragmentShaderBase::FragmentShaderBase() {}
 
-std::string FragmentShaderBase::GetShaderString(TexCoordPrecision precision,
-                                                SamplerType sampler) const {
+std::string FragmentShaderBase::GetShaderString() const {
   // The AA shader values will use TexCoordPrecision.
+  TexCoordPrecision precision = tex_coord_precision_;
   if (has_aa_ && precision == TEX_COORD_PRECISION_NA)
     precision = TEX_COORD_PRECISION_MEDIUM;
   return SetFragmentTexCoordPrecision(
       precision, SetFragmentSamplerType(
-                     sampler, SetBlendModeFunctions(GetShaderSource())));
+                     sampler_type_, SetBlendModeFunctions(GetShaderSource())));
 }
 
 void FragmentShaderBase::Init(GLES2Interface* context,
                               unsigned program,
                               int* base_uniform_index) {
   std::vector<const char*> uniforms;
   std::vector<int> locations;
   if (has_blend_mode()) {
     uniforms.push_back("s_backdropTexture");
     uniforms.push_back("s_originalBackdropTexture");
@@ skipping 58 matching lines @@
       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())
+  if (mask_for_background_)
     locations->original_backdrop = original_backdrop_location_;
   if (has_mask_sampler_) {
     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_;
   }
@@ skipping 17 matching lines @@
     return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
     uniform sampler2D s_originalBackdropTexture;
     uniform TexCoordPrecision vec4 backdropRect;
   });
 
   std::string mixFunction;
-  if (mask_for_background()) {
+  if (mask_for_background_) {
     mixFunction = SHADER0([]() {
       vec4 MixBackdrop(TexCoordPrecision vec2 bgTexCoord, float mask) {
         vec4 backdrop = texture2D(s_backdropTexture, bgTexCoord);
         vec4 original_backdrop =
             texture2D(s_originalBackdropTexture, bgTexCoord);
         return mix(original_backdrop, backdrop, mask);
       }
     });
   } else {
     mixFunction = SHADER0([]() {
@@ skipping 544 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