command_buffer: Make inactive bound uniforms reserve the location

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 55 matching lines @@
     FragmentInputInfo(GLenum _type, GLuint _location)
         : type(_type), location(_location) {}
     FragmentInputInfo() : type(GL_NONE), location(0) {}
     bool IsValid() const { return type != GL_NONE; }
     GLenum type;
     GLuint location;
   };
 
   struct UniformInfo {
     UniformInfo();
-    UniformInfo(
-        GLsizei _size, GLenum _type, GLint _fake_location_base,
-        const std::string& _name);
+    UniformInfo(const std::string& client_name,
+                GLint client_location_base,
+                GLenum _type,
+                bool _is_array,
+                const std::vector<GLint>& service_locations);
     ~UniformInfo();
-
-    bool IsValid() const {
-      return size != 0;
-    }
-
     bool IsSampler() const {
       return type == GL_SAMPLER_2D || type == GL_SAMPLER_2D_RECT_ARB ||
              type == GL_SAMPLER_CUBE || type == GL_SAMPLER_EXTERNAL_OES;
     }
 
     GLsizei size;
     GLenum type;
     uint32 accepts_api_type;
     GLint fake_location_base;
     bool is_array;
     std::string name;
     std::vector<GLint> element_locations;
     std::vector<GLuint> texture_units;
   };
   struct VertexAttrib {
     VertexAttrib(GLsizei _size, GLenum _type, const std::string& _name,
                  GLint _location)
         : size(_size),
           type(_type),
           location(_location),
           name(_name) {
     }
     GLsizei size;
     GLenum type;
     GLint location;
     std::string name;
   };
 
+  class UniformLocationEntry {
+   public:
+    UniformLocationEntry() : uniform_(nullptr), inactive_(false) {}
+    bool IsUnused() const { return !uniform_ && !inactive_; }
+    bool IsInactive() const { return inactive_; }
+    bool IsActive() const { return uniform_; }
+    void SetInactive() {
+      uniform_ = nullptr;
+      inactive_ = true;
+    }
+    void SetActive(UniformInfo* uniform) {
+      uniform_ = uniform;

[Zhenyao Mo, 2015/11/20 00:15:01]

Maybe DCHECK(uniform)?

[Kimmo Kinnunen, 2015/11/20 07:56:53]

Done.

+      inactive_ = false;
+    }
+    const UniformInfo* uniform() const {
+      DCHECK(IsActive());
+      return uniform_;
+    }
+    UniformInfo* uniform() {
+      DCHECK(IsActive());
+      return uniform_;
+    }
+
+   private:
+    UniformInfo* uniform_;  // Pointer to uniform_info_ vector entry.
+    bool inactive_;
+  };
+
   typedef std::vector<UniformInfo> UniformInfoVector;
+  typedef std::vector<UniformLocationEntry> UniformLocationVector;
   typedef std::vector<VertexAttrib> AttribInfoVector;
   typedef std::vector<FragmentInputInfo> FragmentInputInfoVector;
   typedef std::vector<int> SamplerIndices;
   typedef std::map<std::string, GLint> LocationMap;
   typedef std::vector<std::string> StringVector;
 
   Program(ProgramManager* manager, GLuint service_id);
 
   GLuint service_id() const {
     return service_id_;
@@ skipping 41 matching lines @@
   const FragmentInputInfo* GetFragmentInputInfoByFakeLocation(
       GLint fake_location) const;
 
   // Gets the fake location of a uniform by name.
   GLint GetUniformFakeLocation(const std::string& name) const;
 
   // Gets the UniformInfo of a uniform by location.
   const UniformInfo* GetUniformInfoByFakeLocation(
       GLint fake_location, GLint* real_location, GLint* array_index) const;
 
+  // Returns true if |fake_location| is a location for an inactive uniform,
+  // -1 or bound, non-existing uniform.

[Zhenyao Mo, 2015/11/20 00:15:01]

nit: or -> for

[Kimmo Kinnunen, 2015/11/20 07:56:53]

Done.

+  bool IsInactiveUniformLocationByFakeLocation(GLint fake_location) const;
+
   // Gets all the program info.
   void GetProgramInfo(
       ProgramManager* manager, CommonDecoder::Bucket* bucket) const;
 
   // Gets all the UniformBlock info.
   // Return false on overflow.
   bool GetUniformBlocks(CommonDecoder::Bucket* bucket) const;
 
   // Gets all the TransformFeedbackVarying info.
   // Return false on overflow.
@@ skipping 141 matching lines @@
   void MarkAsDeleted() {
     DCHECK(!deleted_);
     deleted_ =  true;
   }
 
   // Resets the program.
   void Reset();
 
   // Updates the program info after a successful link.
   void Update();
+  void UpdateUniforms();
   void UpdateFragmentInputs();
 
   // Process the program log, replacing the hashed names with original names.
   std::string ProcessLogInfo(const std::string& log);
 
   // Updates the program log info from GL
   void UpdateLogInfo();
 
   // Clears all the uniforms.
   void ClearUniforms(std::vector<uint8>* zero_buffer);
 
   // If long attribate names are mapped during shader translation, call
   // glBindAttribLocation() again with the mapped names.
   // This is called right before the glLink() call, but after shaders are
   // translated.
   void ExecuteBindAttribLocationCalls();
 
   // The names of transform feedback varyings need to be hashed just
   // like bound attributes' locations, just before the link call.
   // Returns false upon failure.
   bool ExecuteTransformFeedbackVaryingsCall();
 
-  void AddUniformInfo(
-      GLsizei size, GLenum type, GLint location, GLint fake_base_location,
-      const std::string& name, const std::string& original_name,
-      size_t* next_available_index);
-
-  // Query uniform data returned by ANGLE translator by the mapped name.
-  // Some drivers incorrectly return an uniform name of size-1 array without
-  // "[0]". In this case, we correct the name by appending "[0]" to it.
-  void GetCorrectedUniformData(
-      const std::string& name,
-      std::string* corrected_name, std::string* original_name,
-      GLsizei* size, GLenum* type) const;
-
   // Query VertexAttrib data returned by ANGLE translator by the mapped name.
   void GetVertexAttribData(
       const std::string& name, std::string* original_name, GLenum* type) const;
 
   void DetachShaders(ShaderManager* manager);
 
-  static inline GLint GetUniformInfoIndexFromFakeLocation(
+  static inline size_t GetUniformLocationIndexFromFakeLocation(
       GLint fake_location) {
-    return fake_location & 0xFFFF;
+    return static_cast<size_t>(fake_location & 0xFFFF);
   }
 
-  static inline GLint GetArrayElementIndexFromFakeLocation(
+  static inline size_t GetArrayElementIndexFromFakeLocation(
       GLint fake_location) {
-    return (fake_location >> 16) & 0xFFFF;
+    return static_cast<size_t>((fake_location >> 16) & 0xFFFF);
   }
 
   const FeatureInfo& feature_info() const;
 
   ProgramManager* manager_;
 
   int use_count_;
 
   GLsizei max_attrib_name_length_;
 
   // Attrib by index.
   AttribInfoVector attrib_infos_;
 
   // Attrib by location to index.
   std::vector<GLint> attrib_location_to_index_map_;
 
   GLsizei max_uniform_name_length_;
 
   // Uniform info by index.
   UniformInfoVector uniform_infos_;
+  UniformLocationVector uniform_locations_;
 
   // The indices of the uniforms that are samplers.
   SamplerIndices sampler_indices_;
 
   FragmentInputInfoVector fragment_input_infos_;
 
   // The program this Program is tracking.
   GLuint service_id_;
 
   // Shaders by type of shader.
   scoped_refptr<Shader>
       attached_shaders_[kMaxAttachedShaders];
 
   // True if this program is marked as deleted.
   bool deleted_;
 
   // 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_;
 
-  // 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_;
 
   std::vector<std::string> transform_feedback_varyings_;
@@ skipping 88 matching lines @@
 };
 
 inline const FeatureInfo& Program::feature_info() const {
   return *manager_->feature_info_.get();
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_