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 153 matching lines @@
       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),
       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();
     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 729 matching lines @@
         ForwardGestureEvent(MakeGestureEvent(
             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",
+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;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
     SimulateTouchGestureWithMouse(mouse_event);
     return;
   }
 
   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() {
 }
 
 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().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) +
           GetUnacceleratedDelta(wheel_event.deltaX,
                                 wheel_event.accelerationRatioX);
       float unaccelerated_y =
           GetUnacceleratedDelta(last_wheel_event->deltaY,
                                 last_wheel_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);
       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;
   }
   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(
+          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);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
     SimulateTouchGestureWithMouse(mouse_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_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;
         int y = next_mouse_move_->movementY;
         *next_mouse_move_ = mouse_event;
         next_mouse_move_->movementX += x;
         next_mouse_move_->movementY += y;
+        next_mouse_move_latency_info_.MergeWith(latency_info);
       }
       return;
     }
     mouse_move_pending_ = true;
   } else if (mouse_event.type == WebInputEvent::MouseDown) {
     OnUserGesture();
   }
 
-  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
+  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), latency_info, 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) {
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
-  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
+  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent),
+                    NewInputLatencyInfo(), 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);
   }
 }
 
+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())
     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].first,
+                     sizeof(WebMouseWheelEvent),
+                     coalesced_mouse_wheel_events_[i].second, 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_);
+      ForwardMouseEventWithLatencyInfo(*next_mouse_move_,
+                                       next_mouse_move_latency_info_);
     }
   } 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 117 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 =
+    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_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 void RenderWidgetHostImpl::ProcessGestureAck(bool processed, int type) {
   if (overscroll_controller_) {
     overscroll_controller_->ReceivedEventACK(
         gesture_event_filter_->GetGestureEventAwaitingAck(), processed);
@@ skipping 483 matching lines @@
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 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