Makes WindowTree::DeleteWindow() unembed for roots

services/ui/ws/window_tree.cc

 // Copyright 2014 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/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 184 matching lines @@
 
   window_manager_internal_->WmNewDisplayAdded(display->ToDisplay(),
                                               WindowToWindowData(root),
                                               root->parent()->IsDrawn());
 }
 
 void WindowTree::OnWindowDestroyingTreeImpl(WindowTree* tree) {
   if (event_source_wms_ && event_source_wms_->window_tree() == tree)
     event_source_wms_ = nullptr;
 
-  // Notify our client if |tree| was embedded in any of our views.
+  // Notify our client if |tree| was embedded in any of our windows.
   for (const auto* tree_root : tree->roots_) {
     const bool owns_tree_root = tree_root->id().client_id == id_;
     if (owns_tree_root) {
       client()->OnEmbeddedAppDisconnected(
           ClientWindowIdForWindow(tree_root).id);
     }
   }
 }
 
 void WindowTree::NotifyChangeCompleted(
@@ skipping 382 matching lines @@
   // doesn't know about the ancestors of the roots, and so can't do anything
   // about this ordering change of the root.
   if (HasRoot(window) || HasRoot(relative_window))
     return;
 
   client()->OnWindowReordered(client_window_id.id, relative_client_window_id.id,
                               direction);
   window_server_->OnTreeMessagedClient(id_);
 }
 
-void WindowTree::ProcessWindowDeleted(const ServerWindow* window,
+void WindowTree::ProcessWindowDeleted(ServerWindow* window,
                                       bool originated_change) {
   if (window->id().client_id == id_)
     created_window_map_.erase(window->id());
 
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id))
     return;
 
   if (HasRoot(window))
     RemoveRoot(window, RemoveRootReason::DELETED);
@@ skipping 261 matching lines @@
     return;
   }
 
   RemoveFromMaps(window);
 
   const ServerWindow::Windows& children = window->children();
   for (ServerWindow* child : children)
     RemoveFromKnown(child, local_windows);
 }
 
-void WindowTree::RemoveRoot(const ServerWindow* window,
-                            RemoveRootReason reason) {
+void WindowTree::RemoveRoot(ServerWindow* window, RemoveRootReason reason) {
   DCHECK(roots_.count(window) > 0);
   roots_.erase(window);
 
   const ClientWindowId client_window_id(ClientWindowIdForWindow(window));
 
   // No need to do anything if we created the window.
   if (window->id().client_id == id_)
     return;
 
   if (reason == RemoveRootReason::EMBED) {
     client()->OnUnembed(client_window_id.id);
     client()->OnWindowDeleted(client_window_id.id);
     window_server_->OnTreeMessagedClient(id_);
   }
 
   // This client no longer knows about the window. Unparent any windows that
   // were parented to windows in the root.
   std::vector<ServerWindow*> local_windows;
   RemoveFromKnown(window, &local_windows);
   for (size_t i = 0; i < local_windows.size(); ++i)
     local_windows[i]->parent()->Remove(local_windows[i]);
+
+  if (reason == RemoveRootReason::UNEMBED) {
+    window->OnEmbeddedAppDisconnected();
+
+    // Notify the owner of the window it no longer has a client embedded in it.
+    WindowTree* owning_tree =
+        window_server_->GetTreeWithId(window->id().client_id);
+    DCHECK(owning_tree && owning_tree != this);
+    owning_tree->client()->OnEmbeddedAppDisconnected(
+        owning_tree->ClientWindowIdForWindow(window).id);
+  }
 }
 
 Array<mojom::WindowDataPtr> WindowTree::WindowsToWindowDatas(
     const std::vector<const ServerWindow*>& windows) {
   Array<mojom::WindowDataPtr> array(windows.size());
   for (size_t i = 0; i < windows.size(); ++i)
     array[i] = WindowToWindowData(windows[i]);
   return array;
 }
 
@@ skipping 183 matching lines @@
   display_root->window_manager_state()
       ->window_tree()
       ->window_manager_internal_->WmCreateTopLevelWindow(
           wm_change_id, id_, std::move(transport_properties));
 }
 
 void WindowTree::DeleteWindow(uint32_t change_id, Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   bool success = false;
-  bool should_close = window && (access_policy_->CanDeleteWindow(window) ||
-                                 ShouldRouteToWindowManager(window));
-  if (should_close) {
-    WindowTree* tree =
-        window_server_->GetTreeWithId(window->id().client_id);
-    success = tree && tree->DeleteWindowImpl(this, window);
+  if (window && roots_.count(window) > 0) {
+    success = true;
+    window_server_->OnTreeMessagedClient(id_);
+    RemoveRoot(window, RemoveRootReason::UNEMBED);
+  } else {
+    bool should_close = window && (access_policy_->CanDeleteWindow(window) ||
+                                   ShouldRouteToWindowManager(window));
+    if (should_close) {
+      WindowTree* tree = window_server_->GetTreeWithId(window->id().client_id);
+      success = tree && tree->DeleteWindowImpl(this, window);
+    }
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::AddWindow(uint32_t change_id, Id parent_id, Id child_id) {
   client()->OnChangeCompleted(change_id, AddWindow(ClientWindowId(parent_id),
                                                    ClientWindowId(child_id)));
 }
 
 void WindowTree::RemoveWindowFromParent(uint32_t change_id, Id window_id) {
@@ skipping 701 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui