Use GpuPreferences to avoid directly accessing switches in gpu related code

content/common/gpu/gpu_command_buffer_stub.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 "content/common/gpu/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 198 matching lines @@
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
   } else {
     context_group_ = new gpu::gles2::ContextGroup(
-        mailbox_manager, new GpuCommandBufferMemoryTracker(
-                             channel, command_buffer_id_.GetUnsafeValue()),
+        channel_->gpu_channel_manager()->gpu_preferences(), mailbox_manager,
+        new GpuCommandBufferMemoryTracker(channel,
+                                          command_buffer_id_.GetUnsafeValue()),
         channel_->gpu_channel_manager()->shader_translator_cache(),
         channel_->gpu_channel_manager()->framebuffer_completeness_cache(), NULL,
         subscription_ref_set, pending_valuebuffer_state,
         attrib_parser.bind_generates_resource);
   }
 
 // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
 // performance regressions when enabling FCM.
 // http://crbug.com/180463
 #if defined(OS_MACOSX)
@@ skipping 383 matching lines @@
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   if (!decoder_->Initialize(surface_, context, offscreen_, initial_size_,
                             disallowed_features_, requested_attribs_)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     OnInitializeFailed(reply_message);
     return;
   }
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableGPUServiceLogging)) {
+  if (channel_->gpu_channel_manager()->
+      gpu_preferences().enable_gpu_service_logging) {
     decoder_->set_log_commands(true);
   }
 
   decoder_->GetLogger()->SetMsgCallback(
       base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
                  base::Unretained(this)));
   decoder_->SetShaderCacheCallback(
       base::Bind(&GpuCommandBufferStub::SendCachedShader,
                  base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
@@ skipping 486 matching lines @@
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   bool was_lost = state.error == gpu::error::kLostContext;
 
   if (was_lost) {
     bool was_lost_by_robustness =
         decoder_ && decoder_->WasContextLostByRobustnessExtension();
 
     // Work around issues with recovery by allowing a new GPU process to launch.
     if ((was_lost_by_robustness ||
          context_group_->feature_info()->workarounds().exit_on_context_lost) &&
-        !base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kSingleProcess) &&
-        !base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kInProcessGPU)) {
+        !channel_->gpu_channel_manager()->gpu_preferences().single_process &&
+        !channel_->gpu_channel_manager()->gpu_preferences().in_process_gpu) {
       LOG(ERROR) << "Exiting GPU process because some drivers cannot recover"
                  << " from problems.";
       // Signal the message loop to quit to shut down other threads
       // gracefully.
       base::MessageLoop::current()->QuitNow();
     }
 
     // Lose all other contexts if the reset was triggered by the robustness
     // extension instead of being synthetic.
     if (was_lost_by_robustness &&
@@ skipping 25 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content