ash/root_window_controller_unittest.cc

   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 "ash/root_window_controller.h"
   6
   7 #include "ash/display/display_manager.h"
   8 #include "ash/session/session_state_delegate.h"
   9 #include "ash/shelf/shelf_layout_manager.h"
  10 #include "ash/shell.h"
  11 #include "ash/shell_window_ids.h"
  12 #include "ash/system/tray/system_tray_delegate.h"
  13 #include "ash/test/ash_test_base.h"
  14 #include "ash/test/display_manager_test_api.h"
  15 #include "ash/wm/system_modal_container_layout_manager.h"
  16 #include "ash/wm/window_properties.h"
  17 #include "ash/wm/window_state.h"
  18 #include "ash/wm/window_util.h"
  19 #include "base/command_line.h"
  20 #include "base/memory/scoped_ptr.h"
  21 #include "ui/aura/client/focus_change_observer.h"
  22 #include "ui/aura/client/focus_client.h"
  23 #include "ui/aura/client/window_tree_client.h"
  24 #include "ui/aura/env.h"
  25 #include "ui/aura/test/test_window_delegate.h"
  26 #include "ui/aura/test/test_windows.h"
  27 #include "ui/aura/window.h"
  28 #include "ui/aura/window_event_dispatcher.h"
  29 #include "ui/aura/window_tracker.h"
  30 #include "ui/base/ime/dummy_text_input_client.h"
  31 #include "ui/base/ime/input_method.h"
  32 #include "ui/base/ime/text_input_client.h"
  33 #include "ui/events/test/event_generator.h"
  34 #include "ui/events/test/test_event_handler.h"
  35 #include "ui/keyboard/keyboard_controller_proxy.h"
  36 #include "ui/keyboard/keyboard_switches.h"
  37 #include "ui/keyboard/keyboard_util.h"
  38 #include "ui/views/controls/menu/menu_controller.h"
  39 #include "ui/views/widget/widget.h"
  40 #include "ui/views/widget/widget_delegate.h"
  41
  42 using aura::Window;
  43 using views::Widget;
  44
  45 namespace ash {
  46 namespace {
  47
  48 class TestDelegate : public views::WidgetDelegateView {
  49  public:
  50   explicit TestDelegate(bool system_modal) : system_modal_(system_modal) {}
  51   ~TestDelegate() override {}
  52
  53   // Overridden from views::WidgetDelegate:
  54   views::View* GetContentsView() override { return this; }
  55
  56   ui::ModalType GetModalType() const override {
  57     return system_modal_ ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE;
  58   }
  59
  60  private:
  61   bool system_modal_;
  62
  63   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
  64 };
  65
  66 class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate,
  67                              public aura::client::FocusChangeObserver {
  68  public:
  69   DeleteOnBlurDelegate() : window_(NULL) {}
  70   ~DeleteOnBlurDelegate() override {}
  71
  72   void SetWindow(aura::Window* window) {
  73     window_ = window;
  74     aura::client::SetFocusChangeObserver(window_, this);
  75   }
  76
  77  private:
  78   // aura::test::TestWindowDelegate overrides:
  79   bool CanFocus() override { return true; }
  80
  81   // aura::client::FocusChangeObserver implementation:
  82   void OnWindowFocused(aura::Window* gained_focus,
  83                        aura::Window* lost_focus) override {
  84     if (window_ == lost_focus)
  85       delete window_;
  86   }
  87
  88   aura::Window* window_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(DeleteOnBlurDelegate);
  91 };
  92
  93 }  // namespace
  94
  95 namespace test {
  96
  97 class RootWindowControllerTest : public test::AshTestBase {
  98  public:
  99   views::Widget* CreateTestWidget(const gfx::Rect& bounds) {
 100     views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
 101         NULL, CurrentContext(), bounds);
 102     widget->Show();
 103     return widget;
 104   }
 105
 106   views::Widget* CreateModalWidget(const gfx::Rect& bounds) {
 107     views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
 108         new TestDelegate(true), CurrentContext(), bounds);
 109     widget->Show();
 110     return widget;
 111   }
 112
 113   views::Widget* CreateModalWidgetWithParent(const gfx::Rect& bounds,
 114                                              gfx::NativeWindow parent) {
 115     views::Widget* widget =
 116         views::Widget::CreateWindowWithParentAndBounds(new TestDelegate(true),
 117                                                        parent,
 118                                                        bounds);
 119     widget->Show();
 120     return widget;
 121   }
 122
 123   aura::Window* GetModalContainer(aura::Window* root_window) {
 124     return Shell::GetContainer(root_window,
 125                                ash::kShellWindowId_SystemModalContainer);
 126   }
 127 };
 128
 129 TEST_F(RootWindowControllerTest, MoveWindows_Basic) {
 130   if (!SupportsMultipleDisplays())
 131     return;
 132   // Windows origin should be doubled when moved to the 1st display.
 133   UpdateDisplay("600x600,300x300");
 134   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 135   RootWindowController* controller = Shell::GetPrimaryRootWindowController();
 136   ShelfLayoutManager* shelf_layout_manager =
 137       controller->GetShelfLayoutManager();
 138   shelf_layout_manager->SetAutoHideBehavior(
 139       ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 140
 141   views::Widget* normal = CreateTestWidget(gfx::Rect(650, 10, 100, 100));
 142   EXPECT_EQ(root_windows[1], normal->GetNativeView()->GetRootWindow());
 143   EXPECT_EQ("650,10 100x100", normal->GetWindowBoundsInScreen().ToString());
 144   EXPECT_EQ("50,10 100x100",
 145             normal->GetNativeView()->GetBoundsInRootWindow().ToString());
 146
 147   views::Widget* maximized = CreateTestWidget(gfx::Rect(700, 10, 100, 100));
 148   maximized->Maximize();
 149   EXPECT_EQ(root_windows[1], maximized->GetNativeView()->GetRootWindow());
 150   EXPECT_EQ("600,0 300x253", maximized->GetWindowBoundsInScreen().ToString());
 151   EXPECT_EQ("0,0 300x253",
 152             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 153
 154   views::Widget* minimized = CreateTestWidget(gfx::Rect(800, 10, 100, 100));
 155   minimized->Minimize();
 156   EXPECT_EQ(root_windows[1], minimized->GetNativeView()->GetRootWindow());
 157   EXPECT_EQ("800,10 100x100",
 158             minimized->GetWindowBoundsInScreen().ToString());
 159
 160   views::Widget* fullscreen = CreateTestWidget(gfx::Rect(850, 10, 100, 100));
 161   fullscreen->SetFullscreen(true);
 162   EXPECT_EQ(root_windows[1], fullscreen->GetNativeView()->GetRootWindow());
 163
 164   EXPECT_EQ("600,0 300x300",
 165             fullscreen->GetWindowBoundsInScreen().ToString());
 166   EXPECT_EQ("0,0 300x300",
 167             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 168
 169   views::Widget* unparented_control = new Widget;
 170   Widget::InitParams params;
 171   params.bounds = gfx::Rect(650, 10, 100, 100);
 172   params.context = CurrentContext();
 173   params.type = Widget::InitParams::TYPE_CONTROL;
 174   unparented_control->Init(params);
 175   EXPECT_EQ(root_windows[1],
 176             unparented_control->GetNativeView()->GetRootWindow());
 177   EXPECT_EQ(kShellWindowId_UnparentedControlContainer,
 178             unparented_control->GetNativeView()->parent()->id());
 179
 180   aura::Window* panel = CreateTestWindowInShellWithDelegateAndType(
 181       NULL, ui::wm::WINDOW_TYPE_PANEL, 0, gfx::Rect(700, 100, 100, 100));
 182   EXPECT_EQ(root_windows[1], panel->GetRootWindow());
 183   EXPECT_EQ(kShellWindowId_PanelContainer, panel->parent()->id());
 184
 185   // Make sure a window that will delete itself when losing focus
 186   // will not crash.
 187   aura::WindowTracker tracker;
 188   DeleteOnBlurDelegate delete_on_blur_delegate;
 189   aura::Window* d2 = CreateTestWindowInShellWithDelegate(
 190       &delete_on_blur_delegate, 0, gfx::Rect(50, 50, 100, 100));
 191   delete_on_blur_delegate.SetWindow(d2);
 192   aura::client::GetFocusClient(root_windows[0])->FocusWindow(d2);
 193   tracker.Add(d2);
 194
 195   UpdateDisplay("600x600");
 196
 197   // d2 must have been deleted.
 198   EXPECT_FALSE(tracker.Contains(d2));
 199
 200   EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow());
 201   EXPECT_EQ("100,20 100x100", normal->GetWindowBoundsInScreen().ToString());
 202   EXPECT_EQ("100,20 100x100",
 203             normal->GetNativeView()->GetBoundsInRootWindow().ToString());
 204
 205   // Maximized area on primary display has 3px (given as
 206   // kAutoHideSize in shelf_layout_manager.cc) inset at the bottom.
 207
 208   // First clear fullscreen status, since both fullscreen and maximized windows
 209   // share the same desktop workspace, which cancels the shelf status.
 210   fullscreen->SetFullscreen(false);
 211   EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow());
 212   EXPECT_EQ("0,0 600x597",
 213             maximized->GetWindowBoundsInScreen().ToString());
 214   EXPECT_EQ("0,0 600x597",
 215             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 216
 217   // Set fullscreen to true. In that case the 3px inset becomes invisible so
 218   // the maximized window can also use the area fully.
 219   fullscreen->SetFullscreen(true);
 220   EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow());
 221   EXPECT_EQ("0,0 600x600",
 222             maximized->GetWindowBoundsInScreen().ToString());
 223   EXPECT_EQ("0,0 600x600",
 224             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 225
 226   EXPECT_EQ(root_windows[0], minimized->GetNativeView()->GetRootWindow());
 227   EXPECT_EQ("400,20 100x100",
 228             minimized->GetWindowBoundsInScreen().ToString());
 229
 230   EXPECT_EQ(root_windows[0], fullscreen->GetNativeView()->GetRootWindow());
 231   EXPECT_TRUE(fullscreen->IsFullscreen());
 232   EXPECT_EQ("0,0 600x600",
 233             fullscreen->GetWindowBoundsInScreen().ToString());
 234   EXPECT_EQ("0,0 600x600",
 235             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 236
 237   // Test if the restore bounds are correctly updated.
 238   wm::GetWindowState(maximized->GetNativeView())->Restore();
 239   EXPECT_EQ("200,20 100x100", maximized->GetWindowBoundsInScreen().ToString());
 240   EXPECT_EQ("200,20 100x100",
 241             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 242
 243   fullscreen->SetFullscreen(false);
 244   EXPECT_EQ("500,20 100x100",
 245             fullscreen->GetWindowBoundsInScreen().ToString());
 246   EXPECT_EQ("500,20 100x100",
 247             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 248
 249   // Test if the unparented widget has moved.
 250   EXPECT_EQ(root_windows[0],
 251             unparented_control->GetNativeView()->GetRootWindow());
 252   EXPECT_EQ(kShellWindowId_UnparentedControlContainer,
 253             unparented_control->GetNativeView()->parent()->id());
 254
 255   // Test if the panel has moved.
 256   EXPECT_EQ(root_windows[0], panel->GetRootWindow());
 257   EXPECT_EQ(kShellWindowId_PanelContainer, panel->parent()->id());
 258 }
 259
 260 TEST_F(RootWindowControllerTest, MoveWindows_Modal) {
 261   if (!SupportsMultipleDisplays())
 262     return;
 263
 264   UpdateDisplay("500x500,500x500");
 265
 266   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 267   // Emulate virtual screen coordinate system.
 268   root_windows[0]->SetBounds(gfx::Rect(0, 0, 500, 500));
 269   root_windows[1]->SetBounds(gfx::Rect(500, 0, 500, 500));
 270
 271   views::Widget* normal = CreateTestWidget(gfx::Rect(300, 10, 100, 100));
 272   EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow());
 273   EXPECT_TRUE(wm::IsActiveWindow(normal->GetNativeView()));
 274
 275   views::Widget* modal = CreateModalWidget(gfx::Rect(650, 10, 100, 100));
 276   EXPECT_EQ(root_windows[1], modal->GetNativeView()->GetRootWindow());
 277   EXPECT_TRUE(GetModalContainer(root_windows[1])->Contains(
 278       modal->GetNativeView()));
 279   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 280
 281   ui::test::EventGenerator generator_1st(root_windows[0]);
 282   generator_1st.ClickLeftButton();
 283   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 284
 285   UpdateDisplay("500x500");
 286   EXPECT_EQ(root_windows[0], modal->GetNativeView()->GetRootWindow());
 287   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 288   generator_1st.ClickLeftButton();
 289   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 290 }
 291
 292 // Make sure lock related windows moves.
 293 TEST_F(RootWindowControllerTest, MoveWindows_LockWindowsInUnified) {
 294   if (!SupportsMultipleDisplays())
 295     return;
 296   test::DisplayManagerTestApi::EnableUnifiedDesktopForTest();
 297
 298   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 299   display_manager->SetDefaultMultiDisplayMode(DisplayManager::UNIFIED);
 300   display_manager->SetMultiDisplayMode(DisplayManager::UNIFIED);
 301   UpdateDisplay("500x500");
 302   const int kLockScreenWindowId = 1000;
 303   const int kLockBackgroundWindowId = 1001;
 304
 305   RootWindowController* controller =
 306       Shell::GetInstance()->GetPrimaryRootWindowController();
 307
 308   aura::Window* lock_container =
 309       controller->GetContainer(kShellWindowId_LockScreenContainer);
 310   aura::Window* lock_background_container =
 311       controller->GetContainer(kShellWindowId_LockScreenBackgroundContainer);
 312
 313   views::Widget* lock_screen =
 314       CreateModalWidgetWithParent(gfx::Rect(10, 10, 100, 100), lock_container);
 315   lock_screen->GetNativeWindow()->set_id(kLockScreenWindowId);
 316   lock_screen->SetFullscreen(true);
 317
 318   views::Widget* lock_background = CreateModalWidgetWithParent(
 319       gfx::Rect(10, 10, 100, 100), lock_background_container);
 320   lock_background->GetNativeWindow()->set_id(kLockBackgroundWindowId);
 321
 322   ASSERT_EQ(lock_screen->GetNativeWindow(),
 323             controller->GetRootWindow()->GetChildById(kLockScreenWindowId));
 324   ASSERT_EQ(lock_background->GetNativeWindow(),
 325             controller->GetRootWindow()->GetChildById(kLockBackgroundWindowId));
 326   EXPECT_EQ("0,0 500x500", lock_screen->GetNativeWindow()->bounds().ToString());
 327
 328   // Switch to unified.
 329   UpdateDisplay("500x500,500x500");
 330
 331   // In unified mode, RWC is created
 332   controller = Shell::GetInstance()->GetPrimaryRootWindowController();
 333
 334   ASSERT_EQ(lock_screen->GetNativeWindow(),
 335             controller->GetRootWindow()->GetChildById(kLockScreenWindowId));
 336   ASSERT_EQ(lock_background->GetNativeWindow(),
 337             controller->GetRootWindow()->GetChildById(kLockBackgroundWindowId));
 338   EXPECT_EQ("0,0 500x500", lock_screen->GetNativeWindow()->bounds().ToString());
 339
 340   // Switch to mirror.
 341   display_manager->SetMirrorMode(true);
 342   EXPECT_TRUE(display_manager->IsInMirrorMode());
 343
 344   controller = Shell::GetInstance()->GetPrimaryRootWindowController();
 345   ASSERT_EQ(lock_screen->GetNativeWindow(),
 346             controller->GetRootWindow()->GetChildById(kLockScreenWindowId));
 347   ASSERT_EQ(lock_background->GetNativeWindow(),
 348             controller->GetRootWindow()->GetChildById(kLockBackgroundWindowId));
 349   EXPECT_EQ("0,0 500x500", lock_screen->GetNativeWindow()->bounds().ToString());
 350
 351   // Switch to unified.
 352   display_manager->SetMirrorMode(false);
 353   EXPECT_TRUE(display_manager->IsInUnifiedMode());
 354
 355   controller = Shell::GetInstance()->GetPrimaryRootWindowController();
 356
 357   ASSERT_EQ(lock_screen->GetNativeWindow(),
 358             controller->GetRootWindow()->GetChildById(kLockScreenWindowId));
 359   ASSERT_EQ(lock_background->GetNativeWindow(),
 360             controller->GetRootWindow()->GetChildById(kLockBackgroundWindowId));
 361   EXPECT_EQ("0,0 500x500", lock_screen->GetNativeWindow()->bounds().ToString());
 362
 363   // Switch to single display.
 364   UpdateDisplay("600x500");
 365   EXPECT_FALSE(display_manager->IsInUnifiedMode());
 366   EXPECT_FALSE(display_manager->IsInMirrorMode());
 367
 368   controller = Shell::GetInstance()->GetPrimaryRootWindowController();
 369
 370   ASSERT_EQ(lock_screen->GetNativeWindow(),
 371             controller->GetRootWindow()->GetChildById(kLockScreenWindowId));
 372   ASSERT_EQ(lock_background->GetNativeWindow(),
 373             controller->GetRootWindow()->GetChildById(kLockBackgroundWindowId));
 374   EXPECT_EQ("0,0 600x500", lock_screen->GetNativeWindow()->bounds().ToString());
 375 }
 376
 377 TEST_F(RootWindowControllerTest, ModalContainer) {
 378   UpdateDisplay("600x600");
 379   Shell* shell = Shell::GetInstance();
 380   RootWindowController* controller = shell->GetPrimaryRootWindowController();
 381   EXPECT_EQ(user::LOGGED_IN_USER,
 382             shell->system_tray_delegate()->GetUserLoginStatus());
 383   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 384                 ->layout_manager(),
 385             controller->GetSystemModalLayoutManager(NULL));
 386
 387   views::Widget* session_modal_widget =
 388       CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 389   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 390                 ->layout_manager(),
 391             controller->GetSystemModalLayoutManager(
 392                 session_modal_widget->GetNativeView()));
 393
 394   shell->session_state_delegate()->LockScreen();
 395   EXPECT_EQ(user::LOGGED_IN_LOCKED,
 396             shell->system_tray_delegate()->GetUserLoginStatus());
 397   EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 398                 ->layout_manager(),
 399             controller->GetSystemModalLayoutManager(NULL));
 400
 401   aura::Window* lock_container =
 402       controller->GetContainer(kShellWindowId_LockScreenContainer);
 403   views::Widget* lock_modal_widget =
 404       CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100), lock_container);
 405   EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 406                 ->layout_manager(),
 407             controller->GetSystemModalLayoutManager(
 408                 lock_modal_widget->GetNativeView()));
 409   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 410                 ->layout_manager(),
 411             controller->GetSystemModalLayoutManager(
 412                 session_modal_widget->GetNativeView()));
 413
 414   shell->session_state_delegate()->UnlockScreen();
 415 }
 416
 417 TEST_F(RootWindowControllerTest, ModalContainerNotLoggedInLoggedIn) {
 418   UpdateDisplay("600x600");
 419   Shell* shell = Shell::GetInstance();
 420
 421   // Configure login screen environment.
 422   SetUserLoggedIn(false);
 423   EXPECT_EQ(user::LOGGED_IN_NONE,
 424             shell->system_tray_delegate()->GetUserLoginStatus());
 425   EXPECT_EQ(0, shell->session_state_delegate()->NumberOfLoggedInUsers());
 426   EXPECT_FALSE(shell->session_state_delegate()->IsActiveUserSessionStarted());
 427
 428   RootWindowController* controller = shell->GetPrimaryRootWindowController();
 429   EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 430                 ->layout_manager(),
 431             controller->GetSystemModalLayoutManager(NULL));
 432
 433   aura::Window* lock_container =
 434       controller->GetContainer(kShellWindowId_LockScreenContainer);
 435   views::Widget* login_modal_widget =
 436       CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100), lock_container);
 437   EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 438                 ->layout_manager(),
 439             controller->GetSystemModalLayoutManager(
 440                 login_modal_widget->GetNativeView()));
 441   login_modal_widget->Close();
 442
 443   // Configure user session environment.
 444   SetUserLoggedIn(true);
 445   SetSessionStarted(true);
 446   EXPECT_EQ(user::LOGGED_IN_USER,
 447             shell->system_tray_delegate()->GetUserLoginStatus());
 448   EXPECT_EQ(1, shell->session_state_delegate()->NumberOfLoggedInUsers());
 449   EXPECT_TRUE(shell->session_state_delegate()->IsActiveUserSessionStarted());
 450   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 451                 ->layout_manager(),
 452             controller->GetSystemModalLayoutManager(NULL));
 453
 454   views::Widget* session_modal_widget =
 455         CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 456   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 457                 ->layout_manager(),
 458             controller->GetSystemModalLayoutManager(
 459                 session_modal_widget->GetNativeView()));
 460 }
 461
 462 TEST_F(RootWindowControllerTest, ModalContainerBlockedSession) {
 463   UpdateDisplay("600x600");
 464   RootWindowController* controller = Shell::GetPrimaryRootWindowController();
 465   aura::Window* lock_container =
 466       controller->GetContainer(kShellWindowId_LockScreenContainer);
 467   for (int block_reason = FIRST_BLOCK_REASON;
 468        block_reason < NUMBER_OF_BLOCK_REASONS;
 469        ++block_reason) {
 470     views::Widget* session_modal_widget =
 471           CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 472     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 473                   ->layout_manager(),
 474               controller->GetSystemModalLayoutManager(
 475                   session_modal_widget->GetNativeView()));
 476     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 477                   ->layout_manager(),
 478               controller->GetSystemModalLayoutManager(NULL));
 479     session_modal_widget->Close();
 480
 481     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 482
 483     EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 484                   ->layout_manager(),
 485               controller->GetSystemModalLayoutManager(NULL));
 486
 487     views::Widget* lock_modal_widget =
 488         CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100),
 489                                     lock_container);
 490     EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
 491                   ->layout_manager(),
 492               controller->GetSystemModalLayoutManager(
 493                   lock_modal_widget->GetNativeView()));
 494
 495     session_modal_widget =
 496           CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 497     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
 498                   ->layout_manager(),
 499               controller->GetSystemModalLayoutManager(
 500                   session_modal_widget->GetNativeView()));
 501     session_modal_widget->Close();
 502
 503     lock_modal_widget->Close();
 504     UnblockUserSession();
 505   }
 506 }
 507
 508 TEST_F(RootWindowControllerTest, GetWindowForFullscreenMode) {
 509   UpdateDisplay("600x600");
 510   RootWindowController* controller =
 511       Shell::GetInstance()->GetPrimaryRootWindowController();
 512
 513   Widget* w1 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 514   w1->Maximize();
 515   Widget* w2 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 516   w2->SetFullscreen(true);
 517   // |w3| is a transient child of |w2|.
 518   Widget* w3 = Widget::CreateWindowWithParentAndBounds(NULL,
 519       w2->GetNativeWindow(), gfx::Rect(0, 0, 100, 100));
 520
 521   // Test that GetWindowForFullscreenMode() finds the fullscreen window when one
 522   // of its transient children is active.
 523   w3->Activate();
 524   EXPECT_EQ(w2->GetNativeWindow(), controller->GetWindowForFullscreenMode());
 525
 526   // If the topmost window is not fullscreen, it returns NULL.
 527   w1->Activate();
 528   EXPECT_EQ(NULL, controller->GetWindowForFullscreenMode());
 529   w1->Close();
 530   w3->Close();
 531
 532   // Only w2 remains, if minimized GetWindowForFullscreenMode should return
 533   // NULL.
 534   w2->Activate();
 535   EXPECT_EQ(w2->GetNativeWindow(), controller->GetWindowForFullscreenMode());
 536   w2->Minimize();
 537   EXPECT_EQ(NULL, controller->GetWindowForFullscreenMode());
 538 }
 539
 540 TEST_F(RootWindowControllerTest, MultipleDisplaysGetWindowForFullscreenMode) {
 541   if (!SupportsMultipleDisplays())
 542     return;
 543
 544   UpdateDisplay("600x600,600x600");
 545   Shell::RootWindowControllerList controllers =
 546       Shell::GetInstance()->GetAllRootWindowControllers();
 547
 548   Widget* w1 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 549   w1->Maximize();
 550   Widget* w2 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 551   w2->SetFullscreen(true);
 552   Widget* w3 = CreateTestWidget(gfx::Rect(600, 0, 100, 100));
 553
 554   EXPECT_EQ(w1->GetNativeWindow()->GetRootWindow(),
 555             controllers[0]->GetRootWindow());
 556   EXPECT_EQ(w2->GetNativeWindow()->GetRootWindow(),
 557             controllers[0]->GetRootWindow());
 558   EXPECT_EQ(w3->GetNativeWindow()->GetRootWindow(),
 559             controllers[1]->GetRootWindow());
 560
 561   w1->Activate();
 562   EXPECT_EQ(NULL, controllers[0]->GetWindowForFullscreenMode());
 563   EXPECT_EQ(NULL, controllers[1]->GetWindowForFullscreenMode());
 564
 565   w2->Activate();
 566   EXPECT_EQ(w2->GetNativeWindow(),
 567             controllers[0]->GetWindowForFullscreenMode());
 568   EXPECT_EQ(NULL, controllers[1]->GetWindowForFullscreenMode());
 569
 570   // Verify that the first root window controller remains in fullscreen mode
 571   // when a window on the other display is activated.
 572   w3->Activate();
 573   EXPECT_EQ(w2->GetNativeWindow(),
 574             controllers[0]->GetWindowForFullscreenMode());
 575   EXPECT_EQ(NULL, controllers[1]->GetWindowForFullscreenMode());
 576 }
 577
 578 // Test that user session window can't be focused if user session blocked by
 579 // some overlapping UI.
 580 TEST_F(RootWindowControllerTest, FocusBlockedWindow) {
 581   UpdateDisplay("600x600");
 582   RootWindowController* controller =
 583       Shell::GetInstance()->GetPrimaryRootWindowController();
 584   aura::Window* lock_container =
 585       controller->GetContainer(kShellWindowId_LockScreenContainer);
 586   aura::Window* lock_window = Widget::CreateWindowWithParentAndBounds(NULL,
 587       lock_container, gfx::Rect(0, 0, 100, 100))->GetNativeView();
 588   lock_window->Show();
 589   aura::Window* session_window =
 590       CreateTestWidget(gfx::Rect(0, 0, 100, 100))->GetNativeView();
 591   session_window->Show();
 592
 593   for (int block_reason = FIRST_BLOCK_REASON;
 594        block_reason < NUMBER_OF_BLOCK_REASONS;
 595        ++block_reason) {
 596     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 597     lock_window->Focus();
 598     EXPECT_TRUE(lock_window->HasFocus());
 599     session_window->Focus();
 600     EXPECT_FALSE(session_window->HasFocus());
 601     UnblockUserSession();
 602   }
 603 }
 604
 605 // Tracks whether OnWindowDestroying() has been invoked.
 606 class DestroyedWindowObserver : public aura::WindowObserver {
 607  public:
 608   DestroyedWindowObserver() : destroyed_(false), window_(NULL) {}
 609   ~DestroyedWindowObserver() override { Shutdown(); }
 610
 611   void SetWindow(Window* window) {
 612     window_ = window;
 613     window->AddObserver(this);
 614   }
 615
 616   bool destroyed() const { return destroyed_; }
 617
 618   // WindowObserver overrides:
 619   void OnWindowDestroying(Window* window) override {
 620     destroyed_ = true;
 621     Shutdown();
 622   }
 623
 624  private:
 625   void Shutdown() {
 626     if (!window_)
 627       return;
 628     window_->RemoveObserver(this);
 629     window_ = NULL;
 630   }
 631
 632   bool destroyed_;
 633   Window* window_;
 634
 635   DISALLOW_COPY_AND_ASSIGN(DestroyedWindowObserver);
 636 };
 637
 638 // Verifies shutdown doesn't delete windows that are not owned by the parent.
 639 TEST_F(RootWindowControllerTest, DontDeleteWindowsNotOwnedByParent) {
 640   DestroyedWindowObserver observer1;
 641   aura::test::TestWindowDelegate delegate1;
 642   aura::Window* window1 = new aura::Window(&delegate1);
 643   window1->SetType(ui::wm::WINDOW_TYPE_CONTROL);
 644   window1->set_owned_by_parent(false);
 645   observer1.SetWindow(window1);
 646   window1->Init(ui::LAYER_NOT_DRAWN);
 647   aura::client::ParentWindowWithContext(
 648       window1, Shell::GetInstance()->GetPrimaryRootWindow(), gfx::Rect());
 649
 650   DestroyedWindowObserver observer2;
 651   aura::Window* window2 = new aura::Window(NULL);
 652   window2->set_owned_by_parent(false);
 653   observer2.SetWindow(window2);
 654   window2->Init(ui::LAYER_NOT_DRAWN);
 655   Shell::GetInstance()->GetPrimaryRootWindow()->AddChild(window2);
 656
 657   Shell::GetInstance()->GetPrimaryRootWindowController()->CloseChildWindows();
 658
 659   ASSERT_FALSE(observer1.destroyed());
 660   delete window1;
 661
 662   ASSERT_FALSE(observer2.destroyed());
 663   delete window2;
 664 }
 665
 666 typedef test::NoSessionAshTestBase NoSessionRootWindowControllerTest;
 667
 668 // Make sure that an event handler exists for entire display area.
 669 TEST_F(NoSessionRootWindowControllerTest, Event) {
 670   // Hide the shelf since it might otherwise get an event target.
 671   RootWindowController* controller = Shell::GetPrimaryRootWindowController();
 672   ShelfLayoutManager* shelf_layout_manager =
 673       controller->GetShelfLayoutManager();
 674   shelf_layout_manager->SetAutoHideBehavior(
 675       ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
 676
 677   aura::Window* root = Shell::GetPrimaryRootWindow();
 678   const gfx::Size size = root->bounds().size();
 679   aura::Window* event_target = root->GetEventHandlerForPoint(gfx::Point(0, 0));
 680   EXPECT_TRUE(event_target);
 681   EXPECT_EQ(event_target,
 682             root->GetEventHandlerForPoint(gfx::Point(0, size.height() - 1)));
 683   EXPECT_EQ(event_target,
 684             root->GetEventHandlerForPoint(gfx::Point(size.width() - 1, 0)));
 685   EXPECT_EQ(event_target,
 686             root->GetEventHandlerForPoint(gfx::Point(0, size.height() - 1)));
 687   EXPECT_EQ(event_target,
 688             root->GetEventHandlerForPoint(
 689                 gfx::Point(size.width() - 1, size.height() - 1)));
 690 }
 691
 692 class VirtualKeyboardRootWindowControllerTest
 693     : public RootWindowControllerTest {
 694  public:
 695   VirtualKeyboardRootWindowControllerTest() {}
 696   ~VirtualKeyboardRootWindowControllerTest() override {}
 697
 698   void SetUp() override {
 699     base::CommandLine::ForCurrentProcess()->AppendSwitch(
 700         keyboard::switches::kEnableVirtualKeyboard);
 701     test::AshTestBase::SetUp();
 702     Shell::GetPrimaryRootWindowController()->ActivateKeyboard(
 703         keyboard::KeyboardController::GetInstance());
 704   }
 705
 706  private:
 707   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardRootWindowControllerTest);
 708 };
 709
 710 class MockTextInputClient : public ui::DummyTextInputClient {
 711  public:
 712   MockTextInputClient() :
 713       ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
 714
 715   void EnsureCaretInRect(const gfx::Rect& rect) override {
 716     visible_rect_ = rect;
 717   }
 718
 719   const gfx::Rect& visible_rect() const {
 720     return visible_rect_;
 721   }
 722
 723  private:
 724   gfx::Rect visible_rect_;
 725
 726   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 727 };
 728
 729 class TargetHitTestEventHandler : public ui::test::TestEventHandler {
 730  public:
 731   TargetHitTestEventHandler() {}
 732
 733   // ui::test::TestEventHandler overrides.
 734   void OnMouseEvent(ui::MouseEvent* event) override {
 735     if (event->type() == ui::ET_MOUSE_PRESSED)
 736       ui::test::TestEventHandler::OnMouseEvent(event);
 737     event->StopPropagation();
 738   }
 739
 740  private:
 741   DISALLOW_COPY_AND_ASSIGN(TargetHitTestEventHandler);
 742 };
 743
 744 // Test for http://crbug.com/297858. Virtual keyboard container should only show
 745 // on primary root window.
 746 TEST_F(VirtualKeyboardRootWindowControllerTest,
 747        VirtualKeyboardOnPrimaryRootWindowOnly) {
 748   if (!SupportsMultipleDisplays())
 749     return;
 750
 751   UpdateDisplay("500x500,500x500");
 752
 753   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 754   aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
 755   aura::Window* secondary_root_window =
 756       root_windows[0] == primary_root_window ?
 757           root_windows[1] : root_windows[0];
 758
 759   ASSERT_TRUE(Shell::GetContainer(primary_root_window,
 760                                   kShellWindowId_VirtualKeyboardContainer));
 761   ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
 762                                    kShellWindowId_VirtualKeyboardContainer));
 763 }
 764
 765 // Test for http://crbug.com/263599. Virtual keyboard should be able to receive
 766 // events at blocked user session.
 767 TEST_F(VirtualKeyboardRootWindowControllerTest,
 768        ClickVirtualKeyboardInBlockedWindow) {
 769   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 770   aura::Window* keyboard_container =
 771       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 772   ASSERT_TRUE(keyboard_container);
 773   keyboard_container->Show();
 774
 775   aura::Window* keyboard_window = keyboard::KeyboardController::GetInstance()->
 776       proxy()->GetKeyboardWindow();
 777   keyboard_container->AddChild(keyboard_window);
 778   keyboard_window->set_owned_by_parent(false);
 779   keyboard_window->SetBounds(gfx::Rect());
 780   keyboard_window->Show();
 781
 782   ui::test::TestEventHandler handler;
 783   root_window->AddPreTargetHandler(&handler);
 784
 785   ui::test::EventGenerator event_generator(root_window, keyboard_window);
 786   event_generator.ClickLeftButton();
 787   int expected_mouse_presses = 1;
 788   EXPECT_EQ(expected_mouse_presses, handler.num_mouse_events() / 2);
 789
 790   for (int block_reason = FIRST_BLOCK_REASON;
 791        block_reason < NUMBER_OF_BLOCK_REASONS;
 792        ++block_reason) {
 793     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 794     event_generator.ClickLeftButton();
 795     expected_mouse_presses++;
 796     EXPECT_EQ(expected_mouse_presses, handler.num_mouse_events() / 2);
 797     UnblockUserSession();
 798   }
 799   root_window->RemovePreTargetHandler(&handler);
 800 }
 801
 802 // Test for http://crbug.com/299787. RootWindowController should delete
 803 // the old container since the keyboard controller creates a new window in
 804 // GetWindowContainer().
 805 TEST_F(VirtualKeyboardRootWindowControllerTest,
 806        DeleteOldContainerOnVirtualKeyboardInit) {
 807   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 808   aura::Window* keyboard_container =
 809       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 810   ASSERT_TRUE(keyboard_container);
 811   // Track the keyboard container window.
 812   aura::WindowTracker tracker;
 813   tracker.Add(keyboard_container);
 814   // Mock a login user profile change to reinitialize the keyboard.
 815   ash::Shell::GetInstance()->OnLoginUserProfilePrepared();
 816   // keyboard_container should no longer be present.
 817   EXPECT_FALSE(tracker.Contains(keyboard_container));
 818 }
 819
 820 // Test for crbug.com/342524. After user login, the work space should restore to
 821 // full screen.
 822 TEST_F(VirtualKeyboardRootWindowControllerTest, RestoreWorkspaceAfterLogin) {
 823   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 824   aura::Window* keyboard_container =
 825       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 826   keyboard_container->Show();
 827   keyboard::KeyboardController* controller =
 828       keyboard::KeyboardController::GetInstance();
 829   aura::Window* keyboard_window = controller->proxy()->GetKeyboardWindow();
 830   keyboard_container->AddChild(keyboard_window);
 831   keyboard_window->set_owned_by_parent(false);
 832   keyboard_window->SetBounds(keyboard::FullWidthKeyboardBoundsFromRootBounds(
 833       root_window->bounds(), 100));
 834   keyboard_window->Show();
 835
 836   gfx::Rect before = ash::Shell::GetScreen()->GetPrimaryDisplay().work_area();
 837
 838   // Notify keyboard bounds changing.
 839   controller->NotifyKeyboardBoundsChanging(keyboard_container->bounds());
 840
 841   if (!keyboard::IsKeyboardOverscrollEnabled()) {
 842     gfx::Rect after = ash::Shell::GetScreen()->GetPrimaryDisplay().work_area();
 843     EXPECT_LT(after, before);
 844   }
 845
 846   // Mock a login user profile change to reinitialize the keyboard.
 847   ash::Shell::GetInstance()->OnLoginUserProfilePrepared();
 848   EXPECT_EQ(ash::Shell::GetScreen()->GetPrimaryDisplay().work_area(), before);
 849 }
 850
 851 // Ensure that system modal dialogs do not block events targeted at the virtual
 852 // keyboard.
 853 TEST_F(VirtualKeyboardRootWindowControllerTest, ClickWithActiveModalDialog) {
 854   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 855   aura::Window* keyboard_container =
 856       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 857   ASSERT_TRUE(keyboard_container);
 858   keyboard_container->Show();
 859
 860   aura::Window* keyboard_window = keyboard::KeyboardController::GetInstance()->
 861       proxy()->GetKeyboardWindow();
 862   keyboard_container->AddChild(keyboard_window);
 863   keyboard_window->set_owned_by_parent(false);
 864   keyboard_window->SetBounds(keyboard::FullWidthKeyboardBoundsFromRootBounds(
 865       root_window->bounds(), 100));
 866
 867   ui::test::TestEventHandler handler;
 868   root_window->AddPreTargetHandler(&handler);
 869   ui::test::EventGenerator root_window_event_generator(root_window);
 870   ui::test::EventGenerator keyboard_event_generator(root_window,
 871                                                     keyboard_window);
 872
 873   views::Widget* modal_widget =
 874       CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 875
 876   // Verify that mouse events to the root window are block with a visble modal
 877   // dialog.
 878   root_window_event_generator.ClickLeftButton();
 879   EXPECT_EQ(0, handler.num_mouse_events());
 880
 881   // Verify that event dispatch to the virtual keyboard is unblocked.
 882   keyboard_event_generator.ClickLeftButton();
 883   EXPECT_EQ(1, handler.num_mouse_events() / 2);
 884
 885   modal_widget->Close();
 886
 887   // Verify that mouse events are now unblocked to the root window.
 888   root_window_event_generator.ClickLeftButton();
 889   EXPECT_EQ(2, handler.num_mouse_events() / 2);
 890   root_window->RemovePreTargetHandler(&handler);
 891 }
 892
 893 // Ensure that the visible area for scrolling the text caret excludes the
 894 // region occluded by the on-screen keyboard.
 895 TEST_F(VirtualKeyboardRootWindowControllerTest, EnsureCaretInWorkArea) {
 896   keyboard::KeyboardController* keyboard_controller =
 897       keyboard::KeyboardController::GetInstance();
 898   keyboard::KeyboardControllerProxy* proxy = keyboard_controller->proxy();
 899
 900   MockTextInputClient text_input_client;
 901   ui::InputMethod* input_method = proxy->GetInputMethod();
 902   ASSERT_TRUE(input_method);
 903   input_method->SetFocusedTextInputClient(&text_input_client);
 904
 905   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 906   aura::Window* keyboard_container =
 907       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 908   ASSERT_TRUE(keyboard_container);
 909   keyboard_container->Show();
 910
 911   const int keyboard_height = 100;
 912   aura::Window* keyboard_window =proxy->GetKeyboardWindow();
 913   keyboard_container->AddChild(keyboard_window);
 914   keyboard_window->set_owned_by_parent(false);
 915   keyboard_window->SetBounds(keyboard::FullWidthKeyboardBoundsFromRootBounds(
 916       root_window->bounds(), keyboard_height));
 917
 918   proxy->EnsureCaretInWorkArea();
 919   ASSERT_EQ(root_window->bounds().width(),
 920             text_input_client.visible_rect().width());
 921   ASSERT_EQ(root_window->bounds().height() - keyboard_height,
 922             text_input_client.visible_rect().height());
 923
 924   input_method->SetFocusedTextInputClient(NULL);
 925 }
 926
 927 // Tests that the virtual keyboard does not block context menus. The virtual
 928 // keyboard should appear in front of most content, but not context menus. See
 929 // crbug/377180.
 930 TEST_F(VirtualKeyboardRootWindowControllerTest, ZOrderTest) {
 931   UpdateDisplay("800x600");
 932   keyboard::KeyboardController* keyboard_controller =
 933       keyboard::KeyboardController::GetInstance();
 934   keyboard::KeyboardControllerProxy* proxy = keyboard_controller->proxy();
 935
 936   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 937   aura::Window* keyboard_container =
 938       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
 939   ASSERT_TRUE(keyboard_container);
 940   keyboard_container->Show();
 941
 942   const int keyboard_height = 200;
 943   aura::Window* keyboard_window = proxy->GetKeyboardWindow();
 944   keyboard_container->AddChild(keyboard_window);
 945   keyboard_window->set_owned_by_parent(false);
 946   gfx::Rect keyboard_bounds = keyboard::FullWidthKeyboardBoundsFromRootBounds(
 947       root_window->bounds(), keyboard_height);
 948   keyboard_window->SetBounds(keyboard_bounds);
 949   keyboard_window->Show();
 950
 951   ui::test::EventGenerator generator(root_window);
 952
 953   // Cover the screen with two windows: a normal window on the left side and a
 954   // context menu on the right side. When the virtual keyboard is displayed it
 955   // partially occludes the normal window, but not the context menu. Compute
 956   // positions for generating synthetic click events to perform hit tests,
 957   // ensuring the correct window layering. 'top' is above the VK, whereas
 958   // 'bottom' lies within the VK. 'left' is centered in the normal window, and
 959   // 'right' is centered in the context menu.
 960   int window_height = keyboard_bounds.bottom();
 961   int window_width = keyboard_bounds.width() / 2;
 962   int left = window_width / 2;
 963   int right = 3 * window_width / 2;
 964   int top = keyboard_bounds.y() / 2;
 965   int bottom = window_height - keyboard_height / 2;
 966
 967   // Normal window is partially occluded by the virtual keyboard.
 968   aura::test::TestWindowDelegate delegate;
 969   scoped_ptr<aura::Window> normal(CreateTestWindowInShellWithDelegateAndType(
 970       &delegate,
 971       ui::wm::WINDOW_TYPE_NORMAL,
 972       0,
 973       gfx::Rect(0, 0, window_width, window_height)));
 974   normal->set_owned_by_parent(false);
 975   normal->Show();
 976   TargetHitTestEventHandler normal_handler;
 977   normal->AddPreTargetHandler(&normal_handler);
 978
 979   // Test that only the click on the top portion of the window is picked up. The
 980   // click on the bottom hits the virtual keyboard instead.
 981   generator.MoveMouseTo(left, top);
 982   generator.ClickLeftButton();
 983   EXPECT_EQ(1, normal_handler.num_mouse_events());
 984   generator.MoveMouseTo(left, bottom);
 985   generator.ClickLeftButton();
 986   EXPECT_EQ(1, normal_handler.num_mouse_events());
 987
 988   // Menu overlaps virtual keyboard.
 989   aura::test::TestWindowDelegate delegate2;
 990   scoped_ptr<aura::Window> menu(CreateTestWindowInShellWithDelegateAndType(
 991       &delegate2,
 992       ui::wm::WINDOW_TYPE_MENU,
 993       0,
 994       gfx::Rect(window_width, 0, window_width, window_height)));
 995   menu->set_owned_by_parent(false);
 996   menu->Show();
 997   TargetHitTestEventHandler menu_handler;
 998   menu->AddPreTargetHandler(&menu_handler);
 999
1000   // Test that both clicks register.
1001   generator.MoveMouseTo(right, top);
1002   generator.ClickLeftButton();
1003   EXPECT_EQ(1, menu_handler.num_mouse_events());
1004   generator.MoveMouseTo(right, bottom);
1005   generator.ClickLeftButton();
1006   EXPECT_EQ(2, menu_handler.num_mouse_events());
1007
1008   // Cleanup to ensure that the test windows are destroyed before their
1009   // delegates.
1010   normal.reset();
1011   menu.reset();
1012 }
1013
1014 // Resolution in UpdateDisplay is not being respected on Windows 8.
1015 #if defined(OS_WIN)
1016 #define MAYBE_DisplayRotation DISABLED_DisplayRotation
1017 #else
1018 #define MAYBE_DisplayRotation DisplayRotation
1019 #endif
1020
1021 // Tests that the virtual keyboard correctly resizes with a change to display
1022 // orientation. See crbug/417612.
1023 TEST_F(VirtualKeyboardRootWindowControllerTest, MAYBE_DisplayRotation) {
1024   UpdateDisplay("800x600");
1025   aura::Window* root_window = Shell::GetPrimaryRootWindow();
1026   aura::Window* keyboard_container =
1027       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
1028   ASSERT_TRUE(keyboard_container);
1029   keyboard::KeyboardController* keyboard_controller =
1030       keyboard::KeyboardController::GetInstance();
1031   keyboard_controller->ShowKeyboard(false);
1032   keyboard_controller->proxy()->GetKeyboardWindow()->SetBounds(
1033       gfx::Rect(0, 400, 800, 200));
1034   EXPECT_EQ("0,400 800x200", keyboard_container->bounds().ToString());
1035
1036   UpdateDisplay("600x800");
1037   EXPECT_EQ("0,600 600x200", keyboard_container->bounds().ToString());
1038 }
1039
1040 }  // namespace test
1041 }  // namespace ash