Centralizes more shared code between ash and mash

ash/mus/window_manager.cc

 // Copyright 2015 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/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/app_list_presenter_mus.h"
 #include "ash/mus/bridge/wm_lookup_mus.h"
+#include "ash/mus/bridge/wm_root_window_controller_mus.h"
 #include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/window_manager_observer.h"
 #include "ash/public/interfaces/container.mojom.h"
@@ skipping 118 matching lines @@
   if (was_displays_empty) {
     screen_->display_list()->AddDisplay(display,
                                         display::DisplayList::Type::PRIMARY);
   }
 
   std::unique_ptr<RootWindowController> root_window_controller_ptr(
       new RootWindowController(this, window, display));
   RootWindowController* root_window_controller =
       root_window_controller_ptr.get();
   root_window_controllers_.insert(std::move(root_window_controller_ptr));
-  window->AddObserver(this);
 
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnRootWindowControllerAdded(root_window_controller));
 
   if (!was_displays_empty) {
     // If this isn't the initial display then add the display to Screen after
     // creating the RootWindowController. We need to do this after creating the
     // RootWindowController as adding the display triggers OnDisplayAdded(),
     // which triggers some overrides asking for the RootWindowController for the
     // new display.
     screen_->display_list()->AddDisplay(
         display, display::DisplayList::Type::NOT_PRIMARY);
   }
   return root_window_controller;
 }
 
 void WindowManager::DestroyRootWindowController(
     RootWindowController* root_window_controller) {
-  // TODO(sky): WindowManager shouldn't need to observe the windows. Instead
-  // WindowManager should have a specific API that is called when a display is
-  // removed.
+  if (root_window_controllers_.size() > 1) {
+    root_window_controller->wm_root_window_controller()->MoveWindowsTo(
+        WmWindowMus::Get(GetPrimaryRootWindowController()->root()));

[James Cook, 2016/09/21 22:03:19]

DCHECK that the root_window_controller being destroyed is not the primary?

(I'm not sure when the primary window switch happens. However, it is definitely
possible to disconnect the primary display.)

[sky, 2016/09/21 22:47:49]

Done.

+  }
+
   ui::Window* root_window = root_window_controller->root();
   auto it = FindRootWindowControllerByWindow(root_window);
   DCHECK(it != root_window_controllers_.end());
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                    OnWillDestroyRootWindowController((*it).get()));
+
+  (*it)->Shutdown();
+
+  // NOTE: classic ash deleted RootWindowController after a delay (DeleteSoon())
+  // this may need to change to mirror that.
   root_window_controllers_.erase(it);
-  // Remove the observer so we don't see the OnWindowDestroying/Destroyed as we
-  // already handled it here.
-  root_window->RemoveObserver(this);
-  root_window->Destroy();
 }
 
 void WindowManager::Shutdown() {
   if (!window_tree_client_)
     return;
 
   // Observers can rely on WmShell from the callback. So notify the observers
   // before destroying it.
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnWindowTreeClientDestroyed());
 
   // Destroy the roots of the RootWindowControllers, which triggers removal
   // in OnWindowDestroyed().
   while (!root_window_controllers_.empty())
-    (*root_window_controllers_.begin())->root()->Destroy();
+    DestroyRootWindowController(root_window_controllers_.begin()->get());
 
   lookup_.reset();
   shell_->Shutdown();
   shell_.reset();
   shadow_controller_.reset();
 
   pointer_watcher_event_router_.reset();
 
   window_tree_client_.reset();
   window_manager_client_ = nullptr;
 }
 
 WindowManager::RootWindowControllers::iterator
 WindowManager::FindRootWindowControllerByWindow(ui::Window* window) {
   for (auto it = root_window_controllers_.begin();
        it != root_window_controllers_.end(); ++it) {
     if ((*it)->root() == window)
       return it;
   }
   return root_window_controllers_.end();
 }
 
-void WindowManager::OnWindowDestroying(ui::Window* window) {
-  auto it = FindRootWindowControllerByWindow(window);
-  DCHECK(it != root_window_controllers_.end());
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                    OnWillDestroyRootWindowController((*it).get()));
-}
-
-void WindowManager::OnWindowDestroyed(ui::Window* window) {
-  auto it = FindRootWindowControllerByWindow(window);
-  DCHECK(it != root_window_controllers_.end());
-  window->RemoveObserver(this);
-  root_window_controllers_.erase(it);
+RootWindowController* WindowManager::GetPrimaryRootWindowController() {
+  return static_cast<WmRootWindowControllerMus*>(
+             WmShell::Get()->GetPrimaryRootWindowController())
+      ->root_window_controller();
 }
 
 void WindowManager::OnEmbed(ui::Window* root) {
   // WindowManager should never see this, instead OnWmNewDisplay() is called.
   NOTREACHED();
 }
 
 void WindowManager::OnEmbedRootDestroyed(ui::Window* root) {
   // WindowManager should never see this.
   NOTREACHED();
@@ skipping 46 matching lines @@
   for (auto* window : client_windows)
     SetWindowIsJanky(window, janky);
 }
 
 void WindowManager::OnWmNewDisplay(ui::Window* window,
                                    const display::Display& display) {
   CreateRootWindowController(window, display);
 }
 
 void WindowManager::OnWmDisplayRemoved(ui::Window* window) {
-  // TODO(sky): wire up this up correctly.
-  NOTIMPLEMENTED();
+  auto iter = FindRootWindowControllerByWindow(window);
+  DCHECK(iter != root_window_controllers_.end());
+  DestroyRootWindowController(iter->get());
 }
 
 void WindowManager::OnWmPerformMoveLoop(
     ui::Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& on_done) {
   WmWindowMus* child_window = WmWindowMus::Get(window);
   MoveEventHandler* handler = MoveEventHandler::GetForWindow(child_window);
   if (!handler) {
@@ skipping 20 matching lines @@
                                                     const ui::Event& event) {
   auto iter = accelerator_handlers_.find(GetAcceleratorNamespaceId(id));
   if (iter == accelerator_handlers_.end())
     return ui::mojom::EventResult::HANDLED;
 
   return iter->second->OnAccelerator(id, event);
 }
 
 }  // namespace mus
 }  // namespace ash