Hook up shader long variable name mapping with GPU command buffer port.

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 84 matching lines @@
   for (GLint ii = 0; ii < num_attribs; ++ii) {
     GLsizei length = 0;
     GLsizei size = 0;
     GLenum type = 0;
     glGetActiveAttrib(
         service_id_, ii, max_len, &length, &size, &type, name_buffer.get());
     DCHECK(max_len == 0 || length < max_len);
     DCHECK(length == 0 || name_buffer[length] == '\0');
     if (!IsInvalidPrefix(name_buffer.get(), length)) {
       std::string name;
-      GetCorrectedVariableInfo(false, name_buffer.get(), &name, &size, &type);
+      std::string original_name;
+      GetCorrectedVariableInfo(
+          false, name_buffer.get(), &name, &original_name, &size, &type);
       // TODO(gman): Should we check for error?
       GLint location = glGetAttribLocation(service_id_, name_buffer.get());
       if (location > max_location) {
         max_location = location;
       }
-      attrib_infos_.push_back(VertexAttribInfo(size, type, name, location));
-      max_attrib_name_length_ = std::max(max_attrib_name_length_, length);
+      attrib_infos_.push_back(
+          VertexAttribInfo(size, type, original_name, location));
+      max_attrib_name_length_ = std::max(
+          max_attrib_name_length_, static_cast<GLsizei>(original_name.size()));
     }
   }
 
   // Create attrib location to index map.
   attrib_location_to_index_map_.resize(max_location + 1);
   for (GLint ii = 0; ii <= max_location; ++ii) {
     attrib_location_to_index_map_[ii] = -1;
   }
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttribInfo& info = attrib_infos_[ii];
@@ skipping 12 matching lines @@
     GLsizei size = 0;
     GLenum type = 0;
     glGetActiveUniform(
         service_id_, ii, max_len, &length, &size, &type, name_buffer.get());
     DCHECK(max_len == 0 || length < max_len);
     DCHECK(length == 0 || name_buffer[length] == '\0');
     // TODO(gman): Should we check for error?
     if (!IsInvalidPrefix(name_buffer.get(), length)) {
       GLint location =  glGetUniformLocation(service_id_, name_buffer.get());
       std::string name;
-      GetCorrectedVariableInfo(true, name_buffer.get(), &name, &size, &type);
-      const UniformInfo* info = AddUniformInfo(size, type, location, name);
+      std::string original_name;
+      GetCorrectedVariableInfo(
+          true, name_buffer.get(), &name, &original_name, &size, &type);
+      const UniformInfo* info =
+          AddUniformInfo(size, type, location, name, original_name);
       for (size_t jj = 0; jj < info->element_locations.size(); ++jj) {
         if (info->element_locations[jj] > max_location) {
           max_location = info->element_locations[jj];
         }
       }
       if (info->IsSampler()) {
         sampler_indices_.push_back(index);
       }
       max_uniform_name_length_ =
           std::max(max_uniform_name_length_,
@@ skipping 100 matching lines @@
     }
   }
   return NULL;
 }
 
 // Note: This is only valid to call right after a program has been linked
 // successfully.
 void ProgramManager::ProgramInfo::GetCorrectedVariableInfo(
     bool use_uniforms,
     const std::string& name, std::string* corrected_name,
+    std::string* original_name,
     GLsizei* size, GLenum* type) const {
   DCHECK(corrected_name);
+  DCHECK(original_name);
   DCHECK(size);
   DCHECK(type);
   const char* kArraySpec = "[0]";
   for (int jj = 0; jj < 2; ++jj) {
     std::string test_name(name + ((jj == 1) ? kArraySpec : ""));
     for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
       ShaderManager::ShaderInfo* shader_info = attached_shaders_[ii].get();
       if (shader_info) {
         const ShaderManager::ShaderInfo::VariableInfo* variable_info =
             use_uniforms ? shader_info->GetUniformInfo(test_name) :
                            shader_info->GetAttribInfo(test_name);
         // Note: There is an assuption here that if an attrib is defined in more
         // than 1 attached shader their types and sizes match. Should we check
         // for that case?
         if (variable_info) {
           *corrected_name = test_name;
+          *original_name = variable_info->name;
           *type = variable_info->type;
           *size = variable_info->size;
           return;
         }
       }
     }
   }
   *corrected_name = name;
+  *original_name = name;
 }
 
 const ProgramManager::ProgramInfo::UniformInfo*
     ProgramManager::ProgramInfo::AddUniformInfo(
-        GLsizei size, GLenum type, GLint location, const std::string& name) {
+        GLsizei size, GLenum type, GLint location, const std::string& name,
+        const std::string& original_name) {
   const char* kArraySpec = "[0]";
-  uniform_infos_.push_back(UniformInfo(size, type, name));
+  uniform_infos_.push_back(UniformInfo(size, type, original_name));
   UniformInfo& info = uniform_infos_.back();
   info.element_locations.resize(size);
   info.element_locations[0] = location;
   DCHECK_GE(size, 0);
   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) {
-    // Sadly there is no way to tell if this is an array except if the name
-    // has an array string or the size > 1. That means an array of size 1 can
-    // be ambiguous.
-    //
-    // For now we just make sure that if the size is > 1 then the name must have
-    // an array spec.
-
     // 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);
@@ skipping 211 matching lines @@
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
 }  // namespace gles2
 }  // namespace gpu