Plumb LatencyInfo through aura.

content/browser/renderer_host/render_widget_host_view_aura.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/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 1427 matching lines @@
 #endif
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
   BufferPresentedCallback ack_callback = base::Bind(
       &AcknowledgeBufferForGpu,
       params_in_pixel.route_id,
       gpu_host_id,
       params_in_pixel.mailbox_name);
-  BuffersSwapped(
-      params_in_pixel.size, params_in_pixel.scale_factor,
-      params_in_pixel.mailbox_name, ack_callback);
+  BuffersSwapped(params_in_pixel.size,
+                 params_in_pixel.scale_factor,
+                 params_in_pixel.mailbox_name,
+                 params_in_pixel.latency_info,
+                 ack_callback);
 }
 
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
     scoped_ptr<cc::DelegatedFrameData> frame_data,
-    float frame_device_scale_factor) {
+    float frame_device_scale_factor,
+    const ui::LatencyInfo& latency_info) {
   gfx::Size frame_size_in_dip;
   if (!frame_data->render_pass_list.empty()) {
     frame_size_in_dip = gfx::ToFlooredSize(gfx::ScaleSize(
         frame_data->render_pass_list.back()->output_rect.size(),
         1.f/frame_device_scale_factor));
   }
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::CompositorFrameAck ack;
     ack.resources.swap(frame_data->resource_list);
     RenderWidgetHostImpl::SendSwapCompositorFrameAck(
         host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
     return;
   }
   window_->layer()->SetDelegatedFrame(frame_data.Pass(), frame_size_in_dip);
   released_front_lock_ = NULL;
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     SendDelegatedFrameAck();
   } else {
+    compositor->SetLatencyInfo(latency_info);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
                    AsWeakPtr()));
   }
 }
 
 void RenderWidgetHostViewAura::SendDelegatedFrameAck() {
   cc::CompositorFrameAck ack;
   window_->layer()->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
     scoped_ptr<cc::SoftwareFrameData> frame_data,
-    float frame_device_scale_factor) {
+    float frame_device_scale_factor,
+    const ui::LatencyInfo& latency_info) {
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
   const TransportDIB::Id& dib_id = frame_data->dib_id;
   scoped_ptr<TransportDIB> dib(host_->GetProcess()->MapTransportDIB(dib_id));
 
   // Validate the received DIB.
   size_t expected_size = 4 * frame_size.GetArea();
   if (!dib || dib->size() < expected_size) {
     host_->GetProcess()->ReceivedBadMessage();
     return;
@@ skipping 26 matching lines @@
         base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
                    AsWeakPtr(), last_dib_id));
   }
 
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
   released_front_lock_ = NULL;
   window_->SetExternalTexture(NULL);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
+  compositor->SetLatencyInfo(latency_info);
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 }
 
 void RenderWidgetHostViewAura::SendSoftwareFrameAck(
     const TransportDIB::Id& id) {
   cc::CompositorFrameAck ack;
   ack.last_dib_id = id;
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::OnSwapCompositorFrame(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (frame->delegated_frame_data) {
     SwapDelegatedFrame(frame->delegated_frame_data.Pass(),
-                       frame->metadata.device_scale_factor);
+                       frame->metadata.device_scale_factor,
+                       frame->metadata.latency_info);
     return;
   }
 
   if (frame->software_frame_data) {
     SwapSoftwareFrame(frame->software_frame_data.Pass(),
-                      frame->metadata.device_scale_factor);
+                      frame->metadata.device_scale_factor,
+                      frame->metadata.latency_info);
     return;
   }
 
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
   BufferPresentedCallback ack_callback = base::Bind(
       &SendCompositorFrameAck,
       host_->GetRoutingID(), host_->GetProcess()->GetID(),
       frame->gl_frame_data->mailbox, frame->gl_frame_data->size);
 
   if (!frame->gl_frame_data->sync_point) {
     LOG(ERROR) << "CompositorFrame without sync point. Skipping frame...";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->WaitSyncPoint(frame->gl_frame_data->sync_point);
 
   std::string mailbox_name(
       reinterpret_cast<const char*>(frame->gl_frame_data->mailbox.name),
       sizeof(frame->gl_frame_data->mailbox.name));
-  BuffersSwapped(
-      frame->gl_frame_data->size, frame->metadata.device_scale_factor,
-      mailbox_name, ack_callback);
+  BuffersSwapped(frame->gl_frame_data->size,
+                 frame->metadata.device_scale_factor,
+                 mailbox_name,
+                 frame->metadata.latency_info,
+                 ack_callback);
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
   if (GetBrowserAccessibilityManager()) {
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerWin()
         ->set_parent_iaccessible(accessible_parent);
   }
 }
 #endif
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& size,
     float surface_scale_factor,
     const std::string& mailbox_name,
+    const ui::LatencyInfo& latency_info,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> texture_to_return(current_surface_);
   const gfx::Rect surface_rect = gfx::Rect(size);
   if (!SwapBuffersPrepare(surface_rect, surface_scale_factor, surface_rect,
                           mailbox_name, ack_callback)) {
     return;
   }
 
   previous_damage_.setRect(RectToSkIRect(surface_rect));
   skipped_damage_.setEmpty();
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
     gfx::Size surface_size = ConvertSizeToDIP(surface_scale_factor, size);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
+    compositor->SetLatencyInfo(latency_info);
   }
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 
   SwapBuffersCompleted(ack_callback, texture_to_return);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
@@ skipping 54 matching lines @@
                   params_in_pixel.height));
 
     // Damage may not have been DIP aligned, so inflate damage to compensate
     // for any round-off error.
     rect_to_paint.Inset(-1, -1);
     rect_to_paint.Intersect(window_->bounds());
 
     if (paint_observer_)
       paint_observer_->OnUpdateCompositorContent();
     window_->SchedulePaintInRect(rect_to_paint);
+    compositor->SetLatencyInfo(params_in_pixel.latency_info);
   }
 
   SwapBuffersCompleted(ack_callback, previous_texture);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
@@ skipping 1283 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content