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/session_state_delegate.h"
   8 #include "ash/shelf/shelf_layout_manager.h"
   9 #include "ash/shell.h"
  10 #include "ash/shell_window_ids.h"
  11 #include "ash/system/tray/system_tray_delegate.h"
  12 #include "ash/test/ash_test_base.h"
  13 #include "ash/wm/system_modal_container_layout_manager.h"
  14 #include "ash/wm/window_properties.h"
  15 #include "ash/wm/window_state.h"
  16 #include "ash/wm/window_util.h"
  17 #include "base/command_line.h"
  18 #include "ui/aura/client/focus_change_observer.h"
  19 #include "ui/aura/client/focus_client.h"
  20 #include "ui/aura/client/window_tree_client.h"
  21 #include "ui/aura/env.h"
  22 #include "ui/aura/root_window.h"
  23 #include "ui/aura/test/event_generator.h"
  24 #include "ui/aura/test/test_event_handler.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_tracker.h"
  29 #include "ui/keyboard/keyboard_controller_proxy.h"
  30 #include "ui/keyboard/keyboard_switches.h"
  31 #include "ui/views/controls/menu/menu_controller.h"
  32 #include "ui/views/widget/widget.h"
  33 #include "ui/views/widget/widget_delegate.h"
  34
  35 using aura::Window;
  36 using views::Widget;
  37
  38 namespace ash {
  39 namespace {
  40
  41 class TestDelegate : public views::WidgetDelegateView {
  42  public:
  43   explicit TestDelegate(bool system_modal) : system_modal_(system_modal) {}
  44   virtual ~TestDelegate() {}
  45
  46   // Overridden from views::WidgetDelegate:
  47   virtual views::View* GetContentsView() OVERRIDE {
  48     return this;
  49   }
  50
  51   virtual ui::ModalType GetModalType() const OVERRIDE {
  52     return system_modal_ ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE;
  53   }
  54
  55  private:
  56   bool system_modal_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
  59 };
  60
  61 class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate,
  62                              public aura::client::FocusChangeObserver {
  63  public:
  64   DeleteOnBlurDelegate() : window_(NULL) {}
  65   virtual ~DeleteOnBlurDelegate() {}
  66
  67   void SetWindow(aura::Window* window) {
  68     window_ = window;
  69     aura::client::SetFocusChangeObserver(window_, this);
  70   }
  71
  72  private:
  73   // aura::test::TestWindowDelegate overrides:
  74   virtual bool CanFocus() OVERRIDE {
  75     return true;
  76   }
  77
  78   // aura::client::FocusChangeObserver implementation:
  79   virtual void OnWindowFocused(aura::Window* gained_focus,
  80                                aura::Window* lost_focus) OVERRIDE {
  81     if (window_ == lost_focus)
  82       delete window_;
  83   }
  84
  85   aura::Window* window_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(DeleteOnBlurDelegate);
  88 };
  89
  90 }  // namespace
  91
  92 namespace test {
  93
  94 class RootWindowControllerTest : public test::AshTestBase {
  95  public:
  96   views::Widget* CreateTestWidget(const gfx::Rect& bounds) {
  97     views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
  98         NULL, CurrentContext(), bounds);
  99     widget->Show();
 100     return widget;
 101   }
 102
 103   views::Widget* CreateModalWidget(const gfx::Rect& bounds) {
 104     views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
 105         new TestDelegate(true), CurrentContext(), bounds);
 106     widget->Show();
 107     return widget;
 108   }
 109
 110   views::Widget* CreateModalWidgetWithParent(const gfx::Rect& bounds,
 111                                              gfx::NativeWindow parent) {
 112     views::Widget* widget =
 113         views::Widget::CreateWindowWithParentAndBounds(new TestDelegate(true),
 114                                                        parent,
 115                                                        bounds);
 116     widget->Show();
 117     return widget;
 118   }
 119
 120   aura::Window* GetModalContainer(aura::Window* root_window) {
 121     return Shell::GetContainer(
 122         root_window,
 123         ash::internal::kShellWindowId_SystemModalContainer);
 124   }
 125 };
 126
 127 TEST_F(RootWindowControllerTest, MoveWindows_Basic) {
 128   if (!SupportsMultipleDisplays())
 129     return;
 130   // Windows origin should be doubled when moved to the 1st display.
 131   UpdateDisplay("600x600,300x300");
 132   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 133   internal::RootWindowController* controller =
 134       Shell::GetPrimaryRootWindowController();
 135   internal::ShelfLayoutManager* shelf_layout_manager =
 136       controller->GetShelfLayoutManager();
 137   shelf_layout_manager->SetAutoHideBehavior(
 138       ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 139
 140   views::Widget* normal = CreateTestWidget(gfx::Rect(650, 10, 100, 100));
 141   EXPECT_EQ(root_windows[1], normal->GetNativeView()->GetRootWindow());
 142   EXPECT_EQ("650,10 100x100", normal->GetWindowBoundsInScreen().ToString());
 143   EXPECT_EQ("50,10 100x100",
 144             normal->GetNativeView()->GetBoundsInRootWindow().ToString());
 145
 146   views::Widget* maximized = CreateTestWidget(gfx::Rect(700, 10, 100, 100));
 147   maximized->Maximize();
 148   EXPECT_EQ(root_windows[1], maximized->GetNativeView()->GetRootWindow());
 149   EXPECT_EQ("600,0 300x253", maximized->GetWindowBoundsInScreen().ToString());
 150   EXPECT_EQ("0,0 300x253",
 151             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 152
 153   views::Widget* minimized = CreateTestWidget(gfx::Rect(800, 10, 100, 100));
 154   minimized->Minimize();
 155   EXPECT_EQ(root_windows[1], minimized->GetNativeView()->GetRootWindow());
 156   EXPECT_EQ("800,10 100x100",
 157             minimized->GetWindowBoundsInScreen().ToString());
 158
 159   views::Widget* fullscreen = CreateTestWidget(gfx::Rect(850, 10, 100, 100));
 160   fullscreen->SetFullscreen(true);
 161   EXPECT_EQ(root_windows[1], fullscreen->GetNativeView()->GetRootWindow());
 162
 163   EXPECT_EQ("600,0 300x300",
 164             fullscreen->GetWindowBoundsInScreen().ToString());
 165   EXPECT_EQ("0,0 300x300",
 166             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 167
 168   views::Widget* unparented_control = new Widget;
 169   Widget::InitParams params;
 170   params.bounds = gfx::Rect(650, 10, 100, 100);
 171   params.context = CurrentContext();
 172   params.type = Widget::InitParams::TYPE_CONTROL;
 173   unparented_control->Init(params);
 174   EXPECT_EQ(root_windows[1],
 175             unparented_control->GetNativeView()->GetRootWindow());
 176   EXPECT_EQ(internal::kShellWindowId_UnparentedControlContainer,
 177             unparented_control->GetNativeView()->parent()->id());
 178
 179   aura::Window* panel = CreateTestWindowInShellWithDelegateAndType(
 180       NULL, ui::wm::WINDOW_TYPE_PANEL, 0, gfx::Rect(700, 100, 100, 100));
 181   EXPECT_EQ(root_windows[1], panel->GetRootWindow());
 182   EXPECT_EQ(internal::kShellWindowId_PanelContainer, panel->parent()->id());
 183
 184   // Make sure a window that will delete itself when losing focus
 185   // will not crash.
 186   aura::WindowTracker tracker;
 187   DeleteOnBlurDelegate delete_on_blur_delegate;
 188   aura::Window* d2 = CreateTestWindowInShellWithDelegate(
 189       &delete_on_blur_delegate, 0, gfx::Rect(50, 50, 100, 100));
 190   delete_on_blur_delegate.SetWindow(d2);
 191   aura::client::GetFocusClient(root_windows[0])->FocusWindow(d2);
 192   tracker.Add(d2);
 193
 194   UpdateDisplay("600x600");
 195
 196   // d2 must have been deleted.
 197   EXPECT_FALSE(tracker.Contains(d2));
 198
 199   EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow());
 200   EXPECT_EQ("100,20 100x100", normal->GetWindowBoundsInScreen().ToString());
 201   EXPECT_EQ("100,20 100x100",
 202             normal->GetNativeView()->GetBoundsInRootWindow().ToString());
 203
 204   // Maximized area on primary display has 3px (given as
 205   // kAutoHideSize in shelf_layout_manager.cc) inset at the bottom.
 206
 207   // First clear fullscreen status, since both fullscreen and maximized windows
 208   // share the same desktop workspace, which cancels the shelf status.
 209   fullscreen->SetFullscreen(false);
 210   EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow());
 211   EXPECT_EQ("0,0 600x597",
 212             maximized->GetWindowBoundsInScreen().ToString());
 213   EXPECT_EQ("0,0 600x597",
 214             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 215
 216   // Set fullscreen to true. In that case the 3px inset becomes invisible so
 217   // the maximized window can also use the area fully.
 218   fullscreen->SetFullscreen(true);
 219   EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow());
 220   EXPECT_EQ("0,0 600x600",
 221             maximized->GetWindowBoundsInScreen().ToString());
 222   EXPECT_EQ("0,0 600x600",
 223             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 224
 225   EXPECT_EQ(root_windows[0], minimized->GetNativeView()->GetRootWindow());
 226   EXPECT_EQ("400,20 100x100",
 227             minimized->GetWindowBoundsInScreen().ToString());
 228
 229   EXPECT_EQ(root_windows[0], fullscreen->GetNativeView()->GetRootWindow());
 230   EXPECT_TRUE(fullscreen->IsFullscreen());
 231   EXPECT_EQ("0,0 600x600",
 232             fullscreen->GetWindowBoundsInScreen().ToString());
 233   EXPECT_EQ("0,0 600x600",
 234             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 235
 236   // Test if the restore bounds are correctly updated.
 237   wm::GetWindowState(maximized->GetNativeView())->Restore();
 238   EXPECT_EQ("200,20 100x100", maximized->GetWindowBoundsInScreen().ToString());
 239   EXPECT_EQ("200,20 100x100",
 240             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 241
 242   fullscreen->SetFullscreen(false);
 243   EXPECT_EQ("500,20 100x100",
 244             fullscreen->GetWindowBoundsInScreen().ToString());
 245   EXPECT_EQ("500,20 100x100",
 246             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 247
 248   // Test if the unparented widget has moved.
 249   EXPECT_EQ(root_windows[0],
 250             unparented_control->GetNativeView()->GetRootWindow());
 251   EXPECT_EQ(internal::kShellWindowId_UnparentedControlContainer,
 252             unparented_control->GetNativeView()->parent()->id());
 253
 254   // Test if the panel has moved.
 255   EXPECT_EQ(root_windows[0], panel->GetRootWindow());
 256   EXPECT_EQ(internal::kShellWindowId_PanelContainer, panel->parent()->id());
 257 }
 258
 259 TEST_F(RootWindowControllerTest, MoveWindows_Modal) {
 260   if (!SupportsMultipleDisplays())
 261     return;
 262
 263   UpdateDisplay("500x500,500x500");
 264
 265   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 266   // Emulate virtual screen coordinate system.
 267   root_windows[0]->SetBounds(gfx::Rect(0, 0, 500, 500));
 268   root_windows[1]->SetBounds(gfx::Rect(500, 0, 500, 500));
 269
 270   views::Widget* normal = CreateTestWidget(gfx::Rect(300, 10, 100, 100));
 271   EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow());
 272   EXPECT_TRUE(wm::IsActiveWindow(normal->GetNativeView()));
 273
 274   views::Widget* modal = CreateModalWidget(gfx::Rect(650, 10, 100, 100));
 275   EXPECT_EQ(root_windows[1], modal->GetNativeView()->GetRootWindow());
 276   EXPECT_TRUE(GetModalContainer(root_windows[1])->Contains(
 277       modal->GetNativeView()));
 278   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 279
 280   aura::test::EventGenerator generator_1st(root_windows[0]);
 281   generator_1st.ClickLeftButton();
 282   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 283
 284   UpdateDisplay("500x500");
 285   EXPECT_EQ(root_windows[0], modal->GetNativeView()->GetRootWindow());
 286   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 287   generator_1st.ClickLeftButton();
 288   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 289 }
 290
 291 TEST_F(RootWindowControllerTest, ModalContainer) {
 292   UpdateDisplay("600x600");
 293   Shell* shell = Shell::GetInstance();
 294   internal::RootWindowController* controller =
 295       shell->GetPrimaryRootWindowController();
 296   EXPECT_EQ(user::LOGGED_IN_USER,
 297             shell->system_tray_delegate()->GetUserLoginStatus());
 298   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 299       internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 300           controller->GetSystemModalLayoutManager(NULL));
 301
 302   views::Widget* session_modal_widget =
 303       CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 304   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 305       internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 306           controller->GetSystemModalLayoutManager(
 307               session_modal_widget->GetNativeView()));
 308
 309   shell->session_state_delegate()->LockScreen();
 310   EXPECT_EQ(user::LOGGED_IN_LOCKED,
 311             shell->system_tray_delegate()->GetUserLoginStatus());
 312   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 313       internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 314           controller->GetSystemModalLayoutManager(NULL));
 315
 316   aura::Window* lock_container =
 317       Shell::GetContainer(controller->root_window(),
 318                           internal::kShellWindowId_LockScreenContainer);
 319   views::Widget* lock_modal_widget =
 320       CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100), lock_container);
 321   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 322       internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 323           controller->GetSystemModalLayoutManager(
 324               lock_modal_widget->GetNativeView()));
 325   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 326         internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 327             controller->GetSystemModalLayoutManager(
 328                 session_modal_widget->GetNativeView()));
 329
 330   shell->session_state_delegate()->UnlockScreen();
 331 }
 332
 333 TEST_F(RootWindowControllerTest, ModalContainerNotLoggedInLoggedIn) {
 334   UpdateDisplay("600x600");
 335   Shell* shell = Shell::GetInstance();
 336
 337   // Configure login screen environment.
 338   SetUserLoggedIn(false);
 339   EXPECT_EQ(user::LOGGED_IN_NONE,
 340             shell->system_tray_delegate()->GetUserLoginStatus());
 341   EXPECT_EQ(0, shell->session_state_delegate()->NumberOfLoggedInUsers());
 342   EXPECT_FALSE(shell->session_state_delegate()->IsActiveUserSessionStarted());
 343
 344   internal::RootWindowController* controller =
 345       shell->GetPrimaryRootWindowController();
 346   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 347       internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 348           controller->GetSystemModalLayoutManager(NULL));
 349
 350   aura::Window* lock_container =
 351       Shell::GetContainer(controller->root_window(),
 352                           internal::kShellWindowId_LockScreenContainer);
 353   views::Widget* login_modal_widget =
 354       CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100), lock_container);
 355   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 356       internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 357           controller->GetSystemModalLayoutManager(
 358               login_modal_widget->GetNativeView()));
 359   login_modal_widget->Close();
 360
 361   // Configure user session environment.
 362   SetUserLoggedIn(true);
 363   SetSessionStarted(true);
 364   EXPECT_EQ(user::LOGGED_IN_USER,
 365             shell->system_tray_delegate()->GetUserLoginStatus());
 366   EXPECT_EQ(1, shell->session_state_delegate()->NumberOfLoggedInUsers());
 367   EXPECT_TRUE(shell->session_state_delegate()->IsActiveUserSessionStarted());
 368   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 369       internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 370           controller->GetSystemModalLayoutManager(NULL));
 371
 372   views::Widget* session_modal_widget =
 373         CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 374   EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 375       internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 376           controller->GetSystemModalLayoutManager(
 377               session_modal_widget->GetNativeView()));
 378 }
 379
 380 TEST_F(RootWindowControllerTest, ModalContainerBlockedSession) {
 381   UpdateDisplay("600x600");
 382   Shell* shell = Shell::GetInstance();
 383   internal::RootWindowController* controller =
 384       shell->GetPrimaryRootWindowController();
 385   aura::Window* lock_container =
 386       Shell::GetContainer(controller->root_window(),
 387                           internal::kShellWindowId_LockScreenContainer);
 388   for (int block_reason = FIRST_BLOCK_REASON;
 389        block_reason < NUMBER_OF_BLOCK_REASONS;
 390        ++block_reason) {
 391     views::Widget* session_modal_widget =
 392           CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 393     EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 394         internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 395             controller->GetSystemModalLayoutManager(
 396                 session_modal_widget->GetNativeView()));
 397     EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 398         internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 399             controller->GetSystemModalLayoutManager(NULL));
 400     session_modal_widget->Close();
 401
 402     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 403
 404     EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 405         internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 406             controller->GetSystemModalLayoutManager(NULL));
 407
 408     views::Widget* lock_modal_widget =
 409         CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100),
 410                                     lock_container);
 411     EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 412         internal::kShellWindowId_LockSystemModalContainer)->layout_manager(),
 413               controller->GetSystemModalLayoutManager(
 414                   lock_modal_widget->GetNativeView()));
 415
 416     session_modal_widget =
 417           CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 418     EXPECT_EQ(Shell::GetContainer(controller->root_window(),
 419         internal::kShellWindowId_SystemModalContainer)->layout_manager(),
 420             controller->GetSystemModalLayoutManager(
 421                 session_modal_widget->GetNativeView()));
 422     session_modal_widget->Close();
 423
 424     lock_modal_widget->Close();
 425     UnblockUserSession();
 426   }
 427 }
 428
 429 TEST_F(RootWindowControllerTest, GetWindowForFullscreenMode) {
 430   UpdateDisplay("600x600");
 431   internal::RootWindowController* controller =
 432       Shell::GetInstance()->GetPrimaryRootWindowController();
 433
 434   Widget* w1 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 435   w1->Maximize();
 436   Widget* w2 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
 437   w2->SetFullscreen(true);
 438   // |w3| is a transient child of |w2|.
 439   Widget* w3 = Widget::CreateWindowWithParentAndBounds(NULL,
 440       w2->GetNativeWindow(), gfx::Rect(0, 0, 100, 100));
 441
 442   // Test that GetWindowForFullscreenMode() finds the fullscreen window when one
 443   // of its transient children is active.
 444   w3->Activate();
 445   EXPECT_EQ(w2->GetNativeWindow(), controller->GetWindowForFullscreenMode());
 446
 447   // If the topmost window is not fullscreen, it returns NULL.
 448   w1->Activate();
 449   EXPECT_EQ(NULL, controller->GetWindowForFullscreenMode());
 450   w1->Close();
 451   w3->Close();
 452
 453   // Only w2 remains, if minimized GetWindowForFullscreenMode should return
 454   // NULL.
 455   w2->Activate();
 456   EXPECT_EQ(w2->GetNativeWindow(), controller->GetWindowForFullscreenMode());
 457   w2->Minimize();
 458   EXPECT_EQ(NULL, controller->GetWindowForFullscreenMode());
 459 }
 460
 461 // Test that user session window can't be focused if user session blocked by
 462 // some overlapping UI.
 463 TEST_F(RootWindowControllerTest, FocusBlockedWindow) {
 464   UpdateDisplay("600x600");
 465   internal::RootWindowController* controller =
 466       Shell::GetInstance()->GetPrimaryRootWindowController();
 467   aura::Window* lock_container =
 468       Shell::GetContainer(controller->root_window(),
 469                           internal::kShellWindowId_LockScreenContainer);
 470   aura::Window* lock_window = Widget::CreateWindowWithParentAndBounds(NULL,
 471       lock_container, gfx::Rect(0, 0, 100, 100))->GetNativeView();
 472   lock_window->Show();
 473   aura::Window* session_window =
 474       CreateTestWidget(gfx::Rect(0, 0, 100, 100))->GetNativeView();
 475   session_window->Show();
 476
 477   for (int block_reason = FIRST_BLOCK_REASON;
 478        block_reason < NUMBER_OF_BLOCK_REASONS;
 479        ++block_reason) {
 480     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 481     lock_window->Focus();
 482     EXPECT_TRUE(lock_window->HasFocus());
 483     session_window->Focus();
 484     EXPECT_FALSE(session_window->HasFocus());
 485     UnblockUserSession();
 486   }
 487 }
 488
 489 // Tracks whether OnWindowDestroying() has been invoked.
 490 class DestroyedWindowObserver : public aura::WindowObserver {
 491  public:
 492   DestroyedWindowObserver() : destroyed_(false), window_(NULL) {}
 493   virtual ~DestroyedWindowObserver() {
 494     Shutdown();
 495   }
 496
 497   void SetWindow(Window* window) {
 498     window_ = window;
 499     window->AddObserver(this);
 500   }
 501
 502   bool destroyed() const { return destroyed_; }
 503
 504   // WindowObserver overrides:
 505   virtual void OnWindowDestroying(Window* window) OVERRIDE {
 506     destroyed_ = true;
 507     Shutdown();
 508   }
 509
 510  private:
 511   void Shutdown() {
 512     if (!window_)
 513       return;
 514     window_->RemoveObserver(this);
 515     window_ = NULL;
 516   }
 517
 518   bool destroyed_;
 519   Window* window_;
 520
 521   DISALLOW_COPY_AND_ASSIGN(DestroyedWindowObserver);
 522 };
 523
 524 // Verifies shutdown doesn't delete windows that are not owned by the parent.
 525 TEST_F(RootWindowControllerTest, DontDeleteWindowsNotOwnedByParent) {
 526   DestroyedWindowObserver observer1;
 527   aura::test::TestWindowDelegate delegate1;
 528   aura::Window* window1 = new aura::Window(&delegate1);
 529   window1->SetType(ui::wm::WINDOW_TYPE_CONTROL);
 530   window1->set_owned_by_parent(false);
 531   observer1.SetWindow(window1);
 532   window1->Init(aura::WINDOW_LAYER_NOT_DRAWN);
 533   aura::client::ParentWindowWithContext(
 534       window1, Shell::GetInstance()->GetPrimaryRootWindow(), gfx::Rect());
 535
 536   DestroyedWindowObserver observer2;
 537   aura::Window* window2 = new aura::Window(NULL);
 538   window2->set_owned_by_parent(false);
 539   observer2.SetWindow(window2);
 540   window2->Init(aura::WINDOW_LAYER_NOT_DRAWN);
 541   Shell::GetInstance()->GetPrimaryRootWindow()->AddChild(window2);
 542
 543   Shell::GetInstance()->GetPrimaryRootWindowController()->CloseChildWindows();
 544
 545   ASSERT_FALSE(observer1.destroyed());
 546   delete window1;
 547
 548   ASSERT_FALSE(observer2.destroyed());
 549   delete window2;
 550 }
 551
 552 typedef test::NoSessionAshTestBase NoSessionRootWindowControllerTest;
 553
 554 // Make sure that an event handler exists for entire display area.
 555 TEST_F(NoSessionRootWindowControllerTest, Event) {
 556   aura::Window* root = Shell::GetPrimaryRootWindow();
 557   const gfx::Size size = root->bounds().size();
 558   aura::Window* event_target = root->GetEventHandlerForPoint(gfx::Point(0, 0));
 559   EXPECT_TRUE(event_target);
 560   EXPECT_EQ(event_target,
 561             root->GetEventHandlerForPoint(gfx::Point(0, size.height() - 1)));
 562   EXPECT_EQ(event_target,
 563             root->GetEventHandlerForPoint(gfx::Point(size.width() - 1, 0)));
 564   EXPECT_EQ(event_target,
 565             root->GetEventHandlerForPoint(gfx::Point(0, size.height() - 1)));
 566   EXPECT_EQ(event_target,
 567             root->GetEventHandlerForPoint(
 568                 gfx::Point(size.width() - 1, size.height() - 1)));
 569 }
 570
 571 class VirtualKeyboardRootWindowControllerTest : public test::AshTestBase {
 572  public:
 573   VirtualKeyboardRootWindowControllerTest() {};
 574   virtual ~VirtualKeyboardRootWindowControllerTest() {};
 575
 576   virtual void SetUp() OVERRIDE {
 577     CommandLine::ForCurrentProcess()->AppendSwitch(
 578         keyboard::switches::kEnableVirtualKeyboard);
 579     test::AshTestBase::SetUp();
 580     Shell::GetPrimaryRootWindowController()->ActivateKeyboard(
 581         Shell::GetInstance()->keyboard_controller());
 582   }
 583
 584  private:
 585   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardRootWindowControllerTest);
 586 };
 587
 588 // Test for http://crbug.com/297858. Virtual keyboard container should only show
 589 // on primary root window.
 590 TEST_F(VirtualKeyboardRootWindowControllerTest,
 591        VirtualKeyboardOnPrimaryRootWindowOnly) {
 592   if (!SupportsMultipleDisplays())
 593     return;
 594
 595   UpdateDisplay("500x500,500x500");
 596
 597   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 598   aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
 599   aura::Window* secondary_root_window =
 600       root_windows[0] == primary_root_window ?
 601           root_windows[1] : root_windows[0];
 602
 603   ASSERT_TRUE(Shell::GetContainer(
 604       primary_root_window,
 605       internal::kShellWindowId_VirtualKeyboardContainer));
 606   ASSERT_FALSE(Shell::GetContainer(
 607       secondary_root_window,
 608       internal::kShellWindowId_VirtualKeyboardContainer));
 609 }
 610
 611 // Test for http://crbug.com/263599. Virtual keyboard should be able to receive
 612 // events at blocked user session.
 613 TEST_F(VirtualKeyboardRootWindowControllerTest,
 614        ClickVirtualKeyboardInBlockedWindow) {
 615   aura::Window* root_window = Shell::GetPrimaryRootWindow();
 616   aura::Window* keyboard_container = Shell::GetContainer(root_window,
 617       internal::kShellWindowId_VirtualKeyboardContainer);
 618   ASSERT_TRUE(keyboard_container);
 619   keyboard_container->Show();
 620
 621   aura::Window* keyboard_window = Shell::GetInstance()->keyboard_controller()->
 622       proxy()->GetKeyboardWindow();
 623   keyboard_container->AddChild(keyboard_window);
 624   keyboard_window->SetBounds(gfx::Rect());
 625   keyboard_window->Show();
 626
 627   aura::test::TestEventHandler* handler = new aura::test::TestEventHandler;
 628   root_window->SetEventFilter(handler);
 629
 630   aura::test::EventGenerator event_generator(root_window, keyboard_window);
 631   event_generator.ClickLeftButton();
 632   int expected_mouse_presses = 1;
 633   EXPECT_EQ(expected_mouse_presses, handler->num_mouse_events() / 2);
 634
 635   for (int block_reason = FIRST_BLOCK_REASON;
 636        block_reason < NUMBER_OF_BLOCK_REASONS;
 637        ++block_reason) {
 638     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 639     event_generator.ClickLeftButton();
 640     expected_mouse_presses++;
 641     EXPECT_EQ(expected_mouse_presses, handler->num_mouse_events() / 2);
 642     UnblockUserSession();
 643   }
 644 }
 645
 646 // Test for http://crbug.com/299787. RootWindowController should delete
 647 // the old container since the keyboard controller creates a new window in
 648 // GetWindowContainer().
 649 TEST_F(VirtualKeyboardRootWindowControllerTest,
 650        DeleteOldContainerOnVirtualKeyboardInit) {
 651   aura::Window* root_window = ash::Shell::GetPrimaryRootWindow();
 652   aura::Window* keyboard_container = Shell::GetContainer(root_window,
 653       internal::kShellWindowId_VirtualKeyboardContainer);
 654   ASSERT_TRUE(keyboard_container);
 655   // Track the keyboard container window.
 656   aura::WindowTracker tracker;
 657   tracker.Add(keyboard_container);
 658   // Mock a login user profile change to reinitialize the keyboard.
 659   ash::Shell::GetInstance()->OnLoginUserProfilePrepared();
 660   // keyboard_container should no longer be present.
 661   EXPECT_FALSE(tracker.Contains(keyboard_container));
 662 }
 663
 664 }  // namespace test
 665 }  // namespace ash