Remove gpu side LatencyInfo merging

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.
 
 #include "content/common/gpu/image_transport_surface.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 37 matching lines @@
       manager_(manager),
       stub_(stub->AsWeakPtr()),
       handle_(handle) {
   route_id_ = manager_->GenerateRouteID();
   manager_->AddRoute(route_id_, this);
 }
 
 ImageTransportHelper::~ImageTransportHelper() {
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
-        base::Callback<void(const ui::LatencyInfo&)>());
+        base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
   manager_->RemoveRoute(route_id_);
 }
 
 bool ImageTransportHelper::Initialize() {
   gpu::gles2::GLES2Decoder* decoder = Decoder();
 
   if (!decoder)
     return false;
 
@@ skipping 56 matching lines @@
 }
 
 void ImageTransportHelper::SendUpdateVSyncParameters(
       base::TimeTicks timebase, base::TimeDelta interval) {
   manager_->Send(new GpuHostMsg_UpdateVSyncParameters(stub_->surface_id(),
                                                       timebase,
                                                       interval));
 }
 
 void ImageTransportHelper::SendLatencyInfo(
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   manager_->Send(new GpuHostMsg_FrameDrawn(latency_info));
 }
 
 void ImageTransportHelper::SetScheduled(bool is_scheduled) {
   gpu::GpuScheduler* scheduler = Scheduler();
   if (!scheduler)
     return;
 
   scheduler->SetScheduled(is_scheduled);
 }
@@ skipping 56 matching lines @@
 void ImageTransportHelper::Resize(gfx::Size size, float scale_factor) {
   surface_->OnResize(size, scale_factor);
 
 #if defined(OS_ANDROID)
   manager_->gpu_memory_manager()->ScheduleManage(
       GpuMemoryManager::kScheduleManageNow);
 #endif
 }
 
 void ImageTransportHelper::SetLatencyInfo(
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   surface_->SetLatencyInfo(latency_info);
 }
 
 PassThroughImageTransportSurface::PassThroughImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::GLSurface* surface,
     bool transport)
     : GLSurfaceAdapter(surface),
       transport_(transport),
@@ skipping 20 matching lines @@
   if (is_swap_buffers_pending_) {
     DCHECK(!did_unschedule_);
     did_unschedule_ = true;
     helper_->SetScheduled(false);
     return true;
   }
   return false;
 }
 
 void PassThroughImageTransportSurface::SetLatencyInfo(
-    const ui::LatencyInfo& latency_info) {
-  latency_info_ = latency_info;
+    const std::vector<ui::LatencyInfo>& latency_info) {
+  for (size_t i = 0; i < latency_info.size(); i++)
+    latency_info_.push_back(latency_info[i]);
 }
 
 bool PassThroughImageTransportSurface::SwapBuffers() {
   // GetVsyncValues before SwapBuffers to work around Mali driver bug:
   // crbug.com/223558.
   SendVSyncUpdateIfAvailable();
   bool result = gfx::GLSurfaceAdapter::SwapBuffers();
-  latency_info_.AddLatencyNumber(
-      ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
+  for (size_t i = 0; i < latency_info_.size(); i++) {
+    latency_info_[i].AddLatencyNumber(
+        ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
+  }
 
   if (transport_) {
     DCHECK(!is_swap_buffers_pending_);
     is_swap_buffers_pending_ = true;
 
     // 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.latency_info = std::vector<ui::LatencyInfo>();

[jbauman, 2014/01/09 01:28:47]

Why aren't you passing latency_info_ through here?

[Yufeng Shen (Slow to review), 2014/01/09 22:41:40]

Done.

     params.size = surface()->GetSize();
     helper_->SendAcceleratedSurfaceBuffersSwapped(params);
   } else {
     helper_->SendLatencyInfo(latency_info_);
   }
+  latency_info_.clear();
   return result;
 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   SendVSyncUpdateIfAvailable();
   bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
-  latency_info_.AddLatencyNumber(
-      ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
+  for (size_t i = 0; i < latency_info_.size(); i++) {
+    latency_info_[i].AddLatencyNumber(
+        ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
+  }
 
   if (transport_) {
     DCHECK(!is_swap_buffers_pending_);
     is_swap_buffers_pending_ = true;
 
     // 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.latency_info = std::vector<ui::LatencyInfo>();

[jbauman, 2014/01/09 01:28:47]

Likewise, you need to pass latency_info_ through here.

[Yufeng Shen (Slow to review), 2014/01/09 22:41:40]

Done.

     params.surface_size = surface()->GetSize();
     params.x = x;
     params.y = y;
     params.width = width;
     params.height = height;
     helper_->SendAcceleratedSurfacePostSubBuffer(params);
 
     helper_->SetScheduled(false);
   } else {
     helper_->SendLatencyInfo(latency_info_);
   }
+  latency_info_.clear();
   return result;
 }
 
 bool PassThroughImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (!did_set_swap_interval_) {
     ImageTransportHelper::SetSwapInterval(context);
     did_set_swap_interval_ = true;
   }
   return true;
 }
@@ skipping 44 matching lines @@
 void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
   gfx::VSyncProvider* vsync_provider = GetVSyncProvider();
   if (vsync_provider) {
     vsync_provider->GetVSyncParameters(
       base::Bind(&ImageTransportHelper::SendUpdateVSyncParameters,
                  helper_->AsWeakPtr()));
   }
 }
 
 }  // namespace content