src/gpu/config/gpu_control_list.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef GPU_CONFIG_GPU_CONTROL_LIST_H_
   6 #define GPU_CONFIG_GPU_CONTROL_LIST_H_
   7
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/gtest_prod_util.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/values.h"
  18 #include "build/build_config.h"
  19 #include "gpu/gpu_export.h"
  20
  21 namespace gpu {
  22 struct GPUInfo;
  23
  24 class GPU_EXPORT GpuControlList {
  25  public:
  26   enum OsType {
  27     kOsLinux,
  28     kOsMacosx,
  29     kOsWin,
  30     kOsChromeOS,
  31     kOsAndroid,
  32     kOsAny,
  33     kOsUnknown
  34   };
  35
  36   enum OsFilter {
  37     // In loading, ignore all entries that belong to other OS.
  38     kCurrentOsOnly,
  39     // In loading, keep all entries. This is for testing only.
  40     kAllOs
  41   };
  42
  43   GpuControlList();
  44   virtual ~GpuControlList();
  45
  46   // Loads control list information from a json file.
  47   // If failed, the current GpuControlList is un-touched.
  48   bool LoadList(const std::string& json_context, OsFilter os_filter);
  49
  50   // Collects system information and combines them with gpu_info and control
  51   // list information to decide which entries are applied to the current
  52   // system and returns the union of features specified in each entry.
  53   // If os is kOsAny, use the current OS; if os_version is empty, use the
  54   // current OS version.
  55   std::set<int> MakeDecision(
  56       OsType os, std::string os_version, const GPUInfo& gpu_info);
  57
  58   // Collects the active entries from the last MakeDecision() call.
  59   // If disabled set to true, return entries that are disabled; otherwise,
  60   // return enabled entries.
  61   void GetDecisionEntries(std::vector<uint32>* entry_ids,
  62                           bool disabled) const;
  63
  64   // Returns the description and bugs from active entries from the last
  65   // MakeDecision() call.
  66   //
  67   // Each problems has:
  68   // {
  69   //    "description": "Your GPU is too old",
  70   //    "crBugs": [1234],
  71   //    "webkitBugs": []
  72   // }
  73   void GetReasons(
  74       base::ListValue* problem_list, const std::string& tag) const;
  75
  76   // Return the largest entry id.  This is used for histogramming.
  77   uint32 max_entry_id() const;
  78
  79   // Returns the version of the control list.
  80   std::string version() const;
  81
  82   // Check if we need more gpu info to make the decisions.
  83   // This is computed from the last MakeDecision() call.
  84   // If yes, we should create a gl context and do a full gpu info collection.
  85   bool needs_more_info() const { return needs_more_info_; }
  86
  87   // Returns the number of entries.  This is only for tests.
  88   size_t num_entries() const;
  89
  90   // Register a feature to FeatureMap - used to construct a GpuControlList.
  91   void AddSupportedFeature(const std::string& feature_name, int feature_id);
  92   // Register whether "all" is recognized as all features.
  93   void set_supports_feature_type_all(bool supported);
  94
  95   // Enables logging of control list decisions.
  96   void enable_control_list_logging(
  97       const std::string& control_list_logging_name) {
  98     control_list_logging_enabled_ = true;
  99     control_list_logging_name_ = control_list_logging_name;
 100   }
 101
 102  private:
 103   friend class GpuControlListEntryTest;
 104   friend class MachineModelInfoTest;
 105   friend class NumberInfoTest;
 106   friend class OsInfoTest;
 107   friend class StringInfoTest;
 108   friend class VersionInfoTest;
 109
 110   enum NumericOp {
 111     kBetween,  // <= * <=
 112     kEQ,  // =
 113     kLT,  // <
 114     kLE,  // <=
 115     kGT,  // >
 116     kGE,  // >=
 117     kAny,
 118     kUnknown  // Indicates the data is invalid.
 119   };
 120
 121   class GPU_EXPORT VersionInfo {
 122    public:
 123     // If version_style is empty, it defaults to kNumerical.
 124     VersionInfo(const std::string& version_op,
 125                 const std::string& version_style,
 126                 const std::string& version_string,
 127                 const std::string& version_string2);
 128     ~VersionInfo();
 129
 130     // Determines if a given version is included in the VersionInfo range.
 131     // "splitter" divides version string into segments.
 132     bool Contains(const std::string& version, char splitter) const;
 133     // Same as above, using '.' as splitter.
 134     bool Contains(const std::string& version) const;
 135
 136     // Determine if the version_style is lexical.
 137     bool IsLexical() const;
 138
 139     // Determines if the VersionInfo contains valid information.
 140     bool IsValid() const;
 141
 142    private:
 143     enum VersionStyle {
 144       kVersionStyleNumerical,
 145       kVersionStyleLexical,
 146       kVersionStyleUnknown
 147     };
 148
 149     static VersionStyle StringToVersionStyle(const std::string& version_style);
 150
 151     // Compare two version strings.
 152     // Return 1 if version > version_ref,
 153     //        0 if version = version_ref,
 154     //       -1 if version < version_ref.
 155     // Note that we only compare as many segments as both versions contain.
 156     // For example: Compare("10.3.1", "10.3") returns 0,
 157     //              Compare("10.3", "10.3.1") returns 0.
 158     // If "version_style" is Lexical, the first segment is compared
 159     // numerically, all other segments are compared lexically.
 160     // Lexical is used for AMD Linux driver versions only.
 161     static int Compare(const std::vector<std::string>& version,
 162                        const std::vector<std::string>& version_ref,
 163                        VersionStyle version_style);
 164
 165     NumericOp op_;
 166     VersionStyle version_style_;
 167     std::vector<std::string> version_;
 168     std::vector<std::string> version2_;
 169   };
 170
 171   class GPU_EXPORT OsInfo {
 172    public:
 173     OsInfo(const std::string& os,
 174            const std::string& version_op,
 175            const std::string& version_string,
 176            const std::string& version_string2);
 177     ~OsInfo();
 178
 179     // Determines if a given os/version is included in the OsInfo set.
 180     bool Contains(OsType type, const std::string& version) const;
 181
 182     // Determines if the VersionInfo contains valid information.
 183     bool IsValid() const;
 184
 185     OsType type() const;
 186
 187     // Maps string to OsType; returns kOsUnknown if it's not a valid os.
 188     static OsType StringToOsType(const std::string& os);
 189
 190    private:
 191     OsType type_;
 192     scoped_ptr<VersionInfo> version_info_;
 193   };
 194
 195   class GPU_EXPORT StringInfo {
 196    public:
 197     StringInfo(const std::string& string_op, const std::string& string_value);
 198
 199     // Determines if a given string is included in the StringInfo.
 200     bool Contains(const std::string& value) const;
 201
 202     // Determines if the StringInfo contains valid information.
 203     bool IsValid() const;
 204
 205    private:
 206     enum Op {
 207       kContains,
 208       kBeginWith,
 209       kEndWith,
 210       kEQ,  // =
 211       kUnknown  // Indicates StringInfo data is invalid.
 212     };
 213
 214     // Maps string to Op; returns kUnknown if it's not a valid Op.
 215     static Op StringToOp(const std::string& string_op);
 216
 217     Op op_;
 218     std::string value_;
 219   };
 220
 221   class GPU_EXPORT FloatInfo {
 222    public:
 223     FloatInfo(const std::string& float_op,
 224               const std::string& float_value,
 225               const std::string& float_value2);
 226
 227     // Determines if a given float is included in the FloatInfo.
 228     bool Contains(float value) const;
 229
 230     // Determines if the FloatInfo contains valid information.
 231     bool IsValid() const;
 232
 233    private:
 234     NumericOp op_;
 235     float value_;
 236     float value2_;
 237   };
 238
 239   class GPU_EXPORT IntInfo {
 240    public:
 241     IntInfo(const std::string& int_op,
 242             const std::string& int_value,
 243             const std::string& int_value2);
 244
 245     // Determines if a given int is included in the IntInfo.
 246     bool Contains(int value) const;
 247
 248     // Determines if the IntInfo contains valid information.
 249     bool IsValid() const;
 250
 251    private:
 252     NumericOp op_;
 253     int value_;
 254     int value2_;
 255   };
 256
 257   class GPU_EXPORT BoolInfo {
 258    public:
 259     explicit BoolInfo(bool value);
 260
 261     // Determines if a given bool is included in the BoolInfo.
 262     bool Contains(bool value) const;
 263
 264    private:
 265     bool value_;
 266   };
 267
 268   class GpuControlListEntry;
 269   typedef scoped_refptr<GpuControlListEntry> ScopedGpuControlListEntry;
 270
 271   typedef base::hash_map<std::string, int> FeatureMap;
 272
 273   class GPU_EXPORT GpuControlListEntry
 274       : public base::RefCounted<GpuControlListEntry> {
 275    public:
 276     // Constructs GpuControlListEntry from DictionaryValue loaded from json.
 277     // Top-level entry must have an id number.  Others are exceptions.
 278     static ScopedGpuControlListEntry GetEntryFromValue(
 279         const base::DictionaryValue* value, bool top_level,
 280         const FeatureMap& feature_map,
 281         bool supports_feature_type_all);
 282
 283     // Logs a control list match for this rule in the list identified by
 284     // |control_list_logging_name|.
 285     void LogControlListMatch(
 286         const std::string& control_list_logging_name) const;
 287
 288     // Determines if a given os/gc/machine_model/driver is included in the
 289     // Entry set.
 290     bool Contains(OsType os_type, const std::string& os_version,
 291                   const GPUInfo& gpu_info) const;
 292
 293     // Determines whether we needs more gpu info to make the blacklisting
 294     // decision.  It should only be checked if Contains() returns true.
 295     bool NeedsMoreInfo(const GPUInfo& gpu_info) const;
 296
 297     // Returns the OsType.
 298     OsType GetOsType() const;
 299
 300     // Returns the entry's unique id.  0 is reserved.
 301     uint32 id() const;
 302
 303     // Returns whether the entry is disabled.
 304     bool disabled() const;
 305
 306     // Returns the description of the entry
 307     const std::string& description() const { return description_; }
 308
 309     // Returns a list of Chromium and Webkit bugs applicable to this entry
 310     const std::vector<int>& cr_bugs() const { return cr_bugs_; }
 311     const std::vector<int>& webkit_bugs() const { return webkit_bugs_; }
 312
 313     // Returns the blacklisted features in this entry.
 314     const std::set<int>& features() const;
 315
 316     // Returns a list of blacklisted feature names in this entry.
 317     void GetFeatureNames(base::ListValue* feature_names,
 318                          const FeatureMap& feature_map,
 319                          bool supports_feature_type_all) const;
 320
 321    private:
 322     friend class base::RefCounted<GpuControlListEntry>;
 323
 324     enum MultiGpuStyle {
 325       kMultiGpuStyleOptimus,
 326       kMultiGpuStyleAMDSwitchable,
 327       kMultiGpuStyleNone
 328     };
 329
 330     enum MultiGpuCategory {
 331       // This entry applies if this is the primary GPU on the system.
 332       kMultiGpuCategoryPrimary,
 333       // This entry applies if this is a secondary GPU on the system.
 334       kMultiGpuCategorySecondary,
 335       // This entry applies if this is the active GPU on the system.
 336       kMultiGpuCategoryActive,
 337       // This entry applies if this is any of the GPUs on the system.
 338       kMultiGpuCategoryAny,
 339       kMultiGpuCategoryNone
 340     };
 341
 342     enum GLType {
 343       kGLTypeGL,  // This is default on MacOSX, Linux, ChromeOS
 344       kGLTypeGLES,  // This is default on Android
 345       kGLTypeANGLE,  // This is default on Windows
 346       kGLTypeNone
 347     };
 348
 349     GpuControlListEntry();
 350     ~GpuControlListEntry();
 351
 352     bool SetId(uint32 id);
 353
 354     void SetDisabled(bool disabled);
 355
 356     bool SetOsInfo(const std::string& os,
 357                    const std::string& version_op,
 358                    const std::string& version_string,
 359                    const std::string& version_string2);
 360
 361     bool SetVendorId(const std::string& vendor_id_string);
 362
 363     bool AddDeviceId(const std::string& device_id_string);
 364
 365     bool SetMultiGpuStyle(const std::string& multi_gpu_style_string);
 366
 367     bool SetMultiGpuCategory(const std::string& multi_gpu_category_string);
 368
 369     bool SetGLType(const std::string& gl_type_string);
 370
 371     bool SetDriverVendorInfo(const std::string& vendor_op,
 372                              const std::string& vendor_value);
 373
 374     bool SetDriverVersionInfo(const std::string& version_op,
 375                               const std::string& version_style,
 376                               const std::string& version_string,
 377                               const std::string& version_string2);
 378
 379     bool SetDriverDateInfo(const std::string& date_op,
 380                            const std::string& date_string,
 381                            const std::string& date_string2);
 382
 383     bool SetGLVersionInfo(const std::string& version_op,
 384                           const std::string& version_string,
 385                           const std::string& version_string2);
 386
 387     bool SetGLVendorInfo(const std::string& vendor_op,
 388                          const std::string& vendor_value);
 389
 390     bool SetGLRendererInfo(const std::string& renderer_op,
 391                            const std::string& renderer_value);
 392
 393     bool SetGLExtensionsInfo(const std::string& extensions_op,
 394                              const std::string& extensions_value);
 395
 396     bool SetGLResetNotificationStrategyInfo(const std::string& op,
 397                                             const std::string& int_string,
 398                                             const std::string& int_string2);
 399
 400     bool SetCpuBrand(const std::string& cpu_op,
 401                      const std::string& cpu_value);
 402
 403     bool SetPerfGraphicsInfo(const std::string& op,
 404                              const std::string& float_string,
 405                              const std::string& float_string2);
 406
 407     bool SetPerfGamingInfo(const std::string& op,
 408                            const std::string& float_string,
 409                            const std::string& float_string2);
 410
 411     bool SetPerfOverallInfo(const std::string& op,
 412                             const std::string& float_string,
 413                             const std::string& float_string2);
 414
 415     bool AddMachineModelName(const std::string& model_name);
 416
 417     bool SetMachineModelVersionInfo(const std::string& version_op,
 418                                     const std::string& version_string,
 419                                     const std::string& version_string2);
 420
 421     bool SetGpuCountInfo(const std::string& op,
 422                          const std::string& int_string,
 423                          const std::string& int_string2);
 424
 425     void SetDirectRenderingInfo(bool value);
 426
 427     bool SetFeatures(const std::vector<std::string>& features,
 428                      const FeatureMap& feature_map,
 429                      bool supports_feature_type_all);
 430
 431     void AddException(ScopedGpuControlListEntry exception);
 432
 433     // Return true if GL_VERSION string does not fit the entry info
 434     // on GL type and GL version.
 435     bool GLVersionInfoMismatch(const std::string& gl_version) const;
 436
 437     static MultiGpuStyle StringToMultiGpuStyle(const std::string& style);
 438
 439     static MultiGpuCategory StringToMultiGpuCategory(
 440         const std::string& category);
 441
 442     static GLType StringToGLType(const std::string& gl_type);
 443
 444     // map a feature_name to feature_id. If the string is not a registered
 445     // feature name, return false.
 446     static bool StringToFeature(const std::string& feature_name,
 447                                 int* feature_id,
 448                                 const FeatureMap& feature_map);
 449
 450     // Return the default GL type, depending on the OS.
 451     // See GLType declaration.
 452     static GLType GetDefaultGLType();
 453
 454     uint32 id_;
 455     bool disabled_;
 456     std::string description_;
 457     std::vector<int> cr_bugs_;
 458     std::vector<int> webkit_bugs_;
 459     scoped_ptr<OsInfo> os_info_;
 460     uint32 vendor_id_;
 461     std::vector<uint32> device_id_list_;
 462     MultiGpuStyle multi_gpu_style_;
 463     MultiGpuCategory multi_gpu_category_;
 464     GLType gl_type_;
 465     scoped_ptr<StringInfo> driver_vendor_info_;
 466     scoped_ptr<VersionInfo> driver_version_info_;
 467     scoped_ptr<VersionInfo> driver_date_info_;
 468     scoped_ptr<VersionInfo> gl_version_info_;
 469     scoped_ptr<StringInfo> gl_vendor_info_;
 470     scoped_ptr<StringInfo> gl_renderer_info_;
 471     scoped_ptr<StringInfo> gl_extensions_info_;
 472     scoped_ptr<IntInfo> gl_reset_notification_strategy_info_;
 473     scoped_ptr<StringInfo> cpu_brand_;
 474     scoped_ptr<FloatInfo> perf_graphics_info_;
 475     scoped_ptr<FloatInfo> perf_gaming_info_;
 476     scoped_ptr<FloatInfo> perf_overall_info_;
 477     std::vector<std::string> machine_model_name_list_;
 478     scoped_ptr<VersionInfo> machine_model_version_info_;
 479     scoped_ptr<IntInfo> gpu_count_info_;
 480     scoped_ptr<BoolInfo> direct_rendering_info_;
 481     std::set<int> features_;
 482     std::vector<ScopedGpuControlListEntry> exceptions_;
 483   };
 484
 485   // Gets the current OS type.
 486   static OsType GetOsType();
 487
 488   bool LoadList(const base::DictionaryValue& parsed_json, OsFilter os_filter);
 489
 490   void Clear();
 491
 492   static NumericOp StringToNumericOp(const std::string& op);
 493
 494   std::string version_;
 495   std::vector<ScopedGpuControlListEntry> entries_;
 496
 497   // This records all the blacklist entries that are appliable to the current
 498   // user machine.  It is updated everytime MakeDecision() is called and is
 499   // used later by GetDecisionEntries().
 500   std::vector<ScopedGpuControlListEntry> active_entries_;
 501
 502   uint32 max_entry_id_;
 503
 504   bool needs_more_info_;
 505
 506   // The features a GpuControlList recognizes and handles.
 507   FeatureMap feature_map_;
 508   bool supports_feature_type_all_;
 509
 510   bool control_list_logging_enabled_;
 511   std::string control_list_logging_name_;
 512 };
 513
 514 }  // namespace gpu
 515
 516 #endif  // GPU_CONFIG_GPU_CONTROL_LIST_H_
 517