Merge gpu_switching_list into gpu_driver_bug_list.

BUG=314901
TEST=gpu_unittests
R=bajones@chromium.org, kbr@chromium.org, piman@chromium.org, sievers@chromium.org

Review URL: https://codereview.chromium.org/57633007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@233143 0039d316-1c4b-4281-b951-d872f2087c98

20 files changed, 159 insertions, 423 deletions

diff --git a/content/browser/gpu/compositor_util.cc b/content/browser/gpu/compositor_util.cc
index 85240fa..916fcde 100644
--- a/content/browser/gpu/compositor_util.cc
+++ b/content/browser/gpu/compositor_util.cc
@@ -366,25 +366,6 @@ base::Value* GetFeatureStatus() {
     feature_status_dict->SetString(
         gpu_feature_info.name.c_str(), status.c_str());
   }
-  gpu::GpuSwitchingOption gpu_switching_option =
-      manager->GetGpuSwitchingOption();
-  if (gpu_switching_option != gpu::GPU_SWITCHING_OPTION_UNKNOWN) {
-    std::string gpu_switching;
-    switch (gpu_switching_option) {
-    case gpu::GPU_SWITCHING_OPTION_AUTOMATIC:
-        gpu_switching = "gpu_switching_automatic";
-        break;
-    case gpu::GPU_SWITCHING_OPTION_FORCE_DISCRETE:
-        gpu_switching = "gpu_switching_force_discrete";
-        break;
-    case gpu::GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
-        gpu_switching = "gpu_switching_force_integrated";
-        break;
-      default:
-        break;
-    }
-    feature_status_dict->SetString("gpu_switching", gpu_switching.c_str());
-  }
   return feature_status_dict;
 }
 
diff --git a/content/browser/gpu/gpu_data_manager_impl.cc b/content/browser/gpu/gpu_data_manager_impl.cc
index 3109657..18b1a71 100644
--- a/content/browser/gpu/gpu_data_manager_impl.cc
+++ b/content/browser/gpu/gpu_data_manager_impl.cc
@@ -162,11 +162,6 @@ void GpuDataManagerImpl::UpdateRendererWebPrefs(
   private_->UpdateRendererWebPrefs(prefs);
 }
 
-gpu::GpuSwitchingOption GpuDataManagerImpl::GetGpuSwitchingOption() const {
-  base::AutoLock auto_lock(lock_);
-  return private_->GetGpuSwitchingOption();
-}
-
 std::string GpuDataManagerImpl::GetBlacklistVersion() const {
   base::AutoLock auto_lock(lock_);
   return private_->GetBlacklistVersion();
diff --git a/content/browser/gpu/gpu_data_manager_impl.h b/content/browser/gpu/gpu_data_manager_impl.h
index a1ea201..7fb75a4 100644
--- a/content/browser/gpu/gpu_data_manager_impl.h
+++ b/content/browser/gpu/gpu_data_manager_impl.h
@@ -21,7 +21,6 @@
 #include "content/public/common/gpu_memory_stats.h"
 #include "content/public/common/three_d_api_types.h"
 #include "gpu/config/gpu_info.h"
-#include "gpu/config/gpu_switching_option.h"
 
 class CommandLine;
 class GURL;
@@ -109,8 +108,6 @@ class CONTENT_EXPORT GpuDataManagerImpl
   // Update WebPreferences for renderer based on blacklisting decisions.
   void UpdateRendererWebPrefs(WebPreferences* prefs) const;
 
-  gpu::GpuSwitchingOption GetGpuSwitchingOption() const;
-
   std::string GetBlacklistVersion() const;
   std::string GetDriverBugListVersion() const;
 
diff --git a/content/browser/gpu/gpu_data_manager_impl_private.cc b/content/browser/gpu/gpu_data_manager_impl_private.cc
index 315ba66..8ce3104 100644
--- a/content/browser/gpu/gpu_data_manager_impl_private.cc
+++ b/content/browser/gpu/gpu_data_manager_impl_private.cc
@@ -294,6 +294,21 @@ void ApplyAndroidWorkarounds(const gpu::GPUInfo& gpu_info,
 }
 #endif  // OS_ANDROID
 
+// Overwrite force gpu workaround if a commandline switch exists.
+void AdjustGpuSwitchingOption(std::set<int>* workarounds) {
+  DCHECK(workarounds);
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  std::string option = command_line.GetSwitchValueASCII(
+      switches::kGpuSwitching);
+  if (option == switches::kGpuSwitchingOptionNameForceDiscrete) {
+    workarounds->erase(gpu::FORCE_INTEGRATED_GPU);
+    workarounds->insert(gpu::FORCE_DISCRETE_GPU);
+  } else if (option == switches::kGpuSwitchingOptionNameForceIntegrated) {
+    workarounds->erase(gpu::FORCE_DISCRETE_GPU);
+    workarounds->insert(gpu::FORCE_INTEGRATED_GPU);
+  }
+}
+
 // Block all domains' use of 3D APIs for this many milliseconds if
 // approaching a threshold where system stability might be compromised.
 const int64 kBlockAllDomainsMs = 10000;
@@ -318,7 +333,7 @@ void GpuDataManagerImplPrivate::InitializeForTesting(
   // Prevent all further initialization.
   finalized_ = true;
 
-  InitializeImpl(gpu_blacklist_json, std::string(), std::string(), gpu_info);
+  InitializeImpl(gpu_blacklist_json, std::string(), gpu_info);
 }
 
 bool GpuDataManagerImplPrivate::IsFeatureBlacklisted(int feature) const {
@@ -565,18 +580,15 @@ void GpuDataManagerImplPrivate::Initialize() {
 #endif
 
   std::string gpu_blacklist_string;
-  std::string gpu_switching_list_string;
   std::string gpu_driver_bug_list_string;
   if (!command_line->HasSwitch(switches::kIgnoreGpuBlacklist) &&
       !command_line->HasSwitch(switches::kUseGpuInTests)) {
     gpu_blacklist_string = gpu::kSoftwareRenderingListJson;
-    gpu_switching_list_string = gpu::kGpuSwitchingListJson;
   }
   if (!command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
     gpu_driver_bug_list_string = gpu::kGpuDriverBugListJson;
   }
   InitializeImpl(gpu_blacklist_string,
-                 gpu_switching_list_string,
                  gpu_driver_bug_list_string,
                  gpu_info);
 }
@@ -600,22 +612,11 @@ void GpuDataManagerImplPrivate::UpdateGpuInfo(const gpu::GPUInfo& gpu_info) {
 
     UpdateBlacklistedFeatures(features);
   }
-  if (gpu_switching_list_) {
-    std::set<int> option = gpu_switching_list_->MakeDecision(
-        gpu::GpuControlList::kOsAny, std::string(), gpu_info_);
-    if (option.size() == 1) {
-      // Blacklist decision should not overwrite commandline switch from users.
-      CommandLine* command_line = CommandLine::ForCurrentProcess();
-      if (!command_line->HasSwitch(switches::kGpuSwitching)) {
-        gpu_switching_ = static_cast<gpu::GpuSwitchingOption>(
-            *(option.begin()));
-      }
-    }
-  }
   if (gpu_driver_bug_list_) {
     gpu_driver_bugs_ = gpu_driver_bug_list_->MakeDecision(
         gpu::GpuControlList::kOsAny, std::string(), gpu_info_);
   }
+  AdjustGpuSwitchingOption(&gpu_driver_bugs_);
 
   // We have to update GpuFeatureType before notify all the observers.
   NotifyGpuInfoUpdate();
@@ -698,24 +699,10 @@ void GpuDataManagerImplPrivate::AppendGpuCommandLine(
   } else if (!use_gl.empty()) {
     command_line->AppendSwitchASCII(switches::kUseGL, use_gl);
   }
-  if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
+  if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus())
     command_line->AppendSwitchASCII(switches::kSupportsDualGpus, "true");
-    switch (gpu_switching_) {
-      case gpu::GPU_SWITCHING_OPTION_FORCE_DISCRETE:
-        command_line->AppendSwitchASCII(switches::kGpuSwitching,
-            switches::kGpuSwitchingOptionNameForceDiscrete);
-        break;
-      case gpu::GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
-        command_line->AppendSwitchASCII(switches::kGpuSwitching,
-            switches::kGpuSwitchingOptionNameForceIntegrated);
-        break;
-      case gpu::GPU_SWITCHING_OPTION_AUTOMATIC:
-      case gpu::GPU_SWITCHING_OPTION_UNKNOWN:
-        break;
-    }
-  } else {
+  else
     command_line->AppendSwitchASCII(switches::kSupportsDualGpus, "false");
-  }
 
   if (!swiftshader_path.empty()) {
     command_line->AppendSwitchPath(switches::kSwiftShaderPath,
@@ -835,13 +822,6 @@ void GpuDataManagerImplPrivate::UpdateRendererWebPrefs(
 #endif
 }
 
-gpu::GpuSwitchingOption
-GpuDataManagerImplPrivate::GetGpuSwitchingOption() const {
-  if (!ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus())
-    return gpu::GPU_SWITCHING_OPTION_UNKNOWN;
-  return gpu_switching_;
-}
-
 void GpuDataManagerImplPrivate::DisableHardwareAcceleration() {
   card_blacklisted_ = true;
 
@@ -977,7 +957,6 @@ GpuDataManagerImplPrivate* GpuDataManagerImplPrivate::Create(
 GpuDataManagerImplPrivate::GpuDataManagerImplPrivate(
     GpuDataManagerImpl* owner)
     : complete_gpu_info_already_requested_(false),
-      gpu_switching_(gpu::GPU_SWITCHING_OPTION_AUTOMATIC),
       observer_list_(new GpuDataManagerObserverList),
       use_swiftshader_(false),
       card_blacklisted_(false),
@@ -1003,14 +982,6 @@ GpuDataManagerImplPrivate::GpuDataManagerImplPrivate(
 #if defined(USE_AURA) && !defined(OS_CHROMEOS)
   use_software_compositor_ = true;
 #endif
-  if (command_line->HasSwitch(switches::kGpuSwitching)) {
-    std::string option_string = command_line->GetSwitchValueASCII(
-        switches::kGpuSwitching);
-    gpu::GpuSwitchingOption option =
-        gpu::StringToGpuSwitchingOption(option_string);
-    if (option != gpu::GPU_SWITCHING_OPTION_UNKNOWN)
-      gpu_switching_ = option;
-  }
 
 #if defined(OS_MACOSX)
   CGGetActiveDisplayList (0, NULL, &display_count_);
@@ -1031,7 +1002,6 @@ GpuDataManagerImplPrivate::~GpuDataManagerImplPrivate() {
 
 void GpuDataManagerImplPrivate::InitializeImpl(
     const std::string& gpu_blacklist_json,
-    const std::string& gpu_switching_list_json,
     const std::string& gpu_driver_bug_list_json,
     const gpu::GPUInfo& gpu_info) {
   std::string browser_version_string = ProcessVersionString(
@@ -1051,15 +1021,6 @@ void GpuDataManagerImplPrivate::InitializeImpl(
         gpu::GpuControlList::kCurrentOsOnly);
     DCHECK(success);
   }
-  if (!gpu_switching_list_json.empty()) {
-    gpu_switching_list_.reset(gpu::GpuSwitchingList::Create());
-    if (log_gpu_control_list_decisions)
-      gpu_switching_list_->enable_control_list_logging("gpu_switching_list");
-    bool success = gpu_switching_list_->LoadList(
-        browser_version_string, gpu_switching_list_json,
-        gpu::GpuControlList::kCurrentOsOnly);
-    DCHECK(success);
-  }
   if (!gpu_driver_bug_list_json.empty()) {
     gpu_driver_bug_list_.reset(gpu::GpuDriverBugList::Create());
     if (log_gpu_control_list_decisions)
@@ -1121,17 +1082,10 @@ void GpuDataManagerImplPrivate::UpdateGpuSwitchingManager(
       gpu_info.secondary_gpus.size() + 1);
 
   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
-    switch (gpu_switching_) {
-      case gpu::GPU_SWITCHING_OPTION_FORCE_DISCRETE:
-        ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
-        break;
-      case gpu::GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
-        ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
-        break;
-      case gpu::GPU_SWITCHING_OPTION_AUTOMATIC:
-      case gpu::GPU_SWITCHING_OPTION_UNKNOWN:
-        break;
-    }
+    if (gpu_driver_bugs_.count(gpu::FORCE_DISCRETE_GPU) == 1)
+      ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
+    else if (gpu_driver_bugs_.count(gpu::FORCE_INTEGRATED_GPU) == 1)
+      ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
   }
 }
 
diff --git a/content/browser/gpu/gpu_data_manager_impl_private.h b/content/browser/gpu/gpu_data_manager_impl_private.h
index ed1b39c..056920b 100644
--- a/content/browser/gpu/gpu_data_manager_impl_private.h
+++ b/content/browser/gpu/gpu_data_manager_impl_private.h
@@ -16,7 +16,6 @@
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "gpu/config/gpu_blacklist.h"
 #include "gpu/config/gpu_driver_bug_list.h"
-#include "gpu/config/gpu_switching_list.h"
 
 namespace content {
 
@@ -65,8 +64,6 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
 
   void UpdateRendererWebPrefs(WebPreferences* prefs) const;
 
-  gpu::GpuSwitchingOption GetGpuSwitchingOption() const;
-
   std::string GetBlacklistVersion() const;
   std::string GetDriverBugListVersion() const;
 
@@ -169,7 +166,6 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   explicit GpuDataManagerImplPrivate(GpuDataManagerImpl* owner);
 
   void InitializeImpl(const std::string& gpu_blacklist_json,
-                      const std::string& gpu_switching_list_json,
                       const std::string& gpu_driver_bug_list_json,
                       const gpu::GPUInfo& gpu_info);
 
@@ -206,14 +202,11 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   std::set<int> blacklisted_features_;
   std::set<int> preliminary_blacklisted_features_;
 
-  gpu::GpuSwitchingOption gpu_switching_;
-
   std::set<int> gpu_driver_bugs_;
 
   gpu::GPUInfo gpu_info_;
 
   scoped_ptr<gpu::GpuBlacklist> gpu_blacklist_;
-  scoped_ptr<gpu::GpuSwitchingList> gpu_switching_list_;
   scoped_ptr<gpu::GpuDriverBugList> gpu_driver_bug_list_;
 
   const scoped_refptr<GpuDataManagerObserverList> observer_list_;
diff --git a/content/gpu/gpu_main.cc b/content/gpu/gpu_main.cc
index c2ffd63..0bed8c2 100644
--- a/content/gpu/gpu_main.cc
+++ b/content/gpu/gpu_main.cc
@@ -29,7 +29,9 @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
 #include "crypto/hmac.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_info_collector.h"
+#include "gpu/config/gpu_util.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
@@ -115,13 +117,14 @@ int GpuMain(const MainFunctionParams& parameters) {
     logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
   }
 
-  if (command_line.HasSwitch(switches::kSupportsDualGpus) &&
-      command_line.HasSwitch(switches::kGpuSwitching)) {
-    std::string option = command_line.GetSwitchValueASCII(
-        switches::kGpuSwitching);
-    if (option == switches::kGpuSwitchingOptionNameForceDiscrete)
+  if (command_line.HasSwitch(switches::kSupportsDualGpus)) {
+    std::string types = command_line.GetSwitchValueASCII(
+        switches::kGpuDriverBugWorkarounds);
+    std::set<int> workarounds;
+    gpu::StringToFeatureSet(types, &workarounds);
+    if (workarounds.count(gpu::FORCE_DISCRETE_GPU) == 1)
       ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
-    else if (option == switches::kGpuSwitchingOptionNameForceIntegrated)
+    else if (workarounds.count(gpu::FORCE_INTEGRATED_GPU) == 1)
       ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
   }
 
diff --git a/gpu/config/gpu_driver_bug_list_json.cc b/gpu/config/gpu_driver_bug_list_json.cc
index 49d34f1..44d482a 100644
--- a/gpu/config/gpu_driver_bug_list_json.cc
+++ b/gpu/config/gpu_driver_bug_list_json.cc
@@ -19,7 +19,7 @@ const char kGpuDriverBugListJson[] = LONG_STRING_CONST(
 {
   "name": "gpu driver bug list",
   // Please update the version number whenever you change this file.
-  "version": "2.26",
+  "version": "3.0",
   "entries": [
     {
       "id": 1,
@@ -634,6 +634,35 @@ const char kGpuDriverBugListJson[] = LONG_STRING_CONST(
       "features": [
         "use_virtualized_gl_contexts"
       ]
+    },
+    {
+      "id": 48,
+      "description": "Force to use discrete GPU on older MacBookPro models.",
+      "cr_bugs": [113703],
+      "os": {
+        "type": "macosx",
+        "version": {
+          "op": ">=",
+          "value": "10.7"
+        }
+      },
+      "machine_model": {
+        "name": {
+          "op": "=",
+          "value": "MacBookPro"
+        },
+        "version": {
+          "op": "<",
+          "value": "8"
+        }
+      },
+      "gpu_count": {
+        "op": "=",
+        "value": "2"
+      },
+      "features": [
+        "force_discrete_gpu"
+      ]
     }
   ]
 }
diff --git a/gpu/config/gpu_driver_bug_list_unittest.cc b/gpu/config/gpu_driver_bug_list_unittest.cc
index 597e730..1a5590c 100644
--- a/gpu/config/gpu_driver_bug_list_unittest.cc
+++ b/gpu/config/gpu_driver_bug_list_unittest.cc
@@ -10,6 +10,8 @@
 #include "gpu/config/gpu_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#define LONG_STRING_CONST(...) #__VA_ARGS__
+
 namespace gpu {
 
 class GpuDriverBugListTest : public testing::Test {
@@ -74,5 +76,54 @@ TEST_F(GpuDriverBugListTest, CurrentListForImagination) {
   EXPECT_EQ(1u, bugs.count(USE_CLIENT_SIDE_ARRAYS_FOR_STREAM_BUFFERS));
 }
 
+TEST_F(GpuDriverBugListTest, GpuSwitching) {
+  const std::string json = LONG_STRING_CONST(
+      {
+        "name": "gpu driver bug list",
+        "version": "0.1",
+        "entries": [
+          {
+            "id": 1,
+            "os": {
+              "type": "macosx"
+            },
+            "features": [
+              "force_discrete_gpu"
+            ]
+          },
+          {
+            "id": 2,
+            "os": {
+              "type": "win"
+            },
+            "features": [
+              "force_integrated_gpu"
+            ]
+          }
+        ]
+      }
+  );
+  scoped_ptr<GpuDriverBugList> driver_bug_list(GpuDriverBugList::Create());
+  EXPECT_TRUE(driver_bug_list->LoadList(json, GpuControlList::kAllOs));
+  std::set<int> switching = driver_bug_list->MakeDecision(
+      GpuControlList::kOsMacosx, "10.8", gpu_info());
+  EXPECT_EQ(1u, switching.size());
+  EXPECT_EQ(1u, switching.count(FORCE_DISCRETE_GPU));
+  std::vector<uint32> entries;
+  driver_bug_list->GetDecisionEntries(&entries, false);
+  ASSERT_EQ(1u, entries.size());
+  EXPECT_EQ(1u, entries[0]);
+
+  driver_bug_list.reset(GpuDriverBugList::Create());
+  EXPECT_TRUE(driver_bug_list->LoadList(json, GpuControlList::kAllOs));
+  switching = driver_bug_list->MakeDecision(
+      GpuControlList::kOsWin, "6.1", gpu_info());
+  EXPECT_EQ(1u, switching.size());
+  EXPECT_EQ(1u, switching.count(FORCE_INTEGRATED_GPU));
+  driver_bug_list->GetDecisionEntries(&entries, false);
+  ASSERT_EQ(1u, entries.size());
+  EXPECT_EQ(2u, entries[0]);
+}
+
 }  // namespace gpu
 
diff --git a/gpu/config/gpu_driver_bug_workaround_type.h b/gpu/config/gpu_driver_bug_workaround_type.h
index 66db5ff..98031ae 100644
--- a/gpu/config/gpu_driver_bug_workaround_type.h
+++ b/gpu/config/gpu_driver_bug_workaround_type.h
@@ -38,6 +38,10 @@
          enable_chromium_fast_npot_mo8_textures)             \
   GPU_OP(EXIT_ON_CONTEXT_LOST,                               \
          exit_on_context_lost)                               \
+  GPU_OP(FORCE_DISCRETE_GPU,                                 \
+         force_discrete_gpu)                                 \
+  GPU_OP(FORCE_INTEGRATED_GPU,                               \
+         force_integrated_gpu)                               \
   GPU_OP(INIT_GL_POSITION_IN_VERTEX_SHADER,                  \
          init_gl_position_in_vertex_shader)                  \
   GPU_OP(MAX_CUBE_MAP_TEXTURE_SIZE_LIMIT_1024,               \
diff --git a/gpu/config/gpu_switching_list.cc b/gpu/config/gpu_switching_list.cc
deleted file mode 100644
index b87dfb2..0000000
--- a/gpu/config/gpu_switching_list.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 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/config/gpu_switching_list.h"
-
-#include "gpu/config/gpu_switching_option.h"
-
-namespace gpu {
-
-GpuSwitchingList::GpuSwitchingList()
-    : GpuControlList() {
-}
-
-GpuSwitchingList::~GpuSwitchingList() {
-}
-
-// static
-GpuSwitchingList* GpuSwitchingList::Create() {
-  GpuSwitchingList* list = new GpuSwitchingList();
-  list->AddSupportedFeature("force_integrated",
-                            GPU_SWITCHING_OPTION_FORCE_INTEGRATED);
-  list->AddSupportedFeature("force_discrete",
-                            GPU_SWITCHING_OPTION_FORCE_DISCRETE);
-  return list;
-}
-
-}  // namespace gpu
-
diff --git a/gpu/config/gpu_switching_list.h b/gpu/config/gpu_switching_list.h
deleted file mode 100644
index 095597a..0000000
--- a/gpu/config/gpu_switching_list.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 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.
-
-#ifndef GPU_CONFIG_GPU_SWITCHING_LIST_H_
-#define GPU_CONFIG_GPU_SWITCHING_LIST_H_
-
-#include <string>
-
-#include "gpu/config/gpu_control_list.h"
-
-namespace gpu {
-
-class GPU_EXPORT GpuSwitchingList : public GpuControlList {
- public:
-  virtual ~GpuSwitchingList();
-
-  static GpuSwitchingList* Create();
-
- private:
-  GpuSwitchingList();
-
-  DISALLOW_COPY_AND_ASSIGN(GpuSwitchingList);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_CONFIG_GPU_SWITCHING_LIST_H_
-
diff --git a/gpu/config/gpu_switching_list_json.cc b/gpu/config/gpu_switching_list_json.cc
deleted file mode 100644
index 81a8d22..0000000
--- a/gpu/config/gpu_switching_list_json.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 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.
-
-// Determines whether a certain gpu is prefered in a dual-gpu situation.
-// The format of a valid gpu_switching_list.json file is defined in
-// <gpu/config/gpu_control_list_format.txt>.
-// The supported "features" can be found in <gpu/config/gpu_switching_list.cc>.
-
-#include "gpu/config/gpu_control_list_jsons.h"
-
-#define LONG_STRING_CONST(...) #__VA_ARGS__
-
-namespace gpu {
-
-const char kGpuSwitchingListJson[] = LONG_STRING_CONST(
-
-{
-  "name": "gpu switching list",
-  // Please update the version number whenever you change this file.
-  "version": "2.0",
-  "entries": [
-    {
-      "id": 1,
-      "description": "Force to use discrete GPU on older MacBookPro models.",
-      "cr_bugs": [113703],
-      "os": {
-        "type": "macosx",
-        "version": {
-          "op": ">=",
-          "value": "10.7"
-        }
-      },
-      "machine_model": {
-        "name": {
-          "op": "=",
-          "value": "MacBookPro"
-        },
-        "version": {
-          "op": "<",
-          "value": "8"
-        }
-      },
-      "gpu_count": {
-        "op": "=",
-        "value": "2"
-      },
-      "features": [
-        "force_discrete"
-      ]
-    }
-  ]
-}
-
-);  // LONG_STRING_CONST macro
-
-}  // namespace gpu
-
diff --git a/gpu/config/gpu_switching_list_unittest.cc b/gpu/config/gpu_switching_list_unittest.cc
deleted file mode 100644
index 56d0f8f..0000000
--- a/gpu/config/gpu_switching_list_unittest.cc
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (c) 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 <vector>
-
-#include "base/memory/scoped_ptr.h"
-#include "gpu/config/gpu_control_list_jsons.h"
-#include "gpu/config/gpu_info.h"
-#include "gpu/config/gpu_switching_list.h"
-#include "gpu/config/gpu_switching_option.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#define LONG_STRING_CONST(...) #__VA_ARGS__
-
-const char kOsVersion[] = "10.6.4";
-
-namespace gpu {
-
-class GpuSwitchingListTest : public testing::Test {
- public:
-  GpuSwitchingListTest() { }
-
-  virtual ~GpuSwitchingListTest() { }
-
-  const GPUInfo& gpu_info() const {
-    return gpu_info_;
-  }
-
- protected:
-  virtual void SetUp() {
-    gpu_info_.gpu.vendor_id = 0x10de;
-    gpu_info_.gpu.device_id = 0x0640;
-    gpu_info_.driver_vendor = "NVIDIA";
-    gpu_info_.driver_version = "1.6.18";
-    gpu_info_.driver_date = "7-14-2009";
-    gpu_info_.machine_model = "MacBookPro 7.1";
-    gpu_info_.gl_vendor = "NVIDIA Corporation";
-    gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
-    gpu_info_.performance_stats.graphics = 5.0;
-    gpu_info_.performance_stats.gaming = 5.0;
-    gpu_info_.performance_stats.overall = 5.0;
-  }
-
-  virtual void TearDown() {
-  }
-
- private:
-  GPUInfo gpu_info_;
-};
-
-TEST_F(GpuSwitchingListTest, CurrentSwitchingListValidation) {
-  scoped_ptr<GpuSwitchingList> switching_list(GpuSwitchingList::Create());
-  EXPECT_TRUE(switching_list->LoadList(
-      kGpuSwitchingListJson, GpuControlList::kAllOs));
-}
-
-TEST_F(GpuSwitchingListTest, GpuSwitching) {
-  const std::string json = LONG_STRING_CONST(
-      {
-        "name": "gpu switching list",
-        "version": "0.1",
-        "entries": [
-          {
-            "id": 1,
-            "os": {
-              "type": "macosx"
-            },
-            "features": [
-              "force_discrete"
-            ]
-          },
-          {
-            "id": 2,
-            "os": {
-              "type": "win"
-            },
-            "features": [
-              "force_integrated"
-            ]
-          }
-        ]
-      }
-  );
-  scoped_ptr<GpuSwitchingList> switching_list(GpuSwitchingList::Create());
-  EXPECT_TRUE(switching_list->LoadList(json, GpuControlList::kAllOs));
-  std::set<int> switching = switching_list->MakeDecision(
-      GpuControlList::kOsMacosx, kOsVersion, gpu_info());
-  EXPECT_EQ(1u, switching.size());
-  EXPECT_EQ(1u, switching.count(GPU_SWITCHING_OPTION_FORCE_DISCRETE));
-  std::vector<uint32> entries;
-  switching_list->GetDecisionEntries(&entries, false);
-  ASSERT_EQ(1u, entries.size());
-  EXPECT_EQ(1u, entries[0]);
-
-  switching_list.reset(GpuSwitchingList::Create());
-  EXPECT_TRUE(switching_list->LoadList(json, GpuControlList::kAllOs));
-  switching = switching_list->MakeDecision(
-      GpuControlList::kOsWin, kOsVersion, gpu_info());
-  EXPECT_EQ(1u, switching.size());
-  EXPECT_EQ(1u, switching.count(GPU_SWITCHING_OPTION_FORCE_INTEGRATED));
-  switching_list->GetDecisionEntries(&entries, false);
-  ASSERT_EQ(1u, entries.size());
-  EXPECT_EQ(2u, entries[0]);
-}
-
-}  // namespace gpu
-
diff --git a/gpu/config/gpu_switching_option.h b/gpu/config/gpu_switching_option.h
deleted file mode 100644
index 036c15f..0000000
--- a/gpu/config/gpu_switching_option.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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.
-
-#ifndef GPU_CONFIG_GPU_SWITCHING_OPTION_H_
-#define GPU_CONFIG_GPU_SWITCHING_OPTION_H_
-
-//#include "build/build_config.h"
-
-namespace gpu {
-
-enum GpuSwitchingOption {
-  GPU_SWITCHING_OPTION_AUTOMATIC,
-  GPU_SWITCHING_OPTION_FORCE_INTEGRATED,
-  GPU_SWITCHING_OPTION_FORCE_DISCRETE,
-  GPU_SWITCHING_OPTION_UNKNOWN
-};
-
-}  // namespace gpu
-
-#endif  // GPU_CONFIG_GPU_SWITCHING_OPTION_H_
-
diff --git a/gpu/config/gpu_util.cc b/gpu/config/gpu_util.cc
index 7fae88a..728546c 100644
--- a/gpu/config/gpu_util.cc
+++ b/gpu/config/gpu_util.cc
@@ -9,6 +9,7 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_control_list_jsons.h"
 #include "gpu/config/gpu_driver_bug_list.h"
@@ -31,32 +32,20 @@ std::string IntSetToString(const std::set<int>& list) {
   return rt;
 }
 
-}  // namespace anonymous
-
-GpuSwitchingOption StringToGpuSwitchingOption(
-    const std::string& switching_string) {
-  if (switching_string == switches::kGpuSwitchingOptionNameAutomatic)
-    return GPU_SWITCHING_OPTION_AUTOMATIC;
-  if (switching_string == switches::kGpuSwitchingOptionNameForceIntegrated)
-    return GPU_SWITCHING_OPTION_FORCE_INTEGRATED;
-  if (switching_string == switches::kGpuSwitchingOptionNameForceDiscrete)
-    return GPU_SWITCHING_OPTION_FORCE_DISCRETE;
-  return GPU_SWITCHING_OPTION_UNKNOWN;
-}
-
-std::string GpuSwitchingOptionToString(GpuSwitchingOption option) {
-  switch (option) {
-    case GPU_SWITCHING_OPTION_AUTOMATIC:
-      return switches::kGpuSwitchingOptionNameAutomatic;
-    case GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
-      return switches::kGpuSwitchingOptionNameForceIntegrated;
-    case GPU_SWITCHING_OPTION_FORCE_DISCRETE:
-      return switches::kGpuSwitchingOptionNameForceDiscrete;
-    default:
-      return "unknown";
+void StringToIntSet(const std::string& str, std::set<int>* list) {
+  DCHECK(list);
+  std::vector<std::string> pieces;
+  base::SplitString(str, ',', &pieces);
+  for (size_t i = 0; i < pieces.size(); ++i) {
+    int number = 0;
+    bool succeed = base::StringToInt(pieces[i], &number);
+    DCHECK(succeed);
+    list->insert(number);
   }
 }
 
+}  // namespace anonymous
+
 void MergeFeatureSets(std::set<int>* dst, const std::set<int>& src) {
   DCHECK(dst);
   if (src.empty())
@@ -79,4 +68,9 @@ void ApplyGpuDriverBugWorkarounds(CommandLine* command_line) {
   }
 }
 
+void StringToFeatureSet(
+    const std::string& str, std::set<int>* feature_set) {
+  StringToIntSet(str, feature_set);
+}
+
 }  // namespace gpu
diff --git a/gpu/config/gpu_util.h b/gpu/config/gpu_util.h
index 6d6800e..58e2db0 100644
--- a/gpu/config/gpu_util.h
+++ b/gpu/config/gpu_util.h
@@ -9,21 +9,12 @@
 #include <string>
 
 #include "build/build_config.h"
-#include "gpu/config/gpu_switching_option.h"
 #include "gpu/gpu_export.h"
 
 class CommandLine;
 
 namespace gpu {
 
-// Maps string to GpuSwitchingOption; returns GPU_SWITCHING_UNKNOWN if an
-// unknown name is input (case-sensitive).
-GPU_EXPORT GpuSwitchingOption StringToGpuSwitchingOption(
-    const std::string& switching_string);
-
-// Gets a string version of a GpuSwitchingOption.
-GPU_EXPORT std::string GpuSwitchingOptionToString(GpuSwitchingOption option);
-
 // Merge features in src into dst.
 GPU_EXPORT void MergeFeatureSets(
     std::set<int>* dst, const std::set<int>& src);
@@ -32,6 +23,10 @@ GPU_EXPORT void MergeFeatureSets(
 // system, and append the |command_line|.
 GPU_EXPORT void ApplyGpuDriverBugWorkarounds(CommandLine* command_line);
 
+// |str| is in the format of "feature1,feature2,...,featureN".
+GPU_EXPORT void StringToFeatureSet(
+    const std::string& str, std::set<int>* feature_set);
+
 }  // namespace gpu
 
 #endif  // GPU_CONFIG_GPU_UTIL_H_
diff --git a/gpu/config/gpu_util_unittest.cc b/gpu/config/gpu_util_unittest.cc
index f3e3f8f..e1264db 100644
--- a/gpu/config/gpu_util_unittest.cc
+++ b/gpu/config/gpu_util_unittest.cc
@@ -4,37 +4,9 @@
 
 #include "gpu/config/gpu_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gl/gl_switches.h"
 
 namespace gpu {
 
-TEST(GpuUtilTest, GpuSwitchingOptionFromString) {
-  // Test StringToGpuSwitchingOption.
-  EXPECT_EQ(StringToGpuSwitchingOption(
-                switches::kGpuSwitchingOptionNameAutomatic),
-            GPU_SWITCHING_OPTION_AUTOMATIC);
-  EXPECT_EQ(StringToGpuSwitchingOption(
-                switches::kGpuSwitchingOptionNameForceDiscrete),
-            GPU_SWITCHING_OPTION_FORCE_DISCRETE);
-  EXPECT_EQ(StringToGpuSwitchingOption(
-                switches::kGpuSwitchingOptionNameForceIntegrated),
-            GPU_SWITCHING_OPTION_FORCE_INTEGRATED);
-  EXPECT_EQ(StringToGpuSwitchingOption("xxx"), GPU_SWITCHING_OPTION_UNKNOWN);
-}
-
-TEST(GpuUtilTest, GpuSwitchingOptionToString) {
-  // Test GpuSwitchingOptionToString.
-  EXPECT_STREQ(
-      GpuSwitchingOptionToString(GPU_SWITCHING_OPTION_AUTOMATIC).c_str(),
-      switches::kGpuSwitchingOptionNameAutomatic);
-  EXPECT_STREQ(
-      GpuSwitchingOptionToString(GPU_SWITCHING_OPTION_FORCE_DISCRETE).c_str(),
-      switches::kGpuSwitchingOptionNameForceDiscrete);
-  EXPECT_STREQ(
-      GpuSwitchingOptionToString(GPU_SWITCHING_OPTION_FORCE_INTEGRATED).c_str(),
-      switches::kGpuSwitchingOptionNameForceIntegrated);
-}
-
 TEST(GpuUtilTest, MergeFeatureSets) {
   {
     // Merge two empty sets.
@@ -75,4 +47,25 @@ TEST(GpuUtilTest, MergeFeatureSets) {
   }
 }
 
+TEST(GpuUtilTest, StringToFeatureSet) {
+  {
+    // zero feature.
+    std::set<int> features;
+    StringToFeatureSet("", &features);
+    EXPECT_EQ(0u, features.size());
+  }
+  {
+    // One features.
+    std::set<int> features;
+    StringToFeatureSet("4", &features);
+    EXPECT_EQ(1u, features.size());
+  }
+  {
+    // Multiple features.
+    std::set<int> features;
+    StringToFeatureSet("1,9", &features);
+    EXPECT_EQ(2u, features.size());
+  }
+}
+
 }  // namespace gpu
diff --git a/gpu/gpu.gyp b/gpu/gpu.gyp
index fd7cac8..334c0b3 100644
--- a/gpu/gpu.gyp
+++ b/gpu/gpu.gyp
@@ -224,7 +224,6 @@
         'config/gpu_driver_bug_list_unittest.cc',
         'config/gpu_info_collector_unittest.cc',
         'config/gpu_info_unittest.cc',
-        'config/gpu_switching_list_unittest.cc',
         'config/gpu_test_config_unittest.cc',
         'config/gpu_test_expectations_parser_unittest.cc',
         'config/gpu_util_unittest.cc',
diff --git a/gpu/gpu_config.gypi b/gpu/gpu_config.gypi
index c95605b..9c1d581 100644
--- a/gpu/gpu_config.gypi
+++ b/gpu/gpu_config.gypi
@@ -35,10 +35,6 @@
     'config/gpu_info_collector.cc',
     'config/gpu_info_collector.h',
     'config/gpu_performance_stats.h',
-    'config/gpu_switching_list_json.cc',
-    'config/gpu_switching_list.cc',
-    'config/gpu_switching_list.h',
-    'config/gpu_switching_option.h',
     'config/gpu_test_config.cc',
     'config/gpu_test_config.h',
     'config/gpu_test_expectations_parser.cc',
diff --git a/ui/gl/gl_switches.cc b/ui/gl/gl_switches.cc
index 6addfe1..5ac5148 100644
--- a/ui/gl/gl_switches.cc
+++ b/ui/gl/gl_switches.cc
@@ -62,7 +62,6 @@ const char kGpuSwitching[]                  = "gpu-switching";
 
 const char kGpuSwitchingOptionNameForceIntegrated[] = "force_integrated";
 const char kGpuSwitchingOptionNameForceDiscrete[]   = "force_discrete";
-const char kGpuSwitchingOptionNameAutomatic[]   = "automatic";
 
 // Flag used for Linux tests: for desktop GL bindings, try to load this GL
 // library first, but fall back to regular library if loading fails.
@@ -78,7 +77,6 @@ const char* kGLSwitchesCopiedFromGpuProcessHost[] = {
   kEnableGPUServiceLogging,
   kEnableGPUServiceTracing,
   kGpuNoContextLost,
-  kGpuSwitching,
 };
 const int kGLSwitchesCopiedFromGpuProcessHostNumSwitches =
     arraysize(kGLSwitchesCopiedFromGpuProcessHost);