Changes how window manager obtains WindowTree from mus

components/mus/public/cpp/lib/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 "components/mus/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/input_event_handler.h"
 #include "components/mus/public/cpp/lib/in_flight_change.h"
 #include "components/mus/public/cpp/lib/window_private.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tracker.h"
 #include "components/mus/public/cpp/window_tree_client_delegate.h"
 #include "components/mus/public/cpp/window_tree_client_observer.h"
+#include "components/mus/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "services/shell/public/cpp/connector.h"
+#include "ui/display/mojo/display_type_converters.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace mus {
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
@@ skipping 52 matching lines @@
     mojo::InterfaceRequest<mojom::WindowTreeClient> request)
     : client_id_(0),
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       capture_window_(nullptr),
       focused_window_(nullptr),
       binding_(this),
       tree_(nullptr),
-      delete_on_no_roots_(true),
+      delete_on_no_roots_(!window_manager_delegate),
       in_destructor_(false),
       cursor_location_memory_(nullptr),
       weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
@@ skipping 28 matching lines @@
 void WindowTreeClient::ConnectViaWindowTreeFactory(
     shell::Connector* connector) {
   // Clients created with no root shouldn't delete automatically.
   delete_on_no_roots_ = false;
 
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("mojo:mus", &factory);
-  factory->CreateWindowTree(GetProxy(&tree_ptr_),
+  mojom::WindowTreePtr window_tree;
+  factory->CreateWindowTree(GetProxy(&window_tree),
                             binding_.CreateInterfacePtrAndBind());
-  tree_ = tree_ptr_.get();
+  SetWindowTree(std::move(window_tree));
+}
 
-  tree_ptr_->GetCursorLocationMemory(
-      base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
-                 weak_factory_.GetWeakPtr()));
+void WindowTreeClient::ConnectAsWindowManager(shell::Connector* connector) {
+  DCHECK(window_manager_delegate_);
+
+  mojom::WindowManagerWindowTreeFactoryPtr factory;
+  connector->ConnectToInterface("mojo:mus", &factory);
+  mojom::WindowTreePtr window_tree;
+  factory->CreateWindowTree(GetProxy(&window_tree),
+                            binding_.CreateInterfacePtrAndBind());
+  SetWindowTree(std::move(window_tree));
 }
 
 void WindowTreeClient::WaitForEmbed() {
   DCHECK(roots_.empty());
   // OnEmbed() is the first function called.
   binding_.WaitForIncomingMethodCall();
   // TODO(sky): deal with pipe being closed before we get OnEmbed().
 }
 
 void WindowTreeClient::DestroyWindow(Window* window) {
@@ skipping 331 matching lines @@
     tree_->NewWindow(change_id, server_id(window),
                      std::move(transport_properties));
   } else {
     roots_.insert(window);
     tree_->NewTopLevelWindow(change_id, server_id(window),
                              std::move(transport_properties));
   }
   return window;
 }
 
+void WindowTreeClient::SetWindowTree(mojom::WindowTreePtr window_tree_ptr) {
+  tree_ptr_ = std::move(window_tree_ptr);
+  tree_ = tree_ptr_.get();
+
+  tree_ptr_->GetCursorLocationMemory(
+      base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
+                 weak_factory_.GetWeakPtr()));
+
+  tree_ptr_.set_connection_error_handler(base::Bind(
+      &WindowTreeClient::OnConnectionLost, weak_factory_.GetWeakPtr()));
+
+  if (window_manager_delegate_) {
+    tree_ptr_->GetWindowManagerClient(GetProxy(&window_manager_internal_client_,
+                                               tree_ptr_.associated_group()));
+  }
+}
+
+void WindowTreeClient::OnConnectionLost() {
+  delete this;
+}
+
 void WindowTreeClient::OnEmbedImpl(mojom::WindowTree* window_tree,
                                        ClientSpecificId client_id,
                                        mojom::WindowDataPtr root_data,
                                        int64_t display_id,
                                        Id focused_window_id,
                                        bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   tree_ = window_tree;
   client_id_ = client_id;
 
   DCHECK(roots_.empty());
   Window* root = AddWindowToClient(this, nullptr, root_data);
   WindowPrivate(root).LocalSetDisplay(display_id);
   roots_.insert(root);
 
   focused_window_ = GetWindowByServerId(focused_window_id);
 
   WindowPrivate(root).LocalSetParentDrawn(drawn);
 
   delegate_->OnEmbed(root);
 
   if (focused_window_) {
     FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
                       OnWindowTreeFocusChanged(focused_window_, nullptr));
   }
 }
 
+void WindowTreeClient::WmNewDisplayAddedImpl(const display::Display& display,
+                                             mojom::WindowDataPtr root_data,
+                                             bool parent_drawn) {
+  DCHECK(window_manager_delegate_);
+
+  Window* root = AddWindowToClient(this, nullptr, root_data);
+  WindowPrivate(root).LocalSetDisplay(display.id());
+  WindowPrivate(root).LocalSetParentDrawn(parent_drawn);
+  roots_.insert(root);
+
+  window_manager_delegate_->OnWmNewDisplay(root, display);
+}
+
 void WindowTreeClient::OnReceivedCursorLocationMemory(
     mojo::ScopedSharedBufferHandle handle) {
   cursor_location_handle_ = std::move(handle);
   MojoResult result = mojo::MapBuffer(
       cursor_location_handle_.get(), 0,
       sizeof(base::subtle::Atomic32),
       reinterpret_cast<void**>(&cursor_location_memory_),
       MOJO_MAP_BUFFER_FLAG_NONE);
   if (result != MOJO_RESULT_OK) {
     NOTREACHED();
@@ skipping 451 matching lines @@
 
 void WindowTreeClient::RequestClose(uint32_t window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (!window || !IsRoot(window))
     return;
 
   FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
                     OnRequestClose(window));
 }
 
+void WindowTreeClient::OnConnect(ClientSpecificId client_id) {
+  client_id_ = client_id;
+}
+
+void WindowTreeClient::WmNewDisplayAdded(mojom::DisplayPtr display,
+                                         mojom::WindowDataPtr root_data,
+                                         bool parent_drawn) {
+  WmNewDisplayAddedImpl(display.To<display::Display>(), std::move(root_data),
+                        parent_drawn);
+}
+
 void WindowTreeClient::WmSetBounds(uint32_t change_id,
                                        Id window_id,
                                        const gfx::Rect& transit_bounds) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
     gfx::Rect bounds = transit_bounds;
     result = window_manager_delegate_->OnWmSetBounds(window, &bounds);
     if (result) {
@@ skipping 111 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace mus