Delegate touch handler registration logic to the TouchEventQueue

content/browser/renderer_host/input/input_router_impl_unittest.cc

 // Copyright 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.
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
@@ skipping 251 matching lines @@
   }
 
   bool TouchEventQueueEmpty() const {
     return input_router()->touch_event_queue_->empty();
   }
 
   bool TouchEventTimeoutEnabled() const {
     return input_router()->touch_event_queue_->ack_timeout_enabled();
   }
 
+  void OnHasTouchEventHandlers(bool has_handlers) {
+    input_router_->OnMessageReceived(
+        ViewHostMsg_HasTouchEventHandlers(0, has_handlers));
+  }
+
   size_t GetSentMessageCountAndResetSink() {
     size_t count = process_->sink().message_count();
     process_->sink().ClearMessages();
     return count;
   }
 
   scoped_ptr<MockRenderProcessHost> process_;
   scoped_ptr<MockInputRouterClient> client_;
   scoped_ptr<MockInputAckHandler> ack_handler_;
   scoped_ptr<InputRouterImpl> input_router_;
@@ skipping 240 matching lines @@
   ASSERT_EQ(WebMouseWheelEvent::PhaseEnded, wheel_event->phase);
 
   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(1));
   EXPECT_EQ(WebInputEvent::GestureScrollEnd, input_event->type);
 
   ASSERT_EQ(2U, GetSentMessageCountAndResetSink());
 }
 
 // Tests that touch-events are queued properly.
 TEST_F(InputRouterImplTest, TouchEventQueue) {
+  OnHasTouchEventHandlers(true);
+
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_TRUE(client_->GetAndResetFilterEventCalled());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   EXPECT_FALSE(TouchEventQueueEmpty());
 
   // The second touch should not be sent since one is already in queue.
   MoveTouchPoint(0, 5, 5);
   SendTouchEvent();
   EXPECT_FALSE(client_->GetAndResetFilterEventCalled());
@@ skipping 14 matching lines @@
   EXPECT_TRUE(TouchEventQueueEmpty());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::TouchMove,
             ack_handler_->acked_touch_event().event.type);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 }
 
 // Tests that the touch-queue is emptied if a page stops listening for touch
 // events.
 TEST_F(InputRouterImplTest, TouchEventQueueFlush) {
-  input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
+  OnHasTouchEventHandlers(true);
   EXPECT_TRUE(client_->has_touch_handler());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_TRUE(TouchEventQueueEmpty());
 
   EXPECT_TRUE(input_router_->ShouldForwardTouchEvent());
 
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_FALSE(TouchEventQueueEmpty());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // The page stops listening for touch-events. The touch-event queue should now
   // be emptied, but none of the queued touch-events should be sent to the
   // renderer.
-  input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
+  OnHasTouchEventHandlers(false);
   EXPECT_FALSE(client_->has_touch_handler());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_TRUE(TouchEventQueueEmpty());
   EXPECT_FALSE(input_router_->ShouldForwardTouchEvent());
 }
 
 #if defined(OS_WIN) || defined(USE_AURA)
 // Tests that the acked events have correct state. (ui::Events are used only on
 // windows and aura)
 TEST_F(InputRouterImplTest, AckedTouchEventState) {
@@ skipping 102 matching lines @@
   // Check that the second event was sent.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
                   InputMsg_HandleInputEvent::ID));
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Check that the correct unhandled wheel event was received.
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 }
 
 TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) {
+  OnHasTouchEventHandlers(true);
+
   int start_type = static_cast<int>(WebInputEvent::TouchStart);
   int end_type = static_cast<int>(WebInputEvent::TouchCancel);
   ASSERT_LT(start_type, end_type);
   for (int i = start_type; i <= end_type; ++i) {
     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
     if (!WebInputEventTraits::IgnoresAckDisposition(type))
       continue;
 
     // The TouchEventQueue requires an initial TouchStart for it to begin
     // forwarding other touch event types.
@@ skipping 225 matching lines @@
 
   input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT |
                                 InputRouter::FIXED_PAGE_SCALE);
   EXPECT_FALSE(TouchEventTimeoutEnabled());
 
   input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE);
   EXPECT_TRUE(TouchEventTimeoutEnabled());
 }
 
 }  // namespace content