Changes how window manager obtains WindowTree from mus

components/mus/ws/test_utils.cc

 // Copyright 2016 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/test_utils.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/output/copy_output_request.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display_binding.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/server_window_surface_manager_test_api.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_window_tree_factory.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mus {
 namespace ws {
 namespace test {
 namespace {
 
 // -----------------------------------------------------------------------------
 // Empty implementation of PlatformDisplay.
@@ skipping 44 matching lines @@
     // Used the id of the client in the upper bits to simplify things.
     const ClientWindowId client_id =
         ClientWindowId(WindowIdToTransportId(WindowId(tree->id(), id)));
     if (!tree->GetWindowByClientId(client_id))
       return client_id;
   }
 }
 
 }  // namespace
 
-// WindowManagerFactoryRegistryTestApi ----------------------------------------
+// WindowManagerWindowTreeFactorySetTestApi ------------------------------------
 
-WindowManagerFactoryRegistryTestApi::WindowManagerFactoryRegistryTestApi(
-    WindowManagerFactoryRegistry* registry)
-    : registry_(registry) {}
+WindowManagerWindowTreeFactorySetTestApi::
+    WindowManagerWindowTreeFactorySetTestApi(
+        WindowManagerWindowTreeFactorySet*
+            window_manager_window_tree_factory_set)
+    : window_manager_window_tree_factory_set_(
+          window_manager_window_tree_factory_set) {}
 
-WindowManagerFactoryRegistryTestApi::~WindowManagerFactoryRegistryTestApi() {}
+WindowManagerWindowTreeFactorySetTestApi::
+    ~WindowManagerWindowTreeFactorySetTestApi() {}
 
-void WindowManagerFactoryRegistryTestApi::AddService(
-    const UserId& user_id,
-    mojom::WindowManagerFactory* factory) {
-  std::unique_ptr<WindowManagerFactoryService> service_ptr(
-      new WindowManagerFactoryService(registry_, user_id));
-  WindowManagerFactoryService* service = service_ptr.get();
-  registry_->AddServiceImpl(std::move(service_ptr));
-  service->SetWindowManagerFactoryImpl(factory);
+void WindowManagerWindowTreeFactorySetTestApi::Add(const UserId& user_id) {
+  WindowManagerWindowTreeFactory* factory =
+      window_manager_window_tree_factory_set_->Add(user_id, nullptr);
+  factory->CreateWindowTree(nullptr, nullptr);
 }
 
 // TestPlatformDisplayFactory  -------------------------------------------------
 
 TestPlatformDisplayFactory::TestPlatformDisplayFactory(
     int32_t* cursor_id_storage)
     : cursor_id_storage_(cursor_id_storage) {}
 
 TestPlatformDisplayFactory::~TestPlatformDisplayFactory() {}
 
@@ skipping 331 matching lines @@
   *window = child1;
 }
 
 void WindowEventTargetingHelper::SetTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   message_loop_.SetTaskRunner(task_runner);
 }
 
 // ----------------------------------------------------------------------------
 
-TestWindowManagerFactory::TestWindowManagerFactory() {}
-
-TestWindowManagerFactory::~TestWindowManagerFactory() {}
-
-void TestWindowManagerFactory::CreateWindowManager(
-    mus::mojom::DisplayPtr display,
-    mus::mojom::WindowTreeClientRequest client) {}
-
-// ----------------------------------------------------------------------------
-
 ServerWindow* FirstRoot(WindowTree* tree) {
   return tree->roots().size() == 1u
              ? tree->GetWindow((*tree->roots().begin())->id())
              : nullptr;
 }
 
 ClientWindowId FirstRootId(WindowTree* tree) {
   ServerWindow* first_root = FirstRoot(tree);
   return first_root ? ClientWindowIdForWindow(tree, first_root)
                     : ClientWindowId();
 }
 
 ClientWindowId ClientWindowIdForWindow(WindowTree* tree,
                                        const ServerWindow* window) {
   ClientWindowId client_window_id;
   // If window isn't known we'll return 0, which should then error out.
   tree->IsWindowKnown(window, &client_window_id);
   return client_window_id;
 }
 
 ServerWindow* NewWindowInTree(WindowTree* tree, ClientWindowId* client_id) {
-  ServerWindow* parent = FirstRoot(tree);
+  return NewWindowInTreeWithParent(tree, FirstRoot(tree), client_id);
+}
+
+ServerWindow* NewWindowInTreeWithParent(WindowTree* tree,
+                                        ServerWindow* parent,
+                                        ClientWindowId* client_id) {
   if (!parent)
     return nullptr;
   ClientWindowId parent_client_id;
   if (!tree->IsWindowKnown(parent, &parent_client_id))
     return nullptr;
   ClientWindowId client_window_id = NextUnusedClientWindowId(tree);
   if (!tree->NewWindow(client_window_id, ServerWindow::Properties()))
     return nullptr;
   if (!tree->SetWindowVisibility(client_window_id, true))
     return nullptr;
   if (!tree->AddWindow(parent_client_id, client_window_id))
     return nullptr;
   *client_id = client_window_id;
   return tree->GetWindowByClientId(client_window_id);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus