Makes display roots be destroyed by client

services/ui/ws/display.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 "services/ui/ws/display.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 38 matching lines @@
       this);
 
   if (!focus_controller_) {
     focus_controller_->RemoveObserver(this);
     focus_controller_.reset();
   }
 
   for (ServerWindow* window : windows_needing_frame_destruction_)
     window->RemoveObserver(this);
 
-  // If there is a |binding_| then the tree was created specifically for this
-  // display (which corresponds to a WindowTreeHost).
-  if (binding_ && !window_manager_display_root_map_.empty()) {
+  if (!binding_) {
+    for (auto& pair : window_manager_display_root_map_)
+      pair.second->window_manager_state()->OnDisplayDestroying(this);
+  } else if (!window_manager_display_root_map_.empty()) {
+    // If there is a |binding_| then the tree was created specifically for this
+    // display (which corresponds to a WindowTreeHost).
     window_server_->DestroyTree(window_manager_display_root_map_.begin()
                                     ->second->window_manager_state()
                                     ->window_tree());
   }
 }
 
 void Display::Init(std::unique_ptr<DisplayBinding> binding) {
   init_called_ = true;
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
@@ skipping 69 matching lines @@
     if (pair.second->root()->id() == id)
       return pair.second->root();
   }
   return nullptr;
 }
 
 WindowManagerDisplayRoot* Display::GetWindowManagerDisplayRootWithRoot(
     const ServerWindow* window) {
   for (auto& pair : window_manager_display_root_map_) {
     if (pair.second->root() == window)
-      return pair.second.get();
+      return pair.second;
   }
   return nullptr;
 }
 
 const WindowManagerDisplayRoot* Display::GetWindowManagerDisplayRootForUser(
     const UserId& user_id) const {
   auto iter = window_manager_display_root_map_.find(user_id);
   return iter == window_manager_display_root_map_.end() ? nullptr
-                                                        : iter->second.get();
+                                                        : iter->second;
 }
 
 const WindowManagerDisplayRoot* Display::GetActiveWindowManagerDisplayRoot()
     const {
   return GetWindowManagerDisplayRootForUser(
       window_server_->user_id_tracker()->active_id());
 }
 
 bool Display::SetFocusedWindow(ServerWindow* new_focused_window) {
   ServerWindow* old_focused_window = focus_controller_->GetFocusedWindow();
@@ skipping 66 matching lines @@
     return;
 
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
     std::unique_ptr<WindowManagerDisplayRoot> display_root_ptr(
         new WindowManagerDisplayRoot(this));
     WindowManagerDisplayRoot* display_root = display_root_ptr.get();
     // For this case we never create additional displays roots, so any
     // id works.
     window_manager_display_root_map_[shell::mojom::kRootUserID] =
-        std::move(display_root_ptr);
+        display_root_ptr.get();
     WindowTree* window_tree = binding_->CreateWindowTree(display_root->root());
     display_root->window_manager_state_ = window_tree->window_manager_state();
+    window_tree->window_manager_state()->AddWindowManagerDisplayRoot(
+        std::move(display_root_ptr));
   } else {
     CreateWindowManagerDisplayRootsFromFactories();
   }
   display_manager()->OnDisplayUpdate(this);
 }
 
 void Display::CreateWindowManagerDisplayRootsFromFactories() {
   std::vector<WindowManagerWindowTreeFactory*> factories =
       window_server_->window_manager_window_tree_factory_set()->GetFactories();
   for (WindowManagerWindowTreeFactory* factory : factories) {
     if (factory->window_tree())
       CreateWindowManagerDisplayRootFromFactory(factory);
   }
 }
 
 void Display::CreateWindowManagerDisplayRootFromFactory(
     WindowManagerWindowTreeFactory* factory) {
   std::unique_ptr<WindowManagerDisplayRoot> display_root_ptr(
       new WindowManagerDisplayRoot(this));
   WindowManagerDisplayRoot* display_root = display_root_ptr.get();
-  window_manager_display_root_map_[factory->user_id()] =
-      std::move(display_root_ptr);
-  display_root->window_manager_state_ =
+  window_manager_display_root_map_[factory->user_id()] = display_root_ptr.get();
+  WindowManagerState* window_manager_state =
       factory->window_tree()->window_manager_state();
+  display_root->window_manager_state_ = window_manager_state;
   const bool is_active =
       factory->user_id() == window_server_->user_id_tracker()->active_id();
   display_root->root()->SetVisible(is_active);
-  display_root->window_manager_state()->window_tree()->AddRootForWindowManager(
+  window_manager_state->window_tree()->AddRootForWindowManager(
       display_root->root());
+  window_manager_state->AddWindowManagerDisplayRoot(
+      std::move(display_root_ptr));
 }
 
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
 bool Display::IsInHighContrastMode() {
   return window_server_->IsActiveUserInHighContrastMode();
 }
 
@@ skipping 133 matching lines @@
 }
 
 void Display::OnWindowManagerWindowTreeFactoryReady(
     WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
     CreateWindowManagerDisplayRootFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace ui