Home | History | Annotate | Download | only in test 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/events/test/event_generator.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/location.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/single_thread_task_runner.h"
     11 #include "base/thread_task_runner_handle.h"
     12 #include "base/time/default_tick_clock.h"
     13 #include "ui/events/event.h"
     14 #include "ui/events/event_source.h"
     15 #include "ui/events/event_utils.h"
     16 #include "ui/events/test/events_test_utils.h"
     17 #include "ui/gfx/vector2d_conversions.h"
     18 
     19 #if defined(USE_X11)
     20 #include <X11/Xlib.h>
     21 #include "ui/events/test/events_test_utils_x11.h"
     22 #endif
     23 
     24 #if defined(OS_WIN)
     25 #include "ui/events/keycodes/keyboard_code_conversion.h"
     26 #endif
     27 
     28 namespace ui {
     29 namespace test {
     30 namespace {
     31 
     32 void DummyCallback(EventType, const gfx::Vector2dF&) {
     33 }
     34 
     35 class TestKeyEvent : public ui::KeyEvent {
     36  public:
     37   TestKeyEvent(const base::NativeEvent& native_event, int flags)
     38       : KeyEvent(native_event) {
     39     set_flags(flags);
     40   }
     41 };
     42 
     43 class TestTouchEvent : public ui::TouchEvent {
     44  public:
     45   TestTouchEvent(ui::EventType type,
     46                  const gfx::Point& root_location,
     47                  int touch_id,
     48                  int flags,
     49                  base::TimeDelta timestamp)
     50       : TouchEvent(type, root_location, flags, touch_id, timestamp,
     51                    1.0f, 1.0f, 0.0f, 0.0f) {
     52   }
     53 
     54  private:
     55   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
     56 };
     57 
     58 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
     59 
     60 }  // namespace
     61 
     62 EventGeneratorDelegate* EventGenerator::default_delegate = NULL;
     63 
     64 EventGenerator::EventGenerator(gfx::NativeWindow root_window)
     65     : current_target_(NULL),
     66       flags_(0),
     67       grab_(false),
     68       async_(false),
     69       tick_clock_(new base::DefaultTickClock()) {
     70   Init(root_window, NULL);
     71 }
     72 
     73 EventGenerator::EventGenerator(gfx::NativeWindow root_window,
     74                                const gfx::Point& point)
     75     : current_location_(point),
     76       current_target_(NULL),
     77       flags_(0),
     78       grab_(false),
     79       async_(false),
     80       tick_clock_(new base::DefaultTickClock()) {
     81   Init(root_window, NULL);
     82 }
     83 
     84 EventGenerator::EventGenerator(gfx::NativeWindow root_window,
     85                                gfx::NativeWindow window)
     86     : current_target_(NULL),
     87       flags_(0),
     88       grab_(false),
     89       async_(false),
     90       tick_clock_(new base::DefaultTickClock()) {
     91   Init(root_window, window);
     92 }
     93 
     94 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     95     : delegate_(delegate),
     96       current_target_(NULL),
     97       flags_(0),
     98       grab_(false),
     99       async_(false),
    100       tick_clock_(new base::DefaultTickClock()) {
    101   Init(NULL, NULL);
    102 }
    103 
    104 EventGenerator::~EventGenerator() {
    105   for (std::list<ui::Event*>::iterator i = pending_events_.begin();
    106       i != pending_events_.end(); ++i)
    107     delete *i;
    108   pending_events_.clear();
    109   delegate()->SetContext(NULL, NULL, NULL);
    110 }
    111 
    112 void EventGenerator::PressLeftButton() {
    113   PressButton(ui::EF_LEFT_MOUSE_BUTTON);
    114 }
    115 
    116 void EventGenerator::ReleaseLeftButton() {
    117   ReleaseButton(ui::EF_LEFT_MOUSE_BUTTON);
    118 }
    119 
    120 void EventGenerator::ClickLeftButton() {
    121   PressLeftButton();
    122   ReleaseLeftButton();
    123 }
    124 
    125 void EventGenerator::DoubleClickLeftButton() {
    126   flags_ |= ui::EF_IS_DOUBLE_CLICK;
    127   PressLeftButton();
    128   flags_ ^= ui::EF_IS_DOUBLE_CLICK;
    129   ReleaseLeftButton();
    130 }
    131 
    132 void EventGenerator::PressRightButton() {
    133   PressButton(ui::EF_RIGHT_MOUSE_BUTTON);
    134 }
    135 
    136 void EventGenerator::ReleaseRightButton() {
    137   ReleaseButton(ui::EF_RIGHT_MOUSE_BUTTON);
    138 }
    139 
    140 void EventGenerator::MoveMouseWheel(int delta_x, int delta_y) {
    141   gfx::Point location = GetLocationInCurrentRoot();
    142   ui::MouseEvent mouseev(ui::ET_MOUSEWHEEL, location, location, flags_, 0);
    143   ui::MouseWheelEvent wheelev(mouseev, delta_x, delta_y);
    144   Dispatch(&wheelev);
    145 }
    146 
    147 void EventGenerator::SendMouseExit() {
    148   gfx::Point exit_location(current_location_);
    149   delegate()->ConvertPointToTarget(current_target_, &exit_location);
    150   ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, exit_location, exit_location,
    151                          flags_, 0);
    152   Dispatch(&mouseev);
    153 }
    154 
    155 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
    156   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
    157       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
    158   ui::MouseEvent mouseev(event_type, point_in_host, point_in_host, flags_, 0);
    159   Dispatch(&mouseev);
    160 
    161   current_location_ = point_in_host;
    162   delegate()->ConvertPointFromHost(current_target_, &current_location_);
    163 }
    164 
    165 void EventGenerator::MoveMouseTo(const gfx::Point& point_in_screen,
    166                                  int count) {
    167   DCHECK_GT(count, 0);
    168   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
    169       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
    170 
    171   gfx::Vector2dF diff(point_in_screen - current_location_);
    172   for (float i = 1; i <= count; i++) {
    173     gfx::Vector2dF step(diff);
    174     step.Scale(i / count);
    175     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
    176     if (!grab_)
    177       UpdateCurrentDispatcher(move_point);
    178     delegate()->ConvertPointToTarget(current_target_, &move_point);
    179     ui::MouseEvent mouseev(event_type, move_point, move_point, flags_, 0);
    180     Dispatch(&mouseev);
    181   }
    182   current_location_ = point_in_screen;
    183 }
    184 
    185 void EventGenerator::MoveMouseRelativeTo(const EventTarget* window,
    186                                          const gfx::Point& point_in_parent) {
    187   gfx::Point point(point_in_parent);
    188   delegate()->ConvertPointFromTarget(window, &point);
    189   MoveMouseTo(point);
    190 }
    191 
    192 void EventGenerator::DragMouseTo(const gfx::Point& point) {
    193   PressLeftButton();
    194   MoveMouseTo(point);
    195   ReleaseLeftButton();
    196 }
    197 
    198 void EventGenerator::MoveMouseToCenterOf(EventTarget* window) {
    199   MoveMouseTo(CenterOfWindow(window));
    200 }
    201 
    202 void EventGenerator::PressTouch() {
    203   PressTouchId(0);
    204 }
    205 
    206 void EventGenerator::PressTouchId(int touch_id) {
    207   TestTouchEvent touchev(
    208       ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), touch_id, flags_,
    209       Now());
    210   Dispatch(&touchev);
    211 }
    212 
    213 void EventGenerator::MoveTouch(const gfx::Point& point) {
    214   MoveTouchId(point, 0);
    215 }
    216 
    217 void EventGenerator::MoveTouchId(const gfx::Point& point, int touch_id) {
    218   current_location_ = point;
    219   TestTouchEvent touchev(
    220       ui::ET_TOUCH_MOVED, GetLocationInCurrentRoot(), touch_id, flags_,
    221       Now());
    222   Dispatch(&touchev);
    223 
    224   if (!grab_)
    225     UpdateCurrentDispatcher(point);
    226 }
    227 
    228 void EventGenerator::ReleaseTouch() {
    229   ReleaseTouchId(0);
    230 }
    231 
    232 void EventGenerator::ReleaseTouchId(int touch_id) {
    233   TestTouchEvent touchev(
    234       ui::ET_TOUCH_RELEASED, GetLocationInCurrentRoot(), touch_id, flags_,
    235       Now());
    236   Dispatch(&touchev);
    237 }
    238 
    239 void EventGenerator::PressMoveAndReleaseTouchTo(const gfx::Point& point) {
    240   PressTouch();
    241   MoveTouch(point);
    242   ReleaseTouch();
    243 }
    244 
    245 void EventGenerator::PressMoveAndReleaseTouchToCenterOf(EventTarget* window) {
    246   PressMoveAndReleaseTouchTo(CenterOfWindow(window));
    247 }
    248 
    249 void EventGenerator::GestureEdgeSwipe() {
    250   ui::GestureEvent gesture(
    251       0, 0, 0, Now(), ui::GestureEventDetails(ui::ET_GESTURE_WIN8_EDGE_SWIPE));
    252   Dispatch(&gesture);
    253 }
    254 
    255 void EventGenerator::GestureTapAt(const gfx::Point& location) {
    256   const int kTouchId = 2;
    257   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
    258                        location,
    259                        kTouchId,
    260                        Now());
    261   Dispatch(&press);
    262 
    263   ui::TouchEvent release(
    264       ui::ET_TOUCH_RELEASED, location, kTouchId,
    265       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
    266   Dispatch(&release);
    267 }
    268 
    269 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
    270   const int kTouchId = 3;
    271   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
    272                        location,
    273                        kTouchId,
    274                        Now());
    275   Dispatch(&press);
    276 
    277   ui::TouchEvent release(
    278       ui::ET_TOUCH_RELEASED, location, kTouchId,
    279       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
    280   Dispatch(&release);
    281 }
    282 
    283 void EventGenerator::GestureScrollSequence(const gfx::Point& start,
    284                                            const gfx::Point& end,
    285                                            const base::TimeDelta& step_delay,
    286                                            int steps) {
    287   GestureScrollSequenceWithCallback(start, end, step_delay, steps,
    288                                     base::Bind(&DummyCallback));
    289 }
    290 
    291 void EventGenerator::GestureScrollSequenceWithCallback(
    292     const gfx::Point& start,
    293     const gfx::Point& end,
    294     const base::TimeDelta& step_delay,
    295     int steps,
    296     const ScrollStepCallback& callback) {
    297   const int kTouchId = 5;
    298   base::TimeDelta timestamp = Now();
    299   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
    300   Dispatch(&press);
    301 
    302   callback.Run(ui::ET_GESTURE_SCROLL_BEGIN, gfx::Vector2dF());
    303 
    304   int dx = (end.x() - start.x()) / steps;
    305   int dy = (end.y() - start.y()) / steps;
    306   gfx::Point location = start;
    307   for (int i = 0; i < steps; ++i) {
    308     location.Offset(dx, dy);
    309     timestamp += step_delay;
    310     ui::TouchEvent move(ui::ET_TOUCH_MOVED, location, kTouchId, timestamp);
    311     Dispatch(&move);
    312     callback.Run(ui::ET_GESTURE_SCROLL_UPDATE, gfx::Vector2dF(dx, dy));
    313   }
    314 
    315   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
    316   Dispatch(&release);
    317 
    318   callback.Run(ui::ET_GESTURE_SCROLL_END, gfx::Vector2dF());
    319 }
    320 
    321 void EventGenerator::GestureMultiFingerScroll(int count,
    322                                               const gfx::Point start[],
    323                                               int event_separation_time_ms,
    324                                               int steps,
    325                                               int move_x,
    326                                               int move_y) {
    327   const int kMaxTouchPoints = 10;
    328   int delays[kMaxTouchPoints] = { 0 };
    329   GestureMultiFingerScrollWithDelays(
    330       count, start, delays, event_separation_time_ms, steps, move_x, move_y);
    331 }
    332 
    333 void EventGenerator::GestureMultiFingerScrollWithDelays(
    334     int count,
    335     const gfx::Point start[],
    336     const int delay_adding_finger_ms[],
    337     int event_separation_time_ms,
    338     int steps,
    339     int move_x,
    340     int move_y) {
    341   const int kMaxTouchPoints = 10;
    342   gfx::Point points[kMaxTouchPoints];
    343   CHECK_LE(count, kMaxTouchPoints);
    344   CHECK_GT(steps, 0);
    345 
    346   int delta_x = move_x / steps;
    347   int delta_y = move_y / steps;
    348 
    349   for (int i = 0; i < count; ++i) {
    350     points[i] = start[i];
    351   }
    352 
    353   base::TimeDelta press_time_first = Now();
    354   base::TimeDelta press_time[kMaxTouchPoints];
    355   bool pressed[kMaxTouchPoints];
    356   for (int i = 0; i < count; ++i) {
    357     pressed[i] = false;
    358     press_time[i] = press_time_first +
    359         base::TimeDelta::FromMilliseconds(delay_adding_finger_ms[i]);
    360   }
    361 
    362   int last_id = 0;
    363   for (int step = 0; step < steps; ++step) {
    364     base::TimeDelta move_time = press_time_first +
    365         base::TimeDelta::FromMilliseconds(event_separation_time_ms * step);
    366 
    367     while (last_id < count &&
    368            !pressed[last_id] &&
    369            move_time >= press_time[last_id]) {
    370       ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
    371                            points[last_id],
    372                            last_id,
    373                            press_time[last_id]);
    374       Dispatch(&press);
    375       pressed[last_id] = true;
    376       last_id++;
    377     }
    378 
    379     for (int i = 0; i < count; ++i) {
    380       points[i].Offset(delta_x, delta_y);
    381       if (i >= last_id)
    382         continue;
    383       ui::TouchEvent move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
    384       Dispatch(&move);
    385     }
    386   }
    387 
    388   base::TimeDelta release_time = press_time_first +
    389       base::TimeDelta::FromMilliseconds(event_separation_time_ms * steps);
    390   for (int i = 0; i < last_id; ++i) {
    391     ui::TouchEvent release(
    392         ui::ET_TOUCH_RELEASED, points[i], i, release_time);
    393     Dispatch(&release);
    394   }
    395 }
    396 
    397 void EventGenerator::ScrollSequence(const gfx::Point& start,
    398                                     const base::TimeDelta& step_delay,
    399                                     float x_offset,
    400                                     float y_offset,
    401                                     int steps,
    402                                     int num_fingers) {
    403   base::TimeDelta timestamp = Now();
    404   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
    405                                start,
    406                                timestamp,
    407                                0,
    408                                0, 0,
    409                                0, 0,
    410                                num_fingers);
    411   Dispatch(&fling_cancel);
    412 
    413   float dx = x_offset / steps;
    414   float dy = y_offset / steps;
    415   for (int i = 0; i < steps; ++i) {
    416     timestamp += step_delay;
    417     ui::ScrollEvent move(ui::ET_SCROLL,
    418                          start,
    419                          timestamp,
    420                          0,
    421                          dx, dy,
    422                          dx, dy,
    423                          num_fingers);
    424     Dispatch(&move);
    425   }
    426 
    427   ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
    428                               start,
    429                               timestamp,
    430                               0,
    431                               x_offset, y_offset,
    432                               x_offset, y_offset,
    433                               num_fingers);
    434   Dispatch(&fling_start);
    435 }
    436 
    437 void EventGenerator::ScrollSequence(const gfx::Point& start,
    438                                     const base::TimeDelta& step_delay,
    439                                     const std::vector<gfx::Point>& offsets,
    440                                     int num_fingers) {
    441   size_t steps = offsets.size();
    442   base::TimeDelta timestamp = Now();
    443   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
    444                                start,
    445                                timestamp,
    446                                0,
    447                                0, 0,
    448                                0, 0,
    449                                num_fingers);
    450   Dispatch(&fling_cancel);
    451 
    452   for (size_t i = 0; i < steps; ++i) {
    453     timestamp += step_delay;
    454     ui::ScrollEvent scroll(ui::ET_SCROLL,
    455                            start,
    456                            timestamp,
    457                            0,
    458                            offsets[i].x(), offsets[i].y(),
    459                            offsets[i].x(), offsets[i].y(),
    460                            num_fingers);
    461     Dispatch(&scroll);
    462   }
    463 
    464   ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
    465                               start,
    466                               timestamp,
    467                               0,
    468                               offsets[steps - 1].x(), offsets[steps - 1].y(),
    469                               offsets[steps - 1].x(), offsets[steps - 1].y(),
    470                               num_fingers);
    471   Dispatch(&fling_start);
    472 }
    473 
    474 void EventGenerator::PressKey(ui::KeyboardCode key_code, int flags) {
    475   DispatchKeyEvent(true, key_code, flags);
    476 }
    477 
    478 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
    479   DispatchKeyEvent(false, key_code, flags);
    480 }
    481 
    482 void EventGenerator::Dispatch(ui::Event* event) {
    483   DoDispatchEvent(event, async_);
    484 }
    485 
    486 void EventGenerator::SetTickClock(scoped_ptr<base::TickClock> tick_clock) {
    487   tick_clock_ = tick_clock.Pass();
    488 }
    489 
    490 base::TimeDelta EventGenerator::Now() {
    491   // This is the same as what EventTimeForNow() does, but here we do it
    492   // with a tick clock that can be replaced with a simulated clock for tests.
    493   return base::TimeDelta::FromInternalValue(
    494       tick_clock_->NowTicks().ToInternalValue());
    495 }
    496 
    497 void EventGenerator::Init(gfx::NativeWindow root_window,
    498                           gfx::NativeWindow window_context) {
    499   delegate()->SetContext(this, root_window, window_context);
    500   if (window_context)
    501     current_location_ = delegate()->CenterOfWindow(window_context);
    502   current_target_ = delegate()->GetTargetAt(current_location_);
    503 }
    504 
    505 void EventGenerator::DispatchKeyEvent(bool is_press,
    506                                       ui::KeyboardCode key_code,
    507                                       int flags) {
    508 #if defined(OS_WIN)
    509   UINT key_press = WM_KEYDOWN;
    510   uint16 character = ui::GetCharacterFromKeyCode(key_code, flags);
    511   if (is_press && character) {
    512     MSG native_event = { NULL, WM_KEYDOWN, key_code, 0 };
    513     TestKeyEvent keyev(native_event, flags);
    514     Dispatch(&keyev);
    515     // On Windows, WM_KEYDOWN event is followed by WM_CHAR with a character
    516     // if the key event cooresponds to a real character.
    517     key_press = WM_CHAR;
    518     key_code = static_cast<ui::KeyboardCode>(character);
    519   }
    520   MSG native_event =
    521       { NULL, (is_press ? key_press : WM_KEYUP), key_code, 0 };
    522   TestKeyEvent keyev(native_event, flags);
    523 #elif defined(USE_X11)
    524   ui::ScopedXI2Event xevent;
    525   xevent.InitKeyEvent(is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
    526                       key_code,
    527                       flags);
    528   ui::KeyEvent keyev(xevent);
    529 #else
    530   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
    531   ui::KeyEvent keyev(type, key_code, flags);
    532 #endif  // OS_WIN
    533   Dispatch(&keyev);
    534 }
    535 
    536 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
    537   current_target_ = delegate()->GetTargetAt(point);
    538 }
    539 
    540 void EventGenerator::PressButton(int flag) {
    541   if (!(flags_ & flag)) {
    542     flags_ |= flag;
    543     grab_ = (flags_ & kAllButtonMask) != 0;
    544     gfx::Point location = GetLocationInCurrentRoot();
    545     ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location, flags_,
    546                            flag);
    547     Dispatch(&mouseev);
    548   }
    549 }
    550 
    551 void EventGenerator::ReleaseButton(int flag) {
    552   if (flags_ & flag) {
    553     gfx::Point location = GetLocationInCurrentRoot();
    554     ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, location,
    555                            location, flags_, flag);
    556     Dispatch(&mouseev);
    557     flags_ ^= flag;
    558   }
    559   grab_ = (flags_ & kAllButtonMask) != 0;
    560 }
    561 
    562 gfx::Point EventGenerator::GetLocationInCurrentRoot() const {
    563   gfx::Point p(current_location_);
    564   delegate()->ConvertPointToTarget(current_target_, &p);
    565   return p;
    566 }
    567 
    568 gfx::Point EventGenerator::CenterOfWindow(const EventTarget* window) const {
    569   return delegate()->CenterOfTarget(window);
    570 }
    571 
    572 void EventGenerator::DoDispatchEvent(ui::Event* event, bool async) {
    573   if (async) {
    574     ui::Event* pending_event;
    575     if (event->IsKeyEvent()) {
    576       pending_event = new ui::KeyEvent(*static_cast<ui::KeyEvent*>(event));
    577     } else if (event->IsMouseEvent()) {
    578       pending_event = new ui::MouseEvent(*static_cast<ui::MouseEvent*>(event));
    579     } else if (event->IsTouchEvent()) {
    580       pending_event = new ui::TouchEvent(*static_cast<ui::TouchEvent*>(event));
    581     } else if (event->IsScrollEvent()) {
    582       pending_event =
    583           new ui::ScrollEvent(*static_cast<ui::ScrollEvent*>(event));
    584     } else {
    585       NOTREACHED() << "Invalid event type";
    586       return;
    587     }
    588     if (pending_events_.empty()) {
    589       base::ThreadTaskRunnerHandle::Get()->PostTask(
    590           FROM_HERE,
    591           base::Bind(&EventGenerator::DispatchNextPendingEvent,
    592                      base::Unretained(this)));
    593     }
    594     pending_events_.push_back(pending_event);
    595   } else {
    596     ui::EventSource* event_source = delegate()->GetEventSource(current_target_);
    597     ui::EventSourceTestApi event_source_test(event_source);
    598     ui::EventDispatchDetails details =
    599         event_source_test.SendEventToProcessor(event);
    600     CHECK(!details.dispatcher_destroyed);
    601   }
    602 }
    603 
    604 void EventGenerator::DispatchNextPendingEvent() {
    605   DCHECK(!pending_events_.empty());
    606   ui::Event* event = pending_events_.front();
    607   DoDispatchEvent(event, false);
    608   pending_events_.pop_front();
    609   delete event;
    610   if (!pending_events_.empty()) {
    611     base::ThreadTaskRunnerHandle::Get()->PostTask(
    612         FROM_HERE,
    613         base::Bind(&EventGenerator::DispatchNextPendingEvent,
    614                    base::Unretained(this)));
    615   }
    616 }
    617 
    618 const EventGeneratorDelegate* EventGenerator::delegate() const {
    619   if (delegate_)
    620     return delegate_.get();
    621 
    622   DCHECK(default_delegate);
    623   return default_delegate;
    624 }
    625 
    626 EventGeneratorDelegate* EventGenerator::delegate() {
    627   return const_cast<EventGeneratorDelegate*>(
    628       const_cast<const EventGenerator*>(this)->delegate());
    629 }
    630 
    631 }  // namespace test
    632 }  // namespace ui
    633