Centralizes more shared code between ash and mash

ash/root_window_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/aura/aura_layout_manager_adapter.h"
@@ skipping 225 matching lines @@
   return wm_root_window_controller_->workspace_controller();
 }
 
 void RootWindowController::Shutdown() {
   WmShell::Get()->RemoveShellObserver(this);
 
 #if defined(OS_CHROMEOS)
   touch_exploration_manager_.reset();
 #endif
 
-  aura::Window* root_window = GetRootWindow();
-  WmWindow* root_shutting_down = WmWindowAura::Get(root_window);
-  WmShell* shell = WmShell::Get();
-  // Change the target root window before closing child windows. If any child
-  // being removed triggers a relayout of the shelf it will try to build a
-  // window list adding windows from the target root window's containers which
-  // may have already gone away.
-  if (shell->GetRootWindowForNewWindows() == root_shutting_down) {
-    // The root window for new windows is being destroyed. Switch to the primary
-    // root window if possible.
-    WmWindow* primary_root = shell->GetPrimaryRootWindow();
-    shell->set_root_window_for_new_windows(
-        primary_root == root_shutting_down ? nullptr : primary_root);
-  }
+  wm_root_window_controller_->ResetRootForNewWindowsIfNecessary();
 
   CloseChildWindows();
+  aura::Window* root_window = GetRootWindow();
   GetRootWindowSettings(root_window)->controller = NULL;
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   GetRootWindowSettings(root_window)->display_id =
       display::Display::kInvalidDisplayID;
   ash_host_->PrepareForShutdown();
 
   system_wallpaper_.reset();
   aura::client::SetScreenPositionClient(root_window, NULL);
 }
@@ skipping 57 matching lines @@
   // TODO(jamescook): Move this into WmShelf.
   wm_shelf_aura_->shelf_widget()->SetShelfVisibility(true);
   wm_shelf_aura_->shelf_widget()->status_area_widget()->Show();
 }
 
 void RootWindowController::CreateShelf() {
   if (wm_shelf_aura_->IsShelfInitialized())
     return;
   wm_shelf_aura_->InitializeShelf();
 
-  if (panel_layout_manager_)
-    panel_layout_manager_->SetShelf(wm_shelf_aura_.get());
-  if (docked_layout_manager_) {
-    docked_layout_manager_->SetShelf(wm_shelf_aura_.get());
+  if (panel_layout_manager())
+    panel_layout_manager()->SetShelf(wm_shelf_aura_.get());
+  if (docked_window_layout_manager()) {
+    docked_window_layout_manager()->SetShelf(wm_shelf_aura_.get());
     if (wm_shelf_aura_->shelf_layout_manager()) {
-      docked_layout_manager_->AddObserver(
+      docked_window_layout_manager()->AddObserver(
           wm_shelf_aura_->shelf_layout_manager());
     }
   }
 
   // Notify shell observers that the shelf has been created.
   // TODO(jamescook): Move this into WmShelf::InitializeShelf(). This will
   // require changing AttachedPanelWidgetTargeter's access to WmShelf.
   WmShell::Get()->NotifyShelfCreatedForRootWindow(
       WmWindowAura::Get(GetRootWindow()));
 
@@ skipping 26 matching lines @@
   // Make sure the wallpaper is visible.
   system_wallpaper_->SetColor(SK_ColorBLACK);
 #if defined(OS_CHROMEOS)
   boot_splash_screen_.reset();
 #endif
 }
 
 void RootWindowController::CloseChildWindows() {
   mouse_event_target_.reset();
 
-  // Remove observer as deactivating keyboard causes |docked_layout_manager_|
-  // to fire notifications.
-  if (docked_layout_manager_ && wm_shelf_aura_->shelf_layout_manager()) {
-    docked_layout_manager_->RemoveObserver(
+  // Remove observer as deactivating keyboard causes
+  // docked_window_layout_manager() to fire notifications.
+  if (docked_window_layout_manager() &&
+      wm_shelf_aura_->shelf_layout_manager()) {
+    docked_window_layout_manager()->RemoveObserver(
         wm_shelf_aura_->shelf_layout_manager());
   }
 
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
-  // panel_layout_manager_ needs to be shut down before windows are destroyed.
-  if (panel_layout_manager_) {
-    panel_layout_manager_->Shutdown();
-    panel_layout_manager_ = NULL;
-  }
-  // docked_layout_manager_ needs to be shut down before windows are destroyed.
-  if (docked_layout_manager_) {
-    docked_layout_manager_->Shutdown();
-    docked_layout_manager_ = NULL;
-  }
-  wm_shelf_aura_->ShutdownShelfWidget();
+  wm_root_window_controller_->CloseChildWindows();
 
-  wm_root_window_controller_->DeleteWorkspaceController();
-
-  // Explicitly destroy top level windows. We do this as during part of
-  // destruction such windows may query the RootWindow for state.
-  aura::Window* root_window = GetRootWindow();
-  aura::WindowTracker non_toplevel_windows;
-  non_toplevel_windows.Add(root_window);
-  while (!non_toplevel_windows.windows().empty()) {
-    const aura::Window* non_toplevel_window =
-        *non_toplevel_windows.windows().begin();
-    non_toplevel_windows.Remove(const_cast<aura::Window*>(non_toplevel_window));
-    aura::WindowTracker toplevel_windows;
-    for (size_t i = 0; i < non_toplevel_window->children().size(); ++i) {
-      aura::Window* child = non_toplevel_window->children()[i];
-      if (!child->owned_by_parent())
-        continue;
-      if (child->delegate())
-        toplevel_windows.Add(child);
-      else
-        non_toplevel_windows.Add(child);
-    }
-    while (!toplevel_windows.windows().empty())
-      delete *toplevel_windows.windows().begin();
-  }
-  // And then remove the containers.
-  while (!root_window->children().empty()) {
-    aura::Window* window = root_window->children()[0];
-    if (window->owned_by_parent()) {
-      delete window;
-    } else {
-      root_window->RemoveChild(window);
-    }
-  }
-
-  wm_shelf_aura_->DestroyShelfWidget();
-
-  // CloseChildWindows may be called twice during the shutdown of ash unittests.
-  // Avoid notifying WmShelf that the shelf has been destroyed twice.
-  if (wm_shelf_aura_->IsShelfInitialized())
-    wm_shelf_aura_->ShutdownShelf();
-
-  aura::client::SetDragDropClient(root_window, nullptr);
-  aura::client::SetTooltipClient(root_window, nullptr);
+  aura::client::SetDragDropClient(GetRootWindow(), nullptr);
+  aura::client::SetTooltipClient(GetRootWindow(), nullptr);
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   wm_root_window_controller_->MoveWindowsTo(WmWindowAura::Get(dst));
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
   return wm_shelf_aura_->shelf_layout_manager();
 }
 
@@ skipping 19 matching lines @@
 }
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(wm_shelf_aura_->shelf_layout_manager());
-  keyboard_controller->AddObserver(panel_layout_manager_);
-  keyboard_controller->AddObserver(docked_layout_manager_);
+  keyboard_controller->AddObserver(panel_layout_manager());
+  keyboard_controller->AddObserver(docked_window_layout_manager());
   keyboard_controller->AddObserver(workspace_controller()->layout_manager());
   keyboard_controller->AddObserver(
-      always_on_top_controller_->GetLayoutManager());
+      wm_root_window_controller_->always_on_top_controller()
+          ->GetLayoutManager());
   WmShell::Get()->NotifyVirtualKeyboardActivated(true);
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   DCHECK(parent);
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   keyboard_container->set_id(kShellWindowId_VirtualKeyboardContainer);
   parent->AddChild(keyboard_container);
 }
 
 void RootWindowController::DeactivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard_controller ||
       !keyboard_controller->keyboard_container_initialized()) {
     return;
   }
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   if (keyboard_container->GetRootWindow() == GetRootWindow()) {
     aura::Window* parent =
         GetContainer(kShellWindowId_ImeWindowParentContainer);
     DCHECK(parent);
     parent->RemoveChild(keyboard_container);
     // Virtual keyboard may be deactivated while still showing, notify all
     // observers that keyboard bounds changed to 0 before remove them.
     keyboard_controller->NotifyKeyboardBoundsChanging(gfx::Rect());
     keyboard_controller->RemoveObserver(wm_shelf_aura_->shelf_layout_manager());
-    keyboard_controller->RemoveObserver(panel_layout_manager_);
-    keyboard_controller->RemoveObserver(docked_layout_manager_);
+    keyboard_controller->RemoveObserver(panel_layout_manager());
+    keyboard_controller->RemoveObserver(docked_window_layout_manager());
     keyboard_controller->RemoveObserver(
         workspace_controller()->layout_manager());
     keyboard_controller->RemoveObserver(
-        always_on_top_controller_->GetLayoutManager());
+        wm_root_window_controller_->always_on_top_controller()
+            ->GetLayoutManager());
     WmShell::Get()->NotifyVirtualKeyboardActivated(false);
   }
 }
 
 bool RootWindowController::IsVirtualKeyboardWindow(aura::Window* window) {
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   return parent ? parent->Contains(window) : false;
 }
 
 void RootWindowController::SetTouchAccessibilityAnchorPoint(
     const gfx::Point& anchor_point) {
 #if defined(OS_CHROMEOS)
   if (touch_exploration_manager_)
     touch_exploration_manager_->SetTouchAccessibilityAnchorPoint(anchor_point);
 #endif  // defined(OS_CHROMEOS)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowController, private:
 
 RootWindowController::RootWindowController(AshWindowTreeHost* ash_host)
     : ash_host_(ash_host),
       wm_shelf_aura_(new WmShelfAura),
-      docked_layout_manager_(NULL),
-      panel_layout_manager_(NULL),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
   aura::Window* root_window = GetRootWindow();
   GetRootWindowSettings(root_window)->controller = this;
 
   // Has to happen after this is set as |controller| of RootWindowSettings.
   wm_root_window_controller_ = WmRootWindowControllerAura::Get(root_window);
 
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowTreeClient(root_window, stacking_controller_.get());
@@ skipping 39 matching lines @@
 
 #if defined(OS_CHROMEOS)
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableTouchExplorationMode)) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 #endif
 }
 
 void RootWindowController::InitLayoutManagers() {
-  wm_root_window_controller_->CreateLayoutManagers();
-
-  aura::Window* root_window = GetRootWindow();
-
-  WmWindow* always_on_top_container =
-      WmWindowAura::Get(GetContainer(kShellWindowId_AlwaysOnTopContainer));
-  always_on_top_controller_.reset(
-      new AlwaysOnTopController(always_on_top_container));
-
   // Create the shelf and status area widgets.
   DCHECK(!wm_shelf_aura_->shelf_widget());
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
   aura::Window* status_container = GetContainer(kShellWindowId_StatusContainer);
   WmWindow* wm_shelf_container = WmWindowAura::Get(shelf_container);
   WmWindow* wm_status_container = WmWindowAura::Get(status_container);
-  wm_shelf_aura_->CreateShelfWidget(WmWindowAura::Get(root_window));
+  wm_shelf_aura_->CreateShelfWidget(WmWindowAura::Get(GetRootWindow()));
+
+  wm_root_window_controller_->CreateLayoutManagers();
 
   // Make it easier to resize windows that partially overlap the shelf. Must
   // occur after the ShelfLayoutManager is constructed by ShelfWidget.
   shelf_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_shelf_container, wm_shelf_aura_.get()));
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_status_container, wm_shelf_aura_.get()));
 
   if (!WmShell::Get()
            ->GetSessionStateDelegate()
            ->IsActiveUserSessionStarted()) {
     // This window exists only to be a event target on login screen.
     // It does not have to handle events, nor be visible.
     mouse_event_target_.reset(new aura::Window(new EmptyWindowDelegate));
     mouse_event_target_->Init(ui::LAYER_NOT_DRAWN);
 
     aura::Window* lock_wallpaper_container =
         GetContainer(kShellWindowId_LockScreenWallpaperContainer);
     lock_wallpaper_container->AddChild(mouse_event_target_.get());
     mouse_event_target_->Show();
   }
 
-  // Create Docked windows layout manager
-  WmWindow* docked_container =
-      WmWindowAura::Get(GetContainer(kShellWindowId_DockedContainer));
-  docked_layout_manager_ = new DockedWindowLayoutManager(docked_container);
-  docked_container->SetLayoutManager(base::WrapUnique(docked_layout_manager_));
-
-  // Installs WmSnapLayoutManager on appropriate containers.
-  wm::WmSnapToPixelLayoutManager::InstallOnContainers(
-      WmWindowAura::Get(root_window));
-
-  // Create Panel layout manager
-  aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
-  WmWindow* wm_panel_container = WmWindowAura::Get(panel_container);
-  panel_layout_manager_ = new PanelLayoutManager(wm_panel_container);
-  wm_panel_container->SetLayoutManager(base::WrapUnique(panel_layout_manager_));
-  panel_container_handler_.reset(new PanelWindowEventHandler);
-  panel_container->AddPreTargetHandler(panel_container_handler_.get());
+  panel_container_handler_ = base::MakeUnique<PanelWindowEventHandler>();
+  GetContainer(kShellWindowId_PanelContainer)
+      ->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
   gfx::Insets touch_extend =
       mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
-  panel_container->SetEventTargeter(
-      std::unique_ptr<ui::EventTargeter>(new AttachedPanelWindowTargeter(
-          panel_container, mouse_extend, touch_extend, panel_layout_manager_)));
+  aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
+  panel_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
+      new AttachedPanelWindowTargeter(panel_container, mouse_extend,
+                                      touch_extend, panel_layout_manager())));
 }
 
 void RootWindowController::InitTouchHuds() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::GetInstance()->is_touch_hud_projection_enabled())
     EnableTouchHudProjection();
 }
 
@@ skipping 23 matching lines @@
     return;
   set_touch_hud_projection(new TouchHudProjection(GetRootWindow()));
 }
 
 void RootWindowController::DisableTouchHudProjection() {
   if (!touch_hud_projection_)
     return;
   touch_hud_projection_->Remove();
 }
 
+DockedWindowLayoutManager*
+RootWindowController::docked_window_layout_manager() {
+  return wm_root_window_controller_->docked_window_layout_manager();
+}
+
+PanelLayoutManager* RootWindowController::panel_layout_manager() {
+  return wm_root_window_controller_->panel_layout_manager();
+}
+
 void RootWindowController::OnLoginStateChanged(LoginStatus status) {
   wm_shelf_aura_->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash