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 1537 matching lines @@
     if (shader) {
       const std::string* original_name =
           shader->GetOriginalNameFromHashedName(hashed_name);
       if (original_name)
         return original_name;
     }
   }
   return nullptr;
 }
 
+const sh::Varying* Program::GetVaryingInfo(
+    const std::string& hashed_name) const {
+  for (auto shader : attached_shaders_) {
+    if (shader) {
+      const sh::Varying* info = shader->GetVaryingInfo(hashed_name);
+      if (info)
+        return info;
+    }
+  }
+  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;

[Ken Russell (switch to Gerrit), 2017/05/03 22:52:48]

This change is well tested with the existing conformance tests, correct?

[Kai Ninomiya, 2017/05/03 23:02:34]

That the interface block name returned will be the correct one? Yes.

     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 109 matching lines @@
     GLsizei var_name_length = 0;
     GLenum var_type = 0;
     glGetTransformFeedbackVarying(
         program, ii, max_name_length,
         &var_name_length, &var_size, &var_type, &buffer[0]);
     varyings[ii].size = static_cast<uint32_t>(var_size);
     varyings[ii].type = static_cast<uint32_t>(var_type);
     varyings[ii].name_offset = static_cast<uint32_t>(size.ValueOrDefault(0));
     DCHECK_GT(max_name_length, var_name_length);
     names[ii] = std::string(&buffer[0], var_name_length);
     // TODO(zmo): optimize the name mapping lookup.

[Zhenyao Mo, 2017/05/03 23:24:12]

You can probably remove this comment because I don't think we will do any
further optimization on this.

-    const std::string* original_name = GetOriginalNameFromHashedName(names[ii]);
-    if (original_name)
-      names[ii] = *original_name;
+    const sh::Varying* varying = GetVaryingInfo(names[ii]);
+    if (varying)
+      names[ii] = varying->name;

[Ken Russell (switch to Gerrit), 2017/05/03 22:52:48]

Same question here.

[Kai Ninomiya, 2017/05/03 23:02:34]

Ditto.

     varyings[ii].name_length = names[ii].size() + 1;
     size += names[ii].size();
     size += 1;
   }
   if (!size.IsValid())
     return false;
   uint32_t total_size = size.ValueOrDefault(0);
   DCHECK_LE(header_size + entry_size, total_size);
   uint32_t data_size = total_size - header_size - entry_size;
 
@@ skipping 273 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