Revert of Consolidate all touch/gesture related constants in content

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_queue.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
@@ skipping 127 matching lines @@
 
  protected:
   // testing::Test
   virtual void SetUp() OVERRIDE {
     browser_context_.reset(new TestBrowserContext());
     process_.reset(new MockRenderProcessHost(browser_context_.get()));
     client_.reset(new MockInputRouterClient());
     ack_handler_.reset(new MockInputAckHandler());
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kValidateInputEventStream);
-    input_router_.reset(new InputRouterImpl(process_.get(),
-                                            client_.get(),
-                                            ack_handler_.get(),
-                                            MSG_ROUTING_NONE,
-                                            config_));
+    input_router_.reset(new InputRouterImpl(
+        process_.get(), client_.get(), ack_handler_.get(), MSG_ROUTING_NONE));
+    input_router_->gesture_event_queue_.set_debounce_enabled_for_testing(
+        false);
     client_->set_input_router(input_router());
     ack_handler_->set_input_router(input_router());
   }
 
   virtual void TearDown() OVERRIDE {
     // Process all pending tasks to avoid leaks.
     base::MessageLoop::current()->RunUntilIdle();
 
     input_router_.reset();
     client_.reset();
     process_.reset();
     browser_context_.reset();
   }
 
-  void SetUpForTouchAckTimeoutTest(int timeout_ms) {
-    config_.touch_config.touch_ack_timeout_delay =
-        base::TimeDelta::FromMilliseconds(timeout_ms);
-    config_.touch_config.touch_ack_timeout_supported = true;
-    TearDown();
-    SetUp();
-  }
-
   void SimulateKeyboardEvent(WebInputEvent::Type type, bool is_shortcut) {
     WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
     NativeWebKeyboardEvent native_event;
     memcpy(&native_event, &event, sizeof(event));
     input_router_->SendKeyboardEvent(
         native_event,
         ui::LatencyInfo(),
         is_shortcut);
   }
 
@@ skipping 147 matching lines @@
     process_->sink().ClearMessages();
     return count;
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
     base::MessageLoop::current()->Run();
   }
 
-  InputRouterImpl::Config config_;
   scoped_ptr<MockRenderProcessHost> process_;
   scoped_ptr<MockInputRouterClient> client_;
   scoped_ptr<MockInputAckHandler> ack_handler_;
   scoped_ptr<InputRouterImpl> input_router_;
 
  private:
   base::MessageLoopForUI message_loop_;
   SyntheticWebTouchEvent touch_event_;
 
   scoped_ptr<TestBrowserContext> browser_context_;
@@ skipping 661 matching lines @@
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 
   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   // Now that the Tap has been ACKed, the ShowPress events should receive
   // synthetic acks, and fire immediately.
   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount());
 }
 
-// Test that touch ack timeout behavior is properly toggled by view update flags
-// and allowed touch actions.
+// Test that touch ack timeout behavior is properly configured via the command
+// line, and toggled by view update flags and allowed touch actions.
 TEST_F(InputRouterImplTest, TouchAckTimeoutConfigured) {
-  const int timeout_ms = 1;
-  SetUpForTouchAckTimeoutTest(timeout_ms);
+  // Unless explicitly supported via the command-line, the touch timeout should
+  // be disabled.
+  EXPECT_FALSE(TouchEventTimeoutEnabled());
+
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kTouchAckTimeoutDelayMs, "1");
+  TearDown();
+  SetUp();
   ASSERT_TRUE(TouchEventTimeoutEnabled());
 
   // Verify that the touch ack timeout fires upon the delayed ack.
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-  RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
+  RunTasksAndWait(base::TimeDelta::FromMilliseconds(2));
 
   // The timed-out event should have been ack'ed.
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // Ack'ing the timed-out event should fire a TouchCancel.
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
@@ skipping 45 matching lines @@
   // should be restored.
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_TRUE(TouchEventTimeoutEnabled());
 }
 
 // Test that a touch sequenced preceded by TOUCH_ACTION_NONE is not affected by
 // the touch timeout.
 TEST_F(InputRouterImplTest,
        TouchAckTimeoutDisabledForTouchSequenceAfterTouchActionNone) {
-  const int timeout_ms = 1;
-  SetUpForTouchAckTimeoutTest(timeout_ms);
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kTouchAckTimeoutDelayMs, "1");
+  TearDown();
+  SetUp();
   ASSERT_TRUE(TouchEventTimeoutEnabled());
   OnHasTouchEventHandlers(true);
 
   // Start a touch sequence.
   PressTouchPoint(1, 1);
   SendTouchEvent();
 
   // TOUCH_ACTION_NONE should disable the timeout.
   OnSetTouchAction(TOUCH_ACTION_NONE);
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(TouchEventTimeoutEnabled());
 
   // End the touch sequence.
   ReleaseTouchPoint(0);
   SendTouchEvent();
   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(TouchEventTimeoutEnabled());
   ack_handler_->GetAndResetAckCount();
   GetSentMessageCountAndResetSink();
 
   // Start another touch sequence.  While this does restore the touch timeout
   // the timeout will not apply until the *next* touch sequence. This affords a
   // touch-action response from the renderer without racing against the timeout.
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_TRUE(TouchEventTimeoutEnabled());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Delay the ack.  The timeout should *not* fire.
-  RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
+  RunTasksAndWait(base::TimeDelta::FromMilliseconds(2));
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // Finally send the ack.  The touch sequence should not have been cancelled.
   SendInputEventACK(WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(TouchEventTimeoutEnabled());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // End the sequence.
   ReleaseTouchPoint(0);
   SendTouchEvent();
   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // A new touch sequence should (finally) be subject to the timeout.
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_TRUE(TouchEventTimeoutEnabled());
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Wait for the touch ack timeout to fire.
-  RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1));
+  RunTasksAndWait(base::TimeDelta::FromMilliseconds(2));
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 }
 
 // Test that TouchActionFilter::ResetTouchAction is called before the
 // first touch event for a touch sequence reaches the renderer.
 TEST_F(InputRouterImplTest, ResetTouchActionBeforeEventReachesRenderer) {
   OnHasTouchEventHandlers(true);
 
   // Sequence 1.
   PressTouchPoint(1, 1);
@@ skipping 269 matching lines @@
 
   // Ack the second scroll.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0, client_->in_flight_event_count());
 }
 
 }  // namespace content