Migrate WindowServerTestBase to be a WM client.

services/ui/public/cpp/tests/window_server_test_base.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 "services/ui/public/cpp/tests/window_server_test_base.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_tree_client.h"
-#include "services/ui/public/cpp/window_tree_host_factory.h"
 
 namespace ui {
 namespace {
 
 base::RunLoop* current_run_loop = nullptr;
 
 void TimeoutRunLoop(const base::Closure& timeout_task, bool* timeout) {
   CHECK(current_run_loop);
   *timeout = true;
   timeout_task.Run();
 }
 
 }  // namespace
 
 WindowServerTestBase::WindowServerTestBase()
-    : most_recent_client_(nullptr),
-      window_manager_(nullptr),
+    : window_manager_(nullptr),
       window_manager_delegate_(nullptr),
       window_manager_client_(nullptr) {}
 
 WindowServerTestBase::~WindowServerTestBase() {
   window_tree_clients_.clear();
 }
 
 // static
 bool WindowServerTestBase::DoRunLoopWithTimeout() {
   if (current_run_loop != nullptr)
@@ skipping 30 matching lines @@
       return;
     }
   }
   NOTREACHED();
 }
 
 void WindowServerTestBase::SetUp() {
   WindowServerServiceTestBase::SetUp();
 
   std::unique_ptr<WindowTreeClient> window_manager_window_tree_client =
-      CreateWindowTreeHost(connector(), this, &host_, this);
+      base::MakeUnique<WindowTreeClient>(this, this);
+  window_manager_window_tree_client->ConnectAsWindowManager(connector());
   window_manager_ = window_manager_window_tree_client.get();
   window_tree_clients_.insert(std::move(window_manager_window_tree_client));
 
   ASSERT_TRUE(DoRunLoopWithTimeout());  // RunLoop should be quit by OnEmbed().
 }
 
 bool WindowServerTestBase::OnConnect(
     const service_manager::Identity& remote_identity,
     service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::WindowTreeClient>(this);
   return true;
 }
 
 void WindowServerTestBase::OnEmbed(Window* root) {
-  most_recent_client_ = root->window_tree();
   EXPECT_TRUE(QuitRunLoop());
-  ASSERT_TRUE(window_manager_client_);
-  window_manager_client_->AddActivationParent(root);
 }
 
 void WindowServerTestBase::OnLostConnection(WindowTreeClient* client) {
   window_tree_client_lost_connection_ = true;
   DeleteWindowTreeClient(client);
 }
 
 void WindowServerTestBase::OnEmbedRootDestroyed(Window* root) {
   DeleteWindowTreeClient(root->window_tree());
 }
@@ skipping 29 matching lines @@
 
 void WindowServerTestBase::OnWmClientJankinessChanged(
     const std::set<Window*>& client_windows,
     bool janky) {
   if (window_manager_delegate_)
     window_manager_delegate_->OnWmClientJankinessChanged(client_windows, janky);
 }
 
 void WindowServerTestBase::OnWmNewDisplay(Window* window,
                                           const display::Display& display) {
+  EXPECT_TRUE(QuitRunLoop());
+  ASSERT_TRUE(window_manager_client_);
+  window_manager_client_->AddActivationParent(window);
+
   if (window_manager_delegate_)
     window_manager_delegate_->OnWmNewDisplay(window, display);
 }
 
 void WindowServerTestBase::OnWmDisplayRemoved(Window* window) {
   if (window_manager_delegate_)
     window_manager_delegate_->OnWmDisplayRemoved(window);
 }
 
 void WindowServerTestBase::OnWmDisplayModified(
@@ skipping 26 matching lines @@
 }
 
 void WindowServerTestBase::Create(
     const service_manager::Identity& remote_identity,
     mojom::WindowTreeClientRequest request) {
   window_tree_clients_.insert(
       base::MakeUnique<WindowTreeClient>(this, nullptr, std::move(request)));
 }
 
 }  // namespace ui