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

ui/surface/accelerated_surface_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 "ui/surface/accelerated_surface_win.h"
 
 #include <windows.h>
 #include <algorithm>
 
 #include "base/bind.h"
@@ skipping 143 matching lines @@
 base::LazyInstance<AcceleratedPresenterMap>
     g_accelerated_presenter_map = LAZY_INSTANCE_INITIALIZER;
 
 PresentThread::PresentThread(const char* name) : base::Thread(name) {
 }
 
 void PresentThread::InitDevice() {
   if (device_)
     return;
 
-  TRACE_EVENT0("surface", "PresentThread::Init");
+  TRACE_EVENT0("gpu", "PresentThread::Init");
   d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
   ResetDevice();
 }
 
 void PresentThread::ResetDevice() {
-  TRACE_EVENT0("surface", "PresentThread::ResetDevice");
+  TRACE_EVENT0("gpu", "PresentThread::ResetDevice");
 
   // This will crash some Intel drivers but we can't render anything without
   // reseting the device, which would be disappointing.
   query_ = NULL;
   device_ = NULL;
 
   Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
       d3d_module_.GetFunctionPointer(kCreate3D9DeviceExName));
   if (!create_func)
     return;
@@ skipping 124 matching lines @@
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  this,
                  size,
                  surface_handle,
                  completion_task));
 }
 
 bool AcceleratedPresenter::Present() {
-  TRACE_EVENT0("surface", "Present");
+  TRACE_EVENT0("gpu", "Present");
 
   bool result;
 
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresent,
                  this,
                  &result));
   // http://crbug.com/125391
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   event_.Wait();
   return result;
 }
 
 void AcceleratedPresenter::DoPresent(bool* result)
 {
   *result = DoRealPresent();
   event_.Signal();
 }
 
 bool AcceleratedPresenter::DoRealPresent()
 {
-  TRACE_EVENT0("surface", "DoRealPresent");
+  TRACE_EVENT0("gpu", "DoRealPresent");
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Signal the caller to recomposite if the presenter has been suspended or no
   // surface has ever been presented.
   if (!swap_chain_)
     return false;
 
   // If invalidated, do nothing. The window is gone.
   if (!window_)
     return true;
 
   RECT rect = {
     0, 0,
     size_.width(), size_.height()
   };
 
   {
-    TRACE_EVENT0("surface", "PresentEx");
+    TRACE_EVENT0("gpu", "PresentEx");
     hr = swap_chain_->Present(&rect,
                               &rect,
                               window_,
                               NULL,
                               D3DPRESENT_INTERVAL_IMMEDIATE);
     if (FAILED(hr))
       return false;
   }
 
   return true;
@@ skipping 133 matching lines @@
         switches::kGpuSwapDelay).c_str(), &delay);
   }
   return base::TimeDelta::FromMilliseconds(delay);
 }
 
 void AcceleratedPresenter::DoPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
     const base::Callback<void(bool)>& completion_task) {
   TRACE_EVENT1(
-      "surface", "DoPresentAndAcknowledge", "surface_handle", surface_handle);
+      "gpu", "DoPresentAndAcknowledge", "surface_handle", surface_handle);
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Initialize the device lazily since calling Direct3D can crash bots.
   present_thread_->InitDevice();
 
   if (!present_thread_->device()) {
     if (!completion_task.is_null())
@@ skipping 12 matching lines @@
   // Round up size so the swap chain is not continuously resized with the
   // surface, which could lead to memory fragmentation.
   const int kRound = 64;
   gfx::Size quantized_size(
       std::max(1, (size.width() + kRound - 1) / kRound * kRound),
       std::max(1, (size.height() + kRound - 1) / kRound * kRound));
 
   // Ensure the swap chain exists and is the same size (rounded up) as the
   // surface to be presented.
   if (!swap_chain_ || size_ != quantized_size) {
-    TRACE_EVENT0("surface", "CreateAdditionalSwapChain");
+    TRACE_EVENT0("gpu", "CreateAdditionalSwapChain");
     size_ = quantized_size;
 
     D3DPRESENT_PARAMETERS parameters = { 0 };
     parameters.BackBufferWidth = quantized_size.width();
     parameters.BackBufferHeight = quantized_size.height();
     parameters.BackBufferCount = 1;
     parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
     parameters.hDeviceWindow = GetShellWindow();
     parameters.Windowed = TRUE;
     parameters.Flags = 0;
     parameters.PresentationInterval = GetPresentationInterval();
     parameters.SwapEffect = D3DSWAPEFFECT_COPY;
 
     swap_chain_ = NULL;
     HRESULT hr = present_thread_->device()->CreateAdditionalSwapChain(
         &parameters,
         swap_chain_.Receive());
     if (FAILED(hr))
       return;
   }
 
   if (!source_texture_.get()) {
-    TRACE_EVENT0("surface", "CreateTexture");
+    TRACE_EVENT0("gpu", "CreateTexture");
     HANDLE handle = reinterpret_cast<HANDLE>(surface_handle);
     hr = present_thread_->device()->CreateTexture(size.width(),
                                                   size.height(),
                                                   1,
                                                   D3DUSAGE_RENDERTARGET,
                                                   D3DFMT_A8R8G8B8,
                                                   D3DPOOL_DEFAULT,
                                                   source_texture_.Receive(),
                                                   &handle);
     if (FAILED(hr))
@@ skipping 11 matching lines @@
                                   dest_surface.Receive());
   if (FAILED(hr))
     return;
 
   RECT rect = {
     0, 0,
     size.width(), size.height()
   };
 
   {
-    TRACE_EVENT0("surface", "StretchRect");
+    TRACE_EVENT0("gpu", "StretchRect");
     hr = present_thread_->device()->StretchRect(source_surface,
                                                 &rect,
                                                 dest_surface,
                                                 &rect,
                                                 D3DTEXF_NONE);
     if (FAILED(hr))
       return;
   }
 
   hr = present_thread_->query()->Issue(D3DISSUE_END);
   if (FAILED(hr))
     return;
 
   // Flush so the StretchRect can be processed by the GPU while the window is
   // being resized.
   present_thread_->query()->GetData(NULL, 0, D3DGETDATA_FLUSH);
 
   ::SetWindowPos(
       window_,
       NULL,
       0, 0,
       size.width(), size.height(),
       SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOMOVE |SWP_NOOWNERZORDER |
           SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOSENDCHANGING |
           SWP_ASYNCWINDOWPOS | SWP_NOZORDER);
 
   // Wait for the StretchRect to complete before notifying the GPU process
   // that it is safe to write to its backing store again.
   {
-    TRACE_EVENT0("surface", "spin");
+    TRACE_EVENT0("gpu", "spin");
     do {
       hr = present_thread_->query()->GetData(NULL, 0, D3DGETDATA_FLUSH);
 
       if (hr == S_FALSE)
         Sleep(1);
     } while (hr == S_FALSE);
   }
 
   static const base::TimeDelta swap_delay = GetSwapDelay();
   if (swap_delay.ToInternalValue())
     base::PlatformThread::Sleep(swap_delay);
 
   {
-    TRACE_EVENT0("surface", "Present");
+    TRACE_EVENT0("gpu", "Present");
     hr = swap_chain_->Present(&rect, &rect, window_, NULL, 0);
     if (FAILED(hr) &&
         FAILED(present_thread_->device()->CheckDeviceState(window_))) {
       present_thread_->ResetDevice();
     }
   }
 }
 
 void AcceleratedPresenter::DoSuspend() {
   base::AutoLock locked(lock_);
@@ skipping 19 matching lines @@
   return presenter_->Present();
 }
 
 bool AcceleratedSurface::CopyTo(const gfx::Size& size, void* buf) {
   return presenter_->CopyTo(size, buf);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }