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