Converts mash to use Shell

ash/mus/bridge/wm_shell_mus.cc

 // Copyright 2016 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/mus/bridge/wm_shell_mus.h"
 
 #include <utility>
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/key_event_watcher.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_event_handler.h"
 #include "ash/common/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_cycle_event_filter.h"
 #include "ash/common/wm/window_resizer.h"
-#include "ash/common/wm_activation_observer.h"
 #include "ash/common/wm_window.h"
 #include "ash/mus/accelerators/accelerator_controller_delegate_mus.h"
 #include "ash/mus/accelerators/accelerator_controller_registrar.h"
 #include "ash/mus/bridge/immersive_handler_factory_mus.h"
 #include "ash/mus/bridge/workspace_event_handler_mus.h"
 #include "ash/mus/drag_window_resizer.h"
 #include "ash/mus/keyboard_ui_mus.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/window_manager.h"
+#include "ash/root_window_settings.h"
 #include "ash/shared/immersive_fullscreen_controller.h"
+#include "ash/shell.h"
+#include "ash/shell_init_params.h"
+#include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "components/user_manager/user_info_impl.h"
 #include "ui/aura/mus/window_tree_client.h"
+#include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/window.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/focus_controller.h"
 
 namespace ash {
 namespace mus {
 
@@ skipping 53 matching lines @@
 
   // A pseudo user info.
   std::unique_ptr<user_manager::UserInfo> user_info_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionStateDelegateStub);
 };
 
 }  // namespace
 
 WmShellMus::WmShellMus(
+    WmWindow* primary_root_window,
     std::unique_ptr<ShellDelegate> shell_delegate,
     WindowManager* window_manager,
     views::PointerWatcherEventRouter* pointer_watcher_event_router)
     : WmShell(std::move(shell_delegate)),
       window_manager_(window_manager),
+      primary_root_window_(primary_root_window),
       pointer_watcher_event_router_(pointer_watcher_event_router),
       session_state_delegate_(new SessionStateDelegateStub) {
+  DCHECK(primary_root_window_);
   WmShell::Set(this);
 
   uint16_t accelerator_namespace_id = 0u;
   const bool add_result =
       window_manager->GetNextAcceleratorNamespaceId(&accelerator_namespace_id);
   // WmShellMus is created early on, so that this should always succeed.
   DCHECK(add_result);
   accelerator_controller_delegate_.reset(
       new AcceleratorControllerDelegateMus(window_manager_));
   accelerator_controller_registrar_.reset(new AcceleratorControllerRegistrar(
       window_manager_, accelerator_namespace_id));
   SetAcceleratorController(base::MakeUnique<AcceleratorController>(
       accelerator_controller_delegate_.get(),
       accelerator_controller_registrar_.get()));
   immersive_handler_factory_.reset(new ImmersiveHandlerFactoryMus);
 
-  CreateMaximizeModeController();
-
-  CreateMruWindowTracker();
-
-  SetSystemTrayDelegate(
-      base::WrapUnique(delegate()->CreateSystemTrayDelegate()));
-
   SetKeyboardUI(KeyboardUIMus::Create(window_manager_->connector()));
-
-  wallpaper_delegate()->InitializeWallpaper();
-
-  window_manager->activation_client()->AddObserver(this);
 }
 
 WmShellMus::~WmShellMus() {
-  window_manager_->activation_client()->RemoveObserver(this);
-
-  // This order mirrors that of Shell.
-
-  // Destroy maximize mode controller early on since it has some observers which
-  // need to be removed.
-  DeleteMaximizeModeController();
-  DeleteToastManager();
-  DeleteSystemTrayDelegate();
-  // Has to happen before ~MruWindowTracker.
-  DeleteWindowCycleController();
-  DeleteWindowSelectorController();
-  DeleteMruWindowTracker();
   WmShell::Set(nullptr);
 }
 
 // static
 WmShellMus* WmShellMus::Get() {
   return static_cast<WmShellMus*>(WmShell::Get());
 }
 
-void WmShellMus::AddRootWindowController(RootWindowController* controller) {
-  root_window_controllers_.push_back(controller);
-  // The first root window will be the initial root for new windows.
-  if (!GetRootWindowForNewWindows())
-    set_root_window_for_new_windows(WmWindow::Get(controller->root()));
-}
-
-void WmShellMus::RemoveRootWindowController(RootWindowController* controller) {
-  auto iter = std::find(root_window_controllers_.begin(),
-                        root_window_controllers_.end(), controller);
-  DCHECK(iter != root_window_controllers_.end());
-  root_window_controllers_.erase(iter);
-}
-
 RootWindowController* WmShellMus::GetRootWindowControllerWithDisplayId(
     int64_t id) {
-  for (RootWindowController* root_window_controller :
-       root_window_controllers_) {
-    if (root_window_controller->display().id() == id)
-      return root_window_controller;
+  for (ash::RootWindowController* root_window_controller :
+       ash::RootWindowController::root_window_controllers()) {
+    RootWindowSettings* settings =
+        GetRootWindowSettings(root_window_controller->GetRootWindow());
+    DCHECK(settings);
+    if (settings->display_id == id) {
+      return RootWindowController::ForWindow(
+          root_window_controller->GetRootWindow());
+    }
   }
   NOTREACHED();
   return nullptr;
 }
 
 aura::WindowTreeClient* WmShellMus::window_tree_client() {
   return window_manager_->window_tree_client();
 }
 
+void WmShellMus::Initialize(
+    const scoped_refptr<base::SequencedWorkerPool>& pool) {
+  WmShell::Initialize(pool);
+}
+
+void WmShellMus::Shutdown() {
+  WmShell::Shutdown();
+
+  window_manager_->DeleteAllRootWindowControllers();
+}
+
 bool WmShellMus::IsRunningInMash() const {
   return true;
 }
 
 WmWindow* WmShellMus::NewWindow(ui::wm::WindowType window_type,
                                 ui::LayerType layer_type) {
   aura::Window* window = new aura::Window(nullptr);
   window->SetType(window_type);
   window->Init(layer_type);
   return WmWindow::Get(window);
 }
 
 WmWindow* WmShellMus::GetFocusedWindow() {
   // TODO: remove as both WmShells use same implementation.
-  return WmWindow::Get(static_cast<aura::client::FocusClient*>(
-                           window_manager_->focus_controller())
-                           ->GetFocusedWindow());
+  return WmWindow::Get(
+      aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())
+          ->GetFocusedWindow());
 }
 
 WmWindow* WmShellMus::GetActiveWindow() {
   // TODO: remove as both WmShells use same implementation.
-  return WmWindow::Get(static_cast<aura::client::ActivationClient*>(
-                           window_manager_->focus_controller())
-                           ->GetActiveWindow());
+  return WmWindow::Get(wm::GetActiveWindow());
 }
 
 WmWindow* WmShellMus::GetCaptureWindow() {
   // TODO: remove as both WmShells use same implementation.
   return WmWindow::Get(::wm::CaptureController::Get()->GetCaptureWindow());
 }
 
 WmWindow* WmShellMus::GetPrimaryRootWindow() {
-  return WmWindow::Get(root_window_controllers_[0]->root());
+  // NOTE: This is called before the RootWindowController has been created, so
+  // it can't call through to RootWindowController to get all windows.
+  return primary_root_window_;
 }
 
 WmWindow* WmShellMus::GetRootWindowForDisplayId(int64_t display_id) {
   return WmWindow::Get(
       GetRootWindowControllerWithDisplayId(display_id)->root());
 }
 
 const display::ManagedDisplayInfo& WmShellMus::GetDisplayInfo(
     int64_t display_id) const {
   // TODO(mash): implement http://crbug.com/622480.
@@ skipping 57 matching lines @@
   NOTIMPLEMENTED();
 }
 
 bool WmShellMus::IsMouseEventsEnabled() {
   // TODO: http::/crbug.com/637853
   NOTIMPLEMENTED();
   return true;
 }
 
 std::vector<WmWindow*> WmShellMus::GetAllRootWindows() {
-  std::vector<WmWindow*> wm_windows(root_window_controllers_.size());
-  for (size_t i = 0; i < root_window_controllers_.size(); ++i)
-    wm_windows[i] = WmWindow::Get(root_window_controllers_[i]->root());
-  return wm_windows;
+  std::vector<WmWindow*> root_windows;
+  for (ash::RootWindowController* root_window_controller :
+       ash::RootWindowController::root_window_controllers()) {
+    root_windows.push_back(root_window_controller->GetWindow());
+  }
+  return root_windows;
 }
 
 void WmShellMus::RecordGestureAction(GestureActionType action) {
   // TODO: http://crbug.com/616581.
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::RecordUserMetricsAction(UserMetricsAction action) {
   // TODO: http://crbug.com/616581.
   NOTIMPLEMENTED();
@@ skipping 56 matching lines @@
 
 void WmShellMus::OnOverviewModeEnded() {
   for (auto& observer : *shell_observers())
     observer.OnOverviewModeEnded();
 }
 
 SessionStateDelegate* WmShellMus::GetSessionStateDelegate() {
   return session_state_delegate_.get();
 }
 
-void WmShellMus::AddActivationObserver(WmActivationObserver* observer) {
-  activation_observers_.AddObserver(observer);
-}
-
-void WmShellMus::RemoveActivationObserver(WmActivationObserver* observer) {
-  activation_observers_.RemoveObserver(observer);
-}
-
 void WmShellMus::AddDisplayObserver(WmDisplayObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::RemoveDisplayObserver(WmDisplayObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::AddPointerWatcher(views::PointerWatcher* watcher,
                                    views::PointerWatcherEventTypes events) {
@@ skipping 18 matching lines @@
 }
 
 void WmShellMus::ToggleIgnoreExternalKeyboard() {
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::SetLaserPointerEnabled(bool enabled) {
   NOTIMPLEMENTED();
 }
 
-// TODO: support OnAttemptToReactivateWindow, http://crbug.com/615114.
-// TODO: Nuke and let client code use ActivationChangeObserver directly.
-void WmShellMus::OnWindowActivated(ActivationReason reason,
-                                   aura::Window* gained_active,
-                                   aura::Window* lost_active) {
-  WmWindow* gained_active_wm = WmWindow::Get(gained_active);
-  if (gained_active_wm)
-    set_root_window_for_new_windows(gained_active_wm->GetRootWindow());
-  WmWindow* lost_active_wm = WmWindow::Get(lost_active);
-  for (auto& observer : activation_observers_)
-    observer.OnWindowActivated(gained_active_wm, lost_active_wm);
+void WmShellMus::CreatePointerWatcherAdapter() {
+  // Only needed in WmShellAura, which has specific creation order.
 }
 
+void WmShellMus::CreatePrimaryHost() {}
+
+void WmShellMus::InitHosts(const ShellInitParams& init_params) {
+  window_manager_->CreatePrimaryRootWindowController(
+      base::WrapUnique(init_params.primary_window_tree_host));
+}
 }  // namespace mus
 }  // namespace ash