Support double-tap to click in touch accessibility controller.

ui/aura/test/event_generator.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/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 51 matching lines @@
       : KeyEvent(native_event, is_char) {
     set_flags(flags);
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int touch_id,
-                 int flags)
-      : TouchEvent(type, root_location, flags, touch_id, ui::EventTimeForNow(),
+                 int flags,
+                 base::TimeDelta timestamp)
+      : TouchEvent(type, root_location, flags, touch_id, timestamp,
                    1.0f, 1.0f, 1.0f, 1.0f) {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
 EventGenerator::EventGenerator(Window* root_window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
-      async_(false) {
+      async_(false),
+      use_simulated_time_(false) {
 }
 
 EventGenerator::EventGenerator(Window* root_window, const gfx::Point& point)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(point),
       current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
-      async_(false) {
+      async_(false),
+      use_simulated_time_(false) {
 }
 
 EventGenerator::EventGenerator(Window* root_window, Window* window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(CenterOfWindow(window)),
       current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
-      async_(false) {
+      async_(false),
+      use_simulated_time_(false) {
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
       current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
-      async_(false) {
+      async_(false),
+      use_simulated_time_(false) {
 }
 
 EventGenerator::~EventGenerator() {
   for (std::list<ui::Event*>::iterator i = pending_events_.begin();
       i != pending_events_.end(); ++i)
     delete *i;
   pending_events_.clear();
 }
 
 void EventGenerator::PressLeftButton() {
@@ skipping 85 matching lines @@
 void EventGenerator::MoveMouseToCenterOf(Window* window) {
   MoveMouseTo(CenterOfWindow(window));
 }
 
 void EventGenerator::PressTouch() {
   PressTouchId(0);
 }
 
 void EventGenerator::PressTouchId(int touch_id) {
   TestTouchEvent touchev(
-      ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), touch_id, flags_);
+      ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), touch_id, flags_,
+      Now());
   Dispatch(&touchev);
 }
 
 void EventGenerator::MoveTouch(const gfx::Point& point) {
   MoveTouchId(point, 0);
 }
 
 void EventGenerator::MoveTouchId(const gfx::Point& point, int touch_id) {
   current_location_ = point;
   TestTouchEvent touchev(
-      ui::ET_TOUCH_MOVED, GetLocationInCurrentRoot(), touch_id, flags_);
+      ui::ET_TOUCH_MOVED, GetLocationInCurrentRoot(), touch_id, flags_, Now());
   Dispatch(&touchev);
 
   if (!grab_)
     UpdateCurrentDispatcher(point);
 }
 
 void EventGenerator::ReleaseTouch() {
   ReleaseTouchId(0);
 }
 
 void EventGenerator::ReleaseTouchId(int touch_id) {
   TestTouchEvent touchev(
-      ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(), touch_id, flags_);
+      ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(), touch_id, flags_,
+      Now());
   Dispatch(&touchev);
 }
 
 void EventGenerator::PressMoveAndReleaseTouchTo(const gfx::Point& point) {
   PressTouch();
   MoveTouch(point);
   ReleaseTouch();
 }
 
 void EventGenerator::PressMoveAndReleaseTouchToCenterOf(Window* window) {
   PressMoveAndReleaseTouchTo(CenterOfWindow(window));
 }
 
 void EventGenerator::GestureEdgeSwipe() {
   ui::GestureEvent gesture(
       ui::ET_GESTURE_WIN8_EDGE_SWIPE,
       0,
       0,
       0,
-      ui::EventTimeForNow(),
+      Now(),
       ui::GestureEventDetails(ui::ET_GESTURE_WIN8_EDGE_SWIPE, 0, 0),
       0);
   Dispatch(&gesture);
 }
 
 void EventGenerator::GestureTapAt(const gfx::Point& location) {
   const int kTouchId = 2;
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        location,
                        kTouchId,
-                       ui::EventTimeForNow());
+                       Now());
   Dispatch(&press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
   Dispatch(&release);
 }
 
 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
   const int kTouchId = 3;
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        location,
                        kTouchId,
-                       ui::EventTimeForNow());
+                       Now());
   Dispatch(&press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
   Dispatch(&release);
 }
 
 void EventGenerator::GestureScrollSequence(const gfx::Point& start,
                                            const gfx::Point& end,
                                            const base::TimeDelta& step_delay,
                                            int steps) {
   GestureScrollSequenceWithCallback(start, end, step_delay, steps,
                                     base::Bind(&DummyCallback));
 }
 
 void EventGenerator::GestureScrollSequenceWithCallback(
     const gfx::Point& start,
     const gfx::Point& end,
     const base::TimeDelta& step_delay,
     int steps,
     const ScrollStepCallback& callback) {
   const int kTouchId = 5;
-  base::TimeDelta timestamp = ui::EventTimeForNow();
+  base::TimeDelta timestamp = Now();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
   Dispatch(&press);
 
   callback.Run(ui::ET_GESTURE_SCROLL_BEGIN, gfx::Vector2dF());
 
   int dx = (end.x() - start.x()) / steps;
   int dy = (end.y() - start.y()) / steps;
   gfx::Point location = start;
   for (int i = 0; i < steps; ++i) {
     location.Offset(dx, dy);
@@ skipping 34 matching lines @@
   CHECK_LE(count, kMaxTouchPoints);
   CHECK_GT(steps, 0);
 
   int delta_x = move_x / steps;
   int delta_y = move_y / steps;
 
   for (int i = 0; i < count; ++i) {
     points[i] = start[i];
   }
 
-  base::TimeDelta press_time_first = ui::EventTimeForNow();
+  base::TimeDelta press_time_first = Now();
   base::TimeDelta press_time[kMaxTouchPoints];
   bool pressed[kMaxTouchPoints];
   for (int i = 0; i < count; ++i) {
     pressed[i] = false;
     press_time[i] = press_time_first +
         base::TimeDelta::FromMilliseconds(delay_adding_finger_ms[i]);
   }
 
   int last_id = 0;
   for (int step = 0; step < steps; ++step) {
@@ skipping 29 matching lines @@
     Dispatch(&release);
   }
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     float x_offset,
                                     float y_offset,
                                     int steps,
                                     int num_fingers) {
-  base::TimeDelta timestamp = base::TimeDelta::FromInternalValue(
-      base::TimeTicks::Now().ToInternalValue());
+  base::TimeDelta timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   float dx = x_offset / steps;
@@ skipping 18 matching lines @@
                               x_offset, y_offset,
                               num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     const std::vector<gfx::Point>& offsets,
                                     int num_fingers) {
   int steps = offsets.size();
-  base::TimeDelta timestamp = ui::EventTimeForNow();
+  base::TimeDelta timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   for (int i = 0; i < steps; ++i) {
@@ skipping 23 matching lines @@
 }
 
 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(false, key_code, flags);
 }
 
 void EventGenerator::Dispatch(ui::Event* event) {
   DoDispatchEvent(event, async_);
 }
 
+void EventGenerator::UseSimulatedTime() {
+  use_simulated_time_ = true;
+}
+
+void EventGenerator::AdvanceSimulatedTimeBy(base::TimeDelta delta) {
+  simulated_time_ += delta;
+}
+
+base::TimeDelta EventGenerator::Now() {
+  if (use_simulated_time_)
+    return simulated_time_;
+  return ui::EventTimeForNow();
+}
+
 void EventGenerator::DispatchKeyEvent(bool is_press,
                                       ui::KeyboardCode key_code,
                                       int flags) {
 #if defined(OS_WIN)
   UINT key_press = WM_KEYDOWN;
   uint16 character = ui::GetCharacterFromKeyCode(key_code, flags);
   if (is_press && character) {
     MSG native_event = { NULL, WM_KEYDOWN, key_code, 0 };
     TestKeyEvent keyev(native_event, flags, false);
     Dispatch(&keyev);
@@ skipping 117 matching lines @@
   pending_events_.pop_front();
   delete event;
   if (!pending_events_.empty()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&EventGenerator::DispatchNextPendingEvent,
                    base::Unretained(this)));
   }
 }
 
-
 }  // namespace test
 }  // namespace aura