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 52 matching lines @@
     valid = false;
   }
   if (valid)
     return lexical;
   return numerical;
 }
 
 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)
+  if (vendor_id_ != 0 && vendor_id_ != gpu_info.gpu.vendor_id &&
+      multi_gpu_category_ == kMultiGpuCategoryPrimary)

[Ken Russell (switch to Gerrit), 2012/07/27 01:32:52]

This logic and that below is getting really difficult to follow. It isn't
obvious to me that it's correct any more. In particular, I'm not sure that if
the multi_gpu_category_ is Any, and the device ID matches but the vendor
doesn't, that it does the right thing. Sorry, but I think this needs to be
rewritten at this point.

It would be really nice if the secondary GPUs weren't in a separate list, so you
could just iterate down all the GPUs uniformly. The first GPU in the list would
implicitly be the primary one. That should simplify the logic considerably.
Please try that.

     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) {
+      if ((multi_gpu_category_ == kMultiGpuCategoryPrimary ||
+           multi_gpu_category_ == kMultiGpuCategoryAny) &&
+          device_id_list_[i] == gpu_info.gpu.device_id) {
         found = true;
         break;
       }
+      if (multi_gpu_category_ == kMultiGpuCategorySecondary ||
+          multi_gpu_category_ == kMultiGpuCategoryAny) {
+        for (size_t j = 0; j < gpu_info.secondary_gpus.size(); ++j) {
+          if (vendor_id_ == gpu_info.secondary_gpus[j].vendor_id &&
+              device_id_list_[i] == gpu_info.secondary_gpus[j].device_id) {
+            found = true;
+            break;
+          }
+        }
+        if (found)
+          break;
+      }
     }
     if (!found)
       return false;
   }
   switch (multi_gpu_style_) {
     case kMultiGpuStyleOptimus:
       if (!gpu_info.optimus)
         return false;
       break;
     case kMultiGpuStyleAMDSwitchable:
@@ skipping 326 matching lines @@
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }