Make it possible to blacklist gpu's based on the Windows experience index.

content/browser/gpu/gpu_blacklist.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
@@ skipping 20 matching lines @@
     date_as_version_string += pieces[i];
   }
   return Version::GetVersionFromString(date_as_version_string);
 }
 
 }  // namespace anonymous
 
 GpuBlacklist::VersionInfo::VersionInfo(const std::string& version_op,
                                        const std::string& version_string,
                                        const std::string& version_string2) {
-  op_ = StringToOp(version_op);
+  op_ = StringToNumericOp(version_op);
   if (op_ == kUnknown || op_ == kAny)
     return;
   version_.reset(Version::GetVersionFromString(version_string));
   if (version_.get() == NULL) {
     op_ = kUnknown;
     return;
   }
   if (op_ == kBetween) {
     version2_.reset(Version::GetVersionFromString(version_string2));
     if (version2_.get() == NULL)
@@ skipping 35 matching lines @@
   // op_ == kBetween
   if (relation < 0)
     return false;
   return version.CompareTo(*version2_) <= 0;
 }
 
 bool GpuBlacklist::VersionInfo::IsValid() const {
   return op_ != kUnknown;
 }
 
-GpuBlacklist::VersionInfo::Op GpuBlacklist::VersionInfo::StringToOp(
-    const std::string& version_op) {
-  if (version_op == "=")
-    return kEQ;
-  else if (version_op == "<")
-    return kLT;
-  else if (version_op == "<=")
-    return kLE;
-  else if (version_op == ">")
-    return kGT;
-  else if (version_op == ">=")
-    return kGE;
-  else if (version_op == "any")
-    return kAny;
-  else if (version_op == "between")
-    return kBetween;
-  return kUnknown;
-}
-
 GpuBlacklist::OsInfo::OsInfo(const std::string& os,
                              const std::string& version_op,
                              const std::string& version_string,
                              const std::string& version_string2) {
   type_ = StringToOsType(os);
   if (type_ != kOsUnknown) {
     version_info_.reset(
         new VersionInfo(version_op, version_string, version_string2));
   }
 }
@@ skipping 64 matching lines @@
     return kEQ;
   else if (string_op == "contains")
     return kContains;
   else if (string_op == "beginwith")
     return kBeginWith;
   else if (string_op == "endwith")
     return kEndWith;
   return kUnknown;
 }
 
+GpuBlacklist::FloatInfo::FloatInfo(const std::string& float_op,
+                                   const std::string& float_value,
+                                   const std::string& float_value2)
+    : op_(kUnknown),
+      value_(0.f),
+      value2_(0.f) {
+  double dvalue = 0;
+  if (!base::StringToDouble(float_value, &dvalue)) {
+    op_ = kUnknown;
+    return;
+  }
+  value_ = static_cast<float>(dvalue);
+  op_ = StringToNumericOp(float_op);
+  if (op_ == kBetween) {
+    if (!base::StringToDouble(float_value2, &dvalue)) {
+      op_ = kUnknown;
+      return;
+    }
+    value2_ = static_cast<float>(dvalue);
+  }
+}
+
+bool GpuBlacklist::FloatInfo::Contains(float value) const {
+  if (op_ == kUnknown)
+    return false;
+  if (op_ == kAny)
+    return true;
+  if (op_ == kEQ)
+    return (value == value_);
+  if (op_ == kLT)
+    return (value < value_);
+  if (op_ == kLE)
+    return (value <= value_);
+  if (op_ == kGT)
+    return (value > value_);
+  if (op_ == kGE)
+    return (value >= value_);
+  DCHECK(op_ == kBetween);
+  return ((value_ <= value && value <= value2_) ||
+          (value2_ <= value && value <= value_));
+}
+
+bool GpuBlacklist::FloatInfo::IsValid() const {
+  return op_ != kUnknown;
+}
+
 // static
 GpuBlacklist::ScopedGpuBlacklistEntry
 GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
     DictionaryValue* value, bool top_level) {
   DCHECK(value);
   ScopedGpuBlacklistEntry entry(new GpuBlacklistEntry());
 
   size_t dictionary_entry_count = 0;
 
   if (top_level) {
@@ skipping 155 matching lines @@
     std::string renderer_value;
     gl_renderer_value->GetString("op", &renderer_op);
     gl_renderer_value->GetString("value", &renderer_value);
     if (!entry->SetGLRendererInfo(renderer_op, renderer_value)) {
       LOG(WARNING) << "Malformed gl_renderer entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  DictionaryValue* perf_graphics_value = NULL;
+  if (value->GetDictionary("perf_graphics", &perf_graphics_value)) {
+    std::string op;
+    std::string float_value;
+    std::string float_value2;
+    perf_graphics_value->GetString("op", &op);
+    perf_graphics_value->GetString("value", &float_value);
+    perf_graphics_value->GetString("value2", &float_value2);
+    if (!entry->SetPerfGraphicsInfo(op, float_value, float_value2)) {
+      LOG(WARNING) << "Malformed perf_graphics entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
+  DictionaryValue* perf_gaming_value = NULL;
+  if (value->GetDictionary("perf_gaming", &perf_gaming_value)) {
+    std::string op;
+    std::string float_value;
+    std::string float_value2;
+    perf_gaming_value->GetString("op", &op);
+    perf_gaming_value->GetString("value", &float_value);
+    perf_gaming_value->GetString("value2", &float_value2);
+    if (!entry->SetPerfGamingInfo(op, float_value, float_value2)) {
+      LOG(WARNING) << "Malformed perf_gaming entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
+  DictionaryValue* perf_overall_value = NULL;
+  if (value->GetDictionary("perf_overall", &perf_overall_value)) {
+    std::string op;
+    std::string float_value;
+    std::string float_value2;
+    perf_overall_value->GetString("op", &op);
+    perf_overall_value->GetString("value", &float_value);
+    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) {
     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)) {
@@ skipping 130 matching lines @@
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetGLRendererInfo(
     const std::string& renderer_op,
     const std::string& renderer_value) {
   gl_renderer_info_.reset(
       new StringInfo(renderer_op, renderer_value));
   return gl_renderer_info_->IsValid();
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::SetPerfGraphicsInfo(
+    const std::string& op,
+    const std::string& float_string,
+    const std::string& float_string2) {
+  perf_graphics_info_.reset(
+      new FloatInfo(op, float_string, float_string2));
+  return perf_graphics_info_->IsValid();
+}
+
+bool GpuBlacklist::GpuBlacklistEntry::SetPerfGamingInfo(
+    const std::string& op,
+    const std::string& float_string,
+    const std::string& float_string2) {
+  perf_gaming_info_.reset(
+      new FloatInfo(op, float_string, float_string2));
+  return perf_gaming_info_->IsValid();
+}
+
+bool GpuBlacklist::GpuBlacklistEntry::SetPerfOverallInfo(
+    const std::string& op,
+    const std::string& float_string,
+    const std::string& float_string2) {
+  perf_overall_info_.reset(
+      new FloatInfo(op, float_string, float_string2));
+  return perf_overall_info_->IsValid();
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::SetBlacklistedFeatures(
     const std::vector<std::string>& blacklisted_features) {
   size_t size = blacklisted_features.size();
   if (size == 0)
     return false;
   uint32 flags = 0;
   for (size_t i = 0; i < size; ++i) {
     GpuFeatureFlags::GpuFeatureType type =
         GpuFeatureFlags::StringToGpuFeatureType(blacklisted_features[i]);
     switch (type) {
@@ skipping 53 matching lines @@
     if (driver_date.get() == NULL ||
         !driver_date_info_->Contains(*driver_date))
       return false;
   }
   if (gl_vendor_info_.get() != NULL &&
       !gl_vendor_info_->Contains(gpu_info.gl_vendor))
     return false;
   if (gl_renderer_info_.get() != NULL &&
       !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;
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->Contains(os_type, os_version, gpu_info))
       return false;
   }
   return true;
 }
 
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
     return kOsAny;
@@ skipping 246 matching lines @@
     return kUnsupported;
   }
   return kSupported;
 }
 
 void GpuBlacklist::SetBrowserVersion(const std::string& version_string) {
   browser_version_.reset(Version::GetVersionFromString(version_string));
   DCHECK(browser_version_.get() != NULL);
 }
 
+// static
+GpuBlacklist::NumericOp GpuBlacklist::StringToNumericOp(
+    const std::string& op) {
+  if (op == "=")
+    return kEQ;
+  if (op == "<")
+    return kLT;
+  if (op == "<=")
+    return kLE;
+  if (op == ">")
+    return kGT;
+  if (op == ">=")
+    return kGE;
+  if (op == "any")
+    return kAny;
+  if (op == "between")
+    return kBetween;
+  return kUnknown;
+}
+