Figure out whether we have enough information to make the final GPU blacklisting decision.

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/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
@@ skipping 995 matching lines @@
         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:
+    case kMultiGpuCategoryNone:
       break;
   }
   switch (multi_gpu_style_) {
     case kMultiGpuStyleOptimus:
       if (!gpu_info.optimus)
         return false;
       break;
     case kMultiGpuStyleAMDSwitchable:
       if (!gpu_info.amd_switchable)
         return false;
       break;
-    default:
+    case kMultiGpuStyleNone:
       break;
   }
-  if (driver_vendor_info_.get() != NULL &&
+  if (driver_vendor_info_.get() != NULL && !gpu_info.driver_vendor.empty() &&
       !driver_vendor_info_->Contains(gpu_info.driver_vendor))
     return false;
-  if (driver_version_info_.get() != NULL) {
+  if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
     std::string processed_driver_version;
     if (driver_version_info_->IsLexical())
       processed_driver_version = NumericalToLexical(gpu_info.driver_version);
     else
       processed_driver_version = gpu_info.driver_version;
     Version driver_version(processed_driver_version);
     if (!driver_version.IsValid() ||
         !driver_version_info_->Contains(driver_version))
       return false;
   }
-  if (driver_date_info_.get() != NULL) {
+  if (driver_date_info_.get() != NULL && !gpu_info.driver_date.empty()) {
     Version driver_date;
     GetDateFromString(gpu_info.driver_date, &driver_date);
     if (!driver_date.IsValid() || !driver_date_info_->Contains(driver_date))
       return false;
   }
-  if (gl_vendor_info_.get() != NULL &&
+  if (gl_vendor_info_.get() != NULL && !gpu_info.gl_vendor.empty() &&
       !gl_vendor_info_->Contains(gpu_info.gl_vendor))
     return false;
-  if (gl_renderer_info_.get() != NULL &&
+  if (gl_renderer_info_.get() != NULL && !gpu_info.gl_renderer.empty() &&
       !gl_renderer_info_->Contains(gpu_info.gl_renderer))
     return false;
   if (perf_graphics_info_.get() != NULL &&
       (gpu_info.performance_stats.graphics == 0.0 ||
        !perf_graphics_info_->Contains(gpu_info.performance_stats.graphics)))
     return false;
   if (perf_gaming_info_.get() != NULL &&
       (gpu_info.performance_stats.gaming == 0.0 ||
        !perf_gaming_info_->Contains(gpu_info.performance_stats.gaming)))
     return false;
   if (perf_overall_info_.get() != NULL &&
       (gpu_info.performance_stats.overall == 0.0 ||
        !perf_overall_info_->Contains(gpu_info.performance_stats.overall)))
     return false;
   if (machine_model_info_.get() != NULL &&
       !machine_model_info_->Contains(machine_model_name, machine_model_version))
     return false;
   if (gpu_count_info_.get() != NULL &&
       !gpu_count_info_->Contains(gpu_info.secondary_gpus.size() + 1))
     return false;
   if (cpu_brand_.get() != NULL) {
     base::CPU cpu_info;
     if (!cpu_brand_->Contains(cpu_info.cpu_brand()))
       return false;
   }
 
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->Contains(os_type, os_version, machine_model_name,
-                                 machine_model_version, gpu_info))
+                                 machine_model_version, gpu_info) &&
+        !exceptions_[i]->NeedsMoreInfo(gpu_info))
       return false;
   }
   return true;
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::NeedsMoreInfo(
+    const content::GPUInfo& gpu_info) const {
+  // We only check for missing info that might be collected with a gl context.
+  // If certain info is missing due to some error, say, we fail to collect
+  // vendor_id/device_id, then even if we launch GPU process and create a gl
+  // context, we won't gather such missing info, so we still return false.
+  if (driver_vendor_info_.get() && gpu_info.driver_vendor.empty())
+    return true;
+  if (driver_version_info_.get() && gpu_info.driver_version.empty())
+    return true;
+  if (gl_vendor_info_.get() && gpu_info.gl_vendor.empty())
+    return true;
+  if (gl_renderer_info_.get() && gpu_info.gl_renderer.empty())
+    return true;
+  for (size_t i = 0; i < exceptions_.size(); ++i) {
+    if (exceptions_[i]->NeedsMoreInfo(gpu_info))
+      return true;
+  }
+  return false;
+}
+
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
     return kOsAny;
   return os_info_->type();
 }
 
 uint32 GpuBlacklist::GpuBlacklistEntry::id() const {
   return id_;
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
   return disabled_;
 }
 
 GpuFeatureType GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureType() const {
   return decision_.blacklisted_features;
 }
 
 GpuSwitchingOption
 GpuBlacklist::GpuBlacklistEntry::GetGpuSwitchingOption() const {
   return decision_.gpu_switching;
 }
 
 GpuBlacklist::GpuBlacklist()
     : max_entry_id_(0),
-      contains_unknown_fields_(false) {
+      contains_unknown_fields_(false),
+      needs_more_info_(false) {
 }
 
 GpuBlacklist::~GpuBlacklist() {
   Clear();
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const std::string& json_context, GpuBlacklist::OsFilter os_filter) {
   const std::string browser_version_string = "0";
   return LoadGpuBlacklist(browser_version_string, json_context, os_filter);
@@ skipping 77 matching lines @@
 }
 
 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_OPTION_UNKNOWN;
 
+  needs_more_info_ = false;
+  int possible_type = 0;
+  GpuSwitchingOption possible_switching = content::GPU_SWITCHING_OPTION_UNKNOWN;
+
   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);
 
   CollectCurrentMachineModelInfo();
   for (size_t i = 0; i < blacklist_.size(); ++i) {
     if (blacklist_[i]->Contains(os, *os_version, current_machine_model_name_,
                                 *current_machine_model_version_, gpu_info)) {
       if (!blacklist_[i]->disabled()) {
-        type |= blacklist_[i]->GetGpuFeatureType();
+        bool not_final = blacklist_[i]->NeedsMoreInfo(gpu_info);
+        if (not_final)
+          possible_type |= blacklist_[i]->GetGpuFeatureType();
+        else
+          type |= blacklist_[i]->GetGpuFeatureType();
         if (blacklist_[i]->GetGpuSwitchingOption() !=
-                content::GPU_SWITCHING_OPTION_UNKNOWN)
-          switching = blacklist_[i]->GetGpuSwitchingOption();
+                content::GPU_SWITCHING_OPTION_UNKNOWN) {
+          if (not_final)
+            possible_switching = blacklist_[i]->GetGpuSwitchingOption();
+          else
+            switching = blacklist_[i]->GetGpuSwitchingOption();
+        }
       }
       active_entries_.push_back(blacklist_[i]);
     }
   }
+
+  if ((possible_type != 0 && (possible_type | type) != type) ||
+      (possible_switching != content::GPU_SWITCHING_OPTION_UNKNOWN &&
+       switching == content::GPU_SWITCHING_OPTION_UNKNOWN))
+    needs_more_info_ = true;
+
   Decision decision;
   decision.blacklisted_features = static_cast<GpuFeatureType>(type);
   decision.gpu_switching = switching;
   return decision;
 }
 
 void GpuBlacklist::GetDecisionEntries(
     std::vector<uint32>& entry_ids, bool disabled) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
@@ skipping 128 matching lines @@
   if (op == ">")
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }