Use GpuPreferences to avoid directly accessing switches in gpu related code

gpu/command_buffer/service/program_manager_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 "gpu/command_buffer/service/program_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_version_info.h"
 
 using ::testing::_;
@@ skipping 22 matching lines @@
          static_cast<const uint8_t*>(start);
 }
 
 }  // namespace anonymous
 
 class ProgramManagerTestBase : public GpuServiceTest {
  protected:
   virtual void SetupProgramManager() {
     manager_.reset(new ProgramManager(nullptr, kMaxVaryingVectors,
                                       kMaxDualSourceDrawBuffers,
+                                      gpu_preferences_,
                                       feature_info_.get()));
   }
   void SetUpBase(const char* gl_version,
                  const char* gl_extensions,
-                 FeatureInfo* feature_info = NULL) {
+                 FeatureInfo* feature_info = nullptr) {
     GpuServiceTest::SetUpWithGLVersion(gl_version, gl_extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), gl_extensions, "", gl_version);
     if (!feature_info)
       feature_info = new FeatureInfo();
     feature_info->InitializeForTesting();
     feature_info_ = feature_info;
     SetupProgramManager();
   }
   void SetUp() override {
     // Parameters same as GpuServiceTest::SetUp
     SetUpBase("2.0", "GL_EXT_framebuffer_object");
   }
   void TearDown() override {
     manager_->Destroy(false);
     manager_.reset();
     feature_info_ = nullptr;
     GpuServiceTest::TearDown();
   }
 
   scoped_ptr<ProgramManager> manager_;
+  GpuPreferences gpu_preferences_;
   scoped_refptr<FeatureInfo> feature_info_;
 };
 
 class ProgramManagerTest : public ProgramManagerTestBase {};
 
 TEST_F(ProgramManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   // Check we can create program.
@@ skipping 1843 matching lines @@
       : cache_(new MockProgramCache()),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         program_(NULL) {
   }
 
  protected:
   void SetupProgramManager() override {
     manager_.reset(new ProgramManager(cache_.get(), kMaxVaryingVectors,
                                       kMaxDualSourceDrawBuffers,
+                                      gpu_preferences_,
                                       feature_info_.get()));
   }
 
   void SetUp() override {
     ProgramManagerTestBase::SetUp();
 
     vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
@@ skipping 196 matching lines @@
 class ProgramManagerWithPathRenderingTest
     : public ProgramManagerWithShaderTest,
       public testing::WithParamInterface<
           testing::tuple<const char*, const char*>> {
  protected:
   void SetUp() override {
     base::CommandLine command_line(*base::CommandLine::ForCurrentProcess());
     command_line.AppendSwitch(switches::kEnableGLPathRendering);
     FeatureInfo* feature_info = new FeatureInfo(command_line);
     SetUpBase(testing::get<0>(GetParam()), testing::get<1>(GetParam()),
-              feature_info);
+                              feature_info);
   }
   static const char* kFragmentInput1Name;
   static const char* kFragmentInput2Name;
   // Name that GL reports for input 2. Needed because input 2 is an
   // array.
   static const char* kFragmentInput2GLName;
   static const char* kFragmentInput3Name;
   static const char* kFragmentInput3GLName;
   static const GLint kFragmentInput1Size = 1;
   static const GLint kFragmentInput2Size = 3;
@@ skipping 219 matching lines @@
     ProgramManagerDualSourceBlendingES2Test,
     testing::Values(
         make_gl_ext_tuple("3.2",
                           "GL_ARB_draw_buffers GL_ARB_blend_func_extended "
                           "GL_ARB_program_interface_query"),
         make_gl_ext_tuple("opengl es 3.1",
                           "GL_EXT_draw_buffers GL_EXT_blend_func_extended")));
 
 }  // namespace gles2
 }  // namespace gpu