Expose native, desktop and mobile gesture detection defaults

ui/aura/window_event_dispatcher_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 "ui/aura/window_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 431 matching lines @@
 namespace {
 
 // FilterFilter that tracks the types of events it's seen.
 class EventFilterRecorder : public ui::EventHandler {
  public:
   typedef std::vector<ui::EventType> Events;
   typedef std::vector<gfx::Point> EventLocations;
   typedef std::vector<int> EventFlags;
 
   EventFilterRecorder()
-      : wait_until_event_(ui::ET_UNKNOWN) {
+      : wait_until_event_(ui::ET_UNKNOWN),
+        last_touch_may_cause_scrolling_(false) {
   }
 
   const Events& events() const { return events_; }
 
   const EventLocations& mouse_locations() const { return mouse_locations_; }
   gfx::Point mouse_location(int i) const { return mouse_locations_[i]; }
   const EventLocations& touch_locations() const { return touch_locations_; }
   const EventLocations& gesture_locations() const { return gesture_locations_; }
   const EventFlags& mouse_event_flags() const { return mouse_event_flags_; }
 
   void WaitUntilReceivedEvent(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   Events GetAndResetEvents() {
     Events events = events_;
     Reset();
     return events;
   }
 
   void Reset() {
     events_.clear();
     mouse_locations_.clear();
     touch_locations_.clear();
     gesture_locations_.clear();
     mouse_event_flags_.clear();
+    last_touch_may_cause_scrolling_ = false;
   }
 
   // ui::EventHandler overrides:
   void OnEvent(ui::Event* event) override {
     ui::EventHandler::OnEvent(event);
     events_.push_back(event->type());
     if (wait_until_event_ == event->type() && run_loop_) {
       run_loop_->Quit();
       wait_until_event_ = ui::ET_UNKNOWN;
     }
   }
 
   void OnMouseEvent(ui::MouseEvent* event) override {
     mouse_locations_.push_back(event->location());
     mouse_event_flags_.push_back(event->flags());
   }
 
   void OnTouchEvent(ui::TouchEvent* event) override {
     touch_locations_.push_back(event->location());
+    last_touch_may_cause_scrolling_ = event->may_cause_scrolling();
   }
 
   void OnGestureEvent(ui::GestureEvent* event) override {
     gesture_locations_.push_back(event->location());
   }
 
   bool HasReceivedEvent(ui::EventType type) {
     return std::find(events_.begin(), events_.end(), type) != events_.end();
   }
 
+  bool LastTouchMayCauseScrolling() const {
+    return last_touch_may_cause_scrolling_;
+  }
+
  private:
   scoped_ptr<base::RunLoop> run_loop_;
   ui::EventType wait_until_event_;
 
   Events events_;
   EventLocations mouse_locations_;
   EventLocations touch_locations_;
   EventLocations gesture_locations_;
   EventFlags mouse_event_flags_;
+  bool last_touch_may_cause_scrolling_;
 
   DISALLOW_COPY_AND_ASSIGN(EventFilterRecorder);
 };
 
 // Converts an EventType to a string.
 std::string EventTypeToString(ui::EventType type) {
   switch (type) {
     case ui::ET_TOUCH_RELEASED:
       return "TOUCH_RELEASED";
 
@@ skipping 1842 matching lines @@
 
   ASSERT_EQ(1u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.touch_locations()[0].ToString());
 
   ASSERT_EQ(2u, recorder.gesture_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.gesture_locations()[0].ToString());
 }
 
+// Tests that a scroll-generating touch-event is marked as such.
+TEST_F(WindowEventDispatcherTest, TouchMovesMarkedWhenCausingScroll) {
+  EventFilterRecorder recorder;
+  root_window()->AddPreTargetHandler(&recorder);
+
+  const gfx::Point location(20, 20);
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, location, 0, ui::EventTimeForNow());
+  DispatchEventUsingWindowDispatcher(&press);
+  EXPECT_FALSE(recorder.LastTouchMayCauseScrolling());
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_PRESSED));
+  recorder.Reset();
+
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED,
+                      location + gfx::Vector2d(100, 100),
+                      0,
+                      ui::EventTimeForNow());
+  DispatchEventUsingWindowDispatcher(&move);
+  EXPECT_TRUE(recorder.LastTouchMayCauseScrolling());
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_MOVED));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_BEGIN));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_UPDATE));
+  recorder.Reset();
+
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED,
+                       location + gfx::Vector2d(200, 200),
+                       0,
+                       ui::EventTimeForNow());
+  DispatchEventUsingWindowDispatcher(&move2);
+  EXPECT_TRUE(recorder.LastTouchMayCauseScrolling());
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_MOVED));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_UPDATE));
+  recorder.Reset();
+
+  // Delay the release to avoid fling generation.
+  ui::TouchEvent release(
+      ui::ET_TOUCH_RELEASED,
+      location + gfx::Vector2dF(200, 200),
+      0,
+      ui::EventTimeForNow() + base::TimeDelta::FromSeconds(1));
+  DispatchEventUsingWindowDispatcher(&release);
+  EXPECT_FALSE(recorder.LastTouchMayCauseScrolling());
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_RELEASED));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_END));
+
+  root_window()->RemovePreTargetHandler(&recorder);
+}
 }  // namespace aura