highlight intermediate tabs

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_proxy.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/base/x/x11_util.h"
 #endif
@@ skipping 50 matching lines @@
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
 EventGenerator::EventGenerator(RootWindow* root_window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
-      grab_(false) {
+      grab_(false),
+      post_events_(false) {
 }
 
 EventGenerator::EventGenerator(RootWindow* root_window, const gfx::Point& point)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(point),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
-      grab_(false) {
+      grab_(false),
+      post_events_(false) {
 }
 
 EventGenerator::EventGenerator(RootWindow* root_window, Window* window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(CenterOfWindow(window)),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
-      grab_(false) {
+      grab_(false),
+      post_events_(false) {
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
-      grab_(false) {
+      grab_(false),
+      post_events_(false) {
 }
 
 EventGenerator::~EventGenerator() {
 }
 
 void EventGenerator::PressLeftButton() {
   PressButton(ui::EF_LEFT_MOUSE_BUTTON);
 }
 
 void EventGenerator::ReleaseLeftButton() {
@@ skipping 27 matching lines @@
 
   gfx::Vector2dF diff(point - current_location_);
   for (float i = 1; i <= count; i++) {
     gfx::Vector2dF step(diff);
     step.Scale(i / count);
     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
     if (!grab_)
       UpdateCurrentRootWindow(move_point);
     ConvertPointToTarget(current_root_window_, &move_point);
     ui::MouseEvent mouseev(event_type, move_point, move_point, flags_);
-    Dispatch(mouseev);
+    DispatchMouseEvent(mouseev);
   }
   current_location_ = point;
 }
 
 void EventGenerator::MoveMouseRelativeTo(const Window* window,
                                          const gfx::Point& point_in_parent) {
   gfx::Point point(point_in_parent);
   ConvertPointFromTarget(window, &point);
   MoveMouseTo(point);
 }
 
 void EventGenerator::DragMouseTo(const gfx::Point& point) {
   PressLeftButton();
   MoveMouseTo(point);
   ReleaseLeftButton();
 }
 
 void EventGenerator::MoveMouseToCenterOf(Window* window) {
   MoveMouseTo(CenterOfWindow(window));
 }
 
 void EventGenerator::PressTouch() {
   TestTouchEvent touchev(
       ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), flags_);
-  Dispatch(touchev);
+  DispatchTouchEvent(touchev);
 }
 
 void EventGenerator::MoveTouch(const gfx::Point& point) {
   TestTouchEvent touchev(ui::ET_TOUCH_MOVED, point, flags_);
-  Dispatch(touchev);
+  DispatchTouchEvent(touchev);
 
   current_location_ = point;
   if (!grab_)
     UpdateCurrentRootWindow(point);
 }
 
 void EventGenerator::ReleaseTouch() {
   TestTouchEvent touchev(
       ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(), flags_);
-  Dispatch(touchev);
+  DispatchTouchEvent(touchev);
 }
 
 void EventGenerator::PressMoveAndReleaseTouchTo(const gfx::Point& point) {
   PressTouch();
   MoveTouch(point);
   ReleaseTouch();
 }
 
 void EventGenerator::PressMoveAndReleaseTouchToCenterOf(Window* window) {
   PressMoveAndReleaseTouchTo(CenterOfWindow(window));
 }
 
 void EventGenerator::GestureTapAt(const gfx::Point& location) {
   const int kTouchId = 2;
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        location,
                        kTouchId,
                        ui::EventTimeForNow());
-  Dispatch(press);
+  DispatchTouchEvent(press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
-  Dispatch(release);
+  DispatchTouchEvent(release);
 }
 
 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
   const int kTouchId = 3;
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        location,
                        kTouchId,
                        ui::EventTimeForNow());
-  Dispatch(press);
+  DispatchTouchEvent(press);
 
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
-  Dispatch(release);
+  DispatchTouchEvent(release);
 }
 
 void EventGenerator::GestureScrollSequence(const gfx::Point& start,
                                            const gfx::Point& end,
                                            const base::TimeDelta& step_delay,
                                            int steps) {
   const int kTouchId = 5;
   base::TimeDelta timestamp = ui::EventTimeForNow();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
-  Dispatch(press);
+  DispatchTouchEvent(press);
 
   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);
     timestamp += step_delay;
     ui::TouchEvent move(ui::ET_TOUCH_MOVED, location, kTouchId, timestamp);
-    Dispatch(move);
+    DispatchTouchEvent(move);
   }
 
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
-  Dispatch(release);
+  DispatchTouchEvent(release);
 }
 
 void EventGenerator::GestureMultiFingerScroll(int count,
                                               const gfx::Point* start,
                                               int event_separation_time_ms,
                                               int steps,
                                               int move_x,
                                               int move_y) {
   const int kMaxTouchPoints = 10;
   gfx::Point points[kMaxTouchPoints];
   CHECK_LE(count, kMaxTouchPoints);
   CHECK_GT(steps, 0);
 
   int delta_x = move_x / steps;
   int delta_y = move_y / steps;
 
   base::TimeDelta press_time = ui::EventTimeForNow();
   for (int i = 0; i < count; ++i) {
     points[i] = start[i];
     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, points[i], i, press_time);
-    Dispatch(press);
+    DispatchTouchEvent(press);
   }
 
   for (int step = 0; step < steps; ++step) {
     base::TimeDelta move_time = press_time +
         base::TimeDelta::FromMilliseconds(event_separation_time_ms * step);
     for (int i = 0; i < count; ++i) {
       points[i].Offset(delta_x, delta_y);
       ui::TouchEvent move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
-      Dispatch(move);
+      DispatchTouchEvent(move);
     }
   }
 
   base::TimeDelta release_time = press_time +
       base::TimeDelta::FromMilliseconds(event_separation_time_ms * steps);
   for (int i = 0; i < count; ++i) {
     ui::TouchEvent release(
         ui::ET_TOUCH_RELEASED, points[i], i, release_time);
-    Dispatch(release);
+    DispatchTouchEvent(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(

[sky, 2013/01/22 18:05:01]

Should this use ui::EventTimeForNow ?

[DaveMoore, 2013/01/27 21:21:54]

Done.

+      base::TimeTicks::Now().ToInternalValue());
+  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
+                               start,
+                               timestamp,
+                               0,
+                               0,
+                               0,
+                               num_fingers);
+  DispatchScrollEvent(fling_cancel);
+
+  float dx = x_offset / steps;
+  float dy = y_offset / steps;
+  for (int i = 0; i < steps; ++i) {
+    timestamp += step_delay;
+    ui::ScrollEvent move(ui::ET_SCROLL,
+                         start,
+                         timestamp,
+                         0,
+                         dx,
+                         dy,
+                         num_fingers);
+    DispatchScrollEvent(move);
+  }
+
+  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
+                              start,
+                              timestamp,
+                              0,
+                              x_offset,
+                              y_offset,
+                              num_fingers);
+  DispatchScrollEvent(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 = base::TimeDelta::FromInternalValue(
+      base::TimeTicks::Now().ToInternalValue());
+  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
+                               start,
+                               timestamp,
+                               0,
+                               0,
+                               0,
+                               num_fingers);
+  DispatchScrollEvent(fling_cancel);
+
+  for (int i = 0; i < steps; ++i) {
+    timestamp += step_delay;
+    ui::ScrollEvent scroll(ui::ET_SCROLL,
+                           start,
+                           timestamp,
+                           0,
+                           offsets[i].x(),
+                           offsets[i].y(),
+                           num_fingers);
+    DispatchScrollEvent(scroll);
+  }
+
+  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
+                              start,
+                              timestamp,
+                              0,
+                              offsets[steps - 1].x(),
+                              offsets[steps - 1].y(),
+                              num_fingers);
+  DispatchScrollEvent(fling_start);
+}
+
 void EventGenerator::PressKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(true, key_code, flags);
 }
 
 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(false, key_code, flags);
 }
 
-void EventGenerator::Dispatch(ui::Event& event) {
-  switch (event.type()) {
-    case ui::ET_KEY_PRESSED:
-    case ui::ET_KEY_RELEASED:
-      current_root_window_->AsRootWindowHostDelegate()->OnHostKeyEvent(
-          static_cast<ui::KeyEvent*>(&event));
-      break;
-    case ui::ET_MOUSE_PRESSED:
-    case ui::ET_MOUSE_DRAGGED:
-    case ui::ET_MOUSE_RELEASED:
-    case ui::ET_MOUSE_MOVED:
-    case ui::ET_MOUSE_ENTERED:
-    case ui::ET_MOUSE_EXITED:
-    case ui::ET_MOUSEWHEEL:
-      current_root_window_->AsRootWindowHostDelegate()->OnHostMouseEvent(
-          static_cast<ui::MouseEvent*>(&event));
-      break;
-    case ui::ET_TOUCH_RELEASED:
-    case ui::ET_TOUCH_PRESSED:
-    case ui::ET_TOUCH_MOVED:
-    case ui::ET_TOUCH_STATIONARY:
-    case ui::ET_TOUCH_CANCELLED:
-      current_root_window_->AsRootWindowHostDelegate()->OnHostTouchEvent(
-          static_cast<ui::TouchEvent*>(&event));
-      break;
-    default:
-      NOTIMPLEMENTED();
-      break;
+void EventGenerator::DispatchKeyEvent(ui::KeyEvent& key_event) {
+  if (post_events_) {
+    if (pending_key_events_.empty()) {
+      base::MessageLoopProxy::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&EventGenerator::DoDispatchKeyEvent,
+                     base::Unretained(this)));
+    }
+    pending_key_events_.push_back(key_event);
+  } else {
+    current_root_window_->AsRootWindowHostDelegate()->OnHostKeyEvent(
+        &key_event);
   }
 }
 
+void EventGenerator::DispatchMouseEvent(ui::MouseEvent& mouse_event) {
+  if (post_events_) {
+    if (pending_mouse_events_.empty()) {
+      base::MessageLoopProxy::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&EventGenerator::DoDispatchMouseEvent,
+                     base::Unretained(this)));
+    }
+    pending_mouse_events_.push_back(mouse_event);
+  } else {
+    current_root_window_->AsRootWindowHostDelegate()->OnHostMouseEvent(
+        &mouse_event);
+  }
+}
+
+void EventGenerator::DispatchTouchEvent(ui::TouchEvent& touch_event) {
+  if (post_events_) {
+    if (pending_touch_events_.empty()) {
+      base::MessageLoopProxy::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&EventGenerator::DoDispatchTouchEvent,
+                     base::Unretained(this)));
+    }
+    pending_touch_events_.push_back(touch_event);
+  } else {
+    current_root_window_->AsRootWindowHostDelegate()->OnHostTouchEvent(
+        &touch_event);
+  }
+}
+
+void EventGenerator::DispatchScrollEvent(ui::ScrollEvent& scroll_event) {
+  if (post_events_) {
+    if (pending_scroll_events_.empty()) {
+      base::MessageLoopProxy::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&EventGenerator::DoDispatchScrollEvent,
+                     base::Unretained(this)));
+    }
+    pending_scroll_events_.push_back(scroll_event);
+  } else {
+    current_root_window_->AsRootWindowHostDelegate()->OnHostScrollEvent(
+        &scroll_event);
+  }
+}
+
 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);
+    DispatchKeyEvent(keyev);
     // On Windows, WM_KEYDOWN event is followed by WM_CHAR with a character
     // if the key event cooresponds to a real character.
     key_press = WM_CHAR;
     key_code = static_cast<ui::KeyboardCode>(character);
   }
   MSG native_event =
       { NULL, (is_press ? key_press : WM_KEYUP), key_code, 0 };
   TestKeyEvent keyev(native_event, flags, key_press == WM_CHAR);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
 #if defined(USE_X11)
   scoped_ptr<XEvent> native_event(new XEvent);
   ui::InitXKeyEventForTesting(type, key_code, flags, native_event.get());
   TestKeyEvent keyev(native_event.get(), flags, false);
 #else
   ui::KeyEvent keyev(type, key_code, flags, false);
 #endif  // USE_X11
 #endif  // OS_WIN
-  Dispatch(keyev);
+  DispatchKeyEvent(keyev);
 }
 
 void EventGenerator::UpdateCurrentRootWindow(const gfx::Point& point) {
   current_root_window_ = delegate_->GetRootWindowAt(point);
 }
 
 void EventGenerator::PressButton(int flag) {
   if (!(flags_ & flag)) {
     flags_ |= flag;
     grab_ = flags_ & kAllButtonMask;
     gfx::Point location = GetLocationInCurrentRoot();
     ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location, flags_);
-    Dispatch(mouseev);
+    DispatchMouseEvent(mouseev);
   }
 }
 
 void EventGenerator::ReleaseButton(int flag) {
   if (flags_ & flag) {
     gfx::Point location = GetLocationInCurrentRoot();
     ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, location,
                            location, flags_);
-    Dispatch(mouseev);
+    DispatchMouseEvent(mouseev);
     flags_ ^= flag;
   }
   grab_ = flags_ & kAllButtonMask;
 }
 
 void EventGenerator::ConvertPointFromTarget(const aura::Window* target,
                                             gfx::Point* point) const {
   DCHECK(point);
   aura::client::ScreenPositionClient* client =
       delegate_->GetScreenPositionClient(target);
@@ skipping 19 matching lines @@
   ConvertPointToTarget(current_root_window_, &p);
   return p;
 }
 
 gfx::Point EventGenerator::CenterOfWindow(const Window* window) const {
   gfx::Point center = gfx::Rect(window->bounds().size()).CenterPoint();
   ConvertPointFromTarget(window, &center);
   return center;
 }
 
+void EventGenerator::DoDispatchKeyEvent() {

[sky, 2013/01/22 18:05:01]

How about a single member for std::list<Event*> with one DispatchEvent and
DoDispatchEvent members? Seems like it would be a lot less code.

[DaveMoore, 2013/01/27 21:21:54]

rewritten to minimize copied code.
On 2013/01/22 18:05:01, sky wrote:

+  DCHECK(!pending_key_events_.empty());
+  ui::KeyEvent key_event = pending_key_events_.front();
+  current_root_window_->AsRootWindowHostDelegate()->OnHostKeyEvent(&key_event);
+  pending_key_events_.pop_front();
+  if (!pending_key_events_.empty()) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventGenerator::DoDispatchKeyEvent,
+                   base::Unretained(this)));
+  }
+}
+
+void EventGenerator::DoDispatchMouseEvent() {
+  DCHECK(!pending_mouse_events_.empty());
+  ui::MouseEvent mouse_event = pending_mouse_events_.front();
+  current_root_window_->AsRootWindowHostDelegate()->OnHostMouseEvent(
+      &mouse_event);
+  pending_mouse_events_.pop_front();
+  if (!pending_mouse_events_.empty()) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventGenerator::DoDispatchMouseEvent,
+                   base::Unretained(this)));
+  }
+}
+
+void EventGenerator::DoDispatchTouchEvent() {
+  DCHECK(!pending_touch_events_.empty());
+  ui::TouchEvent touch_event = pending_touch_events_.front();
+  current_root_window_->AsRootWindowHostDelegate()->OnHostTouchEvent(
+      &touch_event);
+  pending_touch_events_.pop_front();
+  if (!pending_touch_events_.empty()) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventGenerator::DoDispatchTouchEvent,
+                   base::Unretained(this)));
+  }
+}
+
+void EventGenerator::DoDispatchScrollEvent() {
+  DCHECK(!pending_scroll_events_.empty());
+  ui::ScrollEvent scroll_event = pending_scroll_events_.front();
+  current_root_window_->AsRootWindowHostDelegate()->OnHostScrollEvent(
+      &scroll_event);
+  pending_scroll_events_.pop_front();
+  if (!pending_scroll_events_.empty()) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventGenerator::DoDispatchScrollEvent,
+                   base::Unretained(this)));
+  }
+}
+
 }  // namespace test
 }  // namespace aura