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#include "gpu/config/gpu_control_list.h"
6
7#include "base/cpu.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"
18
19namespace gpu {
20namespace {
21
22// Break a version string into segments.  Return true if each segment is
23// a valid number, and not all segment is 0.
24bool ProcessVersionString(const std::string& version_string,
25                          char splitter,
26                          std::vector<std::string>* version) {
27  DCHECK(version);
28  base::SplitString(version_string, splitter, version);
29  if (version->size() == 0)
30    return false;
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];
37    }
38    (*version)[0] = year;
39  }
40  bool all_zero = true;
41  for (size_t i = 0; i < version->size(); ++i) {
42    unsigned num = 0;
43    if (!base::StringToUint((*version)[i], &num))
44      return false;
45    if (num)
46      all_zero = false;
47  }
48  return !all_zero;
49}
50
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.
55int CompareNumericalNumberStrings(
56    const std::string& number, const std::string& number_ref) {
57  unsigned value1 = 0;
58  unsigned value2 = 0;
59  bool valid = base::StringToUint(number, &value1);
60  DCHECK(valid);
61  valid = base::StringToUint(number_ref, &value2);
62  DCHECK(valid);
63  if (value1 == value2)
64    return 0;
65  if (value1 > value2)
66    return 1;
67  return -1;
68}
69
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.
78int CompareLexicalNumberStrings(
79    const std::string& number, const std::string& number_ref) {
80  for (size_t i = 0; i < number_ref.length(); ++i) {
81    unsigned value1 = 0;
82    if (i < number.length())
83      value1 = number[i] - '0';
84    unsigned value2 = number_ref[i] - '0';
85    if (value1 > value2)
86      return 1;
87    if (value1 < value2)
88      return -1;
89  }
90  return 0;
91}
92
93// A mismatch is identified only if both |input| and |pattern| are not empty.
94bool StringMismatch(const std::string& input, const std::string& pattern) {
95  if (input.empty() || pattern.empty())
96    return false;
97  return !RE2::FullMatch(input, pattern);
98}
99
100const char kMultiGpuStyleStringAMDSwitchable[] = "amd_switchable";
101const char kMultiGpuStyleStringAMDSwitchableDiscrete[] =
102    "amd_switchable_discrete";
103const char kMultiGpuStyleStringAMDSwitchableIntegrated[] =
104    "amd_switchable_integrated";
105const char kMultiGpuStyleStringOptimus[] = "optimus";
106
107const char kMultiGpuCategoryStringPrimary[] = "primary";
108const char kMultiGpuCategoryStringSecondary[] = "secondary";
109const char kMultiGpuCategoryStringActive[] = "active";
110const char kMultiGpuCategoryStringAny[] = "any";
111
112const char kGLTypeStringGL[] = "gl";
113const char kGLTypeStringGLES[] = "gles";
114const char kGLTypeStringANGLE[] = "angle";
115
116const char kVersionStyleStringNumerical[] = "numerical";
117const char kVersionStyleStringLexical[] = "lexical";
118
119const char kOp[] = "op";
120
121}  // namespace anonymous
122
123GpuControlList::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)
131    return;
132  version_style_ = StringToVersionStyle(version_style);
133  if (!ProcessVersionString(version_string, '.', &version_)) {
134    op_ = kUnknown;
135    return;
136  }
137  if (op_ == kBetween) {
138    if (!ProcessVersionString(version_string2, '.', &version2_))
139      op_ = kUnknown;
140  }
141}
142
143GpuControlList::VersionInfo::~VersionInfo() {
144}
145
146bool GpuControlList::VersionInfo::Contains(
147    const std::string& version_string) const {
148  return Contains(version_string, '.');
149}
150
151bool GpuControlList::VersionInfo::Contains(
152    const std::string& version_string, char splitter) const {
153  if (op_ == kUnknown)
154    return false;
155  if (op_ == kAny)
156    return true;
157  std::vector<std::string> version;
158  if (!ProcessVersionString(version_string, splitter, &version))
159    return false;
160  int relation = Compare(version, version_, version_style_);
161  if (op_ == kEQ)
162    return (relation == 0);
163  else if (op_ == kLT)
164    return (relation < 0);
165  else if (op_ == kLE)
166    return (relation <= 0);
167  else if (op_ == kGT)
168    return (relation > 0);
169  else if (op_ == kGE)
170    return (relation >= 0);
171  // op_ == kBetween
172  if (relation < 0)
173    return false;
174  return Compare(version, version2_, version_style_) <= 0;
175}
176
177bool GpuControlList::VersionInfo::IsValid() const {
178  return (op_ != kUnknown && version_style_ != kVersionStyleUnknown);
179}
180
181bool GpuControlList::VersionInfo::IsLexical() const {
182  return version_style_ == kVersionStyleLexical;
183}
184
185// static
186int 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())
194      return 0;
195    int ret = 0;
196    // We assume both versions are checked by ProcessVersionString().
197    if (i > 0 && version_style == kVersionStyleLexical)
198      ret = CompareLexicalNumberStrings(version[i], version_ref[i]);
199    else
200      ret = CompareNumericalNumberStrings(version[i], version_ref[i]);
201    if (ret != 0)
202      return ret;
203  }
204  return 0;
205}
206
207// static
208GpuControlList::VersionInfo::VersionStyle
209GpuControlList::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;
216}
217
218GpuControlList::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));
226  }
227}
228
229GpuControlList::OsInfo::~OsInfo() {}
230
231bool GpuControlList::OsInfo::Contains(
232    OsType type, const std::string& version) const {
233  if (!IsValid())
234    return false;
235  if (type_ != type && type_ != kOsAny)
236    return false;
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);
241  else
242    processed_version = version;
243
244  return version_info_->Contains(processed_version);
245}
246
247bool GpuControlList::OsInfo::IsValid() const {
248  return type_ != kOsUnknown && version_info_->IsValid();
249}
250
251GpuControlList::OsType GpuControlList::OsInfo::type() const {
252  return type_;
253}
254
255GpuControlList::OsType GpuControlList::OsInfo::StringToOsType(
256    const std::string& os) {
257  if (os == "win")
258    return kOsWin;
259  else if (os == "macosx")
260    return kOsMacosx;
261  else if (os == "android")
262    return kOsAndroid;
263  else if (os == "linux")
264    return kOsLinux;
265  else if (os == "chromeos")
266    return kOsChromeOS;
267  else if (os == "any")
268    return kOsAny;
269  return kOsUnknown;
270}
271
272GpuControlList::FloatInfo::FloatInfo(const std::string& float_op,
273                                     const std::string& float_value,
274                                     const std::string& float_value2)
275    : op_(kUnknown),
276      value_(0.f),
277      value2_(0.f) {
278  op_ = StringToNumericOp(float_op);
279  if (op_ == kAny)
280    return;
281  double dvalue = 0;
282  if (!base::StringToDouble(float_value, &dvalue)) {
283    op_ = kUnknown;
284    return;
285  }
286  value_ = static_cast<float>(dvalue);
287  if (op_ == kBetween) {
288    if (!base::StringToDouble(float_value2, &dvalue)) {
289      op_ = kUnknown;
290      return;
291    }
292    value2_ = static_cast<float>(dvalue);
293  }
294}
295
296bool GpuControlList::FloatInfo::Contains(float value) const {
297  if (op_ == kUnknown)
298    return false;
299  if (op_ == kAny)
300    return true;
301  if (op_ == kEQ)
302    return (value == value_);
303  if (op_ == kLT)
304    return (value < value_);
305  if (op_ == kLE)
306    return (value <= value_);
307  if (op_ == kGT)
308    return (value > value_);
309  if (op_ == kGE)
310    return (value >= value_);
311  DCHECK(op_ == kBetween);
312  return ((value_ <= value && value <= value2_) ||
313          (value2_ <= value && value <= value_));
314}
315
316bool GpuControlList::FloatInfo::IsValid() const {
317  return op_ != kUnknown;
318}
319
320GpuControlList::IntInfo::IntInfo(const std::string& int_op,
321                                 const std::string& int_value,
322                                 const std::string& int_value2)
323    : op_(kUnknown),
324      value_(0),
325      value2_(0) {
326  op_ = StringToNumericOp(int_op);
327  if (op_ == kAny)
328    return;
329  if (!base::StringToInt(int_value, &value_)) {
330    op_ = kUnknown;
331    return;
332  }
333  if (op_ == kBetween &&
334      !base::StringToInt(int_value2, &value2_))
335    op_ = kUnknown;
336}
337
338bool GpuControlList::IntInfo::Contains(int value) const {
339  if (op_ == kUnknown)
340    return false;
341  if (op_ == kAny)
342    return true;
343  if (op_ == kEQ)
344    return (value == value_);
345  if (op_ == kLT)
346    return (value < value_);
347  if (op_ == kLE)
348    return (value <= value_);
349  if (op_ == kGT)
350    return (value > value_);
351  if (op_ == kGE)
352    return (value >= value_);
353  DCHECK(op_ == kBetween);
354  return ((value_ <= value && value <= value2_) ||
355          (value2_ <= value && value <= value_));
356}
357
358bool GpuControlList::IntInfo::IsValid() const {
359  return op_ != kUnknown;
360}
361
362GpuControlList::BoolInfo::BoolInfo(bool value) : value_(value) {}
363
364bool GpuControlList::BoolInfo::Contains(bool value) const {
365  return value_ == value;
366}
367
368// static
369GpuControlList::ScopedGpuControlListEntry
370GpuControlList::GpuControlListEntry::GetEntryFromValue(
371    const base::DictionaryValue* value, bool top_level,
372    const FeatureMap& feature_map,
373    bool supports_feature_type_all) {
374  DCHECK(value);
375  ScopedGpuControlListEntry entry(new GpuControlListEntry());
376
377  size_t dictionary_entry_count = 0;
378
379  if (top_level) {
380    uint32 id;
381    if (!value->GetInteger("id", reinterpret_cast<int*>(&id)) ||
382        !entry->SetId(id)) {
383      LOG(WARNING) << "Malformed id entry " << entry->id();
384      return NULL;
385    }
386    dictionary_entry_count++;
387
388    bool disabled;
389    if (value->GetBoolean("disabled", &disabled)) {
390      entry->SetDisabled(disabled);
391      dictionary_entry_count++;
392    }
393  }
394
395  std::string description;
396  if (value->GetString("description", &description)) {
397    entry->description_ = description;
398    dictionary_entry_count++;
399  } else {
400    entry->description_ = "The GPU is unavailable for an unexplained reason.";
401  }
402
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) {
406      int bug_id;
407      if (cr_bugs->GetInteger(i, &bug_id)) {
408        entry->cr_bugs_.push_back(bug_id);
409      } else {
410        LOG(WARNING) << "Malformed cr_bugs entry " << entry->id();
411        return NULL;
412      }
413    }
414    dictionary_entry_count++;
415  }
416
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) {
420      int bug_id;
421      if (webkit_bugs->GetInteger(i, &bug_id)) {
422        entry->webkit_bugs_.push_back(bug_id);
423      } else {
424        LOG(WARNING) << "Malformed webkit_bugs entry " << entry->id();
425        return NULL;
426      }
427    }
428    dictionary_entry_count++;
429  }
430
431  const base::DictionaryValue* os_value = NULL;
432  if (value->GetDictionary("os", &os_value)) {
433    std::string os_type;
434    std::string os_version_op = "any";
435    std::string os_version_string;
436    std::string os_version_string2;
437    os_value->GetString("type", &os_type);
438    const base::DictionaryValue* os_version_value = NULL;
439    if (os_value->GetDictionary("version", &os_version_value)) {
440      os_version_value->GetString(kOp, &os_version_op);
441      os_version_value->GetString("value", &os_version_string);
442      os_version_value->GetString("value2", &os_version_string2);
443    }
444    if (!entry->SetOsInfo(os_type, os_version_op, os_version_string,
445                          os_version_string2)) {
446      LOG(WARNING) << "Malformed os entry " << entry->id();
447      return NULL;
448    }
449    dictionary_entry_count++;
450  }
451
452  std::string vendor_id;
453  if (value->GetString("vendor_id", &vendor_id)) {
454    if (!entry->SetVendorId(vendor_id)) {
455      LOG(WARNING) << "Malformed vendor_id entry " << entry->id();
456      return NULL;
457    }
458    dictionary_entry_count++;
459  }
460
461  const base::ListValue* device_id_list;
462  if (value->GetList("device_id", &device_id_list)) {
463    for (size_t i = 0; i < device_id_list->GetSize(); ++i) {
464      std::string device_id;
465      if (!device_id_list->GetString(i, &device_id) ||
466          !entry->AddDeviceId(device_id)) {
467        LOG(WARNING) << "Malformed device_id entry " << entry->id();
468        return NULL;
469      }
470    }
471    dictionary_entry_count++;
472  }
473
474  std::string multi_gpu_style;
475  if (value->GetString("multi_gpu_style", &multi_gpu_style)) {
476    if (!entry->SetMultiGpuStyle(multi_gpu_style)) {
477      LOG(WARNING) << "Malformed multi_gpu_style entry " << entry->id();
478      return NULL;
479    }
480    dictionary_entry_count++;
481  }
482
483  std::string multi_gpu_category;
484  if (value->GetString("multi_gpu_category", &multi_gpu_category)) {
485    if (!entry->SetMultiGpuCategory(multi_gpu_category)) {
486      LOG(WARNING) << "Malformed multi_gpu_category entry " << entry->id();
487      return NULL;
488    }
489    dictionary_entry_count++;
490  }
491
492  std::string driver_vendor_value;
493  if (value->GetString("driver_vendor", &driver_vendor_value)) {
494    if (!entry->SetDriverVendorInfo(driver_vendor_value)) {
495      LOG(WARNING) << "Malformed driver_vendor entry " << entry->id();
496      return NULL;
497    }
498    dictionary_entry_count++;
499  }
500
501  const base::DictionaryValue* driver_version_value = NULL;
502  if (value->GetDictionary("driver_version", &driver_version_value)) {
503    std::string driver_version_op = "any";
504    std::string driver_version_style;
505    std::string driver_version_string;
506    std::string driver_version_string2;
507    driver_version_value->GetString(kOp, &driver_version_op);
508    driver_version_value->GetString("style", &driver_version_style);
509    driver_version_value->GetString("value", &driver_version_string);
510    driver_version_value->GetString("value2", &driver_version_string2);
511    if (!entry->SetDriverVersionInfo(driver_version_op,
512                                     driver_version_style,
513                                     driver_version_string,
514                                     driver_version_string2)) {
515      LOG(WARNING) << "Malformed driver_version entry " << entry->id();
516      return NULL;
517    }
518    dictionary_entry_count++;
519  }
520
521  const base::DictionaryValue* driver_date_value = NULL;
522  if (value->GetDictionary("driver_date", &driver_date_value)) {
523    std::string driver_date_op = "any";
524    std::string driver_date_string;
525    std::string driver_date_string2;
526    driver_date_value->GetString(kOp, &driver_date_op);
527    driver_date_value->GetString("value", &driver_date_string);
528    driver_date_value->GetString("value2", &driver_date_string2);
529    if (!entry->SetDriverDateInfo(driver_date_op, driver_date_string,
530                                  driver_date_string2)) {
531      LOG(WARNING) << "Malformed driver_date entry " << entry->id();
532      return NULL;
533    }
534    dictionary_entry_count++;
535  }
536
537  std::string gl_type;
538  if (value->GetString("gl_type", &gl_type)) {
539    if (!entry->SetGLType(gl_type)) {
540      LOG(WARNING) << "Malformed gl_type entry " << entry->id();
541      return NULL;
542    }
543    dictionary_entry_count++;
544  }
545
546  const base::DictionaryValue* gl_version_value = NULL;
547  if (value->GetDictionary("gl_version", &gl_version_value)) {
548    std::string version_op = "any";
549    std::string version_string;
550    std::string version_string2;
551    gl_version_value->GetString(kOp, &version_op);
552    gl_version_value->GetString("value", &version_string);
553    gl_version_value->GetString("value2", &version_string2);
554    if (!entry->SetGLVersionInfo(
555            version_op, version_string, version_string2)) {
556      LOG(WARNING) << "Malformed gl_version entry " << entry->id();
557      return NULL;
558    }
559    dictionary_entry_count++;
560  }
561
562  std::string gl_vendor_value;
563  if (value->GetString("gl_vendor", &gl_vendor_value)) {
564    if (!entry->SetGLVendorInfo(gl_vendor_value)) {
565      LOG(WARNING) << "Malformed gl_vendor entry " << entry->id();
566      return NULL;
567    }
568    dictionary_entry_count++;
569  }
570
571  std::string gl_renderer_value;
572  if (value->GetString("gl_renderer", &gl_renderer_value)) {
573    if (!entry->SetGLRendererInfo(gl_renderer_value)) {
574      LOG(WARNING) << "Malformed gl_renderer entry " << entry->id();
575      return NULL;
576    }
577    dictionary_entry_count++;
578  }
579
580  std::string gl_extensions_value;
581  if (value->GetString("gl_extensions", &gl_extensions_value)) {
582    if (!entry->SetGLExtensionsInfo(gl_extensions_value)) {
583      LOG(WARNING) << "Malformed gl_extensions entry " << entry->id();
584      return NULL;
585    }
586    dictionary_entry_count++;
587  }
588
589  const base::DictionaryValue* gl_reset_notification_strategy_value = NULL;
590  if (value->GetDictionary("gl_reset_notification_strategy",
591                           &gl_reset_notification_strategy_value)) {
592    std::string op;
593    std::string int_value;
594    std::string int_value2;
595    gl_reset_notification_strategy_value->GetString(kOp, &op);
596    gl_reset_notification_strategy_value->GetString("value", &int_value);
597    gl_reset_notification_strategy_value->GetString("value2", &int_value2);
598    if (!entry->SetGLResetNotificationStrategyInfo(
599            op, int_value, int_value2)) {
600      LOG(WARNING) << "Malformed gl_reset_notification_strategy entry "
601                   << entry->id();
602      return NULL;
603    }
604    dictionary_entry_count++;
605  }
606
607  std::string cpu_brand_value;
608  if (value->GetString("cpu_info", &cpu_brand_value)) {
609    if (!entry->SetCpuBrand(cpu_brand_value)) {
610      LOG(WARNING) << "Malformed cpu_brand entry " << entry->id();
611      return NULL;
612    }
613    dictionary_entry_count++;
614  }
615
616  const base::DictionaryValue* perf_graphics_value = NULL;
617  if (value->GetDictionary("perf_graphics", &perf_graphics_value)) {
618    std::string op;
619    std::string float_value;
620    std::string float_value2;
621    perf_graphics_value->GetString(kOp, &op);
622    perf_graphics_value->GetString("value", &float_value);
623    perf_graphics_value->GetString("value2", &float_value2);
624    if (!entry->SetPerfGraphicsInfo(op, float_value, float_value2)) {
625      LOG(WARNING) << "Malformed perf_graphics entry " << entry->id();
626      return NULL;
627    }
628    dictionary_entry_count++;
629  }
630
631  const base::DictionaryValue* perf_gaming_value = NULL;
632  if (value->GetDictionary("perf_gaming", &perf_gaming_value)) {
633    std::string op;
634    std::string float_value;
635    std::string float_value2;
636    perf_gaming_value->GetString(kOp, &op);
637    perf_gaming_value->GetString("value", &float_value);
638    perf_gaming_value->GetString("value2", &float_value2);
639    if (!entry->SetPerfGamingInfo(op, float_value, float_value2)) {
640      LOG(WARNING) << "Malformed perf_gaming entry " << entry->id();
641      return NULL;
642    }
643    dictionary_entry_count++;
644  }
645
646  const base::DictionaryValue* perf_overall_value = NULL;
647  if (value->GetDictionary("perf_overall", &perf_overall_value)) {
648    std::string op;
649    std::string float_value;
650    std::string float_value2;
651    perf_overall_value->GetString(kOp, &op);
652    perf_overall_value->GetString("value", &float_value);
653    perf_overall_value->GetString("value2", &float_value2);
654    if (!entry->SetPerfOverallInfo(op, float_value, float_value2)) {
655      LOG(WARNING) << "Malformed perf_overall entry " << entry->id();
656      return NULL;
657    }
658    dictionary_entry_count++;
659  }
660
661  const base::ListValue* machine_model_name_list;
662  if (value->GetList("machine_model_name", &machine_model_name_list)) {
663    for (size_t i = 0; i < machine_model_name_list->GetSize(); ++i) {
664      std::string model_name;
665      if (!machine_model_name_list->GetString(i, &model_name) ||
666          !entry->AddMachineModelName(model_name)) {
667        LOG(WARNING) << "Malformed machine_model_name entry " << entry->id();
668        return NULL;
669      }
670    }
671    dictionary_entry_count++;
672  }
673
674  const base::DictionaryValue* machine_model_version_value = NULL;
675  if (value->GetDictionary(
676          "machine_model_version", &machine_model_version_value)) {
677    std::string version_op = "any";
678    std::string version_string;
679    std::string version_string2;
680    machine_model_version_value->GetString(kOp, &version_op);
681    machine_model_version_value->GetString("value", &version_string);
682    machine_model_version_value->GetString("value2", &version_string2);
683    if (!entry->SetMachineModelVersionInfo(
684            version_op, version_string, version_string2)) {
685      LOG(WARNING) << "Malformed machine_model_version entry " << entry->id();
686      return NULL;
687    }
688    dictionary_entry_count++;
689  }
690
691  const base::DictionaryValue* gpu_count_value = NULL;
692  if (value->GetDictionary("gpu_count", &gpu_count_value)) {
693    std::string op;
694    std::string int_value;
695    std::string int_value2;
696    gpu_count_value->GetString(kOp, &op);
697    gpu_count_value->GetString("value", &int_value);
698    gpu_count_value->GetString("value2", &int_value2);
699    if (!entry->SetGpuCountInfo(op, int_value, int_value2)) {
700      LOG(WARNING) << "Malformed gpu_count entry " << entry->id();
701      return NULL;
702    }
703    dictionary_entry_count++;
704  }
705
706  bool direct_rendering;
707  if (value->GetBoolean("direct_rendering", &direct_rendering)) {
708    entry->SetDirectRenderingInfo(direct_rendering);
709    dictionary_entry_count++;
710  }
711
712  if (top_level) {
713    const base::ListValue* feature_value = NULL;
714    if (value->GetList("features", &feature_value)) {
715      std::vector<std::string> feature_list;
716      for (size_t i = 0; i < feature_value->GetSize(); ++i) {
717        std::string feature;
718        if (feature_value->GetString(i, &feature)) {
719          feature_list.push_back(feature);
720        } else {
721          LOG(WARNING) << "Malformed feature entry " << entry->id();
722          return NULL;
723        }
724      }
725      if (!entry->SetFeatures(
726              feature_list, feature_map, supports_feature_type_all)) {
727        LOG(WARNING) << "Malformed feature entry " << entry->id();
728        return NULL;
729      }
730      dictionary_entry_count++;
731    }
732  }
733
734  if (top_level) {
735    const base::ListValue* exception_list_value = NULL;
736    if (value->GetList("exceptions", &exception_list_value)) {
737      for (size_t i = 0; i < exception_list_value->GetSize(); ++i) {
738        const base::DictionaryValue* exception_value = NULL;
739        if (!exception_list_value->GetDictionary(i, &exception_value)) {
740          LOG(WARNING) << "Malformed exceptions entry " << entry->id();
741          return NULL;
742        }
743        ScopedGpuControlListEntry exception(GetEntryFromValue(
744            exception_value, false, feature_map, supports_feature_type_all));
745        if (exception.get() == NULL) {
746          LOG(WARNING) << "Malformed exceptions entry " << entry->id();
747          return NULL;
748        }
749        // Exception should inherit vendor_id from parent, otherwise if only
750        // device_ids are specified in Exception, the info will be incomplete.
751        if (exception->vendor_id_ == 0 && entry->vendor_id_ != 0)
752          exception->vendor_id_ = entry->vendor_id_;
753        entry->AddException(exception);
754      }
755      dictionary_entry_count++;
756    }
757  }
758
759  if (value->size() != dictionary_entry_count) {
760    LOG(WARNING) << "Entry with unknown fields " << entry->id();
761    return NULL;
762  }
763
764  // If GL_VERSION is specified, but no info about whether it's GL or GLES,
765  // we use the default for the platform.  See GLType enum declaration.
766  if (entry->gl_version_info_.get() != NULL && entry->gl_type_ == kGLTypeNone)
767    entry->gl_type_ = GetDefaultGLType();
768
769  return entry;
770}
771
772GpuControlList::GpuControlListEntry::GpuControlListEntry()
773    : id_(0),
774      disabled_(false),
775      vendor_id_(0),
776      multi_gpu_style_(kMultiGpuStyleNone),
777      multi_gpu_category_(kMultiGpuCategoryPrimary),
778      gl_type_(kGLTypeNone) {
779}
780
781GpuControlList::GpuControlListEntry::~GpuControlListEntry() { }
782
783bool GpuControlList::GpuControlListEntry::SetId(uint32 id) {
784  if (id != 0) {
785    id_ = id;
786    return true;
787  }
788  return false;
789}
790
791void GpuControlList::GpuControlListEntry::SetDisabled(bool disabled) {
792  disabled_ = disabled;
793}
794
795bool GpuControlList::GpuControlListEntry::SetOsInfo(
796    const std::string& os,
797    const std::string& version_op,
798    const std::string& version_string,
799    const std::string& version_string2) {
800  os_info_.reset(new OsInfo(os, version_op, version_string, version_string2));
801  return os_info_->IsValid();
802}
803
804bool GpuControlList::GpuControlListEntry::SetVendorId(
805    const std::string& vendor_id_string) {
806  vendor_id_ = 0;
807  return base::HexStringToUInt(vendor_id_string, &vendor_id_) &&
808      vendor_id_ != 0;
809}
810
811bool GpuControlList::GpuControlListEntry::AddDeviceId(
812    const std::string& device_id_string) {
813  uint32 device_id = 0;
814  if (base::HexStringToUInt(device_id_string, &device_id) && device_id != 0) {
815    device_id_list_.push_back(device_id);
816    return true;
817  }
818  return false;
819}
820
821bool GpuControlList::GpuControlListEntry::SetMultiGpuStyle(
822    const std::string& multi_gpu_style_string) {
823  MultiGpuStyle style = StringToMultiGpuStyle(multi_gpu_style_string);
824  if (style == kMultiGpuStyleNone)
825    return false;
826  multi_gpu_style_ = style;
827  return true;
828}
829
830bool GpuControlList::GpuControlListEntry::SetMultiGpuCategory(
831    const std::string& multi_gpu_category_string) {
832  MultiGpuCategory category =
833      StringToMultiGpuCategory(multi_gpu_category_string);
834  if (category == kMultiGpuCategoryNone)
835    return false;
836  multi_gpu_category_ = category;
837  return true;
838}
839
840bool GpuControlList::GpuControlListEntry::SetGLType(
841    const std::string& gl_type_string) {
842  GLType gl_type = StringToGLType(gl_type_string);
843  if (gl_type == kGLTypeNone)
844    return false;
845  gl_type_ = gl_type;
846  return true;
847}
848
849bool GpuControlList::GpuControlListEntry::SetDriverVendorInfo(
850    const std::string& vendor_value) {
851  driver_vendor_info_ = vendor_value;
852  return !driver_vendor_info_.empty();
853}
854
855bool GpuControlList::GpuControlListEntry::SetDriverVersionInfo(
856    const std::string& version_op,
857    const std::string& version_style,
858    const std::string& version_string,
859    const std::string& version_string2) {
860  driver_version_info_.reset(new VersionInfo(
861      version_op, version_style, version_string, version_string2));
862  return driver_version_info_->IsValid();
863}
864
865bool GpuControlList::GpuControlListEntry::SetDriverDateInfo(
866    const std::string& date_op,
867    const std::string& date_string,
868    const std::string& date_string2) {
869  driver_date_info_.reset(
870      new VersionInfo(date_op, std::string(), date_string, date_string2));
871  return driver_date_info_->IsValid();
872}
873
874bool GpuControlList::GpuControlListEntry::SetGLVersionInfo(
875    const std::string& version_op,
876    const std::string& version_string,
877    const std::string& version_string2) {
878  gl_version_info_.reset(new VersionInfo(
879      version_op, std::string(), version_string, version_string2));
880  return gl_version_info_->IsValid();
881}
882
883bool GpuControlList::GpuControlListEntry::SetGLVendorInfo(
884    const std::string& vendor_value) {
885  gl_vendor_info_ = vendor_value;
886  return !gl_vendor_info_.empty();
887}
888
889bool GpuControlList::GpuControlListEntry::SetGLRendererInfo(
890    const std::string& renderer_value) {
891  gl_renderer_info_ = renderer_value;
892  return !gl_renderer_info_.empty();
893}
894
895bool GpuControlList::GpuControlListEntry::SetGLExtensionsInfo(
896    const std::string& extensions_value) {
897  gl_extensions_info_ = extensions_value;
898  return !gl_extensions_info_.empty();
899}
900
901bool GpuControlList::GpuControlListEntry::SetGLResetNotificationStrategyInfo(
902    const std::string& op,
903    const std::string& int_string,
904    const std::string& int_string2) {
905  gl_reset_notification_strategy_info_.reset(
906      new IntInfo(op, int_string, int_string2));
907  return gl_reset_notification_strategy_info_->IsValid();
908}
909
910bool GpuControlList::GpuControlListEntry::SetCpuBrand(
911    const std::string& cpu_value) {
912  cpu_brand_ = cpu_value;
913  return !cpu_brand_.empty();
914}
915
916bool GpuControlList::GpuControlListEntry::SetPerfGraphicsInfo(
917    const std::string& op,
918    const std::string& float_string,
919    const std::string& float_string2) {
920  perf_graphics_info_.reset(new FloatInfo(op, float_string, float_string2));
921  return perf_graphics_info_->IsValid();
922}
923
924bool GpuControlList::GpuControlListEntry::SetPerfGamingInfo(
925    const std::string& op,
926    const std::string& float_string,
927    const std::string& float_string2) {
928  perf_gaming_info_.reset(new FloatInfo(op, float_string, float_string2));
929  return perf_gaming_info_->IsValid();
930}
931
932bool GpuControlList::GpuControlListEntry::SetPerfOverallInfo(
933    const std::string& op,
934    const std::string& float_string,
935    const std::string& float_string2) {
936  perf_overall_info_.reset(new FloatInfo(op, float_string, float_string2));
937  return perf_overall_info_->IsValid();
938}
939
940bool GpuControlList::GpuControlListEntry::AddMachineModelName(
941    const std::string& model_name) {
942  if (model_name.empty())
943    return false;
944  machine_model_name_list_.push_back(model_name);
945  return true;
946}
947
948bool GpuControlList::GpuControlListEntry::SetMachineModelVersionInfo(
949    const std::string& version_op,
950    const std::string& version_string,
951    const std::string& version_string2) {
952  machine_model_version_info_.reset(new VersionInfo(
953      version_op, std::string(), version_string, version_string2));
954  return machine_model_version_info_->IsValid();
955}
956
957bool GpuControlList::GpuControlListEntry::SetGpuCountInfo(
958    const std::string& op,
959    const std::string& int_string,
960    const std::string& int_string2) {
961  gpu_count_info_.reset(new IntInfo(op, int_string, int_string2));
962  return gpu_count_info_->IsValid();
963}
964
965void GpuControlList::GpuControlListEntry::SetDirectRenderingInfo(bool value) {
966  direct_rendering_info_.reset(new BoolInfo(value));
967}
968
969bool GpuControlList::GpuControlListEntry::SetFeatures(
970    const std::vector<std::string>& feature_strings,
971    const FeatureMap& feature_map,
972    bool supports_feature_type_all) {
973  size_t size = feature_strings.size();
974  if (size == 0)
975    return false;
976  features_.clear();
977  for (size_t i = 0; i < size; ++i) {
978    int feature = 0;
979    if (supports_feature_type_all && feature_strings[i] == "all") {
980      for (FeatureMap::const_iterator iter = feature_map.begin();
981           iter != feature_map.end(); ++iter)
982        features_.insert(iter->second);
983      continue;
984    }
985    if (!StringToFeature(feature_strings[i], &feature, feature_map)) {
986      features_.clear();
987      return false;
988    }
989    features_.insert(feature);
990  }
991  return true;
992}
993
994void GpuControlList::GpuControlListEntry::AddException(
995    ScopedGpuControlListEntry exception) {
996  exceptions_.push_back(exception);
997}
998
999bool GpuControlList::GpuControlListEntry::GLVersionInfoMismatch(
1000    const std::string& gl_version) const {
1001  if (gl_version.empty())
1002    return false;
1003
1004  if (gl_version_info_.get() == NULL && gl_type_ == kGLTypeNone)
1005    return false;
1006
1007  std::vector<std::string> segments;
1008  base::SplitString(gl_version, ' ', &segments);
1009  std::string number;
1010  GLType gl_type = kGLTypeNone;
1011  if (segments.size() > 2 &&
1012      segments[0] == "OpenGL" && segments[1] == "ES") {
1013    number = segments[2];
1014    gl_type = kGLTypeGLES;
1015    if (segments.size() > 3 &&
1016        StartsWithASCII(segments[3], "(ANGLE", false)) {
1017      gl_type = kGLTypeANGLE;
1018    }
1019  } else {
1020    number = segments[0];
1021    gl_type = kGLTypeGL;
1022  }
1023
1024  if (gl_type_ != kGLTypeNone && gl_type_ != gl_type)
1025    return true;
1026  if (gl_version_info_.get() != NULL && !gl_version_info_->Contains(number))
1027    return true;
1028  return false;
1029}
1030
1031// static
1032GpuControlList::GpuControlListEntry::MultiGpuStyle
1033GpuControlList::GpuControlListEntry::StringToMultiGpuStyle(
1034    const std::string& style) {
1035  if (style == kMultiGpuStyleStringOptimus)
1036    return kMultiGpuStyleOptimus;
1037  if (style == kMultiGpuStyleStringAMDSwitchable)
1038    return kMultiGpuStyleAMDSwitchable;
1039  if (style == kMultiGpuStyleStringAMDSwitchableIntegrated)
1040    return kMultiGpuStyleAMDSwitchableIntegrated;
1041  if (style == kMultiGpuStyleStringAMDSwitchableDiscrete)
1042    return kMultiGpuStyleAMDSwitchableDiscrete;
1043  return kMultiGpuStyleNone;
1044}
1045
1046// static
1047GpuControlList::GpuControlListEntry::MultiGpuCategory
1048GpuControlList::GpuControlListEntry::StringToMultiGpuCategory(
1049    const std::string& category) {
1050  if (category == kMultiGpuCategoryStringPrimary)
1051    return kMultiGpuCategoryPrimary;
1052  if (category == kMultiGpuCategoryStringSecondary)
1053    return kMultiGpuCategorySecondary;
1054  if (category == kMultiGpuCategoryStringActive)
1055    return kMultiGpuCategoryActive;
1056  if (category == kMultiGpuCategoryStringAny)
1057    return kMultiGpuCategoryAny;
1058  return kMultiGpuCategoryNone;
1059}
1060
1061// static
1062GpuControlList::GpuControlListEntry::GLType
1063GpuControlList::GpuControlListEntry::StringToGLType(
1064    const std::string& gl_type) {
1065  if (gl_type == kGLTypeStringGL)
1066    return kGLTypeGL;
1067  if (gl_type == kGLTypeStringGLES)
1068    return kGLTypeGLES;
1069  if (gl_type == kGLTypeStringANGLE)
1070    return kGLTypeANGLE;
1071  return kGLTypeNone;
1072}
1073
1074// static
1075GpuControlList::GpuControlListEntry::GLType
1076GpuControlList::GpuControlListEntry::GetDefaultGLType() {
1077#if defined(OS_CHROMEOS)
1078  return kGLTypeGL;
1079#elif defined(OS_LINUX) || defined(OS_OPENBSD)
1080  return kGLTypeGL;
1081#elif defined(OS_MACOSX)
1082  return kGLTypeGL;
1083#elif defined(OS_WIN)
1084  return kGLTypeANGLE;
1085#elif defined(OS_ANDROID)
1086  return kGLTypeGLES;
1087#else
1088  return kGLTypeNone;
1089#endif
1090}
1091
1092void GpuControlList::GpuControlListEntry::LogControlListMatch(
1093    const std::string& control_list_logging_name) const {
1094  static const char kControlListMatchMessage[] =
1095      "Control list match for rule #%u in %s.";
1096  VLOG(1) << base::StringPrintf(kControlListMatchMessage, id_,
1097                                control_list_logging_name.c_str());
1098}
1099
1100bool GpuControlList::GpuControlListEntry::Contains(
1101    OsType os_type, const std::string& os_version,
1102    const GPUInfo& gpu_info) const {
1103  DCHECK(os_type != kOsAny);
1104  if (os_info_.get() != NULL && !os_info_->Contains(os_type, os_version))
1105    return false;
1106  if (vendor_id_ != 0) {
1107    std::vector<GPUInfo::GPUDevice> candidates;
1108    switch (multi_gpu_category_) {
1109      case kMultiGpuCategoryPrimary:
1110        candidates.push_back(gpu_info.gpu);
1111        break;
1112      case kMultiGpuCategorySecondary:
1113        candidates = gpu_info.secondary_gpus;
1114        break;
1115      case kMultiGpuCategoryAny:
1116        candidates = gpu_info.secondary_gpus;
1117        candidates.push_back(gpu_info.gpu);
1118        break;
1119      case kMultiGpuCategoryActive:
1120        if (gpu_info.gpu.active)
1121          candidates.push_back(gpu_info.gpu);
1122        for (size_t ii = 0; ii < gpu_info.secondary_gpus.size(); ++ii) {
1123          if (gpu_info.secondary_gpus[ii].active)
1124            candidates.push_back(gpu_info.secondary_gpus[ii]);
1125        }
1126      default:
1127        break;
1128    }
1129
1130    GPUInfo::GPUDevice gpu;
1131    gpu.vendor_id = vendor_id_;
1132    bool found = false;
1133    if (device_id_list_.empty()) {
1134      for (size_t ii = 0; ii < candidates.size(); ++ii) {
1135        if (gpu.vendor_id == candidates[ii].vendor_id) {
1136          found = true;
1137          break;
1138        }
1139      }
1140    } else {
1141      for (size_t ii = 0; ii < device_id_list_.size(); ++ii) {
1142        gpu.device_id = device_id_list_[ii];
1143        for (size_t jj = 0; jj < candidates.size(); ++jj) {
1144          if (gpu.vendor_id == candidates[jj].vendor_id &&
1145              gpu.device_id == candidates[jj].device_id) {
1146            found = true;
1147            break;
1148          }
1149        }
1150      }
1151    }
1152    if (!found)
1153      return false;
1154  }
1155  switch (multi_gpu_style_) {
1156    case kMultiGpuStyleOptimus:
1157      if (!gpu_info.optimus)
1158        return false;
1159      break;
1160    case kMultiGpuStyleAMDSwitchable:
1161      if (!gpu_info.amd_switchable)
1162        return false;
1163      break;
1164    case kMultiGpuStyleAMDSwitchableDiscrete:
1165      if (!gpu_info.amd_switchable)
1166        return false;
1167      // The discrete GPU is always the primary GPU.
1168      // This is guaranteed by GpuInfoCollector.
1169      if (!gpu_info.gpu.active)
1170        return false;
1171      break;
1172    case kMultiGpuStyleAMDSwitchableIntegrated:
1173      if (!gpu_info.amd_switchable)
1174        return false;
1175      // Assume the integrated GPU is the first in the secondary GPU list.
1176      if (gpu_info.secondary_gpus.size() == 0 ||
1177          !gpu_info.secondary_gpus[0].active)
1178        return false;
1179      break;
1180    case kMultiGpuStyleNone:
1181      break;
1182  }
1183  if (StringMismatch(gpu_info.driver_vendor, driver_vendor_info_))
1184    return false;
1185  if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
1186    if (!driver_version_info_->Contains(gpu_info.driver_version))
1187      return false;
1188  }
1189  if (driver_date_info_.get() != NULL && !gpu_info.driver_date.empty()) {
1190    if (!driver_date_info_->Contains(gpu_info.driver_date, '-'))
1191      return false;
1192  }
1193  if (GLVersionInfoMismatch(gpu_info.gl_version))
1194    return false;
1195  if (StringMismatch(gpu_info.gl_vendor, gl_vendor_info_))
1196    return false;
1197  if (StringMismatch(gpu_info.gl_renderer, gl_renderer_info_))
1198    return false;
1199  if (StringMismatch(gpu_info.gl_extensions, gl_extensions_info_))
1200    return false;
1201  if (gl_reset_notification_strategy_info_.get() != NULL &&
1202      !gl_reset_notification_strategy_info_->Contains(
1203          gpu_info.gl_reset_notification_strategy))
1204    return false;
1205  if (perf_graphics_info_.get() != NULL &&
1206      (gpu_info.performance_stats.graphics == 0.0 ||
1207       !perf_graphics_info_->Contains(gpu_info.performance_stats.graphics)))
1208    return false;
1209  if (perf_gaming_info_.get() != NULL &&
1210      (gpu_info.performance_stats.gaming == 0.0 ||
1211       !perf_gaming_info_->Contains(gpu_info.performance_stats.gaming)))
1212    return false;
1213  if (perf_overall_info_.get() != NULL &&
1214      (gpu_info.performance_stats.overall == 0.0 ||
1215       !perf_overall_info_->Contains(gpu_info.performance_stats.overall)))
1216    return false;
1217  if (!machine_model_name_list_.empty()) {
1218    if (gpu_info.machine_model_name.empty())
1219      return false;
1220    bool found_match = false;
1221    for (size_t ii = 0; ii < machine_model_name_list_.size(); ++ii) {
1222      if (RE2::FullMatch(gpu_info.machine_model_name,
1223                         machine_model_name_list_[ii])) {
1224        found_match = true;
1225        break;
1226      }
1227    }
1228    if (!found_match)
1229      return false;
1230  }
1231  if (machine_model_version_info_.get() != NULL &&
1232      (gpu_info.machine_model_version.empty() ||
1233       !machine_model_version_info_->Contains(gpu_info.machine_model_version)))
1234    return false;
1235  if (gpu_count_info_.get() != NULL &&
1236      !gpu_count_info_->Contains(gpu_info.secondary_gpus.size() + 1))
1237    return false;
1238  if (direct_rendering_info_.get() != NULL &&
1239      !direct_rendering_info_->Contains(gpu_info.direct_rendering))
1240    return false;
1241  if (!cpu_brand_.empty()) {
1242    base::CPU cpu_info;
1243    if (StringMismatch(cpu_info.cpu_brand(), cpu_brand_))
1244      return false;
1245  }
1246
1247  for (size_t i = 0; i < exceptions_.size(); ++i) {
1248    if (exceptions_[i]->Contains(os_type, os_version, gpu_info) &&
1249        !exceptions_[i]->NeedsMoreInfo(gpu_info))
1250      return false;
1251  }
1252  return true;
1253}
1254
1255bool GpuControlList::GpuControlListEntry::NeedsMoreInfo(
1256    const GPUInfo& gpu_info) const {
1257  // We only check for missing info that might be collected with a gl context.
1258  // If certain info is missing due to some error, say, we fail to collect
1259  // vendor_id/device_id, then even if we launch GPU process and create a gl
1260  // context, we won't gather such missing info, so we still return false.
1261  if (!driver_vendor_info_.empty() && gpu_info.driver_vendor.empty())
1262    return true;
1263  if (driver_version_info_.get() && gpu_info.driver_version.empty())
1264    return true;
1265  if (!gl_vendor_info_.empty() && gpu_info.gl_vendor.empty())
1266    return true;
1267  if (!gl_renderer_info_.empty() && gpu_info.gl_renderer.empty())
1268    return true;
1269  for (size_t i = 0; i < exceptions_.size(); ++i) {
1270    if (exceptions_[i]->NeedsMoreInfo(gpu_info))
1271      return true;
1272  }
1273  return false;
1274}
1275
1276GpuControlList::OsType GpuControlList::GpuControlListEntry::GetOsType() const {
1277  if (os_info_.get() == NULL)
1278    return kOsAny;
1279  return os_info_->type();
1280}
1281
1282uint32 GpuControlList::GpuControlListEntry::id() const {
1283  return id_;
1284}
1285
1286bool GpuControlList::GpuControlListEntry::disabled() const {
1287  return disabled_;
1288}
1289
1290const std::set<int>& GpuControlList::GpuControlListEntry::features() const {
1291  return features_;
1292}
1293
1294void GpuControlList::GpuControlListEntry::GetFeatureNames(
1295    base::ListValue* feature_names,
1296    const FeatureMap& feature_map,
1297    bool supports_feature_type_all) const {
1298  DCHECK(feature_names);
1299  if (supports_feature_type_all && features_.size() == feature_map.size()) {
1300    feature_names->AppendString("all");
1301    return;
1302  }
1303  for (FeatureMap::const_iterator iter = feature_map.begin();
1304       iter != feature_map.end(); ++iter) {
1305    if (features_.count(iter->second) > 0)
1306      feature_names->AppendString(iter->first);
1307  }
1308}
1309
1310// static
1311bool GpuControlList::GpuControlListEntry::StringToFeature(
1312    const std::string& feature_name, int* feature_id,
1313    const FeatureMap& feature_map) {
1314  FeatureMap::const_iterator iter = feature_map.find(feature_name);
1315  if (iter != feature_map.end()) {
1316    *feature_id = iter->second;
1317    return true;
1318  }
1319  return false;
1320}
1321
1322GpuControlList::GpuControlList()
1323    : max_entry_id_(0),
1324      needs_more_info_(false),
1325      supports_feature_type_all_(false),
1326      control_list_logging_enabled_(false) {
1327}
1328
1329GpuControlList::~GpuControlList() {
1330  Clear();
1331}
1332
1333bool GpuControlList::LoadList(
1334    const std::string& json_context,
1335    GpuControlList::OsFilter os_filter) {
1336  scoped_ptr<base::Value> root;
1337  root.reset(base::JSONReader::Read(json_context));
1338  if (root.get() == NULL || !root->IsType(base::Value::TYPE_DICTIONARY))
1339    return false;
1340
1341  base::DictionaryValue* root_dictionary =
1342      static_cast<base::DictionaryValue*>(root.get());
1343  DCHECK(root_dictionary);
1344  return LoadList(*root_dictionary, os_filter);
1345}
1346
1347bool GpuControlList::LoadList(const base::DictionaryValue& parsed_json,
1348                              GpuControlList::OsFilter os_filter) {
1349  std::vector<ScopedGpuControlListEntry> entries;
1350
1351  parsed_json.GetString("version", &version_);
1352  std::vector<std::string> pieces;
1353  if (!ProcessVersionString(version_, '.', &pieces))
1354    return false;
1355
1356  const base::ListValue* list = NULL;
1357  if (!parsed_json.GetList("entries", &list))
1358    return false;
1359
1360  uint32 max_entry_id = 0;
1361  for (size_t i = 0; i < list->GetSize(); ++i) {
1362    const base::DictionaryValue* list_item = NULL;
1363    bool valid = list->GetDictionary(i, &list_item);
1364    if (!valid || list_item == NULL)
1365      return false;
1366    ScopedGpuControlListEntry entry(GpuControlListEntry::GetEntryFromValue(
1367        list_item, true, feature_map_, supports_feature_type_all_));
1368    if (entry.get() == NULL)
1369      return false;
1370    if (entry->id() > max_entry_id)
1371      max_entry_id = entry->id();
1372    entries.push_back(entry);
1373  }
1374
1375  Clear();
1376  OsType my_os = GetOsType();
1377  for (size_t i = 0; i < entries.size(); ++i) {
1378    OsType entry_os = entries[i]->GetOsType();
1379    if (os_filter == GpuControlList::kAllOs ||
1380        entry_os == kOsAny || entry_os == my_os)
1381      entries_.push_back(entries[i]);
1382  }
1383  max_entry_id_ = max_entry_id;
1384  return true;
1385}
1386
1387std::set<int> GpuControlList::MakeDecision(
1388    GpuControlList::OsType os,
1389    std::string os_version,
1390    const GPUInfo& gpu_info) {
1391  active_entries_.clear();
1392  std::set<int> features;
1393
1394  needs_more_info_ = false;
1395  std::set<int> possible_features;
1396
1397  if (os == kOsAny)
1398    os = GetOsType();
1399  if (os_version.empty())
1400    os_version = base::SysInfo::OperatingSystemVersion();
1401
1402  for (size_t i = 0; i < entries_.size(); ++i) {
1403    if (entries_[i]->Contains(os, os_version, gpu_info)) {
1404      bool needs_more_info = entries_[i]->NeedsMoreInfo(gpu_info);
1405      if (!entries_[i]->disabled()) {
1406        if (control_list_logging_enabled_)
1407          entries_[i]->LogControlListMatch(control_list_logging_name_);
1408        MergeFeatureSets(&possible_features, entries_[i]->features());
1409        if (!needs_more_info)
1410          MergeFeatureSets(&features, entries_[i]->features());
1411      }
1412      if (!needs_more_info)
1413        active_entries_.push_back(entries_[i]);
1414    }
1415  }
1416
1417  if (possible_features.size() > features.size())
1418    needs_more_info_ = true;
1419
1420  return features;
1421}
1422
1423void GpuControlList::GetDecisionEntries(
1424    std::vector<uint32>* entry_ids, bool disabled) const {
1425  DCHECK(entry_ids);
1426  entry_ids->clear();
1427  for (size_t i = 0; i < active_entries_.size(); ++i) {
1428    if (disabled == active_entries_[i]->disabled())
1429      entry_ids->push_back(active_entries_[i]->id());
1430  }
1431}
1432
1433void GpuControlList::GetReasons(base::ListValue* problem_list,
1434                                const std::string& tag) const {
1435  DCHECK(problem_list);
1436  for (size_t i = 0; i < active_entries_.size(); ++i) {
1437    GpuControlListEntry* entry = active_entries_[i].get();
1438    if (entry->disabled())
1439      continue;
1440    base::DictionaryValue* problem = new base::DictionaryValue();
1441
1442    problem->SetString("description", entry->description());
1443
1444    base::ListValue* cr_bugs = new base::ListValue();
1445    for (size_t j = 0; j < entry->cr_bugs().size(); ++j)
1446      cr_bugs->Append(new base::FundamentalValue(entry->cr_bugs()[j]));
1447    problem->Set("crBugs", cr_bugs);
1448
1449    base::ListValue* webkit_bugs = new base::ListValue();
1450    for (size_t j = 0; j < entry->webkit_bugs().size(); ++j) {
1451      webkit_bugs->Append(new base::FundamentalValue(entry->webkit_bugs()[j]));
1452    }
1453    problem->Set("webkitBugs", webkit_bugs);
1454
1455    base::ListValue* features = new base::ListValue();
1456    entry->GetFeatureNames(features, feature_map_, supports_feature_type_all_);
1457    problem->Set("affectedGpuSettings", features);
1458
1459    DCHECK(tag == "workarounds" || tag == "disabledFeatures");
1460    problem->SetString("tag", tag);
1461
1462    problem_list->Append(problem);
1463  }
1464}
1465
1466size_t GpuControlList::num_entries() const {
1467  return entries_.size();
1468}
1469
1470uint32 GpuControlList::max_entry_id() const {
1471  return max_entry_id_;
1472}
1473
1474std::string GpuControlList::version() const {
1475  return version_;
1476}
1477
1478GpuControlList::OsType GpuControlList::GetOsType() {
1479#if defined(OS_CHROMEOS)
1480  return kOsChromeOS;
1481#elif defined(OS_WIN)
1482  return kOsWin;
1483#elif defined(OS_ANDROID)
1484  return kOsAndroid;
1485#elif defined(OS_LINUX) || defined(OS_OPENBSD)
1486  return kOsLinux;
1487#elif defined(OS_MACOSX)
1488  return kOsMacosx;
1489#else
1490  return kOsUnknown;
1491#endif
1492}
1493
1494void GpuControlList::Clear() {
1495  entries_.clear();
1496  active_entries_.clear();
1497  max_entry_id_ = 0;
1498}
1499
1500// static
1501GpuControlList::NumericOp GpuControlList::StringToNumericOp(
1502    const std::string& op) {
1503  if (op == "=")
1504    return kEQ;
1505  if (op == "<")
1506    return kLT;
1507  if (op == "<=")
1508    return kLE;
1509  if (op == ">")
1510    return kGT;
1511  if (op == ">=")
1512    return kGE;
1513  if (op == "any")
1514    return kAny;
1515  if (op == "between")
1516    return kBetween;
1517  return kUnknown;
1518}
1519
1520void GpuControlList::AddSupportedFeature(
1521    const std::string& feature_name, int feature_id) {
1522  feature_map_[feature_name] = feature_id;
1523}
1524
1525void GpuControlList::set_supports_feature_type_all(bool supported) {
1526  supports_feature_type_all_ = supported;
1527}
1528
1529}  // namespace gpu
1530
1531