ui/views/widget/widget_interactive_uitest.cc

   1 // Copyright (c) 2013 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 "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/command_line.h"
   8 #include "base/path_service.h"
   9 #include "base/run_loop.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "ui/base/resource/resource_bundle.h"
  13 #include "ui/base/ui_base_paths.h"
  14 #include "ui/base/ui_base_switches.h"
  15 #include "ui/events/event_processor.h"
  16 #include "ui/events/test/event_generator.h"
  17 #include "ui/gfx/native_widget_types.h"
  18 #include "ui/gl/gl_surface.h"
  19 #include "ui/views/controls/textfield/textfield.h"
  20 #include "ui/views/controls/textfield/textfield_test_api.h"
  21 #include "ui/views/focus/focus_manager.h"
  22 #include "ui/views/test/focus_manager_test.h"
  23 #include "ui/views/test/widget_test.h"
  24 #include "ui/views/touchui/touch_selection_controller_impl.h"
  25 #include "ui/views/widget/widget.h"
  26 #include "ui/views/window/dialog_delegate.h"
  27 #include "ui/wm/public/activation_client.h"
  28
  29 #if defined(OS_WIN)
  30 #include "ui/aura/window.h"
  31 #include "ui/aura/window_tree_host.h"
  32 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  33 #include "ui/views/win/hwnd_util.h"
  34 #endif
  35
  36 namespace views {
  37 namespace test {
  38
  39 namespace {
  40
  41 // A View that closes the Widget and exits the current message-loop when it
  42 // receives a mouse-release event.
  43 class ExitLoopOnRelease : public View {
  44  public:
  45   ExitLoopOnRelease() {}
  46   virtual ~ExitLoopOnRelease() {}
  47
  48  private:
  49   // Overridden from View:
  50   virtual void OnMouseReleased(const ui::MouseEvent& event) override {
  51     GetWidget()->Close();
  52     base::MessageLoop::current()->QuitNow();
  53   }
  54
  55   DISALLOW_COPY_AND_ASSIGN(ExitLoopOnRelease);
  56 };
  57
  58 // A view that does a capture on ui::ET_GESTURE_TAP_DOWN events.
  59 class GestureCaptureView : public View {
  60  public:
  61   GestureCaptureView() {}
  62   virtual ~GestureCaptureView() {}
  63
  64  private:
  65   // Overridden from View:
  66   virtual void OnGestureEvent(ui::GestureEvent* event) override {
  67     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
  68       GetWidget()->SetCapture(this);
  69       event->StopPropagation();
  70     }
  71   }
  72
  73   DISALLOW_COPY_AND_ASSIGN(GestureCaptureView);
  74 };
  75
  76 // A view that always processes all mouse events.
  77 class MouseView : public View {
  78  public:
  79   MouseView()
  80       : View(),
  81         entered_(0),
  82         exited_(0),
  83         pressed_(0) {
  84   }
  85   virtual ~MouseView() {}
  86
  87   virtual bool OnMousePressed(const ui::MouseEvent& event) override {
  88     pressed_++;
  89     return true;
  90   }
  91
  92   virtual void OnMouseEntered(const ui::MouseEvent& event) override {
  93     entered_++;
  94   }
  95
  96   virtual void OnMouseExited(const ui::MouseEvent& event) override {
  97     exited_++;
  98   }
  99
 100   // Return the number of OnMouseEntered calls and reset the counter.
 101   int EnteredCalls() {
 102     int i = entered_;
 103     entered_ = 0;
 104     return i;
 105   }
 106
 107   // Return the number of OnMouseExited calls and reset the counter.
 108   int ExitedCalls() {
 109     int i = exited_;
 110     exited_ = 0;
 111     return i;
 112   }
 113
 114   int pressed() const { return pressed_; }
 115
 116  private:
 117   int entered_;
 118   int exited_;
 119
 120   int pressed_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(MouseView);
 123 };
 124
 125 // A View that shows a different widget, sets capture on that widget, and
 126 // initiates a nested message-loop when it receives a mouse-press event.
 127 class NestedLoopCaptureView : public View {
 128  public:
 129   explicit NestedLoopCaptureView(Widget* widget) : widget_(widget) {}
 130   virtual ~NestedLoopCaptureView() {}
 131
 132  private:
 133   // Overridden from View:
 134   virtual bool OnMousePressed(const ui::MouseEvent& event) override {
 135     // Start a nested loop.
 136     widget_->Show();
 137     widget_->SetCapture(widget_->GetContentsView());
 138     EXPECT_TRUE(widget_->HasCapture());
 139
 140     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
 141     base::MessageLoop::ScopedNestableTaskAllower allow(loop);
 142
 143     base::RunLoop run_loop;
 144     run_loop.Run();
 145     return true;
 146   }
 147
 148   Widget* widget_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(NestedLoopCaptureView);
 151 };
 152
 153 }  // namespace
 154
 155 class WidgetTestInteractive : public WidgetTest {
 156  public:
 157   WidgetTestInteractive() {}
 158   virtual ~WidgetTestInteractive() {}
 159
 160   virtual void SetUp() override {
 161     gfx::GLSurface::InitializeOneOffForTests();
 162     ui::RegisterPathProvider();
 163     base::FilePath ui_test_pak_path;
 164     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
 165     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
 166     WidgetTest::SetUp();
 167   }
 168
 169  protected:
 170   static void ShowQuickMenuImmediately(
 171       TouchSelectionControllerImpl* controller) {
 172     DCHECK(controller);
 173     if (controller->context_menu_timer_.IsRunning()) {
 174       controller->context_menu_timer_.Stop();
 175 // TODO(tapted): Enable this when porting ui/views/touchui to Mac.
 176 #if !defined(OS_MACOSX)
 177       controller->ContextMenuTimerFired();
 178 #endif
 179     }
 180   }
 181
 182   static bool IsQuickMenuVisible(TouchSelectionControllerImpl* controller) {
 183     DCHECK(controller);
 184     return controller->context_menu_ && controller->context_menu_->visible();
 185   }
 186 };
 187
 188 #if defined(OS_WIN)
 189 // Tests whether activation and focus change works correctly in Windows.
 190 // We test the following:-
 191 // 1. If the active aura window is correctly set when a top level widget is
 192 //    created.
 193 // 2. If the active aura window in widget 1 created above, is set to NULL when
 194 //    another top level widget is created and focused.
 195 // 3. On focusing the native platform window for widget 1, the active aura
 196 //    window for widget 1 should be set and that for widget 2 should reset.
 197 // TODO(ananta): Discuss with erg on how to write this test for linux x11 aura.
 198 TEST_F(WidgetTestInteractive, DesktopNativeWidgetAuraActivationAndFocusTest) {
 199   // Create widget 1 and expect the active window to be its window.
 200   View* contents_view1 = new View;
 201   contents_view1->SetFocusable(true);
 202   Widget widget1;
 203   Widget::InitParams init_params =
 204       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 205   init_params.bounds = gfx::Rect(0, 0, 200, 200);
 206   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 207   init_params.native_widget = new DesktopNativeWidgetAura(&widget1);
 208   widget1.Init(init_params);
 209   widget1.SetContentsView(contents_view1);
 210   widget1.Show();
 211   aura::Window* root_window1= widget1.GetNativeView()->GetRootWindow();
 212   contents_view1->RequestFocus();
 213
 214   EXPECT_TRUE(root_window1 != NULL);
 215   aura::client::ActivationClient* activation_client1 =
 216       aura::client::GetActivationClient(root_window1);
 217   EXPECT_TRUE(activation_client1 != NULL);
 218   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1.GetNativeView());
 219
 220   // Create widget 2 and expect the active window to be its window.
 221   View* contents_view2 = new View;
 222   Widget widget2;
 223   Widget::InitParams init_params2 =
 224       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 225   init_params2.bounds = gfx::Rect(0, 0, 200, 200);
 226   init_params2.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 227   init_params2.native_widget = new DesktopNativeWidgetAura(&widget2);
 228   widget2.Init(init_params2);
 229   widget2.SetContentsView(contents_view2);
 230   widget2.Show();
 231   aura::Window* root_window2 = widget2.GetNativeView()->GetRootWindow();
 232   contents_view2->RequestFocus();
 233   ::SetActiveWindow(
 234       root_window2->GetHost()->GetAcceleratedWidget());
 235
 236   aura::client::ActivationClient* activation_client2 =
 237       aura::client::GetActivationClient(root_window2);
 238   EXPECT_TRUE(activation_client2 != NULL);
 239   EXPECT_EQ(activation_client2->GetActiveWindow(), widget2.GetNativeView());
 240   EXPECT_EQ(activation_client1->GetActiveWindow(),
 241             reinterpret_cast<aura::Window*>(NULL));
 242
 243   // Now set focus back to widget 1 and expect the active window to be its
 244   // window.
 245   contents_view1->RequestFocus();
 246   ::SetActiveWindow(
 247       root_window1->GetHost()->GetAcceleratedWidget());
 248   EXPECT_EQ(activation_client2->GetActiveWindow(),
 249             reinterpret_cast<aura::Window*>(NULL));
 250   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1.GetNativeView());
 251 }
 252 #endif  // defined(OS_WIN)
 253
 254 TEST_F(WidgetTestInteractive, CaptureAutoReset) {
 255   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
 256   View* container = new View;
 257   toplevel->SetContentsView(container);
 258
 259   EXPECT_FALSE(toplevel->HasCapture());
 260   toplevel->SetCapture(NULL);
 261   EXPECT_TRUE(toplevel->HasCapture());
 262
 263   // By default, mouse release removes capture.
 264   gfx::Point click_location(45, 15);
 265   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, click_location, click_location,
 266                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 267   toplevel->OnMouseEvent(&release);
 268   EXPECT_FALSE(toplevel->HasCapture());
 269
 270   // Now a mouse release shouldn't remove capture.
 271   toplevel->set_auto_release_capture(false);
 272   toplevel->SetCapture(NULL);
 273   EXPECT_TRUE(toplevel->HasCapture());
 274   toplevel->OnMouseEvent(&release);
 275   EXPECT_TRUE(toplevel->HasCapture());
 276   toplevel->ReleaseCapture();
 277   EXPECT_FALSE(toplevel->HasCapture());
 278
 279   toplevel->Close();
 280   RunPendingMessages();
 281 }
 282
 283 TEST_F(WidgetTestInteractive, ResetCaptureOnGestureEnd) {
 284   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
 285   View* container = new View;
 286   toplevel->SetContentsView(container);
 287
 288   View* gesture = new GestureCaptureView;
 289   gesture->SetBounds(0, 0, 30, 30);
 290   container->AddChildView(gesture);
 291
 292   MouseView* mouse = new MouseView;
 293   mouse->SetBounds(30, 0, 30, 30);
 294   container->AddChildView(mouse);
 295
 296   toplevel->SetSize(gfx::Size(100, 100));
 297   toplevel->Show();
 298
 299   // Start a gesture on |gesture|.
 300   ui::GestureEvent tap_down(15,
 301                             15,
 302                             0,
 303                             base::TimeDelta(),
 304                             ui::GestureEventDetails(ui::ET_GESTURE_TAP_DOWN));
 305   ui::GestureEvent end(15,
 306                        15,
 307                        0,
 308                        base::TimeDelta(),
 309                        ui::GestureEventDetails(ui::ET_GESTURE_END));
 310   toplevel->OnGestureEvent(&tap_down);
 311
 312   // Now try to click on |mouse|. Since |gesture| will have capture, |mouse|
 313   // will not receive the event.
 314   gfx::Point click_location(45, 15);
 315
 316   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, click_location, click_location,
 317                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 318   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, click_location, click_location,
 319                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 320
 321   EXPECT_TRUE(toplevel->HasCapture());
 322
 323   toplevel->OnMouseEvent(&press);
 324   toplevel->OnMouseEvent(&release);
 325   EXPECT_EQ(0, mouse->pressed());
 326
 327   EXPECT_FALSE(toplevel->HasCapture());
 328
 329   // The end of the gesture should release the capture, and pressing on |mouse|
 330   // should now reach |mouse|.
 331   toplevel->OnGestureEvent(&end);
 332   toplevel->OnMouseEvent(&press);
 333   toplevel->OnMouseEvent(&release);
 334   EXPECT_EQ(1, mouse->pressed());
 335
 336   toplevel->Close();
 337   RunPendingMessages();
 338 }
 339
 340 // Checks that if a mouse-press triggers a capture on a different widget (which
 341 // consumes the mouse-release event), then the target of the press does not have
 342 // capture.
 343 TEST_F(WidgetTestInteractive, DisableCaptureWidgetFromMousePress) {
 344   // The test creates two widgets: |first| and |second|.
 345   // The View in |first| makes |second| visible, sets capture on it, and starts
 346   // a nested loop (like a menu does). The View in |second| terminates the
 347   // nested loop and closes the widget.
 348   // The test sends a mouse-press event to |first|, and posts a task to send a
 349   // release event to |second|, to make sure that the release event is
 350   // dispatched after the nested loop starts.
 351
 352   Widget* first = CreateTopLevelFramelessPlatformWidget();
 353   Widget* second = CreateTopLevelFramelessPlatformWidget();
 354
 355   View* container = new NestedLoopCaptureView(second);
 356   first->SetContentsView(container);
 357
 358   second->SetContentsView(new ExitLoopOnRelease());
 359
 360   first->SetSize(gfx::Size(100, 100));
 361   first->Show();
 362
 363   gfx::Point location(20, 20);
 364   base::MessageLoop::current()->PostTask(FROM_HERE,
 365       base::Bind(&Widget::OnMouseEvent,
 366                  base::Unretained(second),
 367                  base::Owned(new ui::MouseEvent(ui::ET_MOUSE_RELEASED,
 368                                                 location,
 369                                                 location,
 370                                                 ui::EF_LEFT_MOUSE_BUTTON,
 371                                                 ui::EF_LEFT_MOUSE_BUTTON))));
 372   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, location, location,
 373                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 374   first->OnMouseEvent(&press);
 375   EXPECT_FALSE(first->HasCapture());
 376   first->Close();
 377   RunPendingMessages();
 378 }
 379
 380 // Tests some grab/ungrab events.
 381 // TODO(estade): can this be enabled now that this is an interactive ui test?
 382 TEST_F(WidgetTestInteractive, DISABLED_GrabUngrab) {
 383   Widget* toplevel = CreateTopLevelPlatformWidget();
 384   Widget* child1 = CreateChildNativeWidgetWithParent(toplevel);
 385   Widget* child2 = CreateChildNativeWidgetWithParent(toplevel);
 386
 387   toplevel->SetBounds(gfx::Rect(0, 0, 500, 500));
 388
 389   child1->SetBounds(gfx::Rect(10, 10, 300, 300));
 390   View* view = new MouseView();
 391   view->SetBounds(0, 0, 300, 300);
 392   child1->GetRootView()->AddChildView(view);
 393
 394   child2->SetBounds(gfx::Rect(200, 10, 200, 200));
 395   view = new MouseView();
 396   view->SetBounds(0, 0, 200, 200);
 397   child2->GetRootView()->AddChildView(view);
 398
 399   toplevel->Show();
 400   RunPendingMessages();
 401
 402   // Click on child1
 403   gfx::Point p1(45, 45);
 404   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, p1, p1,
 405                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 406   toplevel->OnMouseEvent(&pressed);
 407
 408   EXPECT_TRUE(toplevel->HasCapture());
 409   EXPECT_TRUE(child1->HasCapture());
 410   EXPECT_FALSE(child2->HasCapture());
 411
 412   ui::MouseEvent released(ui::ET_MOUSE_RELEASED, p1, p1,
 413                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 414   toplevel->OnMouseEvent(&released);
 415
 416   EXPECT_FALSE(toplevel->HasCapture());
 417   EXPECT_FALSE(child1->HasCapture());
 418   EXPECT_FALSE(child2->HasCapture());
 419
 420   RunPendingMessages();
 421
 422   // Click on child2
 423   gfx::Point p2(315, 45);
 424   ui::MouseEvent pressed2(ui::ET_MOUSE_PRESSED, p2, p2,
 425                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 426   toplevel->OnMouseEvent(&pressed2);
 427   EXPECT_TRUE(pressed2.handled());
 428   EXPECT_TRUE(toplevel->HasCapture());
 429   EXPECT_TRUE(child2->HasCapture());
 430   EXPECT_FALSE(child1->HasCapture());
 431
 432   ui::MouseEvent released2(ui::ET_MOUSE_RELEASED, p2, p2,
 433                            ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 434   toplevel->OnMouseEvent(&released2);
 435   EXPECT_FALSE(toplevel->HasCapture());
 436   EXPECT_FALSE(child1->HasCapture());
 437   EXPECT_FALSE(child2->HasCapture());
 438
 439   toplevel->CloseNow();
 440 }
 441
 442 // Tests mouse move outside of the window into the "resize controller" and back
 443 // will still generate an OnMouseEntered and OnMouseExited event..
 444 TEST_F(WidgetTestInteractive, CheckResizeControllerEvents) {
 445   Widget* toplevel = CreateTopLevelPlatformWidget();
 446
 447   toplevel->SetBounds(gfx::Rect(0, 0, 100, 100));
 448
 449   MouseView* view = new MouseView();
 450   view->SetBounds(90, 90, 10, 10);
 451   toplevel->GetRootView()->AddChildView(view);
 452
 453   toplevel->Show();
 454   RunPendingMessages();
 455
 456   // Move to an outside position.
 457   gfx::Point p1(200, 200);
 458   ui::MouseEvent moved_out(ui::ET_MOUSE_MOVED, p1, p1, ui::EF_NONE,
 459                            ui::EF_NONE);
 460   toplevel->OnMouseEvent(&moved_out);
 461   EXPECT_EQ(0, view->EnteredCalls());
 462   EXPECT_EQ(0, view->ExitedCalls());
 463
 464   // Move onto the active view.
 465   gfx::Point p2(95, 95);
 466   ui::MouseEvent moved_over(ui::ET_MOUSE_MOVED, p2, p2, ui::EF_NONE,
 467                             ui::EF_NONE);
 468   toplevel->OnMouseEvent(&moved_over);
 469   EXPECT_EQ(1, view->EnteredCalls());
 470   EXPECT_EQ(0, view->ExitedCalls());
 471
 472   // Move onto the outer resizing border.
 473   gfx::Point p3(102, 95);
 474   ui::MouseEvent moved_resizer(ui::ET_MOUSE_MOVED, p3, p3, ui::EF_NONE,
 475                                ui::EF_NONE);
 476   toplevel->OnMouseEvent(&moved_resizer);
 477   EXPECT_EQ(0, view->EnteredCalls());
 478   EXPECT_EQ(1, view->ExitedCalls());
 479
 480   // Move onto the view again.
 481   toplevel->OnMouseEvent(&moved_over);
 482   EXPECT_EQ(1, view->EnteredCalls());
 483   EXPECT_EQ(0, view->ExitedCalls());
 484
 485   RunPendingMessages();
 486
 487   toplevel->CloseNow();
 488 }
 489
 490 // Test view focus restoration when a widget is deactivated and re-activated.
 491 TEST_F(WidgetTestInteractive, ViewFocusOnWidgetActivationChanges) {
 492   Widget* widget1 = CreateTopLevelPlatformWidget();
 493   View* view1 = new View;
 494   view1->SetFocusable(true);
 495   widget1->GetContentsView()->AddChildView(view1);
 496
 497   Widget* widget2 = CreateTopLevelPlatformWidget();
 498   View* view2a = new View;
 499   View* view2b = new View;
 500   view2a->SetFocusable(true);
 501   view2b->SetFocusable(true);
 502   widget2->GetContentsView()->AddChildView(view2a);
 503   widget2->GetContentsView()->AddChildView(view2b);
 504
 505   widget1->Show();
 506   EXPECT_TRUE(widget1->IsActive());
 507   view1->RequestFocus();
 508   EXPECT_EQ(view1, widget1->GetFocusManager()->GetFocusedView());
 509
 510   widget2->Show();
 511   EXPECT_TRUE(widget2->IsActive());
 512   EXPECT_FALSE(widget1->IsActive());
 513   EXPECT_EQ(NULL, widget1->GetFocusManager()->GetFocusedView());
 514   view2a->RequestFocus();
 515   EXPECT_EQ(view2a, widget2->GetFocusManager()->GetFocusedView());
 516   view2b->RequestFocus();
 517   EXPECT_EQ(view2b, widget2->GetFocusManager()->GetFocusedView());
 518
 519   widget1->Activate();
 520   EXPECT_TRUE(widget1->IsActive());
 521   EXPECT_EQ(view1, widget1->GetFocusManager()->GetFocusedView());
 522   EXPECT_FALSE(widget2->IsActive());
 523   EXPECT_EQ(NULL, widget2->GetFocusManager()->GetFocusedView());
 524
 525   widget2->Activate();
 526   EXPECT_TRUE(widget2->IsActive());
 527   EXPECT_EQ(view2b, widget2->GetFocusManager()->GetFocusedView());
 528   EXPECT_FALSE(widget1->IsActive());
 529   EXPECT_EQ(NULL, widget1->GetFocusManager()->GetFocusedView());
 530
 531   widget1->CloseNow();
 532   widget2->CloseNow();
 533 }
 534
 535 #if defined(OS_WIN)
 536
 537 // Test view focus retention when a widget's HWND is disabled and re-enabled.
 538 TEST_F(WidgetTestInteractive, ViewFocusOnHWNDEnabledChanges) {
 539   Widget* widget = CreateTopLevelFramelessPlatformWidget();
 540   widget->SetContentsView(new View);
 541   for (size_t i = 0; i < 2; ++i) {
 542     widget->GetContentsView()->AddChildView(new View);
 543     widget->GetContentsView()->child_at(i)->SetFocusable(true);
 544   }
 545
 546   widget->Show();
 547   const HWND hwnd = HWNDForWidget(widget);
 548   EXPECT_TRUE(::IsWindow(hwnd));
 549   EXPECT_TRUE(::IsWindowEnabled(hwnd));
 550   EXPECT_EQ(hwnd, ::GetActiveWindow());
 551
 552   for (int i = 0; i < widget->GetContentsView()->child_count(); ++i) {
 553     SCOPED_TRACE(base::StringPrintf("Child view %d", i));
 554     View* view = widget->GetContentsView()->child_at(i);
 555
 556     view->RequestFocus();
 557     EXPECT_EQ(view, widget->GetFocusManager()->GetFocusedView());
 558     EXPECT_FALSE(::EnableWindow(hwnd, FALSE));
 559     EXPECT_FALSE(::IsWindowEnabled(hwnd));
 560
 561     // Oddly, disabling the HWND leaves it active with the focus unchanged.
 562     EXPECT_EQ(hwnd, ::GetActiveWindow());
 563     EXPECT_TRUE(widget->IsActive());
 564     EXPECT_EQ(view, widget->GetFocusManager()->GetFocusedView());
 565
 566     EXPECT_TRUE(::EnableWindow(hwnd, TRUE));
 567     EXPECT_TRUE(::IsWindowEnabled(hwnd));
 568     EXPECT_EQ(hwnd, ::GetActiveWindow());
 569     EXPECT_TRUE(widget->IsActive());
 570     EXPECT_EQ(view, widget->GetFocusManager()->GetFocusedView());
 571   }
 572
 573   widget->CloseNow();
 574 }
 575
 576 // This class subclasses the Widget class to listen for activation change
 577 // notifications and provides accessors to return information as to whether
 578 // the widget is active. We need this to ensure that users of the widget
 579 // class activate the widget only when the underlying window becomes really
 580 // active. Previously we would activate the widget in the WM_NCACTIVATE
 581 // message which is incorrect because APIs like FlashWindowEx flash the
 582 // window caption by sending fake WM_NCACTIVATE messages.
 583 class WidgetActivationTest : public Widget {
 584  public:
 585   WidgetActivationTest()
 586       : active_(false) {}
 587
 588   virtual ~WidgetActivationTest() {}
 589
 590   virtual void OnNativeWidgetActivationChanged(bool active) override {
 591     active_ = active;
 592   }
 593
 594   bool active() const { return active_; }
 595
 596  private:
 597   bool active_;
 598
 599   DISALLOW_COPY_AND_ASSIGN(WidgetActivationTest);
 600 };
 601
 602 // Tests whether the widget only becomes active when the underlying window
 603 // is really active.
 604 TEST_F(WidgetTestInteractive, WidgetNotActivatedOnFakeActivationMessages) {
 605   WidgetActivationTest widget1;
 606   Widget::InitParams init_params =
 607       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 608   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 609   init_params.native_widget = new DesktopNativeWidgetAura(&widget1);
 610   init_params.bounds = gfx::Rect(0, 0, 200, 200);
 611   widget1.Init(init_params);
 612   widget1.Show();
 613   EXPECT_EQ(true, widget1.active());
 614
 615   WidgetActivationTest widget2;
 616   init_params.native_widget = new DesktopNativeWidgetAura(&widget2);
 617   widget2.Init(init_params);
 618   widget2.Show();
 619   EXPECT_EQ(true, widget2.active());
 620   EXPECT_EQ(false, widget1.active());
 621
 622   HWND win32_native_window1 = HWNDForWidget(&widget1);
 623   EXPECT_TRUE(::IsWindow(win32_native_window1));
 624
 625   ::SendMessage(win32_native_window1, WM_NCACTIVATE, 1, 0);
 626   EXPECT_EQ(false, widget1.active());
 627   EXPECT_EQ(true, widget2.active());
 628
 629   ::SetActiveWindow(win32_native_window1);
 630   EXPECT_EQ(true, widget1.active());
 631   EXPECT_EQ(false, widget2.active());
 632 }
 633 #endif  // defined(OS_WIN)
 634
 635 #if !defined(OS_CHROMEOS)
 636 // Provides functionality to create a window modal dialog.
 637 class ModalDialogDelegate : public DialogDelegateView {
 638  public:
 639   explicit ModalDialogDelegate(ui::ModalType type) : type_(type) {}
 640   virtual ~ModalDialogDelegate() {}
 641
 642   // WidgetDelegate overrides.
 643   virtual ui::ModalType GetModalType() const override {
 644     return type_;
 645   }
 646
 647  private:
 648   ui::ModalType type_;
 649
 650   DISALLOW_COPY_AND_ASSIGN(ModalDialogDelegate);
 651 };
 652
 653 // Tests whether the focused window is set correctly when a modal window is
 654 // created and destroyed. When it is destroyed it should focus the owner window.
 655 TEST_F(WidgetTestInteractive, WindowModalWindowDestroyedActivationTest) {
 656   TestWidgetFocusChangeListener focus_listener;
 657   WidgetFocusManager::GetInstance()->AddFocusChangeListener(&focus_listener);
 658   const std::vector<NativeViewPair>& focus_changes =
 659       focus_listener.focus_changes();
 660
 661   // Create a top level widget.
 662   Widget top_level_widget;
 663   Widget::InitParams init_params =
 664       CreateParams(Widget::InitParams::TYPE_WINDOW);
 665   init_params.show_state = ui::SHOW_STATE_NORMAL;
 666   gfx::Rect initial_bounds(0, 0, 500, 500);
 667   init_params.bounds = initial_bounds;
 668   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 669   init_params.native_widget =
 670       new PlatformDesktopNativeWidget(&top_level_widget);
 671   top_level_widget.Init(init_params);
 672   top_level_widget.Show();
 673
 674   gfx::NativeView top_level_native_view = top_level_widget.GetNativeView();
 675   EXPECT_EQ(1u, focus_changes.size());
 676   EXPECT_EQ(NativeViewPair(NULL, top_level_native_view), focus_changes[0]);
 677
 678   // Create a modal dialog.
 679   // This instance will be destroyed when the dialog is destroyed.
 680   ModalDialogDelegate* dialog_delegate =
 681       new ModalDialogDelegate(ui::MODAL_TYPE_WINDOW);
 682
 683   Widget* modal_dialog_widget = views::DialogDelegate::CreateDialogWidget(
 684       dialog_delegate, NULL, top_level_widget.GetNativeView());
 685   modal_dialog_widget->SetBounds(gfx::Rect(100, 100, 200, 200));
 686   modal_dialog_widget->Show();
 687
 688   gfx::NativeView modal_native_view = modal_dialog_widget->GetNativeView();
 689   EXPECT_EQ(3u, focus_changes.size());
 690   EXPECT_EQ(NativeViewPair(top_level_native_view, modal_native_view),
 691             focus_changes[1]);
 692   EXPECT_EQ(NativeViewPair(top_level_native_view, modal_native_view),
 693             focus_changes[2]);
 694
 695   modal_dialog_widget->CloseNow();
 696
 697   EXPECT_EQ(5u, focus_changes.size());
 698   EXPECT_EQ(NativeViewPair(modal_native_view, top_level_native_view),
 699             focus_changes[3]);
 700   EXPECT_EQ(NativeViewPair(modal_native_view, top_level_native_view),
 701             focus_changes[4]);
 702
 703   top_level_widget.CloseNow();
 704   WidgetFocusManager::GetInstance()->RemoveFocusChangeListener(&focus_listener);
 705 }
 706
 707 // Test that when opening a system-modal window, capture is released.
 708 TEST_F(WidgetTestInteractive, SystemModalWindowReleasesCapture) {
 709   TestWidgetFocusChangeListener focus_listener;
 710   WidgetFocusManager::GetInstance()->AddFocusChangeListener(&focus_listener);
 711
 712   // Create a top level widget.
 713   Widget top_level_widget;
 714   Widget::InitParams init_params =
 715       CreateParams(Widget::InitParams::TYPE_WINDOW);
 716   init_params.show_state = ui::SHOW_STATE_NORMAL;
 717   gfx::Rect initial_bounds(0, 0, 500, 500);
 718   init_params.bounds = initial_bounds;
 719   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 720   init_params.native_widget =
 721       new PlatformDesktopNativeWidget(&top_level_widget);
 722   top_level_widget.Init(init_params);
 723   top_level_widget.Show();
 724
 725   EXPECT_EQ(top_level_widget.GetNativeView(),
 726             focus_listener.focus_changes().back().second);;
 727
 728   EXPECT_FALSE(top_level_widget.HasCapture());
 729   top_level_widget.SetCapture(NULL);
 730   EXPECT_TRUE(top_level_widget.HasCapture());
 731
 732   // Create a modal dialog.
 733   ModalDialogDelegate* dialog_delegate =
 734       new ModalDialogDelegate(ui::MODAL_TYPE_SYSTEM);
 735
 736   Widget* modal_dialog_widget = views::DialogDelegate::CreateDialogWidget(
 737       dialog_delegate, NULL, top_level_widget.GetNativeView());
 738   modal_dialog_widget->SetBounds(gfx::Rect(100, 100, 200, 200));
 739   modal_dialog_widget->Show();
 740
 741   EXPECT_FALSE(top_level_widget.HasCapture());
 742
 743   modal_dialog_widget->CloseNow();
 744   top_level_widget.CloseNow();
 745   WidgetFocusManager::GetInstance()->RemoveFocusChangeListener(&focus_listener);
 746 }
 747
 748 #endif  // !defined(OS_CHROMEOS)
 749
 750 TEST_F(WidgetTestInteractive, CanActivateFlagIsHonored) {
 751   Widget widget;
 752   Widget::InitParams init_params =
 753       CreateParams(Widget::InitParams::TYPE_WINDOW);
 754   init_params.bounds = gfx::Rect(0, 0, 200, 200);
 755   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 756   init_params.activatable = Widget::InitParams::ACTIVATABLE_NO;
 757 #if !defined(OS_CHROMEOS)
 758   init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
 759 #endif  // !defined(OS_CHROMEOS)
 760   widget.Init(init_params);
 761
 762   widget.Show();
 763   EXPECT_FALSE(widget.IsActive());
 764 }
 765
 766 // Test that touch selection quick menu is not activated when opened.
 767 TEST_F(WidgetTestInteractive, TouchSelectionQuickMenuIsNotActivated) {
 768   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
 769 #if defined(OS_WIN)
 770   views_delegate().set_use_desktop_native_widgets(true);
 771 #endif  // !defined(OS_WIN)
 772
 773   Widget widget;
 774   Widget::InitParams init_params =
 775       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 776   init_params.bounds = gfx::Rect(0, 0, 200, 200);
 777   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 778   widget.Init(init_params);
 779
 780   Textfield* textfield = new Textfield;
 781   textfield->SetBounds(0, 0, 200, 20);
 782   textfield->SetText(base::ASCIIToUTF16("some text"));
 783   widget.GetRootView()->AddChildView(textfield);
 784
 785   widget.Show();
 786   textfield->RequestFocus();
 787   textfield->SelectAll(true);
 788   TextfieldTestApi textfield_test_api(textfield);
 789
 790   RunPendingMessages();
 791
 792   ui::test::EventGenerator generator(widget.GetNativeWindow());
 793   generator.GestureTapAt(gfx::Point(10, 10));
 794   ShowQuickMenuImmediately(static_cast<TouchSelectionControllerImpl*>(
 795       textfield_test_api.touch_selection_controller()));
 796
 797   EXPECT_TRUE(textfield->HasFocus());
 798   EXPECT_TRUE(widget.IsActive());
 799   EXPECT_TRUE(IsQuickMenuVisible(static_cast<TouchSelectionControllerImpl*>(
 800       textfield_test_api.touch_selection_controller())));
 801 }
 802
 803 TEST_F(WidgetTestInteractive, DisableViewDoesNotActivateWidget) {
 804 #if defined(OS_WIN)
 805   views_delegate().set_use_desktop_native_widgets(true);
 806 #endif  // !defined(OS_WIN)
 807
 808   // Create first widget and view, activate the widget, and focus the view.
 809   Widget widget1;
 810   Widget::InitParams params1 = CreateParams(Widget::InitParams::TYPE_POPUP);
 811   params1.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 812   params1.activatable = Widget::InitParams::ACTIVATABLE_YES;
 813   widget1.Init(params1);
 814
 815   View* view1 = new View();
 816   view1->SetFocusable(true);
 817   widget1.GetRootView()->AddChildView(view1);
 818
 819   widget1.Activate();
 820   EXPECT_TRUE(widget1.IsActive());
 821
 822   FocusManager* focus_manager1 = widget1.GetFocusManager();
 823   ASSERT_TRUE(focus_manager1);
 824   focus_manager1->SetFocusedView(view1);
 825   EXPECT_EQ(view1, focus_manager1->GetFocusedView());
 826
 827   // Create second widget and view, activate the widget, and focus the view.
 828   Widget widget2;
 829   Widget::InitParams params2 = CreateParams(Widget::InitParams::TYPE_POPUP);
 830   params2.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 831   params2.activatable = Widget::InitParams::ACTIVATABLE_YES;
 832   widget2.Init(params2);
 833
 834   View* view2 = new View();
 835   view2->SetFocusable(true);
 836   widget2.GetRootView()->AddChildView(view2);
 837
 838   widget2.Activate();
 839   EXPECT_TRUE(widget2.IsActive());
 840   EXPECT_FALSE(widget1.IsActive());
 841
 842   FocusManager* focus_manager2 = widget2.GetFocusManager();
 843   ASSERT_TRUE(focus_manager2);
 844   focus_manager2->SetFocusedView(view2);
 845   EXPECT_EQ(view2, focus_manager2->GetFocusedView());
 846
 847   // Disable the first view and make sure it loses focus, but its widget is not
 848   // activated.
 849   view1->SetEnabled(false);
 850   EXPECT_NE(view1, focus_manager1->GetFocusedView());
 851   EXPECT_FALSE(widget1.IsActive());
 852   EXPECT_TRUE(widget2.IsActive());
 853 }
 854
 855 namespace {
 856
 857 // Used to veirfy OnMouseCaptureLost() has been invoked.
 858 class CaptureLostTrackingWidget : public Widget {
 859  public:
 860   CaptureLostTrackingWidget() : got_capture_lost_(false) {}
 861   virtual ~CaptureLostTrackingWidget() {}
 862
 863   bool GetAndClearGotCaptureLost() {
 864     bool value = got_capture_lost_;
 865     got_capture_lost_ = false;
 866     return value;
 867   }
 868
 869   // Widget:
 870   virtual void OnMouseCaptureLost() override {
 871     got_capture_lost_ = true;
 872     Widget::OnMouseCaptureLost();
 873   }
 874
 875  private:
 876   bool got_capture_lost_;
 877
 878   DISALLOW_COPY_AND_ASSIGN(CaptureLostTrackingWidget);
 879 };
 880
 881 }  // namespace
 882
 883 class WidgetCaptureTest : public ViewsTestBase {
 884  public:
 885   WidgetCaptureTest() {
 886   }
 887
 888   virtual ~WidgetCaptureTest() {
 889   }
 890
 891   virtual void SetUp() override {
 892     gfx::GLSurface::InitializeOneOffForTests();
 893     ui::RegisterPathProvider();
 894     base::FilePath ui_test_pak_path;
 895     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
 896     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
 897     ViewsTestBase::SetUp();
 898   }
 899
 900   // Verifies Widget::SetCapture() results in updating native capture along with
 901   // invoking the right Widget function.
 902   void TestCapture(bool use_desktop_native_widget) {
 903     CaptureLostTrackingWidget widget1;
 904     Widget::InitParams params1 =
 905         CreateParams(views::Widget::InitParams::TYPE_WINDOW);
 906     params1.native_widget = CreateNativeWidget(use_desktop_native_widget,
 907                                                &widget1);
 908     params1.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 909     widget1.Init(params1);
 910     widget1.Show();
 911
 912     CaptureLostTrackingWidget widget2;
 913     Widget::InitParams params2 =
 914         CreateParams(views::Widget::InitParams::TYPE_WINDOW);
 915     params2.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 916     params2.native_widget = CreateNativeWidget(use_desktop_native_widget,
 917                                                &widget2);
 918     widget2.Init(params2);
 919     widget2.Show();
 920
 921     // Set capture to widget2 and verity it gets it.
 922     widget2.SetCapture(widget2.GetRootView());
 923     EXPECT_FALSE(widget1.HasCapture());
 924     EXPECT_TRUE(widget2.HasCapture());
 925     EXPECT_FALSE(widget1.GetAndClearGotCaptureLost());
 926     EXPECT_FALSE(widget2.GetAndClearGotCaptureLost());
 927
 928     // Set capture to widget1 and verify it gets it.
 929     widget1.SetCapture(widget1.GetRootView());
 930     EXPECT_TRUE(widget1.HasCapture());
 931     EXPECT_FALSE(widget2.HasCapture());
 932     EXPECT_FALSE(widget1.GetAndClearGotCaptureLost());
 933     EXPECT_TRUE(widget2.GetAndClearGotCaptureLost());
 934
 935     // Release and verify no one has it.
 936     widget1.ReleaseCapture();
 937     EXPECT_FALSE(widget1.HasCapture());
 938     EXPECT_FALSE(widget2.HasCapture());
 939     EXPECT_TRUE(widget1.GetAndClearGotCaptureLost());
 940     EXPECT_FALSE(widget2.GetAndClearGotCaptureLost());
 941   }
 942
 943   NativeWidget* CreateNativeWidget(bool create_desktop_native_widget,
 944                                    Widget* widget) {
 945 #if !defined(OS_CHROMEOS)
 946     if (create_desktop_native_widget)
 947       return new PlatformDesktopNativeWidget(widget);
 948 #endif
 949     return NULL;
 950   }
 951
 952  private:
 953   DISALLOW_COPY_AND_ASSIGN(WidgetCaptureTest);
 954 };
 955
 956 // See description in TestCapture().
 957 TEST_F(WidgetCaptureTest, Capture) {
 958   TestCapture(false);
 959 }
 960
 961 #if !defined(OS_CHROMEOS)
 962 // See description in TestCapture(). Creates DesktopNativeWidget.
 963 TEST_F(WidgetCaptureTest, CaptureDesktopNativeWidget) {
 964   TestCapture(true);
 965 }
 966 #endif
 967
 968 // Test that no state is set if capture fails.
 969 TEST_F(WidgetCaptureTest, FailedCaptureRequestIsNoop) {
 970   Widget widget;
 971   Widget::InitParams params =
 972       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 973   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 974   params.bounds = gfx::Rect(400, 400);
 975   widget.Init(params);
 976
 977   MouseView* mouse_view1 = new MouseView;
 978   MouseView* mouse_view2 = new MouseView;
 979   View* contents_view = new View;
 980   contents_view->AddChildView(mouse_view1);
 981   contents_view->AddChildView(mouse_view2);
 982   widget.SetContentsView(contents_view);
 983
 984   mouse_view1->SetBounds(0, 0, 200, 400);
 985   mouse_view2->SetBounds(200, 0, 200, 400);
 986
 987   // Setting capture should fail because |widget| is not visible.
 988   widget.SetCapture(mouse_view1);
 989   EXPECT_FALSE(widget.HasCapture());
 990
 991   widget.Show();
 992   ui::test::EventGenerator generator(GetContext(), widget.GetNativeWindow());
 993   generator.set_current_location(gfx::Point(300, 10));
 994   generator.PressLeftButton();
 995
 996   EXPECT_FALSE(mouse_view1->pressed());
 997   EXPECT_TRUE(mouse_view2->pressed());
 998 }
 999
1000 #if !defined(OS_CHROMEOS) && !defined(OS_WIN)
1001 // Test that a synthetic mouse exit is sent to the widget which was handling
1002 // mouse events when a different widget grabs capture.
1003 // TODO(pkotwicz): Make test pass on CrOS and Windows.
1004 TEST_F(WidgetCaptureTest, MouseExitOnCaptureGrab) {
1005   Widget widget1;
1006   Widget::InitParams params1 =
1007       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
1008   params1.native_widget = CreateNativeWidget(true, &widget1);
1009   params1.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
1010   widget1.Init(params1);
1011   MouseView* mouse_view1 = new MouseView;
1012   widget1.SetContentsView(mouse_view1);
1013   widget1.Show();
1014   widget1.SetBounds(gfx::Rect(300, 300));
1015
1016   Widget widget2;
1017   Widget::InitParams params2 =
1018       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
1019   params2.native_widget = CreateNativeWidget(true, &widget2);
1020   params2.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
1021   widget2.Init(params2);
1022   widget2.Show();
1023   widget2.SetBounds(gfx::Rect(400, 0, 300, 300));
1024
1025   ui::test::EventGenerator generator(widget1.GetNativeWindow());
1026   generator.set_current_location(gfx::Point(100, 100));
1027   generator.MoveMouseBy(0, 0);
1028
1029   EXPECT_EQ(1, mouse_view1->EnteredCalls());
1030   EXPECT_EQ(0, mouse_view1->ExitedCalls());
1031
1032   widget2.SetCapture(NULL);
1033   EXPECT_EQ(0, mouse_view1->EnteredCalls());
1034   // Grabbing native capture on Windows generates a ui::ET_MOUSE_EXITED event
1035   // in addition to the one generated by Chrome.
1036   EXPECT_LT(0, mouse_view1->ExitedCalls());
1037 }
1038 #endif  // !defined(OS_CHROMEOS)
1039
1040 namespace {
1041
1042 // Widget observer which grabs capture when the widget is activated.
1043 class CaptureOnActivationObserver : public WidgetObserver {
1044  public:
1045   CaptureOnActivationObserver() {
1046   }
1047   virtual ~CaptureOnActivationObserver() {
1048   }
1049
1050   // WidgetObserver:
1051   virtual void OnWidgetActivationChanged(Widget* widget, bool active) override {
1052     if (active)
1053       widget->SetCapture(NULL);
1054   }
1055
1056  private:
1057   DISALLOW_COPY_AND_ASSIGN(CaptureOnActivationObserver);
1058 };
1059
1060 }  // namespace
1061
1062 // Test that setting capture on widget activation of a non-toplevel widget
1063 // (e.g. a bubble on Linux) succeeds.
1064 TEST_F(WidgetCaptureTest, SetCaptureToNonToplevel) {
1065   Widget toplevel;
1066   Widget::InitParams toplevel_params =
1067       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
1068   toplevel_params.native_widget = CreateNativeWidget(true, &toplevel);
1069   toplevel_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
1070   toplevel.Init(toplevel_params);
1071   toplevel.Show();
1072
1073   Widget* child = new Widget;
1074   Widget::InitParams child_params =
1075       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
1076   child_params.parent = toplevel.GetNativeView();
1077   child_params.context = toplevel.GetNativeWindow();
1078   child->Init(child_params);
1079
1080   CaptureOnActivationObserver observer;
1081   child->AddObserver(&observer);
1082   child->Show();
1083
1084   EXPECT_TRUE(child->HasCapture());
1085 }
1086
1087
1088 #if defined(OS_WIN)
1089 namespace {
1090
1091 // Used to verify OnMouseEvent() has been invoked.
1092 class MouseEventTrackingWidget : public Widget {
1093  public:
1094   MouseEventTrackingWidget() : got_mouse_event_(false) {}
1095   virtual ~MouseEventTrackingWidget() {}
1096
1097   bool GetAndClearGotMouseEvent() {
1098     bool value = got_mouse_event_;
1099     got_mouse_event_ = false;
1100     return value;
1101   }
1102
1103   // Widget:
1104   virtual void OnMouseEvent(ui::MouseEvent* event) override {
1105     got_mouse_event_ = true;
1106     Widget::OnMouseEvent(event);
1107   }
1108
1109  private:
1110   bool got_mouse_event_;
1111
1112   DISALLOW_COPY_AND_ASSIGN(MouseEventTrackingWidget);
1113 };
1114
1115 }  // namespace
1116
1117 // Verifies if a mouse event is received on a widget that doesn't have capture
1118 // on Windows that it is correctly processed by the widget that doesn't have
1119 // capture. This behavior is not desired on OSes other than Windows.
1120 TEST_F(WidgetCaptureTest, MouseEventDispatchedToRightWindow) {
1121   MouseEventTrackingWidget widget1;
1122   Widget::InitParams params1 =
1123       CreateParams(views::Widget::InitParams::TYPE_WINDOW);
1124   params1.native_widget = new DesktopNativeWidgetAura(&widget1);
1125   params1.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
1126   widget1.Init(params1);
1127   widget1.Show();
1128
1129   MouseEventTrackingWidget widget2;
1130   Widget::InitParams params2 =
1131       CreateParams(views::Widget::InitParams::TYPE_WINDOW);
1132   params2.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
1133   params2.native_widget = new DesktopNativeWidgetAura(&widget2);
1134   widget2.Init(params2);
1135   widget2.Show();
1136
1137   // Set capture to widget2 and verity it gets it.
1138   widget2.SetCapture(widget2.GetRootView());
1139   EXPECT_FALSE(widget1.HasCapture());
1140   EXPECT_TRUE(widget2.HasCapture());
1141
1142   widget1.GetAndClearGotMouseEvent();
1143   widget2.GetAndClearGotMouseEvent();
1144   // Send a mouse event to the RootWindow associated with |widget1|. Even though
1145   // |widget2| has capture, |widget1| should still get the event.
1146   ui::MouseEvent mouse_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
1147                              ui::EF_NONE, ui::EF_NONE);
1148   ui::EventDispatchDetails details = widget1.GetNativeWindow()->
1149       GetHost()->event_processor()->OnEventFromSource(&mouse_event);
1150   ASSERT_FALSE(details.dispatcher_destroyed);
1151   EXPECT_TRUE(widget1.GetAndClearGotMouseEvent());
1152   EXPECT_FALSE(widget2.GetAndClearGotMouseEvent());
1153 }
1154 #endif  // defined(OS_WIN)
1155
1156 }  // namespace test
1157 }  // namespace views