Add latency info to input events sent to RenderWidget.

content/browser/renderer_host/render_widget_host_impl.cc

 // 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.
 
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 149 matching lines @@
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       weak_factory_(this),
       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();
     surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
   } else {
     // TODO(piman): This is a O(N) lookup, where we could forward the
     // information from the RenderWidgetHelper. The problem is that doing so
     // currently leaks outside of content all the way to chrome classes, and
@@ skipping 731 matching lines @@
             WebInputEvent::GesturePinchEnd, mouse_event.timeStampSeconds,
             x, y, 0));
       }
       break;
     case WebMouseEvent::ButtonNone:
       break;
   }
 }
 
 void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
-  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::ForwardMouseEvent",
-               "x", mouse_event.x, "y", mouse_event.y);
+  ForwardMouseEventWithLatencyInfo(
+      MouseEventWithLatencyInfo(mouse_event, NewInputLatencyInfo()));
+}
+
+void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
+    const MouseEventWithLatencyInfo& mouse_event) {
+  TRACE_EVENT2("renderer_host",
+               "RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo",
+               "x", mouse_event.event.x, "y", mouse_event.event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
-    SimulateTouchGestureWithMouse(mouse_event);
+    SimulateTouchGestureWithMouse(mouse_event.event);
     return;
   }
 
-  if (mouse_event.type == WebInputEvent::MouseDown &&
+  if (mouse_event.event.type == WebInputEvent::MouseDown &&
       gesture_event_filter_->GetTouchpadTapSuppressionController()->
           ShouldDeferMouseDown(mouse_event))
       return;
-  if (mouse_event.type == WebInputEvent::MouseUp &&
+  if (mouse_event.event.type == WebInputEvent::MouseUp &&
       gesture_event_filter_->GetTouchpadTapSuppressionController()->
           ShouldSuppressMouseUp())
       return;
 
   ForwardMouseEventImmediately(mouse_event);
 }
 
 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;
 
   if (delegate_->PreHandleWheelEvent(wheel_event))
     return;
 
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // 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().event, wheel_event)) {
+      coalesced_mouse_wheel_events_.push_back(
+          MouseWheelEventWithLatencyInfo(wheel_event, latency_info));
     } else {
-      WebMouseWheelEvent* last_wheel_event =
+      MouseWheelEventWithLatencyInfo* last_wheel_event =
           &coalesced_mouse_wheel_events_.back();
       float unaccelerated_x =
-          GetUnacceleratedDelta(last_wheel_event->deltaX,
-                                last_wheel_event->accelerationRatioX) +
+          GetUnacceleratedDelta(last_wheel_event->event.deltaX,
+                                last_wheel_event->event.accelerationRatioX) +
           GetUnacceleratedDelta(wheel_event.deltaX,
                                 wheel_event.accelerationRatioX);
       float unaccelerated_y =
-          GetUnacceleratedDelta(last_wheel_event->deltaY,
-                                last_wheel_event->accelerationRatioY) +
+          GetUnacceleratedDelta(last_wheel_event->event.deltaY,
+                                last_wheel_event->event.accelerationRatioY) +
           GetUnacceleratedDelta(wheel_event.deltaY,
                                 wheel_event.accelerationRatioY);
-      last_wheel_event->deltaX += wheel_event.deltaX;
-      last_wheel_event->deltaY += wheel_event.deltaY;
-      last_wheel_event->wheelTicksX += wheel_event.wheelTicksX;
-      last_wheel_event->wheelTicksY += wheel_event.wheelTicksY;
-      last_wheel_event->accelerationRatioX =
-          GetAccelerationRatio(last_wheel_event->deltaX, unaccelerated_x);
-      last_wheel_event->accelerationRatioY =
-          GetAccelerationRatio(last_wheel_event->deltaY, unaccelerated_y);
+      last_wheel_event->event.deltaX += wheel_event.deltaX;
+      last_wheel_event->event.deltaY += wheel_event.deltaY;
+      last_wheel_event->event.wheelTicksX += wheel_event.wheelTicksX;
+      last_wheel_event->event.wheelTicksY += wheel_event.wheelTicksY;
+      last_wheel_event->event.accelerationRatioX =
+          GetAccelerationRatio(last_wheel_event->event.deltaX, unaccelerated_x);
+      last_wheel_event->event.accelerationRatioY =
+          GetAccelerationRatio(last_wheel_event->event.deltaY, unaccelerated_y);
       DCHECK_GE(wheel_event.timeStampSeconds,
-                last_wheel_event->timeStampSeconds);
-      last_wheel_event->timeStampSeconds = wheel_event.timeStampSeconds;
+                last_wheel_event->event.timeStampSeconds);
+      last_wheel_event->event.timeStampSeconds = wheel_event.timeStampSeconds;
+      last_wheel_event->latency.MergeWith(latency_info);
     }
     return;
   }
   mouse_wheel_pending_ = true;
   current_wheel_event_ = wheel_event;
 
   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(
     const WebKit::WebGestureEvent& gesture_event) {
   TRACE_EVENT0("renderer_host", "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(
+          GestureEventWithLatencyInfo(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 MouseEventWithLatencyInfo& mouse_event) {
   TRACE_EVENT2("renderer_host",
                "RenderWidgetHostImpl::ForwardMouseEventImmediately",
-               "x", mouse_event.x, "y", mouse_event.y);
+               "x", mouse_event.event.x, "y", mouse_event.event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
-    SimulateTouchGestureWithMouse(mouse_event);
+    SimulateTouchGestureWithMouse(mouse_event.event);
     return;
   }
 
   // Avoid spamming the renderer with mouse move events.  It is important
   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
   // more WM_MOUSEMOVE events than we wish to send to the renderer.
-  if (mouse_event.type == WebInputEvent::MouseMove) {
+  if (mouse_event.event.type == WebInputEvent::MouseMove) {
     if (mouse_move_pending_) {
       if (!next_mouse_move_) {
-        next_mouse_move_.reset(new WebMouseEvent(mouse_event));
+        next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
       } else {
         // Accumulate movement deltas.
-        int x = next_mouse_move_->movementX;
-        int y = next_mouse_move_->movementY;
-        *next_mouse_move_ = mouse_event;
-        next_mouse_move_->movementX += x;
-        next_mouse_move_->movementY += y;
+        int x = next_mouse_move_->event.movementX;
+        int y = next_mouse_move_->event.movementY;
+        next_mouse_move_->event = mouse_event.event;
+        next_mouse_move_->event.movementX += x;
+        next_mouse_move_->event.movementY += y;
+        next_mouse_move_->latency.MergeWith(mouse_event.latency);
       }
       return;
     }
     mouse_move_pending_ = true;
-  } else if (mouse_event.type == WebInputEvent::MouseDown) {
+  } else if (mouse_event.event.type == WebInputEvent::MouseDown) {
     OnUserGesture();
   }
 
-  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
+  ForwardInputEvent(mouse_event.event, sizeof(WebMouseEvent),
+                    mouse_event.latency, false);
 }
 
 void RenderWidgetHostImpl::ForwardTouchEventImmediately(
     const WebKit::WebTouchEvent& touch_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardTouchEvent");
   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) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
-  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
+  ForwardInputEvent(gesture_event.event, sizeof(WebGestureEvent),
+                    gesture_event.latency, false);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   // First, let keypress listeners take a shot at handling the event.  If a
   // listener handles the event, it should not be propagated to the renderer.
@@ skipping 51 matching lines @@
     // Put all WebKeyboardEvent objects in a queue since we can't trust the
     // renderer and we need to give something to the HandleKeyboardEvent
     // handler.
     key_queue_.push_back(key_event);
     HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
     gesture_event_filter_->FlingHasBeenHalted();
 
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
+                      NewInputLatencyInfo(),
                       is_keyboard_shortcut);
   }
 }
 
 void RenderWidgetHostImpl::SendCursorVisibilityState(bool is_visible) {
   Send(new InputMsg_CursorVisibilityChange(GetRoutingID(), is_visible));
 }
 
+int64 RenderWidgetHostImpl::GetLatencyComponentId() {
+  return GetRoutingID() | (static_cast<int64>(GetProcess()->GetID()) << 32);
+}
+
+cc::LatencyInfo RenderWidgetHostImpl::NewInputLatencyInfo() {
+  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 InputMsg_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())
     return;
 
   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;
     } else if (WebInputEvent::isGestureEventType(input_event.type) &&
                gesture_event_filter_->HasQueuedGestureEvents()) {
       // If the gesture-event filter has queued gesture events, that implies it
       // is awaiting an ack for the event. Since the event is being consumed by
       // the over scroll here, it is never sent to the renderer, and so it won't
       // receive any ACKs. So send the ACK to the gesture event filter
       // immediately, and mark it as having been processed.
@@ skipping 10 matching lines @@
     return;
   }
 
   in_process_event_types_.push(input_event.type);
 
   // Transmit any pending wheel events on a non-wheel event. This ensures that
   // the renderer receives the final PhaseEnded wheel event, which is necessary
   // 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].event,
+                     sizeof(WebMouseWheelEvent),
+                     coalesced_mouse_wheel_events_[i].latency,
+                     false);
     }
     coalesced_mouse_wheel_events_.clear();
   }
 
   if (view_) {
     // Perform optional, synchronous event handling, sending ACK messages for
     // processed events, or proceeding as usual.
     InputEventAckState filter_ack = view_->FilterInputEvent(input_event);
     switch (filter_ack) {
       // Send the ACK and early exit.
       case INPUT_EVENT_ACK_STATE_CONSUMED:
       case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
         next_mouse_move_.reset();
         OnInputEventAck(input_event.type, filter_ack);
         // WARNING: |this| may be deleted at this point.
         return;
 
       // Proceed as normal.
       case INPUT_EVENT_ACK_STATE_UNKNOWN:
       case INPUT_EVENT_ACK_STATE_NOT_CONSUMED:
       default:
         break;
     };
   }
 
-  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|
   // after this line.
   next_mouse_move_.reset();
 
   StartHangMonitorTimeout(
       TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
@@ skipping 583 matching lines @@
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_) {
-      DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
-      ForwardMouseEvent(*next_mouse_move_);
+      DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
+      ForwardMouseEventWithLatencyInfo(*next_mouse_move_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
   } else if (type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(processed);
   } else if (WebInputEvent::isTouchEventType(type)) {
     ProcessTouchAck(ack_result);
   } else if (WebInputEvent::isGestureEventType(type)) {
     ProcessGestureAck(processed, type);
   }
@@ skipping 37 matching lines @@
 }
 
 void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
   if (overscroll_controller_)
     overscroll_controller_->ReceivedEventACK(current_wheel_event_, processed);
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
-    WebMouseWheelEvent next_wheel_event =
+    MouseWheelEventWithLatencyInfo next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
-    ForwardWheelEvent(next_wheel_event);
+    ForwardWheelEventWithLatencyInfo(next_wheel_event.event,
+                                     next_wheel_event.latency);
   }
 
   if (!processed && !is_hidden_ && view_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 void RenderWidgetHostImpl::ProcessGestureAck(bool processed, int type) {
   if (overscroll_controller_) {
     overscroll_controller_->ReceivedEventACK(
         gesture_event_filter_->GetGestureEventAwaitingAck(), processed);
@@ skipping 493 matching lines @@
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
+void RenderWidgetHostImpl::FrameSwapped(const cc::LatencyInfo& latency_info) {
+}
+
 }  // namespace content