Eliminate WindowTreeConnection

components/mus/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 "components/mus/public/cpp/tests/window_server_test_base.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "components/mus/public/cpp/window.h"
-#include "components/mus/public/cpp/window_tree_connection.h"
+#include "components/mus/public/cpp/window_tree_client.h"
 #include "components/mus/public/cpp/window_tree_host_factory.h"
 #include "services/shell/public/cpp/connector.h"
 
 namespace mus {
 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_connection_(nullptr),
+    : most_recent_client_(nullptr),
       window_manager_(nullptr),
       window_manager_delegate_(nullptr),
       window_manager_client_(nullptr),
-      window_tree_connection_destroyed_(false) {}
+      window_tree_client_destroyed_(false) {}
 
 WindowServerTestBase::~WindowServerTestBase() {}
 
 // static
 bool WindowServerTestBase::DoRunLoopWithTimeout() {
   if (current_run_loop != nullptr)
     return false;
 
   bool timeout = false;
   base::RunLoop run_loop;
@@ skipping 16 matching lines @@
   current_run_loop = nullptr;
   return true;
 }
 
 void WindowServerTestBase::SetUp() {
   WindowServerShellTestBase::SetUp();
 
   CreateWindowTreeHost(connector(), this, &host_, this);
 
   ASSERT_TRUE(DoRunLoopWithTimeout());  // RunLoop should be quit by OnEmbed().
-  std::swap(window_manager_, most_recent_connection_);
+  std::swap(window_manager_, most_recent_client_);
 }
 
 bool WindowServerTestBase::AcceptConnection(shell::Connection* connection) {
   connection->AddInterface<mojom::WindowTreeClient>(this);
   return true;
 }
 
 void WindowServerTestBase::OnEmbed(Window* root) {
-  most_recent_connection_ = root->connection();
+  most_recent_client_ = root->window_tree();
   EXPECT_TRUE(QuitRunLoop());
   ASSERT_TRUE(window_manager_client_);
   window_manager_client_->AddActivationParent(root);
 }
 
-void WindowServerTestBase::OnConnectionLost(WindowTreeConnection* connection) {
-  window_tree_connection_destroyed_ = true;
+void WindowServerTestBase::OnWindowTreeClientDestroyed(
+    WindowTreeClient* client) {
+  window_tree_client_destroyed_ = true;
 }
 
 void WindowServerTestBase::OnEventObserved(const ui::Event& event,
                                            Window* target) {}
 
 void WindowServerTestBase::SetWindowManagerClient(WindowManagerClient* client) {
   window_manager_client_ = client;
 }
 
 bool WindowServerTestBase::OnWmSetBounds(Window* window, gfx::Rect* bounds) {
@@ skipping 23 matching lines @@
     bool janky) {
   if (window_manager_delegate_)
     window_manager_delegate_->OnWmClientJankinessChanged(client_windows, janky);
 }
 
 void WindowServerTestBase::OnAccelerator(uint32_t id, const ui::Event& event) {
   if (window_manager_delegate_)
     window_manager_delegate_->OnAccelerator(id, event);
 }
 
-void WindowServerTestBase::Create(
-    shell::Connection* connection,
-    mojo::InterfaceRequest<mojom::WindowTreeClient> request) {
-  WindowTreeConnection::Create(
-      this, std::move(request),
-      WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
+void WindowServerTestBase::Create(shell::Connection* connection,
+                                  mojom::WindowTreeClientRequest request) {
+  new WindowTreeClient(this, nullptr, std::move(request));
 }
 
 }  // namespace mus