chromeos: Promotes more from WmShell to Shell

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>
 
@@ skipping 92 matching lines @@
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "chromeos/audio/audio_a11y_controller.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/system/devicemode.h"
 #include "components/ui_devtools/devtools_server.h"
+#include "services/preferences/public/cpp/pref_client_store.h"
+#include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/user_activity_forwarder.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/user_activity/user_activity_detector.h"
@@ skipping 69 matching lines @@
 bool Shell::initially_hide_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 // static
 Shell* Shell::CreateInstance(const ShellInitParams& init_params) {
   CHECK(!instance_);
   WmShell* wm_shell = init_params.wm_shell;
   if (!wm_shell)
-    wm_shell =
-        new WmShellAura(base::WrapUnique<ShellDelegate>(init_params.delegate));
-  instance_ = new Shell(base::WrapUnique<WmShell>(wm_shell));
+    wm_shell = new WmShellAura();
+  instance_ = new Shell(base::WrapUnique<ShellDelegate>(init_params.delegate),
+                        base::WrapUnique<WmShell>(wm_shell));
   instance_->Init(init_params);
   return instance_;
 }
 
 // static
-Shell* Shell::GetInstance() {
+Shell* Shell::Get() {
   CHECK(instance_);
   return instance_;
 }
 
 // static
 bool Shell::HasInstance() {
   return !!instance_;
 }
 
 // static
@@ skipping 250 matching lines @@
 }
 
 void Shell::NotifyShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   for (auto& observer : shell_observers_)
     observer.OnShelfAutoHideBehaviorChanged(root_window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
-Shell::Shell(std::unique_ptr<WmShell> wm_shell)
+Shell::Shell(std::unique_ptr<ShellDelegate> shell_delegate,
+             std::unique_ptr<WmShell> wm_shell)
     : wm_shell_(std::move(wm_shell)),
+      shell_delegate_(std::move(shell_delegate)),
       link_handler_model_factory_(nullptr),
       display_configurator_(new display::DisplayConfigurator()),
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false) {
   // TODO(sky): better refactor cash/mash dependencies. Perhaps put all cash
   // state on WmShellAura. http://crbug.com/671246.
 
   if (!wm_shell_->IsRunningInMash()) {
-    gpu_support_.reset(wm_shell_->delegate()->CreateGPUSupport());
+    gpu_support_.reset(shell_delegate_->CreateGPUSupport());
     display_manager_.reset(ScreenAsh::CreateDisplayManager());
     window_tree_host_manager_.reset(new WindowTreeHostManager);
     user_metrics_recorder_.reset(new UserMetricsRecorder);
   }
 
   PowerStatus::Initialize();
 }
 
 Shell::~Shell() {
   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
 
   const bool is_mash = wm_shell_->IsRunningInMash();
 
   if (!is_mash)
     user_metrics_recorder_->OnShellShuttingDown();
 
-  wm_shell_->delegate()->PreShutdown();
+  shell_delegate_->PreShutdown();
 
   // 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_)
     window_modality_controller_.reset();
   if (!is_mash) {
@@ skipping 134 matching lines @@
   display_change_observer_.reset();
   shutdown_observer_.reset();
 
   PowerStatus::Shutdown();
 
   // Ensure that DBusThreadManager outlives this Shell.
   DCHECK(chromeos::DBusThreadManager::IsInitialized());
 
   // Needs to happen right before |instance_| is reset.
   wm_shell_.reset();
+  wallpaper_delegate_.reset();
+  pref_store_ = nullptr;
+  shell_delegate_.reset();
 
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   const bool is_mash = wm_shell_->IsRunningInMash();
 
   blocking_pool_ = init_params.blocking_pool;
 
+  wallpaper_delegate_ = shell_delegate_->CreateWallpaperDelegate();
+
+  // Can be null in tests.
+  if (shell_delegate_->GetShellConnector()) {
+    prefs::mojom::PreferencesServiceFactoryPtr pref_factory_ptr;
+    shell_delegate_->GetShellConnector()->BindInterface(
+        prefs::mojom::kServiceName, &pref_factory_ptr);
+    pref_store_ = new preferences::PrefClientStore(std::move(pref_factory_ptr));
+  }
+
   // Some delegates access WmShell during their construction. Create them here
   // instead of the WmShell constructor.
-  accessibility_delegate_.reset(
-      wm_shell_->delegate()->CreateAccessibilityDelegate());
-  palette_delegate_ = wm_shell_->delegate()->CreatePaletteDelegate();
+  accessibility_delegate_.reset(shell_delegate_->CreateAccessibilityDelegate());
+  palette_delegate_ = shell_delegate_->CreatePaletteDelegate();
   toast_manager_ = base::MakeUnique<ToastManager>();
 
   // Create the app list item in the shelf data model.
   AppListShelfItemDelegate::CreateAppListItemAndDelegate(
       wm_shell_->shelf_model());
 
   // Install the custom factory early on so that views::FocusManagers for Tray,
   // Shelf, and WallPaper could be created by the factory.
   views::FocusManagerFactory::Install(new AshFocusManagerFactory);
 
@@ skipping 22 matching lines @@
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_.reset(new WindowPositioner(wm_shell_.get()));
 
   if (!is_mash) {
     native_cursor_manager_ = new AshNativeCursorManager;
     cursor_manager_.reset(
         new CursorManager(base::WrapUnique(native_cursor_manager_)));
   }
 
-  wm_shell_->delegate()->PreInit();
+  shell_delegate_->PreInit();
   bool display_initialized = true;
   if (!is_mash) {
     display_initialized = display_manager_->InitFromCommandLine();
 
     display_configuration_controller_.reset(new DisplayConfigurationController(
         display_manager_.get(), window_tree_host_manager_.get()));
 
 #if defined(USE_OZONE)
     display_configurator_->Init(
         ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(),
@@ skipping 131 matching lines @@
       base::MakeUnique<LockStateController>(wm_shell_->shutdown_controller());
   power_button_controller_.reset(
       new PowerButtonController(lock_state_controller_.get()));
   // Pass the initial display state to PowerButtonController.
   power_button_controller_->OnDisplayModeChanged(
       display_configurator_->cached_displays());
 
   AddShellObserver(lock_state_controller_.get());
 
   // The connector is unavailable in some tests.
-  if (is_mash && wm_shell_->delegate()->GetShellConnector()) {
+  if (is_mash && shell_delegate_->GetShellConnector()) {
     ui::mojom::UserActivityMonitorPtr user_activity_monitor;
-    wm_shell_->delegate()->GetShellConnector()->BindInterface(
-        ui::mojom::kServiceName, &user_activity_monitor);
+    shell_delegate_->GetShellConnector()->BindInterface(ui::mojom::kServiceName,
+                                                        &user_activity_monitor);
     user_activity_forwarder_ = base::MakeUnique<aura::UserActivityForwarder>(
         std::move(user_activity_monitor), user_activity_detector_.get());
   }
 
   drag_drop_controller_.reset(new DragDropController);
   // |screenshot_controller_| needs to be created (and prepended as a
   // pre-target handler) at this point, because |mouse_cursor_filter_| needs to
   // process mouse events prior to screenshot session.
   // See http://crbug.com/459214
   screenshot_controller_.reset(new ScreenshotController());
@@ skipping 20 matching lines @@
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
       std::unique_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
   AddPreTargetHandler(tooltip_controller_.get());
 
   modality_filter_.reset(new SystemModalContainerEventFilter(this));
   AddPreTargetHandler(modality_filter_.get());
 
   event_client_.reset(new EventClientImpl);
 
-  session_state_delegate_.reset(
-      wm_shell_->delegate()->CreateSessionStateDelegate());
+  session_state_delegate_.reset(shell_delegate_->CreateSessionStateDelegate());
   // Must occur after Shell has installed its early pre-target handlers (for
   // example, WindowModalityController).
   wm_shell_->CreatePointerWatcherAdapter();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
   shadow_controller_.reset(new ::wm::ShadowController(focus_controller_.get()));
 
   wm_shell_->SetSystemTrayDelegate(
-      base::WrapUnique(wm_shell_->delegate()->CreateSystemTrayDelegate()));
+      base::WrapUnique(shell_delegate_->CreateSystemTrayDelegate()));
 
   // Create AshTouchTransformController before
   // WindowTreeHostManager::InitDisplays()
   // since AshTouchTransformController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
   if (!is_mash) {
     touch_transformer_controller_.reset(new AshTouchTransformController(
         display_configurator_.get(), display_manager_.get()));
   }
 
   if (!is_mash)
     wm_shell_->SetKeyboardUI(KeyboardUI::Create());
 
   wm_shell_->InitHosts(init_params);
 
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
   if (!is_mash)
     virtual_keyboard_controller_.reset(new VirtualKeyboardController);
 
   audio_a11y_controller_.reset(new chromeos::AudioA11yController);
 
   // Initialize the wallpaper after the RootWindowController has been created,
   // otherwise the widget will not paint when restoring after a browser crash.
   // Also, initialize after display initialization to ensure correct sizing.
-  wm_shell_->wallpaper_delegate()->InitializeWallpaper();
+  wallpaper_delegate_->InitializeWallpaper();
 
   if (cursor_manager_) {
     if (initially_hide_cursor_)
       cursor_manager_->HideCursor();
     cursor_manager_->SetCursor(ui::kCursorPointer);
   }
 
   power_event_observer_.reset(new PowerEventObserver());
   user_activity_notifier_.reset(
       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
@@ skipping 23 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(
-            wm_shell_->delegate()->CreateKeyboardUI(),
-            virtual_keyboard_controller_.get()));
+        new keyboard::KeyboardController(shell_delegate_->CreateKeyboardUI(),
+                                         virtual_keyboard_controller_.get()));
   }
 }
 
 void Shell::InitRootWindow(aura::Window* root_window) {
   DCHECK(focus_controller_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
 
   aura::client::SetFocusClient(root_window, focus_controller_.get());
   aura::client::SetActivationClient(root_window, focus_controller_.get());
@@ skipping 59 matching lines @@
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   WmWindow* gained_active_wm = WmWindow::Get(gained_active);
   if (gained_active_wm)
     root_window_for_new_windows_ = gained_active_wm->GetRootWindow();
 }
 
 }  // namespace ash