Add trace events to measure GPU process startup timing and time to first present.

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 "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_native_library.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
@@ skipping 21 matching lines @@
     return 0.0;
 
   double score;
   if (!base::StringToDouble(score_string, &score))
     return 0.0;
 
   return static_cast<float>(score);
 }
 
 content::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;
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Get path to WinSAT results files.
   wchar_t winsat_results_path[MAX_PATH];
   DWORD size = ExpandEnvironmentStrings(
@@ skipping 81 matching lines @@
                       base::TimeTicks::Now() - start_time);
 
   return stats;
 }
 
 }  // namespace anonymous
 
 namespace gpu_info_collector {
 
 bool CollectGraphicsInfo(content::GPUInfo* gpu_info) {
+  TRACE_EVENT0("gpu", "CollectGraphicsInfo");
+
   DCHECK(gpu_info);
 
   content::GpuPerformanceStats stats = RetrieveGpuPerformanceStats();
   UMA_HISTOGRAM_BOOLEAN(
       "GPU.WinSAT.HasResults",
       stats.overall != 0.0 && stats.graphics != 0.0 && stats.gaming != 0.0);
   gpu_info->performance_stats = stats;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
@@ skipping 33 matching lines @@
 
   if (!CollectGraphicsInfoD3D(d3d, gpu_info))
     return false;
 
   // DirectX diagnostics are collected asynchronously because it takes a
   // couple of seconds. Do not mark gpu_info as complete until that is done.
   return true;
 }
 
 bool CollectPreliminaryGraphicsInfo(content::GPUInfo* gpu_info) {
+  TRACE_EVENT0("gpu", "CollectPreliminaryGraphicsInfo");
+
   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) {
+  TRACE_EVENT0("gpu", "CollectGraphicsInfoD3D");
+
   DCHECK(d3d);
   DCHECK(gpu_info);
 
   bool succeed = CollectVideoCardInfo(gpu_info);
 
   // Get version information
   D3DCAPS9 d3d_caps;
   if (d3d->GetDeviceCaps(D3DADAPTER_DEFAULT,
                          D3DDEVTYPE_HAL,
                          &d3d_caps) == D3D_OK) {
@@ skipping 10 matching lines @@
   base::win::ScopedComPtr<IDirect3D9Ex> d3dex;
   if (SUCCEEDED(d3dex.QueryFrom(d3d)))
     gpu_info->can_lose_context = false;
   else
     gpu_info->can_lose_context = true;
 
   return true;
 }
 
 bool CollectVideoCardInfo(content::GPUInfo* gpu_info) {
+  TRACE_EVENT0("gpu", "CollectVideoCardInfo");
+
   DCHECK(gpu_info);
 
   // nvd3d9wrap.dll is loaded into all processes when Optimus is enabled.
   HMODULE nvd3d9wrap = GetModuleHandleW(L"nvd3d9wrap.dll");
   gpu_info->optimus = nvd3d9wrap != NULL;
 
   // Taken from http://developer.nvidia.com/object/device_ids.html
   DISPLAY_DEVICE dd;
   dd.cb = sizeof(DISPLAY_DEVICE);
   int i = 0;
@@ skipping 14 matching lines @@
     gpu_info->gpu.vendor_id = vendor_id;
     gpu_info->gpu.device_id = device_id;
     // TODO(zmo): we only need to call CollectDriverInfoD3D() if we use ANGLE.
     return CollectDriverInfoD3D(id, gpu_info);
   }
   return false;
 }
 
 bool CollectDriverInfoD3D(const std::wstring& device_id,
                           content::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;
   }
 
   DWORD index = 0;
@@ skipping 53 matching lines @@
         RegCloseKey(key);
         break;
       }
     }
   }
   SetupDiDestroyDeviceInfoList(device_info);
   return found;
 }
 
 bool CollectDriverInfoGL(content::GPUInfo* gpu_info) {
+  TRACE_EVENT0("gpu", "CollectDriverInfoGL");
+
   DCHECK(gpu_info);
 
   std::string gl_version_string = gpu_info->gl_version_string;
 
   // TODO(zmo): We assume the driver version is in the end of GL_VERSION
   // string.  Need to verify if it is true for majority drivers.
 
   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