Remove gpu side LatencyInfo merging

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/base64.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 46 matching lines @@
 #include "ui/ozone/ozone_switches.h"
 #endif
 
 namespace content {
 
 bool GpuProcessHost::gpu_enabled_ = true;
 bool GpuProcessHost::hardware_gpu_enabled_ = true;
 
 namespace {
 
+const unsigned int kMaxLatencyInfoNumber = 100;
+
 enum GPUProcessLifetimeEvent {
   LAUNCHED,
   DIED_FIRST_TIME,
   DIED_SECOND_TIME,
   DIED_THIRD_TIME,
   DIED_FOURTH_TIME,
   GPU_PROCESS_LIFETIME_EVENT_MAX = 100
 };
 
 // Indexed by GpuProcessKind. There is one of each kind maximum. This array may
@@ skipping 48 matching lines @@
   }
 }
 
 #if defined(OS_WIN)
 // This sends a ViewMsg_SwapBuffers_ACK directly to the renderer process
 // (RenderWidget).
 void AcceleratedSurfaceBuffersSwappedCompletedForRenderer(
     int surface_id,
     base::TimeTicks timebase,
     base::TimeDelta interval,
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&AcceleratedSurfaceBuffersSwappedCompletedForRenderer,
                    surface_id, timebase, interval, latency_info));
     return;
   }
 
   int render_process_id = 0;
@@ skipping 14 matching lines @@
   RenderWidgetHostImpl::From(rwh)->DidReceiveRendererFrame();
 }
 
 void AcceleratedSurfaceBuffersSwappedCompleted(
     int host_id,
     int route_id,
     int surface_id,
     bool alive,
     base::TimeTicks timebase,
     base::TimeDelta interval,
-    const ui::LatencyInfo& latency_info) {
+    const std::vector<ui::LatencyInfo>& latency_info) {
   AcceleratedSurfaceBuffersSwappedCompletedForGPU(
       host_id, route_id, alive, timebase, interval);
   AcceleratedSurfaceBuffersSwappedCompletedForRenderer(
       surface_id, timebase, interval, latency_info);
 }
 
 // NOTE: changes to this class need to be reviewed by the security team.
 class GpuSandboxedProcessLauncherDelegate
     : public SandboxedProcessLauncherDelegate {
  public:
@@ skipping 686 matching lines @@
 
 void GpuProcessHost::OnGpuMemoryUmaStatsReceived(
     const GPUMemoryUmaStats& stats) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryUmaStatsReceived");
   uma_memory_stats_received_ = true;
   uma_memory_stats_ = stats;
 }
 
 #if defined(OS_MACOSX)
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {

[jln (very slow on Chromium), 2014/01/14 01:11:52]

Check for vector size here as well.

[Yufeng Shen (Slow to review), 2014/01/14 20:02:42]

Done.

   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   gfx::GLSurfaceHandle surface_handle =
       GpuSurfaceTracker::Get()->GetSurfaceHandle(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 (surface_handle.handle != gfx::kNullPluginWindow ||
       surface_handle.transport_type == gfx::TEXTURE_TRANSPORT) {
     RouteOnUIThread(GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
@@ skipping 23 matching lines @@
   ignore_result(scoped_completion_runner.Release());
 
   ViewHostMsg_CompositorSurfaceBuffersSwapped_Params view_params;
   view_params.surface_id = params.surface_id;
   view_params.surface_handle = params.surface_handle;
   view_params.route_id = params.route_id;
   view_params.size = params.size;
   view_params.scale_factor = params.scale_factor;
   view_params.gpu_process_host_id = host_id_;
   view_params.latency_info = params.latency_info;
+  if (view_params.latency_info.size() > kMaxLatencyInfoNumber) {
+    for (size_t i = 0; i < view_params.latency_info.size(); i++)
+      view_params.latency_info[i].AddLatencyNumber(
+          ui::LATENCY_INFO_LIST_TERMINATED_OVERFLOW_COMPONENT, 0, 0);
+    view_params.latency_info.clear();
+  }
   helper->DidReceiveBackingStoreMsg(ViewHostMsg_CompositorSurfaceBuffersSwapped(
       render_widget_id,
       view_params));
 }
 #endif  // OS_MACOSX
 
 #if defined(OS_WIN)
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");

[jln (very slow on Chromium), 2014/01/14 01:11:52]

Another size check required here.

[Yufeng Shen (Slow to review), 2014/01/14 20:02:42]

Done.

 
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompleted,
           host_id_, params.route_id, params.surface_id,
-          true, base::TimeTicks(), base::TimeDelta(), ui::LatencyInfo()));
+          true, base::TimeTicks(), base::TimeDelta(),
+          std::vector<ui::LatencyInfo>()));
 
   gfx::GLSurfaceHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceHandle(params.surface_id);
 
   if (handle.is_null())
     return;
 
   if (handle.transport_type == gfx::TEXTURE_TRANSPORT) {
     TRACE_EVENT1("gpu", "SurfaceIDNotFound_RoutingToUI",
                  "surface_id", params.surface_id);
@@ skipping 45 matching lines @@
       presenter->AsyncCopyToVideoFrame(
           gfx::Rect(params.size), target_frame,
           base::Bind(copy_callback, present_time));
     }
   }
 }
 
 void GpuProcessHost::OnAcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfacePostSubBuffer");
 

[jln (very slow on Chromium), 2014/01/14 01:11:52]

And here as well (or someone will forget to check when they'll implement it).

[Yufeng Shen (Slow to review), 2014/01/14 20:02:42]

Done.

   NOTIMPLEMENTED();
 }
 
 void GpuProcessHost::OnAcceleratedSurfaceSuspend(int32 surface_id) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceSuspend");
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceHandle(surface_id).handle;
 
   if (!handle) {
@@ skipping 249 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content