Folds WmRootWindowController into RootWindowController

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/ash_touch_exploration_manager_chromeos.h"
@@ skipping 11 matching lines @@
 #include "ash/common/shell_delegate.h"
 #include "ash/common/system/status_area_layout_manager.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wallpaper/wallpaper_widget_controller.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/lock_layout_manager.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/system_modal_container_layout_manager.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_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.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/boot_splash_screen_chromeos.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_wallpaper_controller.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "chromeos/chromeos_switches.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/screen_position_client.h"
+#include "ui/aura/mus/window_mus.h"
+#include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
+#include "ui/base/models/menu_model.h"
 #include "ui/chromeos/touch_exploration_controller.h"
 #include "ui/display/types/display_constants.h"
+#include "ui/events/event_utils.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
+#include "ui/views/controls/menu/menu_model_adapter.h"
+#include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/view_model.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/wm/core/capture_controller.h"
+#include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/tooltip_client.h"
 #include "ui/wm/public/window_types.h"
 
 namespace ash {
 namespace {
 
 // Duration for the animation that hides the boot splash screen, in
 // milliseconds.  This should be short enough in relation to
@@ skipping 50 matching lines @@
 
 }  // namespace
 
 RootWindowController::~RootWindowController() {
   Shutdown();
   ash_host_.reset();
   mus_window_tree_host_.reset();
   // The CaptureClient needs to be around for as long as the RootWindow is
   // valid.
   capture_client_.reset();
+  if (animating_wallpaper_widget_controller_.get())
+    animating_wallpaper_widget_controller_->StopAnimating();
 }
 
 void RootWindowController::CreateForPrimaryDisplay(AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host, nullptr);
   controller->Init(RootWindowType::PRIMARY);
 }
 
 void RootWindowController::CreateForSecondaryDisplay(AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host, nullptr);
   controller->Init(RootWindowType::SECONDARY);
@@ skipping 23 matching lines @@
 }
 
 aura::Window* RootWindowController::GetRootWindow() {
   return GetHost()->window();
 }
 
 const aura::Window* RootWindowController::GetRootWindow() const {
   return GetHost()->window();
 }
 
-WorkspaceController* RootWindowController::workspace_controller() {
-  return wm_root_window_controller_->workspace_controller();
-}
-
 void RootWindowController::Shutdown() {
   WmShell::Get()->RemoveShellObserver(this);
 
   touch_exploration_manager_.reset();
 
-  wm_root_window_controller_->ResetRootForNewWindowsIfNecessary();
+  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::kInvalidDisplayId;
   if (ash_host_)
     ash_host_->PrepareForShutdown();
 
@@ skipping 62 matching lines @@
     // brightness/grayscale animation.
     boot_splash_screen_->StartHideAnimation(
         base::TimeDelta::FromMilliseconds(kBootSplashScreenHideDurationMs));
   }
 }
 
 void RootWindowController::OnWallpaperAnimationFinished(views::Widget* widget) {
   // Make sure the wallpaper is visible.
   system_wallpaper_->SetColor(SK_ColorBLACK);
   boot_splash_screen_.reset();
+  WmShell::Get()->wallpaper_delegate()->OnWallpaperAnimationFinished();
+  // Only removes old component when wallpaper animation finished. If we
+  // remove the old one before the new wallpaper is done fading in there will
+  // be a white flash during the animation.
+  if (animating_wallpaper_widget_controller()) {
+    WallpaperWidgetController* controller =
+        animating_wallpaper_widget_controller()->GetController(true);
+    DCHECK_EQ(controller->widget(), widget);
+    // Release the old controller and close its wallpaper widget.
+    SetWallpaperWidgetController(controller);
+  }
 }
 
 void RootWindowController::CloseChildWindows() {
   // Remove observer as deactivating keyboard causes
   // docked_window_layout_manager() to fire notifications.
   if (docked_window_layout_manager() && wm_shelf_->shelf_layout_manager()) {
     docked_window_layout_manager()->RemoveObserver(
         wm_shelf_->shelf_layout_manager());
   }
 
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
-  wm_root_window_controller_->CloseChildWindows();
+  CloseChildWindowsImpl();
 
   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_->shelf_layout_manager();
 }
 
 StatusAreaWidget* RootWindowController::GetStatusAreaWidget() {
   ShelfWidget* shelf_widget = wm_shelf_->shelf_widget();
   return shelf_widget ? shelf_widget->status_area_widget() : nullptr;
 }
 
 SystemTray* RootWindowController::GetSystemTray() {
@@ skipping 17 matching lines @@
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(wm_shelf_->shelf_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(
-      wm_root_window_controller_->always_on_top_controller()
-          ->GetLayoutManager());
+      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_->shelf_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(
-        wm_root_window_controller_->always_on_top_controller()
-            ->GetLayoutManager());
+        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(
@@ skipping 12 matching lines @@
       mus_window_tree_host_(window_tree_host),
       window_tree_host_(ash_host ? ash_host->AsWindowTreeHost()
                                  : window_tree_host),
       wm_shelf_(base::MakeUnique<WmShelf>()),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
   DCHECK((ash_host && !window_tree_host) || (!ash_host && window_tree_host));
   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_ = base::MakeUnique<WmRootWindowController>(
-      this, WmWindowAura::Get(root_window));
-
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowParentingClient(root_window,
                                          stacking_controller_.get());
   capture_client_.reset(new ::wm::ScopedCaptureClient(root_window));
 }
 
 void RootWindowController::Init(RootWindowType root_window_type) {
   aura::Window* root_window = GetRootWindow();
   WmShell* wm_shell = WmShell::Get();
   Shell* shell = nullptr;
   if (!wm_shell->IsRunningInMash()) {
     shell = Shell::GetInstance();
     shell->InitRootWindow(root_window);
   }
 
-  wm_root_window_controller_->CreateContainers();
+  CreateContainers();
 
   CreateSystemWallpaper(root_window_type);
 
   InitLayoutManagers();
   InitTouchHuds();
 
   if (wm_shell->GetPrimaryRootWindowController()
           ->GetSystemModalLayoutManager(nullptr)
           ->has_window_dimmer()) {
-    wm_root_window_controller_->GetSystemModalLayoutManager(nullptr)
-        ->CreateModalBackground();
+    GetSystemModalLayoutManager(nullptr)->CreateModalBackground();
   }
 
   wm_shell->AddShellObserver(this);
 
-  wm_root_window_controller_->root_window_layout_manager()->OnWindowResized();
+  root_window_layout_manager_->OnWindowResized();
   if (root_window_type == RootWindowType::PRIMARY) {
     if (!wm_shell->IsRunningInMash())
       shell->InitKeyboard();
   } else {
     window_tree_host_->Show();
 
     // Create a shelf if a user is already logged in.
     if (wm_shell->GetSessionStateDelegate()->NumberOfLoggedInUsers())
-      wm_root_window_controller_->CreateShelf();
+      CreateShelf();
 
     // Notify shell observers about new root window.
     if (!wm_shell->IsRunningInMash())
       shell->OnRootWindowAdded(WmWindowAura::Get(root_window));
   }
 
   // TODO: AshTouchExplorationManager doesn't work with mus.
   // http://crbug.com/679782
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableTouchExplorationMode) &&
       !wm_shell->IsRunningInMash()) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   // Create the shelf and status area widgets.
   DCHECK(!wm_shelf_->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_root_window_controller_->CreateLayoutManagers();
+  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_.get()));
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_status_container, wm_shelf_.get()));
 
   panel_container_handler_ = base::MakeUnique<PanelWindowEventHandler>();
   GetContainer(kShellWindowId_PanelContainer)
@@ skipping 53 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_->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