Report LatencyInfo through trace buffer

content/browser/renderer_host/input/immediate_input_router.h

 // Copyright 2013 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 CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_
 
 #include <queue>
 
 #include "base/basictypes.h"
@@ skipping 60 matching lines @@
   }
 
   TouchEventQueue* touch_event_queue() {
     return touch_event_queue_.get();
   }
 
 private:
   friend class ImmediateInputRouterTest;
 
   // TouchEventQueueClient
-  virtual void OnTouchEventAck(const TouchEventWithLatencyInfo& event,
-                               InputEventAckState ack_result) OVERRIDE;
+  virtual void OnTouchEventAck(const WebKit::WebTouchEvent& event,
+                               InputEventAckState ack_result,
+                               ui::LatencyInfo* latency) OVERRIDE;
 
   bool SendMoveCaret(scoped_ptr<IPC::Message> message);
   bool SendSelectRange(scoped_ptr<IPC::Message> message);
   bool Send(IPC::Message* message);
 
   // Transmits the given input event an as an IPC::Message. This is an internal
   // helper for |FilterAndSendInputEvent()| and should not be used otherwise.
   void SendWebInputEvent(const WebKit::WebInputEvent& input_event,
                          const ui::LatencyInfo& latency_info,
                          bool is_keyboard_shortcut);
 
   // Filters and forwards the given WebInputEvent to |SendWebInputEvent()|. This
   // is an internal helper for |Send*Event()| and should not be used otherwise.
   void FilterAndSendWebInputEvent(const WebKit::WebInputEvent& input_event,
                                   const ui::LatencyInfo& latency_info,
                                   bool is_keyboard_shortcut);
 
   // IPC message handlers
   void OnInputEventAck(WebKit::WebInputEvent::Type event_type,
                        InputEventAckState ack_result,
-                       const ui::LatencyInfo& latency_info);
+                       ui::LatencyInfo latency_info);
   void OnMsgMoveCaretAck();
   void OnSelectRangeAck();
   void OnHasTouchEventHandlers(bool has_handlers);
 
   // Handle the event ack. Triggered via |OnInputEventAck()| if the event was
   // processed in the renderer, or synchonously from |FilterAndSendInputevent()|
   // if the event was filtered by the |client_| prior to sending.
   void ProcessInputEventAck(WebKit::WebInputEvent::Type event_type,
                             InputEventAckState ack_result,
-                            const ui::LatencyInfo& latency_info);
+                            ui::LatencyInfo* latency_info);
 
   // Called by ProcessInputEventAck() to process a keyboard event ack message.
   void ProcessKeyboardAck(int type, InputEventAckState ack_result);
 
   // Called by ProcessInputEventAck() to process a wheel event ack message.
   // This could result in a task being posted to allow additional wheel
   // input messages to be coalesced.
-  void ProcessWheelAck(InputEventAckState ack_result);
+  void ProcessWheelAck(InputEventAckState ack_result,
+                       ui::LatencyInfo* latency_info);
 
   // Called by ProcessInputEventAck() to process a gesture event ack message.
   // This validates the gesture for suppression of touchpad taps and sends one
   // previously queued coalesced gesture if it exists.
-  void ProcessGestureAck(int type, InputEventAckState ack_result);
+  void ProcessGestureAck(int type,
+                         InputEventAckState ack_result,
+                         ui::LatencyInfo* latency);
 
   // Called on ProcessInputEventAck() to process a touch event ack message.
   // This can result in a gesture event being generated and sent back to the
   // renderer.
   void ProcessTouchAck(InputEventAckState ack_result,
-                       const ui::LatencyInfo& latency_info);
+                       ui::LatencyInfo* latency_info);
 
   void HandleGestureScroll(
       const GestureEventWithLatencyInfo& gesture_event);
 
   int routing_id() const { return routing_id_; }
 
 
   RenderProcessHost* process_;
   InputRouterClient* client_;
   InputAckHandler* ack_handler_;
@@ skipping 57 matching lines @@
 
   scoped_ptr<TouchEventQueue> touch_event_queue_;
   scoped_ptr<GestureEventFilter> gesture_event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(ImmediateInputRouter);
 };
 
 }  // namespace content
 
 #endif // CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_