Eliminate WindowTreeConnection

components/mus/ws/window_manager_client_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/lib/window_private.h"
-#include "components/mus/public/cpp/lib/window_tree_client_impl.h"
 #include "components/mus/public/cpp/tests/window_server_test_base.h"
 #include "components/mus/public/cpp/window_observer.h"
-#include "components/mus/public/cpp/window_tree_connection.h"
-#include "components/mus/public/cpp/window_tree_connection_observer.h"
-#include "components/mus/public/cpp/window_tree_delegate.h"
+#include "components/mus/public/cpp/window_tree_client.h"
+#include "components/mus/public/cpp/window_tree_client_delegate.h"
+#include "components/mus/public/cpp/window_tree_client_observer.h"
 #include "ui/gfx/geometry/mojo/geometry_type_converters.h"
 #include "ui/gfx/geometry/mojo/geometry_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace mus {
 namespace ws {
 
 namespace {
 
 Id server_id(mus::Window* window) {
   return WindowPrivate(window).server_id();
 }
 
-mus::Window* GetChildWindowByServerId(WindowTreeConnection* connection,
+mus::Window* GetChildWindowByServerId(WindowTreeClient* client,
                                       uint32_t id) {
-  return static_cast<WindowTreeClientImpl*>(connection)
-      ->GetWindowByServerId(id);
+  return client->GetWindowByServerId(id);
 }
 
 int ValidIndexOf(const Window::Children& windows, Window* window) {
   Window::Children::const_iterator it =
       std::find(windows.begin(), windows.end(), window);
   return (it != windows.end()) ? (it - windows.begin()) : -1;
 }
 
 class TestWindowManagerDelegate : public WindowManagerDelegate {
  public:
@@ skipping 138 matching lines @@
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 // Wait until |window|'s tree size matches |tree_size|; returns false on
 // timeout.
-bool WaitForOrderChange(WindowTreeConnection* connection, Window* window) {
+bool WaitForOrderChange(WindowTreeClient* client, Window* window) {
   OrderChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 // Tracks a window's destruction. Query is_valid() for current state.
 class WindowTracker : public WindowObserver {
  public:
   explicit WindowTracker(Window* window) : window_(window) {
     window_->AddObserver(this);
   }
@@ skipping 15 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WindowTracker);
 };
 
 }  // namespace
 
 // WindowServer
 // -----------------------------------------------------------------
 
 struct EmbedResult {
-  EmbedResult(WindowTreeConnection* connection, ClientSpecificId id)
-      : connection(connection), client_id(id) {}
-  EmbedResult() : connection(nullptr), client_id(0) {}
+  EmbedResult(WindowTreeClient* client, ClientSpecificId id)
+      : client(client), client_id(id) {}
+  EmbedResult() : client(nullptr), client_id(0) {}
 
-  WindowTreeConnection* connection;
+  WindowTreeClient* client;
 
   // The id supplied to the callback from OnEmbed(). Depending upon the
   // access policy this may or may not match the client id of
-  // |connection|.
+  // |client|.
   ClientSpecificId client_id;
 };
 
-Window* GetFirstRoot(WindowTreeConnection* connection) {
-  return connection->GetRoots().empty() ? nullptr
-                                        : *connection->GetRoots().begin();
+Window* GetFirstRoot(WindowTreeClient* client) {
+  return client->GetRoots().empty() ? nullptr : *client->GetRoots().begin();
 }
 
-// These tests model synchronization of two peer connections to the window
-// manager
-// service, that are given access to some root window.
+// These tests model synchronization of two peer clients of the window server,
+// that are given access to some root window.
 
 class WindowServerTest : public WindowServerTestBase {
  public:
   WindowServerTest() {}
 
   Window* GetFirstWMRoot() { return GetFirstRoot(window_manager()); }
 
-  Window* NewVisibleWindow(Window* parent, WindowTreeConnection* connection) {
-    Window* window = connection->NewWindow();
+  Window* NewVisibleWindow(Window* parent, WindowTreeClient* client) {
+    Window* window = client->NewWindow();
     window->SetVisible(true);
     parent->AddChild(window);
     return window;
   }
 
   // Embeds another version of the test app @ window. This runs a run loop until
   // a response is received, or a timeout. On success the new WindowServer is
   // returned.
   EmbedResult Embed(Window* window) {
     DCHECK(!embed_details_);
     embed_details_.reset(new EmbedDetails);
     window->Embed(ConnectAndGetWindowServerClient(),
                   base::Bind(&WindowServerTest::EmbedCallbackImpl,
                              base::Unretained(this)));
     embed_details_->waiting = true;
     if (!WindowServerTestBase::DoRunLoopWithTimeout())
       return EmbedResult();
-    const EmbedResult result(embed_details_->connection,
+    const EmbedResult result(embed_details_->client,
                              embed_details_->client_id);
     embed_details_.reset();
     return result;
   }
 
   // Establishes a connection to this application and asks for a
   // WindowTreeClient.
   mus::mojom::WindowTreeClientPtr ConnectAndGetWindowServerClient() {
     mus::mojom::WindowTreeClientPtr client;
     connector()->ConnectToInterface(test_name(), &client);
     return client;
   }
 
   // WindowServerTestBase:
   void OnEmbed(Window* root) override {
     if (!embed_details_) {
       WindowServerTestBase::OnEmbed(root);
       return;
     }
 
-    embed_details_->connection = root->connection();
+    embed_details_->client = root->window_tree();
     if (embed_details_->callback_run)
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
  private:
   // Used to track the state of a call to window->Embed().
   struct EmbedDetails {
     EmbedDetails()
         : callback_run(false),
           result(false),
           waiting(false),
-          connection(nullptr) {}
+          client(nullptr) {}
 
     // The callback supplied to Embed() was received.
     bool callback_run;
 
     // The boolean supplied to the Embed() callback.
     bool result;
 
     // Whether a MessageLoop is running.
     bool waiting;
 
     // Client id supplied to the Embed() callback.
     ClientSpecificId client_id;
 
-    // The WindowTreeConnection that resulted from the Embed(). null if |result|
-    // is false.
-    WindowTreeConnection* connection;
+    // The WindowTreeClient that resulted from the Embed(). null if |result| is
+    // false.
+    WindowTreeClient* client;
   };
 
   void EmbedCallbackImpl(bool result) {
     embed_details_->callback_run = true;
     embed_details_->result = result;
-    if (embed_details_->waiting && (!result || embed_details_->connection))
+    if (embed_details_->waiting && (!result || embed_details_->client))
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   std::unique_ptr<EmbedDetails> embed_details_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowServerTest);
 };
 
 TEST_F(WindowServerTest, RootWindow) {
   ASSERT_NE(nullptr, window_manager());
   EXPECT_EQ(1u, window_manager()->GetRoots().size());
 }
 
 TEST_F(WindowServerTest, Embed) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
-  WindowTreeConnection* embedded = Embed(window).connection;
+  WindowTreeClient* embedded = Embed(window).client;
   ASSERT_NE(nullptr, embedded);
 
   Window* window_in_embedded = GetFirstRoot(embedded);
   ASSERT_NE(nullptr, window_in_embedded);
   EXPECT_EQ(server_id(window), server_id(window_in_embedded));
   EXPECT_EQ(nullptr, window_in_embedded->parent());
   EXPECT_TRUE(window_in_embedded->children().empty());
 }
 
 // Window manager has two windows, N1 and N11. Embeds A at N1. A should not see
 // N11.
 TEST_F(WindowServerTest, EmbeddedDoesntSeeChild) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
   Window* nested = window_manager()->NewWindow();
   ASSERT_NE(nullptr, nested);
   nested->SetVisible(true);
   window->AddChild(nested);
 
-  WindowTreeConnection* embedded = Embed(window).connection;
+  WindowTreeClient* embedded = Embed(window).client;
   ASSERT_NE(nullptr, embedded);
   Window* window_in_embedded = GetFirstRoot(embedded);
   EXPECT_EQ(server_id(window), server_id(window_in_embedded));
   EXPECT_EQ(nullptr, window_in_embedded->parent());
   EXPECT_TRUE(window_in_embedded->children().empty());
 }
 
 // TODO(beng): write a replacement test for the one that once existed here:
 // This test validates the following scenario:
-// -  a window originating from one connection
-// -  a window originating from a second connection
-// +  the connection originating the window is destroyed
-// -> the window should still exist (since the second connection is live) but
+// -  a window originating from one client
+// -  a window originating from a second client
+// +  the client originating the window is destroyed
+// -> the window should still exist (since the second client is live) but
 //    should be disconnected from any windows.
 // http://crbug.com/396300
 //
 // TODO(beng): The new test should validate the scenario as described above
-//             except that the second connection still has a valid tree.
+//             except that the second client still has a valid tree.
 
-// Verifies that bounds changes applied to a window hierarchy in one connection
+// Verifies that bounds changes applied to a window hierarchy in one client
 // are reflected to another.
 TEST_F(WindowServerTest, SetBounds) {
   Window* window = window_manager()->NewWindow();
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
-  WindowTreeConnection* embedded = Embed(window).connection;
+  WindowTreeClient* embedded = Embed(window).client;
   ASSERT_NE(nullptr, embedded);
 
   Window* window_in_embedded =
       GetChildWindowByServerId(embedded, server_id(window));
   EXPECT_EQ(window->bounds(), window_in_embedded->bounds());
 
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   ASSERT_TRUE(WaitForBoundsToChange(window_in_embedded));
   EXPECT_TRUE(window->bounds() == window_in_embedded->bounds());
 }
 
 // Verifies that bounds changes applied to a window owned by a different
-// connection can be refused.
+// client can be refused.
 TEST_F(WindowServerTest, SetBoundsSecurity) {
   TestWindowManagerDelegate wm_delegate;
   set_window_manager_delegate(&wm_delegate);
 
   Window* window = window_manager()->NewWindow();
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
-  WindowTreeConnection* embedded = Embed(window).connection;
+  WindowTreeClient* embedded = Embed(window).client;
   ASSERT_NE(nullptr, embedded);
 
   Window* window_in_embedded =
       GetChildWindowByServerId(embedded, server_id(window));
   window->SetBounds(gfx::Rect(0, 0, 800, 600));
   ASSERT_TRUE(WaitForBoundsToChange(window_in_embedded));
 
   window_in_embedded->SetBounds(gfx::Rect(0, 0, 1024, 768));
   // Bounds change is initially accepted, but the server declines the request.
   EXPECT_FALSE(window->bounds() == window_in_embedded->bounds());
 
   // The client is notified when the requested is declined, and updates the
   // local bounds accordingly.
   ASSERT_TRUE(WaitForBoundsToChange(window_in_embedded));
   EXPECT_TRUE(window->bounds() == window_in_embedded->bounds());
   set_window_manager_delegate(nullptr);
 }
 
 // Verifies that a root window can always be destroyed.
 TEST_F(WindowServerTest, DestroySecurity) {
   Window* window = window_manager()->NewWindow();
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
 
-  WindowTreeConnection* embedded = Embed(window).connection;
+  WindowTreeClient* embedded = Embed(window).client;
   ASSERT_NE(nullptr, embedded);
 
-  // The root can be destroyed, even though it was not created by the
-  // connection.
+  // The root can be destroyed, even though it was not created by the client.
   Window* embed_root = GetChildWindowByServerId(embedded, server_id(window));
   WindowTracker tracker1(window);
   WindowTracker tracker2(embed_root);
   embed_root->Destroy();
   EXPECT_FALSE(tracker2.is_valid());
   EXPECT_TRUE(tracker1.is_valid());
 
   window->Destroy();
   EXPECT_FALSE(tracker1.is_valid());
 }
 
 TEST_F(WindowServerTest, MultiRoots) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
   Window* window2 = window_manager()->NewWindow();
   window2->SetVisible(true);
   GetFirstWMRoot()->AddChild(window2);
-  WindowTreeConnection* embedded1 = Embed(window1).connection;
+  WindowTreeClient* embedded1 = Embed(window1).client;
   ASSERT_NE(nullptr, embedded1);
-  WindowTreeConnection* embedded2 = Embed(window2).connection;
+  WindowTreeClient* embedded2 = Embed(window2).client;
   ASSERT_NE(nullptr, embedded2);
   EXPECT_NE(embedded1, embedded2);
 }
 
 TEST_F(WindowServerTest, Reorder) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
-  WindowTreeConnection* embedded = Embed(window1).connection;
+  WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
 
   Window* window11 = embedded->NewWindow();
   window11->SetVisible(true);
   GetFirstRoot(embedded)->AddChild(window11);
   Window* window12 = embedded->NewWindow();
   window12->SetVisible(true);
   GetFirstRoot(embedded)->AddChild(window12);
   ASSERT_TRUE(WaitForTreeSizeToMatch(window1, 3u));
 
@@ skipping 64 matching lines @@
 };
 
 }  // namespace
 
 TEST_F(WindowServerTest, Visible) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
   // Embed another app and verify initial state.
-  WindowTreeConnection* embedded = Embed(window1).connection;
+  WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
   ASSERT_NE(nullptr, GetFirstRoot(embedded));
   Window* embedded_root = GetFirstRoot(embedded);
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
-  // Change the visible state from the first connection and verify its mirrored
+  // Change the visible state from the first client and verify its mirrored
   // correctly to the embedded app.
   {
     VisibilityChangeObserver observer(embedded_root);
     window1->SetVisible(false);
     ASSERT_TRUE(WindowServerTestBase::DoRunLoopWithTimeout());
   }
 
   EXPECT_FALSE(window1->visible());
   EXPECT_FALSE(window1->IsDrawn());
 
@@ skipping 36 matching lines @@
 };
 
 }  // namespace
 
 TEST_F(WindowServerTest, Drawn) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
   // Embed another app and verify initial state.
-  WindowTreeConnection* embedded = Embed(window1).connection;
+  WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
   ASSERT_NE(nullptr, GetFirstRoot(embedded));
   Window* embedded_root = GetFirstRoot(embedded);
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
   // Change the visibility of the root, this should propagate a drawn state
   // change to |embedded|.
   {
     DrawnChangeObserver observer(embedded_root);
@@ skipping 42 matching lines @@
   }
 
   Window* window_;
   Window* last_gained_focus_;
   Window* last_lost_focus_;
   bool quit_on_change_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 };
 
-class NullFocusChangeObserver : public WindowTreeConnectionObserver {
+class NullFocusChangeObserver : public WindowTreeClientObserver {
  public:
-  explicit NullFocusChangeObserver(WindowTreeConnection* connection)
-      : connection_(connection) {
-    connection_->AddObserver(this);
+  explicit NullFocusChangeObserver(WindowTreeClient* client)
+      : client_(client) {
+    client_->AddObserver(this);
   }
-  ~NullFocusChangeObserver() override { connection_->RemoveObserver(this); }
+  ~NullFocusChangeObserver() override { client_->RemoveObserver(this); }
 
  private:
-  // Overridden from WindowTreeConnectionObserver.
+  // Overridden from WindowTreeClientObserver.
   void OnWindowTreeFocusChanged(Window* gained_focus,
                                 Window* lost_focus) override {
     if (!gained_focus)
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
-  WindowTreeConnection* connection_;
+  WindowTreeClient* client_;
 
   DISALLOW_COPY_AND_ASSIGN(NullFocusChangeObserver);
 };
 
 bool WaitForWindowToHaveFocus(Window* window) {
   if (window->HasFocus())
     return true;
   FocusChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
-bool WaitForNoWindowToHaveFocus(WindowTreeConnection* connection) {
-  if (!connection->GetFocusedWindow())
+bool WaitForNoWindowToHaveFocus(WindowTreeClient* client) {
+  if (!client->GetFocusedWindow())
     return true;
-  NullFocusChangeObserver observer(connection);
+  NullFocusChangeObserver observer(client);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 }  // namespace
 
 TEST_F(WindowServerTest, Focus) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
-  WindowTreeConnection* embedded = Embed(window1).connection;
+  WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
   Window* window11 = embedded->NewWindow();
   window11->SetVisible(true);
   GetFirstRoot(embedded)->AddChild(window11);
 
   {
     // Focus the embed root in |embedded|.
     Window* embedded_root = GetFirstRoot(embedded);
     FocusChangeObserver observer(embedded_root);
     observer.set_quit_on_change(false);
@@ skipping 33 matching lines @@
     EXPECT_EQ(server_id(GetFirstRoot(embedded)),
               server_id(observer.last_gained_focus()));
   }
 }
 
 TEST_F(WindowServerTest, ClearFocus) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
-  WindowTreeConnection* embedded = Embed(window1).connection;
+  WindowTreeClient* embedded = Embed(window1).client;
   ASSERT_NE(nullptr, embedded);
   Window* window11 = embedded->NewWindow();
   window11->SetVisible(true);
   GetFirstRoot(embedded)->AddChild(window11);
 
   // Focus the embed root in |embedded|.
   Window* embedded_root = GetFirstRoot(embedded);
   {
     FocusChangeObserver observer(embedded_root);
     observer.set_quit_on_change(false);
@@ skipping 18 matching lines @@
     EXPECT_FALSE(window1->HasFocus());
     EXPECT_FALSE(window_manager()->GetFocusedWindow());
   }
 }
 
 TEST_F(WindowServerTest, FocusNonFocusableWindow) {
   Window* window = window_manager()->NewWindow();
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
 
-  WindowTreeConnection* connection = Embed(window).connection;
-  ASSERT_NE(nullptr, connection);
-  ASSERT_FALSE(connection->GetRoots().empty());
-  Window* client_window = *connection->GetRoots().begin();
+  WindowTreeClient* client = Embed(window).client;
+  ASSERT_NE(nullptr, client);
+  ASSERT_FALSE(client->GetRoots().empty());
+  Window* client_window = *client->GetRoots().begin();
   client_window->SetCanFocus(false);
 
   client_window->SetFocus();
   ASSERT_TRUE(client_window->HasFocus());
 
-  WaitForNoWindowToHaveFocus(connection);
+  WaitForNoWindowToHaveFocus(client);
   ASSERT_FALSE(client_window->HasFocus());
 }
 
 TEST_F(WindowServerTest, Activation) {
   Window* parent = NewVisibleWindow(GetFirstWMRoot(), window_manager());
 
   // Allow the child windows to be activated. Do this before we wait, that way
   // we're guaranteed that when we request focus from a separate client the
   // requests are processed in order.
   window_manager_client()->AddActivationParent(parent);
 
   Window* child1 = NewVisibleWindow(parent, window_manager());
   Window* child2 = NewVisibleWindow(parent, window_manager());
   Window* child3 = NewVisibleWindow(parent, window_manager());
 
   child1->AddTransientWindow(child3);
 
-  WindowTreeConnection* embedded1 = Embed(child1).connection;
+  WindowTreeClient* embedded1 = Embed(child1).client;
   ASSERT_NE(nullptr, embedded1);
-  WindowTreeConnection* embedded2 = Embed(child2).connection;
+  WindowTreeClient* embedded2 = Embed(child2).client;
   ASSERT_NE(nullptr, embedded2);
 
   Window* child11 = NewVisibleWindow(GetFirstRoot(embedded1), embedded1);
   Window* child21 = NewVisibleWindow(GetFirstRoot(embedded2), embedded2);
 
   WaitForTreeSizeToMatch(parent, 6);
 
   // |child2| and |child3| are stacked about |child1|.
   EXPECT_GT(ValidIndexOf(parent->children(), child2),
             ValidIndexOf(parent->children(), child1));
@@ skipping 32 matching lines @@
   EXPECT_GT(ValidIndexOf(parent->children(), child3),
             ValidIndexOf(parent->children(), child1));
 }
 
 TEST_F(WindowServerTest, ActivationNext) {
   Window* parent = GetFirstWMRoot();
   Window* child1 = NewVisibleWindow(parent, window_manager());
   Window* child2 = NewVisibleWindow(parent, window_manager());
   Window* child3 = NewVisibleWindow(parent, window_manager());
 
-  WindowTreeConnection* embedded1 = Embed(child1).connection;
+  WindowTreeClient* embedded1 = Embed(child1).client;
   ASSERT_NE(nullptr, embedded1);
-  WindowTreeConnection* embedded2 = Embed(child2).connection;
+  WindowTreeClient* embedded2 = Embed(child2).client;
   ASSERT_NE(nullptr, embedded2);
-  WindowTreeConnection* embedded3 = Embed(child3).connection;
+  WindowTreeClient* embedded3 = Embed(child3).client;
   ASSERT_NE(nullptr, embedded3);
 
   Window* child11 = NewVisibleWindow(GetFirstRoot(embedded1), embedded1);
   Window* child21 = NewVisibleWindow(GetFirstRoot(embedded2), embedded2);
   Window* child31 = NewVisibleWindow(GetFirstRoot(embedded3), embedded3);
   WaitForTreeSizeToMatch(parent, 7);
 
   Window* expecteds[] = { child3, child2, child1, child3, nullptr };
   Window* focused[] = { child31, child21, child11, child31, nullptr };
   for (size_t index = 0; expecteds[index]; ++index) {
@@ skipping 20 matching lines @@
   }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDestroyed(Window* window) override {
     EXPECT_EQ(window, window_);
     window_->RemoveObserver(this);
     *got_destroy_ = true;
     window_ = nullptr;
 
-    // We should always get OnWindowDestroyed() before OnConnectionLost().
-    EXPECT_FALSE(test_->window_tree_connection_destroyed());
+    // We should always get OnWindowDestroyed() before
+    // OnWindowTreeClientDestroyed().
+    EXPECT_FALSE(test_->window_tree_client_destroyed());
   }
 
   WindowServerTestBase* test_;
   Window* window_;
   bool* got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a WindowServer sends the right notifications.
 TEST_F(WindowServerTest, DeleteWindowServer) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
-  WindowTreeConnection* connection = Embed(window).connection;
-  ASSERT_TRUE(connection);
+  WindowTreeClient* client = Embed(window).client;
+  ASSERT_TRUE(client);
   bool got_destroy = false;
-  DestroyedChangedObserver observer(this, GetFirstRoot(connection),
+  DestroyedChangedObserver observer(this, GetFirstRoot(client),
                                     &got_destroy);
-  delete connection;
-  EXPECT_TRUE(window_tree_connection_destroyed());
+  delete client;
+  EXPECT_TRUE(window_tree_client_destroyed());
   EXPECT_TRUE(got_destroy);
 }
 
 // Verifies two Embed()s in the same window trigger deletion of the first
 // WindowServer.
 TEST_F(WindowServerTest, DisconnectTriggersDelete) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
-  WindowTreeConnection* connection = Embed(window).connection;
-  EXPECT_NE(connection, window_manager());
-  Window* embedded_window = connection->NewWindow();
-  // Embed again, this should trigger disconnect and deletion of connection.
+  WindowTreeClient* client = Embed(window).client;
+  EXPECT_NE(client, window_manager());
+  Window* embedded_window = client->NewWindow();
+  // Embed again, this should trigger disconnect and deletion of client.
   bool got_destroy;
   DestroyedChangedObserver observer(this, embedded_window, &got_destroy);
-  EXPECT_FALSE(window_tree_connection_destroyed());
+  EXPECT_FALSE(window_tree_client_destroyed());
   Embed(window);
-  EXPECT_TRUE(window_tree_connection_destroyed());
+  EXPECT_TRUE(window_tree_client_destroyed());
 }
 
 class WindowRemovedFromParentObserver : public WindowObserver {
  public:
   explicit WindowRemovedFromParentObserver(Window* window)
       : window_(window), was_removed_(false) {
     window_->AddObserver(this);
   }
   ~WindowRemovedFromParentObserver() override { window_->RemoveObserver(this); }
 
@@ skipping 28 matching lines @@
   // we may end up reconnecting to the test and rerunning the test, which is
   // problematic since the other services don't shut down.
   ASSERT_TRUE(DoRunLoopWithTimeout());
 }
 
 namespace {
 
 class DestroyObserver : public WindowObserver {
  public:
   DestroyObserver(WindowServerTestBase* test,
-                  WindowTreeConnection* connection,
+                  WindowTreeClient* client,
                   bool* got_destroy)
       : test_(test), got_destroy_(got_destroy) {
-    GetFirstRoot(connection)->AddObserver(this);
+    GetFirstRoot(client)->AddObserver(this);
   }
   ~DestroyObserver() override {}
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDestroyed(Window* window) override {
     *got_destroy_ = true;
     window->RemoveObserver(this);
 
     // We should always get OnWindowDestroyed() before
     // OnWindowManagerDestroyed().
-    EXPECT_FALSE(test_->window_tree_connection_destroyed());
+    EXPECT_FALSE(test_->window_tree_client_destroyed());
 
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   WindowServerTestBase* test_;
   bool* got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
 };
 
 }  // namespace
 
-// Verifies deleting a Window that is the root of another connection notifies
+// Verifies deleting a Window that is the root of another client notifies
 // observers in the right order (OnWindowDestroyed() before
 // OnWindowManagerDestroyed()).
 TEST_F(WindowServerTest, WindowServerDestroyedAfterRootObserver) {
   Window* embed_window = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(embed_window);
 
-  WindowTreeConnection* embedded_connection = Embed(embed_window).connection;
+  WindowTreeClient* embedded_client = Embed(embed_window).client;
 
   bool got_destroy = false;
-  DestroyObserver observer(this, embedded_connection, &got_destroy);
-  // Delete the window |embedded_connection| is embedded in. This is async,
-  // but will eventually trigger deleting |embedded_connection|.
+  DestroyObserver observer(this, embedded_client, &got_destroy);
+  // Delete the window |embedded_client| is embedded in. This is async,
+  // but will eventually trigger deleting |embedded_client|.
   embed_window->Destroy();
   EXPECT_TRUE(DoRunLoopWithTimeout());
   EXPECT_TRUE(got_destroy);
 }
 
 TEST_F(WindowServerTest, ClientAreaChanged) {
   Window* embed_window = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(embed_window);
 
-  WindowTreeConnection* embedded_connection = Embed(embed_window).connection;
+  WindowTreeClient* embedded_client = Embed(embed_window).client;
 
   // Verify change from embedded makes it to parent.
-  GetFirstRoot(embedded_connection)->SetClientArea(gfx::Insets(1, 2, 3, 4));
+  GetFirstRoot(embedded_client)->SetClientArea(gfx::Insets(1, 2, 3, 4));
   ASSERT_TRUE(WaitForClientAreaToChange(embed_window));
   EXPECT_TRUE(gfx::Insets(1, 2, 3, 4) == embed_window->client_area());
 
   // Changing bounds shouldn't effect client area.
   embed_window->SetBounds(gfx::Rect(21, 22, 23, 24));
-  WaitForBoundsToChange(GetFirstRoot(embedded_connection));
+  WaitForBoundsToChange(GetFirstRoot(embedded_client));
   EXPECT_TRUE(gfx::Rect(21, 22, 23, 24) ==
-              GetFirstRoot(embedded_connection)->bounds());
+              GetFirstRoot(embedded_client)->bounds());
   EXPECT_TRUE(gfx::Insets(1, 2, 3, 4) ==
-              GetFirstRoot(embedded_connection)->client_area());
+              GetFirstRoot(embedded_client)->client_area());
 }
 
 class EstablishConnectionViaFactoryDelegate : public TestWindowManagerDelegate {
  public:
   explicit EstablishConnectionViaFactoryDelegate(
-      WindowTreeConnection* connection)
-      : connection_(connection), run_loop_(nullptr), created_window_(nullptr) {}
+      WindowTreeClient* client)
+      : client_(client), run_loop_(nullptr), created_window_(nullptr) {}
   ~EstablishConnectionViaFactoryDelegate() override {}
 
   bool QuitOnCreate() {
     if (run_loop_)
       return false;
 
     created_window_ = nullptr;
     run_loop_.reset(new base::RunLoop);
     run_loop_->Run();
     run_loop_.reset();
     return created_window_ != nullptr;
   }
 
   Window* created_window() { return created_window_; }
 
   // WindowManagerDelegate:
   Window* OnWmCreateTopLevelWindow(
       std::map<std::string, std::vector<uint8_t>>* properties) override {
-    created_window_ = connection_->NewWindow(properties);
-    (*connection_->GetRoots().begin())->AddChild(created_window_);
+    created_window_ = client_->NewWindow(properties);
+    (*client_->GetRoots().begin())->AddChild(created_window_);
     if (run_loop_)
       run_loop_->Quit();
     return created_window_;
   }
 
  private:
-  WindowTreeConnection* connection_;
+  WindowTreeClient* client_;
   std::unique_ptr<base::RunLoop> run_loop_;
   Window* created_window_;
 
   DISALLOW_COPY_AND_ASSIGN(EstablishConnectionViaFactoryDelegate);
 };
 
 TEST_F(WindowServerTest, EstablishConnectionViaFactory) {
   EstablishConnectionViaFactoryDelegate delegate(window_manager());
   set_window_manager_delegate(&delegate);
-  std::unique_ptr<WindowTreeConnection> second_connection(
-      WindowTreeConnection::Create(this, connector()));
-  Window* window_in_second_connection =
-      second_connection->NewTopLevelWindow(nullptr);
-  ASSERT_TRUE(window_in_second_connection);
-  ASSERT_TRUE(second_connection->GetRoots().count(window_in_second_connection) >
+  std::unique_ptr<WindowTreeClient> second_client(
+      new WindowTreeClient(this, nullptr, nullptr));
+  second_client->ConnectViaWindowTreeFactory(connector());
+  Window* window_in_second_client =
+      second_client->NewTopLevelWindow(nullptr);
+  ASSERT_TRUE(window_in_second_client);
+  ASSERT_TRUE(second_client->GetRoots().count(window_in_second_client) >
               0);
   // Wait for the window to appear in the wm.
   ASSERT_TRUE(delegate.QuitOnCreate());
 
   Window* window_in_wm = delegate.created_window();
   ASSERT_TRUE(window_in_wm);
 
   // Change the bounds in the wm, and make sure the child sees it.
   window_in_wm->SetBounds(gfx::Rect(1, 11, 12, 101));
-  ASSERT_TRUE(WaitForBoundsToChange(window_in_second_connection));
-  EXPECT_EQ(gfx::Rect(1, 11, 12, 101), window_in_second_connection->bounds());
+  ASSERT_TRUE(WaitForBoundsToChange(window_in_second_client));
+  EXPECT_EQ(gfx::Rect(1, 11, 12, 101), window_in_second_client->bounds());
 }
 
 }  // namespace ws
 }  // namespace mus