Consolidate all touch/gesture related constants in content

content/browser/renderer_host/input/touch_event_queue_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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
@@ skipping 23 matching lines @@
       : sent_event_count_(0),
         acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
         slop_length_dips_(0),
         touch_scrolling_mode_(TouchEventQueue::TOUCH_SCROLLING_MODE_DEFAULT) {}
 
   virtual ~TouchEventQueueTest() {}
 
   // testing::Test
   virtual void SetUp() OVERRIDE {
-    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
-  }
-
-  virtual void SetTouchScrollingMode(TouchEventQueue::TouchScrollingMode mode) {
-    touch_scrolling_mode_ = mode;
-    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
+    ResetQueueWithConfig(CreateConfig());
   }
 
   virtual void TearDown() OVERRIDE {
     queue_.reset();
   }
 
   // TouchEventQueueClient
   virtual void SendTouchEventImmediately(
       const TouchEventWithLatencyInfo& event) OVERRIDE {
     ++sent_event_count_;
@@ skipping 17 matching lines @@
       scoped_ptr<WebGestureEvent> followup_gesture_event =
           followup_gesture_event_.Pass();
       queue_->OnGestureScrollEvent(
           GestureEventWithLatencyInfo(*followup_gesture_event,
                                       ui::LatencyInfo()));
     }
   }
 
  protected:
 
-  void SetUpForTimeoutTesting(base::TimeDelta timeout_delay) {
-    queue_->SetAckTimeoutEnabled(true, timeout_delay);
+  TouchEventQueue::Config CreateConfig() {
+    TouchEventQueue::Config config;
+    config.touch_scrolling_mode = touch_scrolling_mode_;
+    config.touchmove_slop_suppression_length_dips = slop_length_dips_;
+    return config;
+  }
+
+  void SetTouchScrollingMode(TouchEventQueue::TouchScrollingMode mode) {
+    touch_scrolling_mode_ = mode;
+    ResetQueueWithConfig(CreateConfig());
   }
 
   void SetUpForTouchMoveSlopTesting(double slop_length_dips) {
     slop_length_dips_ = slop_length_dips;
-    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
+    ResetQueueWithConfig(CreateConfig());
+  }
+
+  void SetUpForTimeoutTesting(base::TimeDelta timeout_delay) {
+    TouchEventQueue::Config config = CreateConfig();
+    config.touch_ack_timeout_delay = timeout_delay;
+    config.touch_ack_timeout_supported = true;
+    ResetQueueWithConfig(config);
   }
 
   void SendTouchEvent(const WebTouchEvent& event) {
     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent event;
     event.type = type;
     queue_->OnGestureScrollEvent(
@@ skipping 72 matching lines @@
   }
 
   bool IsPendingAckTouchStart() const {
     return queue_->IsPendingAckTouchStart();
   }
 
   void OnHasTouchEventHandlers(bool has_handlers) {
     queue_->OnHasTouchEventHandlers(has_handlers);
   }
 
-  void SetAckTimeoutDisabled() {
-    queue_->SetAckTimeoutEnabled(false, base::TimeDelta());
-  }
+  void SetAckTimeoutDisabled() { queue_->SetAckTimeoutEnabled(false); }
 
   bool IsTimeoutEnabled() const { return queue_->ack_timeout_enabled(); }
 
   bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); }
 
   bool HasPendingAsyncTouchMove() const {
     return queue_->HasPendingAsyncTouchMoveForTesting();
   }
 
   size_t queued_event_count() const {
@@ skipping 21 matching lines @@
         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
     base::MessageLoop::current()->Run();
   }
 
  private:
   void SendTouchEvent() {
     SendTouchEvent(touch_event_);
     touch_event_.ResetPoints();
   }
 
-  void ResetQueueWithParameters(TouchEventQueue::TouchScrollingMode mode,
-                                double slop_length_dips) {
-    queue_.reset(new TouchEventQueue(this, mode, slop_length_dips));
+  void ResetQueueWithConfig(const TouchEventQueue::Config& config) {
+    queue_.reset(new TouchEventQueue(this, config));
     queue_->OnHasTouchEventHandlers(true);
   }
 
   scoped_ptr<TouchEventQueue> queue_;
   size_t sent_event_count_;
   size_t acked_event_count_;
   WebTouchEvent last_sent_event_;
   WebTouchEvent last_acked_event_;
   InputEventAckState last_acked_event_state_;
   SyntheticWebTouchEvent touch_event_;
@@ skipping 1696 matching lines @@
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 }
 
 }  // namespace content