Add capability for GPU blacklist to manage GPU switching.

This is orthorgonal to the blacklist feature management.

Doing this, we don't have to hardwire the forcing on discrete GPU for the new Macbook 2012; also, we provide a way for users to bypass the forcing (use --ignore-gpu-blacklist).

Note that this CL implements it in the GPU blacklist.  We haven't hooked it up to the real GPU switching yet (will do it in another CL).

BUG=140114,131276,111720
TEST=tree
Review URL: https://chromiumcodereview.appspot.com/10915219

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

12 files changed, 400 insertions, 173 deletions

diff --git a/chrome/browser/resources/gpu_internals/info_view.js b/chrome/browser/resources/gpu_internals/info_view.js
index 69dd0a6..974b018 100644
--- a/chrome/browser/resources/gpu_internals/info_view.js
+++ b/chrome/browser/resources/gpu_internals/info_view.js
@@ -83,7 +83,9 @@ cr.define('gpu', function() {
         'flash_3d': 'Flash 3D',
         'flash_stage3d': 'Flash Stage3D',
         'texture_sharing': 'Texture Sharing',
-        'video_decode': 'Video Decode'
+        'video_decode': 'Video Decode',
+        // GPU Switching
+        'gpu_switching': 'GPU Switching',
       };
       var statusLabelMap = {
         'disabled_software': 'Software only. Hardware acceleration disabled.',
@@ -100,7 +102,11 @@ cr.define('gpu', function() {
             'Hardware accelerated on all pages and threaded',
         'enabled': 'Hardware accelerated',
         'accelerated': 'Accelerated',
-        'accelerated_threaded': 'Accelerated and threaded'
+        'accelerated_threaded': 'Accelerated and threaded',
+        // GPU Switching
+        'gpu_switching_automatic': 'Automatic switching',
+        'gpu_switching_force_discrete': 'Always on discrete GPU',
+        'gpu_switching_force_integrated': 'Always on integrated GPU',
       };
 
       var statusClassMap = {
@@ -116,7 +122,11 @@ cr.define('gpu', function() {
         'enabled_force_threaded': 'feature-green',
         'enabled': 'feature-green',
         'accelerated': 'feature-green',
-        'accelerated_threaded': 'feature-green'
+        'accelerated_threaded': 'feature-green',
+        // GPU Switching
+        'gpu_switching_automatic': 'feature-green',
+        'gpu_switching_force_discrete': 'feature-red',
+        'gpu_switching_force_integrated': 'feature-red',
       };
 
       // GPU info, basic
diff --git a/chrome/browser/ui/webui/gpu_internals_ui.cc b/chrome/browser/ui/webui/gpu_internals_ui.cc
index 4d4d3c3..91c535c 100644
--- a/chrome/browser/ui/webui/gpu_internals_ui.cc
+++ b/chrome/browser/ui/webui/gpu_internals_ui.cc
@@ -340,7 +340,26 @@ Value* GetFeatureStatus() {
       feature_status_list->Append(
           NewStatusValue(kGpuFeatureInfo[i].name.c_str(), status.c_str()));
     }
-
+    content::GPUInfo gpu_info = GpuDataManager::GetInstance()->GetGPUInfo();
+    if (gpu_info.secondary_gpus.size() > 0 ||
+        gpu_info.optimus || gpu_info.amd_switchable) {
+      std::string gpu_switching;
+      switch (GpuDataManager::GetInstance()->GetGpuSwitchingOption()) {
+        case content::GPU_SWITCHING_AUTOMATIC:
+          gpu_switching = "gpu_switching_automatic";
+          break;
+        case content::GPU_SWITCHING_FORCE_DISCRETE:
+          gpu_switching = "gpu_switching_force_discrete";
+          break;
+        case content::GPU_SWITCHING_FORCE_INTEGRATED:
+          gpu_switching = "gpu_switching_force_integrated";
+          break;
+        default:
+          break;
+      }
+      feature_status_list->Append(
+          NewStatusValue("gpu_switching", gpu_switching.c_str()));
+    }
     status->Set("featureStatus", feature_status_list);
   }
 
diff --git a/content/browser/gpu/gpu_blacklist.cc b/content/browser/gpu/gpu_blacklist.cc
index 403a894..e36ec77 100644
--- a/content/browser/gpu/gpu_blacklist.cc
+++ b/content/browser/gpu/gpu_blacklist.cc
@@ -17,6 +17,7 @@
 #include "content/public/common/gpu_info.h"
 
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 namespace {
 
@@ -553,25 +554,32 @@ GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
 
   if (top_level) {
     const ListValue* blacklist_value = NULL;
-    if (!value->GetList("blacklist", &blacklist_value)) {
-      LOG(WARNING) << "Malformed blacklist entry " << entry->id();
-      return NULL;
-    }
-    std::vector<std::string> blacklist;
-    for (size_t i = 0; i < blacklist_value->GetSize(); ++i) {
-      std::string feature;
-      if (blacklist_value->GetString(i, &feature)) {
-        blacklist.push_back(feature);
-      } else {
+    if (value->GetList("blacklist", &blacklist_value)) {
+      std::vector<std::string> blacklist;
+      for (size_t i = 0; i < blacklist_value->GetSize(); ++i) {
+        std::string feature;
+        if (blacklist_value->GetString(i, &feature)) {
+          blacklist.push_back(feature);
+        } else {
+          LOG(WARNING) << "Malformed blacklist entry " << entry->id();
+          return NULL;
+        }
+      }
+      if (!entry->SetBlacklistedFeatures(blacklist)) {
         LOG(WARNING) << "Malformed blacklist entry " << entry->id();
         return NULL;
       }
+      dictionary_entry_count++;
     }
-    if (!entry->SetBlacklistedFeatures(blacklist)) {
-      LOG(WARNING) << "Malformed blacklist entry " << entry->id();
-      return NULL;
+
+    std::string switching_value;
+    if (value->GetString("gpu_switching", &switching_value)) {
+      if (!entry->SetGpuSwitchingOption(switching_value)) {
+        LOG(WARNING) << "Malformed gpu_switching entry " << entry->id();
+        return NULL;
+      }
+      dictionary_entry_count++;
     }
-    dictionary_entry_count++;
   }
 
   if (top_level) {
@@ -618,7 +626,6 @@ GpuBlacklist::GpuBlacklistEntry::GpuBlacklistEntry()
       vendor_id_(0),
       multi_gpu_style_(kMultiGpuStyleNone),
       multi_gpu_category_(kMultiGpuCategoryPrimary),
-      feature_type_(content::GPU_FEATURE_TYPE_UNKNOWN),
       contains_unknown_fields_(false),
       contains_unknown_features_(false) {
 }
@@ -779,7 +786,17 @@ bool GpuBlacklist::GpuBlacklistEntry::SetBlacklistedFeatures(
         break;
     }
   }
-  feature_type_ = static_cast<GpuFeatureType>(feature_type);
+  decision_.blacklisted_features = static_cast<GpuFeatureType>(feature_type);
+  return true;
+}
+
+bool GpuBlacklist::GpuBlacklistEntry::SetGpuSwitchingOption(
+    const std::string& switching_string) {
+  GpuSwitchingOption switching = gpu_util::StringToGpuSwitchingOption(
+      switching_string);
+  if (switching == content::GPU_SWITCHING_UNKNOWN)
+    return false;
+  decision_.gpu_switching = switching;
   return true;
 }
 
@@ -913,7 +930,12 @@ bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
 }
 
 GpuFeatureType GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureType() const {
-  return feature_type_;
+  return decision_.blacklisted_features;
+}
+
+GpuSwitchingOption
+GpuBlacklist::GpuBlacklistEntry::GetGpuSwitchingOption() const {
+  return decision_.gpu_switching;
 }
 
 GpuBlacklist::GpuBlacklist()
@@ -1008,12 +1030,13 @@ bool GpuBlacklist::LoadGpuBlacklist(
   return true;
 }
 
-GpuFeatureType GpuBlacklist::DetermineGpuFeatureType(
+GpuBlacklist::Decision GpuBlacklist::MakeBlacklistDecision(
     GpuBlacklist::OsType os,
     Version* os_version,
     const content::GPUInfo& gpu_info) {
   active_entries_.clear();
   int type = 0;
+  GpuSwitchingOption switching = content::GPU_SWITCHING_AUTOMATIC;
 
   if (os == kOsAny)
     os = GetOsType();
@@ -1030,22 +1053,26 @@ GpuFeatureType GpuBlacklist::DetermineGpuFeatureType(
 
   for (size_t i = 0; i < blacklist_.size(); ++i) {
     if (blacklist_[i]->Contains(os, *os_version, gpu_info)) {
-      if (!blacklist_[i]->disabled())
+      if (!blacklist_[i]->disabled()) {
         type |= blacklist_[i]->GetGpuFeatureType();
+        if (blacklist_[i]->GetGpuSwitchingOption() !=
+                content::GPU_SWITCHING_AUTOMATIC)
+          switching = blacklist_[i]->GetGpuSwitchingOption();
+      }
       active_entries_.push_back(blacklist_[i]);
     }
   }
-  return static_cast<GpuFeatureType>(type);
+  Decision decision;
+  decision.blacklisted_features = static_cast<GpuFeatureType>(type);
+  decision.gpu_switching = switching;
+  return decision;
 }
 
-void GpuBlacklist::GetGpuFeatureTypeEntries(
-    content::GpuFeatureType feature,
-    std::vector<uint32>& entry_ids,
-    bool disabled) const {
+void GpuBlacklist::GetDecisionEntries(
+    std::vector<uint32>& entry_ids, bool disabled) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
-    if (((feature & active_entries_[i]->GetGpuFeatureType()) != 0) &&
-        disabled == active_entries_[i]->disabled())
+    if (disabled == active_entries_[i]->disabled())
       entry_ids.push_back(active_entries_[i]->id());
   }
 }
diff --git a/content/browser/gpu/gpu_blacklist.h b/content/browser/gpu/gpu_blacklist.h
index 61801c3..2193f29 100644
--- a/content/browser/gpu/gpu_blacklist.h
+++ b/content/browser/gpu/gpu_blacklist.h
@@ -41,6 +41,16 @@ class CONTENT_EXPORT GpuBlacklist {
     kAllOs
   };
 
+  struct Decision {
+    content::GpuFeatureType blacklisted_features;
+    content::GpuSwitchingOption gpu_switching;
+
+    Decision()
+        : blacklisted_features(content::GPU_FEATURE_TYPE_UNKNOWN),
+          gpu_switching(content::GPU_SWITCHING_AUTOMATIC) {
+    }
+  };
+
   GpuBlacklist();
   virtual ~GpuBlacklist();
 
@@ -52,28 +62,20 @@ class CONTENT_EXPORT GpuBlacklist {
                         OsFilter os_filter);
 
   // Collects system information and combines them with gpu_info and blacklist
-  // information to determine gpu feature flags.
+  // information to make the blacklist decision.
   // If os is kOsAny, use the current OS; if os_version is null, use the
   // current OS version.
-  content::GpuFeatureType DetermineGpuFeatureType(
+  Decision MakeBlacklistDecision(
       OsType os, Version* os_version, const content::GPUInfo& gpu_info);
 
-  // Collects the active entries that set the "feature" flag from the last
-  // DetermineGpuFeatureType() call.  This tells which entries are responsible
-  // for raising a certain flag, i.e, for blacklisting a certain feature.
-  // Examples of "feature":
-  //   GPU_FEATURE_TYPE_ALL - any of the supported features;
-  //   GPU_FEATURE_TYPE_WEBGL - a single feature;
-  //   GPU_FEATURE_TYPE_WEBGL | GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING
-  //       - two features.
+  // Collects the active entries from the last MakeBlacklistDecision() call.
   // If disabled set to true, return entries that are disabled; otherwise,
   // return enabled entries.
-  void GetGpuFeatureTypeEntries(content::GpuFeatureType feature,
-                                std::vector<uint32>& entry_ids,
-                                bool disabled) const;
+  void GetDecisionEntries(std::vector<uint32>& entry_ids,
+                          bool disabled) const;
 
   // Returns the description and bugs from active entries from the last
-  // DetermineGpuFeatureType() call.
+  // MakeBlacklistDecision() call.
   //
   // Each problems has:
   // {
@@ -249,6 +251,9 @@ class CONTENT_EXPORT GpuBlacklist {
     // Returns the GpuFeatureType.
     content::GpuFeatureType GetGpuFeatureType() const;
 
+    // Returns the GpuSwitchingOption.
+    content::GpuSwitchingOption GetGpuSwitchingOption() const;
+
     // Returns true if an unknown field is encountered.
     bool contains_unknown_fields() const {
       return contains_unknown_fields_;
@@ -327,6 +332,8 @@ class CONTENT_EXPORT GpuBlacklist {
     bool SetBlacklistedFeatures(
         const std::vector<std::string>& blacklisted_features);
 
+    bool SetGpuSwitchingOption(const std::string& switching_string);
+
     void AddException(ScopedGpuBlacklistEntry exception);
 
     static MultiGpuStyle StringToMultiGpuStyle(const std::string& style);
@@ -352,7 +359,7 @@ class CONTENT_EXPORT GpuBlacklist {
     scoped_ptr<FloatInfo> perf_graphics_info_;
     scoped_ptr<FloatInfo> perf_gaming_info_;
     scoped_ptr<FloatInfo> perf_overall_info_;
-    content::GpuFeatureType feature_type_;
+    Decision decision_;
     std::vector<ScopedGpuBlacklistEntry> exceptions_;
     bool contains_unknown_fields_;
     bool contains_unknown_features_;
@@ -386,8 +393,8 @@ class CONTENT_EXPORT GpuBlacklist {
   scoped_ptr<Version> browser_version_;
 
   // This records all the blacklist entries that are appliable to the current
-  // user machine.  It is updated everytime DetermineGpuFeatureType() is
-  // called and is used later by GetGpuFeatureTypeEntries().
+  // user machine.  It is updated everytime MakeBlacklistDecision() is
+  // called and is used later by GetDecisionEntries().
   std::vector<ScopedGpuBlacklistEntry> active_entries_;
 
   uint32 max_entry_id_;
diff --git a/content/browser/gpu/gpu_blacklist_unittest.cc b/content/browser/gpu/gpu_blacklist_unittest.cc
index 6e921b8..467446b 100644
--- a/content/browser/gpu/gpu_blacklist_unittest.cc
+++ b/content/browser/gpu/gpu_blacklist_unittest.cc
@@ -15,6 +15,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 class GpuBlacklistTest : public testing::Test {
  public:
@@ -77,8 +78,9 @@ TEST_F(GpuBlacklistTest, DefaultBlacklistSettings) {
   Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
   // Default blacklist settings: all feature are allowed.
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -97,8 +99,9 @@ TEST_F(GpuBlacklistTest, EmptyBlacklist) {
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       empty_list_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(blacklist->GetVersion(), std::string("2.5"));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -135,8 +138,9 @@ TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       exact_list_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
 
   // Invalid json input should not change the current blacklist settings.
@@ -144,17 +148,13 @@ TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
 
   EXPECT_FALSE(blacklist->LoadGpuBlacklist(
       invalid_json, GpuBlacklist::kAllOs));
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
   std::vector<uint32> entries;
   bool disabled = false;
-  blacklist->GetGpuFeatureTypeEntries(
-      content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING, entries, disabled);
-  EXPECT_EQ(entries.size(), 1u);
-  EXPECT_EQ(entries[0], 5u);
-  blacklist->GetGpuFeatureTypeEntries(
-      content::GPU_FEATURE_TYPE_ALL, entries, disabled);
+  blacklist->GetDecisionEntries(entries, disabled);
   EXPECT_EQ(entries.size(), 1u);
   EXPECT_EQ(entries[0], 5u);
   EXPECT_EQ(blacklist->max_entry_id(), 5u);
@@ -182,28 +182,34 @@ TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) {
   // Blacklist entries won't be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX) || \
     defined(OS_OPENBSD)
   // Blacklist entries will be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_json, GpuBlacklist::kCurrentOsOnly));
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 #endif
 }
@@ -232,14 +238,17 @@ TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_linux_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
@@ -271,14 +280,17 @@ TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       linux_except_nvidia_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -310,14 +322,17 @@ TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       linux_except_intel_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
@@ -348,14 +363,17 @@ TEST_F(GpuBlacklistTest, DateOnWindowsEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       date_windows_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
@@ -380,14 +398,17 @@ TEST_F(GpuBlacklistTest, MultipleDevicesEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       devices_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
 }
 
@@ -413,11 +434,13 @@ TEST_F(GpuBlacklistTest, ChromeOSEntry) {
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       devices_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsChromeOS, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsChromeOS, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info());
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -444,15 +467,17 @@ TEST_F(GpuBlacklistTest, ChromeVersionEntry) {
   scoped_ptr<GpuBlacklist> blacklist9(Create());
   EXPECT_TRUE(blacklist9->LoadGpuBlacklist(
       "9.0", browser_version_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist9->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist9->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 
   scoped_ptr<GpuBlacklist> blacklist10(Create());
   EXPECT_TRUE(blacklist10->LoadGpuBlacklist(
       "10.0", browser_version_json, GpuBlacklist::kAllOs));
-  type = blacklist10->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  type = blacklist10->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -506,8 +531,9 @@ TEST_F(GpuBlacklistTest, UnknownField) {
       unknown_field_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -550,8 +576,9 @@ TEST_F(GpuBlacklistTest, UnknownExceptionField) {
       unknown_exception_field_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -577,8 +604,9 @@ TEST_F(GpuBlacklistTest, UnknownFeature) {
       unknown_feature_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -605,8 +633,9 @@ TEST_F(GpuBlacklistTest, GlVendor) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       gl_vendor_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -633,8 +662,9 @@ TEST_F(GpuBlacklistTest, GlRenderer) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       gl_renderer_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -660,8 +690,9 @@ TEST_F(GpuBlacklistTest, PerfGraphics) {
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -687,8 +718,9 @@ TEST_F(GpuBlacklistTest, PerfGaming) {
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -715,8 +747,9 @@ TEST_F(GpuBlacklistTest, PerfOverall) {
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -740,17 +773,16 @@ TEST_F(GpuBlacklistTest, DisabledEntry) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       disabled_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, 0);
   std::vector<uint32> flag_entries;
   bool disabled = false;
-  blacklist->GetGpuFeatureTypeEntries(
-      content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
+  blacklist->GetDecisionEntries(flag_entries, disabled);
   EXPECT_EQ(flag_entries.size(), 0u);
   disabled = true;
-  blacklist->GetGpuFeatureTypeEntries(
-      content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
+  blacklist->GetDecisionEntries(flag_entries, disabled);
   EXPECT_EQ(flag_entries.size(), 1u);
 }
 
@@ -780,8 +812,9 @@ TEST_F(GpuBlacklistTest, Optimus) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       optimus_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info);
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -811,8 +844,9 @@ TEST_F(GpuBlacklistTest, AMDSwitchable) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       amd_switchable_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -849,23 +883,27 @@ TEST_F(GpuBlacklistTest, LexicalDriverVersion) {
       lexical_json, GpuBlacklist::kAllOs));
 
   gpu_info.driver_version = "8.109";
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info);
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 
   gpu_info.driver_version = "8.2";
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info);
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 
   gpu_info.driver_version = "8.21";
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info);
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, 0);
 
   gpu_info.driver_version = "8.2010";
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, &os_version, gpu_info);
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, 0);
 }
 
@@ -898,16 +936,18 @@ TEST_F(GpuBlacklistTest, MultipleGPUsAny) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       multi_gpu_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, 0);
 
   content::GPUInfo::GPUDevice gpu_device;
   gpu_device.vendor_id = 0x8086;
   gpu_device.device_id = 0x0166;
   gpu_info.secondary_gpus.push_back(gpu_device);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
@@ -940,19 +980,88 @@ TEST_F(GpuBlacklistTest, MultipleGPUsSecondary) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       multi_gpu_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, 0);
 
   content::GPUInfo::GPUDevice gpu_device;
   gpu_device.vendor_id = 0x8086;
   gpu_device.device_id = 0x0166;
   gpu_info.secondary_gpus.push_back(gpu_device);
-  type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
+  type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
+TEST_F(GpuBlacklistTest, GpuSwitching) {
+  const std::string gpu_switching_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"os\": {\n"
+      "        \"type\": \"macosx\"\n"
+      "      },\n"
+      "      \"gpu_switching\": \"force_discrete\"\n"
+      "    },\n"
+      "    {\n"
+      "      \"id\": 2,\n"
+      "      \"os\": {\n"
+      "        \"type\": \"win\"\n"
+      "      },\n"
+      "      \"gpu_switching\": \"force_integrated\"\n"
+      "    },\n"
+      "    {\n"
+      "      \"id\": 3,\n"
+      "      \"os\": {\n"
+      "        \"type\": \"linux\"\n"
+      "      },\n"
+      "      \"gpu_switching\": \"automatic\"\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  Version os_version("10.6.4");
+
+  scoped_ptr<GpuBlacklist> blacklist(Create());
+  EXPECT_TRUE(blacklist->LoadGpuBlacklist(
+      gpu_switching_json, GpuBlacklist::kAllOs));
+  GpuSwitchingOption switching = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).gpu_switching;
+  EXPECT_EQ(switching, content::GPU_SWITCHING_FORCE_DISCRETE);
+  std::vector<uint32> entries;
+  bool disabled = false;
+  blacklist->GetDecisionEntries(entries, disabled);
+  EXPECT_EQ(entries.size(), 1u);
+  EXPECT_EQ(entries[0], 1u);
+
+  blacklist.reset(Create());
+  EXPECT_TRUE(blacklist->LoadGpuBlacklist(
+      gpu_switching_json, GpuBlacklist::kAllOs));
+  switching = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsWin, &os_version,
+      gpu_info()).gpu_switching;
+  EXPECT_EQ(switching, content::GPU_SWITCHING_FORCE_INTEGRATED);
+  blacklist->GetDecisionEntries(entries, disabled);
+  EXPECT_EQ(entries.size(), 1u);
+  EXPECT_EQ(entries[0], 2u);
+
+  blacklist.reset(Create());
+  EXPECT_TRUE(blacklist->LoadGpuBlacklist(
+      gpu_switching_json, GpuBlacklist::kAllOs));
+  switching = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsLinux, &os_version,
+      gpu_info()).gpu_switching;
+  EXPECT_EQ(switching, content::GPU_SWITCHING_AUTOMATIC);
+  blacklist->GetDecisionEntries(entries, disabled);
+  EXPECT_EQ(entries.size(), 1u);
+  EXPECT_EQ(entries[0], 3u);
+}
+
 TEST_F(GpuBlacklistTest, VideoDecode) {
   const std::string video_decode_json =
       "{\n"
@@ -977,8 +1086,8 @@ TEST_F(GpuBlacklistTest, VideoDecode) {
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       video_decode_json, GpuBlacklist::kAllOs));
-  GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
+  GpuFeatureType type = blacklist->MakeBlacklistDecision(
+      GpuBlacklist::kOsMacosx, &os_version,
+      gpu_info()).blacklisted_features;
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE);
 }
-
diff --git a/content/browser/gpu/gpu_data_manager_impl.cc b/content/browser/gpu/gpu_data_manager_impl.cc
index 3f5d40a..d549edf 100644
--- a/content/browser/gpu/gpu_data_manager_impl.cc
+++ b/content/browser/gpu/gpu_data_manager_impl.cc
@@ -32,6 +32,7 @@
 using content::BrowserThread;
 using content::GpuDataManagerObserver;
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 // static
 content::GpuDataManager* content::GpuDataManager::GetInstance() {
@@ -47,6 +48,7 @@ GpuDataManagerImpl::GpuDataManagerImpl()
     : complete_gpu_info_already_requested_(false),
       gpu_feature_type_(content::GPU_FEATURE_TYPE_UNKNOWN),
       preliminary_gpu_feature_type_(content::GPU_FEATURE_TYPE_UNKNOWN),
+      gpu_switching_(content::GPU_SWITCHING_AUTOMATIC),
       observer_list_(new GpuDataManagerObserverList),
       software_rendering_(false),
       card_blacklisted_(false),
@@ -127,11 +129,15 @@ void GpuDataManagerImpl::UpdateGpuInfo(const content::GPUInfo& gpu_info) {
   content::GetContentClient()->SetGpuInfo(gpu_info);
 
   if (gpu_blacklist_.get()) {
-    GpuFeatureType feature_type = gpu_blacklist_->DetermineGpuFeatureType(
-        GpuBlacklist::kOsAny, NULL, gpu_info);
-    if (update_histograms_)
-      gpu_util::UpdateStats(gpu_blacklist_.get(), feature_type);
-    UpdateBlacklistedFeatures(feature_type);
+    GpuBlacklist::Decision decision =
+        gpu_blacklist_->MakeBlacklistDecision(
+            GpuBlacklist::kOsAny, NULL, gpu_info);
+    if (update_histograms_) {
+      gpu_util::UpdateStats(gpu_blacklist_.get(),
+                            decision.blacklisted_features);
+    }
+    UpdateBlacklistedFeatures(decision.blacklisted_features);
+    gpu_switching_ = decision.gpu_switching;
   }
 
   {
@@ -199,6 +205,10 @@ GpuFeatureType GpuDataManagerImpl::GetBlacklistedFeatures() const {
   return gpu_feature_type_;
 }
 
+GpuSwitchingOption GpuDataManagerImpl::GetGpuSwitchingOption() const {
+  return gpu_switching_;
+}
+
 base::ListValue* GpuDataManagerImpl::GetBlacklistReasons() const {
   ListValue* reasons = new ListValue();
   if (gpu_blacklist_.get())
diff --git a/content/browser/gpu/gpu_data_manager_impl.h b/content/browser/gpu/gpu_data_manager_impl.h
index 26d57f5..98a9c27 100644
--- a/content/browser/gpu/gpu_data_manager_impl.h
+++ b/content/browser/gpu/gpu_data_manager_impl.h
@@ -38,6 +38,7 @@ class CONTENT_EXPORT GpuDataManagerImpl
       const std::string& gpu_blacklist_json,
       const content::GPUInfo& gpu_info) OVERRIDE;
   virtual content::GpuFeatureType GetBlacklistedFeatures() const OVERRIDE;
+  virtual content::GpuSwitchingOption GetGpuSwitchingOption() const OVERRIDE;
   virtual base::ListValue* GetBlacklistReasons() const OVERRIDE;
   virtual std::string GetBlacklistVersion() const OVERRIDE;
   virtual content::GPUInfo GetGPUInfo() const OVERRIDE;
@@ -120,6 +121,8 @@ class CONTENT_EXPORT GpuDataManagerImpl
   content::GpuFeatureType gpu_feature_type_;
   content::GpuFeatureType preliminary_gpu_feature_type_;
 
+  content::GpuSwitchingOption gpu_switching_;
+
   content::GPUInfo gpu_info_;
   mutable base::Lock gpu_info_lock_;
 
diff --git a/content/browser/gpu/gpu_util.cc b/content/browser/gpu/gpu_util.cc
index 267b2b4..7b53fee 100644
--- a/content/browser/gpu/gpu_util.cc
+++ b/content/browser/gpu/gpu_util.cc
@@ -15,6 +15,7 @@
 #include "content/public/common/content_switches.h"
 
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 namespace {
 
@@ -29,6 +30,11 @@ const char kGpuFeatureNameAcceleratedVideoDecode[] = "accelerated_video_decode";
 const char kGpuFeatureNameAll[] = "all";
 const char kGpuFeatureNameUnknown[] = "unknown";
 
+const char kGpuSwitchingNameAutomatic[] = "automatic";
+const char kGpuSwitchingNameForceIntegrated[] = "force_integrated";
+const char kGpuSwitchingNameForceDiscrete[] = "force_discrete";
+const char kGpuSwitchingNameUnknown[] = "unknown";
+
 enum GpuFeatureStatus {
     kGpuFeatureEnabled = 0,
     kGpuFeatureBlacklisted = 1,
@@ -87,21 +93,21 @@ namespace gpu_util {
 GpuFeatureType StringToGpuFeatureType(const std::string& feature_string) {
   if (feature_string == kGpuFeatureNameAccelerated2dCanvas)
     return content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
-  else if (feature_string == kGpuFeatureNameAcceleratedCompositing)
+  if (feature_string == kGpuFeatureNameAcceleratedCompositing)
     return content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING;
-  else if (feature_string == kGpuFeatureNameWebgl)
+  if (feature_string == kGpuFeatureNameWebgl)
     return content::GPU_FEATURE_TYPE_WEBGL;
-  else if (feature_string == kGpuFeatureNameMultisampling)
+  if (feature_string == kGpuFeatureNameMultisampling)
     return content::GPU_FEATURE_TYPE_MULTISAMPLING;
-  else if (feature_string == kGpuFeatureNameFlash3d)
+  if (feature_string == kGpuFeatureNameFlash3d)
     return content::GPU_FEATURE_TYPE_FLASH3D;
-  else if (feature_string == kGpuFeatureNameFlashStage3d)
+  if (feature_string == kGpuFeatureNameFlashStage3d)
     return content::GPU_FEATURE_TYPE_FLASH_STAGE3D;
-  else if (feature_string == kGpuFeatureNameTextureSharing)
+  if (feature_string == kGpuFeatureNameTextureSharing)
     return content::GPU_FEATURE_TYPE_TEXTURE_SHARING;
-  else if (feature_string == kGpuFeatureNameAcceleratedVideoDecode)
+  if (feature_string == kGpuFeatureNameAcceleratedVideoDecode)
     return content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE;
-  else if (feature_string == kGpuFeatureNameAll)
+  if (feature_string == kGpuFeatureNameAll)
     return content::GPU_FEATURE_TYPE_ALL;
   return content::GPU_FEATURE_TYPE_UNKNOWN;
 }
@@ -133,6 +139,17 @@ std::string GpuFeatureTypeToString(GpuFeatureType type) {
   return JoinString(matches, ',');
 }
 
+GpuSwitchingOption StringToGpuSwitchingOption(
+    const std::string& switching_string) {
+  if (switching_string == kGpuSwitchingNameAutomatic)
+    return content::GPU_SWITCHING_AUTOMATIC;
+  if (switching_string == kGpuSwitchingNameForceIntegrated)
+    return content::GPU_SWITCHING_FORCE_INTEGRATED;
+  if (switching_string == kGpuSwitchingNameForceDiscrete)
+    return content::GPU_SWITCHING_FORCE_DISCRETE;
+  return content::GPU_SWITCHING_UNKNOWN;
+}
+
 void UpdateStats(const GpuBlacklist* blacklist,
                  uint32 blacklisted_features) {
   uint32 max_entry_id = blacklist->max_entry_id();
@@ -148,8 +165,7 @@ void UpdateStats(const GpuBlacklist* blacklist,
         0, max_entry_id + 1);
   } else {
     std::vector<uint32> flag_entries;
-    blacklist->GetGpuFeatureTypeEntries(
-        content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
+    blacklist->GetDecisionEntries(flag_entries, disabled);
     DCHECK_GT(flag_entries.size(), 0u);
     for (size_t i = 0; i < flag_entries.size(); ++i) {
       UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
@@ -161,8 +177,7 @@ void UpdateStats(const GpuBlacklist* blacklist,
   // us to understand the impact of an entry before enable it.
   std::vector<uint32> flag_disabled_entries;
   disabled = true;
-  blacklist->GetGpuFeatureTypeEntries(
-      content::GPU_FEATURE_TYPE_ALL, flag_disabled_entries, disabled);
+  blacklist->GetDecisionEntries(flag_disabled_entries, disabled);
   for (size_t i = 0; i < flag_disabled_entries.size(); ++i) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerDisabledEntry",
         flag_disabled_entries[i], max_entry_id + 1);
diff --git a/content/browser/gpu/gpu_util.h b/content/browser/gpu/gpu_util.h
index 7732dce..98c8197 100644
--- a/content/browser/gpu/gpu_util.h
+++ b/content/browser/gpu/gpu_util.h
@@ -27,6 +27,11 @@ CONTENT_EXPORT content::GpuFeatureType StringToGpuFeatureType(
 CONTENT_EXPORT std::string GpuFeatureTypeToString(
     content::GpuFeatureType feature);
 
+// Maps string to GpuSwitchingOption; returns GPU_SWITCHING_UNKNOWN if an
+// unknown name is input (case-sensitive).
+CONTENT_EXPORT content::GpuSwitchingOption StringToGpuSwitchingOption(
+    const std::string& switching_string);
+
 // Send UMA histograms about the enabled features.
 CONTENT_EXPORT void UpdateStats(
     const GpuBlacklist* blacklist, uint32 blacklisted_features);
diff --git a/content/browser/gpu/gpu_util_unittest.cc b/content/browser/gpu/gpu_util_unittest.cc
index b92b5f8..b13b7a0 100644
--- a/content/browser/gpu/gpu_util_unittest.cc
+++ b/content/browser/gpu/gpu_util_unittest.cc
@@ -85,3 +85,16 @@ TEST(GpuUtilsTest, GpuFeatureTypeToString) {
               content::GPU_FEATURE_TYPE_ALL)).c_str(),
       "all");
 }
+
+TEST(GpuUtilsTest, GpuSwitchingOptionFromString) {
+  // Test StringToGpuSwitchingOption.
+  EXPECT_EQ(gpu_util::StringToGpuSwitchingOption("automatic"),
+            content::GPU_SWITCHING_AUTOMATIC);
+  EXPECT_EQ(gpu_util::StringToGpuSwitchingOption("force_discrete"),
+            content::GPU_SWITCHING_FORCE_DISCRETE);
+  EXPECT_EQ(gpu_util::StringToGpuSwitchingOption("force_integrated"),
+            content::GPU_SWITCHING_FORCE_INTEGRATED);
+  EXPECT_EQ(gpu_util::StringToGpuSwitchingOption("xxx"),
+            content::GPU_SWITCHING_UNKNOWN);
+}
+
diff --git a/content/public/browser/gpu_data_manager.h b/content/public/browser/gpu_data_manager.h
index 0a84870..e8a5ae6 100644
--- a/content/public/browser/gpu_data_manager.h
+++ b/content/public/browser/gpu_data_manager.h
@@ -42,6 +42,8 @@ class GpuDataManager {
 
   virtual GpuFeatureType GetBlacklistedFeatures() const = 0;
 
+  virtual GpuSwitchingOption GetGpuSwitchingOption() const = 0;
+
   // Returns the reasons for the latest run of blacklisting decisions.
   // For the structure of returned value, see documentation for
   // GpuBlacklist::GetBlacklistedReasons().
diff --git a/content/public/common/gpu_feature_type.h b/content/public/common/gpu_feature_type.h
index 5900ec0..e494be4 100644
--- a/content/public/common/gpu_feature_type.h
+++ b/content/public/common/gpu_feature_type.h
@@ -31,6 +31,13 @@ enum GpuFeatureType {
   GPU_FEATURE_TYPE_UNKNOWN = 0
 };
 
+enum GpuSwitchingOption {
+  GPU_SWITCHING_AUTOMATIC,
+  GPU_SWITCHING_FORCE_INTEGRATED,
+  GPU_SWITCHING_FORCE_DISCRETE,
+  GPU_SWITCHING_UNKNOWN
+};
+
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_COMMON_GPU_FEATURE_TYPE_H_