Remove some LatencyInfo merging code path

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/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 1342 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);
+  // TODO(miletus) : Pass the params_in_pixel.latency_info directly into
+  // BuffersSwapped() once GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params
+  // is converted to contain std::vector<ui::LatencyInfo>.
+  std::vector<ui::LatencyInfo> latency_info;
+  latency_info.push_back(params_in_pixel.latency_info);
   BuffersSwapped(params_in_pixel.size,
                  gfx::Rect(params_in_pixel.size),
                  params_in_pixel.scale_factor,
                  params_in_pixel.mailbox_name,
-                 params_in_pixel.latency_info,
+                 latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   DCHECK_NE(0u, frame_data->render_pass_list.size());
 
   cc::RenderPass* root_pass = frame_data->render_pass_list.back();
 
   gfx::Size frame_size = root_pass->output_rect.size();
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
 
   gfx::Rect damage_rect = gfx::ToEnclosingRect(root_pass->damage_rect);
   damage_rect.Intersect(gfx::Rect(frame_size));
@@ skipping 75 matching lines @@
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   window_->SchedulePaintInRect(damage_rect_in_dip);
 
   pending_delegated_ack_count_++;
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     SendDelegatedFrameAck(output_surface_id);
   } else {
-    compositor->SetLatencyInfo(latency_info);
+    for (size_t i = 0; i < latency_info.size(); i++)
+      compositor->SetLatencyInfo(latency_info[i]);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
   DidReceiveFrameFromRenderer();
   if (frame_provider_.get())
     delegated_frame_evictor_->SwappedFrame(!host_->is_hidden());
   // Note: the frame may have been evicted immediately.
 }
@@ skipping 33 matching lines @@
 void RenderWidgetHostViewAura::EvictDelegatedFrame() {
   window_->layer()->SetShowPaintedContent();
   frame_provider_ = NULL;
   delegated_frame_evictor_->DiscardedFrame();
 }
 
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::SoftwareFrameData> frame_data,
     float frame_device_scale_factor,
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
   if (ShouldSkipFrame(frame_size_in_dip)) {
     ReleaseSoftwareFrame(output_surface_id, frame_data->id);
     SendSoftwareFrameAck(output_surface_id);
     return;
   }
 
@@ skipping 23 matching lines @@
   released_front_lock_ = NULL;
   CheckResizeLock();
   window_->layer()->SetTextureMailbox(mailbox,
                                       callback.Pass(),
                                       frame_device_scale_factor);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
-    compositor->SetLatencyInfo(latency_info);
+    for (size_t i = 0; i < latency_info.size(); i++)
+      compositor->SetLatencyInfo(latency_info[i]);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   DidReceiveFrameFromRenderer();
 
   software_frame_manager_->SwapToNewFrameComplete(!host_->is_hidden());
@@ skipping 98 matching lines @@
     const {
   return reinterpret_cast<gfx::NativeViewId>(plugin_parent_window_);
 }
 #endif
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& surface_size,
     const gfx::Rect& damage_rect,
     float surface_scale_factor,
     const std::string& mailbox_name,
-    const ui::LatencyInfo& latency_info,
+    const std::vector<ui::LatencyInfo>& latency_info,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> previous_texture(current_surface_);
   const gfx::Rect surface_rect = gfx::Rect(surface_size);
   software_frame_manager_->DiscardCurrentFrame();
 
   if (!SwapBuffersPrepare(surface_rect,
                           surface_scale_factor,
                           damage_rect,
                           mailbox_name,
                           ack_callback)) {
@@ skipping 39 matching lines @@
                                    damage_rect.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(latency_info);
+    for (size_t i = 0; i < latency_info.size(); i++)
+      compositor->SetLatencyInfo(latency_info[i]);
   }
 
   SwapBuffersCompleted(ack_callback, previous_texture);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
   gfx::Rect damage_rect(params_in_pixel.x,
                         params_in_pixel.y,
                         params_in_pixel.width,
                         params_in_pixel.height);
   BufferPresentedCallback ack_callback =
       base::Bind(&AcknowledgeBufferForGpu,
                  params_in_pixel.route_id,
                  gpu_host_id,
                  params_in_pixel.mailbox_name);
+  // TODO(miletus) : Pass the params_in_pixel.latency_info directly into
+  // BuffersSwapped() once GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params
+  // is converted to contain std::vector<ui::LatencyInfo>.
+  std::vector<ui::LatencyInfo> latency_info;
+  latency_info.push_back(params_in_pixel.latency_info);
   BuffersSwapped(params_in_pixel.surface_size,
                  damage_rect,
                  params_in_pixel.surface_scale_factor,
                  params_in_pixel.mailbox_name,
-                 params_in_pixel.latency_info,
+                 latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
   if (current_surface_.get()) {
     ui::Compositor* compositor = GetCompositor();
@@ skipping 1710 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content