command_buffer: Make inactive bound uniforms reserve the location

gpu/command_buffer/service/program_manager.cc

 // 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.
 
 #include "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 99 matching lines @@
 uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
       type(GL_NONE),
+      accepts_api_type(0),
       fake_location_base(0),
-      is_array(false) {
-}
+      is_array(false) {}
 
-Program::UniformInfo::UniformInfo(GLsizei _size,
+Program::UniformInfo::UniformInfo(const std::string& client_name,
+                                  int client_location_base,
                                   GLenum _type,
-                                  int _fake_location_base,
-                                  const std::string& _name)
-    : size(_size),
+                                  bool _is_array,
+                                  const std::vector<GLint>& service_locations)
+    : size(service_locations.size()),
       type(_type),
       accepts_api_type(0),
-      fake_location_base(_fake_location_base),
-      is_array(false),
-      name(_name) {
+      fake_location_base(client_location_base),
+      is_array(_is_array),
+      name(client_name),
+      element_locations(service_locations) {
   switch (type) {
     case GL_INT:
       accepts_api_type = kUniform1i;
       break;
     case GL_INT_VEC2:
       accepts_api_type = kUniform2i;
       break;
     case GL_INT_VEC3:
       accepts_api_type = kUniform3i;
       break;
@@ skipping 85 matching lines @@
     case GL_UNSIGNED_INT_SAMPLER_3D:
     case GL_UNSIGNED_INT_SAMPLER_CUBE:
     case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
       accepts_api_type = kUniform1i;
       break;
 
     default:
       NOTREACHED() << "Unhandled UniformInfo type " << type;
       break;
   }
+  DCHECK_LT(0, size);
+  DCHECK(is_array || size == 1);
+
+  size_t num_texture_units = IsSampler() ? static_cast<size_t>(size) : 0u;
+  texture_units.clear();
+  texture_units.resize(num_texture_units, 0);
 }
-
 Program::UniformInfo::~UniformInfo() {}
 
 bool ProgramManager::IsInvalidPrefix(const char* name, size_t length) {
   static const char kInvalidPrefix[] = { 'g', 'l', '_' };
   return (length >= sizeof(kInvalidPrefix) &&
       memcmp(name, kInvalidPrefix, sizeof(kInvalidPrefix)) == 0);
 }
 
 Program::Program(ProgramManager* manager, GLuint service_id)
     : manager_(manager),
       use_count_(0),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       deleted_(false),
       valid_(false),
       link_status_(false),
       uniforms_cleared_(false),
-      num_uniforms_(0),
       transform_feedback_buffer_mode_(GL_NONE) {
   manager_->StartTracking(this);
 }
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
-  num_uniforms_ = 0;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
+  uniform_locations_.clear();
   fragment_input_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
 }
 
 std::string Program::ProcessLogInfo(
     const std::string& log) {
   std::string output;
   re2::StringPiece input(log);
   std::string prior_log;
@@ skipping 31 matching lines @@
   set_log_info(ProcessLogInfo(log).c_str());
 }
 
 void Program::ClearUniforms(
     std::vector<uint8>* zero_buffer) {
   DCHECK(zero_buffer);
   if (uniforms_cleared_) {
     return;
   }
   uniforms_cleared_ = true;
-  for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
-    const UniformInfo& uniform_info = uniform_infos_[ii];
-    if (!uniform_info.IsValid()) {
-      continue;
-    }
+  for (const UniformInfo& uniform_info : uniform_infos_) {
     GLint location = uniform_info.element_locations[0];
     GLsizei size = uniform_info.size;
     uint32 unit_size =
         GLES2Util::GetElementCountForUniformType(uniform_info.type) *
         GLES2Util::GetElementSizeForUniformType(uniform_info.type);
     DCHECK_LT(0u, unit_size);
     uint32 size_needed = size * unit_size;
     if (size_needed > zero_buffer->size()) {
       zero_buffer->resize(size_needed, 0u);
     }
@@ skipping 97 matching lines @@
           location, size, false, reinterpret_cast<const GLfloat*>(zero));
       break;
 
     default:
       NOTREACHED();
       break;
     }
   }
 }
 
-namespace {
-
-struct UniformData {
-  UniformData() : size(-1), type(GL_NONE), location(0), added(false) {
-  }
-  std::string queried_name;
-  std::string corrected_name;
-  std::string original_name;
-  GLsizei size;
-  GLenum type;
-  GLint location;
-  bool added;
-};
-
-}  // anonymous namespace
-
 void Program::Update() {
   Reset();
   UpdateLogInfo();
   link_status_ = true;
   uniforms_cleared_ = false;
   GLint num_attribs = 0;
   GLint max_len = 0;
   GLint max_location = -1;
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTES, &num_attribs);
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
@@ skipping 35 matching lines @@
     DVLOG(1) << "----: attribs for service_id: " << service_id();
     for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
       const VertexAttrib& info = attrib_infos_[ii];
       DVLOG(1) << ii << ": loc = " << info.location
                << ", size = " << info.size
                << ", type = " << GLES2Util::GetStringEnum(info.type)
                << ", name = " << info.name;
     }
   }
 #endif
-
-  max_len = 0;
-  GLint num_uniforms = 0;
-  glGetProgramiv(service_id_, GL_ACTIVE_UNIFORMS, &num_uniforms);
-  glGetProgramiv(service_id_, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_len);
-  DCHECK(num_uniforms <= 0 || max_len > 0);
-  name_buffer.reset(new char[max_len]);
-
-  // Reads all the names.
-  std::vector<UniformData> uniform_data;
-  for (GLint ii = 0; ii < num_uniforms; ++ii) {
-    GLsizei length = 0;
-    UniformData data;
-    glGetActiveUniform(
-        service_id_, ii, max_len, &length,
-        &data.size, &data.type, name_buffer.get());
-    DCHECK(length < max_len);
-    DCHECK(length == 0 || name_buffer[length] == '\0');
-    data.queried_name = std::string(name_buffer.get());
-    GetCorrectedUniformData(data.queried_name, &data.corrected_name,
-                            &data.original_name, &data.size, &data.type);
-    uniform_data.push_back(data);
-  }
-
-  // NOTE: We don't care if 2 uniforms are bound to the same location.
-  // One of them will take preference. The spec allows this, same as
-  // BindAttribLocation.
-  //
-  // The reason we don't check is if we were to fail we'd have to
-  // restore the previous program but since we've already linked successfully
-  // at this point the previous program is gone.
-
-  // Assigns the uniforms with bindings.
-  size_t next_available_index = 0;
-  for (size_t ii = 0; ii < uniform_data.size(); ++ii) {
-    UniformData& data = uniform_data[ii];
-    // Force builtin uniforms (gl_DepthRange) to have invalid location.
-    if (ProgramManager::IsInvalidPrefix(data.queried_name.c_str(),
-                                        data.queried_name.size())) {
-      data.location = -1;
-    } else {
-      data.location =
-          glGetUniformLocation(service_id_, data.queried_name.c_str());
-    }
-    // remove "[0]"
-    std::string short_name;
-    int element_index = 0;
-    bool good = GetUniformNameSansElement(data.original_name, &element_index,
-                                          &short_name);
-    DCHECK(good);
-    LocationMap::const_iterator it = bind_uniform_location_map_.find(
-        short_name);
-    if (it != bind_uniform_location_map_.end()) {
-      AddUniformInfo(
-          data.size, data.type, data.location, it->second, data.corrected_name,
-          data.original_name, &next_available_index);
-      data.added = true;
-    }
-  }
-
-  // Assigns the uniforms that were not bound.
-  for (size_t ii = 0; ii < uniform_data.size(); ++ii) {
-    const UniformData& data = uniform_data[ii];
-    if (!data.added) {
-      AddUniformInfo(
-          data.size, data.type, data.location, -1, data.corrected_name,
-          data.original_name, &next_available_index);
-    }
-  }
+  UpdateUniforms();
 
 #if !defined(NDEBUG)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGPUServiceLoggingGPU)) {
     DVLOG(1) << "----: uniforms for service_id: " << service_id();
-    for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
-      const UniformInfo& info = uniform_infos_[ii];
-      if (info.IsValid()) {
-        DVLOG(1) << ii << ": loc = " << info.element_locations[0]
-                 << ", size = " << info.size
-                 << ", type = " << GLES2Util::GetStringEnum(info.type)
-                 << ", name = " << info.name;
-      }
+    size_t ii = 0;
+    for (const UniformInfo& info : uniform_infos_) {
+      DVLOG(1) << ii++ << ": loc = " << info.element_locations[0]
+               << ", size = " << info.size
+               << ", type = " << GLES2Util::GetStringEnum(info.type)
+               << ", name = " << info.name;
     }
   }
 #endif
 
   UpdateFragmentInputs();
 
   valid_ = true;
 }
 
+void Program::UpdateUniforms() {
+  // Reserve each client-bound uniform location. This way unbound uniforms will
+  // not be allocated to locations that user expects bound uniforms to be, even
+  // if the expected uniforms are optimized away by the driver.
+  for (const auto& binding : bind_uniform_location_map_) {
+    if (binding.second < 0)
+      continue;
+    size_t client_location = static_cast<size_t>(binding.second);
+    if (uniform_locations_.size() <= client_location)
+      uniform_locations_.resize(client_location + 1);
+    uniform_locations_[client_location].SetInactive();
+  }
+
+  GLint num_uniforms = 0;
+  glGetProgramiv(service_id_, GL_ACTIVE_UNIFORMS, &num_uniforms);
+  if (num_uniforms <= 0)
+    return;
+
+  uniform_infos_.resize(num_uniforms);
+
+  GLint name_buffer_length = 0;
+  glGetProgramiv(service_id_, GL_ACTIVE_UNIFORM_MAX_LENGTH,
+                 &name_buffer_length);
+  DCHECK(name_buffer_length > 0);
+  scoped_ptr<char[]> name_buffer(new char[name_buffer_length]);
+
+  size_t unused_client_location_cursor = 0;
+
+  for (GLint uniform_index = 0; uniform_index < num_uniforms; ++uniform_index) {
+    GLsizei name_length = 0;
+    GLsizei size = 0;
+    GLenum type = GL_NONE;
+    glGetActiveUniform(service_id_, uniform_index, name_buffer_length,
+                       &name_length, &size, &type, name_buffer.get());
+    DCHECK(name_length < name_buffer_length);
+    DCHECK(name_length == 0 || name_buffer[name_length] == '\0');
+    std::string service_name(name_buffer.get(), name_length);
+
+    GLint service_location = -1;
+    // Force builtin uniforms (gl_DepthRange) to have invalid location.
+    if (!ProgramManager::IsInvalidPrefix(service_name.c_str(),
+                                         service_name.size())) {
+      service_location =
+          glGetUniformLocation(service_id_, service_name.c_str());
+    }
+
+    // Determine the client name of the uniform and whether it is an array
+    // or not.
+    bool is_array;
+    std::string client_name;
+    for (size_t i = 0; i < kMaxAttachedShaders && client_name.empty(); ++i) {
+      const auto& shader = attached_shaders_[i];
+      if (!shader)
+        continue;
+      const sh::ShaderVariable* info = nullptr;
+      const sh::Uniform* uniform = shader->GetUniformInfo(service_name);
+      if (uniform &&
+          uniform->findInfoByMappedName(service_name, &info, &client_name)) {
+        DCHECK(!client_name.empty());
+        is_array = info->arraySize > 0;
+        type = info->type;
+        size = std::max(1u, info->arraySize);
+      }
+    }
+    if (client_name.empty()) {
+      // This happens only in cases where we do not have ANGLE or run unit tests
+      // (or ANGLE has a severe bug).
+      client_name = service_name;
+      GLSLArrayName parsed_service_name(service_name);
+      is_array = size > 1 || parsed_service_name.IsArrayName();
+    }
+
+    std::string service_base_name = service_name;
+    std::string client_base_name = client_name;
+    if (is_array) {
+      // Some drivers incorrectly return an uniform name of size-1 array without
+      // "[0]". In this case, we correct the service name by appending "[0]" to
+      // it.
+      GLSLArrayName parsed_service_name(service_name);
+      if (parsed_service_name.IsArrayName()) {
+        service_base_name = parsed_service_name.base_name();
+        GLSLArrayName parsed_client_name(client_name);
+        client_base_name = parsed_client_name.base_name();
+      } else {
+        service_name += "[0]";
+        client_name += "[0]";
+      }
+    }
+
+    // Assign a location for the uniform: use either client-bound
+    // location or automatically assigned to an unused location.
+    size_t client_location_base = 0;
+    LocationMap::const_iterator it =
+        bind_uniform_location_map_.find(client_base_name);
+    if (it != bind_uniform_location_map_.end()) {
+      client_location_base = it->second;
+    } else {
+      while (unused_client_location_cursor < uniform_locations_.size() &&
+             !uniform_locations_[unused_client_location_cursor].IsUnused())
+        unused_client_location_cursor++;
+      if (unused_client_location_cursor == uniform_locations_.size())
+        uniform_locations_.resize(unused_client_location_cursor + 1);
+      client_location_base = unused_client_location_cursor;
+      unused_client_location_cursor++;
+    }
+
+    // Populate the uniform list entry.
+    std::vector<GLint> service_locations;
+    service_locations.resize(size);
+    service_locations[0] = service_location;
+
+    if (size > 1) {
+      for (GLsizei ii = 1; ii < size; ++ii) {
+        std::string element_name(service_base_name + "[" +
+                                 base::IntToString(ii) + "]");
+        service_locations[ii] =
+            glGetUniformLocation(service_id_, element_name.c_str());
+      }
+    }
+
+    UniformInfo& info = uniform_infos_[uniform_index];
+    info = UniformInfo(client_name, client_location_base, type, is_array,
+                       service_locations);
+    if (info.IsSampler()) {
+      sampler_indices_.push_back(uniform_index);
+    }
+
+    // Populate the uniform location list entry.
+    // Before linking, we already validated that no two statically used uniforms
+    // are bound to the same location.
+    DCHECK(!uniform_locations_[client_location_base].IsActive());
+    uniform_locations_[client_location_base].SetActive(&info);
+
+    max_uniform_name_length_ = std::max(max_uniform_name_length_,
+                                        static_cast<GLsizei>(info.name.size()));
+  }
+}
+
 void Program::UpdateFragmentInputs() {
   if (!feature_info().feature_flags().chromium_path_rendering)
     return;
   GLint num_fragment_inputs = 0;
   glGetProgramInterfaceiv(service_id_, GL_FRAGMENT_INPUT_NV,
                           GL_ACTIVE_RESOURCES, &num_fragment_inputs);
   if (num_fragment_inputs <= 0)
     return;
   GLint max_len = 0;
   glGetProgramInterfaceiv(service_id_, GL_FRAGMENT_INPUT_NV, GL_MAX_NAME_LENGTH,
@@ skipping 290 matching lines @@
     return;
   }
   glValidateProgram(service_id());
   UpdateLogInfo();
 }
 
 GLint Program::GetUniformFakeLocation(
     const std::string& name) const {
   GLSLArrayName parsed_name(name);
 
-  for (GLuint ii = 0; ii < uniform_infos_.size(); ++ii) {
-    const UniformInfo& info = uniform_infos_[ii];
-    if (!info.IsValid()) {
-      continue;
-    }
+  for (const UniformInfo& info : uniform_infos_) {
     if (info.name == name ||
         (info.is_array &&
          info.name.compare(0, info.name.size() - 3, name) == 0)) {
       return info.fake_location_base;
     } else if (parsed_name.IsArrayName() && info.is_array) {
       // Look for an array specification.
       size_t open_pos = info.name.find_last_of('[');
       if (info.name.compare(0, open_pos, parsed_name.base_name()) == 0) {
         int index = parsed_name.element_index();
-        DCHECK(index >= 0);
         if (index < info.size) {
           DCHECK_GT(static_cast<int>(info.element_locations.size()), index);
           if (info.element_locations[index] == -1)
             return -1;
           return ProgramManager::MakeFakeLocation(
               info.fake_location_base, index);
         }
       }
     }
   }
   return -1;
 }
 
 GLint Program::GetAttribLocation(
     const std::string& original_name) const {
   for (GLuint ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
     if (info.name == original_name) {
       return info.location;
     }
   }
   return -1;
 }
 
 const Program::UniformInfo*
     Program::GetUniformInfoByFakeLocation(
         GLint fake_location, GLint* real_location, GLint* array_index) const {
   DCHECK(real_location);
   DCHECK(array_index);
-  if (fake_location < 0) {
-    return NULL;
-  }
+  if (fake_location < 0)
+    return nullptr;
+  size_t location_index =
+      GetUniformLocationIndexFromFakeLocation(fake_location);
+  if (location_index >= uniform_locations_.size())
+    return nullptr;
 
-  GLint uniform_index = GetUniformInfoIndexFromFakeLocation(fake_location);
-  if (uniform_index >= 0 &&
-      static_cast<size_t>(uniform_index) < uniform_infos_.size()) {
-    const UniformInfo& uniform_info = uniform_infos_[uniform_index];
-    if (!uniform_info.IsValid()) {
-      return NULL;
-    }
-    GLint element_index = GetArrayElementIndexFromFakeLocation(fake_location);
-    if (element_index < uniform_info.size) {
-      *real_location = uniform_info.element_locations[element_index];
-      *array_index = element_index;
-      return &uniform_info;
-    }
-  }
-  return NULL;
+  if (!uniform_locations_[location_index].IsActive())
+    return nullptr;
+
+  const UniformInfo* info = uniform_locations_[location_index].uniform();
+  size_t element_index = GetArrayElementIndexFromFakeLocation(fake_location);
+  if (static_cast<GLsizei>(element_index) >= info->size)
+    return nullptr;
+  *real_location = info->element_locations[element_index];
+  *array_index = element_index;
+  return info;
+}
+
+bool Program::IsInactiveUniformLocationByFakeLocation(
+    GLint fake_location) const {
+  if (fake_location < 0)
+    return true;
+  size_t location_index =
+      GetUniformLocationIndexFromFakeLocation(fake_location);
+  if (location_index >= uniform_locations_.size())
+    return false;

[zmo, 2015/11/20 00:23:42]

Question: why false here?

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

The function returns true only for locations of inactive uniforms, i.e. for
location that that behave like -1. When location_index >=
uniform_locations_.size(), it's guaranteed to be unused and non inactive.

+  return uniform_locations_[location_index].IsInactive();
 }
 
 const std::string* Program::GetAttribMappedName(
     const std::string& original_name) const {
   for (auto shader : attached_shaders_) {
     if (shader) {
       const std::string* mapped_name =
           shader->GetAttribMappedName(original_name);
       if (mapped_name)
         return mapped_name;
@@ skipping 59 matching lines @@
   // string would exactly match the name of the variable if the suffix "[0]"
   // were appended to the string".
 
   // At this point we can not know if the string identifies a simple variable,
   // a base name of an array, or nothing.  Store both, so if user overwrites
   // either, both still work correctly.
   bind_fragment_input_location_map_[name] = location;
   bind_fragment_input_location_map_[name + "[0]"] = location;
 }
 
-// Note: This is only valid to call right after a program has been linked
-// successfully.
-void Program::GetCorrectedUniformData(
-    const std::string& name,
-    std::string* corrected_name, std::string* original_name,
-    GLsizei* size, GLenum* type) const {
-  DCHECK(corrected_name && original_name && size && type);
-  for (auto shader : attached_shaders_) {
-    if (!shader)
-      continue;
-    const sh::ShaderVariable* info = NULL;
-    const sh::Uniform* uniform = shader->GetUniformInfo(name);
-    bool found = false;
-    if (uniform)
-      found = uniform->findInfoByMappedName(name, &info, original_name);
-    if (found) {
-      const std::string kArraySpec("[0]");
-      if (info->arraySize > 0 &&
-          !base::EndsWith(name, kArraySpec, base::CompareCase::SENSITIVE)) {
-        *corrected_name = name + kArraySpec;
-        *original_name += kArraySpec;
-      } else {
-        *corrected_name = name;
-      }
-      *type = info->type;
-      *size = std::max(1u, info->arraySize);
-      return;
-    }
-  }
-  // TODO(zmo): this path should never be reached unless there is a serious
-  // bug in the driver or in ANGLE translator.
-  *corrected_name = name;
-  *original_name = name;
-}
-
 void Program::GetVertexAttribData(
     const std::string& name, std::string* original_name, GLenum* type) const {
   DCHECK(original_name);
   DCHECK(type);
   Shader* shader = attached_shaders_[ShaderTypeToIndex(GL_VERTEX_SHADER)].get();
   if (shader) {
     // Vertex attributes can not be arrays or structs (GLSL ES 3.00.4, section
     // 4.3.4, "Input Variables"), so the top level sh::Attribute returns the
     // information we need.
     const sh::Attribute* info = shader->GetAttribInfo(name);
     if (info) {
       *original_name = info->name;
       *type = info->type;
       return;
     }
   }
   // TODO(zmo): this path should never be reached unless there is a serious
   // bug in the driver or in ANGLE translator.
   *original_name = name;
 }
 
-void Program::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) {
-  DCHECK(next_available_index);
-  const char* kArraySpec = "[0]";
-  size_t uniform_index =
-      fake_base_location >= 0 ? fake_base_location : *next_available_index;
-  if (uniform_infos_.size() < uniform_index + 1) {
-    uniform_infos_.resize(uniform_index + 1);
-  }
-
-  // Before linking, we already validated that no two statically used uniforms
-  // are bound to the same location.
-  DCHECK(!uniform_infos_[uniform_index].IsValid());
-
-  uniform_infos_[uniform_index] = UniformInfo(
-      size, type, uniform_index, original_name);
-  ++num_uniforms_;
-
-  UniformInfo& info = uniform_infos_[uniform_index];
-  info.element_locations.resize(size);
-  info.element_locations[0] = location;
-  DCHECK_LE(0, size);
-  size_t num_texture_units = info.IsSampler() ? static_cast<size_t>(size) : 0u;
-  info.texture_units.clear();
-  info.texture_units.resize(num_texture_units, 0);
-
-  if (size > 1) {
-    // Go through the array element locations looking for a match.
-    // We can skip the first element because it's the same as the
-    // the location without the array operators.
-    size_t array_pos = name.rfind(kArraySpec);
-    std::string base_name = name;
-    if (name.size() > 3) {
-      if (array_pos != name.size() - 3) {
-        info.name = name + kArraySpec;
-      } else {
-        base_name = name.substr(0, name.size() - 3);
-      }
-    }
-    for (GLsizei ii = 1; ii < info.size; ++ii) {
-      std::string element_name(base_name + "[" + base::IntToString(ii) + "]");
-      info.element_locations[ii] =
-          glGetUniformLocation(service_id_, element_name.c_str());
-    }
-  }
-
-  info.is_array =
-     (size > 1 ||
-      (info.name.size() > 3 &&
-       info.name.rfind(kArraySpec) == info.name.size() - 3));
-
-  if (info.IsSampler()) {
-    sampler_indices_.push_back(info.fake_location_base);
-  }
-  max_uniform_name_length_ =
-      std::max(max_uniform_name_length_,
-               static_cast<GLsizei>(info.name.size()));
-
-  while (*next_available_index < uniform_infos_.size() &&
-         uniform_infos_[*next_available_index].IsValid()) {
-    *next_available_index = *next_available_index + 1;
-  }
-}
-
 const Program::UniformInfo*
     Program::GetUniformInfo(
         GLint index) const {
   if (static_cast<size_t>(index) >= uniform_infos_.size()) {
     return NULL;
   }
-
-  const UniformInfo& info = uniform_infos_[index];
-  return info.IsValid() ? &info : NULL;
+  return &uniform_infos_[index];
 }
 
 bool Program::SetSamplers(
     GLint num_texture_units, GLint fake_location,
     GLsizei count, const GLint* value) {
   if (fake_location < 0) {
     return true;
   }
-  GLint uniform_index = GetUniformInfoIndexFromFakeLocation(fake_location);
-  if (uniform_index >= 0 &&
-      static_cast<size_t>(uniform_index) < uniform_infos_.size()) {
-    UniformInfo& info = uniform_infos_[uniform_index];
-    if (!info.IsValid()) {
-      return false;
-    }
-    GLint element_index = GetArrayElementIndexFromFakeLocation(fake_location);
-    if (element_index < info.size) {
-      count = std::min(info.size - element_index, count);
-      if (info.IsSampler() && count > 0) {
-        for (GLsizei ii = 0; ii < count; ++ii) {
-          if (value[ii] < 0 || value[ii] >= num_texture_units) {
-            return false;
-          }
-        }
-        std::copy(value, value + count,
-                  info.texture_units.begin() + element_index);
-        return true;
+  size_t location_index =
+      GetUniformLocationIndexFromFakeLocation(fake_location);
+  if (location_index >= uniform_infos_.size())
+    return false;
+
+  if (!uniform_locations_[location_index].IsActive())
+    return false;
+
+  UniformInfo* info = uniform_locations_[location_index].uniform();
+
+  size_t element_index = GetArrayElementIndexFromFakeLocation(fake_location);
+  if (static_cast<GLsizei>(element_index) >= info->size)
+    return true;
+  count = std::min(info->size - static_cast<GLsizei>(element_index), count);
+  if (info->IsSampler() && count > 0) {
+    for (GLsizei ii = 0; ii < count; ++ii) {
+      if (value[ii] < 0 || value[ii] >= num_texture_units) {
+        return false;
       }
     }
+    std::copy(value, value + count,
+              info->texture_units.begin() + element_index);
+    return true;
   }
   return true;
 }
 
 void Program::GetProgramiv(GLenum pname, GLint* params) {
   switch (pname) {
     case GL_ACTIVE_ATTRIBUTES:
       *params = attrib_infos_.size();
       break;
     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
       // Notice +1 to accomodate NULL terminator.
       *params = max_attrib_name_length_ + 1;
       break;
     case GL_ACTIVE_UNIFORMS:
-      *params = num_uniforms_;
+      *params = uniform_infos_.size();
       break;
     case GL_ACTIVE_UNIFORM_MAX_LENGTH:
       // Notice +1 to accomodate NULL terminator.
       *params = max_uniform_name_length_ + 1;
       break;
     case GL_LINK_STATUS:
       *params = link_status_;
       break;
     case GL_INFO_LOG_LENGTH:
       // Notice +1 to accomodate NULL terminator.
@@ skipping 341 matching lines @@
   // of an identifier is 256 characters.
   uint32 num_locations = 0;
   uint32 total_string_size = 0;
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
     num_locations += 1;
     total_string_size += info.name.size();
   }
 
-  for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
-    const UniformInfo& info = uniform_infos_[ii];
-    if (info.IsValid()) {
-      num_locations += info.element_locations.size();
-      total_string_size += info.name.size();
-    }
+  for (const UniformInfo& info : uniform_infos_) {
+    num_locations += info.element_locations.size();
+    total_string_size += info.name.size();
   }
 
-  uint32 num_inputs = attrib_infos_.size() + num_uniforms_;
+  uint32 num_inputs = attrib_infos_.size() + uniform_infos_.size();
   uint32 input_size = num_inputs * sizeof(ProgramInput);
   uint32 location_size = num_locations * sizeof(int32);
   uint32 size = sizeof(ProgramInfoHeader) +
       input_size + location_size + total_string_size;
 
   bucket->SetSize(size);
   ProgramInfoHeader* header = bucket->GetDataAs<ProgramInfoHeader*>(0, size);
   ProgramInput* inputs = bucket->GetDataAs<ProgramInput*>(
       sizeof(ProgramInfoHeader), input_size);
   int32* locations = bucket->GetDataAs<int32*>(
       sizeof(ProgramInfoHeader) + input_size, location_size);
   char* strings = bucket->GetDataAs<char*>(
       sizeof(ProgramInfoHeader) + input_size + location_size,
       total_string_size);
   DCHECK(header);
   DCHECK(inputs);
   DCHECK(locations);
   DCHECK(strings);
 
   header->link_status = link_status_;
   header->num_attribs = attrib_infos_.size();
-  header->num_uniforms = num_uniforms_;
+  header->num_uniforms = uniform_infos_.size();
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
     inputs->size = info.size;
     inputs->type = info.type;
     inputs->location_offset = ComputeOffset(header, locations);
     inputs->name_offset = ComputeOffset(header, strings);
     inputs->name_length = info.name.size();
     *locations++ = info.location;
     memcpy(strings, info.name.c_str(), info.name.size());
     strings += info.name.size();
     ++inputs;
   }
 
-  for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
-    const UniformInfo& info = uniform_infos_[ii];
-    if (info.IsValid()) {
-      inputs->size = info.size;
-      inputs->type = info.type;
-      inputs->location_offset = ComputeOffset(header, locations);
-      inputs->name_offset = ComputeOffset(header, strings);
-      inputs->name_length = info.name.size();
-      DCHECK(static_cast<size_t>(info.size) == info.element_locations.size());
-      for (size_t jj = 0; jj < info.element_locations.size(); ++jj) {
-        if (info.element_locations[jj] == -1)
-          *locations++ = -1;
-        else
-          *locations++ = ProgramManager::MakeFakeLocation(ii, jj);
-      }
-      memcpy(strings, info.name.c_str(), info.name.size());
-      strings += info.name.size();
-      ++inputs;
+  for (const UniformInfo& info : uniform_infos_) {
+    inputs->size = info.size;
+    inputs->type = info.type;
+    inputs->location_offset = ComputeOffset(header, locations);
+    inputs->name_offset = ComputeOffset(header, strings);
+    inputs->name_length = info.name.size();
+    DCHECK(static_cast<size_t>(info.size) == info.element_locations.size());
+    for (size_t jj = 0; jj < info.element_locations.size(); ++jj) {
+      if (info.element_locations[jj] == -1)
+        *locations++ = -1;
+      else
+        *locations++ =
+            ProgramManager::MakeFakeLocation(info.fake_location_base, jj);
     }
+    memcpy(strings, info.name.c_str(), info.name.size());
+    strings += info.name.size();
+    ++inputs;
   }
+  // NOTE: currently we do not pass inactive uniform binding locations
+  // through the program info call.
 
   // NOTE: currently we do not pass fragment input infos through the program
   // info call, because they are not exposed through any getter function.
 
   DCHECK_EQ(ComputeOffset(header, strings), size);
 }
 
 bool Program::GetUniformBlocks(CommonDecoder::Bucket* bucket) const {
   // The data is packed into the bucket in the following order
   //   1) header
@@ skipping 433 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu