command_buffer: Make inactive bound fragment inputs 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 260 matching lines @@
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
   uniform_locations_.clear();
   fragment_input_infos_.clear();
+  fragment_input_locations_.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;
   std::string hashed_name;
@@ skipping 365 matching lines @@
     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;
+  for (const auto& binding : bind_fragment_input_location_map_) {
+    if (binding.second < 0)
+      continue;
+    size_t client_location = static_cast<size_t>(binding.second);
+    if (fragment_input_locations_.size() <= client_location)
+      fragment_input_locations_.resize(client_location + 1);
+    fragment_input_locations_[client_location].SetInactive();
+  }
+
   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,
                           &max_len);
   DCHECK(max_len > 0);
 
   scoped_ptr<char[]> name_buffer(new char[max_len]);
 
   Shader* fragment_shader =
       attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
 
   const GLenum kQueryProperties[] = {GL_LOCATION, GL_TYPE, GL_ARRAY_SIZE};
 
+  std::vector<size_t> client_location_indices;
   for (GLint ii = 0; ii < num_fragment_inputs; ++ii) {
     GLsizei name_length = 0;
     glGetProgramResourceName(service_id_, GL_FRAGMENT_INPUT_NV, ii, max_len,
                              &name_length, name_buffer.get());
     DCHECK(name_length < max_len);
     DCHECK(name_length == 0 || name_buffer[name_length] == '\0');
     // A fragment shader can have gl_FragCoord, gl_FrontFacing or gl_PointCoord
     // built-ins as its input, as well as custom varyings. We are interested in
     // custom varyings, client is allowed to bind only them.
     if (ProgramManager::IsInvalidPrefix(name_buffer.get(), name_length))
@@ skipping 28 matching lines @@
       client_name = service_name;
       if (size <= 0)
         continue;
     }
 
     auto it = bind_fragment_input_location_map_.find(client_name);
     if (it != bind_fragment_input_location_map_.end() && it->second >= 0 &&
         query_results[0] >= 0) {
       size_t client_location = static_cast<size_t>(it->second);
       GLuint service_location = static_cast<GLuint>(query_results[0]);
-
-      if (fragment_input_infos_.size() <= client_location)
-        fragment_input_infos_.resize(client_location + 1);
-      DCHECK(!fragment_input_infos_[client_location].IsValid());
-      fragment_input_infos_[client_location] =
-          FragmentInputInfo(type, service_location);
+      fragment_input_infos_.push_back(
+          FragmentInputInfo(type, service_location));
+      client_location_indices.push_back(client_location);
     }
 
     if (size <= 1)
       continue;
     GLSLArrayName parsed_client_name(client_name);
     GLSLArrayName parsed_service_name(service_name);
     if (!parsed_client_name.IsArrayName() ||
         parsed_client_name.element_index() != 0 ||
         !parsed_service_name.IsArrayName() ||
         parsed_service_name.element_index() != 0) {
       NOTREACHED() << "GLSL array variable names should end with \"[0]\". "
                       "Likely driver or ANGLE error.";
       continue;
     }
 
     for (GLsizei jj = 1; jj < size; ++jj) {
       std::string array_spec(std::string("[") + base::IntToString(jj) + "]");
       std::string client_element_name =
           parsed_client_name.base_name() + array_spec;
 
       auto it = bind_fragment_input_location_map_.find(client_element_name);
       if (it != bind_fragment_input_location_map_.end() && it->second >= 0) {
         size_t client_location = static_cast<size_t>(it->second);
         std::string service_element_name =
             parsed_service_name.base_name() + array_spec;
         GLint service_location = glGetProgramResourceLocation(
             service_id_, GL_FRAGMENT_INPUT_NV, service_element_name.c_str());
         if (service_location >= 0) {
-          if (fragment_input_infos_.size() <= client_location)
-            fragment_input_infos_.resize(client_location + 1);
-          DCHECK(!fragment_input_infos_[client_location].IsValid());
-          fragment_input_infos_[client_location] =
-              FragmentInputInfo(type, static_cast<GLuint>(service_location));
+          fragment_input_infos_.push_back(
+              FragmentInputInfo(type, static_cast<GLuint>(service_location)));
+          client_location_indices.push_back(client_location);
         }
       }
     }
   }
+  for (size_t i = 0; i < client_location_indices.size(); ++i) {
+    size_t client_location = client_location_indices[i];
+    // Before linking, we already validated that no two statically used fragment
+    // inputs are bound to the same location.
+    DCHECK(!fragment_input_locations_[client_location].IsActive());
+    fragment_input_locations_[client_location].SetActive(
+        &fragment_input_infos_[i]);
+  }
 }
 
 void Program::ExecuteBindAttribLocationCalls() {
   for (const auto& key_value : bind_attrib_location_map_) {
     const std::string* mapped_name = GetAttribMappedName(key_value.first);
     if (mapped_name)
       glBindAttribLocation(service_id_, key_value.second, mapped_name->c_str());
   }
 }
 
@@ skipping 233 matching lines @@
   if (fake_location < 0)
     return nullptr;
   size_t location_index =
       GetUniformLocationIndexFromFakeLocation(fake_location);
   if (location_index >= uniform_locations_.size())
     return nullptr;
 
   if (!uniform_locations_[location_index].IsActive())
     return nullptr;
 
-  const UniformInfo* info = uniform_locations_[location_index].uniform();
+  const UniformInfo* info =
+      uniform_locations_[location_index].shader_variable();
   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 {
@@ skipping 40 matching lines @@
           shader->GetOriginalNameFromHashedName(hashed_name);
       if (original_name)
         return original_name;
     }
   }
   return nullptr;
 }
 
 const Program::FragmentInputInfo* Program::GetFragmentInputInfoByFakeLocation(
     GLint fake_location) const {
-  if (fake_location < 0 ||
-      static_cast<size_t>(fake_location) >= fragment_input_infos_.size())
+  if (fake_location < 0)
     return nullptr;
-  const FragmentInputInfo* info = &fragment_input_infos_[fake_location];
-  if (!info->IsValid())
+  size_t location_index = static_cast<size_t>(fake_location);
+  if (location_index >= fragment_input_locations_.size())
     return nullptr;
-  return info;
+  if (!fragment_input_locations_[location_index].IsActive())
+    return nullptr;
+  return fragment_input_locations_[location_index].shader_variable();
+}
+
+bool Program::IsInactiveFragmentInputLocationByFakeLocation(
+    GLint fake_location) const {
+  if (fake_location < 0)
+    return true;
+  size_t location_index = static_cast<size_t>(fake_location);
+  if (location_index >= fragment_input_locations_.size())
+    return false;
+  return fragment_input_locations_[location_index].IsInactive();
 }
 
 bool Program::SetUniformLocationBinding(
     const std::string& name, GLint location) {
   std::string short_name;
   int element_index = 0;
   if (!GetUniformNameSansElement(name, &element_index, &short_name) ||
       element_index != 0) {
     return false;
   }
@@ skipping 115 matching lines @@
     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();
+  UniformInfo* info = uniform_locations_[location_index].shader_variable();
 
   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;
       }
@@ skipping 885 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu