Changes ownership of WindowTreeClient

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>
 
@@ skipping 52 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppListPresenterStub);
 };
 
 WindowManager::WindowManager(shell::Connector* connector)
     : connector_(connector) {}
 
 WindowManager::~WindowManager() {
-  // NOTE: |window_tree_client_| may already be null.
-  delete window_tree_client_;
+  Shutdown();
 }
 
-void WindowManager::Init(ui::WindowTreeClient* window_tree_client) {
+void WindowManager::Init(
+    std::unique_ptr<ui::WindowTreeClient> window_tree_client) {
   DCHECK(!window_tree_client_);
-  window_tree_client_ = window_tree_client;
+  window_tree_client_ = std::move(window_tree_client);
 
   pointer_watcher_event_router_.reset(
-      new views::PointerWatcherEventRouter(window_tree_client));
+      new views::PointerWatcherEventRouter(window_tree_client_.get()));
 
-  shadow_controller_.reset(new ShadowController(window_tree_client));
+  shadow_controller_.reset(new ShadowController(window_tree_client_.get()));
 
   // The insets are roughly what is needed by CustomFrameView. The expectation
   // is at some point we'll write our own NonClientFrameView and get the insets
   // from it.
   ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ui::mojom::FrameDecorationValues::New();
   const gfx::Insets client_area_insets =
       NonClientFrameController::GetPreferredClientAreaInsets();
   frame_decoration_values->normal_client_area_insets = client_area_insets;
   frame_decoration_values->maximized_client_area_insets = client_area_insets;
@@ skipping 78 matching lines @@
   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));
   return root_window_controller;
 }
 
+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();
+
+  lookup_.reset();
+  shell_->Shutdown();
+  shell_.reset();
+  shadow_controller_.reset();
+
+  pointer_watcher_event_router_.reset();
+
+  window_tree_client_.reset();
+  window_manager_client_ = nullptr;
+}
+
 void WindowManager::OnWindowDestroying(ui::Window* window) {
   for (auto it = root_window_controllers_.begin();
        it != root_window_controllers_.end(); ++it) {
     if ((*it)->root() == window) {
       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                         OnWillDestroyRootWindowController((*it).get()));
       return;
     }
   }
   NOTREACHED();
 }
 
 void WindowManager::OnWindowDestroyed(ui::Window* window) {
   window->RemoveObserver(this);
   for (auto it = root_window_controllers_.begin();
        it != root_window_controllers_.end(); ++it) {
     if ((*it)->root() == window) {
       root_window_controllers_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
 void WindowManager::OnEmbed(ui::Window* root) {
   // WindowManager should never see this, instead OnWmNewDisplay() is called.
   NOTREACHED();
 }
 
-void WindowManager::OnDidDestroyClient(ui::WindowTreeClient* client) {
-  // Destroying the roots should result in removal from
-  // |root_window_controllers_|.
-  DCHECK(root_window_controllers_.empty());
+void WindowManager::OnEmbedRootDestroyed(ui::Window* root) {
+  // WindowManager should never see this.
+  NOTREACHED();
+}
 
-  // Observers can rely on WmShell from the callback. So notify the observers
-  // before destroying it.
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                    OnWindowTreeClientDestroyed());
-
-  lookup_.reset();
-  shell_->Shutdown();
-  shell_.reset();
-  shadow_controller_.reset();
-
-  pointer_watcher_event_router_.reset();
-
-  window_tree_client_ = nullptr;
-  window_manager_client_ = nullptr;
+void WindowManager::OnLostConnection(ui::WindowTreeClient* client) {
+  DCHECK_EQ(client, window_tree_client_.get());
+  Shutdown();
+  // TODO(sky): this case should trigger shutting down WindowManagerApplication
+  // too.
 }
 
 void WindowManager::OnPointerEventObserved(const ui::PointerEvent& event,
                                            ui::Window* target) {
   pointer_watcher_event_router_->OnPointerEventObserved(event, target);
 }
 
 void WindowManager::SetWindowManagerClient(ui::WindowManagerClient* client) {
   window_manager_client_ = client;
 }
@@ skipping 67 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