Use GpuPreferences to avoid directly accessing switches in gpu related code

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"
 
@@ skipping 15 matching lines @@
     ShBuiltInResources resources;
     ShInitBuiltInResources(&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_,
-                                         SH_EMULATE_BUILT_IN_FUNCTIONS));
+                                         SH_EMULATE_BUILT_IN_FUNCTIONS,
+                                         false));
     ASSERT_TRUE(fragment_translator_->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC,
                                            &resources, shader_output_language_,
-                                           static_cast<ShCompileOptions>(0)));
+                                           static_cast<ShCompileOptions>(0),
+                                           false));
   }
   void TearDown() override {
     vertex_translator_ = NULL;
     fragment_translator_ = NULL;
   }
 
   scoped_refptr<ShaderTranslator> vertex_translator_;
   scoped_refptr<ShaderTranslator> fragment_translator_;
   ShShaderOutput shader_output_language_;
 };
@@ skipping 13 matching lines @@
     ShBuiltInResources resources;
     ShInitBuiltInResources(&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_,
-                                         SH_EMULATE_BUILT_IN_FUNCTIONS));
+                                         SH_EMULATE_BUILT_IN_FUNCTIONS, false));
     ASSERT_TRUE(fragment_translator_->Init(GL_FRAGMENT_SHADER, SH_GLES3_SPEC,
                                            &resources, shader_output_language_,
-                                           static_cast<ShCompileOptions>(0)));
+                                           static_cast<ShCompileOptions>(0),
+                                           false));
   }
   void TearDown() override {
     vertex_translator_ = NULL;
     fragment_translator_ = NULL;
   }
 
   scoped_refptr<ShaderTranslator> vertex_translator_;
   scoped_refptr<ShaderTranslator> fragment_translator_;
   ShShaderOutput shader_output_language_;
 };
@@ skipping 330 matching lines @@
 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);
 
   ASSERT_TRUE(translator_1->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
                                  SH_GLSL_150_CORE_OUTPUT,
-                                 SH_EMULATE_BUILT_IN_FUNCTIONS));
+                                 SH_EMULATE_BUILT_IN_FUNCTIONS,
+                                 false));
   ASSERT_TRUE(translator_2->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
                                  SH_GLSL_150_CORE_OUTPUT,
-                                 static_cast<ShCompileOptions>(0)));
+                                 static_cast<ShCompileOptions>(0),
+                                 false));
   resources.EXT_draw_buffers = 1;
   ASSERT_TRUE(translator_3->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
                                  SH_GLSL_150_CORE_OUTPUT,
-                                 SH_EMULATE_BUILT_IN_FUNCTIONS));
+                                 SH_EMULATE_BUILT_IN_FUNCTIONS,
+                                 false));
 
   std::string options_1(
       translator_1->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_2(
       translator_1->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_3(
       translator_2->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_4(
       translator_3->GetStringForOptionsThatWouldAffectCompilation());
 
@@ skipping 11 matching lines @@
 // 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);
   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));
+                                      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,
-                                        compile_options));
+                                        compile_options,
+                                        false));
 
   std::string translated_source;
   int shader_version;
   {
     const char* kShader =
         "attribute vec4 vPosition;\n"
         "void main() {\n"
         "}";
 
     EXPECT_TRUE(vertex_translator->Translate(
@@ skipping 42 matching lines @@
                                             "");
 
   scoped_refptr<ShaderTranslator> translator = new ShaderTranslator();
   ShBuiltInResources resources;
   ShInitBuiltInResources(&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));
+                               shader_output_language, compile_options, false));
 
   std::string translated_source;
   int shader_version;
   EXPECT_TRUE(translator->Translate(kShader, nullptr, &translated_source,
                                     &shader_version, nullptr, nullptr, nullptr,
                                     nullptr, nullptr, nullptr));
 
   std::string expected_version_directive = testing::get<1>(GetParam());
   if (expected_version_directive.empty()) {
     EXPECT_TRUE(translated_source.find("#version") == std::string::npos)
@@ skipping 62 matching lines @@
                         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