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