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

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 340 matching lines @@
     g_gpu_process_hosts[kind_] = NULL;
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&GpuProcessHostUIShim::Destroy, host_id_));
 }
 
 bool GpuProcessHost::Init() {
   init_start_time_ = base::TimeTicks::Now();
 
+  TRACE_EVENT_INSTANT0("gpu", "LaunchGpuProcess");
+
   std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   if (in_process_) {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDisableGpuWatchdog);
 
     in_process_gpu_thread_.reset(new GpuMainThread(channel_id));
 
@@ skipping 55 matching lines @@
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceRelease,
                         OnAcceleratedSurfaceRelease)
 #endif
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHost::OnChannelConnected(int32 peer_pid) {
+  TRACE_EVENT0("gpu", "GpuProcessHostUIShim::OnChannelConnected");
+
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void GpuProcessHost::EstablishGpuChannel(
     int client_id,
     bool share_context,
     const EstablishChannelCallback& callback) {
@@ skipping 16 matching lines @@
         base::kNullProcessHandle, content::GPUInfo());
   }
 }
 
 void GpuProcessHost::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& compositing_surface,
     int surface_id,
     int client_id,
     const GPUCreateCommandBufferConfig& init_params,
     const CreateCommandBufferCallback& callback) {
+  TRACE_EVENT0("gpu", "GpuProcessHostUIShim::CreateViewCommandBuffer");
+
   DCHECK(CalledOnValidThread());
 
 #if defined(TOOLKIT_GTK)
   // There should only be one such command buffer (for the compositor).  In
   // practice, if the GPU process lost a context, GraphicsContext3D with
   // associated command buffer and view surface will not be gone until new
   // one is in place and all layers are reattached.
   linked_ptr<SurfaceRef> surface_ref;
   SurfaceRefMap::iterator it = surface_refs_.find(surface_id);
   if (it != surface_refs_.end())
     surface_ref = (*it).second;
   else
     surface_ref.reset(new SurfaceRef(compositing_surface.handle));
 #endif  // defined(TOOLKIT_GTK)
 
   if (!compositing_surface.is_null() &&
       Send(new GpuMsg_CreateViewCommandBuffer(
           compositing_surface, surface_id, client_id, init_params))) {
     create_command_buffer_requests_.push(callback);
 #if defined(TOOLKIT_GTK)
     surface_refs_.insert(std::make_pair(surface_id, surface_ref));
 #endif
   } else {
     CreateCommandBufferError(callback, MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle) {
+  TRACE_EVENT0("gpu", "GpuProcessHostUIShim::OnChannelEstablished");
+
   EstablishChannelCallback callback = channel_requests_.front();
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
   if (!channel_handle.name.empty() &&
       !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed()) {
     Send(new GpuMsg_CloseChannel(channel_handle));
     EstablishChannelError(callback,
                           IPC::ChannelHandle(),
                           base::kNullProcessHandle,
                           content::GPUInfo());
     RouteOnUIThread(GpuHostMsg_OnLogMessage(
         logging::LOG_WARNING,
         "WARNING",
         "Hardware acceleration is unavailable."));
     return;
   }
 
   callback.Run(channel_handle,
                GpuDataManagerImpl::GetInstance()->GetGPUInfo());
 }
 
 void GpuProcessHost::OnCommandBufferCreated(const int32 route_id) {
+  TRACE_EVENT0("gpu", "GpuProcessHostUIShim::OnCommandBufferCreated");
+
   if (!create_command_buffer_requests_.empty()) {
     CreateCommandBufferCallback callback =
         create_command_buffer_requests_.front();
     create_command_buffer_requests_.pop();
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback, route_id);
     else
       callback.Run(route_id);
   }
 }
 
 void GpuProcessHost::OnDestroyCommandBuffer(int32 surface_id) {
+  TRACE_EVENT0("gpu", "GpuProcessHostUIShim::OnDestroyCommandBuffer");
+
 #if defined(TOOLKIT_GTK)
   SurfaceRefMap::iterator it = surface_refs_.find(surface_id);
   if (it != surface_refs_.end())
     surface_refs_.erase(it);
 #endif  // defined(TOOLKIT_GTK)
 }
 
 #if defined(OS_MACOSX)
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
-  TRACE_EVENT0("renderer",
-      "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
+  TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(params.surface_id);
   // Compositor window is always gfx::kNullPluginWindow.
   // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
   // plugin windows.
   if (handle != gfx::kNullPluginWindow) {
     RouteOnUIThread(GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
     return;
   }
@@ skipping 24 matching lines @@
       params.surface_handle,
       params.route_id,
       host_id_));
 }
 #endif  // OS_MACOSX
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
-  TRACE_EVENT0("renderer",
-      "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
+  TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompleted,
                  host_id_,
                  params.route_id,
                  true));
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(params.surface_id);
   if (!handle)
     return;
 
   scoped_refptr<AcceleratedPresenter> presenter(
       AcceleratedPresenter::GetForWindow(handle));
   if (!presenter)
     return;
 
   scoped_completion_runner.Release();
   presenter->AsyncPresentAndAcknowledge(
       params.size,
       params.surface_handle,
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompleted,
                  host_id_,
                  params.route_id));
 }
 
 void GpuProcessHost::OnAcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params) {
-  TRACE_EVENT0("renderer",
-      "GpuProcessHost::OnAcceleratedSurfacePostSubBuffer");
+  TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfacePostSubBuffer");
 
   NOTIMPLEMENTED();
 }
 
 void GpuProcessHost::OnAcceleratedSurfaceSuspend(int32 surface_id) {
-  TRACE_EVENT0("renderer",
-      "GpuProcessHost::OnAcceleratedSurfaceSuspend");
+  TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceSuspend");
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(surface_id);
   if (!handle)
     return;
 
   scoped_refptr<AcceleratedPresenter> presenter(
       AcceleratedPresenter::GetForWindow(handle));
   if (!presenter)
     return;
 
   presenter->Suspend();
 }
 
 void GpuProcessHost::OnAcceleratedSurfaceRelease(
     const GpuHostMsg_AcceleratedSurfaceRelease_Params& params) {
-  TRACE_EVENT0("renderer",
-      "GpuProcessHost::OnAcceleratedSurfaceRelease");
+  TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceRelease");
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(params.surface_id);
   if (!handle)
     return;
 
   scoped_refptr<AcceleratedPresenter> presenter(
       AcceleratedPresenter::GetForWindow(handle));
   if (!presenter)
     return;
@@ skipping 138 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }