Remove gpu side LatencyInfo merging

ui/surface/accelerated_surface_win.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 "ui/surface/accelerated_surface_win.h"
 
 #include <windows.h>
 #include <algorithm>
 
 #include "base/bind.h"
@@ skipping 359 matching lines @@
 
 // static
 scoped_refptr<AcceleratedPresenter> AcceleratedPresenter::GetForWindow(
     gfx::PluginWindowHandle window) {
   return g_accelerated_presenter_map.Pointer()->GetPresenter(window);
 }
 
 void AcceleratedPresenter::AsyncPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const ui::LatencyInfo& latency_info,
+    const std::vector<ui::LatencyInfo>& latency_info,
     const CompletionTask& completion_task) {
   if (!surface_handle) {
     TRACE_EVENT1("gpu", "EarlyOut_ZeroSurfaceHandle",
                  "surface_handle", surface_handle);
-    completion_task.Run(
-        true, base::TimeTicks(), base::TimeDelta(), ui::LatencyInfo());
+    completion_task.Run(true, base::TimeTicks(), base::TimeDelta(),
+                        std::vector<ui::LatencyInfo>());
     return;
   }
 
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  this,
                  size,
                  surface_handle,
                  latency_info,
@@ skipping 275 matching lines @@
 
 bool AcceleratedPresenter::IsSwapChainInitialized() const {
   base::AutoLock locked(*present_thread_->lock());
 
   return !!swap_chain_;
 }
 
 void AcceleratedPresenter::DoPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const ui::LatencyInfo& latency_info,
+    const std::vector<ui::LatencyInfo>& latency_info,
     const CompletionTask& completion_task) {
   TRACE_EVENT2(
       "gpu", "DoPresentAndAcknowledge",
       "width", size.width(),
       "height", size.height());
 
   HRESULT hr;
 
   base::AutoLock locked(*present_thread_->lock());
 
-  latency_info_.MergeWith(latency_info);
+  for (size_t i = 0; i < latency_info.size(); i++)
+    latency_info_.push_back(latency_info[i]);
 
   // Initialize the device lazily since calling Direct3D can crash bots.
   present_thread_->InitDevice();
 
   if (!present_thread_->device()) {
-    completion_task.Run(
-        false, base::TimeTicks(), base::TimeDelta(), ui::LatencyInfo());
+    completion_task.Run(false, base::TimeTicks(), base::TimeDelta(),
+                        std::vector<ui::LatencyInfo>());
     TRACE_EVENT0("gpu", "EarlyOut_NoDevice");
     return;
   }
 
   // Ensure the task is acknowledged on early out after this point.
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(completion_task,
                  true,
                  base::TimeTicks(),
                  base::TimeDelta(),
-                 ui::LatencyInfo()));
+                 std::vector<ui::LatencyInfo>()));
 
   // If invalidated, do nothing, the window is gone.
   if (!window_) {
     TRACE_EVENT0("gpu", "EarlyOut_NoWindow");
     return;
   }
 
 #if !defined(USE_AURA)
   // If the window is a different size than the swap chain that is being
   // presented then drop the frame.
@@ skipping 118 matching lines @@
       if (present_thread_->IsDeviceLost())
         present_thread_->ResetDevice();
       return;
     }
   } else {
     HDC dc = GetDC(window_);
     PresentWithGDI(dc);
     ReleaseDC(window_, dc);
   }
 
-  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);
+  }
 
   hidden_ = false;
 
   D3DDISPLAYMODE display_mode;
   hr = present_thread_->device()->GetDisplayMode(0, &display_mode);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get display mode";
     return;
   }
 
@@ skipping 47 matching lines @@
         if (present_thread_->IsDeviceLost()) {
           present_thread_->ResetDevice();
           return;
         }
       }
     } while (hr == S_FALSE);
   }
 
   scoped_completion_runner.Release();
   completion_task.Run(true, last_vsync_time, refresh_period, latency_info_);
-  latency_info_.Clear();
+  latency_info_.clear();
 }
 
 void AcceleratedPresenter::DoSuspend() {
   base::AutoLock locked(*present_thread_->lock());
   swap_chain_ = NULL;
 }
 
 void AcceleratedPresenter::DoReleaseSurface() {
   base::AutoLock locked(*present_thread_->lock());
   present_thread_->InitDevice();
@@ skipping 169 matching lines @@
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }
 
 void AcceleratedSurface::SetIsSessionLocked(bool locked) {
   presenter_->SetIsSessionLocked(locked);
 }