Remove NameMap from shader translator and shader/program managers

gpu/command_buffer/service/test_helper.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/test_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1105 matching lines @@
     ::gl::MockGLInterface* gl,
     Shader* shader,
     bool expected_valid,
     const std::string* const expected_log_info,
     const std::string* const expected_translated_source,
     const int* const expected_shader_version,
     const AttributeMap* const expected_attrib_map,
     const UniformMap* const expected_uniform_map,
     const VaryingMap* const expected_varying_map,
     const InterfaceBlockMap* const expected_interface_block_map,
-    const OutputVariableList* const expected_output_variable_list,
-    const NameMap* const expected_name_map) {
+    const OutputVariableList* const expected_output_variable_list) {
   const std::string empty_log_info;
   const std::string* log_info = (expected_log_info && !expected_valid) ?
       expected_log_info : &empty_log_info;
   const std::string empty_translated_source;
   const std::string* translated_source =
       (expected_translated_source && expected_valid) ?
           expected_translated_source : &empty_translated_source;
   int default_shader_version = 100;
   const int* shader_version = (expected_shader_version && expected_valid) ?
       expected_shader_version : &default_shader_version;
   const AttributeMap empty_attrib_map;
   const AttributeMap* attrib_map = (expected_attrib_map && expected_valid) ?
       expected_attrib_map : &empty_attrib_map;
   const UniformMap empty_uniform_map;
   const UniformMap* uniform_map = (expected_uniform_map && expected_valid) ?
       expected_uniform_map : &empty_uniform_map;
   const VaryingMap empty_varying_map;
   const VaryingMap* varying_map = (expected_varying_map && expected_valid) ?
       expected_varying_map : &empty_varying_map;
   const InterfaceBlockMap empty_interface_block_map;
   const InterfaceBlockMap* interface_block_map =
       (expected_interface_block_map && expected_valid) ?
       expected_interface_block_map : &empty_interface_block_map;
   const OutputVariableList empty_output_variable_list;
   const OutputVariableList* output_variable_list =
       (expected_output_variable_list && expected_valid)
           ? expected_output_variable_list
           : &empty_output_variable_list;
-  const NameMap empty_name_map;
-  const NameMap* name_map = (expected_name_map && expected_valid) ?
-      expected_name_map : &empty_name_map;
 
   MockShaderTranslator* mock_translator = new MockShaderTranslator;
   scoped_refptr<ShaderTranslatorInterface> translator(mock_translator);
   EXPECT_CALL(*mock_translator, Translate(_,
                                           NotNull(),   // log_info
                                           NotNull(),   // translated_source
                                           NotNull(),   // shader_version
                                           NotNull(),   // attrib_map
                                           NotNull(),   // uniform_map
                                           NotNull(),   // varying_map
                                           NotNull(),   // interface_block_map
-                                          NotNull(),   // output_variable_list
-                                          NotNull()))  // name_map
+                                          NotNull()))  // output_variable_list
       .WillOnce(DoAll(SetArgumentPointee<1>(*log_info),
                       SetArgumentPointee<2>(*translated_source),
                       SetArgumentPointee<3>(*shader_version),
                       SetArgumentPointee<4>(*attrib_map),
                       SetArgumentPointee<5>(*uniform_map),
                       SetArgumentPointee<6>(*varying_map),
                       SetArgumentPointee<7>(*interface_block_map),
                       SetArgumentPointee<8>(*output_variable_list),
-                      SetArgumentPointee<9>(*name_map), Return(expected_valid)))
+                      Return(expected_valid)))
       .RetiresOnSaturation();
   if (expected_valid) {
     EXPECT_CALL(*gl, ShaderSource(shader->service_id(), 1, _, NULL))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl, CompileShader(shader->service_id()))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl, GetShaderiv(shader->service_id(),
                                  GL_COMPILE_STATUS,
                                  NotNull()))  // status
         .WillOnce(SetArgumentPointee<2>(GL_TRUE))
         .RetiresOnSaturation();
   }
   shader->RequestCompile(translator, Shader::kGL);
   shader->DoCompile();
 }
 
 // static
 void TestHelper::SetShaderStates(::gl::MockGLInterface* gl,
                                  Shader* shader,
                                  bool valid) {
   SetShaderStates(gl, shader, valid, nullptr, nullptr, nullptr, nullptr,
-                  nullptr, nullptr, nullptr, nullptr, nullptr);
+                  nullptr, nullptr, nullptr, nullptr);
 }
 
 // static
 sh::Attribute TestHelper::ConstructAttribute(
     GLenum type, GLint array_size, GLenum precision,
     bool static_use, const std::string& name) {
   return ConstructShaderVariable<sh::Attribute>(
       type, array_size, precision, static_use, name);
 }
 
@@ skipping 19 matching lines @@
     GLenum precision,
     bool static_use,
     const std::string& name) {
   return ConstructShaderVariable<sh::OutputVariable>(
       type, array_size, precision, static_use, name);
 }
 
 }  // namespace gles2
 }  // namespace gpu