Add subscribeUniform extension pipeline

gpu/command_buffer/service/program_manager.h

 // Copyright (c) 2012 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 GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 class GPU_EXPORT Program : public base::RefCounted<Program> {
  public:
   static const int kMaxAttachedShaders = 2;
 
   enum VaryingsPackingOption {
     kCountOnlyStaticallyUsed,
     kCountAll
   };
 
   enum UniformApiType {
+    kUniformNone = 0,
     kUniform1i = 1 << 0,
     kUniform2i = 1 << 1,
     kUniform3i = 1 << 2,
     kUniform4i = 1 << 3,
     kUniform1f = 1 << 4,
     kUniform2f = 1 << 5,
     kUniform3f = 1 << 6,
     kUniform4f = 1 << 7,
     kUniformMatrix2f = 1 << 8,
     kUniformMatrix3f = 1 << 9,
@@ skipping 36 matching lines @@
     GLsizei size;
     GLenum type;
     GLint location;
     std::string name;
   };
 
   typedef std::vector<UniformInfo> UniformInfoVector;
   typedef std::vector<VertexAttrib> AttribInfoVector;
   typedef std::vector<int> SamplerIndices;
   typedef std::map<std::string, GLint> LocationMap;
+  typedef base::hash_map<GLint, GLenum> SubscriptionMap;
 
   Program(ProgramManager* manager, GLuint service_id);
 
   GLuint service_id() const {
     return service_id_;
   }
 
   const SamplerIndices& sampler_indices() {
     return sampler_indices_;
   }
@@ skipping 76 matching lines @@
 
   const std::string* log_info() const {
     return log_info_.get();
   }
 
   bool InUse() const {
     DCHECK_GE(use_count_, 0);
     return use_count_ != 0;
   }
 
+  void SetNeedsUpdateSubscriptions();
+  bool needs_update_subscriptions() const {
+    return needs_update_subscriptions_;
+  }
+
   // Sets attribute-location binding from a glBindAttribLocation() call.
   void SetAttribLocationBinding(const std::string& attrib, GLint location) {
     bind_attrib_location_map_[attrib] = location;
   }
 
   // Sets uniform-location binding from a glBindUniformLocationCHROMIUM call.
   // returns false if error.
   bool SetUniformLocationBinding(const std::string& name, GLint location);
 
   // Detects if there are attribute location conflicts from
@@ skipping 15 matching lines @@
   // GLSL ES spec 1.00.17, section 4.6.4, Invariance and Linkage.
   bool DetectBuiltInInvariantConflicts() const;
 
   // Return true if an uniform and an attribute share the same name.
   bool DetectGlobalNameConflicts(std::string* conflicting_name) const;
 
   // Return false if varyings can't be packed into the max available
   // varying registers.
   bool CheckVaryingsPacking(VaryingsPackingOption option) const;
 
+  // Subscribe uniform |location| to |target|
+  void AddSubscription(GLint location, GLenum target);
+  // Unsubscribes uniform |location| for any targets
+  void RemoveSubscription(GLint location);
+
   // Visible for testing
   const LocationMap& bind_attrib_location_map() const {
     return bind_attrib_location_map_;
   }
 
+  const SubscriptionMap& subscription_map() const { return subscription_map_; }
+
  private:
   friend class base::RefCounted<Program>;
   friend class ProgramManager;
 
   ~Program();
 
   void set_log_info(const char* str) {
     log_info_.reset(str ? new std::string(str) : NULL);
   }
 
@@ skipping 97 matching lines @@
 
   // This is true if glLinkProgram was successful at least once.
   bool valid_;
 
   // This is true if glLinkProgram was successful last time it was called.
   bool link_status_;
 
   // True if the uniforms have been cleared.
   bool uniforms_cleared_;
 
+  // True if one or more subscription uniforms are out of date
+  bool needs_update_subscriptions_;
+
   // This is different than uniform_infos_.size() because
   // that is a sparce array.
   GLint num_uniforms_;
 
   // Log info
   scoped_ptr<std::string> log_info_;
 
   // attribute-location binding map from glBindAttribLocation() calls.
   LocationMap bind_attrib_location_map_;
 
   // uniform-location binding map from glBindUniformLocationCHROMIUM() calls.
   LocationMap bind_uniform_location_map_;
+
+  SubscriptionMap subscription_map_;
 };
 
 // Tracks the Programs.
 //
 // NOTE: To support shared resources an instance of this class will
 // need to be shared by multiple GLES2Decoders.
 class GPU_EXPORT ProgramManager {
  public:
   explicit ProgramManager(ProgramCache* program_cache,
                           uint32 max_varying_vectors);
@@ skipping 25 matching lines @@
 
   // Clears the uniforms for this program.
   void ClearUniforms(Program* program);
 
   // Returns true if prefix is invalid for gl.
   static bool IsInvalidPrefix(const char* name, size_t length);
 
   // Check if a Program is owned by this ProgramManager.
   bool IsOwned(Program* program);
 
+  // Update the active_state of the subscriptions
+  void ActivateUniformSubscriptionState();
+
   static int32 MakeFakeLocation(int32 index, int32 element);
 
+  static Program::UniformApiType ApiTypeForSubscriptionTarget(GLenum target);
+
   uint32 max_varying_vectors() const {
     return max_varying_vectors_;
   }
 
  private:
   friend class Program;
 
   void StartTracking(Program* program);
   void StopTracking(Program* program);
 
@@ skipping 18 matching lines @@
 
   uint32 max_varying_vectors_;
 
   DISALLOW_COPY_AND_ASSIGN(ProgramManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_