mash: Migrate ShellDelegate ownership and access to WmShell.

ash/shell.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/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_delegate.h"
 #include "ash/accelerators/focus_manager_factory.h"
 #include "ash/aura/wm_shell_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/keyboard/keyboard_ui.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_model.h"
+#include "ash/common/shell_delegate.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/locale/locale_notification_controller.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/root_window_finder.h"
 #include "ash/common/wm/window_positioner.h"
 #include "ash/common/wm_shell.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 17 matching lines @@
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/new_window_delegate.h"
 #include "ash/pointer_watcher_delegate.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/app_list_shelf_item_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/shelf_window_watcher.h"
-#include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_init_params.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/toast/toast_manager.h"
 #include "ash/utility/screenshot_controller.h"
 #include "ash/wm/ash_focus_rules.h"
 #include "ash/wm/ash_native_cursor_manager.h"
 #include "ash/wm/event_client_impl.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/overlay_event_filter.h"
@@ skipping 240 matching lines @@
     return;
 
   aura::Window* root = WmWindowAura::GetAuraWindow(
       wm::GetRootWindowMatching(gfx::Rect(location_in_screen, gfx::Size())));
   GetRootWindowController(root)->ShowContextMenu(location_in_screen,
                                                  source_type);
 }
 
 void Shell::ShowAppList(aura::Window* window) {
   // If the context window is not given, show it on the target root window.
-  delegate_->GetAppListPresenter()->Show(GetDisplayIdForWindow(window));
+  wm_shell_->delegate()->GetAppListPresenter()->Show(
+      GetDisplayIdForWindow(window));
 }
 
 void Shell::DismissAppList() {
-  delegate_->GetAppListPresenter()->Dismiss();
+  wm_shell_->delegate()->GetAppListPresenter()->Dismiss();
 }
 
 void Shell::ToggleAppList(aura::Window* window) {
   // If the context window is not given, show it on the target root window.
-  delegate_->GetAppListPresenter()->ToggleAppList(
+  wm_shell_->delegate()->GetAppListPresenter()->ToggleAppList(
       GetDisplayIdForWindow(window));
 }
 
 bool Shell::IsApplistVisible() const {
-  return delegate_->GetAppListPresenter()->IsVisible();
+  return wm_shell_->delegate()->GetAppListPresenter()->IsVisible();
 }
 
 bool Shell::GetAppListTargetVisibility() const {
-  return delegate_->GetAppListPresenter()->GetTargetVisibility();
+  return wm_shell_->delegate()->GetAppListPresenter()->GetTargetVisibility();
 }
 
 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView(
     views::Widget* widget) {
   // Use translucent-style window frames for dialogs.
   return new CustomFrameViewAsh(widget);
 }
 
 void Shell::SetDisplayWorkAreaInsets(Window* contains,
                                      const gfx::Insets& insets) {
@@ skipping 192 matching lines @@
 SystemTray* Shell::GetPrimarySystemTray() {
   return GetPrimaryRootWindowController()->GetSystemTray();
 }
 
 ShelfDelegate* Shell::GetShelfDelegate() {
   if (!shelf_delegate_) {
     // Creates ShelfItemDelegateManager before ShelfDelegate.
     shelf_item_delegate_manager_.reset(
         new ShelfItemDelegateManager(shelf_model_.get()));
 
-    shelf_delegate_.reset(delegate_->CreateShelfDelegate(shelf_model_.get()));
+    shelf_delegate_.reset(
+        wm_shell_->delegate()->CreateShelfDelegate(shelf_model_.get()));
     std::unique_ptr<ShelfItemDelegate> controller(new AppListShelfItemDelegate);
 
     // Finding the shelf model's location of the app list and setting its
     // ShelfItemDelegate.
     int app_list_index = shelf_model_->GetItemIndexForType(TYPE_APP_LIST);
     DCHECK_GE(app_list_index, 0);
     ShelfID app_list_id = shelf_model_->items()[app_list_index].id;
     DCHECK(app_list_id);
     shelf_item_delegate_manager_->SetShelfItemDelegate(app_list_id,
                                                        std::move(controller));
@@ skipping 27 matching lines @@
 void Shell::DoInitialWorkspaceAnimation() {
   return GetPrimaryRootWindowController()
       ->workspace_controller()
       ->DoInitialAnimation();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(ShellDelegate* delegate, base::SequencedWorkerPool* blocking_pool)
-    : target_root_window_(nullptr),
+    : wm_shell_(new WmShellAura(delegate)),

[James Cook, 2016/07/06 21:27:27]

It's nice that it works to move this here!

[msw, 2016/07/06 21:58:56]

Acknowledged.

+      target_root_window_(nullptr),
       scoped_target_root_window_(nullptr),
-      delegate_(delegate),
       shelf_model_(new ShelfModel),
       link_handler_model_factory_(nullptr),
       activation_client_(nullptr),
 #if defined(OS_CHROMEOS)
       display_configurator_(new ui::DisplayConfigurator()),
 #endif  // defined(OS_CHROMEOS)
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false),
       blocking_pool_(blocking_pool) {
-  DCHECK(delegate_.get());
   DCHECK(aura::Env::GetInstanceDontCreate());
-  gpu_support_.reset(delegate_->CreateGPUSupport());
+  gpu_support_.reset(wm_shell_->delegate()->CreateGPUSupport());
   display_manager_.reset(new DisplayManager);
   window_tree_host_manager_.reset(new WindowTreeHostManager);
   user_metrics_recorder_.reset(new UserMetricsRecorder);
 
 #if defined(OS_CHROMEOS)
   PowerStatus::Initialize();
 #endif
 }
 
 Shell::~Shell() {
   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
 
   user_metrics_recorder_->OnShellShuttingDown();
 
-  delegate_->PreShutdown();
+  wm_shell_->delegate()->PreShutdown();
 
   views::FocusManagerFactory::Install(nullptr);
 
   // Remove the focus from any window. This will prevent overhead and side
   // effects (e.g. crashes) from changing focus during shutdown.
   // See bug crbug.com/134502.
   aura::client::GetFocusClient(GetPrimaryRootWindow())->FocusWindow(nullptr);
 
   // Please keep in same order as in Init() because it's easy to miss one.
   if (window_modality_controller_)
@@ skipping 162 matching lines @@
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   in_mus_ = init_params.in_mus;
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   DCHECK(in_mus_) << "linux desktop does not support ash.";
 #endif
 
-  wm_shell_.reset(new WmShellAura);
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_.reset(new WindowPositioner(wm_shell_.get()));
 
   if (!in_mus_) {
     native_cursor_manager_ = new AshNativeCursorManager;
 #if defined(OS_CHROMEOS)
     cursor_manager_.reset(
         new CursorManager(base::WrapUnique(native_cursor_manager_)));
 #else
     cursor_manager_.reset(
         new ::wm::CursorManager(base::WrapUnique(native_cursor_manager_)));
 #endif
   }
 
-  delegate_->PreInit();
+  wm_shell_->delegate()->PreInit();
   bool display_initialized = display_manager_->InitFromCommandLine();
 
   display_configuration_controller_.reset(new DisplayConfigurationController(
       display_manager_.get(), window_tree_host_manager_.get()));
 
 #if defined(OS_CHROMEOS)
   // When running as part of mash display configuration is handled by the mus
   // process, so we won't try to configure displays here.
   if (in_mus_) {
     display_configurator_->set_configure_display(false);
@@ skipping 21 matching lines @@
       base::SysInfo::IsRunningOnChromeOS()) {
     display_change_observer_.reset(new DisplayChangeObserver);
     // Register |display_change_observer_| first so that the rest of
     // observer gets invoked after the root windows are configured.
     display_configurator_->AddObserver(display_change_observer_.get());
     display_error_observer_.reset(new DisplayErrorObserver());
     display_configurator_->AddObserver(display_error_observer_.get());
     display_configurator_->set_state_controller(display_change_observer_.get());
     display_configurator_->set_mirroring_controller(display_manager_.get());
     display_configurator_->ForceInitialConfigure(
-        delegate_->IsFirstRunAfterBoot() ? kChromeOsBootColor : 0);
+        wm_shell_->delegate()->IsFirstRunAfterBoot() ? kChromeOsBootColor : 0);
     display_initialized = true;
   }
   display_color_manager_.reset(
       new DisplayColorManager(display_configurator_.get(), blocking_pool_));
 #endif  // defined(OS_CHROMEOS)
 
   if (!display_initialized)
     display_manager_->InitDefaultDisplay();
 
   display_manager_->RefreshFontParams();
@@ skipping 119 matching lines @@
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
       std::unique_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
   AddPreTargetHandler(tooltip_controller_.get());
 
   event_client_.reset(new EventClientImpl);
 
   // This controller needs to be set before SetupManagedWindowMode.
   desktop_background_controller_.reset(
       new DesktopBackgroundController(blocking_pool_));
-  user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate());
+  user_wallpaper_delegate_.reset(
+      wm_shell_->delegate()->CreateUserWallpaperDelegate());
 
-  session_state_delegate_.reset(delegate_->CreateSessionStateDelegate());
-  accessibility_delegate_.reset(delegate_->CreateAccessibilityDelegate());
-  new_window_delegate_.reset(delegate_->CreateNewWindowDelegate());
+  session_state_delegate_.reset(
+      wm_shell_->delegate()->CreateSessionStateDelegate());
+  accessibility_delegate_.reset(
+      wm_shell_->delegate()->CreateAccessibilityDelegate());
+  new_window_delegate_.reset(wm_shell_->delegate()->CreateNewWindowDelegate());
   wm_shell_->SetMediaDelegate(

[James Cook, 2016/07/06 21:27:27]

Could the media delegate be created inside WmShell?

[msw, 2016/07/06 21:58:56]

Yes, all of these other delegates should be created and owned by WmShell; some
would be straightforward to move now, but I think it'd make sense to leave them
for followup CLs.

-      base::WrapUnique(delegate_->CreateMediaDelegate()));
-  pointer_watcher_delegate_ = delegate_->CreatePointerWatcherDelegate();
+      base::WrapUnique(wm_shell_->delegate()->CreateMediaDelegate()));
+  pointer_watcher_delegate_ =
+      wm_shell_->delegate()->CreatePointerWatcherDelegate();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
   shadow_controller_.reset(new ::wm::ShadowController(activation_client_));
 
   wm_shell_->SetSystemTrayDelegate(
-      base::WrapUnique(delegate()->CreateSystemTrayDelegate()));
+      base::WrapUnique(wm_shell_->delegate()->CreateSystemTrayDelegate()));

[James Cook, 2016/07/06 21:27:27]

ditto

[msw, 2016/07/06 21:58:56]

See comment above.

 
   locale_notification_controller_.reset(new LocaleNotificationController);
 
   // Initialize toast manager
   toast_manager_.reset(new ToastManager);
 
 #if defined(OS_CHROMEOS)
   // Create TouchTransformerController before
   // WindowTreeHostManager::InitDisplays()
   // since TouchTransformerController listens on
@@ skipping 63 matching lines @@
   if (keyboard::IsKeyboardEnabled()) {
     if (keyboard::KeyboardController::GetInstance()) {
       RootWindowControllerList controllers = GetAllRootWindowControllers();
       for (RootWindowControllerList::iterator iter = controllers.begin();
            iter != controllers.end(); ++iter) {
         (*iter)->DeactivateKeyboard(
             keyboard::KeyboardController::GetInstance());
       }
     }
     keyboard::KeyboardController::ResetInstance(
-        new keyboard::KeyboardController(delegate_->CreateKeyboardUI()));
+        new keyboard::KeyboardController(
+            wm_shell_->delegate()->CreateKeyboardUI()));
   }
 }
 
 void Shell::InitRootWindow(aura::Window* root_window) {
   DCHECK(activation_client_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
 
   aura::client::SetFocusClient(root_window, focus_client_.get());
   aura::client::SetActivationClient(root_window, activation_client_);
@@ skipping 48 matching lines @@
 
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash