Enhance GPU blacklist so we can also blacklist GPUs other than the primary one.

chrome/browser/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 "chrome/browser/gpu_blacklist.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 49 matching lines @@
       lexical += numerical[i];
     }
   } else {
     valid = false;
   }
   if (valid)
     return lexical;
   return numerical;
 }
 
+bool GpuUnmatched(uint32 vendor_id, const std::vector<uint32>& device_id_list,
+                  const content::GPUInfo::GPUDevice& gpu) {
+  if (vendor_id == 0)
+    return false;
+  if (vendor_id != gpu.vendor_id)
+    return true;
+  bool device_specified = false;
+  for (size_t i = 0; i < device_id_list.size(); ++i) {
+    if (device_id_list[i] == 0)
+      continue;
+    if (device_id_list[i] == gpu.device_id)
+      return false;
+    device_specified = true;
+  }
+  return device_specified;
+}
+
 const char kMultiGpuStyleStringAMDSwitchable[] = "amd_switchable";
 const char kMultiGpuStyleStringOptimus[] = "optimus";
 
+const char kMultiGpuCategoryStringPrimary[] = "primary";
+const char kMultiGpuCategoryStringSecondary[] = "secondary";
+const char kMultiGpuCategoryStringAny[] = "any";
+
 const char kVersionStyleStringNumerical[] = "numerical";
 const char kVersionStyleStringLexical[] = "lexical";
 
 }  // namespace anonymous
 
 GpuBlacklist::VersionInfo::VersionInfo(
     const std::string& version_op,
     const std::string& version_style,
     const std::string& version_string,
     const std::string& version_string2)
@@ skipping 314 matching lines @@
 
   std::string multi_gpu_style;
   if (value->GetString("multi_gpu_style", &multi_gpu_style)) {
     if (!entry->SetMultiGpuStyle(multi_gpu_style)) {
       LOG(WARNING) << "Malformed multi_gpu_style entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  std::string multi_gpu_category;
+  if (value->GetString("multi_gpu_category", &multi_gpu_category)) {
+    if (!entry->SetMultiGpuCategory(multi_gpu_category)) {
+      LOG(WARNING) << "Malformed multi_gpu_category entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
   DictionaryValue* driver_vendor_value = NULL;
   if (value->GetDictionary("driver_vendor", &driver_vendor_value)) {
     std::string vendor_op;
     std::string vendor_value;
     driver_vendor_value->GetString("op", &vendor_op);
     driver_vendor_value->GetString("value", &vendor_value);
     if (!entry->SetDriverVendorInfo(vendor_op, vendor_value)) {
       LOG(WARNING) << "Malformed driver_vendor entry " << entry->id();
       return NULL;
     }
@@ skipping 166 matching lines @@
     entry->contains_unknown_fields_ = true;
   }
   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) {
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetId(uint32 id) {
   if (id != 0) {
     id_ = id;
     return true;
   }
@@ skipping 33 matching lines @@
 
 bool GpuBlacklist::GpuBlacklistEntry::SetMultiGpuStyle(
     const std::string& multi_gpu_style_string) {
   MultiGpuStyle style = StringToMultiGpuStyle(multi_gpu_style_string);
   if (style == kMultiGpuStyleNone)
     return false;
   multi_gpu_style_ = style;
   return true;
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::SetMultiGpuCategory(
+    const std::string& multi_gpu_category_string) {
+  MultiGpuCategory category =
+      StringToMultiGpuCategory(multi_gpu_category_string);
+  if (category == kMultiGpuCategoryNone)
+    return false;
+  multi_gpu_category_ = category;
+  return true;
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::SetDriverVendorInfo(
     const std::string& vendor_op,
     const std::string& vendor_value) {
   driver_vendor_info_.reset(
       new StringInfo(vendor_op, vendor_value));
   return driver_vendor_info_->IsValid();
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetDriverVersionInfo(
     const std::string& version_op,
@@ skipping 95 matching lines @@
 GpuBlacklist::GpuBlacklistEntry::MultiGpuStyle
 GpuBlacklist::GpuBlacklistEntry::StringToMultiGpuStyle(
     const std::string& style) {
   if (style == kMultiGpuStyleStringOptimus)
     return kMultiGpuStyleOptimus;
   if (style == kMultiGpuStyleStringAMDSwitchable)
     return kMultiGpuStyleAMDSwitchable;
   return kMultiGpuStyleNone;
 }
 
+// static
+GpuBlacklist::GpuBlacklistEntry::MultiGpuCategory
+GpuBlacklist::GpuBlacklistEntry::StringToMultiGpuCategory(
+    const std::string& category) {
+  if (category == kMultiGpuCategoryStringPrimary)
+    return kMultiGpuCategoryPrimary;
+  if (category == kMultiGpuCategoryStringSecondary)
+    return kMultiGpuCategorySecondary;
+  if (category == kMultiGpuCategoryStringAny)
+    return kMultiGpuCategoryAny;
+  return kMultiGpuCategoryNone;
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::Contains(
     OsType os_type, const Version& os_version,
     const content::GPUInfo& gpu_info) const {
   DCHECK(os_type != kOsAny);
   if (os_info_.get() != NULL && !os_info_->Contains(os_type, os_version))
     return false;
-  if (vendor_id_ != 0 && vendor_id_ != gpu_info.gpu.vendor_id)
-    return false;
-  if (device_id_list_.size() > 0) {
-    bool found = false;
-    for (size_t i = 0; i < device_id_list_.size(); ++i) {
-      if (device_id_list_[i] == gpu_info.gpu.device_id) {
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-      return false;
+  bool is_not_primary_gpu =
+      GpuUnmatched(vendor_id_, device_id_list_, gpu_info.gpu);
+  bool is_not_secondary_gpu = true;
+  for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
+    is_not_secondary_gpu = is_not_secondary_gpu &&
+        GpuUnmatched(vendor_id_, device_id_list_, gpu_info.secondary_gpus[i]);
+  }
+  switch (multi_gpu_category_) {
+    case kMultiGpuCategoryPrimary:
+      if (is_not_primary_gpu)
+        return false;
+      break;
+    case kMultiGpuCategorySecondary:
+      if (is_not_secondary_gpu)
+        return false;
+      break;
+    case kMultiGpuCategoryAny:
+      if (is_not_primary_gpu && is_not_secondary_gpu)
+        return false;
+      break;
+    default:
+      break;
   }
   switch (multi_gpu_style_) {
     case kMultiGpuStyleOptimus:
       if (!gpu_info.optimus)
         return false;
       break;
     case kMultiGpuStyleAMDSwitchable:
       if (!gpu_info.amd_switchable)
         return false;
       break;
@@ skipping 323 matching lines @@
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }