Changes how window manager obtains WindowTree from mus

components/mus/ws/display.cc

 // Copyright 2015 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/display.h"
 
 #include <set>
 #include <vector>
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/platform_display_init_params.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.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 "mojo/common/common_type_converters.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "ui/base/cursor/cursor.h"
 
 namespace mus {
 namespace ws {
 
 Display::Display(WindowServer* window_server,
                  const PlatformDisplayInitParams& platform_display_init_params)
     : id_(window_server->display_manager()->GetAndAdvanceNextDisplayId()),
       window_server_(window_server),
       platform_display_(PlatformDisplay::Create(platform_display_init_params)),
       last_cursor_(ui::kCursorNone) {
   platform_display_->Init(this);
 
-  window_server_->window_manager_factory_registry()->AddObserver(this);
+  window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
 
 Display::~Display() {
   window_server_->user_id_tracker()->RemoveObserver(this);
 
-  window_server_->window_manager_factory_registry()->RemoveObserver(this);
+  window_server_->window_manager_window_tree_factory_set()->RemoveObserver(
+      this);
 
   if (!focus_controller_) {
     focus_controller_->RemoveObserver(this);
     focus_controller_.reset();
   }
 
   for (ServerWindow* window : windows_needing_frame_destruction_)
     window->RemoveObserver(this);
 
   // Destroy any trees, which triggers destroying the WindowManagerState. Copy
@@ skipping 167 matching lines @@
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
     std::unique_ptr<WindowManagerState> wms_ptr(
         new WindowManagerState(this, platform_display_.get()));
     WindowManagerState* wms = wms_ptr.get();
     // For this case we never create additional WindowManagerStates, so any
     // id works.
     window_manager_state_map_[shell::mojom::kRootUserID] = std::move(wms_ptr);
     wms->tree_ = binding_->CreateWindowTree(wms->root());
   } else {
-    CreateWindowManagerStatesFromRegistry();
+    CreateWindowManagerStatesFromFactories();
   }
 }
 
-void Display::CreateWindowManagerStatesFromRegistry() {
-  std::vector<WindowManagerFactoryService*> services =
-      window_server_->window_manager_factory_registry()->GetServices();
-  for (WindowManagerFactoryService* service : services) {
-    if (service->window_manager_factory())
-      CreateWindowManagerStateFromService(service);
+void Display::CreateWindowManagerStatesFromFactories() {
+  std::vector<WindowManagerWindowTreeFactory*> factories =
+      window_server_->window_manager_window_tree_factory_set()->GetFactories();
+  for (WindowManagerWindowTreeFactory* factory : factories) {
+    if (factory->window_tree())
+      CreateWindowManagerStateFromFactory(factory);
   }
 }
 
-void Display::CreateWindowManagerStateFromService(
-    WindowManagerFactoryService* service) {
+void Display::CreateWindowManagerStateFromFactory(
+    WindowManagerWindowTreeFactory* factory) {
   std::unique_ptr<WindowManagerState> wms_ptr(new WindowManagerState(
-      this, platform_display_.get(), service->user_id()));
+      this, platform_display_.get(), factory->user_id()));
   WindowManagerState* wms = wms_ptr.get();
-  window_manager_state_map_[service->user_id()] = std::move(wms_ptr);
-  wms->tree_ = window_server_->CreateTreeForWindowManager(
-      this, service->window_manager_factory(), wms->root(), service->user_id());
+  window_manager_state_map_[factory->user_id()] = std::move(wms_ptr);
+  wms->tree_ = factory->window_tree();
   if (!binding_) {
     const bool is_active =
-        service->user_id() == window_server_->user_id_tracker()->active_id();
+        factory->user_id() == window_server_->user_id_tracker()->active_id();
     wms->root()->SetVisible(is_active);
+    wms->tree_->AddRootForWindowManager(wms->root());
   }
 }
 
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
 void Display::OnEvent(const ui::Event& event) {
   WindowManagerState* wms = GetActiveWindowManagerState();
   if (wms)
@@ skipping 168 matching lines @@
   WindowManagerState* state = GetWindowManagerStateForUser(id);
   if (!state)
     return;
 
   // DestroyTree() calls back to OnWillDestroyTree() and the WindowManagerState
   // is destroyed (and removed).
   window_server_->DestroyTree(state->tree());
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
-void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
+void Display::OnWindowManagerWindowTreeFactoryReady(
+    WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
-    CreateWindowManagerStateFromService(service);
+    CreateWindowManagerStateFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace mus