Send input event's LatencyInfo back from renderer to browser when acked

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 47 matching lines @@
         if (last_event.touches[i].state == WebKit::WebTouchPoint::StateMoved)
           coalesced_event_.event.touches[i].state =
               WebKit::WebTouchPoint::StateMoved;
       }
       return true;
     }
 
     return false;
   }
 
+  void SetLatencyInfoForCoalescedEvent(const ui::LatencyInfo& latency_info) {
+    coalesced_event_.latency = latency_info;
+  }
+
   const TouchEventWithLatencyInfo& coalesced_event() const {
     return coalesced_event_;
   }
 
   WebTouchEventWithLatencyList::const_iterator begin() const {
     return events_.begin();
   }
 
   WebTouchEventWithLatencyList::const_iterator end() const {
     return events_.end();
@@ skipping 39 matching lines @@
   // If the last queued touch-event was a touch-move, and the current event is
   // 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) {
+void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
+                                      const ui::LatencyInfo& latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return;
 
+  touch_queue_.front()->SetLatencyInfoForCoalescedEvent(latency_info);

[sadrul, 2013/08/06 19:08:27]

Instead of doing this, can you send |latency_info| to PopTouchEventWithAck (and
perhaps rename it to PopTouchEventToClient, and send ui::LatencyInfo() in the
other calls to PopTouchEvent...)

[Yufeng Shen (Slow to review), 2013/08/06 19:36:14]

Done.

+
   // 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.
     for (unsigned i = 0; i < event.touchesLength; ++i) {
       const WebKit::WebTouchPoint& point = event.touches[i];
       if (point.state == WebKit::WebTouchPoint::StateReleased ||
           point.state == WebKit::WebTouchPoint::StateCancelled)
@@ skipping 43 matching lines @@
   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);
 
   for (WebTouchEventWithLatencyList::const_iterator iter = acked_event->begin(),
        end = acked_event->end();
        iter != end; ++iter) {
     ui::LatencyInfo* latency = const_cast<ui::LatencyInfo*>(&(iter->latency));
+    latency->AddNewLatencyFrom(acked_event->coalesced_event().latency);
     latency->AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_ACKED_COMPONENT, 0, 0);
     client_->OnTouchEventAck((*iter), ack_result);
   }
 }
 
 bool TouchEventQueue::ShouldForwardToRenderer(
     const WebKit::WebTouchEvent& event) const {
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebKit::WebInputEvent::TouchStart)
@@ skipping 13 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