Add touch scrolling modes experimental flags

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 10 matching lines @@
 namespace {
 const size_t kDefaultTouchTimeoutDelayMs = 10;
 }
 
 class TouchEventQueueTest : public testing::Test,
                             public TouchEventQueueClient {
  public:
   TouchEventQueueTest()
       : sent_event_count_(0),
         acked_event_count_(0),
-        last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {}
+        last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
+        touch_scrolling_mode_(TouchEventQueue::TOUCH_SCROLLING_MODE_DEFAULT),
+        slop_length_dips_(0) {}
 
   virtual ~TouchEventQueueTest() {}
 
   // testing::Test
   virtual void SetUp() OVERRIDE {
-    queue_.reset(new TouchEventQueue(this, 0));
-    queue_->OnHasTouchEventHandlers(true);
+    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
+  }
+
+  virtual void SetTouchScrollingMode(TouchEventQueue::TouchScrollingMode mode) {
+    touch_scrolling_mode_ = mode;
+    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
   }
 
   virtual void TearDown() OVERRIDE {
     queue_.reset();
   }
 
   // TouchEventQueueClient
   virtual void SendTouchEventImmediately(
       const TouchEventWithLatencyInfo& event) OVERRIDE {
     ++sent_event_count_;
@@ skipping 22 matching lines @@
     }
   }
 
  protected:
 
   void SetUpForTimeoutTesting(size_t timeout_delay_ms) {
     queue_->SetAckTimeoutEnabled(true, timeout_delay_ms);
   }
 
   void SetUpForTouchMoveSlopTesting(double slop_length_dips) {
-    queue_.reset(new TouchEventQueue(this, slop_length_dips));
-    queue_->OnHasTouchEventHandlers(true);
+    slop_length_dips_ = slop_length_dips;
+    ResetQueueWithParameters(touch_scrolling_mode_, slop_length_dips_);
   }
 
   void SendTouchEvent(const WebTouchEvent& event) {
     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent event;
     event.type = type;
     queue_->OnGestureScrollEvent(
@@ skipping 85 matching lines @@
   InputEventAckState acked_event_state() const {
     return last_acked_event_state_;
   }
 
  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));
+    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_;
   scoped_ptr<WebTouchEvent> followup_touch_event_;
   scoped_ptr<WebGestureEvent> followup_gesture_event_;
   scoped_ptr<InputEventAckState> sync_ack_result_;
+  double slop_length_dips_;
+  TouchEventQueue::TouchScrollingMode touch_scrolling_mode_;
   base::MessageLoopForUI message_loop_;
 };
 
 
 // Tests that touch-events are queued properly.
 TEST_F(TouchEventQueueTest, Basic) {
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
@@ skipping 1179 matching lines @@
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove's should not should be suppressed, even with the original
   // unmoved pointer.
   MoveTouchPoint(0, 0, 0);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
+//TEST_F(TouchEventQueueTest, SyncTouchMoveDoesntCancelTouchOnScroll) {
+//  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE);
+//  // Queue a TouchStart.
+//  PressTouchPoint(0, 1);
+//  EXPECT_EQ(1U, GetAndResetSentEventCount());
+//  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+//
+//  MoveTouchPoint(0, 20, 5);
+//  EXPECT_EQ(1U, queued_event_count());
+//  EXPECT_EQ(1U, GetAndResetSentEventCount());
+//
+//  // GestureScrollBegin doesn't insert a synthetic TouchCancel.
+//  WebGestureEvent followup_scroll;
+//  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+//  SetFollowupEvent(followup_scroll);
+//  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//  EXPECT_EQ(0U, GetAndResetSentEventCount());
+//  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+//  EXPECT_EQ(0U, queued_event_count());
+//}
+//
+//TEST_F(TouchEventQueueTest, TouchAbsorption) {
+//  SetTouchScrollingMode(
+//      TouchEventQueue::TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE);
+//  // Queue a TouchStart.
+//  PressTouchPoint(0, 1);
+//  EXPECT_EQ(1U, GetAndResetSentEventCount());
+//  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+//
+//  for (int i = 0; i < 3; ++i) {
+//    SendGestureEventACK(WebInputEvent::GestureScrollUpdate,
+//                        INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//
+//    MoveTouchPoint(0, 20, 5);
+//    SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//    EXPECT_EQ(0U, queued_event_count());
+//    EXPECT_EQ(1U, GetAndResetSentEventCount());
+//
+//    // Consuming a scroll event prevents the next touch moves from being
+//    // dispatched.
+//    SendGestureEventACK(WebInputEvent::GestureScrollUpdate,
+//                        INPUT_EVENT_ACK_STATE_CONSUMED);
+//    MoveTouchPoint(0, 20, 5);
+//    SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+//    EXPECT_EQ(0U, queued_event_count());
+//    EXPECT_EQ(0U, GetAndResetSentEventCount());
+//  }
+//}
+
 }  // namespace content