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