Add latency measurement system

content/common/gpu/image_transport_surface.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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 56 matching lines @@
                                            gfx::PluginWindowHandle handle)
     : surface_(surface),
       manager_(manager),
       stub_(stub->AsWeakPtr()),
       handle_(handle) {
   route_id_ = manager_->GenerateRouteID();
   manager_->AddRoute(route_id_, this);
 }
 
 ImageTransportHelper::~ImageTransportHelper() {
+  if (stub_)
+    stub_->SetLatencyInfoCallback(
+        base::Callback<void(const WebKit::WebLatencyInfoImpl&)>());
   manager_->RemoveRoute(route_id_);
 }
 
 bool ImageTransportHelper::Initialize() {
   gpu::gles2::GLES2Decoder* decoder = Decoder();
 
   if (!decoder)
     return false;
 
   decoder->SetResizeCallback(
        base::Bind(&ImageTransportHelper::Resize, base::Unretained(this)));
 
+  if (stub_)
+    stub_->SetLatencyInfoCallback(
+        base::Bind(&ImageTransportHelper::SetLatencyInfo,
+                   base::Unretained(this)));
+
   return true;
 }
 
 void ImageTransportHelper::Destroy() {}
 
 bool ImageTransportHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ImageTransportHelper, message)
     IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_BufferPresented,
                         OnBufferPresented)
     IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_ResizeViewACK, OnResizeViewACK);
+    IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_FrameDisplayed, OnFrameDisplayed);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ImageTransportHelper::SendAcceleratedSurfaceNew(
     GpuHostMsg_AcceleratedSurfaceNew_Params params) {
   params.surface_id = stub_->surface_id();
   params.route_id = route_id_;
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceNew(params));
@@ skipping 36 matching lines @@
                                            size));
 }
 
 void ImageTransportHelper::SendUpdateVSyncParameters(
       base::TimeTicks timebase, base::TimeDelta interval) {
   manager_->Send(new GpuHostMsg_UpdateVSyncParameters(stub_->surface_id(),
                                                       timebase,
                                                       interval));
 }
 
+void ImageTransportHelper::SendLatencyInfo(
+    const WebKit::WebLatencyInfoImpl& latency_info) {
+  stub_->SetLatencyInfo(latency_info);
+}
+
 void ImageTransportHelper::SetScheduled(bool is_scheduled) {
   gpu::GpuScheduler* scheduler = Scheduler();
   if (!scheduler)
     return;
 
   scheduler->SetScheduled(is_scheduled);
 }
 
 void ImageTransportHelper::DeferToFence(base::Closure task) {
   gpu::GpuScheduler* scheduler = Scheduler();
@@ skipping 63 matching lines @@
 #endif
 
 #if defined(OS_WIN)
   if (handle_ != NULL) {
     Decoder()->MakeCurrent();
     SetSwapInterval(Decoder()->GetGLContext());
   }
 #endif
 }
 
+void ImageTransportHelper::SetLatencyInfo(
+    const WebKit::WebLatencyInfoImpl& latency_info) {
+  surface_->SetLatencyInfo(latency_info);
+}
+
+void ImageTransportHelper::OnFrameDisplayed(
+    const WebKit::WebLatencyInfoImpl& latency_info) {
+  SendLatencyInfo(latency_info);
+}
+
 PassThroughImageTransportSurface::PassThroughImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::GLSurface* surface,
     bool transport)
     : GLSurfaceAdapter(surface),
       transport_(transport),
       did_set_swap_interval_(false) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          stub,
                                          gfx::kNullPluginWindow));
 }
 
 bool PassThroughImageTransportSurface::Initialize() {
   // The surface is assumed to have already been initialized.
   return helper_->Initialize();
 }
 
 void PassThroughImageTransportSurface::Destroy() {
   helper_->Destroy();
   GLSurfaceAdapter::Destroy();
 }
 
+void PassThroughImageTransportSurface::SetLatencyInfo(
+    const WebKit::WebLatencyInfoImpl& latency_info) {
+  if (latency_info_.rendererImplFrameNumber !=
+      latency_info.rendererImplFrameNumber)
+    TRACE_EVENT_ASYNC_BEGIN2("frame", "Frame", this,
+                             "frame_number",
+                                 latency_info.rendererImplFrameNumber,
+                             "input_number", latency_info.inputNumber);
+
+  latency_info_ = latency_info;
+}
+
 bool PassThroughImageTransportSurface::SwapBuffers() {
   bool result = gfx::GLSurfaceAdapter::SwapBuffers();
+  latency_info_.swapTimestamp = base::TimeTicks::HighResNow();
+  helper_->SendLatencyInfo(latency_info_);
+  TRACE_EVENT_ASYNC_END2("frame", "Frame", this,
+                         "frame_number", latency_info_.rendererImplFrameNumber,
+                         "input_number", latency_info_.inputNumber);
+
   SendVSyncUpdateIfAvailable();
 
   if (transport_) {
     // Round trip to the browser UI thread, for throttling, by sending a dummy
     // SwapBuffers message.
     GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
     params.surface_handle = 0;
+    params.latency_info = latency_info_;
     params.size = surface()->GetSize();
     helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
     helper_->SetScheduled(false);
   }
   return result;
 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
+  latency_info_.swapTimestamp = base::TimeTicks::HighResNow();
+  helper_->SendLatencyInfo(latency_info_);
+  TRACE_EVENT_ASYNC_END2("frame", "Frame", this,
+                         "frame_number", latency_info_.rendererImplFrameNumber,
+                         "input_number", latency_info_.inputNumber);
   SendVSyncUpdateIfAvailable();
 
   if (transport_) {
     // Round trip to the browser UI thread, for throttling, by sending a dummy
     // PostSubBuffer message.
     GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
     params.surface_handle = 0;
+    params.latency_info = latency_info_;
     params.surface_size = surface()->GetSize();
     params.x = x;
     params.y = y;
     params.width = width;
     params.height = height;
     helper_->SendAcceleratedSurfacePostSubBuffer(params);
 
     helper_->SetScheduled(false);
   }
   return result;
@@ skipping 40 matching lines @@
 
 void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
   GetVSyncParameters(
       base::Bind(&ImageTransportHelper::SendUpdateVSyncParameters,
                  helper_->AsWeakPtr()));
 }
 
 }  // namespace content
 
 #endif  // defined(ENABLE_GPU)