Index: chrome/browser/gpu_blacklist.cc |
=================================================================== |
--- chrome/browser/gpu_blacklist.cc (revision 155054) |
+++ chrome/browser/gpu_blacklist.cc (working copy) |
@@ -1,1188 +0,0 @@ |
-// 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" |
-#include "base/string_split.h" |
-#include "base/string_util.h" |
-#include "base/sys_info.h" |
-#include "base/version.h" |
-#include "chrome/browser/gpu_util.h" |
-#include "chrome/common/chrome_version_info.h" |
-#include "content/public/browser/gpu_data_manager.h" |
-#include "content/public/common/content_switches.h" |
-#include "content/public/common/gpu_info.h" |
- |
-using content::GpuDataManager; |
-using content::GpuFeatureType; |
- |
-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) { |
- *version = Version(); |
- return; |
- } |
- std::string date_as_version_string = pieces[2]; |
- for (size_t i = 0; i < 2; ++i) { |
- date_as_version_string += "."; |
- date_as_version_string += pieces[i]; |
- } |
- *version = Version(date_as_version_string); |
-} |
- |
-// We assume the input format is major.minor, and we treat major version |
-// as numerical and minor as lexical. |
-// Otherwise we simply return the original string. |
-// For example, if input numerical is 8.103, returned lexical is 8.1.0.3. |
-std::string NumericalToLexical(const std::string& numerical) { |
- std::string lexical; |
- bool valid = true; |
- size_t pos = numerical.find_first_of('.'); |
- if (pos != std::string::npos && pos + 1 < numerical.length()) { |
- lexical = numerical.substr(0, pos); |
- for (size_t i = pos + 1; i < numerical.length(); ++i) { |
- if (!IsAsciiDigit(numerical[i])) { |
- valid = false; |
- break; |
- } |
- lexical += '.'; |
- 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) |
- : version_style_(kVersionStyleNumerical) { |
- op_ = StringToNumericOp(version_op); |
- if (op_ == kUnknown || op_ == kAny) |
- return; |
- version_style_ = StringToVersionStyle(version_style); |
- std::string processed_version_string, processed_version_string2; |
- if (version_style_ == kVersionStyleLexical) { |
- processed_version_string = NumericalToLexical(version_string); |
- processed_version_string2 = NumericalToLexical(version_string2); |
- } else { |
- processed_version_string = version_string; |
- processed_version_string2 = version_string2; |
- } |
- version_.reset(new Version(processed_version_string)); |
- if (!version_->IsValid()) { |
- op_ = kUnknown; |
- return; |
- } |
- if (op_ == kBetween) { |
- version2_.reset(new Version(processed_version_string2)); |
- if (!version2_->IsValid()) |
- op_ = kUnknown; |
- } |
-} |
- |
-GpuBlacklist::VersionInfo::~VersionInfo() { |
-} |
- |
-bool GpuBlacklist::VersionInfo::Contains(const Version& version) const { |
- if (op_ == kUnknown) |
- return false; |
- if (op_ == kAny) |
- return true; |
- if (op_ == kEQ) { |
- // Handles cases where 10.6 is considered as containing 10.6.*. |
- const std::vector<uint16>& components_reference = version_->components(); |
- const std::vector<uint16>& components = version.components(); |
- for (size_t i = 0; i < components_reference.size(); ++i) { |
- if (i >= components.size() && components_reference[i] != 0) |
- return false; |
- if (components[i] != components_reference[i]) |
- return false; |
- } |
- return true; |
- } |
- int relation = version.CompareTo(*version_); |
- if (op_ == kEQ) |
- return (relation == 0); |
- else if (op_ == kLT) |
- return (relation < 0); |
- else if (op_ == kLE) |
- return (relation <= 0); |
- else if (op_ == kGT) |
- return (relation > 0); |
- else if (op_ == kGE) |
- return (relation >= 0); |
- // op_ == kBetween |
- if (relation < 0) |
- return false; |
- return version.CompareTo(*version2_) <= 0; |
-} |
- |
-bool GpuBlacklist::VersionInfo::IsValid() const { |
- return (op_ != kUnknown && version_style_ != kVersionStyleUnknown); |
-} |
- |
-bool GpuBlacklist::VersionInfo::IsLexical() const { |
- return version_style_ == kVersionStyleLexical; |
-} |
- |
-// static |
-GpuBlacklist::VersionInfo::VersionStyle |
-GpuBlacklist::VersionInfo::StringToVersionStyle( |
- const std::string& version_style) { |
- if (version_style.empty() || version_style == kVersionStyleStringNumerical) |
- return kVersionStyleNumerical; |
- if (version_style == kVersionStyleStringLexical) |
- return kVersionStyleLexical; |
- return kVersionStyleUnknown; |
-} |
- |
-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)); |
- } |
-} |
- |
-GpuBlacklist::OsInfo::~OsInfo() {} |
- |
-bool GpuBlacklist::OsInfo::Contains(OsType type, |
- const Version& version) const { |
- if (!IsValid()) |
- return false; |
- if (type_ != type && type_ != kOsAny) |
- return false; |
- return version_info_->Contains(version); |
-} |
- |
-bool GpuBlacklist::OsInfo::IsValid() const { |
- return type_ != kOsUnknown && version_info_->IsValid(); |
-} |
- |
-GpuBlacklist::OsType GpuBlacklist::OsInfo::type() const { |
- return type_; |
-} |
- |
-GpuBlacklist::OsType GpuBlacklist::OsInfo::StringToOsType( |
- const std::string& os) { |
- if (os == "win") |
- return kOsWin; |
- else if (os == "macosx") |
- return kOsMacosx; |
- else if (os == "linux") |
- return kOsLinux; |
- else if (os == "chromeos") |
- return kOsChromeOS; |
- else if (os == "any") |
- return kOsAny; |
- return kOsUnknown; |
-} |
- |
-GpuBlacklist::StringInfo::StringInfo(const std::string& string_op, |
- const std::string& string_value) { |
- op_ = StringToOp(string_op); |
- value_ = StringToLowerASCII(string_value); |
-} |
- |
-bool GpuBlacklist::StringInfo::Contains(const std::string& value) const { |
- std::string my_value = StringToLowerASCII(value); |
- switch (op_) { |
- case kContains: |
- return strstr(my_value.c_str(), value_.c_str()) != NULL; |
- case kBeginWith: |
- return StartsWithASCII(my_value, value_, false); |
- case kEndWith: |
- return EndsWith(my_value, value_, false); |
- case kEQ: |
- return value_ == my_value; |
- default: |
- return false; |
- } |
-} |
- |
-bool GpuBlacklist::StringInfo::IsValid() const { |
- return op_ != kUnknown; |
-} |
- |
-GpuBlacklist::StringInfo::Op GpuBlacklist::StringInfo::StringToOp( |
- const std::string& string_op) { |
- if (string_op == "=") |
- 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( |
- const DictionaryValue* value, bool top_level) { |
- DCHECK(value); |
- ScopedGpuBlacklistEntry entry(new GpuBlacklistEntry()); |
- |
- size_t dictionary_entry_count = 0; |
- |
- if (top_level) { |
- uint32 id; |
- if (!value->GetInteger("id", reinterpret_cast<int*>(&id)) || |
- !entry->SetId(id)) { |
- LOG(WARNING) << "Malformed id entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- |
- bool disabled; |
- if (value->GetBoolean("disabled", &disabled)) { |
- entry->SetDisabled(disabled); |
- dictionary_entry_count++; |
- } |
- } |
- |
- std::string description; |
- if (value->GetString("description", &description)) { |
- entry->description_ = description; |
- dictionary_entry_count++; |
- } else { |
- entry->description_ = "The GPU is unavailable for an unexplained reason."; |
- } |
- |
- const ListValue* cr_bugs; |
- if (value->GetList("cr_bugs", &cr_bugs)) { |
- for (size_t i = 0; i < cr_bugs->GetSize(); ++i) { |
- int bug_id; |
- if (cr_bugs->GetInteger(i, &bug_id)) { |
- entry->cr_bugs_.push_back(bug_id); |
- } else { |
- LOG(WARNING) << "Malformed cr_bugs entry " << entry->id(); |
- return NULL; |
- } |
- } |
- dictionary_entry_count++; |
- } |
- |
- const ListValue* webkit_bugs; |
- if (value->GetList("webkit_bugs", &webkit_bugs)) { |
- for (size_t i = 0; i < webkit_bugs->GetSize(); ++i) { |
- int bug_id; |
- if (webkit_bugs->GetInteger(i, &bug_id)) { |
- entry->webkit_bugs_.push_back(bug_id); |
- } else { |
- LOG(WARNING) << "Malformed webkit_bugs entry " << entry->id(); |
- return NULL; |
- } |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* os_value = NULL; |
- if (value->GetDictionary("os", &os_value)) { |
- std::string os_type; |
- std::string os_version_op = "any"; |
- std::string os_version_string; |
- std::string os_version_string2; |
- os_value->GetString("type", &os_type); |
- const DictionaryValue* os_version_value = NULL; |
- if (os_value->GetDictionary("version", &os_version_value)) { |
- os_version_value->GetString("op", &os_version_op); |
- os_version_value->GetString("number", &os_version_string); |
- os_version_value->GetString("number2", &os_version_string2); |
- } |
- if (!entry->SetOsInfo(os_type, os_version_op, os_version_string, |
- os_version_string2)) { |
- LOG(WARNING) << "Malformed os entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- } |
- |
- std::string vendor_id; |
- if (value->GetString("vendor_id", &vendor_id)) { |
- if (!entry->SetVendorId(vendor_id)) { |
- LOG(WARNING) << "Malformed vendor_id entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- } |
- |
- const ListValue* device_id_list; |
- if (value->GetList("device_id", &device_id_list)) { |
- for (size_t i = 0; i < device_id_list->GetSize(); ++i) { |
- std::string device_id; |
- if (!device_id_list->GetString(i, &device_id) || |
- !entry->AddDeviceId(device_id)) { |
- LOG(WARNING) << "Malformed device_id entry " << entry->id(); |
- return NULL; |
- } |
- } |
- dictionary_entry_count++; |
- } |
- |
- 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++; |
- } |
- |
- const 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; |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* driver_version_value = NULL; |
- if (value->GetDictionary("driver_version", &driver_version_value)) { |
- std::string driver_version_op = "any"; |
- std::string driver_version_style; |
- std::string driver_version_string; |
- std::string driver_version_string2; |
- driver_version_value->GetString("op", &driver_version_op); |
- driver_version_value->GetString("style", &driver_version_style); |
- driver_version_value->GetString("number", &driver_version_string); |
- driver_version_value->GetString("number2", &driver_version_string2); |
- if (!entry->SetDriverVersionInfo(driver_version_op, |
- driver_version_style, |
- driver_version_string, |
- driver_version_string2)) { |
- LOG(WARNING) << "Malformed driver_version entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* driver_date_value = NULL; |
- if (value->GetDictionary("driver_date", &driver_date_value)) { |
- std::string driver_date_op = "any"; |
- std::string driver_date_string; |
- std::string driver_date_string2; |
- driver_date_value->GetString("op", &driver_date_op); |
- driver_date_value->GetString("number", &driver_date_string); |
- driver_date_value->GetString("number2", &driver_date_string2); |
- if (!entry->SetDriverDateInfo(driver_date_op, driver_date_string, |
- driver_date_string2)) { |
- LOG(WARNING) << "Malformed driver_date entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* gl_vendor_value = NULL; |
- if (value->GetDictionary("gl_vendor", &gl_vendor_value)) { |
- std::string vendor_op; |
- std::string vendor_value; |
- gl_vendor_value->GetString("op", &vendor_op); |
- gl_vendor_value->GetString("value", &vendor_value); |
- if (!entry->SetGLVendorInfo(vendor_op, vendor_value)) { |
- LOG(WARNING) << "Malformed gl_vendor entry " << entry->id(); |
- return NULL; |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* gl_renderer_value = NULL; |
- if (value->GetDictionary("gl_renderer", &gl_renderer_value)) { |
- std::string renderer_op; |
- 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++; |
- } |
- |
- const 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++; |
- } |
- |
- const 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++; |
- } |
- |
- const 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) { |
- 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 { |
- 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 (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; |
- } |
- ScopedGpuBlacklistEntry exception( |
- GetGpuBlacklistEntryFromValue(exception_value, false)); |
- if (exception == NULL) { |
- LOG(WARNING) << "Malformed exceptions entry " << entry->id(); |
- return NULL; |
- } |
- if (exception->contains_unknown_fields_) { |
- LOG(WARNING) << "Exception with unknown fields " << entry->id(); |
- entry->contains_unknown_fields_ = true; |
- } else { |
- entry->AddException(exception); |
- } |
- } |
- dictionary_entry_count++; |
- } |
- |
- const DictionaryValue* browser_version_value = NULL; |
- // browser_version is processed in LoadGpuBlacklist(). |
- if (value->GetDictionary("browser_version", &browser_version_value)) |
- dictionary_entry_count++; |
- } |
- |
- if (value->size() != dictionary_entry_count) { |
- LOG(WARNING) << "Entry with unknown fields " << entry->id(); |
- 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) { |
-} |
- |
-GpuBlacklist::GpuBlacklistEntry::~GpuBlacklistEntry() { } |
- |
-bool GpuBlacklist::GpuBlacklistEntry::SetId(uint32 id) { |
- if (id != 0) { |
- id_ = id; |
- return true; |
- } |
- return false; |
-} |
- |
-void GpuBlacklist::GpuBlacklistEntry::SetDisabled(bool disabled) { |
- disabled_ = disabled; |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::SetOsInfo( |
- const std::string& os, |
- const std::string& version_op, |
- const std::string& version_string, |
- const std::string& version_string2) { |
- os_info_.reset(new OsInfo(os, version_op, version_string, version_string2)); |
- return os_info_->IsValid(); |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::SetVendorId( |
- const std::string& vendor_id_string) { |
- vendor_id_ = 0; |
- return base::HexStringToInt(vendor_id_string, |
- reinterpret_cast<int*>(&vendor_id_)); |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::AddDeviceId( |
- const std::string& device_id_string) { |
- uint32 device_id = 0; |
- if (base::HexStringToInt(device_id_string, |
- reinterpret_cast<int*>(&device_id))) { |
- device_id_list_.push_back(device_id); |
- return true; |
- } |
- return false; |
-} |
- |
-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, |
- const std::string& version_style, |
- const std::string& version_string, |
- const std::string& version_string2) { |
- driver_version_info_.reset(new VersionInfo( |
- version_op, version_style, version_string, version_string2)); |
- return driver_version_info_->IsValid(); |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::SetDriverDateInfo( |
- const std::string& date_op, |
- const std::string& date_string, |
- const std::string& date_string2) { |
- driver_date_info_.reset( |
- new VersionInfo(date_op, "", date_string, date_string2)); |
- return driver_date_info_->IsValid(); |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::SetGLVendorInfo( |
- const std::string& vendor_op, |
- const std::string& vendor_value) { |
- gl_vendor_info_.reset( |
- new StringInfo(vendor_op, vendor_value)); |
- return gl_vendor_info_->IsValid(); |
-} |
- |
-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; |
- int feature_type = content::GPU_FEATURE_TYPE_UNKNOWN; |
- for (size_t i = 0; i < size; ++i) { |
- GpuFeatureType type = |
- gpu_util::StringToGpuFeatureType(blacklisted_features[i]); |
- switch (type) { |
- case content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS: |
- case content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING: |
- case content::GPU_FEATURE_TYPE_WEBGL: |
- case content::GPU_FEATURE_TYPE_MULTISAMPLING: |
- case content::GPU_FEATURE_TYPE_FLASH3D: |
- case content::GPU_FEATURE_TYPE_FLASH_STAGE3D: |
- 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); |
- return true; |
-} |
- |
-void GpuBlacklist::GpuBlacklistEntry::AddException( |
- ScopedGpuBlacklistEntry exception) { |
- exceptions_.push_back(exception); |
-} |
- |
-// static |
-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; |
- 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; |
- default: |
- break; |
- } |
- if (driver_vendor_info_.get() != NULL && |
- !driver_vendor_info_->Contains(gpu_info.driver_vendor)) |
- return false; |
- if (driver_version_info_.get() != NULL) { |
- 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) { |
- 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 && |
- !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; |
- return os_info_->type(); |
-} |
- |
-uint32 GpuBlacklist::GpuBlacklistEntry::id() const { |
- return id_; |
-} |
- |
-bool GpuBlacklist::GpuBlacklistEntry::disabled() const { |
- return disabled_; |
-} |
- |
-GpuFeatureType GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureType() const { |
- return feature_type_; |
-} |
- |
-// static |
-GpuBlacklist* GpuBlacklist::GetInstance() { |
- return Singleton<GpuBlacklist>::get(); |
-} |
- |
-GpuBlacklist::GpuBlacklist() |
- : max_entry_id_(0), |
- contains_unknown_fields_(false) { |
- GpuDataManager::GetInstance()->AddObserver(this); |
-} |
- |
-GpuBlacklist::~GpuBlacklist() { |
- Clear(); |
- GpuDataManager::GetInstance()->RemoveObserver(this); |
-} |
- |
-bool GpuBlacklist::LoadGpuBlacklist( |
- const std::string& json_context, GpuBlacklist::OsFilter os_filter) { |
- chrome::VersionInfo chrome_version_info; |
- std::string chrome_version_string = |
- chrome_version_info.is_valid() ? chrome_version_info.Version() : "0"; |
- return LoadGpuBlacklist(chrome_version_string, json_context, os_filter); |
-} |
- |
-bool GpuBlacklist::LoadGpuBlacklist( |
- const std::string& browser_version_string, |
- const std::string& json_context, |
- GpuBlacklist::OsFilter os_filter) { |
- browser_version_.reset(new Version(browser_version_string)); |
- DCHECK(browser_version_->IsValid()); |
- |
- scoped_ptr<Value> root; |
- root.reset(base::JSONReader::Read(json_context)); |
- if (root.get() == NULL || !root->IsType(Value::TYPE_DICTIONARY)) |
- return false; |
- |
- DictionaryValue* root_dictionary = static_cast<DictionaryValue*>(root.get()); |
- DCHECK(root_dictionary); |
- return LoadGpuBlacklist(*root_dictionary, os_filter); |
-} |
- |
-bool GpuBlacklist::LoadGpuBlacklist( |
- const DictionaryValue& parsed_json, GpuBlacklist::OsFilter os_filter) { |
- std::vector<ScopedGpuBlacklistEntry> entries; |
- |
- std::string version_string; |
- parsed_json.GetString("version", &version_string); |
- version_.reset(new Version(version_string)); |
- if (!version_->IsValid()) |
- return false; |
- |
- const ListValue* list = NULL; |
- if (!parsed_json.GetList("entries", &list)) |
- return false; |
- |
- uint32 max_entry_id = 0; |
- bool contains_unknown_fields = false; |
- for (size_t i = 0; i < list->GetSize(); ++i) { |
- const DictionaryValue* list_item = NULL; |
- bool valid = list->GetDictionary(i, &list_item); |
- if (!valid || list_item == NULL) |
- return false; |
- // Check browser version compatibility: if the entry is not for the |
- // current browser version, don't process it. |
- BrowserVersionSupport browser_version_support = |
- IsEntrySupportedByCurrentBrowserVersion(list_item); |
- if (browser_version_support == kMalformed) |
- return false; |
- if (browser_version_support == kUnsupported) |
- continue; |
- DCHECK(browser_version_support == kSupported); |
- ScopedGpuBlacklistEntry entry( |
- GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(list_item, true)); |
- if (entry == NULL) |
- return false; |
- if (entry->id() > max_entry_id) |
- max_entry_id = entry->id(); |
- // If an unknown field is encountered, skip the entry; if an unknown |
- // feature is encountered, ignore the feature, but keep the entry. |
- if (entry->contains_unknown_fields()) { |
- contains_unknown_fields = true; |
- continue; |
- } |
- if (entry->contains_unknown_features()) |
- contains_unknown_fields = true; |
- entries.push_back(entry); |
- } |
- |
- Clear(); |
- OsType my_os = GetOsType(); |
- for (size_t i = 0; i < entries.size(); ++i) { |
- 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::OsType os, |
- Version* os_version, |
- const content::GPUInfo& gpu_info) { |
- active_entries_.clear(); |
- int type = 0; |
- |
- 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()) |
- type |= blacklist_[i]->GetGpuFeatureType(); |
- active_entries_.push_back(blacklist_[i]); |
- } |
- } |
- return static_cast<GpuFeatureType>(type); |
-} |
- |
-void GpuBlacklist::UpdateGpuDataManager() { |
- content::GpuFeatureType feature_type = DetermineGpuFeatureType( |
- GpuBlacklist::kOsAny, NULL, GpuDataManager::GetInstance()->GetGPUInfo()); |
- GpuDataManager::GetInstance()->SetPreliminaryBlacklistedFeatures( |
- feature_type); |
- gpu_util::UpdateStats(); |
-} |
- |
-void GpuBlacklist::GetGpuFeatureTypeEntries( |
- content::GpuFeatureType feature, |
- 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()) |
- 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; |
- DictionaryValue* problem = new DictionaryValue(); |
- |
- problem->SetString("description", entry->description()); |
- |
- ListValue* cr_bugs = new ListValue(); |
- for (size_t j = 0; j < entry->cr_bugs().size(); ++j) |
- cr_bugs->Append(Value::CreateIntegerValue(entry->cr_bugs()[j])); |
- problem->Set("crBugs", cr_bugs); |
- |
- ListValue* webkit_bugs = new ListValue(); |
- for (size_t j = 0; j < entry->webkit_bugs().size(); ++j) { |
- webkit_bugs->Append(Value::CreateIntegerValue( |
- entry->webkit_bugs()[j])); |
- } |
- problem->Set("webkitBugs", webkit_bugs); |
- |
- problem_list->Append(problem); |
- } |
-} |
- |
-size_t GpuBlacklist::num_entries() const { |
- return blacklist_.size(); |
-} |
- |
-uint32 GpuBlacklist::max_entry_id() const { |
- return max_entry_id_; |
-} |
- |
-std::string GpuBlacklist::GetVersion() const { |
- if (version_.get() == NULL) |
- return std::string(); |
- const std::vector<uint16>& components_reference = version_->components(); |
- if (components_reference.size() != 2) |
- return std::string(); |
- |
- std::string version_string = |
- base::UintToString(static_cast<unsigned>(components_reference[0])) + |
- "." + |
- base::UintToString(static_cast<unsigned>(components_reference[1])); |
- return version_string; |
-} |
- |
-GpuBlacklist::OsType GpuBlacklist::GetOsType() { |
-#if defined(OS_CHROMEOS) |
- return kOsChromeOS; |
-#elif defined(OS_WIN) |
- return kOsWin; |
-#elif defined(OS_LINUX) || defined(OS_OPENBSD) |
- return kOsLinux; |
-#elif defined(OS_MACOSX) |
- return kOsMacosx; |
-#else |
- return kOsUnknown; |
-#endif |
-} |
- |
-void GpuBlacklist::Clear() { |
- blacklist_.clear(); |
- active_entries_.clear(); |
- max_entry_id_ = 0; |
- contains_unknown_fields_ = false; |
-} |
- |
-GpuBlacklist::BrowserVersionSupport |
-GpuBlacklist::IsEntrySupportedByCurrentBrowserVersion( |
- const DictionaryValue* value) { |
- DCHECK(value); |
- const DictionaryValue* browser_version_value = NULL; |
- if (value->GetDictionary("browser_version", &browser_version_value)) { |
- std::string version_op = "any"; |
- std::string version_string; |
- std::string version_string2; |
- browser_version_value->GetString("op", &version_op); |
- browser_version_value->GetString("number", &version_string); |
- browser_version_value->GetString("number2", &version_string2); |
- scoped_ptr<VersionInfo> browser_version_info; |
- browser_version_info.reset( |
- new VersionInfo(version_op, "", version_string, version_string2)); |
- if (!browser_version_info->IsValid()) |
- return kMalformed; |
- if (browser_version_info->Contains(*browser_version_)) |
- return kSupported; |
- return kUnsupported; |
- } |
- return kSupported; |
-} |
- |
-void GpuBlacklist::OnGpuInfoUpdate() { |
- UpdateGpuDataManager(); |
-} |
- |
-// 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; |
-} |