ash/root_window_controller.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 <vector>
   8
   9 #include "ash/ash_switches.h"
  10 #include "ash/desktop_background/desktop_background_widget_controller.h"
  11 #include "ash/display/display_controller.h"
  12 #include "ash/display/display_manager.h"
  13 #include "ash/focus_cycler.h"
  14 #include "ash/shell.h"
  15 #include "ash/shell_delegate.h"
  16 #include "ash/shell_factory.h"
  17 #include "ash/shell_window_ids.h"
  18 #include "ash/system/status_area_widget.h"
  19 #include "ash/system/tray/system_tray_delegate.h"
  20 #include "ash/wm/base_layout_manager.h"
  21 #include "ash/wm/boot_splash_screen.h"
  22 #include "ash/wm/panel_layout_manager.h"
  23 #include "ash/wm/panel_window_event_filter.h"
  24 #include "ash/wm/property_util.h"
  25 #include "ash/wm/root_window_layout_manager.h"
  26 #include "ash/wm/screen_dimmer.h"
  27 #include "ash/wm/shelf_layout_manager.h"
  28 #include "ash/wm/shelf_types.h"
  29 #include "ash/wm/status_area_layout_manager.h"
  30 #include "ash/wm/system_background_controller.h"
  31 #include "ash/wm/system_modal_container_layout_manager.h"
  32 #include "ash/wm/toplevel_window_event_handler.h"
  33 #include "ash/wm/visibility_controller.h"
  34 #include "ash/wm/window_properties.h"
  35 #include "ash/wm/workspace_controller.h"
  36 #include "base/command_line.h"
  37 #include "base/time.h"
  38 #include "ui/aura/client/activation_client.h"
  39 #include "ui/aura/client/aura_constants.h"
  40 #include "ui/aura/client/capture_client.h"
  41 #include "ui/aura/client/tooltip_client.h"
  42 #include "ui/aura/focus_manager.h"
  43 #include "ui/aura/root_window.h"
  44 #include "ui/aura/window.h"
  45 #include "ui/aura/window_observer.h"
  46 #include "ui/aura/window_tracker.h"
  47 #include "ui/base/models/menu_model.h"
  48 #include "ui/gfx/display.h"
  49 #include "ui/gfx/screen.h"
  50 #include "ui/views/controls/menu/menu_model_adapter.h"
  51 #include "ui/views/controls/menu/menu_runner.h"
  52 #include "ui/views/view_model.h"
  53 #include "ui/views/view_model_utils.h"
  54
  55 namespace ash {
  56 namespace {
  57
  58 #if defined(OS_CHROMEOS)
  59 // Background color used for the Chrome OS boot splash screen.
  60 const SkColor kChromeOsBootColor = SkColorSetARGB(0xff, 0xfe, 0xfe, 0xfe);
  61 #endif
  62
  63 // Duration for the animation that hides the boot splash screen, in
  64 // milliseconds.  This should be short enough in relation to
  65 // wm/window_animation.cc's brightness/grayscale fade animation that the login
  66 // background image animation isn't hidden by the splash screen animation.
  67 const int kBootSplashScreenHideDurationMs = 500;
  68
  69 // Creates a new window for use as a container.
  70 aura::Window* CreateContainer(int window_id,
  71                               const char* name,
  72                               aura::Window* parent) {
  73   aura::Window* container = new aura::Window(NULL);
  74   container->set_id(window_id);
  75   container->SetName(name);
  76   container->Init(ui::LAYER_NOT_DRAWN);
  77   parent->AddChild(container);
  78   if (window_id != internal::kShellWindowId_UnparentedControlContainer)
  79     container->Show();
  80   return container;
  81 }
  82
  83 // Returns all the children of the workspace windows, eg the standard top-level
  84 // windows.
  85 std::vector<aura::Window*> GetWorkspaceWindows(aura::RootWindow* root) {
  86   using aura::Window;
  87
  88   std::vector<Window*> windows;
  89   Window* container = Shell::GetContainer(
  90       root, internal::kShellWindowId_DefaultContainer);
  91   for (Window::Windows::const_reverse_iterator i =
  92            container->children().rbegin();
  93        i != container->children().rend(); ++i) {
  94     Window* workspace_window = *i;
  95     if (workspace_window->id() == internal::kShellWindowId_WorkspaceContainer) {
  96       windows.insert(windows.end(), workspace_window->children().begin(),
  97                      workspace_window->children().end());
  98     }
  99   }
 100   return windows;
 101 }
 102
 103 // Reparents |window| to |new_parent|.
 104 void ReparentWindow(aura::Window* window, aura::Window* new_parent) {
 105   // Update the restore bounds to make it relative to the display.
 106   gfx::Rect restore_bounds(GetRestoreBoundsInParent(window));
 107   new_parent->AddChild(window);
 108   if (!restore_bounds.IsEmpty())
 109     SetRestoreBoundsInParent(window, restore_bounds);
 110 }
 111
 112 // Reparents the appropriate set of windows from |src| to |dst|.
 113 void ReparentAllWindows(aura::RootWindow* src, aura::RootWindow* dst) {
 114   // Set of windows to move.
 115   const int kContainerIdsToMove[] = {
 116     internal::kShellWindowId_DefaultContainer,
 117     internal::kShellWindowId_AlwaysOnTopContainer,
 118     internal::kShellWindowId_SystemModalContainer,
 119     internal::kShellWindowId_LockSystemModalContainer,
 120     internal::kShellWindowId_InputMethodContainer,
 121   };
 122   // For workspace windows we need to manually reparent the windows. This way
 123   // workspace can move the windows to the appropriate workspace.
 124   std::vector<aura::Window*> windows(GetWorkspaceWindows(src));
 125   internal::WorkspaceController* workspace_controller =
 126       GetRootWindowController(dst)->workspace_controller();
 127   for (size_t i = 0; i < windows.size(); ++i) {
 128     aura::Window* new_parent =
 129         workspace_controller->GetParentForNewWindow(windows[i]);
 130     ReparentWindow(windows[i], new_parent);
 131   }
 132   for (size_t i = 0; i < arraysize(kContainerIdsToMove); i++) {
 133     int id = kContainerIdsToMove[i];
 134     if (id == internal::kShellWindowId_DefaultContainer)
 135       continue;
 136
 137     aura::Window* src_container = Shell::GetContainer(src, id);
 138     aura::Window* dst_container = Shell::GetContainer(dst, id);
 139     aura::Window::Windows children = src_container->children();
 140     for (aura::Window::Windows::iterator iter = children.begin();
 141          iter != children.end(); ++iter) {
 142       aura::Window* window = *iter;
 143       // Don't move modal screen.
 144       if (internal::SystemModalContainerLayoutManager::IsModalBackground(
 145               window))
 146         continue;
 147
 148       ReparentWindow(window, dst_container);
 149     }
 150   }
 151 }
 152
 153 // Mark the container window so that a widget added to this container will
 154 // use the virtual screeen coordinates instead of parent.
 155 void SetUsesScreenCoordinates(aura::Window* container) {
 156   container->SetProperty(internal::kUsesScreenCoordinatesKey, true);
 157 }
 158
 159 }  // namespace
 160
 161 namespace internal {
 162
 163 RootWindowController::RootWindowController(aura::RootWindow* root_window)
 164     : root_window_(root_window),
 165       root_window_layout_(NULL),
 166       status_area_widget_(NULL),
 167       shelf_(NULL),
 168       panel_layout_manager_(NULL) {
 169   SetRootWindowController(root_window, this);
 170   screen_dimmer_.reset(new ScreenDimmer(root_window));
 171 }
 172
 173 RootWindowController::~RootWindowController() {
 174   Shutdown();
 175   root_window_.reset();
 176 }
 177
 178 // static
 179 internal::RootWindowController*
 180 RootWindowController::ForLauncher(aura::Window* window) {
 181   if (Shell::IsLauncherPerDisplayEnabled())
 182     return GetRootWindowController(window->GetRootWindow());
 183   else
 184     return Shell::GetPrimaryRootWindowController();
 185 }
 186
 187 void RootWindowController::Shutdown() {
 188   CloseChildWindows();
 189   if (Shell::GetActiveRootWindow() == root_window_.get()) {
 190     Shell::GetInstance()->set_active_root_window(
 191         Shell::GetPrimaryRootWindow() == root_window_.get() ?
 192         NULL : Shell::GetPrimaryRootWindow());
 193   }
 194   SetRootWindowController(root_window_.get(), NULL);
 195   screen_dimmer_.reset();
 196   workspace_controller_.reset();
 197   // Forget with the display ID so that display lookup
 198   // ends up with invalid display.
 199   root_window_->ClearProperty(kDisplayIdKey);
 200   // And this root window should no longer process events.
 201   root_window_->PrepareForShutdown();
 202
 203   system_background_.reset();
 204
 205   // Launcher widget has an InputMethodBridge that references to
 206   // |input_method_filter_|'s |input_method_|. So explicitly release
 207   // |launcher_| before |input_method_filter_|. And this needs to be
 208   // after we delete all containers in case there are still live
 209   // browser windows which access LauncherModel during close.
 210   launcher_.reset();
 211 }
 212
 213 SystemModalContainerLayoutManager*
 214 RootWindowController::GetSystemModalLayoutManager(aura::Window* window) {
 215   aura::Window* container = NULL;
 216   if (window) {
 217     if (window->parent() &&
 218         window->parent()->id() >= kShellWindowId_LockScreenContainer) {
 219       container = GetContainer(kShellWindowId_LockSystemModalContainer);
 220     } else {
 221       container = GetContainer(kShellWindowId_SystemModalContainer);
 222     }
 223   } else {
 224     user::LoginStatus login = Shell::GetInstance()->status_area_widget() ?
 225         Shell::GetInstance()->tray_delegate()->GetUserLoginStatus() :
 226         user::LOGGED_IN_NONE;
 227     int modal_window_id = (login == user::LOGGED_IN_LOCKED ||
 228                            login == user::LOGGED_IN_NONE) ?
 229         kShellWindowId_LockSystemModalContainer :
 230         kShellWindowId_SystemModalContainer;
 231     container = GetContainer(modal_window_id);
 232   }
 233   return static_cast<SystemModalContainerLayoutManager*>(
 234       container->layout_manager());
 235 }
 236
 237 aura::Window* RootWindowController::GetContainer(int container_id) {
 238   return root_window_->GetChildById(container_id);
 239 }
 240
 241 void RootWindowController::InitLayoutManagers() {
 242   root_window_layout_ =
 243       new RootWindowLayoutManager(root_window_.get());
 244   root_window_->SetLayoutManager(root_window_layout_);
 245
 246   aura::Window* default_container =
 247       GetContainer(kShellWindowId_DefaultContainer);
 248   // Workspace manager has its own layout managers.
 249   workspace_controller_.reset(
 250       new WorkspaceController(default_container));
 251
 252   aura::Window* always_on_top_container =
 253       GetContainer(kShellWindowId_AlwaysOnTopContainer);
 254   always_on_top_container->SetLayoutManager(
 255       new BaseLayoutManager(
 256           always_on_top_container->GetRootWindow()));
 257 }
 258
 259 void RootWindowController::InitForPrimaryDisplay() {
 260   DCHECK(!status_area_widget_);
 261   aura::Window* status_container =
 262       GetContainer(ash::internal::kShellWindowId_StatusContainer);
 263   // Initialize Primary RootWindow specific items.
 264   status_area_widget_ = new internal::StatusAreaWidget(status_container);
 265   status_area_widget_->CreateTrayViews();
 266   // Login screen manages status area visibility by itself.
 267   ShellDelegate* shell_delegate = Shell::GetInstance()->delegate();
 268   if (shell_delegate->IsSessionStarted())
 269     status_area_widget_->Show();
 270
 271   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
 272
 273   internal::ShelfLayoutManager* shelf_layout_manager =
 274       new internal::ShelfLayoutManager(status_area_widget_);
 275   GetContainer(internal::kShellWindowId_LauncherContainer)->
 276       SetLayoutManager(shelf_layout_manager);
 277   shelf_ = shelf_layout_manager;
 278
 279   internal::StatusAreaLayoutManager* status_area_layout_manager =
 280       new internal::StatusAreaLayoutManager(shelf_layout_manager);
 281   GetContainer(internal::kShellWindowId_StatusContainer)->
 282       SetLayoutManager(status_area_layout_manager);
 283
 284   shelf_layout_manager->set_workspace_controller(
 285       workspace_controller());
 286
 287   workspace_controller()->SetShelf(shelf_);
 288
 289   // Create Panel layout manager
 290   aura::Window* panel_container = GetContainer(
 291       internal::kShellWindowId_PanelContainer);
 292   panel_layout_manager_ =
 293       new internal::PanelLayoutManager(panel_container);
 294   panel_container->AddPreTargetHandler(
 295       new internal::PanelWindowEventFilter(
 296           panel_container, panel_layout_manager_));
 297   panel_container->SetLayoutManager(panel_layout_manager_);
 298
 299   if (shell_delegate->IsUserLoggedIn())
 300     CreateLauncher();
 301 }
 302
 303 void RootWindowController::CreateContainers() {
 304   CreateContainersInRootWindow(root_window_.get());
 305 }
 306
 307 void RootWindowController::CreateSystemBackground(
 308     bool is_first_run_after_boot) {
 309   SkColor color = SK_ColorBLACK;
 310 #if defined(OS_CHROMEOS)
 311   if (is_first_run_after_boot)
 312     color = kChromeOsBootColor;
 313 #endif
 314   system_background_.reset(
 315       new SystemBackgroundController(root_window_.get(), color));
 316
 317 #if defined(OS_CHROMEOS)
 318   // Make a copy of the system's boot splash screen so we can composite it
 319   // onscreen until the desktop background is ready.
 320   if (is_first_run_after_boot &&
 321       (CommandLine::ForCurrentProcess()->HasSwitch(
 322            switches::kAshCopyHostBackgroundAtBoot) ||
 323        CommandLine::ForCurrentProcess()->HasSwitch(
 324            switches::kAshAnimateFromBootSplashScreen)))
 325     boot_splash_screen_.reset(new BootSplashScreen(root_window_.get()));
 326 #endif
 327 }
 328
 329 void RootWindowController::CreateLauncher() {
 330   if (launcher_.get())
 331     return;
 332
 333   aura::Window* default_container =
 334       GetContainer(internal::kShellWindowId_DefaultContainer);
 335   launcher_.reset(new Launcher(default_container, shelf_));
 336
 337   launcher_->SetFocusCycler(Shell::GetInstance()->focus_cycler());
 338   shelf_->SetLauncher(launcher_.get());
 339
 340   if (panel_layout_manager_)
 341     panel_layout_manager_->SetLauncher(launcher_.get());
 342
 343   ShellDelegate* delegate = Shell::GetInstance()->delegate();
 344   if (delegate)
 345     launcher_->SetVisible(delegate->IsSessionStarted());
 346   launcher_->widget()->Show();
 347 }
 348
 349 void RootWindowController::ShowLauncher() {
 350   if (!launcher_.get())
 351     return;
 352   launcher_->SetVisible(true);
 353   status_area_widget_->Show();
 354 }
 355
 356 void RootWindowController::OnLoginStateChanged(user::LoginStatus status) {
 357   // TODO(oshima): remove if when launcher per display is enabled by
 358   // default.
 359   if (shelf_)
 360     shelf_->UpdateVisibilityState();
 361 }
 362
 363 void RootWindowController::UpdateAfterLoginStatusChange(
 364     user::LoginStatus status) {
 365   if (status_area_widget_)
 366     status_area_widget_->UpdateAfterLoginStatusChange(status);
 367 }
 368
 369 void RootWindowController::HandleInitialDesktopBackgroundAnimationStarted() {
 370   if (CommandLine::ForCurrentProcess()->HasSwitch(
 371           switches::kAshAnimateFromBootSplashScreen) &&
 372       boot_splash_screen_.get()) {
 373     // Make the splash screen fade out so it doesn't obscure the desktop
 374     // wallpaper's brightness/grayscale animation.
 375     boot_splash_screen_->StartHideAnimation(
 376         base::TimeDelta::FromMilliseconds(kBootSplashScreenHideDurationMs));
 377   }
 378 }
 379
 380 void RootWindowController::HandleDesktopBackgroundVisible() {
 381   system_background_->SetColor(SK_ColorBLACK);
 382   boot_splash_screen_.reset();
 383 }
 384
 385 void RootWindowController::CloseChildWindows() {
 386   // The status area needs to be shut down before the windows are destroyed.
 387   if (status_area_widget_) {
 388     status_area_widget_->Shutdown();
 389     status_area_widget_ = NULL;
 390   }
 391
 392   // Closing the windows frees the workspace controller.
 393   if (shelf_)
 394     shelf_->set_workspace_controller(NULL);
 395
 396   // Close background widget first as it depends on tooltip.
 397   root_window_->SetProperty(kDesktopController,
 398       static_cast<DesktopBackgroundWidgetController*>(NULL));
 399   root_window_->SetProperty(kAnimatingDesktopController,
 400                             static_cast<AnimatingDesktopController*>(NULL));
 401
 402   workspace_controller_.reset();
 403   aura::client::SetTooltipClient(root_window_.get(), NULL);
 404
 405   while (!root_window_->children().empty()) {
 406     aura::Window* child = root_window_->children()[0];
 407     delete child;
 408   }
 409
 410   // All containers are deleted, so reset shelf_.
 411   shelf_ = NULL;
 412 }
 413
 414 void RootWindowController::MoveWindowsTo(aura::RootWindow* dst) {
 415   aura::Window* focused = dst->GetFocusManager()->GetFocusedWindow();
 416   aura::WindowTracker tracker;
 417   if (focused)
 418     tracker.Add(focused);
 419   aura::client::ActivationClient* activation_client =
 420       aura::client::GetActivationClient(dst);
 421   aura::Window* active = activation_client->GetActiveWindow();
 422   if (active && focused != active)
 423     tracker.Add(active);
 424   // Deactivate the window to close menu / bubble windows.
 425   activation_client->DeactivateWindow(active);
 426   // Release capture if any.
 427   aura::client::GetCaptureClient(root_window_.get())->
 428       SetCapture(NULL);
 429   // Clear the focused window if any. This is necessary because a
 430   // window may be deleted when losing focus (fullscreen flash for
 431   // example).  If the focused window is still alive after move, it'll
 432   // be re-focused below.
 433   dst->GetFocusManager()->SetFocusedWindow(NULL, NULL);
 434
 435   ReparentAllWindows(root_window_.get(), dst);
 436
 437   // Restore focused or active window if it's still alive.
 438   if (focused && tracker.Contains(focused) && dst->Contains(focused)) {
 439     dst->GetFocusManager()->SetFocusedWindow(focused, NULL);
 440   } else if (active && tracker.Contains(active) && dst->Contains(active)) {
 441     activation_client->ActivateWindow(active);
 442   }
 443 }
 444
 445 void RootWindowController::ShowContextMenu(
 446     const gfx::Point& location_in_screen) {
 447   aura::RootWindow* target = Shell::IsLauncherPerDisplayEnabled() ?
 448       root_window() : Shell::GetPrimaryRootWindow();
 449   DCHECK(Shell::GetInstance()->delegate());
 450   scoped_ptr<ui::MenuModel> menu_model(
 451       Shell::GetInstance()->delegate()->CreateContextMenu(target));
 452
 453   views::MenuModelAdapter menu_model_adapter(menu_model.get());
 454   views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
 455   views::Widget* widget =
 456       root_window_->GetProperty(kDesktopController)->widget();
 457
 458   if (menu_runner.RunMenuAt(
 459           widget, NULL, gfx::Rect(location_in_screen, gfx::Size()),
 460           views::MenuItemView::TOPLEFT, views::MenuRunner::CONTEXT_MENU) ==
 461       views::MenuRunner::MENU_DELETED)
 462     return;
 463
 464   Shell::GetInstance()->UpdateShelfVisibility();
 465 }
 466
 467 void RootWindowController::UpdateShelfVisibility() {
 468   shelf_->UpdateVisibilityState();
 469 }
 470
 471 void RootWindowController::SetShelfAutoHideBehavior(
 472     ShelfAutoHideBehavior behavior) {
 473   shelf_->SetAutoHideBehavior(behavior);
 474 }
 475
 476 ShelfAutoHideBehavior RootWindowController::GetShelfAutoHideBehavior() const {
 477   return shelf_->auto_hide_behavior();
 478 }
 479
 480 bool RootWindowController::SetShelfAlignment(ShelfAlignment alignment) {
 481   return shelf_->SetAlignment(alignment);
 482 }
 483
 484 ShelfAlignment RootWindowController::GetShelfAlignment() {
 485   return shelf_->alignment();
 486 }
 487
 488 bool RootWindowController::IsShelfAutoHideMenuHideChecked() {
 489   return GetShelfAutoHideBehavior() == ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
 490 }
 491
 492 ShelfAutoHideBehavior
 493 RootWindowController::GetToggledShelfAutoHideBehavior() {
 494   return IsShelfAutoHideMenuHideChecked() ?
 495       ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER :
 496       ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
 497 }
 498
 499 ////////////////////////////////////////////////////////////////////////////////
 500 // RootWindowController, private:
 501
 502 void RootWindowController::CreateContainersInRootWindow(
 503     aura::RootWindow* root_window) {
 504   // These containers are just used by PowerButtonController to animate groups
 505   // of containers simultaneously without messing up the current transformations
 506   // on those containers. These are direct children of the root window; all of
 507   // the other containers are their children.
 508
 509   // The desktop background container is not part of the lock animation, so it
 510   // is not included in those animate groups.
 511   // When screen is locked desktop background is moved to lock screen background
 512   // container (moved back on unlock). We want to make sure that there's an
 513   // opaque layer occluding the non-lock-screen layers.
 514   aura::Window* desktop_background_container = CreateContainer(
 515       kShellWindowId_DesktopBackgroundContainer,
 516       "DesktopBackgroundContainer",
 517       root_window);
 518   SetChildWindowVisibilityChangesAnimated(desktop_background_container);
 519
 520   aura::Window* non_lock_screen_containers = CreateContainer(
 521       kShellWindowId_NonLockScreenContainersContainer,
 522       "NonLockScreenContainersContainer",
 523       root_window);
 524
 525   aura::Window* lock_background_containers = CreateContainer(
 526       kShellWindowId_LockScreenBackgroundContainer,
 527       "LockScreenBackgroundContainer",
 528       root_window);
 529   SetChildWindowVisibilityChangesAnimated(lock_background_containers);
 530
 531   aura::Window* lock_screen_containers = CreateContainer(
 532       kShellWindowId_LockScreenContainersContainer,
 533       "LockScreenContainersContainer",
 534       root_window);
 535   aura::Window* lock_screen_related_containers = CreateContainer(
 536       kShellWindowId_LockScreenRelatedContainersContainer,
 537       "LockScreenRelatedContainersContainer",
 538       root_window);
 539
 540   CreateContainer(kShellWindowId_UnparentedControlContainer,
 541                   "UnparentedControlContainer",
 542                   non_lock_screen_containers);
 543
 544   aura::Window* default_container = CreateContainer(
 545       kShellWindowId_DefaultContainer,
 546       "DefaultContainer",
 547       non_lock_screen_containers);
 548   SetChildWindowVisibilityChangesAnimated(default_container);
 549   SetUsesScreenCoordinates(default_container);
 550
 551   aura::Window* always_on_top_container = CreateContainer(
 552       kShellWindowId_AlwaysOnTopContainer,
 553       "AlwaysOnTopContainer",
 554       non_lock_screen_containers);
 555   always_on_top_container_handler_.reset(
 556       new ToplevelWindowEventHandler(always_on_top_container));
 557   SetChildWindowVisibilityChangesAnimated(always_on_top_container);
 558   SetUsesScreenCoordinates(always_on_top_container);
 559
 560   aura::Window* panel_container = CreateContainer(
 561       kShellWindowId_PanelContainer,
 562       "PanelContainer",
 563       non_lock_screen_containers);
 564   SetUsesScreenCoordinates(panel_container);
 565
 566   aura::Window* launcher_container =
 567       CreateContainer(kShellWindowId_LauncherContainer,
 568                       "LauncherContainer",
 569                       non_lock_screen_containers);
 570   SetUsesScreenCoordinates(launcher_container);
 571
 572   aura::Window* app_list_container =
 573       CreateContainer(kShellWindowId_AppListContainer,
 574                       "AppListContainer",
 575                       non_lock_screen_containers);
 576   SetUsesScreenCoordinates(app_list_container);
 577
 578   aura::Window* modal_container = CreateContainer(
 579       kShellWindowId_SystemModalContainer,
 580       "SystemModalContainer",
 581       non_lock_screen_containers);
 582   modal_container_handler_.reset(
 583       new ToplevelWindowEventHandler(modal_container));
 584   modal_container->SetLayoutManager(
 585       new SystemModalContainerLayoutManager(modal_container));
 586   SetChildWindowVisibilityChangesAnimated(modal_container);
 587   SetUsesScreenCoordinates(modal_container);
 588
 589   aura::Window* input_method_container = CreateContainer(
 590       kShellWindowId_InputMethodContainer,
 591       "InputMethodContainer",
 592       non_lock_screen_containers);
 593   SetUsesScreenCoordinates(input_method_container);
 594
 595   // TODO(beng): Figure out if we can make this use
 596   // SystemModalContainerEventFilter instead of stops_event_propagation.
 597   aura::Window* lock_container = CreateContainer(
 598       kShellWindowId_LockScreenContainer,
 599       "LockScreenContainer",
 600       lock_screen_containers);
 601   lock_container->SetLayoutManager(
 602       new BaseLayoutManager(root_window));
 603   SetUsesScreenCoordinates(lock_container);
 604   // TODO(beng): stopsevents
 605
 606   aura::Window* lock_modal_container = CreateContainer(
 607       kShellWindowId_LockSystemModalContainer,
 608       "LockSystemModalContainer",
 609       lock_screen_containers);
 610   lock_modal_container_handler_.reset(
 611       new ToplevelWindowEventHandler(lock_modal_container));
 612   lock_modal_container->SetLayoutManager(
 613       new SystemModalContainerLayoutManager(lock_modal_container));
 614   SetChildWindowVisibilityChangesAnimated(lock_modal_container);
 615   SetUsesScreenCoordinates(lock_modal_container);
 616
 617   aura::Window* status_container =
 618       CreateContainer(kShellWindowId_StatusContainer,
 619                       "StatusContainer",
 620                       lock_screen_related_containers);
 621   SetUsesScreenCoordinates(status_container);
 622
 623   aura::Window* settings_bubble_container = CreateContainer(
 624       kShellWindowId_SettingBubbleContainer,
 625       "SettingBubbleContainer",
 626       lock_screen_related_containers);
 627   SetChildWindowVisibilityChangesAnimated(settings_bubble_container);
 628   SetUsesScreenCoordinates(settings_bubble_container);
 629
 630   aura::Window* menu_container = CreateContainer(
 631       kShellWindowId_MenuContainer,
 632       "MenuContainer",
 633       lock_screen_related_containers);
 634   SetChildWindowVisibilityChangesAnimated(menu_container);
 635   SetUsesScreenCoordinates(menu_container);
 636
 637   aura::Window* drag_drop_container = CreateContainer(
 638       kShellWindowId_DragImageAndTooltipContainer,
 639       "DragImageAndTooltipContainer",
 640       lock_screen_related_containers);
 641   SetChildWindowVisibilityChangesAnimated(drag_drop_container);
 642   SetUsesScreenCoordinates(drag_drop_container);
 643
 644   aura::Window* overlay_container = CreateContainer(
 645       kShellWindowId_OverlayContainer,
 646       "OverlayContainer",
 647       lock_screen_related_containers);
 648   SetUsesScreenCoordinates(overlay_container);
 649
 650   CreateContainer(kShellWindowId_PowerButtonAnimationContainer,
 651                   "PowerButtonAnimationContainer", root_window) ;
 652 }
 653
 654 }  // namespace internal
 655 }  // namespace ash