gesture recognizer: Remove the touch-event queue.

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"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/base/events/event.h"
 #include "ui/base/gestures/gesture_configuration.h"
 #include "ui/base/gestures/gesture_recognizer_impl.h"
 #include "ui/base/gestures/gesture_sequence.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 
+#include <queue>
+
 namespace aura {
 namespace test {
 
 namespace {
 
 std::string WindowIDAsString(ui::GestureConsumer* consumer) {
   return consumer && !consumer->ignores_events() ?
       base::IntToString(static_cast<Window*>(consumer)->id()) : "?";
 }
 
@@ skipping 248 matching lines @@
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(RootWindow* root_window)
       : window_(NULL),
         root_window_(root_window),
         queue_events_(true) {
   }
   virtual ~QueueTouchEventDelegate() {}
 
   virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
-    return queue_events_ ? ui::ER_ASYNC : ui::ER_UNHANDLED;
+    if (queue_events_) {
+      queue_.push(new ui::TouchEvent(*event, window_, window_));
+      return ui::ER_CONSUMED;
+    }
+    return ui::ER_UNHANDLED;
   }
 
   void ReceivedAck() {
-    root_window_->AdvanceQueuedTouchEvent(window_, false);
+    ReceivedAckImpl(false);
   }
 
   void ReceivedAckPreventDefaulted() {
-    root_window_->AdvanceQueuedTouchEvent(window_, true);
+    ReceivedAckImpl(true);
   }
 
   void set_window(Window* w) { window_ = w; }
   void set_queue_events(bool queue) { queue_events_ = queue; }
 
  private:
+  void ReceivedAckImpl(bool prevent_defaulted) {
+    scoped_ptr<ui::TouchEvent> event(queue_.front());
+    root_window_->ProcessedTouchEvent(event.get(), window_,
+        prevent_defaulted ? ui::ER_HANDLED : ui::ER_UNHANDLED);
+    queue_.pop();
+  }
+
+  std::queue<ui::TouchEvent*> queue_;
   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 {
@@ skipping 1750 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->tap_cancel());
   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->tap_cancel());
-  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 768 matching lines @@
       press1.time_stamp() + base::TimeDelta::FromMilliseconds(40));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move4);
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(-1, delegate->scroll_y());
 
   delegate->Reset();
 }
 
 }  // namespace test
 }  // namespace aura