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.
5 #include "gpu/config/gpu_control_list.h"
8 #include "base/json/json_reader.h"
9 #include "base/logging.h"
10 #include "base/strings/string_number_conversions.h"
11 #include "base/strings/string_split.h"
12 #include "base/strings/string_util.h"
13 #include "base/strings/stringprintf.h"
14 #include "base/sys_info.h"
15 #include "gpu/config/gpu_info.h"
16 #include "gpu/config/gpu_util.h"
17 #include "third_party/re2/re2/re2.h"
22 // Break a version string into segments. Return true if each segment is
23 // a valid number, and not all segment is 0.
24 bool ProcessVersionString(const std::string
& version_string
,
26 std::vector
<std::string
>* version
) {
28 base::SplitString(version_string
, splitter
, version
);
29 if (version
->size() == 0)
31 // If the splitter is '-', we assume it's a date with format "mm-dd-yyyy";
32 // we split it into the order of "yyyy", "mm", "dd".
33 if (splitter
== '-') {
34 std::string year
= (*version
)[version
->size() - 1];
35 for (int i
= version
->size() - 1; i
> 0; --i
) {
36 (*version
)[i
] = (*version
)[i
- 1];
41 for (size_t i
= 0; i
< version
->size(); ++i
) {
43 if (!base::StringToUint((*version
)[i
], &num
))
51 // Compare two number strings using numerical ordering.
52 // Return 0 if number = number_ref,
53 // 1 if number > number_ref,
54 // -1 if number < number_ref.
55 int CompareNumericalNumberStrings(
56 const std::string
& number
, const std::string
& number_ref
) {
59 bool valid
= base::StringToUint(number
, &value1
);
61 valid
= base::StringToUint(number_ref
, &value2
);
70 // Compare two number strings using lexical ordering.
71 // Return 0 if number = number_ref,
72 // 1 if number > number_ref,
73 // -1 if number < number_ref.
74 // We only compare as many digits as number_ref contains.
75 // If number_ref is xxx, it's considered as xxx*
76 // For example: CompareLexicalNumberStrings("121", "12") returns 0,
77 // CompareLexicalNumberStrings("12", "121") returns -1.
78 int CompareLexicalNumberStrings(
79 const std::string
& number
, const std::string
& number_ref
) {
80 for (size_t i
= 0; i
< number_ref
.length(); ++i
) {
82 if (i
< number
.length())
83 value1
= number
[i
] - '0';
84 unsigned value2
= number_ref
[i
] - '0';
93 // A mismatch is identified only if both |input| and |pattern| are not empty.
94 bool StringMismatch(const std::string
& input
, const std::string
& pattern
) {
95 if (input
.empty() || pattern
.empty())
97 return !RE2::FullMatch(input
, pattern
);
100 const char kMultiGpuStyleStringAMDSwitchable
[] = "amd_switchable";
101 const char kMultiGpuStyleStringAMDSwitchableDiscrete
[] =
102 "amd_switchable_discrete";
103 const char kMultiGpuStyleStringAMDSwitchableIntegrated
[] =
104 "amd_switchable_integrated";
105 const char kMultiGpuStyleStringOptimus
[] = "optimus";
107 const char kMultiGpuCategoryStringPrimary
[] = "primary";
108 const char kMultiGpuCategoryStringSecondary
[] = "secondary";
109 const char kMultiGpuCategoryStringActive
[] = "active";
110 const char kMultiGpuCategoryStringAny
[] = "any";
112 const char kGLTypeStringGL
[] = "gl";
113 const char kGLTypeStringGLES
[] = "gles";
114 const char kGLTypeStringANGLE
[] = "angle";
116 const char kVersionStyleStringNumerical
[] = "numerical";
117 const char kVersionStyleStringLexical
[] = "lexical";
119 const char kOp
[] = "op";
121 } // namespace anonymous
123 GpuControlList::VersionInfo::VersionInfo(
124 const std::string
& version_op
,
125 const std::string
& version_style
,
126 const std::string
& version_string
,
127 const std::string
& version_string2
)
128 : version_style_(kVersionStyleNumerical
) {
129 op_
= StringToNumericOp(version_op
);
130 if (op_
== kUnknown
|| op_
== kAny
)
132 version_style_
= StringToVersionStyle(version_style
);
133 if (!ProcessVersionString(version_string
, '.', &version_
)) {
137 if (op_
== kBetween
) {
138 if (!ProcessVersionString(version_string2
, '.', &version2_
))
143 GpuControlList::VersionInfo::~VersionInfo() {
146 bool GpuControlList::VersionInfo::Contains(
147 const std::string
& version_string
) const {
148 return Contains(version_string
, '.');
151 bool GpuControlList::VersionInfo::Contains(
152 const std::string
& version_string
, char splitter
) const {
157 std::vector
<std::string
> version
;
158 if (!ProcessVersionString(version_string
, splitter
, &version
))
160 int relation
= Compare(version
, version_
, version_style_
);
162 return (relation
== 0);
164 return (relation
< 0);
166 return (relation
<= 0);
168 return (relation
> 0);
170 return (relation
>= 0);
174 return Compare(version
, version2_
, version_style_
) <= 0;
177 bool GpuControlList::VersionInfo::IsValid() const {
178 return (op_
!= kUnknown
&& version_style_
!= kVersionStyleUnknown
);
181 bool GpuControlList::VersionInfo::IsLexical() const {
182 return version_style_
== kVersionStyleLexical
;
186 int GpuControlList::VersionInfo::Compare(
187 const std::vector
<std::string
>& version
,
188 const std::vector
<std::string
>& version_ref
,
189 VersionStyle version_style
) {
190 DCHECK(version
.size() > 0 && version_ref
.size() > 0);
191 DCHECK(version_style
!= kVersionStyleUnknown
);
192 for (size_t i
= 0; i
< version_ref
.size(); ++i
) {
193 if (i
>= version
.size())
196 // We assume both versions are checked by ProcessVersionString().
197 if (i
> 0 && version_style
== kVersionStyleLexical
)
198 ret
= CompareLexicalNumberStrings(version
[i
], version_ref
[i
]);
200 ret
= CompareNumericalNumberStrings(version
[i
], version_ref
[i
]);
208 GpuControlList::VersionInfo::VersionStyle
209 GpuControlList::VersionInfo::StringToVersionStyle(
210 const std::string
& version_style
) {
211 if (version_style
.empty() || version_style
== kVersionStyleStringNumerical
)
212 return kVersionStyleNumerical
;
213 if (version_style
== kVersionStyleStringLexical
)
214 return kVersionStyleLexical
;
215 return kVersionStyleUnknown
;
218 GpuControlList::OsInfo::OsInfo(const std::string
& os
,
219 const std::string
& version_op
,
220 const std::string
& version_string
,
221 const std::string
& version_string2
) {
222 type_
= StringToOsType(os
);
223 if (type_
!= kOsUnknown
) {
224 version_info_
.reset(new VersionInfo(
225 version_op
, std::string(), version_string
, version_string2
));
229 GpuControlList::OsInfo::~OsInfo() {}
231 bool GpuControlList::OsInfo::Contains(
232 OsType type
, const std::string
& version
) const {
235 if (type_
!= type
&& type_
!= kOsAny
)
237 std::string processed_version
;
238 size_t pos
= version
.find_first_not_of("0123456789.");
239 if (pos
!= std::string::npos
)
240 processed_version
= version
.substr(0, pos
);
242 processed_version
= version
;
244 return version_info_
->Contains(processed_version
);
247 bool GpuControlList::OsInfo::IsValid() const {
248 return type_
!= kOsUnknown
&& version_info_
->IsValid();
251 GpuControlList::OsType
GpuControlList::OsInfo::type() const {
255 GpuControlList::OsType
GpuControlList::OsInfo::StringToOsType(
256 const std::string
& os
) {
259 else if (os
== "macosx")
261 else if (os
== "android")
263 else if (os
== "linux")
265 else if (os
== "chromeos")
267 else if (os
== "any")
272 GpuControlList::FloatInfo::FloatInfo(const std::string
& float_op
,
273 const std::string
& float_value
,
274 const std::string
& float_value2
)
278 op_
= StringToNumericOp(float_op
);
282 if (!base::StringToDouble(float_value
, &dvalue
)) {
286 value_
= static_cast<float>(dvalue
);
287 if (op_
== kBetween
) {
288 if (!base::StringToDouble(float_value2
, &dvalue
)) {
292 value2_
= static_cast<float>(dvalue
);
296 bool GpuControlList::FloatInfo::Contains(float value
) const {
302 return (value
== value_
);
304 return (value
< value_
);
306 return (value
<= value_
);
308 return (value
> value_
);
310 return (value
>= value_
);
311 DCHECK(op_
== kBetween
);
312 return ((value_
<= value
&& value
<= value2_
) ||
313 (value2_
<= value
&& value
<= value_
));
316 bool GpuControlList::FloatInfo::IsValid() const {
317 return op_
!= kUnknown
;
320 GpuControlList::IntInfo::IntInfo(const std::string
& int_op
,
321 const std::string
& int_value
,
322 const std::string
& int_value2
)
326 op_
= StringToNumericOp(int_op
);
329 if (!base::StringToInt(int_value
, &value_
)) {
333 if (op_
== kBetween
&&
334 !base::StringToInt(int_value2
, &value2_
))
338 bool GpuControlList::IntInfo::Contains(int value
) const {
344 return (value
== value_
);
346 return (value
< value_
);
348 return (value
<= value_
);
350 return (value
> value_
);
352 return (value
>= value_
);
353 DCHECK(op_
== kBetween
);
354 return ((value_
<= value
&& value
<= value2_
) ||
355 (value2_
<= value
&& value
<= value_
));
358 bool GpuControlList::IntInfo::IsValid() const {
359 return op_
!= kUnknown
;
362 GpuControlList::BoolInfo::BoolInfo(bool value
) : value_(value
) {}
364 bool GpuControlList::BoolInfo::Contains(bool value
) const {
365 return value_
== value
;
369 GpuControlList::ScopedGpuControlListEntry
370 GpuControlList::GpuControlListEntry::GetEntryFromValue(
371 const base::DictionaryValue
* value
, bool top_level
,
372 const FeatureMap
& feature_map
,
373 bool supports_feature_type_all
) {
375 ScopedGpuControlListEntry
entry(new GpuControlListEntry());
377 size_t dictionary_entry_count
= 0;
381 if (!value
->GetInteger("id", reinterpret_cast<int*>(&id
)) ||
383 LOG(WARNING
) << "Malformed id entry " << entry
->id();
386 dictionary_entry_count
++;
389 if (value
->GetBoolean("disabled", &disabled
)) {
390 entry
->SetDisabled(disabled
);
391 dictionary_entry_count
++;
395 std::string description
;
396 if (value
->GetString("description", &description
)) {
397 entry
->description_
= description
;
398 dictionary_entry_count
++;
400 entry
->description_
= "The GPU is unavailable for an unexplained reason.";
403 const base::ListValue
* cr_bugs
;
404 if (value
->GetList("cr_bugs", &cr_bugs
)) {
405 for (size_t i
= 0; i
< cr_bugs
->GetSize(); ++i
) {
407 if (cr_bugs
->GetInteger(i
, &bug_id
)) {
408 entry
->cr_bugs_
.push_back(bug_id
);
410 LOG(WARNING
) << "Malformed cr_bugs entry " << entry
->id();
414 dictionary_entry_count
++;
417 const base::ListValue
* webkit_bugs
;
418 if (value
->GetList("webkit_bugs", &webkit_bugs
)) {
419 for (size_t i
= 0; i
< webkit_bugs
->GetSize(); ++i
) {
421 if (webkit_bugs
->GetInteger(i
, &bug_id
)) {
422 entry
->webkit_bugs_
.push_back(bug_id
);
424 LOG(WARNING
) << "Malformed webkit_bugs entry " << entry
->id();
428 dictionary_entry_count
++;
431 const base::ListValue
* disabled_extensions
;
432 if (value
->GetList("disabled_extensions", &disabled_extensions
)) {
433 for (size_t i
= 0; i
< disabled_extensions
->GetSize(); ++i
) {
434 std::string disabled_extension
;
435 if (disabled_extensions
->GetString(i
, &disabled_extension
)) {
436 entry
->disabled_extensions_
.push_back(disabled_extension
);
438 LOG(WARNING
) << "Malformed disabled_extensions entry " << entry
->id();
442 dictionary_entry_count
++;
445 const base::DictionaryValue
* os_value
= NULL
;
446 if (value
->GetDictionary("os", &os_value
)) {
448 std::string os_version_op
= "any";
449 std::string os_version_string
;
450 std::string os_version_string2
;
451 os_value
->GetString("type", &os_type
);
452 const base::DictionaryValue
* os_version_value
= NULL
;
453 if (os_value
->GetDictionary("version", &os_version_value
)) {
454 os_version_value
->GetString(kOp
, &os_version_op
);
455 os_version_value
->GetString("value", &os_version_string
);
456 os_version_value
->GetString("value2", &os_version_string2
);
458 if (!entry
->SetOsInfo(os_type
, os_version_op
, os_version_string
,
459 os_version_string2
)) {
460 LOG(WARNING
) << "Malformed os entry " << entry
->id();
463 dictionary_entry_count
++;
466 std::string vendor_id
;
467 if (value
->GetString("vendor_id", &vendor_id
)) {
468 if (!entry
->SetVendorId(vendor_id
)) {
469 LOG(WARNING
) << "Malformed vendor_id entry " << entry
->id();
472 dictionary_entry_count
++;
475 const base::ListValue
* device_id_list
;
476 if (value
->GetList("device_id", &device_id_list
)) {
477 for (size_t i
= 0; i
< device_id_list
->GetSize(); ++i
) {
478 std::string device_id
;
479 if (!device_id_list
->GetString(i
, &device_id
) ||
480 !entry
->AddDeviceId(device_id
)) {
481 LOG(WARNING
) << "Malformed device_id entry " << entry
->id();
485 dictionary_entry_count
++;
488 std::string multi_gpu_style
;
489 if (value
->GetString("multi_gpu_style", &multi_gpu_style
)) {
490 if (!entry
->SetMultiGpuStyle(multi_gpu_style
)) {
491 LOG(WARNING
) << "Malformed multi_gpu_style entry " << entry
->id();
494 dictionary_entry_count
++;
497 std::string multi_gpu_category
;
498 if (value
->GetString("multi_gpu_category", &multi_gpu_category
)) {
499 if (!entry
->SetMultiGpuCategory(multi_gpu_category
)) {
500 LOG(WARNING
) << "Malformed multi_gpu_category entry " << entry
->id();
503 dictionary_entry_count
++;
506 std::string driver_vendor_value
;
507 if (value
->GetString("driver_vendor", &driver_vendor_value
)) {
508 if (!entry
->SetDriverVendorInfo(driver_vendor_value
)) {
509 LOG(WARNING
) << "Malformed driver_vendor entry " << entry
->id();
512 dictionary_entry_count
++;
515 const base::DictionaryValue
* driver_version_value
= NULL
;
516 if (value
->GetDictionary("driver_version", &driver_version_value
)) {
517 std::string driver_version_op
= "any";
518 std::string driver_version_style
;
519 std::string driver_version_string
;
520 std::string driver_version_string2
;
521 driver_version_value
->GetString(kOp
, &driver_version_op
);
522 driver_version_value
->GetString("style", &driver_version_style
);
523 driver_version_value
->GetString("value", &driver_version_string
);
524 driver_version_value
->GetString("value2", &driver_version_string2
);
525 if (!entry
->SetDriverVersionInfo(driver_version_op
,
526 driver_version_style
,
527 driver_version_string
,
528 driver_version_string2
)) {
529 LOG(WARNING
) << "Malformed driver_version entry " << entry
->id();
532 dictionary_entry_count
++;
535 const base::DictionaryValue
* driver_date_value
= NULL
;
536 if (value
->GetDictionary("driver_date", &driver_date_value
)) {
537 std::string driver_date_op
= "any";
538 std::string driver_date_string
;
539 std::string driver_date_string2
;
540 driver_date_value
->GetString(kOp
, &driver_date_op
);
541 driver_date_value
->GetString("value", &driver_date_string
);
542 driver_date_value
->GetString("value2", &driver_date_string2
);
543 if (!entry
->SetDriverDateInfo(driver_date_op
, driver_date_string
,
544 driver_date_string2
)) {
545 LOG(WARNING
) << "Malformed driver_date entry " << entry
->id();
548 dictionary_entry_count
++;
552 if (value
->GetString("gl_type", &gl_type
)) {
553 if (!entry
->SetGLType(gl_type
)) {
554 LOG(WARNING
) << "Malformed gl_type entry " << entry
->id();
557 dictionary_entry_count
++;
560 const base::DictionaryValue
* gl_version_value
= NULL
;
561 if (value
->GetDictionary("gl_version", &gl_version_value
)) {
562 std::string version_op
= "any";
563 std::string version_string
;
564 std::string version_string2
;
565 gl_version_value
->GetString(kOp
, &version_op
);
566 gl_version_value
->GetString("value", &version_string
);
567 gl_version_value
->GetString("value2", &version_string2
);
568 if (!entry
->SetGLVersionInfo(
569 version_op
, version_string
, version_string2
)) {
570 LOG(WARNING
) << "Malformed gl_version entry " << entry
->id();
573 dictionary_entry_count
++;
576 std::string gl_vendor_value
;
577 if (value
->GetString("gl_vendor", &gl_vendor_value
)) {
578 if (!entry
->SetGLVendorInfo(gl_vendor_value
)) {
579 LOG(WARNING
) << "Malformed gl_vendor entry " << entry
->id();
582 dictionary_entry_count
++;
585 std::string gl_renderer_value
;
586 if (value
->GetString("gl_renderer", &gl_renderer_value
)) {
587 if (!entry
->SetGLRendererInfo(gl_renderer_value
)) {
588 LOG(WARNING
) << "Malformed gl_renderer entry " << entry
->id();
591 dictionary_entry_count
++;
594 std::string gl_extensions_value
;
595 if (value
->GetString("gl_extensions", &gl_extensions_value
)) {
596 if (!entry
->SetGLExtensionsInfo(gl_extensions_value
)) {
597 LOG(WARNING
) << "Malformed gl_extensions entry " << entry
->id();
600 dictionary_entry_count
++;
603 const base::DictionaryValue
* gl_reset_notification_strategy_value
= NULL
;
604 if (value
->GetDictionary("gl_reset_notification_strategy",
605 &gl_reset_notification_strategy_value
)) {
607 std::string int_value
;
608 std::string int_value2
;
609 gl_reset_notification_strategy_value
->GetString(kOp
, &op
);
610 gl_reset_notification_strategy_value
->GetString("value", &int_value
);
611 gl_reset_notification_strategy_value
->GetString("value2", &int_value2
);
612 if (!entry
->SetGLResetNotificationStrategyInfo(
613 op
, int_value
, int_value2
)) {
614 LOG(WARNING
) << "Malformed gl_reset_notification_strategy entry "
618 dictionary_entry_count
++;
621 std::string cpu_brand_value
;
622 if (value
->GetString("cpu_info", &cpu_brand_value
)) {
623 if (!entry
->SetCpuBrand(cpu_brand_value
)) {
624 LOG(WARNING
) << "Malformed cpu_brand entry " << entry
->id();
627 dictionary_entry_count
++;
630 const base::DictionaryValue
* perf_graphics_value
= NULL
;
631 if (value
->GetDictionary("perf_graphics", &perf_graphics_value
)) {
633 std::string float_value
;
634 std::string float_value2
;
635 perf_graphics_value
->GetString(kOp
, &op
);
636 perf_graphics_value
->GetString("value", &float_value
);
637 perf_graphics_value
->GetString("value2", &float_value2
);
638 if (!entry
->SetPerfGraphicsInfo(op
, float_value
, float_value2
)) {
639 LOG(WARNING
) << "Malformed perf_graphics entry " << entry
->id();
642 dictionary_entry_count
++;
645 const base::DictionaryValue
* perf_gaming_value
= NULL
;
646 if (value
->GetDictionary("perf_gaming", &perf_gaming_value
)) {
648 std::string float_value
;
649 std::string float_value2
;
650 perf_gaming_value
->GetString(kOp
, &op
);
651 perf_gaming_value
->GetString("value", &float_value
);
652 perf_gaming_value
->GetString("value2", &float_value2
);
653 if (!entry
->SetPerfGamingInfo(op
, float_value
, float_value2
)) {
654 LOG(WARNING
) << "Malformed perf_gaming entry " << entry
->id();
657 dictionary_entry_count
++;
660 const base::DictionaryValue
* perf_overall_value
= NULL
;
661 if (value
->GetDictionary("perf_overall", &perf_overall_value
)) {
663 std::string float_value
;
664 std::string float_value2
;
665 perf_overall_value
->GetString(kOp
, &op
);
666 perf_overall_value
->GetString("value", &float_value
);
667 perf_overall_value
->GetString("value2", &float_value2
);
668 if (!entry
->SetPerfOverallInfo(op
, float_value
, float_value2
)) {
669 LOG(WARNING
) << "Malformed perf_overall entry " << entry
->id();
672 dictionary_entry_count
++;
675 const base::ListValue
* machine_model_name_list
;
676 if (value
->GetList("machine_model_name", &machine_model_name_list
)) {
677 for (size_t i
= 0; i
< machine_model_name_list
->GetSize(); ++i
) {
678 std::string model_name
;
679 if (!machine_model_name_list
->GetString(i
, &model_name
) ||
680 !entry
->AddMachineModelName(model_name
)) {
681 LOG(WARNING
) << "Malformed machine_model_name entry " << entry
->id();
685 dictionary_entry_count
++;
688 const base::DictionaryValue
* machine_model_version_value
= NULL
;
689 if (value
->GetDictionary(
690 "machine_model_version", &machine_model_version_value
)) {
691 std::string version_op
= "any";
692 std::string version_string
;
693 std::string version_string2
;
694 machine_model_version_value
->GetString(kOp
, &version_op
);
695 machine_model_version_value
->GetString("value", &version_string
);
696 machine_model_version_value
->GetString("value2", &version_string2
);
697 if (!entry
->SetMachineModelVersionInfo(
698 version_op
, version_string
, version_string2
)) {
699 LOG(WARNING
) << "Malformed machine_model_version entry " << entry
->id();
702 dictionary_entry_count
++;
705 const base::DictionaryValue
* gpu_count_value
= NULL
;
706 if (value
->GetDictionary("gpu_count", &gpu_count_value
)) {
708 std::string int_value
;
709 std::string int_value2
;
710 gpu_count_value
->GetString(kOp
, &op
);
711 gpu_count_value
->GetString("value", &int_value
);
712 gpu_count_value
->GetString("value2", &int_value2
);
713 if (!entry
->SetGpuCountInfo(op
, int_value
, int_value2
)) {
714 LOG(WARNING
) << "Malformed gpu_count entry " << entry
->id();
717 dictionary_entry_count
++;
720 bool direct_rendering
;
721 if (value
->GetBoolean("direct_rendering", &direct_rendering
)) {
722 entry
->SetDirectRenderingInfo(direct_rendering
);
723 dictionary_entry_count
++;
727 if (value
->GetBoolean("in_process_gpu", &in_process_gpu
)) {
728 entry
->SetInProcessGPUInfo(in_process_gpu
);
729 dictionary_entry_count
++;
733 const base::ListValue
* feature_value
= NULL
;
734 if (value
->GetList("features", &feature_value
)) {
735 std::vector
<std::string
> feature_list
;
736 for (size_t i
= 0; i
< feature_value
->GetSize(); ++i
) {
738 if (feature_value
->GetString(i
, &feature
)) {
739 feature_list
.push_back(feature
);
741 LOG(WARNING
) << "Malformed feature entry " << entry
->id();
745 if (!entry
->SetFeatures(
746 feature_list
, feature_map
, supports_feature_type_all
)) {
747 LOG(WARNING
) << "Malformed feature entry " << entry
->id();
750 dictionary_entry_count
++;
755 const base::ListValue
* exception_list_value
= NULL
;
756 if (value
->GetList("exceptions", &exception_list_value
)) {
757 for (size_t i
= 0; i
< exception_list_value
->GetSize(); ++i
) {
758 const base::DictionaryValue
* exception_value
= NULL
;
759 if (!exception_list_value
->GetDictionary(i
, &exception_value
)) {
760 LOG(WARNING
) << "Malformed exceptions entry " << entry
->id();
763 ScopedGpuControlListEntry
exception(GetEntryFromValue(
764 exception_value
, false, feature_map
, supports_feature_type_all
));
765 if (exception
.get() == NULL
) {
766 LOG(WARNING
) << "Malformed exceptions entry " << entry
->id();
769 // Exception should inherit vendor_id from parent, otherwise if only
770 // device_ids are specified in Exception, the info will be incomplete.
771 if (exception
->vendor_id_
== 0 && entry
->vendor_id_
!= 0)
772 exception
->vendor_id_
= entry
->vendor_id_
;
773 entry
->AddException(exception
);
775 dictionary_entry_count
++;
779 if (value
->size() != dictionary_entry_count
) {
780 LOG(WARNING
) << "Entry with unknown fields " << entry
->id();
784 // If GL_VERSION is specified, but no info about whether it's GL or GLES,
785 // we use the default for the platform. See GLType enum declaration.
786 if (entry
->gl_version_info_
.get() != NULL
&& entry
->gl_type_
== kGLTypeNone
)
787 entry
->gl_type_
= GetDefaultGLType();
792 GpuControlList::GpuControlListEntry::GpuControlListEntry()
796 multi_gpu_style_(kMultiGpuStyleNone
),
797 multi_gpu_category_(kMultiGpuCategoryPrimary
),
798 gl_type_(kGLTypeNone
) {
801 GpuControlList::GpuControlListEntry::~GpuControlListEntry() { }
803 bool GpuControlList::GpuControlListEntry::SetId(uint32 id
) {
811 void GpuControlList::GpuControlListEntry::SetDisabled(bool disabled
) {
812 disabled_
= disabled
;
815 bool GpuControlList::GpuControlListEntry::SetOsInfo(
816 const std::string
& os
,
817 const std::string
& version_op
,
818 const std::string
& version_string
,
819 const std::string
& version_string2
) {
820 os_info_
.reset(new OsInfo(os
, version_op
, version_string
, version_string2
));
821 return os_info_
->IsValid();
824 bool GpuControlList::GpuControlListEntry::SetVendorId(
825 const std::string
& vendor_id_string
) {
827 return base::HexStringToUInt(vendor_id_string
, &vendor_id_
) &&
831 bool GpuControlList::GpuControlListEntry::AddDeviceId(
832 const std::string
& device_id_string
) {
833 uint32 device_id
= 0;
834 if (base::HexStringToUInt(device_id_string
, &device_id
) && device_id
!= 0) {
835 device_id_list_
.push_back(device_id
);
841 bool GpuControlList::GpuControlListEntry::SetMultiGpuStyle(
842 const std::string
& multi_gpu_style_string
) {
843 MultiGpuStyle style
= StringToMultiGpuStyle(multi_gpu_style_string
);
844 if (style
== kMultiGpuStyleNone
)
846 multi_gpu_style_
= style
;
850 bool GpuControlList::GpuControlListEntry::SetMultiGpuCategory(
851 const std::string
& multi_gpu_category_string
) {
852 MultiGpuCategory category
=
853 StringToMultiGpuCategory(multi_gpu_category_string
);
854 if (category
== kMultiGpuCategoryNone
)
856 multi_gpu_category_
= category
;
860 bool GpuControlList::GpuControlListEntry::SetGLType(
861 const std::string
& gl_type_string
) {
862 GLType gl_type
= StringToGLType(gl_type_string
);
863 if (gl_type
== kGLTypeNone
)
869 bool GpuControlList::GpuControlListEntry::SetDriverVendorInfo(
870 const std::string
& vendor_value
) {
871 driver_vendor_info_
= vendor_value
;
872 return !driver_vendor_info_
.empty();
875 bool GpuControlList::GpuControlListEntry::SetDriverVersionInfo(
876 const std::string
& version_op
,
877 const std::string
& version_style
,
878 const std::string
& version_string
,
879 const std::string
& version_string2
) {
880 driver_version_info_
.reset(new VersionInfo(
881 version_op
, version_style
, version_string
, version_string2
));
882 return driver_version_info_
->IsValid();
885 bool GpuControlList::GpuControlListEntry::SetDriverDateInfo(
886 const std::string
& date_op
,
887 const std::string
& date_string
,
888 const std::string
& date_string2
) {
889 driver_date_info_
.reset(
890 new VersionInfo(date_op
, std::string(), date_string
, date_string2
));
891 return driver_date_info_
->IsValid();
894 bool GpuControlList::GpuControlListEntry::SetGLVersionInfo(
895 const std::string
& version_op
,
896 const std::string
& version_string
,
897 const std::string
& version_string2
) {
898 gl_version_info_
.reset(new VersionInfo(
899 version_op
, std::string(), version_string
, version_string2
));
900 return gl_version_info_
->IsValid();
903 bool GpuControlList::GpuControlListEntry::SetGLVendorInfo(
904 const std::string
& vendor_value
) {
905 gl_vendor_info_
= vendor_value
;
906 return !gl_vendor_info_
.empty();
909 bool GpuControlList::GpuControlListEntry::SetGLRendererInfo(
910 const std::string
& renderer_value
) {
911 gl_renderer_info_
= renderer_value
;
912 return !gl_renderer_info_
.empty();
915 bool GpuControlList::GpuControlListEntry::SetGLExtensionsInfo(
916 const std::string
& extensions_value
) {
917 gl_extensions_info_
= extensions_value
;
918 return !gl_extensions_info_
.empty();
921 bool GpuControlList::GpuControlListEntry::SetGLResetNotificationStrategyInfo(
922 const std::string
& op
,
923 const std::string
& int_string
,
924 const std::string
& int_string2
) {
925 gl_reset_notification_strategy_info_
.reset(
926 new IntInfo(op
, int_string
, int_string2
));
927 return gl_reset_notification_strategy_info_
->IsValid();
930 bool GpuControlList::GpuControlListEntry::SetCpuBrand(
931 const std::string
& cpu_value
) {
932 cpu_brand_
= cpu_value
;
933 return !cpu_brand_
.empty();
936 bool GpuControlList::GpuControlListEntry::SetPerfGraphicsInfo(
937 const std::string
& op
,
938 const std::string
& float_string
,
939 const std::string
& float_string2
) {
940 perf_graphics_info_
.reset(new FloatInfo(op
, float_string
, float_string2
));
941 return perf_graphics_info_
->IsValid();
944 bool GpuControlList::GpuControlListEntry::SetPerfGamingInfo(
945 const std::string
& op
,
946 const std::string
& float_string
,
947 const std::string
& float_string2
) {
948 perf_gaming_info_
.reset(new FloatInfo(op
, float_string
, float_string2
));
949 return perf_gaming_info_
->IsValid();
952 bool GpuControlList::GpuControlListEntry::SetPerfOverallInfo(
953 const std::string
& op
,
954 const std::string
& float_string
,
955 const std::string
& float_string2
) {
956 perf_overall_info_
.reset(new FloatInfo(op
, float_string
, float_string2
));
957 return perf_overall_info_
->IsValid();
960 bool GpuControlList::GpuControlListEntry::AddMachineModelName(
961 const std::string
& model_name
) {
962 if (model_name
.empty())
964 machine_model_name_list_
.push_back(model_name
);
968 bool GpuControlList::GpuControlListEntry::SetMachineModelVersionInfo(
969 const std::string
& version_op
,
970 const std::string
& version_string
,
971 const std::string
& version_string2
) {
972 machine_model_version_info_
.reset(new VersionInfo(
973 version_op
, std::string(), version_string
, version_string2
));
974 return machine_model_version_info_
->IsValid();
977 bool GpuControlList::GpuControlListEntry::SetGpuCountInfo(
978 const std::string
& op
,
979 const std::string
& int_string
,
980 const std::string
& int_string2
) {
981 gpu_count_info_
.reset(new IntInfo(op
, int_string
, int_string2
));
982 return gpu_count_info_
->IsValid();
985 void GpuControlList::GpuControlListEntry::SetDirectRenderingInfo(bool value
) {
986 direct_rendering_info_
.reset(new BoolInfo(value
));
989 void GpuControlList::GpuControlListEntry::SetInProcessGPUInfo(bool value
) {
990 in_process_gpu_info_
.reset(new BoolInfo(value
));
993 bool GpuControlList::GpuControlListEntry::SetFeatures(
994 const std::vector
<std::string
>& feature_strings
,
995 const FeatureMap
& feature_map
,
996 bool supports_feature_type_all
) {
997 size_t size
= feature_strings
.size();
1001 for (size_t i
= 0; i
< size
; ++i
) {
1003 if (supports_feature_type_all
&& feature_strings
[i
] == "all") {
1004 for (FeatureMap::const_iterator iter
= feature_map
.begin();
1005 iter
!= feature_map
.end(); ++iter
)
1006 features_
.insert(iter
->second
);
1009 if (!StringToFeature(feature_strings
[i
], &feature
, feature_map
)) {
1013 features_
.insert(feature
);
1018 void GpuControlList::GpuControlListEntry::AddException(
1019 ScopedGpuControlListEntry exception
) {
1020 exceptions_
.push_back(exception
);
1023 bool GpuControlList::GpuControlListEntry::GLVersionInfoMismatch(
1024 const std::string
& gl_version
) const {
1025 if (gl_version
.empty())
1028 if (gl_version_info_
.get() == NULL
&& gl_type_
== kGLTypeNone
)
1031 std::vector
<std::string
> segments
;
1032 base::SplitString(gl_version
, ' ', &segments
);
1034 GLType gl_type
= kGLTypeNone
;
1035 if (segments
.size() > 2 &&
1036 segments
[0] == "OpenGL" && segments
[1] == "ES") {
1037 bool full_match
= RE2::FullMatch(segments
[2], "([\\d.]+).*", &number
);
1040 gl_type
= kGLTypeGLES
;
1041 if (segments
.size() > 3 &&
1042 base::StartsWith(segments
[3], "(ANGLE",
1043 base::CompareCase::INSENSITIVE_ASCII
)) {
1044 gl_type
= kGLTypeANGLE
;
1047 number
= segments
[0];
1048 gl_type
= kGLTypeGL
;
1051 if (gl_type_
!= kGLTypeNone
&& gl_type_
!= gl_type
)
1053 if (gl_version_info_
.get() != NULL
&& !gl_version_info_
->Contains(number
))
1059 GpuControlList::GpuControlListEntry::MultiGpuStyle
1060 GpuControlList::GpuControlListEntry::StringToMultiGpuStyle(
1061 const std::string
& style
) {
1062 if (style
== kMultiGpuStyleStringOptimus
)
1063 return kMultiGpuStyleOptimus
;
1064 if (style
== kMultiGpuStyleStringAMDSwitchable
)
1065 return kMultiGpuStyleAMDSwitchable
;
1066 if (style
== kMultiGpuStyleStringAMDSwitchableIntegrated
)
1067 return kMultiGpuStyleAMDSwitchableIntegrated
;
1068 if (style
== kMultiGpuStyleStringAMDSwitchableDiscrete
)
1069 return kMultiGpuStyleAMDSwitchableDiscrete
;
1070 return kMultiGpuStyleNone
;
1074 GpuControlList::GpuControlListEntry::MultiGpuCategory
1075 GpuControlList::GpuControlListEntry::StringToMultiGpuCategory(
1076 const std::string
& category
) {
1077 if (category
== kMultiGpuCategoryStringPrimary
)
1078 return kMultiGpuCategoryPrimary
;
1079 if (category
== kMultiGpuCategoryStringSecondary
)
1080 return kMultiGpuCategorySecondary
;
1081 if (category
== kMultiGpuCategoryStringActive
)
1082 return kMultiGpuCategoryActive
;
1083 if (category
== kMultiGpuCategoryStringAny
)
1084 return kMultiGpuCategoryAny
;
1085 return kMultiGpuCategoryNone
;
1089 GpuControlList::GpuControlListEntry::GLType
1090 GpuControlList::GpuControlListEntry::StringToGLType(
1091 const std::string
& gl_type
) {
1092 if (gl_type
== kGLTypeStringGL
)
1094 if (gl_type
== kGLTypeStringGLES
)
1096 if (gl_type
== kGLTypeStringANGLE
)
1097 return kGLTypeANGLE
;
1102 GpuControlList::GpuControlListEntry::GLType
1103 GpuControlList::GpuControlListEntry::GetDefaultGLType() {
1104 #if defined(OS_CHROMEOS)
1106 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
1108 #elif defined(OS_MACOSX)
1110 #elif defined(OS_WIN)
1111 return kGLTypeANGLE
;
1112 #elif defined(OS_ANDROID)
1119 void GpuControlList::GpuControlListEntry::LogControlListMatch(
1120 const std::string
& control_list_logging_name
) const {
1121 static const char kControlListMatchMessage
[] =
1122 "Control list match for rule #%u in %s.";
1123 VLOG(1) << base::StringPrintf(kControlListMatchMessage
, id_
,
1124 control_list_logging_name
.c_str());
1127 bool GpuControlList::GpuControlListEntry::Contains(
1128 OsType os_type
, const std::string
& os_version
,
1129 const GPUInfo
& gpu_info
) const {
1130 DCHECK(os_type
!= kOsAny
);
1131 if (os_info_
.get() != NULL
&& !os_info_
->Contains(os_type
, os_version
))
1133 if (vendor_id_
!= 0) {
1134 std::vector
<GPUInfo::GPUDevice
> candidates
;
1135 switch (multi_gpu_category_
) {
1136 case kMultiGpuCategoryPrimary
:
1137 candidates
.push_back(gpu_info
.gpu
);
1139 case kMultiGpuCategorySecondary
:
1140 candidates
= gpu_info
.secondary_gpus
;
1142 case kMultiGpuCategoryAny
:
1143 candidates
= gpu_info
.secondary_gpus
;
1144 candidates
.push_back(gpu_info
.gpu
);
1146 case kMultiGpuCategoryActive
:
1147 if (gpu_info
.gpu
.active
)
1148 candidates
.push_back(gpu_info
.gpu
);
1149 for (size_t ii
= 0; ii
< gpu_info
.secondary_gpus
.size(); ++ii
) {
1150 if (gpu_info
.secondary_gpus
[ii
].active
)
1151 candidates
.push_back(gpu_info
.secondary_gpus
[ii
]);
1157 GPUInfo::GPUDevice gpu
;
1158 gpu
.vendor_id
= vendor_id_
;
1160 if (device_id_list_
.empty()) {
1161 for (size_t ii
= 0; ii
< candidates
.size(); ++ii
) {
1162 if (gpu
.vendor_id
== candidates
[ii
].vendor_id
) {
1168 for (size_t ii
= 0; ii
< device_id_list_
.size(); ++ii
) {
1169 gpu
.device_id
= device_id_list_
[ii
];
1170 for (size_t jj
= 0; jj
< candidates
.size(); ++jj
) {
1171 if (gpu
.vendor_id
== candidates
[jj
].vendor_id
&&
1172 gpu
.device_id
== candidates
[jj
].device_id
) {
1182 switch (multi_gpu_style_
) {
1183 case kMultiGpuStyleOptimus
:
1184 if (!gpu_info
.optimus
)
1187 case kMultiGpuStyleAMDSwitchable
:
1188 if (!gpu_info
.amd_switchable
)
1191 case kMultiGpuStyleAMDSwitchableDiscrete
:
1192 if (!gpu_info
.amd_switchable
)
1194 // The discrete GPU is always the primary GPU.
1195 // This is guaranteed by GpuInfoCollector.
1196 if (!gpu_info
.gpu
.active
)
1199 case kMultiGpuStyleAMDSwitchableIntegrated
:
1200 if (!gpu_info
.amd_switchable
)
1202 // Assume the integrated GPU is the first in the secondary GPU list.
1203 if (gpu_info
.secondary_gpus
.size() == 0 ||
1204 !gpu_info
.secondary_gpus
[0].active
)
1207 case kMultiGpuStyleNone
:
1210 if (StringMismatch(gpu_info
.driver_vendor
, driver_vendor_info_
))
1212 if (driver_version_info_
.get() != NULL
&& !gpu_info
.driver_version
.empty()) {
1213 if (!driver_version_info_
->Contains(gpu_info
.driver_version
))
1216 if (driver_date_info_
.get() != NULL
&& !gpu_info
.driver_date
.empty()) {
1217 if (!driver_date_info_
->Contains(gpu_info
.driver_date
, '-'))
1220 if (GLVersionInfoMismatch(gpu_info
.gl_version
))
1222 if (StringMismatch(gpu_info
.gl_vendor
, gl_vendor_info_
))
1224 if (StringMismatch(gpu_info
.gl_renderer
, gl_renderer_info_
))
1226 if (StringMismatch(gpu_info
.gl_extensions
, gl_extensions_info_
))
1228 if (gl_reset_notification_strategy_info_
.get() != NULL
&&
1229 !gl_reset_notification_strategy_info_
->Contains(
1230 gpu_info
.gl_reset_notification_strategy
))
1232 if (!machine_model_name_list_
.empty()) {
1233 if (gpu_info
.machine_model_name
.empty())
1235 bool found_match
= false;
1236 for (size_t ii
= 0; ii
< machine_model_name_list_
.size(); ++ii
) {
1237 if (RE2::FullMatch(gpu_info
.machine_model_name
,
1238 machine_model_name_list_
[ii
])) {
1246 if (machine_model_version_info_
.get() != NULL
&&
1247 (gpu_info
.machine_model_version
.empty() ||
1248 !machine_model_version_info_
->Contains(gpu_info
.machine_model_version
)))
1250 if (gpu_count_info_
.get() != NULL
&&
1251 !gpu_count_info_
->Contains(gpu_info
.secondary_gpus
.size() + 1))
1253 if (direct_rendering_info_
.get() != NULL
&&
1254 !direct_rendering_info_
->Contains(gpu_info
.direct_rendering
))
1256 if (in_process_gpu_info_
.get() != NULL
&&
1257 !in_process_gpu_info_
->Contains(gpu_info
.in_process_gpu
))
1259 if (!cpu_brand_
.empty()) {
1261 if (StringMismatch(cpu_info
.cpu_brand(), cpu_brand_
))
1265 for (size_t i
= 0; i
< exceptions_
.size(); ++i
) {
1266 if (exceptions_
[i
]->Contains(os_type
, os_version
, gpu_info
) &&
1267 !exceptions_
[i
]->NeedsMoreInfo(gpu_info
, true))
1273 bool GpuControlList::GpuControlListEntry::NeedsMoreInfo(
1274 const GPUInfo
& gpu_info
,
1275 bool consider_exceptions
) const {
1276 // We only check for missing info that might be collected with a gl context.
1277 // If certain info is missing due to some error, say, we fail to collect
1278 // vendor_id/device_id, then even if we launch GPU process and create a gl
1279 // context, we won't gather such missing info, so we still return false.
1280 if (!driver_vendor_info_
.empty() && gpu_info
.driver_vendor
.empty())
1282 if (driver_version_info_
.get() && gpu_info
.driver_version
.empty())
1284 if (!gl_vendor_info_
.empty() && gpu_info
.gl_vendor
.empty())
1286 if (!gl_renderer_info_
.empty() && gpu_info
.gl_renderer
.empty())
1289 if (consider_exceptions
) {
1290 for (size_t i
= 0; i
< exceptions_
.size(); ++i
) {
1291 if (exceptions_
[i
]->NeedsMoreInfo(gpu_info
, consider_exceptions
))
1299 GpuControlList::OsType
GpuControlList::GpuControlListEntry::GetOsType() const {
1300 if (os_info_
.get() == NULL
)
1302 return os_info_
->type();
1305 uint32
GpuControlList::GpuControlListEntry::id() const {
1309 bool GpuControlList::GpuControlListEntry::disabled() const {
1313 const std::set
<int>& GpuControlList::GpuControlListEntry::features() const {
1317 void GpuControlList::GpuControlListEntry::GetFeatureNames(
1318 base::ListValue
* feature_names
,
1319 const FeatureMap
& feature_map
,
1320 bool supports_feature_type_all
) const {
1321 DCHECK(feature_names
);
1322 if (supports_feature_type_all
&& features_
.size() == feature_map
.size()) {
1323 feature_names
->AppendString("all");
1326 for (FeatureMap::const_iterator iter
= feature_map
.begin();
1327 iter
!= feature_map
.end(); ++iter
) {
1328 if (features_
.count(iter
->second
) > 0)
1329 feature_names
->AppendString(iter
->first
);
1334 bool GpuControlList::GpuControlListEntry::StringToFeature(
1335 const std::string
& feature_name
, int* feature_id
,
1336 const FeatureMap
& feature_map
) {
1337 FeatureMap::const_iterator iter
= feature_map
.find(feature_name
);
1338 if (iter
!= feature_map
.end()) {
1339 *feature_id
= iter
->second
;
1345 GpuControlList::GpuControlList()
1347 needs_more_info_(false),
1348 supports_feature_type_all_(false),
1349 control_list_logging_enabled_(false) {
1352 GpuControlList::~GpuControlList() {
1356 bool GpuControlList::LoadList(
1357 const std::string
& json_context
,
1358 GpuControlList::OsFilter os_filter
) {
1359 scoped_ptr
<base::Value
> root
= base::JSONReader::Read(json_context
);
1360 if (root
.get() == NULL
|| !root
->IsType(base::Value::TYPE_DICTIONARY
))
1363 base::DictionaryValue
* root_dictionary
=
1364 static_cast<base::DictionaryValue
*>(root
.get());
1365 DCHECK(root_dictionary
);
1366 return LoadList(*root_dictionary
, os_filter
);
1369 bool GpuControlList::LoadList(const base::DictionaryValue
& parsed_json
,
1370 GpuControlList::OsFilter os_filter
) {
1371 std::vector
<ScopedGpuControlListEntry
> entries
;
1373 parsed_json
.GetString("version", &version_
);
1374 std::vector
<std::string
> pieces
;
1375 if (!ProcessVersionString(version_
, '.', &pieces
))
1378 const base::ListValue
* list
= NULL
;
1379 if (!parsed_json
.GetList("entries", &list
))
1382 uint32 max_entry_id
= 0;
1383 for (size_t i
= 0; i
< list
->GetSize(); ++i
) {
1384 const base::DictionaryValue
* list_item
= NULL
;
1385 bool valid
= list
->GetDictionary(i
, &list_item
);
1386 if (!valid
|| list_item
== NULL
)
1388 ScopedGpuControlListEntry
entry(GpuControlListEntry::GetEntryFromValue(
1389 list_item
, true, feature_map_
, supports_feature_type_all_
));
1390 if (entry
.get() == NULL
)
1392 if (entry
->id() > max_entry_id
)
1393 max_entry_id
= entry
->id();
1394 entries
.push_back(entry
);
1398 OsType my_os
= GetOsType();
1399 for (size_t i
= 0; i
< entries
.size(); ++i
) {
1400 OsType entry_os
= entries
[i
]->GetOsType();
1401 if (os_filter
== GpuControlList::kAllOs
||
1402 entry_os
== kOsAny
|| entry_os
== my_os
)
1403 entries_
.push_back(entries
[i
]);
1405 max_entry_id_
= max_entry_id
;
1409 std::set
<int> GpuControlList::MakeDecision(
1410 GpuControlList::OsType os
,
1411 std::string os_version
,
1412 const GPUInfo
& gpu_info
) {
1413 active_entries_
.clear();
1414 std::set
<int> features
;
1416 needs_more_info_
= false;
1417 // Has all features permanently in the list without any possibility of
1418 // removal in the future (subset of "features" set).
1419 std::set
<int> permanent_features
;
1420 // Has all features absent from "features" set that could potentially be
1421 // included later with more information.
1422 std::set
<int> potential_features
;
1426 if (os_version
.empty())
1427 os_version
= base::SysInfo::OperatingSystemVersion();
1429 for (size_t i
= 0; i
< entries_
.size(); ++i
) {
1430 ScopedGpuControlListEntry entry
= entries_
[i
];
1431 if (entry
->Contains(os
, os_version
, gpu_info
)) {
1432 bool needs_more_info_main
= entry
->NeedsMoreInfo(gpu_info
, false);
1433 bool needs_more_info_exception
= entry
->NeedsMoreInfo(gpu_info
, true);
1435 if (!entry
->disabled()) {
1436 if (control_list_logging_enabled_
)
1437 entry
->LogControlListMatch(control_list_logging_name_
);
1438 // Only look at main entry info when deciding what to add to "features"
1439 // set. If we don't have enough info for an exception, it's safer if we
1440 // just ignore the exception and assume the exception doesn't apply.
1441 for (std::set
<int>::const_iterator iter
= entry
->features().begin();
1442 iter
!= entry
->features().end(); ++iter
) {
1443 if (needs_more_info_main
) {
1444 if (!features
.count(*iter
))
1445 potential_features
.insert(*iter
);
1447 features
.insert(*iter
);
1448 potential_features
.erase(*iter
);
1449 if (!needs_more_info_exception
)
1450 permanent_features
.insert(*iter
);
1455 if (!needs_more_info_main
)
1456 active_entries_
.push_back(entry
);
1460 needs_more_info_
= permanent_features
.size() < features
.size() ||
1461 !potential_features
.empty();
1465 void GpuControlList::GetDecisionEntries(
1466 std::vector
<uint32
>* entry_ids
, bool disabled
) const {
1469 for (size_t i
= 0; i
< active_entries_
.size(); ++i
) {
1470 if (disabled
== active_entries_
[i
]->disabled())
1471 entry_ids
->push_back(active_entries_
[i
]->id());
1475 std::vector
<std::string
> GpuControlList::GetDisabledExtensions() {
1476 std::set
<std::string
> disabled_extensions
;
1477 for (size_t i
= 0; i
< active_entries_
.size(); ++i
) {
1478 GpuControlListEntry
* entry
= active_entries_
[i
].get();
1480 if (entry
->disabled())
1483 disabled_extensions
.insert(entry
->disabled_extensions().begin(),
1484 entry
->disabled_extensions().end());
1486 return std::vector
<std::string
>(disabled_extensions
.begin(),
1487 disabled_extensions
.end());
1490 void GpuControlList::GetReasons(base::ListValue
* problem_list
,
1491 const std::string
& tag
) const {
1492 DCHECK(problem_list
);
1493 for (size_t i
= 0; i
< active_entries_
.size(); ++i
) {
1494 GpuControlListEntry
* entry
= active_entries_
[i
].get();
1495 if (entry
->disabled())
1497 base::DictionaryValue
* problem
= new base::DictionaryValue();
1499 problem
->SetString("description", entry
->description());
1501 base::ListValue
* cr_bugs
= new base::ListValue();
1502 for (size_t j
= 0; j
< entry
->cr_bugs().size(); ++j
)
1503 cr_bugs
->Append(new base::FundamentalValue(entry
->cr_bugs()[j
]));
1504 problem
->Set("crBugs", cr_bugs
);
1506 base::ListValue
* webkit_bugs
= new base::ListValue();
1507 for (size_t j
= 0; j
< entry
->webkit_bugs().size(); ++j
) {
1508 webkit_bugs
->Append(new base::FundamentalValue(entry
->webkit_bugs()[j
]));
1510 problem
->Set("webkitBugs", webkit_bugs
);
1512 base::ListValue
* features
= new base::ListValue();
1513 entry
->GetFeatureNames(features
, feature_map_
, supports_feature_type_all_
);
1514 problem
->Set("affectedGpuSettings", features
);
1516 DCHECK(tag
== "workarounds" || tag
== "disabledFeatures");
1517 problem
->SetString("tag", tag
);
1519 problem_list
->Append(problem
);
1523 size_t GpuControlList::num_entries() const {
1524 return entries_
.size();
1527 uint32
GpuControlList::max_entry_id() const {
1528 return max_entry_id_
;
1531 std::string
GpuControlList::version() const {
1535 GpuControlList::OsType
GpuControlList::GetOsType() {
1536 #if defined(OS_CHROMEOS)
1538 #elif defined(OS_WIN)
1540 #elif defined(OS_ANDROID)
1542 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
1544 #elif defined(OS_MACOSX)
1551 void GpuControlList::Clear() {
1553 active_entries_
.clear();
1558 GpuControlList::NumericOp
GpuControlList::StringToNumericOp(
1559 const std::string
& op
) {
1572 if (op
== "between")
1577 void GpuControlList::AddSupportedFeature(
1578 const std::string
& feature_name
, int feature_id
) {
1579 feature_map_
[feature_name
] = feature_id
;
1582 void GpuControlList::set_supports_feature_type_all(bool supported
) {
1583 supports_feature_type_all_
= supported
;