The great shader refactor: Move all programs to a common cache

cc/output/program_binding.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_PROGRAM_BINDING_H_
 #define CC_OUTPUT_PROGRAM_BINDING_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 96 matching lines @@
   bool is_opaque_ = false;
 
   PremultipliedAlphaMode premultiplied_alpha_ = PREMULTIPLIED_ALPHA;
   bool has_background_color_ = false;
 
   MaskMode mask_mode_ = NO_MASK;
   bool mask_for_background_ = false;
   bool has_color_matrix_ = false;
 };
 
+struct ProgramKeyHash {
+  size_t operator()(const ProgramKey& key) const {
+    return (static_cast<size_t>(key.type_) << 0) ^
+           (static_cast<size_t>(key.precision_) << 3) ^
+           (static_cast<size_t>(key.sampler_) << 6) ^
+           (static_cast<size_t>(key.blend_mode_) << 9) ^
+           (static_cast<size_t>(key.aa_mode_) << 15) ^
+           (static_cast<size_t>(key.swizzle_mode_) << 16) ^
+           (static_cast<size_t>(key.is_opaque_) << 17) ^
+           (static_cast<size_t>(key.premultiplied_alpha_) << 19) ^
+           (static_cast<size_t>(key.has_background_color_) << 20) ^
+           (static_cast<size_t>(key.mask_mode_) << 21) ^
+           (static_cast<size_t>(key.mask_for_background_) << 22) ^
+           (static_cast<size_t>(key.has_color_matrix_) << 23);
+  }
+};
+
 template <class VertexShader, class FragmentShader>
 class ProgramBinding : public ProgramBindingBase {
  public:
   ProgramBinding() {}
 
   void Initialize(ContextProvider* context_provider, const ProgramKey& key) {
     // Set parameters that are common to all sub-classes.
     vertex_shader_.aa_mode_ = key.aa_mode_;
     fragment_shader_.aa_mode_ = key.aa_mode_;
     fragment_shader_.blend_mode_ = key.blend_mode_;
@@ skipping 17 matching lines @@
       case PROGRAM_TYPE_TEXTURE:
         InitializeTextureProgram(key);
         break;
       case PROGRAM_TYPE_RENDER_PASS:
         InitializeRenderPassProgram(key);
         break;
       case PROGRAM_TYPE_VIDEO_STREAM:
         InitializeVideoStreamProgram(key);
         break;
     }
-    fragment_shader_.CheckSubclassProperties();
-    vertex_shader_.CheckSubclassProperties();
     InitializeInternal(context_provider);
   }
 
   void InitializeVideoYUV(ContextProvider* context_provider,
                           TexCoordPrecision precision,
                           SamplerType sampler,
                           bool use_alpha_plane,
                           bool use_nv12,
                           bool use_color_lut) {
     vertex_shader_.tex_coord_source_ = TEX_COORD_SOURCE_ATTRIBUTE;
     vertex_shader_.has_matrix_ = true;
     vertex_shader_.is_ya_uv_ = true;
 
     fragment_shader_.use_alpha_texture_ = use_alpha_plane;
     fragment_shader_.use_nv12_ = use_nv12;
     fragment_shader_.use_color_lut_ = use_color_lut;
     fragment_shader_.tex_coord_precision_ = precision;
     fragment_shader_.sampler_type_ = sampler;
 
-    fragment_shader_.CheckSubclassProperties();
-    vertex_shader_.CheckSubclassProperties();
     InitializeInternal(context_provider);
   }
 
   const VertexShader& vertex_shader() const { return vertex_shader_; }
   const FragmentShader& fragment_shader() const { return fragment_shader_; }
 
  private:
   void InitializeDebugBorderProgram() {
     // Initialize vertex program.
     vertex_shader_.has_matrix_ = true;
@@ skipping 121 matching lines @@
 
     initialized_ = true;
   }
 
   VertexShader vertex_shader_;
   FragmentShader fragment_shader_;
 
   DISALLOW_COPY_AND_ASSIGN(ProgramBinding);
 };
 
+typedef ProgramBinding<VertexShaderBase, FragmentShaderBase> Program;
+
 }  // namespace cc
 
 #endif  // CC_OUTPUT_PROGRAM_BINDING_H_