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