Remove NameMap from shader translator and shader/program managers

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1526 matching lines @@
           shader->GetUniformMappedName(original_name);
       if (mapped_name)
         return mapped_name;
     }
   }
   return nullptr;
 }
 
 const std::string* Program::GetOriginalNameFromHashedName(
     const std::string& hashed_name) const {
+  // TODO(kainino): Might not work on cache load, since name_map doesn't seem
+  // to be loaded from cache. In GetUniformBlocks, GetInterfaceBlockInfo is
+  // used instead.

[Ken Russell (switch to Gerrit), 2017/05/01 23:02:30]

Please refer to crbug.com/716018 at the end of this comment. Thanks.

[Kai Ninomiya, 2017/05/02 00:06:13]

Acknowledged.

   for (auto shader : attached_shaders_) {
     if (shader) {
       const std::string* original_name =
           shader->GetOriginalNameFromHashedName(hashed_name);
       if (original_name)
         return original_name;
     }
   }
   return nullptr;
 }
 
+const sh::InterfaceBlock* Program::GetInterfaceBlockInfo(
+    const std::string& hashed_name) const {
+  for (auto shader : attached_shaders_) {
+    if (shader) {
+      const sh::InterfaceBlock* info =
+          shader->GetInterfaceBlockInfo(hashed_name);
+      if (info)
+        return info;
+    }
+  }
+  return nullptr;
+}
+
 const Program::FragmentInputInfo* Program::GetFragmentInputInfoByFakeLocation(
     GLint fake_location) const {
   if (fake_location < 0)
     return nullptr;
   size_t location_index = static_cast<size_t>(fake_location);
   if (location_index >= fragment_input_locations_.size())
     return nullptr;
   if (!fragment_input_locations_[location_index].IsActive())
     return nullptr;
   return fragment_input_locations_[location_index].shader_variable();
@@ skipping 656 matching lines @@
         program, ii, GL_UNIFORM_BLOCK_NAME_LENGTH, &param);
     DCHECK_GE(max_name_length, param);
     memset(&buffer[0], 0, param);
     length = 0;
     glGetActiveUniformBlockName(
         program, ii, static_cast<GLsizei>(param), &length, &buffer[0]);
     DCHECK_EQ(param, length + 1);
     names[ii] = std::string(&buffer[0], length);
     // TODO(zmo): optimize the name mapping lookup.
     size_t pos = names[ii].find_first_of('[');
-    const std::string* original_name;
+    const sh::InterfaceBlock* interface_block = nullptr;
     std::string array_index_str = "";
     if (pos != std::string::npos) {
-      original_name = GetOriginalNameFromHashedName(names[ii].substr(0, pos));
+      interface_block = GetInterfaceBlockInfo(names[ii].substr(0, pos));
       array_index_str = names[ii].substr(pos);
     } else {
-      original_name = GetOriginalNameFromHashedName(names[ii]);
+      interface_block = GetInterfaceBlockInfo(names[ii]);
     }
-    if (original_name)
-      names[ii] = *original_name + array_index_str;
+    if (interface_block)
+      names[ii] = interface_block->name + array_index_str;
     blocks[ii].name_length = names[ii].size() + 1;
     size += blocks[ii].name_length;
 
     param = 0;
     glGetActiveUniformBlockiv(
         program, ii, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &param);
     blocks[ii].active_uniforms = static_cast<uint32_t>(param);
     blocks[ii].active_uniform_offset = size.ValueOrDefault(0);
     base::CheckedNumeric<uint32_t> indices_size = blocks[ii].active_uniforms;
     indices_size *= sizeof(uint32_t);
@@ skipping 406 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu