Remove gpu side LatencyInfo merging

ui/surface/accelerated_surface_win.h

 // 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.
 
 #ifndef UI_SURFACE_ACCELERATED_SURFACE_WIN_H_
 #define UI_SURFACE_ACCELERATED_SURFACE_WIN_H_
 
 #include <d3d9.h>
 
 #include "base/callback_forward.h"
@@ skipping 14 matching lines @@
 class Rect;
 }
 
 namespace media {
 class VideoFrame;
 }
 
 class SURFACE_EXPORT AcceleratedPresenter
     : public base::RefCountedThreadSafe<AcceleratedPresenter> {
  public:
-  typedef base::Callback<void(bool,
-                              base::TimeTicks,
-                              base::TimeDelta,
-                              const ui::LatencyInfo&)> CompletionTask;
+  typedef base::Callback<void(
+      bool,
+      base::TimeTicks,
+      base::TimeDelta,
+      const std::vector<ui::LatencyInfo>&)> CompletionTask;
 
   explicit AcceleratedPresenter(gfx::PluginWindowHandle window);
 
   static void SetAdapterLUID(uint64 adapter_luid);
 
   // Returns a thread safe reference to the presenter for the given window or
   // null is no such presenter exists. The thread safe refptr ensures the
   // presenter will not be destroyed. This can be called on any thread.
   static scoped_refptr<AcceleratedPresenter> GetForWindow(
       gfx::PluginWindowHandle window);
 
   // Schedule a frame to be presented. The completion callback will be invoked
   // when it is safe to write to the surface on another thread. The lock for
   // this surface will be held while the completion callback runs. This can be
   // called on any thread.
   void AsyncPresentAndAcknowledge(
       const gfx::Size& size,
       int64 surface_handle,
-      const ui::LatencyInfo& latency_info,
+      const std::vector<ui::LatencyInfo>& latency_info,
       const CompletionTask& completion_task);
 
   // Returns true if the swap chain has been created and initialized.  This can
   // be called on any thread.
   bool IsSwapChainInitialized() const;
 
   // Schedule the presenter to free all its resources. This can be called on any
   // thread.
   void Suspend();
 
@@ skipping 24 matching lines @@
  private:
   friend class base::RefCountedThreadSafe<AcceleratedPresenter>;
 
   ~AcceleratedPresenter();
 
   // These member functions are called on the PresentThread with which the
   // presenter has affinity.
   void DoPresentAndAcknowledge(
       const gfx::Size& size,
       int64 surface_handle,
-      const ui::LatencyInfo& latency_info,
+      const std::vector<ui::LatencyInfo>& latency_info,
       const CompletionTask& completion_task);
   void DoSuspend();
   void DoPresent(const base::Closure& composite_task);
   void DoReleaseSurface();
   void DoCopyToAndAcknowledge(
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       scoped_refptr<base::SingleThreadTaskRunner> callback_runner,
       const base::Callback<void(bool, const SkBitmap&)>& callback);
   void DoCopyToVideoFrameAndAcknowledge(
@@ skipping 53 matching lines @@
   // Set to true when the Windows session is locked.
   bool is_session_locked_;
 
   // These are used to detect when the window is resizing. For some reason,
   // presenting with D3D while the window resizes causes those parts not
   // drawn with D3D (e.g. with GDI) to flicker visible / invisible.
   // http://crbug.com/120904
   gfx::Size last_window_size_;
   base::Time last_window_resize_time_;
 
-  ui::LatencyInfo latency_info_;
+  std::vector<ui::LatencyInfo> latency_info_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratedPresenter);
 };
 
 class SURFACE_EXPORT AcceleratedSurface {
  public:
   AcceleratedSurface(gfx::PluginWindowHandle window);
   ~AcceleratedSurface();
 
   // Synchronously present a frame with no acknowledgement.
@@ skipping 26 matching lines @@
 
   // Called when the Windows session in locked or unlocked.
   void SetIsSessionLocked(bool locked);
 
  private:
   const scoped_refptr<AcceleratedPresenter> presenter_;
   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurface);
 };
 
 #endif  // UI_SURFACE_ACCELERATED_SURFACE_WIN_H_