Report LatencyInfo through trace buffer

content/browser/renderer_host/input/touch_event_queue.cc

 // 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.
 
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 
@@ skipping 51 matching lines @@
       return true;
     }
 
     return false;
   }
 
   const TouchEventWithLatencyInfo& coalesced_event() const {
     return coalesced_event_;
   }
 
-  WebTouchEventWithLatencyList::const_iterator begin() const {
+  WebTouchEventWithLatencyList::iterator begin() {
     return events_.begin();
   }
 
-  WebTouchEventWithLatencyList::const_iterator end() const {
+  WebTouchEventWithLatencyList::iterator end() {
     return events_.end();
   }
 
   size_t size() const { return events_.size(); }
 
  private:
   // This is the event that is forwarded to the renderer.
   TouchEventWithLatencyInfo coalesced_event_;
 
   // This is the list of the original events that were coalesced.
@@ skipping 29 matching lines @@
   // also a touch-move, then the events can be coalesced into a single event.
   if (touch_queue_.size() > 1) {
     CoalescedWebTouchEvent* last_event = touch_queue_.back();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
-                                      const ui::LatencyInfo& latency_info) {
+                                      ui::LatencyInfo* latency_info) {

[jdduke (slow), 2013/10/04 02:22:19]

It looks like you can keep this a const ref, same with the
PopTouchEventToClient() arg.

[Yufeng Shen (Slow to review), 2013/10/04 18:03:03]

Done.

   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return;
 
   // Update the ACK status for each touch point in the ACKed event.
   const WebKit::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
   if (event.type == WebKit::WebInputEvent::TouchEnd ||
       event.type == WebKit::WebInputEvent::TouchCancel) {
     // The points have been released. Erase the ACK states.
@@ skipping 18 matching lines @@
 void TouchEventQueue::TryForwardNextEventToRenderer() {
   // If there are queued touch events, then try to forward them to the renderer
   // immediately, or ACK the events back to the client if appropriate.
   while (!touch_queue_.empty()) {
     const TouchEventWithLatencyInfo& touch =
         touch_queue_.front()->coalesced_event();
     if (ShouldForwardToRenderer(touch.event)) {
       client_->SendTouchEventImmediately(touch);
       break;
     }
+    ui::LatencyInfo latency;
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
-                          ui::LatencyInfo());
+                          &latency);
   }
 }
 
 void TouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
+  ui::LatencyInfo latency;
   while (!touch_queue_.empty())
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
-                          ui::LatencyInfo());
+                          &latency);
 }
 
 size_t TouchEventQueue::GetQueueSize() const {
   return touch_queue_.size();
 }
 
 const TouchEventWithLatencyInfo& TouchEventQueue::GetLatestEvent() const {
   return touch_queue_.back()->coalesced_event();
 }
 
 void TouchEventQueue::PopTouchEventToClient(
     InputEventAckState ack_result,
-    const ui::LatencyInfo& renderer_latency_info) {
+    ui::LatencyInfo* renderer_latency_info) {
   if (touch_queue_.empty())

[jdduke (slow), 2013/10/04 02:22:19]

You're adding renderer_latency_info to latency below, so I think you can keep it
const ref.

[Yufeng Shen (Slow to review), 2013/10/04 18:03:03]

Done.

     return;
   scoped_ptr<CoalescedWebTouchEvent> acked_event(touch_queue_.front());
   touch_queue_.pop_front();
 
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
   base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
 
-  base::TimeTicks now = base::TimeTicks::HighResNow();
-  for (WebTouchEventWithLatencyList::const_iterator iter = acked_event->begin(),
+  for (WebTouchEventWithLatencyList::iterator iter = acked_event->begin(),
        end = acked_event->end();
        iter != end; ++iter) {
-    ui::LatencyInfo* latency = const_cast<ui::LatencyInfo*>(&(iter->latency));
-    latency->AddNewLatencyFrom(renderer_latency_info);
-    latency->AddLatencyNumberWithTimestamp(
-        ui::INPUT_EVENT_LATENCY_ACKED_COMPONENT, 0, 0, now, 1);
-    client_->OnTouchEventAck((*iter), ack_result);
+    ui::LatencyInfo* latency = &(iter->latency);
+    latency->AddNewLatencyFrom(*renderer_latency_info);
+    client_->OnTouchEventAck(iter->event, ack_result, latency);
   }
 }
 
 bool TouchEventQueue::ShouldForwardToRenderer(
     const WebKit::WebTouchEvent& event) const {
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebKit::WebInputEvent::TouchStart)
     return true;
 
   if (event.type == WebKit::WebInputEvent::TouchMove &&
@@ skipping 14 matching lines @@
       // If the ACK status of a point is unknown, then the event should be
       // forwarded to the renderer.
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace content