Add semantics to apply gpu blakclist to AMD swichable when a discrete/integrated GPU is in use

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 69 matching lines @@
     unsigned value2 = number_ref[i] - '0';
     if (value1 > value2)
       return 1;
     if (value1 < value2)
       return -1;
   }
   return 0;
 }
 
 const char kMultiGpuStyleStringAMDSwitchable[] = "amd_switchable";
+const char kMultiGpuStyleStringAMDSwitchableDiscrete[] =
+    "amd_switchable_discrete";
+const char kMultiGpuStyleStringAMDSwitchableIntegrated[] =
+    "amd_switchable_integrated";
 const char kMultiGpuStyleStringOptimus[] = "optimus";
 
 const char kMultiGpuCategoryStringPrimary[] = "primary";
 const char kMultiGpuCategoryStringSecondary[] = "secondary";
 const char kMultiGpuCategoryStringActive[] = "active";
 const char kMultiGpuCategoryStringAny[] = "any";
 
 const char kGLTypeStringGL[] = "gl";
 const char kGLTypeStringGLES[] = "gles";
 const char kGLTypeStringANGLE[] = "angle";
@@ skipping 971 matching lines @@
 }
 
 // static
 GpuControlList::GpuControlListEntry::MultiGpuStyle
 GpuControlList::GpuControlListEntry::StringToMultiGpuStyle(
     const std::string& style) {
   if (style == kMultiGpuStyleStringOptimus)
     return kMultiGpuStyleOptimus;
   if (style == kMultiGpuStyleStringAMDSwitchable)
     return kMultiGpuStyleAMDSwitchable;
+  if (style == kMultiGpuStyleStringAMDSwitchableIntegrated)
+    return kMultiGpuStyleAMDSwitchableIntegrated;
+  if (style == kMultiGpuStyleStringAMDSwitchableDiscrete)
+    return kMultiGpuStyleAMDSwitchableDiscrete;
   return kMultiGpuStyleNone;
 }
 
 // static
 GpuControlList::GpuControlListEntry::MultiGpuCategory
 GpuControlList::GpuControlListEntry::StringToMultiGpuCategory(
     const std::string& category) {
   if (category == kMultiGpuCategoryStringPrimary)
     return kMultiGpuCategoryPrimary;
   if (category == kMultiGpuCategoryStringSecondary)
@@ skipping 101 matching lines @@
   }
   switch (multi_gpu_style_) {
     case kMultiGpuStyleOptimus:
       if (!gpu_info.optimus)
         return false;
       break;
     case kMultiGpuStyleAMDSwitchable:
       if (!gpu_info.amd_switchable)
         return false;
       break;
+    case kMultiGpuStyleAMDSwitchableDiscrete:
+      if (!gpu_info.amd_switchable)
+        return false;
+      // The discrete GPU is always the primary GPU.
+      // This is guaranteed by GpuInfoCollector.
+      if (!gpu_info.gpu.active)
+        return false;
+      break;
+    case kMultiGpuStyleAMDSwitchableIntegrated:
+      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 (driver_vendor_info_.get() != NULL && !gpu_info.driver_vendor.empty() &&
       !driver_vendor_info_->Contains(gpu_info.driver_vendor))
     return false;
   if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
     if (!driver_version_info_->Contains(gpu_info.driver_version))
       return false;
   }
@@ skipping 339 matching lines @@
     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