Moves WorkspaceController to ash/common

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 18 matching lines @@
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wm/always_on_top_controller.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/root_window_layout_manager.h"
 #include "ash/common/wm/switchable_windows.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
+#include "ash/common/wm/workspace_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/root_window_settings.h"
 #include "ash/shelf/shelf_window_targeter.h"
 #include "ash/shell.h"
 #include "ash/touch/touch_hud_debug.h"
 #include "ash/touch/touch_hud_projection.h"
 #include "ash/touch/touch_observer_hud.h"
 #include "ash/wm/lock_layout_manager.h"
 #include "ash/wm/panels/attached_panel_window_targeter.h"
 #include "ash/wm/panels/panel_window_event_handler.h"
 #include "ash/wm/stacking_controller.h"
 #include "ash/wm/system_background_controller.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
-#include "ash/wm/workspace_controller.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
@@ skipping 253 matching lines @@
 }
 
 aura::Window* RootWindowController::GetRootWindow() {
   return GetHost()->window();
 }
 
 const aura::Window* RootWindowController::GetRootWindow() const {
   return GetHost()->window();
 }
 
+WorkspaceController* RootWindowController::workspace_controller() {
+  return root_window_controller_common_->workspace_controller();
+}
+
 void RootWindowController::SetWallpaperController(
     DesktopBackgroundWidgetController* controller) {
   wallpaper_controller_.reset(controller);
 }
 
 void RootWindowController::SetAnimatingWallpaperController(
     AnimatingDesktopController* controller) {
   if (animating_wallpaper_controller_.get())
     animating_wallpaper_controller_->StopAnimating();
   animating_wallpaper_controller_.reset(controller);
@@ skipping 22 matching lines @@
   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);
   }
 
   CloseChildWindows();
   GetRootWindowSettings(root_window)->controller = NULL;
-  workspace_controller_.reset();

[msw, 2016/08/30 17:46:20]

nice (called in CloseChildWindows)

   // 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_background_.reset();
   aura::client::SetScreenPositionClient(root_window, NULL);
 }
 
@@ skipping 183 matching lines @@
   aura::Window* root_window = GetRootWindow();
   aura::client::SetDragDropClient(root_window, NULL);
 
   if (shelf_widget_)
     shelf_widget_->Shutdown();
 
   // Close background widget first as it depends on tooltip.
   wallpaper_controller_.reset();
   animating_wallpaper_controller_.reset();
 
-  workspace_controller_.reset();
+  root_window_controller_common_->DeleteWorkspaceController();
   aura::client::SetTooltipClient(root_window, NULL);
 
   // Explicitly destroy top level windows. We do this as during part of
   // destruction such windows may query the RootWindow for state.
   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));
@@ skipping 23 matching lines @@
   shelf_widget_.reset();
   // CloseChildWindows may be called twice during the shutdown of ash unittests.
   // Avoid notifying WmShelf that the Shelf instance has been destroyed twice.
   if (wm_shelf_aura_->shelf())
     wm_shelf_aura_->ClearShelf();
   shelf_.reset();
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   // Clear the workspace controller, so it doesn't incorrectly update the shelf.
-  workspace_controller_.reset();
+  root_window_controller_common_->DeleteWorkspaceController();
   ReparentAllWindows(GetRootWindow(), dst);
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
   return shelf_widget_->shelf_layout_manager();
 }
 
 SystemTray* RootWindowController::GetSystemTray() {
   // We assume in throughout the code that this will not return NULL. If code
   // triggers this for valid reasons, it should test status_area_widget first.
@@ skipping 39 matching lines @@
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(shelf_widget()->shelf_layout_manager());
   keyboard_controller->AddObserver(panel_layout_manager_);
   keyboard_controller->AddObserver(docked_layout_manager_);
-  keyboard_controller->AddObserver(workspace_controller_->layout_manager());
+  keyboard_controller->AddObserver(workspace_controller()->layout_manager());
   keyboard_controller->AddObserver(
       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(shelf_widget()->shelf_layout_manager());
     keyboard_controller->RemoveObserver(panel_layout_manager_);
     keyboard_controller->RemoveObserver(docked_layout_manager_);
     keyboard_controller->RemoveObserver(
-        workspace_controller_->layout_manager());
+        workspace_controller()->layout_manager());
     keyboard_controller->RemoveObserver(
         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;
 }
@@ skipping 84 matching lines @@
       root_window->GetChildById(kShellWindowId_LockScreenContainer);
   DCHECK(lock_container);
   lock_container->SetLayoutManager(new LockLayoutManager(lock_container));
 
   aura::Window* lock_modal_container =
       root_window->GetChildById(kShellWindowId_LockSystemModalContainer);
   DCHECK(lock_modal_container);
   lock_modal_container->SetLayoutManager(
       new SystemModalContainerLayoutManager(lock_modal_container));
 
-  WmWindow* default_container =
-      WmWindowAura::Get(GetContainer(kShellWindowId_DefaultContainer));
-  workspace_controller_.reset(new WorkspaceController(default_container));
-
   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(!shelf_widget_.get());
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
   aura::Window* status_container = GetContainer(kShellWindowId_StatusContainer);
   WmWindow* wm_shelf_container = WmWindowAura::Get(shelf_container);
@@ skipping 124 matching lines @@
     aura::Window* primary_root_window = Shell::GetInstance()
                                             ->window_tree_host_manager()
                                             ->GetPrimaryRootWindow();
     return GetRootWindowSettings(primary_root_window)->controller;
   }
 
   return GetRootWindowSettings(root_window)->controller;
 }
 
 }  // namespace ash