command_buffer: Make inactive bound fragment inputs 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 48 matching lines @@
     kUniformMatrix2x4f = 1 << 16,
     kUniformMatrix3x2f = 1 << 17,
     kUniformMatrix3x4f = 1 << 18,
     kUniformMatrix4x2f = 1 << 19,
     kUniformMatrix4x3f = 1 << 20,
   };
   struct FragmentInputInfo {
     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(const std::string& client_name,
                 GLint client_location_base,
                 GLenum _type,
                 bool _is_array,
@@ skipping 20 matching lines @@
           type(_type),
           location(_location),
           name(_name) {
     }
     GLsizei size;
     GLenum type;
     GLint location;
     std::string name;
   };
 
-  class UniformLocationEntry {
+  template <typename T>
+  class ShaderVariableLocationEntry {
    public:
-    UniformLocationEntry() : uniform_(nullptr), inactive_(false) {}
-    bool IsUnused() const { return !uniform_ && !inactive_; }
+    ShaderVariableLocationEntry()
+        : shader_variable_(nullptr), inactive_(false) {}
+    bool IsUnused() const { return !shader_variable_ && !inactive_; }
     bool IsInactive() const { return inactive_; }
-    bool IsActive() const { return uniform_ != nullptr; }
+    bool IsActive() const { return shader_variable_ != nullptr; }
     void SetInactive() {
-      uniform_ = nullptr;
+      shader_variable_ = nullptr;
       inactive_ = true;
     }
-    void SetActive(UniformInfo* uniform) {
-      DCHECK(uniform);
-      uniform_ = uniform;
+    void SetActive(T* shader_variable) {
+      DCHECK(shader_variable);
+      shader_variable_ = shader_variable;
       inactive_ = false;
     }
-    const UniformInfo* uniform() const {
+    const T* shader_variable() const {
       DCHECK(IsActive());
-      return uniform_;
+      return shader_variable_;
     }
-    UniformInfo* uniform() {
+    T* shader_variable() {
       DCHECK(IsActive());
-      return uniform_;
+      return shader_variable_;
     }
 
    private:
-    UniformInfo* uniform_;  // Pointer to uniform_info_ vector entry.
+    T* shader_variable_;  // Pointer to *_info_ vector entry.
     bool inactive_;
   };
 
   typedef std::vector<UniformInfo> UniformInfoVector;
-  typedef std::vector<UniformLocationEntry> UniformLocationVector;
+  typedef std::vector<ShaderVariableLocationEntry<UniformInfo>>
+      UniformLocationVector;
   typedef std::vector<VertexAttrib> AttribInfoVector;
   typedef std::vector<FragmentInputInfo> FragmentInputInfoVector;
+  typedef std::vector<ShaderVariableLocationEntry<FragmentInputInfo>>
+      FragmentInputLocationVector;
   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 32 matching lines @@
   const std::string* GetUniformMappedName(
       const std::string& original_name) const;
 
   // If the hashed name is not found, return NULL.
   const std::string* GetOriginalNameFromHashedName(
       const std::string& hashed_name) const;
 
   const FragmentInputInfo* GetFragmentInputInfoByFakeLocation(
       GLint fake_location) const;
 
+  bool IsInactiveFragmentInputLocationByFakeLocation(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 for bound, non-existing uniform.
   bool IsInactiveUniformLocationByFakeLocation(GLint fake_location) const;
@@ skipping 227 matching lines @@
   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_;
+  FragmentInputLocationVector fragment_input_locations_;
 
   // 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_;
@@ skipping 108 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_