Use GpuPreferences to avoid directly accessing switches in gpu related code

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 10 matching lines @@
 #include "base/numerics/safe_conversions.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
+#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
-#include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 100 matching lines @@
   // delete the ThreadTaskRunnerHandle before the GPU thread's message loop,
   // and when the message loop is shutdown, it will recreate
   // ThreadTaskRunnerHandle, which will re-add a new task to the, AtExitManager,
   // which causes a deadlock because it's already locked.
   base::ThreadTaskRunnerHandle::IsSet();
   return g_default_service.Get().gpu_thread;
 }
 
 }  // anonyous namespace
 
-InProcessCommandBuffer::Service::Service() {}
+InProcessCommandBuffer::Service::Service(const GpuPreferences& gpu_preferences)
+    : gpu_preferences_(gpu_preferences) {}
 
 InProcessCommandBuffer::Service::~Service() {}
 
+const gpu::GpuPreferences&
+InProcessCommandBuffer::Service::gpu_preferences() {
+  return gpu_preferences_;
+}
+
 scoped_refptr<gfx::GLShareGroup>
 InProcessCommandBuffer::Service::share_group() {
   if (!share_group_.get())
     share_group_ = new gfx::GLShareGroup;
   return share_group_;
 }
 
 scoped_refptr<gles2::MailboxManager>
 InProcessCommandBuffer::Service::mailbox_manager() {
   if (!mailbox_manager_.get()) {
-    mailbox_manager_ = gles2::MailboxManager::Create();
+    mailbox_manager_ = gles2::MailboxManager::Create(gpu_preferences());
   }
   return mailbox_manager_;
 }
 
 scoped_refptr<gles2::SubscriptionRefSet>
 InProcessCommandBuffer::Service::subscription_ref_set() {
   if (!subscription_ref_set_.get()) {
     subscription_ref_set_ = new gles2::SubscriptionRefSet();
   }
   return subscription_ref_set_;
 }
 
 scoped_refptr<ValueStateMap>
 InProcessCommandBuffer::Service::pending_valuebuffer_state() {
   if (!pending_valuebuffer_state_.get()) {
     pending_valuebuffer_state_ = new ValueStateMap();
   }
   return pending_valuebuffer_state_;
 }
 
 gpu::gles2::ProgramCache* InProcessCommandBuffer::Service::program_cache() {
   if (!program_cache_.get() &&
       (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary ||
        gfx::g_driver_gl.ext.b_GL_OES_get_program_binary) &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableGpuProgramCache)) {
-    program_cache_.reset(new gpu::gles2::MemoryProgramCache());
+      !gpu_preferences().disable_gpu_program_cache) {
+    program_cache_.reset(new gpu::gles2::MemoryProgramCache(
+          gpu_preferences().gpu_program_cache_size,
+          gpu_preferences().disable_gpu_shader_disk_cache));
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : command_buffer_id_(
           CommandBufferId::FromUnsafeValue(g_next_command_buffer_id.GetNext())),
       context_lost_(false),
       delayed_work_pending_(false),
@@ skipping 124 matching lines @@
                         : service_->share_group();
 
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset(new StreamTextureManagerInProcess);
 #endif
 
   bool bind_generates_resource = false;
   decoder_.reset(gles2::GLES2Decoder::Create(
       params.context_group
           ? params.context_group->decoder_->GetContextGroup()
-          : new gles2::ContextGroup(service_->mailbox_manager(), NULL,
+          : new gles2::ContextGroup(service_->gpu_preferences(),
+                                    service_->mailbox_manager(), NULL,
                                     service_->shader_translator_cache(),
                                     service_->framebuffer_completeness_cache(),
                                     NULL, service_->subscription_ref_set(),
                                     service_->pending_valuebuffer_state(),
                                     bind_generates_resource)));
 
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
@@ skipping 682 matching lines @@
       base::Bind(&InProcessCommandBuffer::CreateStreamTextureOnGpuThread,
                  base::Unretained(this), texture_id);
   QueueTask(
       base::Bind(&RunTaskWithResult<uint32_t>, task, &stream_id, &completion));
   completion.Wait();
   return stream_id;
 }
 #endif
 
 GpuInProcessThread::GpuInProcessThread(SyncPointManager* sync_point_manager)
-    : base::Thread("GpuThread"), sync_point_manager_(sync_point_manager) {
+    : base::Thread("GpuThread"), Service(gpu_preferences_),
+      sync_point_manager_(sync_point_manager) {
   Start();
 }
 
 GpuInProcessThread::~GpuInProcessThread() {
   Stop();
 }
 
 void GpuInProcessThread::AddRef() const {
   base::RefCountedThreadSafe<GpuInProcessThread>::AddRef();
 }
@@ skipping 10 matching lines @@
   task_runner()->PostDelayedTask(FROM_HERE, callback,
                                  base::TimeDelta::FromMilliseconds(2));
 }
 
 bool GpuInProcessThread::UseVirtualizedGLContexts() {
   return false;
 }
 
 scoped_refptr<gles2::ShaderTranslatorCache>
 GpuInProcessThread::shader_translator_cache() {
-  if (!shader_translator_cache_.get())
-    shader_translator_cache_ = new gpu::gles2::ShaderTranslatorCache;
+  if (!shader_translator_cache_.get()) {
+    shader_translator_cache_ =
+        new gpu::gles2::ShaderTranslatorCache(gpu_preferences());
+  }
   return shader_translator_cache_;
 }
 
 scoped_refptr<gles2::FramebufferCompletenessCache>
 GpuInProcessThread::framebuffer_completeness_cache() {
   if (!framebuffer_completeness_cache_.get())
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu