Revert "Delete CC."

cc/output/shader.h

Index: cc/output/shader.h
diff --git a/cc/output/shader.h b/cc/output/shader.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ccaa77ebad600bdf0e76c8a44bd3dd151dfb61e
--- /dev/null
+++ b/cc/output/shader.h
@@ -0,0 +1,887 @@
+// 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/basictypes.h"
+
+namespace gfx {
+class Point;
+class Size;
+}
+
+namespace gpu {
+namespace gles2 {
+class GLES2Interface;
+}
+}
+
+namespace cc {
+
+enum TexCoordPrecision {
+  TEX_COORD_PRECISION_NA = 0,
+  TEX_COORD_PRECISION_MEDIUM = 1,
+  TEX_COORD_PRECISION_HIGH = 2,
+  LAST_TEX_COORD_PRECISION = 2
+};
+
+enum SamplerType {
+  SAMPLER_TYPE_NA = 0,
+  SAMPLER_TYPE_2D = 1,
+  SAMPLER_TYPE_2D_RECT = 2,
+  SAMPLER_TYPE_EXTERNAL_OES = 3,
+  LAST_SAMPLER_TYPE = 3
+};
+
+enum BlendMode {
+  BLEND_MODE_NONE,
+  BLEND_MODE_NORMAL,
+  BLEND_MODE_SCREEN,
+  BLEND_MODE_OVERLAY,
+  BLEND_MODE_DARKEN,
+  BLEND_MODE_LIGHTEN,
+  BLEND_MODE_COLOR_DODGE,
+  BLEND_MODE_COLOR_BURN,
+  BLEND_MODE_HARD_LIGHT,
+  BLEND_MODE_SOFT_LIGHT,
+  BLEND_MODE_DIFFERENCE,
+  BLEND_MODE_EXCLUSION,
+  BLEND_MODE_MULTIPLY,
+  BLEND_MODE_HUE,
+  BLEND_MODE_SATURATION,
+  BLEND_MODE_COLOR,
+  BLEND_MODE_LUMINOSITY,
+  LAST_BLEND_MODE = BLEND_MODE_LUMINOSITY
+};
+
+enum MaskMode {
+  NO_MASK = 0,
+  HAS_MASK = 1,
+  LAST_MASK_VALUE = HAS_MASK
+};
+
+struct ShaderLocations {
+  ShaderLocations();
+
+  int sampler = -1;
+  int quad = -1;
+  int edge = -1;
+  int viewport = -1;
+  int mask_sampler = -1;
+  int mask_tex_coord_scale = -1;
+  int mask_tex_coord_offset = -1;
+  int matrix = -1;
+  int alpha = -1;
+  int color_matrix = -1;
+  int color_offset = -1;
+  int tex_transform = -1;
+  int backdrop = -1;
+  int backdrop_rect = -1;
+  int original_backdrop = -1;
+};
+
+// Note: The highp_threshold_cache must be provided by the caller to make
+// the caching multi-thread/context safe in an easy low-overhead manner.
+// The caller must make sure to clear highp_threshold_cache to 0, so it can be
+// reinitialized, if a new or different context is used.
+TexCoordPrecision TexCoordPrecisionRequired(gpu::gles2::GLES2Interface* context,
+                                            int* highp_threshold_cache,
+                                            int highp_threshold_min,
+                                            const gfx::Point& max_coordinate);
+
+TexCoordPrecision TexCoordPrecisionRequired(gpu::gles2::GLES2Interface* context,
+                                            int* highp_threshold_cache,
+                                            int highp_threshold_min,
+                                            const gfx::Size& max_size);
+
+class VertexShaderPosTex {
+ public:
+  VertexShaderPosTex();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+
+ private:
+  int matrix_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTex);
+};
+
+class VertexShaderPosTexYUVStretchOffset {
+ public:
+  VertexShaderPosTexYUVStretchOffset();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+  int tex_scale_location() const { return tex_scale_location_; }
+  int tex_offset_location() const { return tex_offset_location_; }
+
+ private:
+  int matrix_location_;
+  int tex_scale_location_;
+  int tex_offset_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexYUVStretchOffset);
+};
+
+class VertexShaderPos {
+ public:
+  VertexShaderPos();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+
+ private:
+  int matrix_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderPos);
+};
+
+class VertexShaderPosTexIdentity {
+ public:
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index) {}
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+class VertexShaderPosTexTransform {
+ public:
+  VertexShaderPosTexTransform();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
+
+  int matrix_location() const { return matrix_location_; }
+  int tex_transform_location() const { return tex_transform_location_; }
+  int vertex_opacity_location() const { return vertex_opacity_location_; }
+
+ private:
+  int matrix_location_;
+  int tex_transform_location_;
+  int vertex_opacity_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexTransform);
+};
+
+class VertexShaderQuad {
+ public:
+  VertexShaderQuad();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+           unsigned program,
+           int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+  int viewport_location() const { return -1; }
+  int quad_location() const { return quad_location_; }
+  int edge_location() const { return -1; }
+
+ private:
+  int matrix_location_;
+  int quad_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuad);
+};
+
+class VertexShaderQuadAA {
+ public:
+  VertexShaderQuadAA();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+           unsigned program,
+           int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+  int viewport_location() const { return viewport_location_; }
+  int quad_location() const { return quad_location_; }
+  int edge_location() const { return edge_location_; }
+
+ private:
+  int matrix_location_;
+  int viewport_location_;
+  int quad_location_;
+  int edge_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadAA);
+};
+
+
+class VertexShaderQuadTexTransformAA {
+ public:
+  VertexShaderQuadTexTransformAA();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+           unsigned program,
+           int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+  void FillLocations(ShaderLocations* locations) const;
+
+  int matrix_location() const { return matrix_location_; }
+  int viewport_location() const { return viewport_location_; }
+  int quad_location() const { return quad_location_; }
+  int edge_location() const { return edge_location_; }
+  int tex_transform_location() const { return tex_transform_location_; }
+
+ private:
+  int matrix_location_;
+  int viewport_location_;
+  int quad_location_;
+  int edge_location_;
+  int tex_transform_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadTexTransformAA);
+};
+
+class VertexShaderTile {
+ public:
+  VertexShaderTile();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+  int viewport_location() const { return -1; }
+  int quad_location() const { return quad_location_; }
+  int edge_location() const { return -1; }
+  int vertex_tex_transform_location() const {
+    return vertex_tex_transform_location_;
+  }
+
+ private:
+  int matrix_location_;
+  int quad_location_;
+  int vertex_tex_transform_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderTile);
+};
+
+class VertexShaderTileAA {
+ public:
+  VertexShaderTileAA();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  int matrix_location() const { return matrix_location_; }
+  int viewport_location() const { return viewport_location_; }
+  int quad_location() const { return quad_location_; }
+  int edge_location() const { return edge_location_; }
+  int vertex_tex_transform_location() const {
+    return vertex_tex_transform_location_;
+  }
+
+ private:
+  int matrix_location_;
+  int viewport_location_;
+  int quad_location_;
+  int edge_location_;
+  int vertex_tex_transform_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(VertexShaderTileAA);
+};
+
+class VertexShaderVideoTransform {
+ public:
+  VertexShaderVideoTransform();
+
+  void Init(gpu::gles2::GLES2Interface* context,
+            unsigned program,
+            int* base_uniform_index);
+  std::string GetShaderString() const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+
+  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 {
+ public:
+  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();
+
+  std::string SetBlendModeFunctions(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 {
+ 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 {
+ 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 {
+ 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 {
+ 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();
+};
+
+class FragmentShaderRGBATexPremultiplyAlpha : public FragmentTexOpaqueBinding {
+ public:
+  std::string GetShaderString(
+      TexCoordPrecision precision, SamplerType sampler) const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+class FragmentShaderTexBackgroundVaryingAlpha
+    : public FragmentTexBackgroundBinding {
+ public:
+  std::string GetShaderString(
+      TexCoordPrecision precision, SamplerType sampler) const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+class FragmentShaderTexBackgroundPremultiplyAlpha
+    : public FragmentTexBackgroundBinding {
+ public:
+  std::string GetShaderString(
+      TexCoordPrecision precision, SamplerType sampler) const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+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;
+};
+
+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;
+};
+
+class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding {
+ public:
+  std::string GetShaderString(
+      TexCoordPrecision precision, SamplerType sampler) const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+class FragmentShaderRGBATex : public FragmentTexOpaqueBinding {
+ public:
+  std::string GetShaderString(
+      TexCoordPrecision precision, SamplerType sampler) const;
+  static std::string GetShaderHead();
+  static std::string GetShaderBody();
+};
+
+// 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();
+};
+
+// 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();
+};
+
+class FragmentShaderRGBATexAlphaAA : public FragmentTexBlendMode {
+ 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:
+  int sampler_location_;
+  int alpha_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaAA);
+};
+
+class FragmentTexClampAlphaAABinding : public FragmentTexBlendMode {
+ 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();
+};
+
+// 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();
+};
+
+class FragmentShaderRGBATexAlphaMask : public FragmentTexBlendMode {
+ 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:
+  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 {
+ 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:
+  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 {
+ 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:
+  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 {
+ 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:
+  int sampler_location_;
+  int alpha_location_;
+  int color_matrix_location_;
+  int color_offset_location_;
+};
+
+class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentTexBlendMode {
+ 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:
+  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 {
+ public:
+  FragmentShaderYUVVideo();
+  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 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 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 clamp_rect_location() const { return clamp_rect_location_; }
+
+ private:
+  int y_texture_location_;
+  int u_texture_location_;
+  int v_texture_location_;
+  int alpha_location_;
+  int yuv_matrix_location_;
+  int yuv_adj_location_;
+  int clamp_rect_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderYUVVideo);
+};
+
+class FragmentShaderYUVAVideo : public FragmentTexBlendMode {
+ public:
+  FragmentShaderYUVAVideo();
+  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 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 a_texture_location() const { return a_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 clamp_rect_location() const { return clamp_rect_location_; }
+
+ private:
+  int y_texture_location_;
+  int u_texture_location_;
+  int v_texture_location_;
+  int a_texture_location_;
+  int alpha_location_;
+  int yuv_matrix_location_;
+  int yuv_adj_location_;
+  int clamp_rect_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderYUVAVideo);
+};
+
+class FragmentShaderColor : public FragmentTexBlendMode {
+ 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:
+  int color_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderColor);
+};
+
+class FragmentShaderColorAA : public FragmentTexBlendMode {
+ 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:
+  int color_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderColorAA);
+};
+
+class FragmentShaderCheckerboard : public FragmentTexBlendMode {
+ public:
+  FragmentShaderCheckerboard();
+  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 alpha_location() const { return alpha_location_; }
+  int tex_transform_location() const { return tex_transform_location_; }
+  int frequency_location() const { return frequency_location_; }
+  int color_location() const { return color_location_; }
+
+ private:
+  int alpha_location_;
+  int tex_transform_location_;
+  int frequency_location_;
+  int color_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(FragmentShaderCheckerboard);
+};
+
+}  // namespace cc
+
+#endif  // CC_OUTPUT_SHADER_H_