Add capability for GPU blacklist to manage GPU switching.

content/browser/gpu/gpu_blacklist.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/gpu/gpu_blacklist.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/version.h"
 #include "content/browser/gpu/gpu_util.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/gpu_info.h"
 
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 namespace {
 
 // Encode a date as Version, where [0] is year, [1] is month, and [2] is day.
 void GetDateFromString(const std::string& date_string, Version* version) {
   // TODO(zmo): verify if in Windows registry, driver dates are always in the
   // format of "mm-dd-yyyy".
   std::vector<std::string> pieces;
   base::SplitString(date_string, '-', &pieces);
   if (pieces.size() != 3) {
@@ skipping 516 matching lines @@
     perf_overall_value->GetString("value2", &float_value2);
     if (!entry->SetPerfOverallInfo(op, float_value, float_value2)) {
       LOG(WARNING) << "Malformed perf_overall entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   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) {
     const ListValue* exception_list_value = NULL;
     if (value->GetList("exceptions", &exception_list_value)) {
       for (size_t i = 0; i < exception_list_value->GetSize(); ++i) {
         const DictionaryValue* exception_value = NULL;
         if (!exception_list_value->GetDictionary(i, &exception_value)) {
           LOG(WARNING) << "Malformed exceptions entry " << entry->id();
           return NULL;
@@ skipping 26 matching lines @@
   }
   return entry;
 }
 
 GpuBlacklist::GpuBlacklistEntry::GpuBlacklistEntry()
     : id_(0),
       disabled_(false),
       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) {
 }
 
 GpuBlacklist::GpuBlacklistEntry::~GpuBlacklistEntry() { }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetId(uint32 id) {
   if (id != 0) {
     id_ = id;
     return true;
@@ skipping 140 matching lines @@
       case content::GPU_FEATURE_TYPE_TEXTURE_SHARING:
       case content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE:
       case content::GPU_FEATURE_TYPE_ALL:
         feature_type |= type;
         break;
       case content::GPU_FEATURE_TYPE_UNKNOWN:
         contains_unknown_features_ = true;
         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;
 }
 
 void GpuBlacklist::GpuBlacklistEntry::AddException(
     ScopedGpuBlacklistEntry exception) {
   exceptions_.push_back(exception);
 }
 
 // static
 GpuBlacklist::GpuBlacklistEntry::MultiGpuStyle
@@ skipping 113 matching lines @@
 
 uint32 GpuBlacklist::GpuBlacklistEntry::id() const {
   return id_;
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
   return disabled_;
 }
 
 GpuFeatureType GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureType() const {
-  return feature_type_;
+  return decision_.blacklisted_features;
+}
+
+GpuSwitchingOption
+GpuBlacklist::GpuBlacklistEntry::GetGpuSwitchingOption() const {
+  return decision_.gpu_switching;
 }
 
 GpuBlacklist::GpuBlacklist()
     : max_entry_id_(0),
       contains_unknown_fields_(false) {
 }
 
 GpuBlacklist::~GpuBlacklist() {
   Clear();
 }
@@ skipping 74 matching lines @@
     OsType entry_os = entries[i]->GetOsType();
     if (os_filter == GpuBlacklist::kAllOs ||
         entry_os == kOsAny || entry_os == my_os)
       blacklist_.push_back(entries[i]);
   }
   max_entry_id_ = max_entry_id;
   contains_unknown_fields_ = contains_unknown_fields;
   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();
   scoped_ptr<Version> my_os_version;
   if (os_version == NULL) {
     std::string version_string = base::SysInfo::OperatingSystemVersion();
     size_t pos = version_string.find_first_not_of("0123456789.");
     if (pos != std::string::npos)
       version_string = version_string.substr(0, pos);
     my_os_version.reset(new Version(version_string));
     os_version = my_os_version.get();
   }
   DCHECK(os_version != NULL);
 
   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());
   }
 }
 
 void GpuBlacklist::GetBlacklistReasons(ListValue* problem_list) const {
   DCHECK(problem_list);
   for (size_t i = 0; i < active_entries_.size(); ++i) {
     GpuBlacklistEntry* entry = active_entries_[i];
     if (entry->disabled())
       continue;
@@ skipping 96 matching lines @@
   if (op == ">")
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }