Changes how window manager obtains WindowTree from mus

components/mus/ws/window_server.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/ws/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "components/mus/public/cpp/surfaces/surfaces_type_converters.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_manager_access_policy.h"
-#include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
+#include "components/mus/ws/window_manager_window_tree_factory.h"
 #include "components/mus/ws/window_server_delegate.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "services/shell/public/cpp/connection.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace mus {
 namespace ws {
 
 WindowServer::WindowServer(
     WindowServerDelegate* delegate,
     const scoped_refptr<mus::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_client_id_(1),
       display_manager_(new DisplayManager(this)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
-      window_manager_factory_registry_(this, &user_id_tracker_) {}
+      window_manager_window_tree_factory_set_(this, &user_id_tracker_) {}
 
 WindowServer::~WindowServer() {
   in_destructor_ = true;
 
   // Destroys the window trees results in querying for the display. Tear down
   // the displays first so that the trees are notified of the display going
   // away while the display is still valid.
   display_manager_->DestroyAllDisplays();
 
   while (!tree_map_.empty())
@@ skipping 34 matching lines @@
   if (!binding) {
     binding.reset(new ws::DefaultWindowTreeBinding(
         tree, this, std::move(window_tree_request), std::move(client)));
   }
 
   AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
   OnTreeMessagedClient(tree->id());
   return tree;
 }
 
-WindowTree* WindowServer::AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
-                                  std::unique_ptr<WindowTreeBinding> binding,
-                                  mojom::WindowTreePtr tree_ptr) {
+void WindowServer::AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
+                           std::unique_ptr<WindowTreeBinding> binding,
+                           mojom::WindowTreePtr tree_ptr) {
   CHECK_EQ(0u, tree_map_.count(tree_impl_ptr->id()));
   WindowTree* tree = tree_impl_ptr.get();
   tree_map_[tree->id()] = std::move(tree_impl_ptr);
   tree->Init(std::move(binding), std::move(tree_ptr));
-  return tree;
 }
 
 WindowTree* WindowServer::CreateTreeForWindowManager(
-    Display* display,
-    mojom::WindowManagerFactory* factory,
-    ServerWindow* root,
-    const UserId& user_id) {
-  mojom::DisplayPtr display_ptr = display->ToMojomDisplay();
-  mojom::WindowTreeClientPtr tree_client;
-  factory->CreateWindowManager(std::move(display_ptr), GetProxy(&tree_client));
-  std::unique_ptr<WindowTree> tree_ptr(new WindowTree(
-      this, user_id, root, base::WrapUnique(new WindowManagerAccessPolicy)));
-  WindowTree* tree = tree_ptr.get();
-  mojom::WindowTreePtr window_tree_ptr;
-  mojom::WindowTreeRequest tree_request;
-  std::unique_ptr<WindowTreeBinding> binding =
+    const UserId& user_id,
+    mojom::WindowTreeRequest window_tree_request,
+    mojom::WindowTreeClientPtr window_tree_client) {
+  std::unique_ptr<WindowTree> window_tree(new WindowTree(
+      this, user_id, nullptr, base::WrapUnique(new WindowManagerAccessPolicy)));
+  std::unique_ptr<WindowTreeBinding> window_tree_binding =
       delegate_->CreateWindowTreeBinding(
-          WindowServerDelegate::BindingType::WINDOW_MANAGER, this, tree,
-          &tree_request, &tree_client);
-  if (!binding) {
-    DefaultWindowTreeBinding* default_binding =
-        new DefaultWindowTreeBinding(tree_ptr.get(), std::move(tree_client));
-    binding.reset(default_binding);
-    window_tree_ptr = default_binding->CreateInterfacePtrAndBind();
+          WindowServerDelegate::BindingType::WINDOW_MANAGER, this,
+          window_tree.get(), &window_tree_request, &window_tree_client);
+  if (!window_tree_binding) {
+    window_tree_binding.reset(new DefaultWindowTreeBinding(
+        window_tree.get(), this, std::move(window_tree_request),
+        std::move(window_tree_client)));
   }
-  AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
-  tree->ConfigureWindowManager();
-  return tree;
+  WindowTree* window_tree_ptr = window_tree.get();
+  AddTree(std::move(window_tree), std::move(window_tree_binding), nullptr);
+  window_tree_ptr->ConfigureWindowManager();
+  return window_tree_ptr;
 }
 
 void WindowServer::DestroyTree(WindowTree* tree) {
   std::unique_ptr<WindowTree> tree_ptr;
   {
     auto iter = tree_map_.find(tree->id());
     DCHECK(iter != tree_map_.end());
     tree_ptr = std::move(iter->second);
     tree_map_.erase(iter);
   }
 
   // Notify remaining connections so that they can cleanup.
   for (auto& pair : tree_map_)
     pair.second->OnWindowDestroyingTreeImpl(tree);
 
   // Notify the hosts, taking care to only notify each host once.
   std::set<Display*> displays_notified;
   for (auto* root : tree->roots()) {
     // WindowTree holds its roots as a const, which is right as WindowTree
     // doesn't need to modify the window. OTOH we do. We could look up the
     // window using the id to get non-const version, but instead we cast.
     Display* display =
         display_manager_->GetDisplayContaining(const_cast<ServerWindow*>(root));
     if (display && displays_notified.count(display) == 0) {
       display->OnWillDestroyTree(tree);
       displays_notified.insert(display);
     }
   }
 
+  window_manager_window_tree_factory_set_.DeleteFactoryAssociatedWithTree(tree);
+
   // Remove any requests from the client that resulted in a call to the window
   // manager and we haven't gotten a response back yet.
   std::set<uint32_t> to_remove;
   for (auto& pair : in_flight_wm_change_map_) {
     if (pair.second.client_id == tree->id())
       to_remove.insert(pair.first);
   }
   for (uint32_t id : to_remove)
     in_flight_wm_change_map_.erase(id);
 }
@@ skipping 45 matching lines @@
     const ServerWindow* window) const {
   if (!window)
     return nullptr;
   for (auto& pair : tree_map_) {
     if (pair.second->HasRoot(window))
       return pair.second.get();
   }
   return nullptr;
 }
 
-void WindowServer::OnFirstWindowManagerFactorySet() {
+void WindowServer::OnFirstWindowManagerWindowTreeFactoryReady() {
   if (display_manager_->has_active_or_pending_displays())
     return;
 
   // We've been supplied a WindowManagerFactory and no displays have been
   // created yet. Treat this as a signal to create a Display.
   // TODO(sky): we need a better way to determine this, most likely a switch.
   delegate_->CreateDefaultDisplays();
 }
 
 bool WindowServer::SetFocusedWindow(ServerWindow* window) {
@@ skipping 408 matching lines @@
   // If we're deleting a window, then this is a superfluous message.
   if (current_operation_type() == OperationType::DELETE_WINDOW)
     return;
   for (auto& pair : tree_map_) {
     pair.second->ProcessTransientWindowRemoved(window, transient_child,
                                                IsOperationSource(pair.first));
   }
 }
 
 void WindowServer::OnFirstDisplayReady() {
+  // TODO(sky): remove this, temporary until window manager state made
+  // global.
+  if (!created_one_display_) {
+    created_one_display_ = true;
+    std::vector<WindowManagerWindowTreeFactory*> factories =
+        window_manager_window_tree_factory_set_.GetFactories();
+    for (WindowManagerWindowTreeFactory* factory : factories)
+      factory->BindPendingRequest();
+  }
   delegate_->OnFirstDisplayReady();
 }
 
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 }  // namespace ws
 }  // namespace mus