Converts ash to use aura-mus

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"
@@ skipping 15 matching lines @@
 #include "ash/mus/bridge/wm_window_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/public/cpp/shell_window_ids.h"
 #include "ash/shared/immersive_fullscreen_controller.h"
 #include "base/memory/ptr_util.h"
 #include "components/user_manager/user_info_impl.h"
-#include "services/ui/common/util.h"
-#include "services/ui/public/cpp/window.h"
-#include "services/ui/public/cpp/window_tree_client.h"
+#include "ui/aura/mus/window_tree_client.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/views/mus/pointer_watcher_event_router2.h"
+#include "ui/wm/core/capture_controller.h"
+#include "ui/wm/core/focus_controller.h"
 
 namespace ash {
 namespace mus {
 
 namespace {
 
 // TODO(jamescook): After ShellDelegate is ported to ash/common use
 // ShellDelegate::CreateSessionStateDelegate() to construct the mus version
 // of SessionStateDelegate.
 class SessionStateDelegateStub : public SessionStateDelegate {
@@ skipping 52 matching lines @@
   std::unique_ptr<user_manager::UserInfo> user_info_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionStateDelegateStub);
 };
 
 }  // namespace
 
 WmShellMus::WmShellMus(
     std::unique_ptr<ShellDelegate> shell_delegate,
     WindowManager* window_manager,
-    views::PointerWatcherEventRouter* pointer_watcher_event_router)
+    views::PointerWatcherEventRouter2* pointer_watcher_event_router)
     : WmShell(std::move(shell_delegate)),
       window_manager_(window_manager),
       pointer_watcher_event_router_(pointer_watcher_event_router),
       session_state_delegate_(new SessionStateDelegateStub) {
-  window_tree_client()->AddObserver(this);
   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(
@@ skipping 20 matching lines @@
 
   // 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();
-  if (window_tree_client())
-    window_tree_client()->RemoveObserver(this);
   WmShell::Set(nullptr);
 }
 
 // static
 WmShellMus* WmShellMus::Get() {
   return static_cast<WmShellMus*>(WmShell::Get());
 }
 
 void WmShellMus::AddRootWindowController(
     WmRootWindowControllerMus* 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(controller->GetWindow());
 }
 
 void WmShellMus::RemoveRootWindowController(
     WmRootWindowControllerMus* 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);
 }
 
 // static
-WmWindowMus* WmShellMus::GetToplevelAncestor(ui::Window* window) {
+WmWindowMus* WmShellMus::GetToplevelAncestor(aura::Window* window) {
   while (window) {
     if (IsActivationParent(window->parent()))
       return WmWindowMus::Get(window);
     window = window->parent();
   }
   return nullptr;
 }
 
 WmRootWindowControllerMus* WmShellMus::GetRootWindowControllerWithDisplayId(
     int64_t id) {
   for (WmRootWindowControllerMus* root_window_controller :
        root_window_controllers_) {
     if (root_window_controller->GetDisplay().id() == id)
       return root_window_controller;
   }
   NOTREACHED();
   return nullptr;
 }
 
+aura::WindowTreeClient* WmShellMus::window_tree_client() {
+  return window_manager_->window_tree_client();
+}
+
 bool WmShellMus::IsRunningInMash() const {
   return true;
 }
 
 WmWindow* WmShellMus::NewWindow(ui::wm::WindowType window_type,
                                 ui::LayerType layer_type) {
-  WmWindowMus* window = WmWindowMus::Get(window_tree_client()->NewWindow());
-  window->set_wm_window_type(window_type);
-  // TODO(sky): support layer_type.
-  NOTIMPLEMENTED();
-  return window;
+  aura::Window* window = new aura::Window(nullptr);
+  window->SetType(window_type);
+  window->Init(layer_type);
+  return WmWindowMus::Get(window);
 }
 
 WmWindow* WmShellMus::GetFocusedWindow() {
-  return WmWindowMus::Get(window_tree_client()->GetFocusedWindow());
+  // TODO: remove as both WmShells use same implementation.
+  return WmWindowMus::Get(static_cast<aura::client::FocusClient*>(
+                              window_manager_->focus_controller())
+                              ->GetFocusedWindow());
 }
 
 WmWindow* WmShellMus::GetActiveWindow() {
-  return GetToplevelAncestor(window_tree_client()->GetFocusedWindow());
+  // TODO: remove as both WmShells use same implementation.
+  return WmWindowMus::Get(static_cast<aura::client::ActivationClient*>(
+                              window_manager_->focus_controller())
+                              ->GetActiveWindow());
 }
 
 WmWindow* WmShellMus::GetCaptureWindow() {
-  return WmWindowMus::Get(window_tree_client()->GetCaptureWindow());
+  // TODO: remove as both WmShells use same implementation.
+  return WmWindowMus::Get(::wm::CaptureController::Get()->GetCaptureWindow());
 }
 
 WmWindow* WmShellMus::GetPrimaryRootWindow() {
   return root_window_controllers_[0]->GetWindow();
 }
 
 WmWindow* WmShellMus::GetRootWindowForDisplayId(int64_t display_id) {
   return GetRootWindowControllerWithDisplayId(display_id)->GetWindow();
 }
 
@@ skipping 29 matching lines @@
   return false;
 }
 
 bool WmShellMus::IsForceMaximizeOnFirstRun() {
   NOTIMPLEMENTED();
   return false;
 }
 
 void WmShellMus::SetDisplayWorkAreaInsets(WmWindow* window,
                                           const gfx::Insets& insets) {
-  RootWindowController* root_window_controller =
-      GetRootWindowControllerWithDisplayId(
-          WmWindowMus::GetMusWindow(window)->display_id())
-          ->root_window_controller();
-  root_window_controller->SetWorkAreaInests(insets);
+  WmRootWindowControllerMus* root_window_controller_mus =
+      static_cast<WmWindowMus*>(window)->GetRootWindowControllerMus();
+  if (!root_window_controller_mus)

[James Cook, 2016/12/05 19:21:44]

Q: How could this be null when root_window_controller wasn't null in the old
code? How does a window not have a RWC?

[sky, 2016/12/05 21:39:19]

You are right. Fixed.

+    return;
+  root_window_controller_mus->root_window_controller()->SetWorkAreaInests(
+      insets);
 }
 
 bool WmShellMus::IsPinned() {
   NOTIMPLEMENTED();
   return false;
 }
 
 void WmShellMus::SetPinnedWindow(WmWindow* window) {
   NOTIMPLEMENTED();
 }
@@ skipping 60 matching lines @@
 std::unique_ptr<ScopedDisableInternalMouseAndKeyboard>
 WmShellMus::CreateScopedDisableInternalMouseAndKeyboard() {
   // TODO: needs implementation for mus, http://crbug.com/624967.
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 std::unique_ptr<WorkspaceEventHandler> WmShellMus::CreateWorkspaceEventHandler(
     WmWindow* workspace_window) {
   return base::MakeUnique<WorkspaceEventHandlerMus>(
-      WmWindowMus::GetMusWindow(workspace_window));
+      WmWindowMus::GetAuraWindow(workspace_window));
 }
 
 std::unique_ptr<ImmersiveFullscreenController>
 WmShellMus::CreateImmersiveFullscreenController() {
   return base::MakeUnique<ImmersiveFullscreenController>();
 }
 
 std::unique_ptr<KeyEventWatcher> WmShellMus::CreateKeyEventWatcher() {
   // TODO: needs implementation for mus, http://crbug.com/649600.
   NOTIMPLEMENTED();
@@ skipping 55 matching lines @@
 #if defined(OS_CHROMEOS)
 void WmShellMus::ToggleIgnoreExternalKeyboard() {
   NOTIMPLEMENTED();
 }
 
 void WmShellMus::SetLaserPointerEnabled(bool enabled) {
   NOTIMPLEMENTED();
 }
 #endif  // defined(OS_CHROMEOS)
 
-ui::WindowTreeClient* WmShellMus::window_tree_client() {
-  return window_manager_->window_tree_client();
-}
-
 // static
-bool WmShellMus::IsActivationParent(ui::Window* window) {
+bool WmShellMus::IsActivationParent(aura::Window* window) {
   return window && IsActivatableShellWindowId(
                        WmWindowMus::Get(window)->GetShellWindowId());
 }
 
 // TODO: support OnAttemptToReactivateWindow, http://crbug.com/615114.
-void WmShellMus::OnWindowTreeFocusChanged(ui::Window* gained_focus,
-                                          ui::Window* lost_focus) {
-  WmWindow* gained_active = GetToplevelAncestor(gained_focus);
-  if (gained_active)
-    set_root_window_for_new_windows(gained_active->GetRootWindow());
-
-  WmWindow* lost_active = GetToplevelAncestor(lost_focus);
-  if (gained_active == lost_active)
-    return;
-
+// 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 = WmWindowMus::Get(gained_active);
+  if (gained_active_wm)
+    set_root_window_for_new_windows(gained_active_wm->GetRootWindow());
+  WmWindow* lost_active_wm = WmWindowMus::Get(lost_active);
   for (auto& observer : activation_observers_)
-    observer.OnWindowActivated(gained_active, lost_active);
-}
-
-void WmShellMus::OnDidDestroyClient(ui::WindowTreeClient* client) {
-  DCHECK_EQ(window_tree_client(), client);
-  client->RemoveObserver(this);
+    observer.OnWindowActivated(gained_active_wm, lost_active_wm);
 }
 
 }  // namespace mus
 }  // namespace ash