gpu: Use the sh-scoped translator methods.

gpu/command_buffer/service/shader_translator_unittest.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 <GLES2/gl2.h>
 
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 namespace gles2 {
 
 class ShaderTranslatorTest : public testing::Test {
  public:
   ShaderTranslatorTest() {
     shader_output_language_ =
         ShaderTranslator::GetShaderOutputLanguageForContext(
             gl::GLVersionInfo("2.0", "", ""));
   }
 
   ~ShaderTranslatorTest() override {}
 
  protected:
   void SetUp() override {
     ShBuiltInResources resources;
-    ShInitBuiltInResources(&resources);
+    sh::InitBuiltInResources(&resources);
     resources.MaxExpressionComplexity = 32;
     resources.MaxCallStackDepth = 32;
 
     vertex_translator_ = new ShaderTranslator();
     fragment_translator_ = new ShaderTranslator();
 
     ASSERT_TRUE(vertex_translator_->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC,
                                          &resources, shader_output_language_,
                                          static_cast<ShCompileOptions>(0),
                                          false));
@@ skipping 18 matching lines @@
     shader_output_language_ =
         ShaderTranslator::GetShaderOutputLanguageForContext(
             gl::GLVersionInfo("3.0", "", ""));
   }
 
   ~ES3ShaderTranslatorTest() override {}
 
  protected:
   void SetUp() override {
     ShBuiltInResources resources;
-    ShInitBuiltInResources(&resources);
+    sh::InitBuiltInResources(&resources);
     resources.MaxExpressionComplexity = 32;
     resources.MaxCallStackDepth = 32;
 
     vertex_translator_ = new ShaderTranslator();
     fragment_translator_ = new ShaderTranslator();
 
     ASSERT_TRUE(vertex_translator_->Init(GL_VERTEX_SHADER, SH_GLES3_SPEC,
                                          &resources, shader_output_language_,
                                          static_cast<ShCompileOptions>(0),
                                          false));
@@ skipping 340 matching lines @@
   }
   EXPECT_TRUE(iter != interface_block_map.end());
 }
 
 TEST_F(ShaderTranslatorTest, OptionsString) {
   scoped_refptr<ShaderTranslator> translator_1 = new ShaderTranslator();
   scoped_refptr<ShaderTranslator> translator_2 = new ShaderTranslator();
   scoped_refptr<ShaderTranslator> translator_3 = new ShaderTranslator();
 
   ShBuiltInResources resources;
-  ShInitBuiltInResources(&resources);
+  sh::InitBuiltInResources(&resources);
 
   ASSERT_TRUE(translator_1->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
                                  SH_GLSL_150_CORE_OUTPUT,
                                  static_cast<ShCompileOptions>(0),
                                  false));
   ASSERT_TRUE(translator_2->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
                                  SH_GLSL_150_CORE_OUTPUT,
                                  SH_INIT_OUTPUT_VARIABLES,
                                  false));
   resources.EXT_draw_buffers = 1;
@@ skipping 19 matching lines @@
 
 class ShaderTranslatorOutputVersionTest
     : public testing::TestWithParam<testing::tuple<const char*, const char*>> {
 };
 
 // crbug.com/540543
 // https://bugs.chromium.org/p/angleproject/issues/detail?id=1276
 // https://bugs.chromium.org/p/angleproject/issues/detail?id=1277
 TEST_F(ShaderTranslatorOutputVersionTest, DISABLED_CompatibilityOutput) {
   ShBuiltInResources resources;
-  ShInitBuiltInResources(&resources);
+  sh::InitBuiltInResources(&resources);
   ShCompileOptions compile_options = SH_OBJECT_CODE;
   ShShaderOutput shader_output_language = SH_GLSL_COMPATIBILITY_OUTPUT;
   scoped_refptr<ShaderTranslator> vertex_translator = new ShaderTranslator();
   ASSERT_TRUE(vertex_translator->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC,
                                       &resources, shader_output_language,
                                       compile_options,
                                       false));
   scoped_refptr<ShaderTranslator> fragment_translator = new ShaderTranslator();
   ASSERT_TRUE(fragment_translator->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC,
                                         &resources, shader_output_language,
@@ skipping 47 matching lines @@
   const char* kShader =
       "attribute vec4 vPosition;\n"
       "void main() {\n"
       "  gl_Position = vPosition;\n"
       "}";
 
   gl::GLVersionInfo output_context_version(testing::get<0>(GetParam()), "", "");
 
   scoped_refptr<ShaderTranslator> translator = new ShaderTranslator();
   ShBuiltInResources resources;
-  ShInitBuiltInResources(&resources);
+  sh::InitBuiltInResources(&resources);
   ShCompileOptions compile_options = SH_OBJECT_CODE;
   ShShaderOutput shader_output_language =
       ShaderTranslator::GetShaderOutputLanguageForContext(
           output_context_version);
   ASSERT_TRUE(translator->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
                                shader_output_language, compile_options, false));
 
   std::string translated_source;
   int shader_version;
   EXPECT_TRUE(translator->Translate(kShader, nullptr, &translated_source,
@@ skipping 67 matching lines @@
 INSTANTIATE_TEST_CASE_P(OpenGLESContexts,
                         ShaderTranslatorOutputVersionTest,
                         testing::Values(make_gl_glsl_tuple("opengl es 2.0", ""),
                                         make_gl_glsl_tuple("opengl es 3.0", ""),
                                         make_gl_glsl_tuple("opengl es 3.1", ""),
                                         make_gl_glsl_tuple("opengl es 3.2",
                                                            "")));
 
 }  // namespace gles2
 }  // namespace gpu