Wires up transient windows for aura-mus

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>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
+#include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
@@ skipping 118 matching lines @@
       window_manager_delegate_(window_manager_delegate),
       binding_(this),
       tree_(nullptr),
       in_destructor_(false),
       weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   delegate_->GetFocusClient()->AddObserver(this);
   delegate_->GetCaptureClient()->AddObserver(this);
+  client::GetTransientWindowClient()->AddObserver(this);
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
 
@@ skipping 13 matching lines @@
 
   // Delete the non-owned windows last. In the typical case these are roots. The
   // exception is the window manager and embed roots, which may know about
   // other random windows that it doesn't own.
   while (!tracker.windows().empty())
     delete tracker.windows().front();
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnDidDestroyClient(this);
 
+  client::GetTransientWindowClient()->RemoveObserver(this);
+  delegate_->GetCaptureClient()->RemoveObserver(this);
   delegate_->GetFocusClient()->RemoveObserver(this);
-  delegate_->GetCaptureClient()->RemoveObserver(this);
 }
 
 void WindowTreeClient::ConnectViaWindowTreeFactory(
     service_manager::Connector* connector) {
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   ui::mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("service:ui", &factory);
   ui::mojom::WindowTreePtr window_tree;
@@ skipping 880 matching lines @@
   if (window) {
     WindowPrivate(window).LocalSetClientArea(
         new_client_area,
         new_additional_client_areas.To<std::vector<gfx::Rect>>());
   }
   */
 }
 
 void WindowTreeClient::OnTransientWindowAdded(uint32_t window_id,
                                               uint32_t transient_window_id) {
-  // TODO: needs to route to StackingClient.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  Window* transient_window = GetWindowByServerId(transient_window_id);
+  WindowMus* window = GetWindowByServerId(window_id);
+  WindowMus* transient_window = GetWindowByServerId(transient_window_id);
   // window or transient_window or both may be null if a local delete occurs
   // with an in flight add from the server.
   if (window && transient_window)
-    WindowPrivate(window).LocalAddTransientWindow(transient_window);
-  */
+    window->AddTransientChildFromServer(transient_window);
 }
 
 void WindowTreeClient::OnTransientWindowRemoved(uint32_t window_id,
                                                 uint32_t transient_window_id) {
-  // TODO: needs to route to StackingClient.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  Window* transient_window = GetWindowByServerId(transient_window_id);
+  WindowMus* window = GetWindowByServerId(window_id);
+  WindowMus* transient_window = GetWindowByServerId(transient_window_id);
   // window or transient_window or both may be null if a local delete occurs
   // with an in flight delete from the server.
   if (window && transient_window)
-    WindowPrivate(window).LocalRemoveTransientWindow(transient_window);
-  */
+    window->RemoveTransientChildFromServer(transient_window);
 }
 
 void WindowTreeClient::OnWindowHierarchyChanged(
     Id window_id,
     Id old_parent_id,
     Id new_parent_id,
     mojo::Array<ui::mojom::WindowDataPtr> windows) {
   WindowMus* initial_parent =
       windows.size() ? GetWindowByServerId(windows[0]->parent_id) : nullptr;
 
@@ skipping 603 matching lines @@
           window_tree_host->GetDisplay().bounds().OffsetFromOrigin();
       bounds->set_origin(display_relative_origin);
       break;
     }
   }
   // We need the root window to always have an origin of 0x0 locally.
   window_tree_host->set_origin_offset(bounds->OffsetFromOrigin());
   bounds->set_origin(gfx::Point());
 }
 
+void WindowTreeClient::OnTransientChildWindowAdded(Window* parent,
+                                                   Window* transient_child) {
+  if (WindowMus::Get(parent)->OnTransientChildAdded(
+          WindowMus::Get(transient_child)) == WindowMus::ChangeSource::SERVER) {
+    return;
+  }
+  DCHECK(tree_);
+  WindowMus* parent_mus = WindowMus::Get(parent);
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          parent_mus, ChangeType::ADD_TRANSIENT_WINDOW));
+  tree_->AddTransientWindow(change_id, parent_mus->server_id(),
+                            WindowMus::Get(transient_child)->server_id());
+}
+
+void WindowTreeClient::OnTransientChildWindowRemoved(Window* parent,
+                                                     Window* transient_child) {
+  if (WindowMus::Get(parent)->OnTransientChildRemoved(
+          WindowMus::Get(transient_child)) == WindowMus::ChangeSource::SERVER) {
+    return;
+  }
+  DCHECK(tree_);
+  WindowMus* child_mus = WindowMus::Get(transient_child);
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          child_mus, ChangeType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT));
+  tree_->RemoveTransientWindowFromParent(change_id, child_mus->server_id());
+}
+
 }  // namespace aura