Converts WindowTreeClientTest to be in terms of aura

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 246 matching lines @@
   DCHECK(tree_);
   tree_->SetImeVisibility(window->server_id(), visible, std::move(state));
 }
 
 void WindowTreeClient::Embed(
     Window* window,
     ui::mojom::WindowTreeClientPtr client,
     uint32_t flags,
     const ui::mojom::WindowTree::EmbedCallback& callback) {
   DCHECK(tree_);
+  if (!window->children().empty()) {
+    // The window server removes all children before embedding. In other words,
+    // it's generally an error to Embed() with existing children. So, fail
+    // early.
+    callback.Run(false);
+    return;
+  }
+
   tree_->Embed(WindowMus::Get(window)->server_id(), std::move(client), flags,
                callback);
 }
 
 void WindowTreeClient::AttachCompositorFrameSink(
     Id window_id,
     ui::mojom::CompositorFrameSinkType type,
     cc::mojom::MojoCompositorFrameSinkRequest compositor_frame_sink,
     cc::mojom::MojoCompositorFrameSinkClientPtr client) {
   DCHECK(tree_);
@@ skipping 311 matching lines @@
 
   // Remove any InFlightChanges associated with the window.
   std::set<uint32_t> in_flight_change_ids_to_remove;
   for (const auto& pair : in_flight_map_) {
     if (pair.second->window() == window)
       in_flight_change_ids_to_remove.insert(pair.first);
   }
   for (auto change_id : in_flight_change_ids_to_remove)
     in_flight_map_.erase(change_id);
 
-  const bool was_root = roots_.erase(window) > 0;
-  if (!in_destructor_ && was_root && roots_.empty() && is_from_embed_)
-    delegate_->OnEmbedRootDestroyed(window->GetWindow());
+  roots_.erase(window);
 }
 
 void WindowTreeClient::OnWindowMusBoundsChanged(WindowMus* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
   // Changes to bounds of root windows are routed through
   // OnWindowTreeHostBoundsWillChange(). Any bounds that happen here are a side
   // effect of those and can be ignored.
   if (IsRoot(window))
     return;
@@ skipping 383 matching lines @@
   WindowMus* relative_window = GetWindowByServerId(relative_window_id);
   WindowMus* parent = WindowMus::Get(window->GetWindow()->parent());
   if (window && relative_window && parent &&
       parent == WindowMus::Get(relative_window->GetWindow()->parent())) {
     parent->ReorderFromServer(window, relative_window, direction);
   }
 }
 
 void WindowTreeClient::OnWindowDeleted(Id window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
-  if (window)
+  if (!window)
+    return;
+
+  if (roots_.count(window)) {
+    // Roots are associated with WindowTreeHosts. The WindowTreeHost owns the
+    // root, so we have to delete the WindowTreeHost to indirectly delete the
+    // Window. Additionally clients may want to do extra processing before the
+    // delete, so call to the delegate to handle it. Let the window know it is
+    // going to be deleted so we don't callback to the server.
+    window->PrepareForDestroy();
+    delegate_->OnEmbedRootDestroyed(GetWindowTreeHostMus(window));
+  } else {
     window->DestroyFromServer();
+  }
 }
 
 void WindowTreeClient::OnWindowVisibilityChanged(Id window_id, bool visible) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightVisibleChange new_change(this, window, visible);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
@@ skipping 605 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura