Use GpuPreferences to avoid directly accessing switches in gpu related code

gpu/command_buffer/service/memory_program_cache.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/memory_program_cache.h"
 
 #include <stddef.h>
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/disk_cache_proto.pb.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
-#include "gpu/command_buffer/service/gpu_switches.h"
+#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "ui/gl/gl_bindings.h"
 
-namespace {
-
-size_t GetCacheSizeBytes() {
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kGpuProgramCacheSizeKb)) {
-    size_t size;
-    if (base::StringToSizeT(
-        command_line->GetSwitchValueNative(switches::kGpuProgramCacheSizeKb),
-        &size))
-      return size * 1024;
-  }
-  return gpu::kDefaultMaxProgramCacheMemoryBytes;
-}
-
-}  // anonymous namespace
-
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 void FillShaderVariableProto(
     ShaderVariableProto* proto, const sh::ShaderVariable& variable) {
   proto->set_type(variable.type);
   proto->set_precision(variable.precision);
   proto->set_name(variable.name);
@@ skipping 109 matching lines @@
   std::string shader;
   proto->SerializeToString(&shader);
 
   std::string key;
   base::Base64Encode(sha_string, &key);
   callback.Run(key, shader);
 }
 
 }  // namespace
 
-MemoryProgramCache::MemoryProgramCache()
-    : max_size_bytes_(GetCacheSizeBytes()),
+MemoryProgramCache::MemoryProgramCache(size_t max_cache_size_bytes,
+                                       bool disable_gpu_shader_disk_cache)
+    : max_size_bytes_(max_cache_size_bytes),
+      disable_gpu_shader_disk_cache_(disable_gpu_shader_disk_cache),
       curr_size_bytes_(0),
       store_(ProgramMRUCache::NO_AUTO_EVICT) {
 }
-
-MemoryProgramCache::MemoryProgramCache(const size_t max_cache_size_bytes)
-    : max_size_bytes_(max_cache_size_bytes),
-      curr_size_bytes_(0),
-      store_(ProgramMRUCache::NO_AUTO_EVICT) {
-}
 
 MemoryProgramCache::~MemoryProgramCache() {}
 
 void MemoryProgramCache::ClearBackend() {
   store_.Clear();
   DCHECK_EQ(0U, curr_size_bytes_);
 }
 
 ProgramCache::ProgramLoadResult MemoryProgramCache::LoadLinkedProgram(
     GLuint program,
@@ skipping 37 matching lines @@
   }
   shader_a->set_attrib_map(value->attrib_map_0());
   shader_a->set_uniform_map(value->uniform_map_0());
   shader_a->set_varying_map(value->varying_map_0());
   shader_a->set_output_variable_list(value->output_variable_list_0());
   shader_b->set_attrib_map(value->attrib_map_1());
   shader_b->set_uniform_map(value->uniform_map_1());
   shader_b->set_varying_map(value->varying_map_1());
   shader_b->set_output_variable_list(value->output_variable_list_1());
 
-  if (!shader_callback.is_null() &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableGpuShaderDiskCache)) {
+  if (!shader_callback.is_null() && !disable_gpu_shader_disk_cache_) {
     scoped_ptr<GpuProgramProto> proto(
         GpuProgramProto::default_instance().New());
     proto->set_sha(sha, kHashLength);
     proto->set_format(value->format());
     proto->set_program(value->data(), value->length());
 
     FillShaderProto(proto->mutable_vertex_shader(), a_sha, shader_a);
     FillShaderProto(proto->mutable_fragment_shader(), b_sha, shader_b);
     RunShaderCallback(shader_callback, proto.get(), sha_string);
   }
@@ skipping 48 matching lines @@
   // accessed.
   ProgramMRUCache::iterator existing = store_.Peek(sha_string);
   if(existing != store_.end())
     store_.Erase(existing);
 
   while (curr_size_bytes_ + length > max_size_bytes_) {
     DCHECK(!store_.empty());
     store_.Erase(store_.rbegin());
   }
 
-  if (!shader_callback.is_null() &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableGpuShaderDiskCache)) {
+  if (!shader_callback.is_null() && !disable_gpu_shader_disk_cache_) {
     scoped_ptr<GpuProgramProto> proto(
         GpuProgramProto::default_instance().New());
     proto->set_sha(sha, kHashLength);
     proto->set_format(format);
     proto->set_program(binary.get(), length);
 
     FillShaderProto(proto->mutable_vertex_shader(), a_sha, shader_a);
     FillShaderProto(proto->mutable_fragment_shader(), b_sha, shader_b);
     RunShaderCallback(shader_callback, proto.get(), sha_string);
   }
@@ skipping 112 matching lines @@
   program_cache_->LinkedProgramCacheSuccess(program_hash);
 }
 
 MemoryProgramCache::ProgramCacheValue::~ProgramCacheValue() {
   program_cache_->curr_size_bytes_ -= length_;
   program_cache_->Evict(program_hash_);
 }
 
 }  // namespace gles2
 }  // namespace gpu