Revert of Consolidate all touch/gesture related constants in content

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/tap_suppression_controller.h"
+#include "content/browser/renderer_host/input/tap_suppression_controller_client.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"
@@ skipping 166 matching lines @@
 // MockRenderWidgetHost ----------------------------------------------------
 
 class MockRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   MockRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
       RenderProcessHost* process,
       int routing_id)
       : RenderWidgetHostImpl(delegate, process, routing_id, false),
         unresponsive_timer_fired_(false) {
+    input_router_impl_ = static_cast<InputRouterImpl*>(input_router_.get());
     acked_touch_event_type_ = blink::WebInputEvent::Undefined;
   }
 
   // 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_;
@@ skipping 30 matching lines @@
   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 DisableGestureDebounce() {
+    gesture_event_queue().set_debounce_enabled_for_testing(false);
+  }
 
   void set_debounce_interval_time_ms(int delay_ms) {
-    gesture_event_queue().set_debounce_interval_time_ms_for_testing(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.
@@ skipping 31 matching lines @@
 
   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));
+    mock_input_router_ = new MockInputRouter(this);
+    input_router_.reset(mock_input_router_);
   }
 
   MockInputRouter* mock_input_router() {
-    return static_cast<MockInputRouter*>(input_router_.get());
+    return mock_input_router_;
   }
 
  protected:
   virtual void NotifyRendererUnresponsive() OVERRIDE {
     unresponsive_timer_fired_ = true;
   }
 
   const TouchEventQueue& touch_event_queue() const {
-    return input_router_impl()->touch_event_queue_;
+    return input_router_impl_->touch_event_queue_;
   }
 
   const GestureEventQueue& gesture_event_queue() const {
-    return input_router_impl()->gesture_event_queue_;
+    return input_router_impl_->gesture_event_queue_;
   }
 
   GestureEventQueue& gesture_event_queue() {
-    return input_router_impl()->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_;
 
+  // |input_router_impl_| and |mock_input_router_| are owned by
+  // RenderWidgetHostImpl.  The handles below are provided for convenience so
+  // that we don't have to reinterpret_cast it all the time.
+  InputRouterImpl* input_router_impl_;
+  MockInputRouter* mock_input_router_;
+
   scoped_ptr<TestOverscrollDelegate> overscroll_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHost);
 };
 
 namespace  {
 
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
@@ skipping 253 matching lines @@
         scoped_ptr<ui::ContextFactory>(new ui::InProcessContextFactory));
     aura::Env::CreateInstance();
     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)
     aura::Env::DeleteInstance();
@@ skipping 885 matching lines @@
   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();
+  host_->DisableGestureDebounce();
   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);
@@ skipping 32 matching lines @@
     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();
+  host_->DisableGestureDebounce();
   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);
@@ skipping 33 matching lines @@
   // 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();
+  host_->DisableGestureDebounce();
   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());
@@ skipping 434 matching lines @@
   // 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();
+  host_->DisableGestureDebounce();
   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());
@@ skipping 70 matching lines @@
 
   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();
+  host_->DisableGestureDebounce();
   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());
@@ skipping 54 matching lines @@
 
   // 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();
+  EXPECT_EQ(0U, process_->sink().message_count());
 
   // 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());
+  process_->sink().ClearMessages();
 }
 
 std::string GetInputMessageTypes(RenderWidgetHostProcess* process) {
   const WebInputEvent* event = NULL;
   ui::LatencyInfo latency_info;
   bool is_keyboard_shortcut;
   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());
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(
         message, &event, &latency_info, &is_keyboard_shortcut));
     if (i != 0)
       result += " ";
     result += WebInputEventTraits::GetName(event->type);
   }
   process->sink().ClearMessages();
   return result;
 }
 
 TEST_F(RenderWidgetHostTest, TouchEmulator) {
   simulated_event_time_delta_seconds_ = 0.1;
+  host_->DisableGestureDebounce();
   // Immediately ack all touches instead of sending them to the renderer.
   host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
   host_->OnMessageReceived(
       ViewHostMsg_SetTouchEventEmulationEnabled(0, true, true));
   process_->sink().ClearMessages();
   view_->set_bounds(gfx::Rect(0, 0, 400, 200));
   view_->Show();
 
   SimulateMouseEvent(WebInputEvent::MouseMove, 10, 10, 0, false);
   EXPECT_EQ(0U, process_->sink().message_count());
@@ skipping 364 matching lines @@
 
   // Tests RWHI::ForwardTouchEventWithLatencyInfo().
   PressTouchPoint(0, 1);
   SendTouchEvent();
   CheckLatencyInfoComponentInMessage(
       process_, GetLatencyComponentId(), WebInputEvent::TouchStart);
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
 }  // namespace content