Move OverscrollController to RenderWidgetHostViewAura

content/browser/renderer_host/render_widget_host_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
-#include "content/browser/renderer_host/input/gesture_event_queue.h"
 #include "content/browser/renderer_host/input/input_router_impl.h"
-#include "content/browser/renderer_host/input/touch_event_queue.h"
-#include "content/browser/renderer_host/overscroll_controller.h"
-#include "content/browser/renderer_host/overscroll_controller_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 19 matching lines @@
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 
-// TestOverscrollDelegate ------------------------------------------------------
-
-class TestOverscrollDelegate : public OverscrollControllerDelegate {
- public:
-  explicit TestOverscrollDelegate(RenderWidgetHostView* view)
-      : view_(view),
-        current_mode_(OVERSCROLL_NONE),
-        completed_mode_(OVERSCROLL_NONE),
-        delta_x_(0.f),
-        delta_y_(0.f) {
-  }
-
-  virtual ~TestOverscrollDelegate() {}
-
-  OverscrollMode current_mode() const { return current_mode_; }
-  OverscrollMode completed_mode() const { return completed_mode_; }
-  float delta_x() const { return delta_x_; }
-  float delta_y() const { return delta_y_; }
-
-  void Reset() {
-    current_mode_ = OVERSCROLL_NONE;
-    completed_mode_ = OVERSCROLL_NONE;
-    delta_x_ = delta_y_ = 0.f;
-  }
-
- private:
-  // Overridden from OverscrollControllerDelegate:
-  virtual gfx::Rect GetVisibleBounds() const OVERRIDE {
-    return view_->IsShowing() ? view_->GetViewBounds() : gfx::Rect();
-  }
-
-  virtual void OnOverscrollUpdate(float delta_x, float delta_y) OVERRIDE {
-    delta_x_ = delta_x;
-    delta_y_ = delta_y;
-  }
-
-  virtual void OnOverscrollComplete(OverscrollMode overscroll_mode) OVERRIDE {
-    EXPECT_EQ(current_mode_, overscroll_mode);
-    completed_mode_ = overscroll_mode;
-    current_mode_ = OVERSCROLL_NONE;
-  }
-
-  virtual void OnOverscrollModeChange(OverscrollMode old_mode,
-                                      OverscrollMode new_mode) OVERRIDE {
-    EXPECT_EQ(current_mode_, old_mode);
-    current_mode_ = new_mode;
-    delta_x_ = delta_y_ = 0.f;
-  }
-
-  RenderWidgetHostView* view_;
-  OverscrollMode current_mode_;
-  OverscrollMode completed_mode_;
-  float delta_x_;
-  float delta_y_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestOverscrollDelegate);
-};
-
 // MockInputRouter -------------------------------------------------------------
 
 class MockInputRouter : public InputRouter {
  public:
   explicit MockInputRouter(InputRouterClient* client)
       : send_event_called_(false),
         sent_mouse_event_(false),
         sent_wheel_event_(false),
         sent_keyboard_event_(false),
         sent_gesture_event_(false),
@@ skipping 77 matching lines @@
   }
 
   // Allow poking at a few private members.
   using RenderWidgetHostImpl::OnUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::last_requested_size_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
   using RenderWidgetHostImpl::input_router_;
 
-  bool unresponsive_timer_fired() const {
-    return unresponsive_timer_fired_;
-  }
-
-  void set_hung_renderer_delay_ms(int delay_ms) {
-    hung_renderer_delay_ms_ = delay_ms;
-  }
-
-  unsigned GestureEventLastQueueEventSize() const {
-    return gesture_event_queue().coalesced_gesture_events_.size();
-  }
-
-  WebGestureEvent GestureEventSecondFromLastQueueEvent() const {
-    return gesture_event_queue().coalesced_gesture_events_.at(
-      GestureEventLastQueueEventSize() - 2).event;
-  }
-
-  WebGestureEvent GestureEventLastQueueEvent() const {
-    return gesture_event_queue().coalesced_gesture_events_.back().event;
-  }
-
-  unsigned GestureEventDebouncingQueueSize() const {
-    return gesture_event_queue().debouncing_deferral_queue_.size();
-  }
-
-  WebGestureEvent GestureEventQueueEventAt(int i) const {
-    return gesture_event_queue().coalesced_gesture_events_.at(i).event;
-  }
-
-  bool ScrollingInProgress() const {
-    return gesture_event_queue().scrolling_in_progress_;
-  }
-
-  void SetupForOverscrollControllerTest() {
-    SetOverscrollControllerEnabled(true);
-    overscroll_delegate_.reset(new TestOverscrollDelegate(GetView()));
-    overscroll_controller_->set_delegate(overscroll_delegate_.get());
-  }
-
-  void DisableGestureDebounce() { set_debounce_interval_time_ms(0); }
-
-  void set_debounce_interval_time_ms(int delay_ms) {
-    gesture_event_queue().set_debounce_interval_time_ms_for_testing(delay_ms);
-  }
-
-  bool TouchEventQueueEmpty() const {
-    return touch_event_queue().empty();
-  }
-
   virtual void OnTouchEventAck(
       const TouchEventWithLatencyInfo& event,
       InputEventAckState ack_result) OVERRIDE {
     // Sniff touch acks.
     acked_touch_event_type_ = event.event.type;
     RenderWidgetHostImpl::OnTouchEventAck(event, ack_result);
   }
 
+  bool unresponsive_timer_fired() const {
+    return unresponsive_timer_fired_;
+  }
+
+  void set_hung_renderer_delay_ms(int delay_ms) {
+    hung_renderer_delay_ms_ = delay_ms;
+  }
+
+  void DisableGestureDebounce() {
+    input_router_.reset(new InputRouterImpl(
+        process_, this, this, routing_id_, InputRouterImpl::Config()));
+  }
+
   WebInputEvent::Type acked_touch_event_type() const {
     return acked_touch_event_type_;
   }
 
-  bool ScrollStateIsContentScrolling() const {
-    return scroll_state() == OverscrollController::STATE_CONTENT_SCROLLING;
-  }
-
-  bool ScrollStateIsOverscrolling() const {
-    return scroll_state() == OverscrollController::STATE_OVERSCROLLING;
-  }
-
-  bool ScrollStateIsUnknown() const {
-    return scroll_state() == OverscrollController::STATE_UNKNOWN;
-  }
-
-  OverscrollController::ScrollState scroll_state() const {
-    return overscroll_controller_->scroll_state_;
-  }
-
-  OverscrollMode overscroll_mode() const {
-    return overscroll_controller_->overscroll_mode_;
-  }
-
-  float overscroll_delta_x() const {
-    return overscroll_controller_->overscroll_delta_x_;
-  }
-
-  float overscroll_delta_y() const {
-    return overscroll_controller_->overscroll_delta_y_;
-  }
-
-  TestOverscrollDelegate* overscroll_delegate() {
-    return overscroll_delegate_.get();
-  }
-
   void SetupForInputRouterTest() {
     input_router_.reset(new MockInputRouter(this));
   }
 
   MockInputRouter* mock_input_router() {
     return static_cast<MockInputRouter*>(input_router_.get());
   }
 
  protected:
   virtual void NotifyRendererUnresponsive() OVERRIDE {
     unresponsive_timer_fired_ = true;
   }
 
-  const TouchEventQueue& touch_event_queue() const {
-    return input_router_impl()->touch_event_queue_;
-  }
-
-  const GestureEventQueue& gesture_event_queue() const {
-    return input_router_impl()->gesture_event_queue_;
-  }
-
-  GestureEventQueue& gesture_event_queue() {
-    return input_router_impl()->gesture_event_queue_;
-  }
-
- private:
-  const InputRouterImpl* input_router_impl() const {
-    return static_cast<InputRouterImpl*>(input_router_.get());
-  }
-
-  InputRouterImpl* input_router_impl() {
-    return static_cast<InputRouterImpl*>(input_router_.get());
-  }
-
   bool unresponsive_timer_fired_;
   WebInputEvent::Type acked_touch_event_type_;
 
-  scoped_ptr<TestOverscrollDelegate> overscroll_delegate_;
-
   DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHost);
 };
 
 namespace  {
 
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
  public:
   explicit RenderWidgetHostProcess(BrowserContext* browser_context)
@@ skipping 102 matching lines @@
 
   // RenderWidgetHostView override.
   virtual gfx::Rect GetViewBounds() const OVERRIDE {
     return bounds_;
   }
   virtual void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch,
                                       InputEventAckState ack_result) OVERRIDE {
     acked_event_ = touch.event;
     ++acked_event_count_;
   }
-  virtual void UnhandledWheelEvent(const WebMouseWheelEvent& event) OVERRIDE {
+  virtual void WheelEventAck(const WebMouseWheelEvent& event,
+                             InputEventAckState ack_result) OVERRIDE {
+    if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
+      return;
     unhandled_wheel_event_count_++;
     unhandled_wheel_event_ = event;
   }
   virtual void GestureEventAck(const WebGestureEvent& event,
                                InputEventAckState ack_result) OVERRIDE {
     gesture_event_type_ = event.type;
     ack_result_ = ack_result;
   }
   virtual gfx::Size GetPhysicalBackingSize() const OVERRIDE {
     if (use_fake_physical_backing_size_)
@@ skipping 128 matching lines @@
         scoped_ptr<ui::ContextFactory>(new ui::InProcessContextFactory));
     aura::Env::CreateInstance(true);
     screen_.reset(aura::TestScreen::Create());
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
 #endif
     host_.reset(
         new MockRenderWidgetHost(delegate_.get(), process_, MSG_ROUTING_NONE));
     view_.reset(new TestView(host_.get()));
     host_->SetView(view_.get());
     host_->Init();
-
-    // Tests for debounce-related behavior will explicitly enable debouncing.
     host_->DisableGestureDebounce();
   }
   virtual void TearDown() {
     view_.reset();
     host_.reset();
     delegate_.reset();
     process_ = NULL;
     browser_context_.reset();
 
 #if defined(USE_AURA)
@@ skipping 68 matching lines @@
   void SimulateMouseEvent(
       WebInputEvent::Type type, int x, int y, int modifiers, bool pressed) {
     WebMouseEvent event =
         SyntheticWebMouseEventBuilder::Build(type, x, y, modifiers);
     if (pressed)
       event.button = WebMouseEvent::ButtonLeft;
     event.timeStampSeconds = GetNextSimulatedEventTimeSeconds();
     host_->ForwardMouseEvent(event);
   }
 
-  void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) {
-    host_->ForwardWheelEvent(SyntheticWebMouseWheelEventBuilder::Build(phase));
-  }
-
-  // Inject provided synthetic WebGestureEvent instance.
-  void SimulateGestureEventCore(const WebGestureEvent& gesture_event) {
-    host_->ForwardGestureEvent(gesture_event);
-  }
-
-  void SimulateGestureEventCoreWithLatencyInfo(
-      const WebGestureEvent& gesture_event,
-      const ui::LatencyInfo& ui_latency) {
-    host_->ForwardGestureEventWithLatencyInfo(gesture_event, ui_latency);
-  }
-
   // Inject simple synthetic WebGestureEvent instances.
   void SimulateGestureEvent(WebInputEvent::Type type,
                             WebGestureEvent::SourceDevice sourceDevice) {
-    SimulateGestureEventCore(
+    host_->ForwardGestureEvent(
         SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
   }
 
   void SimulateGestureEventWithLatencyInfo(
       WebInputEvent::Type type,
       WebGestureEvent::SourceDevice sourceDevice,
       const ui::LatencyInfo& ui_latency) {
-    SimulateGestureEventCoreWithLatencyInfo(
+    host_->ForwardGestureEventWithLatencyInfo(
         SyntheticWebGestureEventBuilder::Build(type, sourceDevice),
         ui_latency);
   }
 
-  void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
-    SimulateGestureEventCore(
-        SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
-  }
-
-  void SimulateGesturePinchUpdateEvent(float scale,
-                                       float anchorX,
-                                       float anchorY,
-                                       int modifiers) {
-    SimulateGestureEventCore(SyntheticWebGestureEventBuilder::BuildPinchUpdate(
-        scale, anchorX, anchorY, modifiers, WebGestureEvent::Touchscreen));
-  }
-
-  // Inject synthetic GestureFlingStart events.
-  void SimulateGestureFlingStartEvent(
-      float velocityX,
-      float velocityY,
-      WebGestureEvent::SourceDevice sourceDevice) {
-    SimulateGestureEventCore(
-        SyntheticWebGestureEventBuilder::BuildFling(velocityX,
-                                                    velocityY,
-                                                    sourceDevice));
-  }
-
   // Set the timestamp for the touch-event.
   void SetTouchTimestamp(base::TimeDelta timestamp) {
     touch_event_.SetTimestamp(timestamp);
   }
 
   // Sends a touch event (irrespective of whether the page has a touch-event
   // handler or not).
   void SendTouchEvent() {
     host_->ForwardTouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo());
 
@@ skipping 433 matching lines @@
 
   // Wait long enough for first timeout and see if it fired.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::MessageLoop::QuitClosure(),
       TimeDelta::FromMilliseconds(40));
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(host_->unresponsive_timer_fired());
 }
 
-// Tests that scroll ACKs are correctly handled by the overscroll-navigation
-// controller.
-TEST_F(RenderWidgetHostTest, WheelScrollEventOverscrolls) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  // Simulate wheel events.
-  SimulateWheelEvent(-5, 0, 0, true);  // sent directly
-  SimulateWheelEvent(-1, 1, 0, true);  // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-20, 6, 1, true);  // enqueued, different modifiers
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK the first wheel event as not processed.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK for the second (coalesced) event as not processed. This will
-  // start a back navigation. However, this will also cause the queued next
-  // event to be sent to the renderer. But since overscroll navigation has
-  // started, that event will also be included in the overscroll computation
-  // instead of being sent to the renderer. So the result will be an overscroll
-  // back navigation, and no event will be sent to the renderer.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(-81.f, host_->overscroll_delta_x());
-  EXPECT_EQ(-31.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  // Send a mouse-move event. This should cancel the overscroll navigation.
-  SimulateMouseMove(5, 10, 0);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-}
-
-// Tests that if some scroll events are consumed towards the start, then
-// subsequent scrolls do not horizontal overscroll.
-TEST_F(RenderWidgetHostTest, WheelScrollConsumedDoNotHorizOverscroll) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  // Simulate wheel events.
-  SimulateWheelEvent(-5, 0, 0, true);  // sent directly
-  SimulateWheelEvent(-1, -1, 0, true);  // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-20, 6, 1, true);  // enqueued, different modifiers
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK the first wheel event as processed.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK for the second (coalesced) event as not processed. This should
-  // not initiate overscroll, since the beginning of the scroll has been
-  // consumed. The queued event with different modifiers should be sent to the
-  // renderer.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-
-  // Indicate the end of the scrolling from the touchpad.
-  SimulateGestureFlingStartEvent(-1200.f, 0.f, WebGestureEvent::Touchpad);
-  EXPECT_EQ(1U, process_->sink().message_count());
-
-  // Start another scroll. This time, do not consume any scroll events.
-  process_->sink().ClearMessages();
-  SimulateWheelEvent(0, -5, 0, true);  // sent directly
-  SimulateWheelEvent(0, -1, 0, true);  // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-20, 6, 1, true);  // enqueued, different modifiers
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK for the first wheel and the subsequent coalesced event as not
-  // processed. This should start a back-overscroll.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-}
-
-// Tests that wheel-scrolling correctly turns overscroll on and off.
-TEST_F(RenderWidgetHostTest, WheelScrollOverscrollToggle) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  // Send a wheel event. ACK the event as not processed. This should not
-  // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(10, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(40, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(60.f, host_->overscroll_delta_x());
-  EXPECT_EQ(10.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  process_->sink().ClearMessages();
-
-  // Scroll in the reverse direction enough to abort the overscroll.
-  SimulateWheelEvent(-20, 0, 0, true);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  // Continue to scroll in the reverse direction.
-  SimulateWheelEvent(-20, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Continue to scroll in the reverse direction enough to initiate overscroll
-  // in that direction.
-  SimulateWheelEvent(-55, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(-75.f, host_->overscroll_delta_x());
-  EXPECT_EQ(-25.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-}
-
-TEST_F(RenderWidgetHostTest, ScrollEventsOverscrollWithFling) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  // Send a wheel event. ACK the event as not processed. This should not
-  // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(20, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(30, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(60.f, host_->overscroll_delta_x());
-  EXPECT_EQ(10.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-
-  // Send a fling start, but with a small velocity, so that the overscroll is
-  // aborted. The fling should proceed to the renderer, through the gesture
-  // event filter.
-  SimulateGestureFlingStartEvent(0.f, 0.1f, WebGestureEvent::Touchpad);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, process_->sink().message_count());
-}
-
-// Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that
-// the zero-velocity fling does not reach the renderer.
-TEST_F(RenderWidgetHostTest, ScrollEventsOverscrollWithZeroFling) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  // Send a wheel event. ACK the event as not processed. This should not
-  // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(20, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(30, 0, 0, true);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(60.f, host_->overscroll_delta_x());
-  EXPECT_EQ(10.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-
-  // Send a fling start, but with a small velocity, so that the overscroll is
-  // aborted. The fling should proceed to the renderer, through the gesture
-  // event filter.
-  SimulateGestureFlingStartEvent(10.f, 0.f, WebGestureEvent::Touchpad);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, process_->sink().message_count());
-}
-
-// Tests that a fling in the opposite direction of the overscroll cancels the
-// overscroll nav instead of completing it.
-TEST_F(RenderWidgetHostTest, ReverseFlingCancelsOverscroll) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  {
-    // Start and end a gesture in the same direction without processing the
-    // gesture events in the renderer. This should initiate and complete an
-    // overscroll navigation.
-    SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                         WebGestureEvent::Touchscreen);
-    SimulateGestureScrollUpdateEvent(300, -5, 0);
-    SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-    EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-    EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-    process_->sink().ClearMessages();
-
-    SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                         WebGestureEvent::Touchscreen);
-    EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
-    EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-    EXPECT_EQ(1U, process_->sink().message_count());
-  }
-
-  {
-    // Start over, except instead of ending the gesture with ScrollEnd, end it
-    // with a FlingStart, with velocity in the reverse direction. This should
-    // initiate an overscroll navigation, but it should be cancelled because of
-    // the fling in the opposite direction.
-    host_->overscroll_delegate()->Reset();
-    SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                         WebGestureEvent::Touchscreen);
-    SimulateGestureScrollUpdateEvent(-300, -5, 0);
-    SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-    EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-    EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_delegate()->current_mode());
-    process_->sink().ClearMessages();
-
-    SimulateGestureFlingStartEvent(100, 0, WebGestureEvent::Touchscreen);
-    EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
-    EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-    EXPECT_EQ(1U, process_->sink().message_count());
-  }
-}
-
-// Tests that touch-scroll events are handled correctly by the overscroll
-// controller. This also tests that the overscroll controller and the
-// gesture-event filter play nice with each other.
-TEST_F(RenderWidgetHostTest, GestureScrollOverscrolls) {
-  // Turn off debounce handling for test isolation.
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  // Send another gesture event and ACK as not being processed. This should
-  // initiate the navigation gesture.
-  SimulateGestureScrollUpdateEvent(55, -5, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(55.f, host_->overscroll_delta_x());
-  EXPECT_EQ(-5.f, host_->overscroll_delta_y());
-  EXPECT_EQ(5.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(-5.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  process_->sink().ClearMessages();
-
-  // Send another gesture update event. This event should be consumed by the
-  // controller, and not be forwarded to the renderer. The gesture-event filter
-  // should not also receive this event.
-  SimulateGestureScrollUpdateEvent(10, -5, 0);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(65.f, host_->overscroll_delta_x());
-  EXPECT_EQ(-10.f, host_->overscroll_delta_y());
-  EXPECT_EQ(15.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(-10.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-
-  // Now send a scroll end. This should cancel the overscroll gesture, and send
-  // the event to the renderer. The gesture-event filter should receive this
-  // event.
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  // The scroll end event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-}
-
-// Tests that if the page is scrolled because of a scroll-gesture, then that
-// particular scroll sequence never generates overscroll if the scroll direction
-// is horizontal.
-TEST_F(RenderWidgetHostTest, GestureScrollConsumedHorizontal) {
-  // Turn off debounce handling for test isolation.
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  SimulateGestureScrollUpdateEvent(10, 0, 0);
-
-  // Start scrolling on content. ACK both events as being processed.
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Send another gesture event and ACK as not being processed. This should
-  // not initiate overscroll because the beginning of the scroll event did
-  // scroll some content on the page. Since there was no overscroll, the event
-  // should reach the renderer.
-  SimulateGestureScrollUpdateEvent(55, 0, 0);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-}
-
-// Tests that the overscroll controller plays nice with touch-scrolls and the
-// gesture event filter with debounce filtering turned on.
-TEST_F(RenderWidgetHostTest, GestureScrollDebounceOverscrolls) {
-  host_->SetupForOverscrollControllerTest();
-  host_->set_debounce_interval_time_ms(100);
-  process_->sink().ClearMessages();
-
-  // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Send update events.
-  SimulateGestureScrollUpdateEvent(25, 0, 0);
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Quickly end and restart the scroll gesture. These two events should get
-  // discarded.
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, host_->GestureEventDebouncingQueueSize());
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(2U, host_->GestureEventDebouncingQueueSize());
-
-  // Send another update event. This should get into the queue.
-  SimulateGestureScrollUpdateEvent(30, 0, 0);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-
-  // Receive an ACK for the first scroll-update event as not being processed.
-  // This will contribute to the overscroll gesture, but not enough for the
-  // overscroll controller to start consuming gesture events. This also cause
-  // the queued gesture event to be forwarded to the renderer.
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Send another update event. This should get into the queue.
-  SimulateGestureScrollUpdateEvent(10, 0, 0);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-
-  // Receive an ACK for the second scroll-update event as not being processed.
-  // This will now initiate an overscroll. This will also cause the queued
-  // gesture event to be released. But instead of going to the renderer, it will
-  // be consumed by the overscroll controller.
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(65.f, host_->overscroll_delta_x());
-  EXPECT_EQ(15.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-}
-
-// Tests that the gesture debounce timer plays nice with the overscroll
-// controller.
-TEST_F(RenderWidgetHostTest, GestureScrollDebounceTimerOverscroll) {
-  host_->SetupForOverscrollControllerTest();
-  host_->set_debounce_interval_time_ms(10);
-  process_->sink().ClearMessages();
-
-  // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Send update events.
-  SimulateGestureScrollUpdateEvent(55, 0, 0);
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Send an end event. This should get in the debounce queue.
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, host_->GestureEventDebouncingQueueSize());
-
-  // Receive ACK for the scroll-update event.
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(55.f, host_->overscroll_delta_x());
-  EXPECT_EQ(5.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  // Let the timer for the debounce queue fire. That should release the queued
-  // scroll-end event. Since overscroll has started, but there hasn't been
-  // enough overscroll to complete the gesture, the overscroll controller
-  // will reset the state. The scroll-end should therefore be dispatched to the
-  // renderer, and the gesture-event-filter should await an ACK for it.
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::MessageLoop::QuitClosure(),
-      TimeDelta::FromMilliseconds(15));
-  base::MessageLoop::current()->Run();
-
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  // The scroll end event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_EQ(1U, process_->sink().message_count());
-}
-
-// Tests that when touch-events are dispatched to the renderer, the overscroll
-// gesture deals with them correctly.
-TEST_F(RenderWidgetHostTest, OverscrollWithTouchEvents) {
-  host_->SetupForOverscrollControllerTest();
-  host_->set_debounce_interval_time_ms(10);
-  host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  // The test sends an intermingled sequence of touch and gesture events.
-
-  PressTouchPoint(0, 1);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::TouchStart,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  MoveTouchPoint(0, 20, 5);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  SimulateGestureScrollUpdateEvent(20, 0, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Another touch move event should reach the renderer since overscroll hasn't
-  // started yet.
-  MoveTouchPoint(0, 65, 10);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SimulateGestureScrollUpdateEvent(45, 0, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(65.f, host_->overscroll_delta_x());
-  EXPECT_EQ(15.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-  process_->sink().ClearMessages();
-
-  // Send another touch event. The page should get the touch-move event, even
-  // though overscroll has started.
-  MoveTouchPoint(0, 55, 5);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_FALSE(host_->TouchEventQueueEmpty());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(65.f, host_->overscroll_delta_x());
-  EXPECT_EQ(15.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-  process_->sink().ClearMessages();
-
-  SimulateGestureScrollUpdateEvent(-10, 0, 0);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(55.f, host_->overscroll_delta_x());
-  EXPECT_EQ(5.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-
-  MoveTouchPoint(0, 255, 5);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_FALSE(host_->TouchEventQueueEmpty());
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  SimulateGestureScrollUpdateEvent(200, 0, 0);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(255.f, host_->overscroll_delta_x());
-  EXPECT_EQ(205.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-
-  // The touch-end/cancel event should always reach the renderer if the page has
-  // touch handlers.
-  ReleaseTouchPoint(0);
-  SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_FALSE(host_->TouchEventQueueEmpty());
-  process_->sink().ClearMessages();
-
-  SendInputEventACK(WebInputEvent::TouchEnd,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-
-  SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::MessageLoop::QuitClosure(),
-      TimeDelta::FromMilliseconds(10));
-  base::MessageLoop::current()->Run();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_TRUE(host_->TouchEventQueueEmpty());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
-}
-
-// Tests that touch-gesture end is dispatched to the renderer at the end of a
-// touch-gesture initiated overscroll.
-TEST_F(RenderWidgetHostTest, TouchGestureEndDispatchedAfterOverscrollComplete) {
-  host_->SetupForOverscrollControllerTest();
-  host_->set_debounce_interval_time_ms(10);
-  host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  // The scroll begin event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  // Send update events.
-  SimulateGestureScrollUpdateEvent(55, -5, 0);
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(55.f, host_->overscroll_delta_x());
-  EXPECT_EQ(5.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(-5.f, host_->overscroll_delegate()->delta_y());
-
-  // Send end event.
-  SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, host_->GestureEventDebouncingQueueSize());
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::MessageLoop::QuitClosure(),
-      TimeDelta::FromMilliseconds(10));
-  base::MessageLoop::current()->Run();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  // The scroll end event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  // The scroll begin event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  // Send update events.
-  SimulateGestureScrollUpdateEvent(235, -5, 0);
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(235.f, host_->overscroll_delta_x());
-  EXPECT_EQ(185.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(-5.f, host_->overscroll_delegate()->delta_y());
-
-  // Send end event.
-  SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, host_->GestureEventDebouncingQueueSize());
-
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::MessageLoop::QuitClosure(),
-      TimeDelta::FromMilliseconds(10));
-  base::MessageLoop::current()->Run();
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  // The scroll end event will have received a synthetic ack from the input
-  // router.
-  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_EQ(0U, process_->sink().message_count());
-}
-
-TEST_F(RenderWidgetHostTest, OverscrollDirectionChange) {
-  host_->SetupForOverscrollControllerTest();
-  host_->set_debounce_interval_time_ms(100);
-  process_->sink().ClearMessages();
-
-  // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Send update events and receive ack as not consumed.
-  SimulateGestureScrollUpdateEvent(125, -5, 0);
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
-  EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
-  EXPECT_TRUE(host_->ScrollingInProgress());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  // Send another update event, but in the reverse direction. The overscroll
-  // controller will consume the event, and reset the overscroll mode.
-  SimulateGestureScrollUpdateEvent(-260, 0, 0);
-  EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-
-  // Since the overscroll mode has been reset, the next scroll update events
-  // should reach the renderer.
-  SimulateGestureScrollUpdateEvent(-20, 0, 0);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-}
-
-// Tests that if a mouse-move event completes the overscroll gesture, future
-// move events do reach the renderer.
-TEST_F(RenderWidgetHostTest, OverscrollMouseMoveCompletion) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  SimulateWheelEvent(5, 0, 0, true);  // sent directly
-  SimulateWheelEvent(-1, 0, 0, true);  // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK the first wheel event as not processed.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Receive ACK for the second (coalesced) event as not processed. This will
-  // start an overcroll gesture.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  // Send a mouse-move event. This should cancel the overscroll navigation
-  // (since the amount overscrolled is not above the threshold), and so the
-  // mouse-move should reach the renderer.
-  SimulateMouseMove(5, 10, 0);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  SendInputEventACK(WebInputEvent::MouseMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  // Moving the mouse more should continue to send the events to the renderer.
-  SimulateMouseMove(5, 10, 0);
-  SendInputEventACK(WebInputEvent::MouseMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Now try with gestures.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  SimulateGestureScrollUpdateEvent(300, -5, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  process_->sink().ClearMessages();
-
-  // Overscroll gesture is in progress. Send a mouse-move now. This should
-  // complete the gesture (because the amount overscrolled is above the
-  // threshold).
-  SimulateMouseMove(5, 10, 0);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::MouseMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Move mouse some more. The mouse-move events should reach the renderer.
-  SimulateMouseMove(5, 10, 0);
-  EXPECT_EQ(1U, process_->sink().message_count());
-
-  SendInputEventACK(WebInputEvent::MouseMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  process_->sink().ClearMessages();
-}
-
-// Tests that if a page scrolled, then the overscroll controller's states are
-// reset after the end of the scroll.
-TEST_F(RenderWidgetHostTest, OverscrollStateResetsAfterScroll) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  SimulateWheelEvent(0, 5, 0, true);  // sent directly
-  SimulateWheelEvent(0, 30, 0, true);  // enqueued
-  SimulateWheelEvent(0, 40, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(0, 10, 0, true);  // coalesced into previous event
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // The first wheel event is consumed. Dispatches the queued wheel event.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(host_->ScrollStateIsContentScrolling());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // The second wheel event is consumed.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(host_->ScrollStateIsContentScrolling());
-
-  // Touchpad scroll can end with a zero-velocity fling. But it is not
-  // dispatched, but it should still reset the overscroll controller state.
-  SimulateGestureFlingStartEvent(0.f, 0.f, WebGestureEvent::Touchpad);
-  EXPECT_TRUE(host_->ScrollStateIsUnknown());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  SimulateWheelEvent(-5, 0, 0, true);  // sent directly
-  SimulateWheelEvent(-60, 0, 0, true);  // enqueued
-  SimulateWheelEvent(-100, 0, 0, true);  // coalesced into previous event
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_TRUE(host_->ScrollStateIsUnknown());
-  process_->sink().ClearMessages();
-
-  // The first wheel scroll did not scroll content. Overscroll should not start
-  // yet, since enough hasn't been scrolled.
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(host_->ScrollStateIsUnknown());
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  SendInputEventACK(WebInputEvent::MouseWheel,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_mode());
-  EXPECT_TRUE(host_->ScrollStateIsOverscrolling());
-  EXPECT_EQ(0U, process_->sink().message_count());
-
-  SimulateGestureFlingStartEvent(0.f, 0.f, WebGestureEvent::Touchpad);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_WEST, host_->overscroll_delegate()->completed_mode());
-  EXPECT_TRUE(host_->ScrollStateIsUnknown());
-  EXPECT_EQ(0U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-}
-
-TEST_F(RenderWidgetHostTest, OverscrollResetsOnBlur) {
-  host_->SetupForOverscrollControllerTest();
-  process_->sink().ClearMessages();
-  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
-  view_->Show();
-
-  // Start an overscroll with gesture scroll. In the middle of the scroll, blur
-  // the host.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  SimulateGestureScrollUpdateEvent(300, -5, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(2U, process_->sink().message_count());
-
-  host_->Blur();
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_x());
-  EXPECT_EQ(0.f, host_->overscroll_delegate()->delta_y());
-  process_->sink().ClearMessages();
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Start a scroll gesture again. This should correctly start the overscroll
-  // after the threshold.
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  SimulateGestureScrollUpdateEvent(300, -5, 0);
-  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
-  EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
-  EXPECT_EQ(3U, process_->sink().message_count());
-}
-
 std::string GetInputMessageTypes(RenderWidgetHostProcess* process) {
   std::string result;
   for (size_t i = 0; i < process->sink().message_count(); ++i) {
     const IPC::Message *message = process->sink().GetMessageAt(i);
     EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type());
     InputMsg_HandleInputEvent::Param params;
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, &params));
     const WebInputEvent* event = params.a;
     if (i != 0)
       result += " ";
@@ skipping 380 matching lines @@
 
   // Tests RWHI::ForwardTouchEventWithLatencyInfo().
   PressTouchPoint(0, 1);
   SendTouchEvent();
   CheckLatencyInfoComponentInMessage(
       process_, GetLatencyComponentId(), WebInputEvent::TouchStart);
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
 }  // namespace content