Add latency info to input events sent to RenderWidget.

content/browser/renderer_host/render_widget_host_impl.cc

Index: content/browser/renderer_host/render_widget_host_impl.cc
diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 395bd1bb5c7bb5fcdfa7c2b5b301cec78d51f456..f66c9b7631e4b4860b6474f22f9f702e1e802c0a 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -171,7 +171,8 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       tick_active_smooth_scroll_gestures_task_posted_(false),
       touch_event_queue_(new TouchEventQueue(this)),
-      gesture_event_filter_(new GestureEventFilter(this)) {
+      gesture_event_filter_(new GestureEventFilter(this)),
+      last_input_number_(0) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
@@ -921,8 +922,15 @@ void RenderWidgetHostImpl::SimulateTouchGestureWithMouse(
   }
 }
 
-void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
-  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::ForwardMouseEvent",
+void RenderWidgetHostImpl::ForwardMouseEvent(
+    const WebMouseEvent& mouse_event) {
+  ForwardMouseEventWithLatencyInfo(mouse_event, NewInputLatencyInfo());
+}
+
+void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
+    const WebMouseEvent& mouse_event, const cc::LatencyInfo& latency_info) {
+  TRACE_EVENT2("renderer_host",
+               "RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo",
                "x", mouse_event.x, "y", mouse_event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
@@ -935,14 +943,14 @@ void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
 
   if (mouse_event.type == WebInputEvent::MouseDown &&
       gesture_event_filter_->GetTouchpadTapSuppressionController()->
-          ShouldDeferMouseDown(mouse_event))
+          ShouldDeferMouseDown(mouse_event, latency_info))
       return;
   if (mouse_event.type == WebInputEvent::MouseUp &&
       gesture_event_filter_->GetTouchpadTapSuppressionController()->
           ShouldSuppressMouseUp())
       return;
 
-  ForwardMouseEventImmediately(mouse_event);
+  ForwardMouseEventImmediately(mouse_event, latency_info);
 }
 
 void RenderWidgetHostImpl::OnPointerEventActivate() {
@@ -950,7 +958,14 @@ void RenderWidgetHostImpl::OnPointerEventActivate() {
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardWheelEvent");
+  ForwardWheelEventWithLatencyInfo(wheel_event, NewInputLatencyInfo());
+}
+
+void RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo(
+    const WebMouseWheelEvent& wheel_event,
+    const cc::LatencyInfo& latency_info) {
+  TRACE_EVENT0("renderer_host",
+               "RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ -963,12 +978,13 @@ void RenderWidgetHostImpl::ForwardWheelEvent(
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
-        !ShouldCoalesceMouseWheelEvents(coalesced_mouse_wheel_events_.back(),
-                                        wheel_event)) {
-      coalesced_mouse_wheel_events_.push_back(wheel_event);
+        !ShouldCoalesceMouseWheelEvents(
+            coalesced_mouse_wheel_events_.back().first, wheel_event)) {
+      coalesced_mouse_wheel_events_.push_back(
+          std::make_pair(wheel_event, latency_info));
     } else {
       WebMouseWheelEvent* last_wheel_event =
-          &coalesced_mouse_wheel_events_.back();
+          &coalesced_mouse_wheel_events_.back().first;
       float unaccelerated_x =
           GetUnacceleratedDelta(last_wheel_event->deltaX,
                                 last_wheel_event->accelerationRatioX) +
@@ -990,6 +1006,7 @@ void RenderWidgetHostImpl::ForwardWheelEvent(
       DCHECK_GE(wheel_event.timeStampSeconds,
                 last_wheel_event->timeStampSeconds);
       last_wheel_event->timeStampSeconds = wheel_event.timeStampSeconds;
+      coalesced_mouse_wheel_events_.back().second.MergeWith(latency_info);
     }
     return;
   }
@@ -999,7 +1016,8 @@ void RenderWidgetHostImpl::ForwardWheelEvent(
   HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
-  ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
+  ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), latency_info,
+                    false);
 }
 
 void RenderWidgetHostImpl::ForwardGestureEvent(
@@ -1008,17 +1026,22 @@ void RenderWidgetHostImpl::ForwardGestureEvent(
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
+  cc::LatencyInfo latency_info = NewInputLatencyInfo();
+
   if (!IsInOverscrollGesture() &&
-      !gesture_event_filter_->ShouldForward(gesture_event))
+      !gesture_event_filter_->ShouldForward(
+          GestureEventLatency(gesture_event, latency_info)))
     return;
 
-  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
+  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent),
+                    latency_info, false);
 }
 
 // Forwards MouseEvent without passing it through
 // TouchpadTapSuppressionController.
 void RenderWidgetHostImpl::ForwardMouseEventImmediately(
-    const WebMouseEvent& mouse_event) {
+    const WebMouseEvent& mouse_event,
+    const cc::LatencyInfo& latency_info) {
   TRACE_EVENT2("renderer_host",
                "RenderWidgetHostImpl::ForwardMouseEventImmediately",
                "x", mouse_event.x, "y", mouse_event.y);
@@ -1039,6 +1062,7 @@ void RenderWidgetHostImpl::ForwardMouseEventImmediately(
     if (mouse_move_pending_) {
       if (!next_mouse_move_) {
         next_mouse_move_.reset(new WebMouseEvent(mouse_event));
+        next_mouse_move_latency_info_ = latency_info;
       } else {
         // Accumulate movement deltas.
         int x = next_mouse_move_->movementX;
@@ -1046,6 +1070,7 @@ void RenderWidgetHostImpl::ForwardMouseEventImmediately(
         *next_mouse_move_ = mouse_event;
         next_mouse_move_->movementX += x;
         next_mouse_move_->movementY += y;
+        next_mouse_move_latency_info_.MergeWith(latency_info);
       }
       return;
     }
@@ -1054,7 +1079,7 @@ void RenderWidgetHostImpl::ForwardMouseEventImmediately(
     OnUserGesture();
   }
 
-  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
+  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), latency_info, false);
 }
 
 void RenderWidgetHostImpl::ForwardTouchEventImmediately(
@@ -1063,14 +1088,16 @@ void RenderWidgetHostImpl::ForwardTouchEventImmediately(
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
-  ForwardInputEvent(touch_event, sizeof(WebKit::WebTouchEvent), false);
+  ForwardInputEvent(touch_event, sizeof(WebKit::WebTouchEvent),
+                    NewInputLatencyInfo(), false);
 }
 
 void RenderWidgetHostImpl::ForwardGestureEventImmediately(
     const WebKit::WebGestureEvent& gesture_event) {
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
-  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
+  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent),
+                    NewInputLatencyInfo(), false);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
@@ -1142,22 +1169,35 @@ void RenderWidgetHostImpl::ForwardKeyboardEvent(
 
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
+                      NewInputLatencyInfo(),
                       is_keyboard_shortcut);
   }
 }
 
+int64 RenderWidgetHostImpl::GetLatencyComponentId() {
+  return GetRoutingID() | ((int64)GetProcess()->GetID() << 32);

[piman, 2013/04/22 20:46:38]

nit: no c-style casts.

qq: does anything bad happens when process IDs wrap and get reused?

+}
+
+cc::LatencyInfo RenderWidgetHostImpl::NewInputLatencyInfo() {

[piman, 2013/04/22 20:46:38]

It's ok to do it by steps, but I want to make sure that we have the long term
vision: there can be sources of input latency in the UI layer (e.g. its own
coalescing), so I'm hoping the latency information will be passed from the UI
layer to the RWHI

+  cc::LatencyInfo info;
+  info.AddLatencyNumber(cc::kInputEvent, GetLatencyComponentId(),
+                        ++last_input_number_);
+  return info;
+}
+
 void RenderWidgetHostImpl::SendInputEvent(const WebInputEvent& input_event,
                                           int event_size,
+                                          const cc::LatencyInfo& latency_info,
                                           bool is_keyboard_shortcut) {
   input_event_start_time_ = TimeTicks::Now();
   Send(new ViewMsg_HandleInputEvent(
-      routing_id_, &input_event, is_keyboard_shortcut));
+      routing_id_, &input_event, latency_info, is_keyboard_shortcut));
   increment_in_flight_event_count();
 }
 
-void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
-                                             int event_size,
-                                             bool is_keyboard_shortcut) {
+void RenderWidgetHostImpl::ForwardInputEvent(
+    const WebInputEvent& input_event, int event_size,
+    const cc::LatencyInfo& latency_info, bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
 
   if (!process_->HasConnection())
@@ -1166,7 +1206,7 @@ void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
   DCHECK(!process_->IgnoreInputEvents());
 
   if (overscroll_controller_.get() &&
-      !overscroll_controller_->WillDispatchEvent(input_event)) {
+      !overscroll_controller_->WillDispatchEvent(input_event, latency_info)) {
     // Reset the wheel-event state when appropriate.
     if (input_event.type == WebKit::WebInputEvent::MouseWheel) {
       mouse_wheel_pending_ = false;
@@ -1197,8 +1237,9 @@ void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
   // to terminate rubber-banding, for example.
   if (input_event.type != WebInputEvent::MouseWheel) {
     for (size_t i = 0; i < coalesced_mouse_wheel_events_.size(); ++i) {
-      SendInputEvent(coalesced_mouse_wheel_events_[i],
-                     sizeof(WebMouseWheelEvent), false);
+      SendInputEvent(coalesced_mouse_wheel_events_[i].first,
+                     sizeof(WebMouseWheelEvent),
+                     coalesced_mouse_wheel_events_[i].second, false);
     }
     coalesced_mouse_wheel_events_.clear();
   }
@@ -1224,7 +1265,7 @@ void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
     };
   }
 
-  SendInputEvent(input_event, event_size, is_keyboard_shortcut);
+  SendInputEvent(input_event, event_size, latency_info, is_keyboard_shortcut);
 
   // Any input event cancels a pending mouse move event. Note that
   // |next_mouse_move_| possibly owns |input_event|, so don't use |input_event|
@@ -1828,7 +1869,8 @@ void RenderWidgetHostImpl::OnInputEventAck(
     // now, we can send the next mouse move event
     if (next_mouse_move_) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
-      ForwardMouseEvent(*next_mouse_move_);
+      ForwardMouseEventWithLatencyInfo(*next_mouse_move_,
+                                       next_mouse_move_latency_info_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
@@ -1966,10 +2008,11 @@ void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
-    WebMouseWheelEvent next_wheel_event =
+    std::pair<WebMouseWheelEvent, cc::LatencyInfo> next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
-    ForwardWheelEvent(next_wheel_event);
+    ForwardWheelEventWithLatencyInfo(next_wheel_event.first,
+                                     next_wheel_event.second);
   }
 
   if (!processed && !is_hidden_ && view_)
@@ -2473,4 +2516,19 @@ void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
+void RenderWidgetHostImpl::FrameSwapped(const cc::LatencyInfo& latency_info) {
+  FOR_EACH_OBSERVER(FrameSwappedObserver, frame_swapped_observer_list_,
+      OnFrameSwapped(this, latency_info));
+}
+
+void RenderWidgetHostImpl::AddFrameSwappedObserver(
+    FrameSwappedObserver* observer) {
+  frame_swapped_observer_list_.AddObserver(observer);
+}
+
+void RenderWidgetHostImpl::RemoveFrameSwappedObserver(
+    FrameSwappedObserver* observer) {
+  frame_swapped_observer_list_.RemoveObserver(observer);
+}
+
 }  // namespace content