gesture: Make sure a combination of sync/async touch-events work correctly.

ui/aura/gestures/gesture_recognizer_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/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 194 matching lines @@
   gfx::Rect bounding_box_;
   int tap_count_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(RootWindow* root_window)
       : window_(NULL),
-        root_window_(root_window) {
+        root_window_(root_window),
+        queue_events_(true) {
   }
   virtual ~QueueTouchEventDelegate() {}
 
   virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+    if (!queue_events_)
+      return ui::TOUCH_STATUS_UNKNOWN;
     return event->type() == ui::ET_TOUCH_RELEASED ?
         ui::TOUCH_STATUS_QUEUED_END : ui::TOUCH_STATUS_QUEUED;
   }
 
   void ReceivedAck() {
     root_window_->AdvanceQueuedTouchEvent(window_, false);
   }
 
   void ReceivedAckPreventDefaulted() {
     root_window_->AdvanceQueuedTouchEvent(window_, true);
   }
 
   void set_window(Window* w) { window_ = w; }
+  void set_queue_events(bool queue) { queue_events_ = queue; }
 
  private:
   Window* window_;
   RootWindow* root_window_;
+  bool queue_events_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueTouchEventDelegate);
 };
 
 // A delegate that ignores gesture events but keeps track of [synthetic] mouse
 // events.
 class GestureEventSynthDelegate : public TestWindowDelegate {
  public:
   GestureEventSynthDelegate()
       : mouse_enter_(false),
@@ skipping 1676 matching lines @@
 
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 45), 7, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
 
   // This new press should not generate a tap-down.
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->scroll_begin());
 }
 
+// Tests that if a consumer has touch-events queued, then no touch-event gets
+// processed synchronously until all the queued evets are processed.
+TEST_F(GestureRecognizerTest, SyncTouchEventWithQueuedTouchEvents) {
+  scoped_ptr<QueueTouchEventDelegate> queued_delegate(
+      new QueueTouchEventDelegate(root_window()));
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId1 = 6;
+  gfx::Rect bounds(10, 20, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate(
+      queued_delegate.get(), -1234, bounds, NULL));
+
+  queued_delegate->set_window(queue.get());
+
+  // Send a touch-event to the window so that the event gets queued. No gesture
+  // event should be created.
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(20, 30), kTouchId1,
+      GetTime());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(80, 25), kTouchId1,
+      press1.time_stamp() + base::TimeDelta::FromMilliseconds(100));
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(80, 25), kTouchId1,
+      move1.time_stamp() + base::TimeDelta::FromMilliseconds(100));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move1);
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->scroll_begin());
+
+  // Stop queueing events.
+  queued_delegate->set_queue_events(false);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
+
+  // Process the two queued events.
+  queued_delegate->ReceivedAck();
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(queued_delegate->begin());
+  EXPECT_TRUE(queued_delegate->tap_down());
+  queued_delegate->Reset();
+
+  queued_delegate->ReceivedAck();
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(queued_delegate->scroll_begin());
+  EXPECT_TRUE(queued_delegate->scroll_update());
+  EXPECT_TRUE(queued_delegate->scroll_end());
+  EXPECT_TRUE(queued_delegate->end());
+}
+
 TEST_F(GestureRecognizerTest, TwoFingerTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
@@ skipping 654 matching lines @@
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 }  // namespace test
 }  // namespace aura