Move GPU device/driver info related code from content to gpu.

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"
 
 // This has to be included before windows.h.
 #include "third_party/re2/re2/re2.h"
 
 #include <windows.h>
@@ skipping 17 matching lines @@
 #include "base/threading/thread.h"
 #include "base/threading/worker_pool.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 
+namespace gpu {
+
 namespace {
 
 // This must be kept in sync with histograms.xml.
 enum DisplayLinkInstallationStatus {
   DISPLAY_LINK_NOT_INSTALLED,
   DISPLAY_LINK_7_1_OR_EARLIER,
   DISPLAY_LINK_7_2_OR_LATER,
   DISPLAY_LINK_INSTALLATION_STATUS_MAX
 };
 
 float ReadXMLFloatValue(XmlReader* reader) {
   std::string score_string;
   if (!reader->ReadElementContent(&score_string))
     return 0.0;
 
   double score;
   if (!base::StringToDouble(score_string, &score))
     return 0.0;
 
   return static_cast<float>(score);
 }
 
-content::GpuPerformanceStats RetrieveGpuPerformanceStats() {
+GpuPerformanceStats RetrieveGpuPerformanceStats() {
   TRACE_EVENT0("gpu", "RetrieveGpuPerformanceStats");
 
   // If the user re-runs the assessment without restarting, the COM API
   // returns WINSAT_ASSESSMENT_STATE_NOT_AVAILABLE. Because of that and
   // http://crbug.com/124325, read the assessment result files directly.
-  content::GpuPerformanceStats stats;
+  GpuPerformanceStats stats;
 
   // Get path to WinSAT results files.
   wchar_t winsat_results_path[MAX_PATH];
   DWORD size = ExpandEnvironmentStrings(
       L"%WinDir%\\Performance\\WinSAT\\DataStore\\",
       winsat_results_path, MAX_PATH);
   if (size == 0 || size > MAX_PATH) {
     LOG(ERROR) << "The path to the WinSAT results is too long: "
                << size << " chars.";
     return stats;
@@ skipping 60 matching lines @@
   if (stats.overall == 0.0)
     LOG(ERROR) << "Could not read overall score from assessment results.";
   if (stats.graphics == 0.0)
     LOG(ERROR) << "Could not read graphics score from assessment results.";
   if (stats.gaming == 0.0)
     LOG(ERROR) << "Could not read gaming score from assessment results.";
 
   return stats;
 }
 
-content::GpuPerformanceStats RetrieveGpuPerformanceStatsWithHistograms() {
+GpuPerformanceStats RetrieveGpuPerformanceStatsWithHistograms() {
   base::TimeTicks start_time = base::TimeTicks::Now();
 
-  content::GpuPerformanceStats stats = RetrieveGpuPerformanceStats();
+  GpuPerformanceStats stats = RetrieveGpuPerformanceStats();
 
   UMA_HISTOGRAM_TIMES("GPU.WinSAT.ReadResultsFileTime",
                       base::TimeTicks::Now() - start_time);
   UMA_HISTOGRAM_CUSTOM_COUNTS("GPU.WinSAT.OverallScore2",
                               stats.overall * 10, 10, 200, 50);
   UMA_HISTOGRAM_CUSTOM_COUNTS("GPU.WinSAT.GraphicsScore2",
                               stats.graphics * 10, 10, 200, 50);
   UMA_HISTOGRAM_CUSTOM_COUNTS("GPU.WinSAT.GamingScore2",
                               stats.gaming * 10, 10, 200, 50);
   UMA_HISTOGRAM_BOOLEAN(
@@ skipping 35 matching lines @@
     return false;
 
   if (key.OpenKey(L"Lenovo dCute", KEY_READ | KEY_WOW64_64KEY))
     return false;
 
   return true;
 }
 
 // Determines whether D3D11 won't work, either because it is not supported on
 // the machine or because it is known it is likely to crash.
-bool D3D11ShouldWork(const content::GPUInfo& gpu_info) {
+bool D3D11ShouldWork(const GPUInfo& gpu_info) {
   // Windows XP never supports D3D11.
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     return false;
 
   // Intel?
   if (gpu_info.gpu.vendor_id == 0x8086) {
     // 2nd Generation Core Processor Family Integrated Graphics Controller
     // or Intel Ivy Bridge?
     if (gpu_info.gpu.device_id == 0x0102 ||
         gpu_info.gpu.device_id == 0x0106 ||
@@ skipping 145 matching lines @@
 // the UMA stats. Records no stats when D3D11 in not supported at all.
 void CollectD3D11Support() {
   // D3D11 takes about 50ms to initialize so do this on a worker thread.
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(CollectD3D11SupportOnWorkerThread),
       false);
 }
 }  // namespace anonymous
 
-namespace gpu_info_collector {
-
 #if !defined(GOOGLE_CHROME_BUILD)
 AMDVideoCardType GetAMDVideocardType() {
   return STANDALONE;
 }
 #else
 // This function has a real implementation for official builds that can
 // be found in src/third_party/amd.
 AMDVideoCardType GetAMDVideocardType();
 #endif
 
 bool CollectDriverInfoD3D(const std::wstring& device_id,
-                          content::GPUInfo* gpu_info) {
+                          GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectDriverInfoD3D");
 
   // create device info for the display device
   HDEVINFO device_info = SetupDiGetClassDevsW(
       NULL, device_id.c_str(), NULL,
       DIGCF_PRESENT | DIGCF_PROFILE | DIGCF_ALLCLASSES);
   if (device_info == INVALID_HANDLE_VALUE) {
     LOG(ERROR) << "Creating device info failed";
     return false;
   }
@@ skipping 58 matching lines @@
         found = true;
         RegCloseKey(key);
         break;
       }
     }
   }
   SetupDiDestroyDeviceInfoList(device_info);
   return found;
 }
 
-bool CollectContextGraphicsInfo(content::GPUInfo* gpu_info) {
+bool CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectGraphicsInfo");
 
   DCHECK(gpu_info);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "swiftshader") {
       gpu_info->software_rendering = true;
       return false;
@@ skipping 65 matching lines @@
     std::wstring device_string = id.substr(17, 4);
     base::HexStringToInt(WideToASCII(vendor_string), &vendor);
     base::HexStringToInt(WideToASCII(device_string), &device);
     *vendor_id = vendor;
     *device_id = device;
     return kGpuIDSuccess;
   }
   return kGpuIDFailure;
 }
 
-bool CollectBasicGraphicsInfo(content::GPUInfo* gpu_info) {
+bool CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectPreliminaryGraphicsInfo");
 
   DCHECK(gpu_info);
 
   gpu_info->performance_stats = RetrieveGpuPerformanceStatsWithHistograms();
 
   // nvd3d9wrap.dll is loaded into all processes when Optimus is enabled.
   HMODULE nvd3d9wrap = GetModuleHandleW(L"nvd3d9wrap.dll");
   gpu_info->optimus = nvd3d9wrap != NULL;
 
@@ skipping 45 matching lines @@
   if (D3D11ShouldWork(*gpu_info)) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CollectD3D11Support),
         base::TimeDelta::FromSeconds(45));
   }
 
   return true;
 }
 
-bool CollectDriverInfoGL(content::GPUInfo* gpu_info) {
+bool CollectDriverInfoGL(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectDriverInfoGL");
 
   if (!gpu_info->driver_version.empty())
     return true;
 
   std::string gl_version_string = gpu_info->gl_version_string;
 
   return RE2::PartialMatch(gl_version_string,
                            "([\\d\\.]+)$",
                            &gpu_info->driver_version);
 }
 
-void MergeGPUInfo(content::GPUInfo* basic_gpu_info,
-                  const content::GPUInfo& context_gpu_info) {
+void MergeGPUInfo(GPUInfo* basic_gpu_info,
+                  const GPUInfo& context_gpu_info) {
   DCHECK(basic_gpu_info);
 
   if (context_gpu_info.software_rendering) {
     basic_gpu_info->software_rendering = true;
     return;
   }
 
   MergeGPUInfoGL(basic_gpu_info, context_gpu_info);
 
   basic_gpu_info->dx_diagnostics = context_gpu_info.dx_diagnostics;
 }
 
-}  // namespace gpu_info_collector
+}  // namespace gpu