Add latency info to input events sent to RenderWidget.

This keeps track of the latency info for input events, and sends that down into the RenderWidget and into the compositor. It also collects the latency info when swap happens with gtk and returns it the the RenderWidgetHostImpl.

BUG=155367

Review URL: https://chromiumcodereview.appspot.com/13931009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@199340 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 312 insertions, 181 deletions

diff --git a/content/browser/renderer_host/event_with_latency_info.h b/content/browser/renderer_host/event_with_latency_info.h
new file mode 100644
index 0000000..f7891ff
--- /dev/null
+++ b/content/browser/renderer_host/event_with_latency_info.h
@@ -0,0 +1,39 @@
+// Copyright (c) 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_EVENT_WITH_LATENCY_INFO_H_
+#define CONTENT_BROWSER_RENDERER_HOST_EVENT_WITH_LATENCY_INFO_H_
+
+#include <cc/debug/latency_info.h>
+
+namespace WebKit {
+class WebGestureEvent;
+class WebMouseEvent;
+class WebMouseWheelEvent;
+}
+
+namespace content {
+
+template <typename T>
+class EventWithLatencyInfo {
+ public:
+  T event;
+  cc::LatencyInfo latency;
+
+  EventWithLatencyInfo(const T& e, const cc::LatencyInfo& l)
+      : event(e), latency(l) {}
+
+  EventWithLatencyInfo() {}
+};
+
+typedef EventWithLatencyInfo<WebKit::WebGestureEvent>
+    GestureEventWithLatencyInfo;
+typedef EventWithLatencyInfo<WebKit::WebMouseWheelEvent>
+    MouseWheelEventWithLatencyInfo;
+typedef EventWithLatencyInfo<WebKit::WebMouseEvent>
+    MouseEventWithLatencyInfo;
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_EVENT_WITH_LATENCY_INFO_H_
diff --git a/content/browser/renderer_host/gesture_event_filter.cc b/content/browser/renderer_host/gesture_event_filter.cc
index 02ed0c3..c7de540 100644
--- a/content/browser/renderer_host/gesture_event_filter.cc
+++ b/content/browser/renderer_host/gesture_event_filter.cc
@@ -75,15 +75,15 @@ GestureEventFilter::GestureEventFilter(RenderWidgetHostImpl* rwhv)
 GestureEventFilter::~GestureEventFilter() { }
 
 bool GestureEventFilter::ShouldDiscardFlingCancelEvent(
-    const WebKit::WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (coalesced_gesture_events_.empty() && fling_in_progress_)
     return false;
   GestureEventQueue::reverse_iterator it =
       coalesced_gesture_events_.rbegin();
   while (it != coalesced_gesture_events_.rend()) {
-    if (it->type == WebInputEvent::GestureFlingStart)
+    if (it->event.type == WebInputEvent::GestureFlingStart)
       return false;
-    if (it->type == WebInputEvent::GestureFlingCancel)
+    if (it->event.type == WebInputEvent::GestureFlingCancel)
       return true;
     it++;
   }
@@ -91,10 +91,10 @@ bool GestureEventFilter::ShouldDiscardFlingCancelEvent(
 }
 
 bool GestureEventFilter::ShouldForwardForBounceReduction(
-    const WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (debounce_interval_time_ms_ ==  0)
     return true;
-  switch (gesture_event.type) {
+  switch (gesture_event.event.type) {
     case WebInputEvent::GestureScrollUpdate:
       if (!scrolling_in_progress_) {
         debounce_deferring_timer_.Start(
@@ -127,7 +127,8 @@ bool GestureEventFilter::ShouldForwardForBounceReduction(
 }
 
 // NOTE: The filters are applied successively. This simplifies the change.
-bool GestureEventFilter::ShouldForward(const WebGestureEvent& gesture_event) {
+bool GestureEventFilter::ShouldForward(
+    const GestureEventWithLatencyInfo& gesture_event) {
   return ShouldForwardForZeroVelocityFlingStart(gesture_event) &&
       ShouldForwardForBounceReduction(gesture_event) &&
       ShouldForwardForGFCFiltering(gesture_event) &&
@@ -137,24 +138,24 @@ bool GestureEventFilter::ShouldForward(const WebGestureEvent& gesture_event) {
 }
 
 bool GestureEventFilter::ShouldForwardForZeroVelocityFlingStart(
-    const WebGestureEvent& gesture_event) {
-  return gesture_event.type != WebInputEvent::GestureFlingStart ||
-      gesture_event.sourceDevice != WebGestureEvent::Touchpad ||
-      gesture_event.data.flingStart.velocityX != 0 ||
-      gesture_event.data.flingStart.velocityY != 0;
+    const GestureEventWithLatencyInfo& gesture_event) {
+  return gesture_event.event.type != WebInputEvent::GestureFlingStart ||
+      gesture_event.event.sourceDevice != WebGestureEvent::Touchpad ||
+      gesture_event.event.data.flingStart.velocityX != 0 ||
+      gesture_event.event.data.flingStart.velocityY != 0;
 }
 
 bool GestureEventFilter::ShouldForwardForGFCFiltering(
-    const WebGestureEvent& gesture_event) {
-  return gesture_event.type != WebInputEvent::GestureFlingCancel ||
+    const GestureEventWithLatencyInfo& gesture_event) {
+  return gesture_event.event.type != WebInputEvent::GestureFlingCancel ||
       !ShouldDiscardFlingCancelEvent(gesture_event);
 }
 
 bool GestureEventFilter::ShouldForwardForTapSuppression(
-    const WebGestureEvent& gesture_event) {
-  switch (gesture_event.type) {
+    const GestureEventWithLatencyInfo& gesture_event) {
+  switch (gesture_event.event.type) {
     case WebInputEvent::GestureFlingCancel:
-      if (gesture_event.sourceDevice == WebGestureEvent::Touchscreen)
+      if (gesture_event.event.sourceDevice == WebGestureEvent::Touchscreen)
         touchscreen_tap_suppression_controller_->GestureFlingCancel();
       else
         touchpad_tap_suppression_controller_->GestureFlingCancel();
@@ -176,12 +177,12 @@ bool GestureEventFilter::ShouldForwardForTapSuppression(
 }
 
 bool GestureEventFilter::ShouldForwardForTapDeferral(
-    const WebGestureEvent& gesture_event) {
-  switch (gesture_event.type) {
+    const GestureEventWithLatencyInfo& gesture_event) {
+  switch (gesture_event.event.type) {
     case WebInputEvent::GestureTapDown:
       // GestureTapDown is always paired with either a Tap, or TapCancel, so it
       // should be impossible to have more than one outstanding at a time.
-      DCHECK_EQ(deferred_tap_down_event_.type, WebInputEvent::Undefined);
+      DCHECK_EQ(deferred_tap_down_event_.event.type, WebInputEvent::Undefined);
       deferred_tap_down_event_ = gesture_event;
       send_gtd_timer_.Start(
           FROM_HERE,
@@ -190,27 +191,27 @@ bool GestureEventFilter::ShouldForwardForTapDeferral(
           &GestureEventFilter::SendGestureTapDownNow);
       return false;
     case WebInputEvent::GestureTapCancel:
-      if (deferred_tap_down_event_.type == WebInputEvent::Undefined) {
+      if (deferred_tap_down_event_.event.type == WebInputEvent::Undefined) {
         // The TapDown has already been put in the queue, must send the
         // corresponding TapCancel as well.
         return true;
       }
       // Cancelling a deferred TapDown, just drop them on the floor.
       send_gtd_timer_.Stop();
-      deferred_tap_down_event_.type = WebInputEvent::Undefined;
+      deferred_tap_down_event_.event.type = WebInputEvent::Undefined;
       return false;
     case WebInputEvent::GestureTap:
       send_gtd_timer_.Stop();
-      if (deferred_tap_down_event_.type != WebInputEvent::Undefined) {
+      if (deferred_tap_down_event_.event.type != WebInputEvent::Undefined) {
         ForwardGestureEventSkipDeferral(deferred_tap_down_event_);
-        deferred_tap_down_event_.type = WebInputEvent::Undefined;
+        deferred_tap_down_event_.event.type = WebInputEvent::Undefined;
       }
       return true;
     case WebInputEvent::GestureFlingStart:
     case WebInputEvent::GestureScrollBegin:
     case WebInputEvent::GesturePinchBegin:
       send_gtd_timer_.Stop();
-      deferred_tap_down_event_.type = WebInputEvent::Undefined;
+      deferred_tap_down_event_.event.type = WebInputEvent::Undefined;
       return true;
     default:
       return true;
@@ -221,8 +222,8 @@ bool GestureEventFilter::ShouldForwardForTapDeferral(
 }
 
 bool GestureEventFilter::ShouldForwardForCoalescing(
-    const WebGestureEvent& gesture_event) {
-  switch (gesture_event.type) {
+    const GestureEventWithLatencyInfo& gesture_event) {
+  switch (gesture_event.event.type) {
     case WebInputEvent::GestureFlingCancel:
       fling_in_progress_ = false;
       break;
@@ -246,7 +247,7 @@ void GestureEventFilter::Reset() {
   ignore_next_ack_ = false;
   combined_scroll_pinch_ = gfx::Transform();
   coalesced_gesture_events_.clear();
-  deferred_tap_down_event_.type = WebInputEvent::Undefined;
+  deferred_tap_down_event_.event.type = WebInputEvent::Undefined;
   debouncing_deferral_queue_.clear();
   send_gtd_timer_.Stop();
   debounce_deferring_timer_.Stop();
@@ -258,9 +259,9 @@ void GestureEventFilter::ProcessGestureAck(bool processed, int type) {
     DLOG(ERROR) << "Received unexpected ACK for event type " << type;
     return;
   }
-  DCHECK_EQ(coalesced_gesture_events_.front().type, type);
+  DCHECK_EQ(coalesced_gesture_events_.front().event.type, type);
   if (type == WebInputEvent::GestureFlingCancel) {
-    if (coalesced_gesture_events_.front().sourceDevice ==
+    if (coalesced_gesture_events_.front().event.sourceDevice ==
         WebGestureEvent::Touchscreen)
       touchscreen_tap_suppression_controller_->GestureFlingCancelAck(processed);
     else
@@ -270,16 +271,18 @@ void GestureEventFilter::ProcessGestureAck(bool processed, int type) {
   if (ignore_next_ack_) {
     ignore_next_ack_ = false;
   } else if (!coalesced_gesture_events_.empty()) {
-    const WebGestureEvent& next_gesture_event =
+    const GestureEventWithLatencyInfo& next_gesture_event =
         coalesced_gesture_events_.front();
     render_widget_host_->ForwardGestureEventImmediately(next_gesture_event);
     // TODO(yusufo): Introduce GesturePanScroll so that these can be combined
     // into one gesture and kept inside the queue that way.
     if (coalesced_gesture_events_.size() > 1) {
-      const WebGestureEvent& second_gesture_event =
+      const GestureEventWithLatencyInfo& second_gesture_event =
           coalesced_gesture_events_[1];
-      if (next_gesture_event.type == WebInputEvent::GestureScrollUpdate &&
-          second_gesture_event.type == WebInputEvent::GesturePinchUpdate) {
+      if (next_gesture_event.event.type ==
+              WebInputEvent::GestureScrollUpdate &&
+          second_gesture_event.event.type ==
+              WebInputEvent::GesturePinchUpdate) {
         render_widget_host_->
             ForwardGestureEventImmediately(second_gesture_event);
         ignore_next_ack_ = true;
@@ -302,9 +305,9 @@ const WebKit::WebInputEvent&
 GestureEventFilter::GetGestureEventAwaitingAck() const {
   DCHECK(!coalesced_gesture_events_.empty());
   if (!ignore_next_ack_)
-    return coalesced_gesture_events_.front();
+    return coalesced_gesture_events_.front().event;
   else
-    return coalesced_gesture_events_.at(1);
+    return coalesced_gesture_events_.at(1).event;
 }
 
 void GestureEventFilter::FlingHasBeenHalted() {
@@ -316,13 +319,13 @@ bool GestureEventFilter::ShouldHandleEventNow() {
 }
 
 void GestureEventFilter::ForwardGestureEventForDeferral(
-    const WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (ShouldForwardForTapDeferral(gesture_event))
     ForwardGestureEventSkipDeferral(gesture_event);
 }
 
 void GestureEventFilter::ForwardGestureEventSkipDeferral(
-    const WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (ShouldForwardForCoalescing(gesture_event))
       render_widget_host_->ForwardGestureEventImmediately(gesture_event);
 }
@@ -331,9 +334,9 @@ void GestureEventFilter::SendGestureTapDownNow() {
   // We must not have already sent the deferred TapDown (if we did, we would
   // have stopped the timer, which prevents this task from running - even if
   // it's time had already elapsed).
-  DCHECK_EQ(deferred_tap_down_event_.type, WebInputEvent::GestureTapDown);
+  DCHECK_EQ(deferred_tap_down_event_.event.type, WebInputEvent::GestureTapDown);
   ForwardGestureEventSkipDeferral(deferred_tap_down_event_);
-  deferred_tap_down_event_.type = WebInputEvent::Undefined;
+  deferred_tap_down_event_.event.type = WebInputEvent::Undefined;
 }
 
 void GestureEventFilter::SendScrollEndingEventsNow() {
@@ -352,19 +355,20 @@ void GestureEventFilter::SendScrollEndingEventsNow() {
 }
 
 void GestureEventFilter::MergeOrInsertScrollAndPinchEvent(
-    const WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   if (coalesced_gesture_events_.size() <= 1) {
     coalesced_gesture_events_.push_back(gesture_event);
     return;
   }
-  WebGestureEvent* last_event = &coalesced_gesture_events_.back();
-  if (gesture_event.type == WebInputEvent::GestureScrollUpdate &&
-      last_event->type == WebInputEvent::GestureScrollUpdate &&
-      last_event->modifiers == gesture_event.modifiers) {
-    last_event->data.scrollUpdate.deltaX +=
-        gesture_event.data.scrollUpdate.deltaX;
-    last_event->data.scrollUpdate.deltaY +=
-        gesture_event.data.scrollUpdate.deltaY;
+  GestureEventWithLatencyInfo* last_event = &coalesced_gesture_events_.back();
+  if (gesture_event.event.type == WebInputEvent::GestureScrollUpdate &&
+      last_event->event.type == WebInputEvent::GestureScrollUpdate &&
+      last_event->event.modifiers == gesture_event.event.modifiers) {
+    last_event->event.data.scrollUpdate.deltaX +=
+        gesture_event.event.data.scrollUpdate.deltaX;
+    last_event->event.data.scrollUpdate.deltaY +=
+        gesture_event.event.data.scrollUpdate.deltaY;
+    last_event->latency.MergeWith(gesture_event.latency);
     return;
   }
   if (coalesced_gesture_events_.size() == 2 ||
@@ -373,22 +377,28 @@ void GestureEventFilter::MergeOrInsertScrollAndPinchEvent(
     coalesced_gesture_events_.push_back(gesture_event);
     return;
   }
-  WebGestureEvent scroll_event;
-  WebGestureEvent pinch_event;
-  scroll_event.modifiers |= gesture_event.modifiers;
-  scroll_event.timeStampSeconds = gesture_event.timeStampSeconds;
+  GestureEventWithLatencyInfo scroll_event;
+  GestureEventWithLatencyInfo pinch_event;
+  scroll_event.event.modifiers |= gesture_event.event.modifiers;
+  scroll_event.event.timeStampSeconds = gesture_event.event.timeStampSeconds;
+  scroll_event.latency = gesture_event.latency;
+  scroll_event.latency.MergeWith(last_event->latency);
   pinch_event = scroll_event;
-  scroll_event.type = WebInputEvent::GestureScrollUpdate;
-  pinch_event.type = WebInputEvent::GesturePinchUpdate;
-  pinch_event.x = gesture_event.type == WebInputEvent::GesturePinchUpdate ?
-      gesture_event.x : last_event->x;
-  pinch_event.y = gesture_event.type == WebInputEvent::GesturePinchUpdate ?
-      gesture_event.y : last_event->y;
+  scroll_event.event.type = WebInputEvent::GestureScrollUpdate;
+  pinch_event.event.type = WebInputEvent::GesturePinchUpdate;
+  pinch_event.event.x = gesture_event.event.type ==
+      WebInputEvent::GesturePinchUpdate ?
+          gesture_event.event.x : last_event->event.x;
+  pinch_event.event.y = gesture_event.event.type ==
+      WebInputEvent::GesturePinchUpdate ?
+          gesture_event.event.y : last_event->event.y;
 
   combined_scroll_pinch_.ConcatTransform(GetTransformForEvent(gesture_event));
-  WebGestureEvent* second_last_event = &coalesced_gesture_events_
+  GestureEventWithLatencyInfo* second_last_event = &coalesced_gesture_events_
       [coalesced_gesture_events_.size() - 2];
   if (ShouldTryMerging(gesture_event, *second_last_event)) {
+    scroll_event.latency.MergeWith(second_last_event->latency);
+    pinch_event.latency.MergeWith(second_last_event->latency);
     coalesced_gesture_events_.pop_back();
   } else {
     DCHECK(combined_scroll_pinch_ == GetTransformForEvent(gesture_event));
@@ -397,39 +407,40 @@ void GestureEventFilter::MergeOrInsertScrollAndPinchEvent(
   }
   coalesced_gesture_events_.pop_back();
   float combined_scale = combined_scroll_pinch_.matrix().getDouble(0, 0);
-  scroll_event.data.scrollUpdate.deltaX =
-      (combined_scroll_pinch_.matrix().getDouble(0, 3) + pinch_event.x)
-          / combined_scale - pinch_event.x;
-  scroll_event.data.scrollUpdate.deltaY =
-      (combined_scroll_pinch_.matrix().getDouble(1, 3) + pinch_event.y)
-          / combined_scale - pinch_event.y;
+  scroll_event.event.data.scrollUpdate.deltaX =
+      (combined_scroll_pinch_.matrix().getDouble(0, 3) + pinch_event.event.x)
+          / combined_scale - pinch_event.event.x;
+  scroll_event.event.data.scrollUpdate.deltaY =
+      (combined_scroll_pinch_.matrix().getDouble(1, 3) + pinch_event.event.y)
+          / combined_scale - pinch_event.event.y;
   coalesced_gesture_events_.push_back(scroll_event);
-  pinch_event.data.pinchUpdate.scale = combined_scale;
+  pinch_event.event.data.pinchUpdate.scale = combined_scale;
   coalesced_gesture_events_.push_back(pinch_event);
 }
 
-bool GestureEventFilter::ShouldTryMerging(const WebGestureEvent& new_event,
-    const WebGestureEvent& event_in_queue) {
+bool GestureEventFilter::ShouldTryMerging(
+    const GestureEventWithLatencyInfo& new_event,
+    const GestureEventWithLatencyInfo& event_in_queue) {
   DLOG_IF(WARNING,
-          new_event.timeStampSeconds <
-          event_in_queue.timeStampSeconds)
+          new_event.event.timeStampSeconds <
+          event_in_queue.event.timeStampSeconds)
           << "Event time not monotonic?\n";
-  return (event_in_queue.type == WebInputEvent::GestureScrollUpdate ||
-      event_in_queue.type == WebInputEvent::GesturePinchUpdate) &&
-      event_in_queue.modifiers == new_event.modifiers;
+  return (event_in_queue.event.type == WebInputEvent::GestureScrollUpdate ||
+      event_in_queue.event.type == WebInputEvent::GesturePinchUpdate) &&
+      event_in_queue.event.modifiers == new_event.event.modifiers;
 }
 
 gfx::Transform GestureEventFilter::GetTransformForEvent(
-    const WebGestureEvent& gesture_event) {
+    const GestureEventWithLatencyInfo& gesture_event) {
   gfx::Transform gesture_transform = gfx::Transform();
-  if (gesture_event.type == WebInputEvent::GestureScrollUpdate) {
-    gesture_transform.Translate(gesture_event.data.scrollUpdate.deltaX,
-                                gesture_event.data.scrollUpdate.deltaY);
-  } else if (gesture_event.type == WebInputEvent::GesturePinchUpdate) {
-    float scale = gesture_event.data.pinchUpdate.scale;
-    gesture_transform.Translate(-gesture_event.x, -gesture_event.y);
+  if (gesture_event.event.type == WebInputEvent::GestureScrollUpdate) {
+    gesture_transform.Translate(gesture_event.event.data.scrollUpdate.deltaX,
+                                gesture_event.event.data.scrollUpdate.deltaY);
+  } else if (gesture_event.event.type == WebInputEvent::GesturePinchUpdate) {
+    float scale = gesture_event.event.data.pinchUpdate.scale;
+    gesture_transform.Translate(-gesture_event.event.x, -gesture_event.event.y);
     gesture_transform.Scale(scale,scale);
-    gesture_transform.Translate(gesture_event.x, gesture_event.y);
+    gesture_transform.Translate(gesture_event.event.x, gesture_event.event.y);
   }
   return gesture_transform;
 }
diff --git a/content/browser/renderer_host/gesture_event_filter.h b/content/browser/renderer_host/gesture_event_filter.h
index 390deee..636ab80 100644
--- a/content/browser/renderer_host/gesture_event_filter.h
+++ b/content/browser/renderer_host/gesture_event_filter.h
@@ -10,6 +10,7 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer.h"
+#include "content/browser/renderer_host/event_with_latency_info.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/gfx/transform.h"
 
@@ -46,8 +47,8 @@ class GestureEventFilter {
   ~GestureEventFilter();
 
   // Returns |true| if the caller should immediately forward the provided
-  // |WebGestureEvent| argument to the renderer.
-  bool ShouldForward(const WebKit::WebGestureEvent&);
+  // |GestureEventWithLatencyInfo| argument to the renderer.
+  bool ShouldForward(const GestureEventWithLatencyInfo&);
 
   // Indicates that the calling RenderWidgetHostImpl has received an
   // acknowledgement from the renderer with state |processed| and event |type|.
@@ -72,11 +73,11 @@ class GestureEventFilter {
 
   // Tries forwarding the event to the tap deferral sub-filter.
   void ForwardGestureEventForDeferral(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Tries forwarding the event, skipping the tap deferral sub-filter.
   void ForwardGestureEventSkipDeferral(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
  private:
   friend class MockRenderWidgetHost;
@@ -96,7 +97,7 @@ class GestureEventFilter {
   // Returns |true| if the given GestureFlingCancel should be discarded
   // as unnecessary.
   bool ShouldDiscardFlingCancelEvent(
-    const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Returns |true| if the only event in the queue is the current event and
   // hence that event should be handled now.
@@ -105,44 +106,45 @@ class GestureEventFilter {
   // Merge or append a GestureScrollUpdate or GesturePinchUpdate into
   // the coalescing queue.
   void MergeOrInsertScrollAndPinchEvent(
-       const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Sub-filter for removing zero-velocity fling-starts from touchpad.
   bool ShouldForwardForZeroVelocityFlingStart(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Sub-filter for removing bounces from in-progress scrolls.
   bool ShouldForwardForBounceReduction(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Sub-filter for removing unnecessary GestureFlingCancels.
   bool ShouldForwardForGFCFiltering(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Sub-filter for suppressing taps immediately after a GestureFlingCancel.
   bool ShouldForwardForTapSuppression(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Sub-filter for deferring GestureTapDowns.
   bool ShouldForwardForTapDeferral(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Puts the events in a queue to forward them one by one; i.e., forward them
   // whenever ACK for previous event is received. This queue also tries to
   // coalesce events as much as possible.
-  bool ShouldForwardForCoalescing(const WebKit::WebGestureEvent& gesture_event);
+  bool ShouldForwardForCoalescing(
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Whether the event_in_queue is GesturePinchUpdate or
   // GestureScrollUpdate and it has the same modifiers as the
   // new event.
-  bool ShouldTryMerging(const WebKit::WebGestureEvent& new_event,
-      const WebKit::WebGestureEvent& event_in_queue);
+  bool ShouldTryMerging(const GestureEventWithLatencyInfo& new_event,
+                        const GestureEventWithLatencyInfo& event_in_queue);
 
   // Returns the transform matrix corresponding to the gesture event.
   // Assumes the gesture event sent is either GestureScrollUpdate or
   // GesturePinchUpdate. Returns the identity matrix otherwise.
   gfx::Transform GetTransformForEvent(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   // Only a RenderWidgetHostViewImpl can own an instance.
   RenderWidgetHostImpl* render_widget_host_;
@@ -179,13 +181,13 @@ class GestureEventFilter {
   scoped_ptr<TouchscreenTapSuppressionController>
       touchscreen_tap_suppression_controller_;
 
-  typedef std::deque<WebKit::WebGestureEvent> GestureEventQueue;
+  typedef std::deque<GestureEventWithLatencyInfo> GestureEventQueue;
 
   // Queue of coalesced gesture events not yet sent to the renderer.
   GestureEventQueue coalesced_gesture_events_;
 
   // Tap gesture event currently subject to deferral.
-  WebKit::WebGestureEvent deferred_tap_down_event_;
+  GestureEventWithLatencyInfo deferred_tap_down_event_;
 
   // Timer to release a previously deferred GestureTapDown event.
   base::OneShotTimer<GestureEventFilter> debounce_deferring_timer_;
diff --git a/content/browser/renderer_host/overscroll_controller.cc b/content/browser/renderer_host/overscroll_controller.cc
index 0a4086a..14a82e6 100644
--- a/content/browser/renderer_host/overscroll_controller.cc
+++ b/content/browser/renderer_host/overscroll_controller.cc
@@ -25,7 +25,8 @@ OverscrollController::~OverscrollController() {
 }
 
 bool OverscrollController::WillDispatchEvent(
-    const WebKit::WebInputEvent& event) {
+    const WebKit::WebInputEvent& event,
+    const cc::LatencyInfo& latency_info) {
   if (DispatchEventCompletesAction(event)) {
     CompleteAction();
 
@@ -39,7 +40,7 @@ bool OverscrollController::WillDispatchEvent(
       const WebKit::WebGestureEvent& gevent =
           static_cast<const WebKit::WebGestureEvent&>(event);
       return render_widget_host_->gesture_event_filter()->
-          ShouldForward(gevent);
+          ShouldForward(GestureEventWithLatencyInfo(gevent, latency_info));
     }
 
     return false;
@@ -54,7 +55,8 @@ bool OverscrollController::WillDispatchEvent(
     if (ShouldForwardToGestureFilter(event)) {
       const WebKit::WebGestureEvent& gevent =
           static_cast<const WebKit::WebGestureEvent&>(event);
-      return render_widget_host_->gesture_event_filter()->ShouldForward(gevent);
+      return render_widget_host_->gesture_event_filter()->ShouldForward(
+          GestureEventWithLatencyInfo(gevent, latency_info));
     }
 
     // Let the event be dispatched to the renderer.
diff --git a/content/browser/renderer_host/overscroll_controller.h b/content/browser/renderer_host/overscroll_controller.h
index 9f26b91..6f82d0a 100644
--- a/content/browser/renderer_host/overscroll_controller.h
+++ b/content/browser/renderer_host/overscroll_controller.h
@@ -9,6 +9,10 @@
 #include "base/compiler_specific.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 
+namespace cc {
+struct LatencyInfo;
+}
+
 namespace content {
 
 class MockRenderWidgetHost;
@@ -39,7 +43,8 @@ class OverscrollController {
   // RenderWidgetHostView so that the state of the overscroll gesture can be
   // updated properly.
   // Returns true if the event should be dispatched, false otherwise.
-  bool WillDispatchEvent(const WebKit::WebInputEvent& event);
+  bool WillDispatchEvent(const WebKit::WebInputEvent& event,
+                         const cc::LatencyInfo& latency_info);
 
   // This must be called when the ACK for any event comes in. This updates the
   // overscroll gesture status as appropriate.
diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index e724523..1d72843 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,
       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();
@@ -941,22 +942,29 @@ void RenderWidgetHostImpl::SimulateTouchGestureWithMouse(
 }
 
 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;
@@ -969,7 +977,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;
 
@@ -982,33 +997,35 @@ 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().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;
   }
@@ -1018,7 +1035,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(
@@ -1027,26 +1045,30 @@ 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(
+          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;
   }
 
@@ -1054,26 +1076,28 @@ void RenderWidgetHostImpl::ForwardMouseEventImmediately(
   // 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(
@@ -1082,14 +1106,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) {
+    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(
@@ -1161,6 +1187,7 @@ void RenderWidgetHostImpl::ForwardKeyboardEvent(
 
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
+                      NewInputLatencyInfo(),
                       is_keyboard_shortcut);
   }
 }
@@ -1169,18 +1196,30 @@ 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())
@@ -1189,7 +1228,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;
@@ -1220,8 +1259,10 @@ 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].event,
+                     sizeof(WebMouseWheelEvent),
+                     coalesced_mouse_wheel_events_[i].latency,
+                     false);
     }
     coalesced_mouse_wheel_events_.clear();
   }
@@ -1247,7 +1288,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|
@@ -1851,8 +1892,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_);
+      DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
+      ForwardMouseEventWithLatencyInfo(*next_mouse_move_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
@@ -1910,10 +1951,11 @@ void RenderWidgetHostImpl::ProcessWheelAck(bool 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_)
@@ -2427,4 +2469,7 @@ void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
+void RenderWidgetHostImpl::FrameSwapped(const cc::LatencyInfo& latency_info) {
+}
+
 }  // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index 3eb8ae9..5c55655 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h
@@ -23,6 +23,8 @@
 #include "base/time.h"
 #include "base/timer.h"
 #include "build/build_config.h"
+#include "cc/debug/latency_info.h"
+#include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/browser/renderer_host/smooth_scroll_gesture_controller.h"
 #include "content/common/view_message_enums.h"
 #include "content/port/common/input_event_ack_state.h"
@@ -259,10 +261,11 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   virtual void ForwardTouchEvent(const WebKit::WebTouchEvent& touch_event);
 
   // Forwards the given event immediately to the renderer.
-  void ForwardMouseEventImmediately(const WebKit::WebMouseEvent& mouse_event);
+  void ForwardMouseEventImmediately(
+      const MouseEventWithLatencyInfo& mouse_event);
   void ForwardTouchEventImmediately(const WebKit::WebTouchEvent& touch_event);
   void ForwardGestureEventImmediately(
-      const WebKit::WebGestureEvent& gesture_event);
+      const GestureEventWithLatencyInfo& gesture_event);
 
   void CancelUpdateTextDirection();
 
@@ -473,17 +476,35 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // other way around.
   bool should_auto_resize() { return should_auto_resize_; }
 
+  void FrameSwapped(const cc::LatencyInfo& latency_info);
+
+  // Returns the ID that uniquely describes this component to the latency
+  // subsystem.
+  int64 GetLatencyComponentId();
+
  protected:
   virtual RenderWidgetHostImpl* AsRenderWidgetHostImpl() OVERRIDE;
 
   // Transmits the given input event. This is an internal helper for
   // |ForwardInputEvent()| and should not be used directly from elsewhere.
   void SendInputEvent(const WebKit::WebInputEvent& input_event,
-                      int event_size, bool is_keyboard_shortcut);
+                      int event_size, const cc::LatencyInfo& latency_info,
+                      bool is_keyboard_shortcut);
 
   // Internal implementation of the public Forward*Event() methods.
   void ForwardInputEvent(const WebKit::WebInputEvent& input_event,
-                         int event_size, bool is_keyboard_shortcut);
+                         int event_size, const cc::LatencyInfo& latency_info,
+                         bool is_keyboard_shortcut);
+
+  // Internal forwarding implementations that take a LatencyInfo.
+  virtual void ForwardMouseEventWithLatencyInfo(
+      const MouseEventWithLatencyInfo& mouse_event);
+  virtual void ForwardWheelEventWithLatencyInfo(
+      const WebKit::WebMouseWheelEvent& wheel_event,
+      const cc::LatencyInfo& latency_info);
+
+  // Create a LatencyInfo struct for a new input event that was just received.
+  cc::LatencyInfo NewInputLatencyInfo();
 
   // Called when we receive a notification indicating that the renderer
   // process has gone. This will reset our state so that our state will be
@@ -749,14 +770,14 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
 
   // The next mouse move event to send (only non-null while mouse_move_pending_
   // is true).
-  scoped_ptr<WebKit::WebMouseEvent> next_mouse_move_;
+  scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move_;
 
   // (Similar to |mouse_move_pending_|.) True if a mouse wheel event was sent
   // and we are waiting for a corresponding ack.
   bool mouse_wheel_pending_;
   WebKit::WebMouseWheelEvent current_wheel_event_;
 
-  typedef std::deque<WebKit::WebMouseWheelEvent> WheelEventQueue;
+  typedef std::deque<MouseWheelEventWithLatencyInfo> WheelEventQueue;
 
   // (Similar to |next_mouse_move_|.) The next mouse wheel events to send.
   // Unlike mouse moves, mouse wheel events received while one is pending are
@@ -883,6 +904,8 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // List of callbacks for pending snapshot requests to the renderer.
   std::queue<base::Callback<void(bool, const SkBitmap&)> > pending_snapshots_;
 
+  int64 last_input_number_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 84945b9..f4a9579 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -140,11 +140,11 @@ class MockRenderWidgetHost : public RenderWidgetHostImpl {
 
   WebGestureEvent GestureEventSecondFromLastQueueEvent() {
     return gesture_event_filter_->coalesced_gesture_events_.at(
-      GestureEventLastQueueEventSize() - 2);
+      GestureEventLastQueueEventSize() - 2).event;
   }
 
   WebGestureEvent GestureEventLastQueueEvent() {
-    return gesture_event_filter_->coalesced_gesture_events_.back();
+    return gesture_event_filter_->coalesced_gesture_events_.back().event;
   }
 
   unsigned GestureEventDebouncingQueueSize() {
@@ -152,7 +152,7 @@ class MockRenderWidgetHost : public RenderWidgetHostImpl {
   }
 
   WebGestureEvent GestureEventQueueEventAt(int i) {
-    return gesture_event_filter_->coalesced_gesture_events_.at(i);
+    return gesture_event_filter_->coalesced_gesture_events_.at(i).event;
   }
 
   bool shouldDeferTapDownEvents() {
diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.cc b/content/browser/renderer_host/render_widget_host_view_gtk.cc
index ece0421..9a7ec32 100644
--- a/content/browser/renderer_host/render_widget_host_view_gtk.cc
+++ b/content/browser/renderer_host/render_widget_host_view_gtk.cc
@@ -1070,19 +1070,21 @@ bool RenderWidgetHostViewGtk::CanCopyToVideoFrame() const {
 void RenderWidgetHostViewGtk::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
-   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-   ack_params.sync_point = 0;
-   RenderWidgetHostImpl::AcknowledgeBufferPresent(
+  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+  ack_params.sync_point = 0;
+  RenderWidgetHostImpl::AcknowledgeBufferPresent(
       params.route_id, gpu_host_id, ack_params);
+  host_->FrameSwapped(params.latency_info);
 }
 
 void RenderWidgetHostViewGtk::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
-   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-   ack_params.sync_point = 0;
-   RenderWidgetHostImpl::AcknowledgeBufferPresent(
+  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+  ack_params.sync_point = 0;
+  RenderWidgetHostImpl::AcknowledgeBufferPresent(
       params.route_id, gpu_host_id, ack_params);
+  host_->FrameSwapped(params.latency_info);
 }
 
 void RenderWidgetHostViewGtk::AcceleratedSurfaceSuspend() {
diff --git a/content/browser/renderer_host/touchpad_tap_suppression_controller.cc b/content/browser/renderer_host/touchpad_tap_suppression_controller.cc
index 9154908..4f43696 100644
--- a/content/browser/renderer_host/touchpad_tap_suppression_controller.cc
+++ b/content/browser/renderer_host/touchpad_tap_suppression_controller.cc
@@ -27,7 +27,7 @@ void TouchpadTapSuppressionController::GestureFlingCancelAck(
 }
 
 bool TouchpadTapSuppressionController::ShouldDeferMouseDown(
-    const WebKit::WebMouseEvent& /*event*/) {
+    const MouseEventWithLatencyInfo& /*event*/) {
   return false;
 }
 
diff --git a/content/browser/renderer_host/touchpad_tap_suppression_controller.h b/content/browser/renderer_host/touchpad_tap_suppression_controller.h
index 874bc8f..76e1fc1 100644
--- a/content/browser/renderer_host/touchpad_tap_suppression_controller.h
+++ b/content/browser/renderer_host/touchpad_tap_suppression_controller.h
@@ -6,6 +6,8 @@
 #define CONTENT_BROWSER_RENDERER_HOST_TOUCHPAD_TAP_SUPPRESSION_CONTROLLER_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "cc/debug/latency_info.h"
+#include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/browser/renderer_host/tap_suppression_controller_client.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 
@@ -31,7 +33,7 @@ class TouchpadTapSuppressionController : public TapSuppressionControllerClient {
   // Should be called on arrival of MouseDown events. Returns true if the caller
   // should stop normal handling of the MouseDown. In this case, the caller is
   // responsible for saving the event for later use, if needed.
-  bool ShouldDeferMouseDown(const WebKit::WebMouseEvent& event);
+  bool ShouldDeferMouseDown(const MouseEventWithLatencyInfo& event);
 
   // Should be called on arrival of MouseUp events. Returns true if the caller
   // should stop normal handling of the MouseUp.
@@ -48,7 +50,7 @@ class TouchpadTapSuppressionController : public TapSuppressionControllerClient {
   virtual void ForwardStashedTapDownSkipDeferral() OVERRIDE;
 
   RenderWidgetHostImpl* render_widget_host_;
-  WebKit::WebMouseEvent stashed_mouse_down_;
+  MouseEventWithLatencyInfo stashed_mouse_down_;
 
   // The core controller of tap suppression.
   scoped_ptr<TapSuppressionController> controller_;
diff --git a/content/browser/renderer_host/touchpad_tap_suppression_controller_aura.cc b/content/browser/renderer_host/touchpad_tap_suppression_controller_aura.cc
index 13fadab..a9ef442 100644
--- a/content/browser/renderer_host/touchpad_tap_suppression_controller_aura.cc
+++ b/content/browser/renderer_host/touchpad_tap_suppression_controller_aura.cc
@@ -28,7 +28,7 @@ void TouchpadTapSuppressionController::GestureFlingCancelAck(bool processed) {
 }
 
 bool TouchpadTapSuppressionController::ShouldDeferMouseDown(
-    const WebKit::WebMouseEvent& event) {
+    const MouseEventWithLatencyInfo& event) {
   bool should_defer = controller_->ShouldDeferTapDown();
   if (should_defer)
     stashed_mouse_down_ = event;
diff --git a/content/browser/renderer_host/touchscreen_tap_suppression_controller.cc b/content/browser/renderer_host/touchscreen_tap_suppression_controller.cc
index 8de9e40..001ef11 100644
--- a/content/browser/renderer_host/touchscreen_tap_suppression_controller.cc
+++ b/content/browser/renderer_host/touchscreen_tap_suppression_controller.cc
@@ -28,7 +28,7 @@ void TouchscreenTapSuppressionController::GestureFlingCancelAck(
 }
 
 bool TouchscreenTapSuppressionController::ShouldDeferGestureTapDown(
-    const WebKit::WebGestureEvent& event) {
+    const GestureEventWithLatencyInfo& event) {
   bool should_defer = controller_->ShouldDeferTapDown();
   if (should_defer)
     stashed_tap_down_ = event;
diff --git a/content/browser/renderer_host/touchscreen_tap_suppression_controller.h b/content/browser/renderer_host/touchscreen_tap_suppression_controller.h
index 4a6f730..bc5f275 100644
--- a/content/browser/renderer_host/touchscreen_tap_suppression_controller.h
+++ b/content/browser/renderer_host/touchscreen_tap_suppression_controller.h
@@ -6,8 +6,8 @@
 #define CONTENT_BROWSER_RENDERER_HOST_TOUCHSCREEN_TAP_SUPPRESSION_CONTROLLER_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/tap_suppression_controller_client.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 
 namespace content {
 
@@ -32,7 +32,7 @@ class TouchscreenTapSuppressionController
   // Should be called on arrival of GestureTapDown events. Returns true if the
   // caller should stop normal handling of the GestureTapDown. In this case, the
   // caller is responsible for saving the event for later use, if needed.
-  bool ShouldDeferGestureTapDown(const WebKit::WebGestureEvent& event);
+  bool ShouldDeferGestureTapDown(const GestureEventWithLatencyInfo& event);
 
   // Should be called on arrival of GestureTap events. Returns true if the
   // caller should stop normal handling of the GestureTap.
@@ -51,7 +51,7 @@ class TouchscreenTapSuppressionController
   virtual void ForwardStashedTapDownSkipDeferral() OVERRIDE;
 
   GestureEventFilter* gesture_event_filter_;
-  WebKit::WebGestureEvent stashed_tap_down_;
+  GestureEventWithLatencyInfo stashed_tap_down_;
 
   // The core controller of tap suppression.
   scoped_ptr<TapSuppressionController> controller_;
diff --git a/content/browser/renderer_host/touchscreen_tap_suppression_controller_stub.cc b/content/browser/renderer_host/touchscreen_tap_suppression_controller_stub.cc
index f2d2770..86c0d68 100644
--- a/content/browser/renderer_host/touchscreen_tap_suppression_controller_stub.cc
+++ b/content/browser/renderer_host/touchscreen_tap_suppression_controller_stub.cc
@@ -26,7 +26,7 @@ void TouchscreenTapSuppressionController::GestureFlingCancelAck(
 }
 
 bool TouchscreenTapSuppressionController::ShouldDeferGestureTapDown(
-    const WebKit::WebGestureEvent& /*event*/) {
+    const GestureEventWithLatencyInfo& /*event*/) {
   return false;
 }