The great shader refactor: Delete instances of GetShaderSource

cc/output/shader.h

 // 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.
 
 #ifndef CC_OUTPUT_SHADER_H_
 #define CC_OUTPUT_SHADER_H_
 
 #include <string>
 
 #include "base/macros.h"
@@ skipping 336 matching lines @@
   int matrix_location() const { return matrix_location_; }
   int tex_matrix_location() const { return tex_matrix_location_; }
 
  private:
   int matrix_location_;
   int tex_matrix_location_;
 
   DISALLOW_COPY_AND_ASSIGN(VertexShaderVideoTransform);
 };
 
-class FragmentTexBlendMode {
+class FragmentShaderBase {
  public:
+  std::string GetShaderString(TexCoordPrecision precision,
+                              SamplerType sampler) const;
+
   int backdrop_location() const { return backdrop_location_; }
   int original_backdrop_location() const { return original_backdrop_location_; }
   int backdrop_rect_location() const { return backdrop_rect_location_; }
 
   BlendMode blend_mode() const { return blend_mode_; }
   void set_blend_mode(BlendMode blend_mode) { blend_mode_ = blend_mode; }
   bool has_blend_mode() const { return blend_mode_ != BLEND_MODE_NONE; }
   void set_mask_for_background(bool mask_for_background) {
     mask_for_background_ = mask_for_background;
   }
   bool mask_for_background() const { return mask_for_background_; }
 
  protected:
-  FragmentTexBlendMode();
+  FragmentShaderBase();
+  virtual std::string GetShaderSource() const = 0;
 
   std::string SetBlendModeFunctions(const std::string& shader_string) const;
 
   int backdrop_location_;
   int original_backdrop_location_;
   int backdrop_rect_location_;
 
  private:
   BlendMode blend_mode_;
   bool mask_for_background_;
 
   std::string GetHelperFunctions() const;
   std::string GetBlendFunction() const;
   std::string GetBlendFunctionBodyForRGB() const;
 };
 
-class FragmentTexAlphaBinding : public FragmentTexBlendMode {
+class FragmentTexAlphaBinding : public FragmentShaderBase {
  public:
   FragmentTexAlphaBinding();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int fragment_tex_transform_location() const { return -1; }
   int sampler_location() const { return sampler_location_; }
 
  private:
   int sampler_location_;
   int alpha_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentTexAlphaBinding);
 };
 
-class FragmentTexColorMatrixAlphaBinding : public FragmentTexBlendMode {
+class FragmentTexColorMatrixAlphaBinding : public FragmentShaderBase {
  public:
     FragmentTexColorMatrixAlphaBinding();
 
     void Init(gpu::gles2::GLES2Interface* context,
               unsigned program,
               int* base_uniform_index);
     int alpha_location() const { return alpha_location_; }
     int color_matrix_location() const { return color_matrix_location_; }
     int color_offset_location() const { return color_offset_location_; }
     int fragment_tex_transform_location() const { return -1; }
     int sampler_location() const { return sampler_location_; }
 
  private:
     int sampler_location_;
     int alpha_location_;
     int color_matrix_location_;
     int color_offset_location_;
 };
 
-class FragmentTexOpaqueBinding : public FragmentTexBlendMode {
+class FragmentTexOpaqueBinding : public FragmentShaderBase {
  public:
   FragmentTexOpaqueBinding();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return -1; }
   int fragment_tex_transform_location() const { return -1; }
   int background_color_location() const { return -1; }
   int sampler_location() const { return sampler_location_; }
 
  private:
   int sampler_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentTexOpaqueBinding);
 };
 
-class FragmentTexBackgroundBinding : public FragmentTexBlendMode {
+class FragmentTexBackgroundBinding : public FragmentShaderBase {
  public:
   FragmentTexBackgroundBinding();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int background_color_location() const { return background_color_location_; }
   int sampler_location() const { return sampler_location_; }
 
  private:
   int background_color_location_;
   int sampler_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentTexBackgroundBinding);
 };
 
 class FragmentShaderRGBATexVaryingAlpha : public FragmentTexOpaqueBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderRGBATexPremultiplyAlpha : public FragmentTexOpaqueBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderTexBackgroundVaryingAlpha
     : public FragmentTexBackgroundBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderTexBackgroundPremultiplyAlpha
     : public FragmentTexBackgroundBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderRGBATexAlpha : public FragmentTexAlphaBinding {
  public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
+
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderRGBATexColorMatrixAlpha
     : public FragmentTexColorMatrixAlphaBinding {
  public:
-  std::string GetShaderString(TexCoordPrecision precision,
-                              SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
+
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 class FragmentShaderRGBATex : public FragmentTexOpaqueBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 // Swizzles the red and blue component of sampled texel with alpha.
 class FragmentShaderRGBATexSwizzleAlpha : public FragmentTexAlphaBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 // Swizzles the red and blue component of sampled texel without alpha.
 class FragmentShaderRGBATexSwizzleOpaque : public FragmentTexOpaqueBinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
-class FragmentShaderRGBATexAlphaAA : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaAA : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaAA();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
 
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int alpha_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaAA);
 };
 
-class FragmentTexClampAlphaAABinding : public FragmentTexBlendMode {
+class FragmentTexClampAlphaAABinding : public FragmentShaderBase {
  public:
   FragmentTexClampAlphaAABinding();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int fragment_tex_transform_location() const {
     return fragment_tex_transform_location_;
   }
 
  private:
   int sampler_location_;
   int alpha_location_;
   int fragment_tex_transform_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentTexClampAlphaAABinding);
 };
 
 class FragmentShaderRGBATexClampAlphaAA
     : public FragmentTexClampAlphaAABinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
 // Swizzles the red and blue component of sampled texel.
 class FragmentShaderRGBATexClampSwizzleAlphaAA
     : public FragmentTexClampAlphaAABinding {
- public:
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
+ private:
+  std::string GetShaderSource() const override;
 };
 
-class FragmentShaderRGBATexAlphaMask : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaMask : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaMask();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
     return mask_tex_coord_offset_location_;
   }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int mask_sampler_location_;
   int alpha_location_;
   int mask_tex_coord_scale_location_;
   int mask_tex_coord_offset_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaMask);
 };
 
-class FragmentShaderRGBATexAlphaMaskAA : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaMaskAA : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaMaskAA();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
     return mask_tex_coord_offset_location_;
   }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int mask_sampler_location_;
   int alpha_location_;
   int mask_tex_coord_scale_location_;
   int mask_tex_coord_offset_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaMaskAA);
 };
 
-class FragmentShaderRGBATexAlphaMaskColorMatrixAA
-    : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaMaskColorMatrixAA : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaMaskColorMatrixAA();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
     return mask_tex_coord_offset_location_;
   }
   int color_matrix_location() const { return color_matrix_location_; }
   int color_offset_location() const { return color_offset_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int mask_sampler_location_;
   int alpha_location_;
   int mask_tex_coord_scale_location_;
   int mask_tex_coord_offset_location_;
   int color_matrix_location_;
   int color_offset_location_;
 };
 
-class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaColorMatrixAA();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int color_matrix_location() const { return color_matrix_location_; }
   int color_offset_location() const { return color_offset_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int alpha_location_;
   int color_matrix_location_;
   int color_offset_location_;
 };
 
-class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentTexBlendMode {
+class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentShaderBase {
  public:
   FragmentShaderRGBATexAlphaMaskColorMatrix();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
   void FillLocations(ShaderLocations* locations) const;
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int alpha_location() const { return alpha_location_; }
   int sampler_location() const { return sampler_location_; }
   int mask_sampler_location() const { return mask_sampler_location_; }
   int mask_tex_coord_scale_location() const {
     return mask_tex_coord_scale_location_;
   }
   int mask_tex_coord_offset_location() const {
     return mask_tex_coord_offset_location_;
   }
   int color_matrix_location() const { return color_matrix_location_; }
   int color_offset_location() const { return color_offset_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int sampler_location_;
   int mask_sampler_location_;
   int alpha_location_;
   int mask_tex_coord_scale_location_;
   int mask_tex_coord_offset_location_;
   int color_matrix_location_;
   int color_offset_location_;
 };
 
-class FragmentShaderYUVVideo : public FragmentTexBlendMode {
+class FragmentShaderYUVVideo : public FragmentShaderBase {
  public:
   FragmentShaderYUVVideo();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-
   void SetFeatures(bool use_alpha_texture, bool use_nv12, bool use_color_lut);
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int y_texture_location() const { return y_texture_location_; }
   int u_texture_location() const { return u_texture_location_; }
   int v_texture_location() const { return v_texture_location_; }
   int uv_texture_location() const { return uv_texture_location_; }
   int a_texture_location() const { return a_texture_location_; }
   int lut_texture_location() const { return lut_texture_location_; }
   int alpha_location() const { return alpha_location_; }
   int yuv_matrix_location() const { return yuv_matrix_location_; }
   int yuv_adj_location() const { return yuv_adj_location_; }
   int ya_clamp_rect_location() const { return ya_clamp_rect_location_; }
   int uv_clamp_rect_location() const { return uv_clamp_rect_location_; }
   int resource_multiplier_location() const {
     return resource_multiplier_location_;
   }
   int resource_offset_location() const { return resource_offset_location_; }
 
  private:
+  std::string GetShaderSource() const override;
+
   bool use_alpha_texture_;
   bool use_nv12_;
   bool use_color_lut_;
 
   int y_texture_location_;
   int u_texture_location_;
   int v_texture_location_;
   int uv_texture_location_;
   int a_texture_location_;
   int lut_texture_location_;
   int alpha_location_;
   int yuv_matrix_location_;
   int yuv_adj_location_;
   int ya_clamp_rect_location_;
   int uv_clamp_rect_location_;
   int resource_multiplier_location_;
   int resource_offset_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderYUVVideo);
 };
 
-class FragmentShaderColor : public FragmentTexBlendMode {
+class FragmentShaderColor : public FragmentShaderBase {
  public:
   FragmentShaderColor();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int color_location() const { return color_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int color_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderColor);
 };
 
-class FragmentShaderColorAA : public FragmentTexBlendMode {
+class FragmentShaderColorAA : public FragmentShaderBase {
  public:
   FragmentShaderColorAA();
-  std::string GetShaderString(
-      TexCoordPrecision precision, SamplerType sampler) const;
-  static std::string GetShaderHead();
-  static std::string GetShaderBody();
 
   void Init(gpu::gles2::GLES2Interface* context,
             unsigned program,
             int* base_uniform_index);
   int color_location() const { return color_location_; }
 
  private:
+  std::string GetShaderSource() const override;
   int color_location_;
 
   DISALLOW_COPY_AND_ASSIGN(FragmentShaderColorAA);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_SHADER_H_