blob: 5d29776160afa854211ac772787fad9ccda59db3 [file] [log] [blame]
// Copyright (c) 2013 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.
#ifndef GPU_CONFIG_GPU_CONTROL_LIST_H_
#define GPU_CONFIG_GPU_CONTROL_LIST_H_
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/containers/hash_tables.h"
#include "base/memory/ref_counted.h"
#include "base/values.h"
#include "build/build_config.h"
#include "gpu/gpu_export.h"
namespace gpu {
struct GPUInfo;
class GPU_EXPORT GpuControlList {
public:
enum OsType {
kOsLinux,
kOsMacosx,
kOsWin,
kOsChromeOS,
kOsAndroid,
kOsAny,
kOsUnknown
};
enum OsFilter {
// In loading, ignore all entries that belong to other OS.
kCurrentOsOnly,
// In loading, keep all entries. This is for testing only.
kAllOs
};
GpuControlList();
virtual ~GpuControlList();
// Loads control list information from a json file.
// If failed, the current GpuControlList is un-touched.
bool LoadList(const std::string& json_context, OsFilter os_filter);
// Collects system information and combines them with gpu_info and control
// list information to decide which entries are applied to the current
// system and returns the union of features specified in each entry.
// If os is kOsAny, use the current OS; if os_version is empty, use the
// current OS version.
std::set<int> MakeDecision(
OsType os, std::string os_version, const GPUInfo& gpu_info);
// Collects the active entries from the last MakeDecision() call.
// If disabled set to true, return entries that are disabled; otherwise,
// return enabled entries.
void GetDecisionEntries(std::vector<uint32_t>* entry_ids,
bool disabled) const;
// Collects all disabled extensions.
std::vector<std::string> GetDisabledExtensions();
// Returns the description and bugs from active entries from the last
// MakeDecision() call.
//
// Each problems has:
// {
// "description": "Your GPU is too old",
// "crBugs": [1234],
// "webkitBugs": []
// }
void GetReasons(
base::ListValue* problem_list, const std::string& tag) const;
// Return the largest entry id. This is used for histogramming.
uint32_t max_entry_id() const;
// Returns the version of the control list.
std::string version() const;
// Check if we need more gpu info to make the decisions.
// This is computed from the last MakeDecision() call.
// If yes, we should create a gl context and do a full gpu info collection.
bool needs_more_info() const { return needs_more_info_; }
// Returns the number of entries. This is only for tests.
size_t num_entries() const;
// Register a feature to FeatureMap - used to construct a GpuControlList.
void AddSupportedFeature(const std::string& feature_name, int feature_id);
// Register whether "all" is recognized as all features.
void set_supports_feature_type_all(bool supported);
// Enables logging of control list decisions.
void enable_control_list_logging(
const std::string& control_list_logging_name) {
control_list_logging_enabled_ = true;
control_list_logging_name_ = control_list_logging_name;
}
private:
friend class GpuControlListEntryTest;
friend class MachineModelInfoTest;
friend class NumberInfoTest;
friend class OsInfoTest;
friend class StringInfoTest;
friend class VersionInfoTest;
enum NumericOp {
kBetween, // <= * <=
kEQ, // =
kLT, // <
kLE, // <=
kGT, // >
kGE, // >=
kAny,
kUnknown // Indicates the data is invalid.
};
class GPU_EXPORT VersionInfo {
public:
// If version_style is empty, it defaults to kNumerical.
VersionInfo(const std::string& version_op,
const std::string& version_style,
const std::string& version_string,
const std::string& version_string2);
~VersionInfo();
// Determines if a given version is included in the VersionInfo range.
// "splitter" divides version string into segments.
bool Contains(const std::string& version, char splitter) const;
// Same as above, using '.' as splitter.
bool Contains(const std::string& version) const;
// Determine if the version_style is lexical.
bool IsLexical() const;
// Determines if the VersionInfo contains valid information.
bool IsValid() const;
private:
enum VersionStyle {
kVersionStyleNumerical,
kVersionStyleLexical,
kVersionStyleUnknown
};
static VersionStyle StringToVersionStyle(const std::string& version_style);
// Compare two version strings.
// Return 1 if version > version_ref,
// 0 if version = version_ref,
// -1 if version < version_ref.
// Note that we only compare as many segments as both versions contain.
// For example: Compare("10.3.1", "10.3") returns 0,
// Compare("10.3", "10.3.1") returns 0.
// If "version_style" is Lexical, the first segment is compared
// numerically, all other segments are compared lexically.
// Lexical is used for AMD Linux driver versions only.
static int Compare(const std::vector<std::string>& version,
const std::vector<std::string>& version_ref,
VersionStyle version_style);
NumericOp op_;
VersionStyle version_style_;
std::vector<std::string> version_;
std::vector<std::string> version2_;
};
class GPU_EXPORT OsInfo {
public:
OsInfo(const std::string& os,
const std::string& version_op,
const std::string& version_string,
const std::string& version_string2);
~OsInfo();
// Determines if a given os/version is included in the OsInfo set.
bool Contains(OsType type, const std::string& version) const;
// Determines if the VersionInfo contains valid information.
bool IsValid() const;
OsType type() const;
// Maps string to OsType; returns kOsUnknown if it's not a valid os.
static OsType StringToOsType(const std::string& os);
private:
OsType type_;
std::unique_ptr<VersionInfo> version_info_;
};
class GPU_EXPORT FloatInfo {
public:
FloatInfo(const std::string& float_op,
const std::string& float_value,
const std::string& float_value2);
// Determines if a given float is included in the FloatInfo.
bool Contains(float value) const;
// Determines if the FloatInfo contains valid information.
bool IsValid() const;
private:
NumericOp op_;
float value_;
float value2_;
};
class GPU_EXPORT IntInfo {
public:
IntInfo(const std::string& int_op,
const std::string& int_value,
const std::string& int_value2);
// Determines if a given int is included in the IntInfo.
bool Contains(int value) const;
// Determines if the IntInfo contains valid information.
bool IsValid() const;
private:
NumericOp op_;
int value_;
int value2_;
};
class GPU_EXPORT BoolInfo {
public:
explicit BoolInfo(bool value);
// Determines if a given bool is included in the BoolInfo.
bool Contains(bool value) const;
private:
bool value_;
};
class GpuControlListEntry;
typedef scoped_refptr<GpuControlListEntry> ScopedGpuControlListEntry;
typedef base::hash_map<std::string, int> FeatureMap;
class GPU_EXPORT GpuControlListEntry
: public base::RefCounted<GpuControlListEntry> {
public:
// Constructs GpuControlListEntry from DictionaryValue loaded from json.
// Top-level entry must have an id number. Others are exceptions.
static ScopedGpuControlListEntry GetEntryFromValue(
const base::DictionaryValue* value, bool top_level,
const FeatureMap& feature_map,
bool supports_feature_type_all);
// Logs a control list match for this rule in the list identified by
// |control_list_logging_name|.
void LogControlListMatch(
const std::string& control_list_logging_name) const;
// Determines if a given os/gc/machine_model/driver is included in the
// Entry set.
bool Contains(OsType os_type, const std::string& os_version,
const GPUInfo& gpu_info) const;
// Determines whether we needs more gpu info to make the blacklisting
// decision. It should only be checked if Contains() returns true.
bool NeedsMoreInfo(const GPUInfo& gpu_info, bool consider_exceptions) const;
// Returns the OsType.
OsType GetOsType() const;
// Returns the entry's unique id. 0 is reserved.
uint32_t id() const;
// Returns whether the entry is disabled.
bool disabled() const;
// Returns the description of the entry
const std::string& description() const { return description_; }
// Returns a list of Chromium and Webkit bugs applicable to this entry
const std::vector<int>& cr_bugs() const { return cr_bugs_; }
const std::vector<int>& webkit_bugs() const { return webkit_bugs_; }
const std::vector<std::string>& disabled_extensions() const {
return disabled_extensions_;
}
// Returns the blacklisted features in this entry.
const std::set<int>& features() const;
// Returns a list of blacklisted feature names in this entry.
void GetFeatureNames(base::ListValue* feature_names,
const FeatureMap& feature_map,
bool supports_feature_type_all) const;
private:
friend class base::RefCounted<GpuControlListEntry>;
enum MultiGpuStyle {
kMultiGpuStyleOptimus,
kMultiGpuStyleAMDSwitchable,
kMultiGpuStyleAMDSwitchableIntegrated,
kMultiGpuStyleAMDSwitchableDiscrete,
kMultiGpuStyleNone
};
enum MultiGpuCategory {
// This entry applies if this is the primary GPU on the system.
kMultiGpuCategoryPrimary,
// This entry applies if this is a secondary GPU on the system.
kMultiGpuCategorySecondary,
// This entry applies if this is the active GPU on the system.
kMultiGpuCategoryActive,
// This entry applies if this is any of the GPUs on the system.
kMultiGpuCategoryAny,
kMultiGpuCategoryNone
};
enum GLType {
kGLTypeGL, // This is default on MacOSX, Linux, ChromeOS
kGLTypeGLES, // This is default on Android
kGLTypeANGLE, // This is default on Windows
kGLTypeNone
};
GpuControlListEntry();
~GpuControlListEntry();
bool SetId(uint32_t id);
void SetDisabled(bool disabled);
bool SetOsInfo(const std::string& os,
const std::string& version_op,
const std::string& version_string,
const std::string& version_string2);
bool SetVendorId(const std::string& vendor_id_string);
bool AddDeviceId(const std::string& device_id_string);
bool SetMultiGpuStyle(const std::string& multi_gpu_style_string);
bool SetMultiGpuCategory(const std::string& multi_gpu_category_string);
bool SetGLType(const std::string& gl_type_string);
bool SetDriverVendorInfo(const std::string& vendor_value);
bool SetDriverVersionInfo(const std::string& version_op,
const std::string& version_style,
const std::string& version_string,
const std::string& version_string2);
bool SetDriverDateInfo(const std::string& date_op,
const std::string& date_string,
const std::string& date_string2);
bool SetGLVersionInfo(const std::string& version_op,
const std::string& version_string,
const std::string& version_string2);
bool SetGLVendorInfo(const std::string& vendor_value);
bool SetGLRendererInfo(const std::string& renderer_value);
bool SetGLExtensionsInfo(const std::string& extensions_value);
bool SetGLResetNotificationStrategyInfo(const std::string& op,
const std::string& int_string,
const std::string& int_string2);
bool SetCpuBrand(const std::string& cpu_value);
bool SetPerfGraphicsInfo(const std::string& op,
const std::string& float_string,
const std::string& float_string2);
bool SetPerfGamingInfo(const std::string& op,
const std::string& float_string,
const std::string& float_string2);
bool SetPerfOverallInfo(const std::string& op,
const std::string& float_string,
const std::string& float_string2);
bool AddMachineModelName(const std::string& model_name);
bool SetMachineModelVersionInfo(const std::string& version_op,
const std::string& version_string,
const std::string& version_string2);
bool SetGpuCountInfo(const std::string& op,
const std::string& int_string,
const std::string& int_string2);
void SetDirectRenderingInfo(bool value);
void SetInProcessGPUInfo(bool value);
bool SetFeatures(const std::vector<std::string>& features,
const FeatureMap& feature_map,
bool supports_feature_type_all);
void AddException(ScopedGpuControlListEntry exception);
// Return true if GL_VERSION string does not fit the entry info
// on GL type and GL version.
bool GLVersionInfoMismatch(const std::string& gl_version) const;
static MultiGpuStyle StringToMultiGpuStyle(const std::string& style);
static MultiGpuCategory StringToMultiGpuCategory(
const std::string& category);
static GLType StringToGLType(const std::string& gl_type);
// map a feature_name to feature_id. If the string is not a registered
// feature name, return false.
static bool StringToFeature(const std::string& feature_name,
int* feature_id,
const FeatureMap& feature_map);
// Return the default GL type, depending on the OS.
// See GLType declaration.
static GLType GetDefaultGLType();
uint32_t id_;
bool disabled_;
std::string description_;
std::vector<int> cr_bugs_;
std::vector<int> webkit_bugs_;
std::vector<std::string> disabled_extensions_;
std::unique_ptr<OsInfo> os_info_;
uint32_t vendor_id_;
std::vector<uint32_t> device_id_list_;
MultiGpuStyle multi_gpu_style_;
MultiGpuCategory multi_gpu_category_;
GLType gl_type_;
std::string driver_vendor_info_;
std::unique_ptr<VersionInfo> driver_version_info_;
std::unique_ptr<VersionInfo> driver_date_info_;
std::unique_ptr<VersionInfo> gl_version_info_;
std::string gl_vendor_info_;
std::string gl_renderer_info_;
std::string gl_extensions_info_;
std::unique_ptr<IntInfo> gl_reset_notification_strategy_info_;
std::string cpu_brand_;
std::unique_ptr<FloatInfo> perf_graphics_info_;
std::unique_ptr<FloatInfo> perf_gaming_info_;
std::unique_ptr<FloatInfo> perf_overall_info_;
std::vector<std::string> machine_model_name_list_;
std::unique_ptr<VersionInfo> machine_model_version_info_;
std::unique_ptr<IntInfo> gpu_count_info_;
std::unique_ptr<BoolInfo> direct_rendering_info_;
std::unique_ptr<BoolInfo> in_process_gpu_info_;
std::set<int> features_;
std::vector<ScopedGpuControlListEntry> exceptions_;
};
// Gets the current OS type.
static OsType GetOsType();
bool LoadList(const base::DictionaryValue& parsed_json, OsFilter os_filter);
void Clear();
static NumericOp StringToNumericOp(const std::string& op);
std::string version_;
std::vector<ScopedGpuControlListEntry> entries_;
// This records all the blacklist entries that are appliable to the current
// user machine. It is updated everytime MakeDecision() is called and is
// used later by GetDecisionEntries().
std::vector<ScopedGpuControlListEntry> active_entries_;
uint32_t max_entry_id_;
bool needs_more_info_;
// The features a GpuControlList recognizes and handles.
FeatureMap feature_map_;
bool supports_feature_type_all_;
bool control_list_logging_enabled_;
std::string control_list_logging_name_;
};
} // namespace gpu
#endif // GPU_CONFIG_GPU_CONTROL_LIST_H_