gpu/config/gpu_control_list.cc

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