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