Add GL strings to CastSysInfo interface and use to configure GPU

gpu/config/gpu_control_list.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/config/gpu_control_list.h"
 
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 440 matching lines @@
 
   std::string vendor_id;
   if (value->GetString("vendor_id", &vendor_id)) {
     if (!entry->SetVendorId(vendor_id)) {
       LOG(WARNING) << "Malformed vendor_id entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  std::string vendor_string;
+  if (value->GetString("vendor_string", &vendor_string)) {
+    entry->SetVendorString(vendor_string);
+    dictionary_entry_count++;
+  }
+  std::string device_string;
+  if (value->GetString("device_string", &device_string)) {
+    entry->SetDeviceString(device_string);
+    dictionary_entry_count++;
+  }
+
   const base::ListValue* device_id_list;
   if (value->GetList("device_id", &device_id_list)) {
     for (size_t i = 0; i < device_id_list->GetSize(); ++i) {
       std::string device_id;
       if (!device_id_list->GetString(i, &device_id) ||
           !entry->AddDeviceId(device_id)) {
         LOG(WARNING) << "Malformed device_id entry " << entry->id();
         return NULL;
       }
     }
@@ skipping 330 matching lines @@
   return os_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetVendorId(
     const std::string& vendor_id_string) {
   vendor_id_ = 0;
   return base::HexStringToUInt(vendor_id_string, &vendor_id_) &&
       vendor_id_ != 0;
 }
 
+void GpuControlList::GpuControlListEntry::SetVendorString(
+    const std::string& vendor_string) {
+  vendor_string_ = vendor_string;
+}
+
 bool GpuControlList::GpuControlListEntry::AddDeviceId(
     const std::string& device_id_string) {
   uint32 device_id = 0;
   if (base::HexStringToUInt(device_id_string, &device_id) && device_id != 0) {
     device_id_list_.push_back(device_id);
     return true;
   }
   return false;
 }
 
+void GpuControlList::GpuControlListEntry::SetDeviceString(
+    const std::string& device_string) {
+  device_string_ = device_string;
+}
+
 bool GpuControlList::GpuControlListEntry::SetMultiGpuStyle(
     const std::string& multi_gpu_style_string) {
   MultiGpuStyle style = StringToMultiGpuStyle(multi_gpu_style_string);
   if (style == kMultiGpuStyleNone)
     return false;
   multi_gpu_style_ = style;
   return true;
 }
 
 bool GpuControlList::GpuControlListEntry::SetMultiGpuCategory(
@@ skipping 344 matching lines @@
       if (!gpu_info.amd_switchable)
         return false;
       // Assume the integrated GPU is the first in the secondary GPU list.
       if (gpu_info.secondary_gpus.size() == 0 ||
           !gpu_info.secondary_gpus[0].active)
         return false;
       break;
     case kMultiGpuStyleNone:
       break;
   }
+  if (StringMismatch(gpu_info.gpu.vendor_string, vendor_string_))
+    return false;
+  if (StringMismatch(gpu_info.gpu.device_string, device_string_))
+    return false;
   if (StringMismatch(gpu_info.driver_vendor, driver_vendor_info_))
     return false;
   if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
     if (!driver_version_info_->Contains(gpu_info.driver_version))
       return false;
   }
   if (driver_date_info_.get() != NULL && !gpu_info.driver_date.empty()) {
     if (!driver_date_info_->Contains(gpu_info.driver_date, '-'))
       return false;
   }
@@ skipping 315 matching lines @@
 void GpuControlList::AddSupportedFeature(
     const std::string& feature_name, int feature_id) {
   feature_map_[feature_name] = feature_id;
 }
 
 void GpuControlList::set_supports_feature_type_all(bool supported) {
   supports_feature_type_all_ = supported;
 }
 
 }  // namespace gpu
-