Make it possible to blacklist gpu's based on the Windows experience index.

content/gpu/gpu_info_collector_win.cc

 // Copyright (c) 2012 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 "content/gpu/gpu_info_collector.h"
 
 #include <windows.h>
 #include <d3d9.h>
 #include <setupapi.h>
+#include <winsatcominterfacei.h>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/scoped_native_library.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_egl.h"
 
 // ANGLE seems to require that main.h be included before any other ANGLE header.
 #include "libEGL/Display.h"
 #include "libEGL/main.h"
 
 namespace {
 
 // The version number stores the major and minor version in the least 16 bits;
 // for example, 2.5 is 0x00000205.
 // Returned string is in the format of "major.minor".
 std::string VersionNumberToString(uint32 version_number) {
   int hi = (version_number >> 8) & 0xff;
   int low = version_number & 0xff;
   return base::IntToString(hi) + "." + base::IntToString(low);
 }
 
+float GetAssessmentScore(IProvideWinSATResultsInfo* results,
+                         WINSAT_ASSESSMENT_TYPE type) {
+  IProvideWinSATAssessmentInfo* subcomponent = NULL;
+  if (FAILED(results->GetAssessmentInfo(type, &subcomponent)))
+    return 0.0;
+
+  float score = 0.0;
+  if (FAILED(subcomponent->get_Score(&score)))
+    score = 0.0;
+  subcomponent->Release();
+  return score;
+}
+
+content::GpuPerformanceStats RetrieveGpuPerformanceStats() {
+  IQueryRecentWinSATAssessment* assessment = NULL;
+  IProvideWinSATResultsInfo* results = NULL;
+
+  content::GpuPerformanceStats stats;
+
+  do {
+    HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+    if (FAILED(hr)) {
+      LOG(ERROR) << "CoInitializeEx() failed";
+      break;
+    }
+
+    hr = CoCreateInstance(__uuidof(CQueryWinSAT),
+                          NULL,
+                          CLSCTX_INPROC_SERVER,
+                          __uuidof(IQueryRecentWinSATAssessment),
+                          reinterpret_cast<void**>(&assessment));
+    if (FAILED(hr)) {
+      LOG(ERROR) << "CoCreateInstance() failed";
+      break;
+    }
+
+    hr = assessment->get_Info(&results);
+    if (FAILED(hr)) {
+      LOG(ERROR) << "get_Info() failed";
+      break;
+    }
+
+    WINSAT_ASSESSMENT_STATE state = WINSAT_ASSESSMENT_STATE_UNKNOWN;
+    hr = results->get_AssessmentState(&state);
+    if (FAILED(hr)) {
+      LOG(ERROR) << "get_AssessmentState() failed";
+      break;
+    }
+    if (state != WINSAT_ASSESSMENT_STATE_VALID &&
+        state != WINSAT_ASSESSMENT_STATE_INCOHERENT_WITH_HARDWARE) {
+      LOG(ERROR) << "Can't retrieve a valid assessment";
+      break;
+    }
+
+    hr = results->get_SystemRating(&stats.overall);
+    if (FAILED(hr))
+      LOG(ERROR) << "Get overall score failed";
+
+    stats.gaming = GetAssessmentScore(results, WINSAT_ASSESSMENT_D3D);
+    if (stats.gaming == 0.0)
+      LOG(ERROR) << "Get gaming score failed";
+
+    stats.graphics = GetAssessmentScore(results, WINSAT_ASSESSMENT_GRAPHICS);
+    if (stats.graphics == 0.0)
+      LOG(ERROR) << "Get graphics score failed";
+  } while (false);
+
+  if (assessment)
+    assessment->Release();
+  if (results)
+    results->Release();
+  CoUninitialize();
+
+  return stats;
+}
+
 }  // namespace anonymous
 
 // Setup API functions
 typedef HDEVINFO (WINAPI*SetupDiGetClassDevsWFunc)(
     CONST GUID *ClassGuid,
     PCWSTR Enumerator,
     HWND hwndParent,
     DWORD Flags
 );
 typedef BOOL (WINAPI*SetupDiEnumDeviceInfoFunc)(
@@ skipping 12 matching lines @@
 );
 typedef BOOL (WINAPI*SetupDiDestroyDeviceInfoListFunc)(
     HDEVINFO DeviceInfoSet
 );
 
 namespace gpu_info_collector {
 
 bool CollectGraphicsInfo(content::GPUInfo* gpu_info) {
   DCHECK(gpu_info);
 
+  gpu_info->performance_stats = RetrieveGpuPerformanceStats();
+
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "swiftshader")
       return false;
   }
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     gpu_info->finalized = true;
     return CollectGraphicsInfoGL(gpu_info);
@@ skipping 29 matching lines @@
   return true;
 }
 
 bool CollectPreliminaryGraphicsInfo(content::GPUInfo* gpu_info) {
   DCHECK(gpu_info);
 
   bool rt = true;
   if (!CollectVideoCardInfo(gpu_info))
     rt = false;
 
+  gpu_info->performance_stats = RetrieveGpuPerformanceStats();
+
   return rt;
 }
 
 bool CollectGraphicsInfoD3D(IDirect3D9* d3d, content::GPUInfo* gpu_info) {
   DCHECK(d3d);
   DCHECK(gpu_info);
 
   bool succeed = CollectVideoCardInfo(gpu_info);
 
   // Get version information
@@ skipping 152 matching lines @@
 
   size_t pos = gl_version_string.find_last_not_of("0123456789.");
   if (pos != std::string::npos && pos < gl_version_string.length() - 1) {
     gpu_info->driver_version = gl_version_string.substr(pos + 1);
     return true;
   }
   return false;
 }
 
 }  // namespace gpu_info_collector