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 689 matching lines @@
   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) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
+  if (params.latency_info.size() > kMaxLatencyInfoNumber) {
+    LOG(ERROR) << "GpuHostMsg_AcceleratedSurfaceBuffersSwapped LatencyInfo"
+               << " size " << params.latency_info.size() << " is too big.";

[Ken Russell (switch to Gerrit), 2014/01/15 06:41:29]

Please refactor this duplicated code and constant to be contained in one place.
I suggest adding a static method to ui::LatencyInfo like

  bool Verify(const std::vector<LatencyInfo>& info_vector, const char*
referring_message_name)

which you can call throughout this CL with two lines, like

  if (!ui::LatencyInfo::Verify(params.latency_info,
"GpuHostMsg_AcceleratedSurfaceBuffersSwapped"))
    return;

Please place the implementation in latency_info.cc so it doesn't get inlined
everywhere.

[Yufeng Shen (Slow to review), 2014/01/15 19:44:31]

Done.

+    return;
+  }
+
   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));
     return;
   }
@@ skipping 32 matching lines @@
       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");
 
+  if (params.latency_info.size() > kMaxLatencyInfoNumber) {
+    LOG(ERROR) << "GpuHostMsg_AcceleratedSurfaceBuffersSwapped LatencyInfo"
+               << " size " << params.latency_info.size() << " is too big.";
+    return;
+  }
+
   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 46 matching lines @@
           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");
 
+  if (params.latency_info.size() > kMaxLatencyInfoNumber) {
+    LOG(ERROR) << "GpuHostMsg_AcceleratedSurfacePostSubBuffer LatencyInfo"
+               << " size " << params.latency_info.size() << " is too big.";
+    return;
+  }
+
   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