More renaming in mus

WindowTreeImpl -> WindowTree
ClientConnection -> WindowTreeBinding

BUG=none
TEST=none
R=ben@chromium.org
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/1766463003

Cr-Commit-Position: refs/heads/master@{#379199}

1 files changed, 340 insertions, 340 deletions

diff --git a/components/mus/ws/window_tree_apptest.cc b/components/mus/ws/window_tree_apptest.cc
index f232911..8970435 100644
--- a/components/mus/ws/window_tree_apptest.cc
+++ b/components/mus/ws/window_tree_apptest.cc
@@ -65,7 +65,7 @@ void EmbedCallbackImpl(base::RunLoop* run_loop,
 // -----------------------------------------------------------------------------
 
 bool EmbedUrl(mojo::Connector* connector,
-              WindowTree* ws,
+              WindowTree* tree,
               const String& url,
               Id root_id) {
   bool result = false;
@@ -73,32 +73,32 @@ bool EmbedUrl(mojo::Connector* connector,
   {
     mojom::WindowTreeClientPtr client;
     connector->ConnectToInterface(url.get(), &client);
-    ws->Embed(root_id, std::move(client),
-              mojom::WindowTree::kAccessPolicyDefault,
-              base::Bind(&EmbedCallbackImpl, &run_loop, &result));
+    tree->Embed(root_id, std::move(client),
+                mojom::WindowTree::kAccessPolicyDefault,
+                base::Bind(&EmbedCallbackImpl, &run_loop, &result));
   }
   run_loop.Run();
   return result;
 }
 
-bool Embed(WindowTree* ws, Id root_id, mojom::WindowTreeClientPtr client) {
+bool Embed(WindowTree* tree, Id root_id, mojom::WindowTreeClientPtr client) {
   bool result = false;
   base::RunLoop run_loop;
   {
-    ws->Embed(root_id, std::move(client),
-              mojom::WindowTree::kAccessPolicyDefault,
-              base::Bind(&EmbedCallbackImpl, &run_loop, &result));
+    tree->Embed(root_id, std::move(client),
+                mojom::WindowTree::kAccessPolicyDefault,
+                base::Bind(&EmbedCallbackImpl, &run_loop, &result));
   }
   run_loop.Run();
   return result;
 }
 
-void GetWindowTree(WindowTree* ws,
+void GetWindowTree(WindowTree* tree,
                    Id window_id,
                    std::vector<TestWindow>* windows) {
   base::RunLoop run_loop;
-  ws->GetWindowTree(window_id,
-                    base::Bind(&WindowTreeResultCallback, &run_loop, windows));
+  tree->GetWindowTree(
+      window_id, base::Bind(&WindowTreeResultCallback, &run_loop, windows));
   run_loop.Run();
 }
 
@@ -481,19 +481,19 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
 
  protected:
   // Returns the changes from the various connections.
-  std::vector<Change>* changes1() { return ws_client1_->tracker()->changes(); }
-  std::vector<Change>* changes2() { return ws_client2_->tracker()->changes(); }
-  std::vector<Change>* changes3() { return ws_client3_->tracker()->changes(); }
+  std::vector<Change>* changes1() { return wt_client1_->tracker()->changes(); }
+  std::vector<Change>* changes2() { return wt_client2_->tracker()->changes(); }
+  std::vector<Change>* changes3() { return wt_client3_->tracker()->changes(); }
 
-  // Various connections. |ws1()|, being the first connection, has special
+  // Various connections. |wt1()|, being the first connection, has special
   // permissions (it's treated as the window manager).
-  WindowTree* ws1() { return ws_client1_->tree(); }
-  WindowTree* ws2() { return ws_client2_->tree(); }
-  WindowTree* ws3() { return ws_client3_->tree(); }
+  WindowTree* wt1() { return wt_client1_->tree(); }
+  WindowTree* wt2() { return wt_client2_->tree(); }
+  WindowTree* wt3() { return wt_client3_->tree(); }
 
-  TestWindowTreeClientImpl* ws_client1() { return ws_client1_.get(); }
-  TestWindowTreeClientImpl* ws_client2() { return ws_client2_.get(); }
-  TestWindowTreeClientImpl* ws_client3() { return ws_client3_.get(); }
+  TestWindowTreeClientImpl* wt_client1() { return wt_client1_.get(); }
+  TestWindowTreeClientImpl* wt_client2() { return wt_client2_.get(); }
+  TestWindowTreeClientImpl* wt_client3() { return wt_client3_.get(); }
 
   Id root_window_id() const { return root_window_id_; }
 
@@ -501,17 +501,17 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
   int connection_id_2() const { return connection_id_2_; }
 
   void EstablishSecondConnectionWithRoot(Id root_id) {
-    ASSERT_TRUE(ws_client2_.get() == nullptr);
-    ws_client2_ =
-        EstablishConnectionViaEmbed(ws1(), root_id, &connection_id_2_);
+    ASSERT_TRUE(wt_client2_.get() == nullptr);
+    wt_client2_ =
+        EstablishConnectionViaEmbed(wt1(), root_id, &connection_id_2_);
     ASSERT_GT(connection_id_2_, 0);
-    ASSERT_TRUE(ws_client2_.get() != nullptr);
+    ASSERT_TRUE(wt_client2_.get() != nullptr);
   }
 
   void EstablishSecondConnection(bool create_initial_window) {
     Id window_1_1 = 0;
     if (create_initial_window) {
-      window_1_1 = ws_client1()->NewWindow(1);
+      window_1_1 = wt_client1()->NewWindow(1);
       ASSERT_TRUE(window_1_1);
     }
     ASSERT_NO_FATAL_FAILURE(
@@ -524,9 +524,9 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
   }
 
   void EstablishThirdConnection(WindowTree* owner, Id root_id) {
-    ASSERT_TRUE(ws_client3_.get() == nullptr);
-    ws_client3_ = EstablishConnectionViaEmbed(owner, root_id, nullptr);
-    ASSERT_TRUE(ws_client3_.get() != nullptr);
+    ASSERT_TRUE(wt_client3_.get() == nullptr);
+    wt_client3_ = EstablishConnectionViaEmbed(owner, root_id, nullptr);
+    ASSERT_TRUE(wt_client3_.get() != nullptr);
   }
 
   scoped_ptr<TestWindowTreeClientImpl> WaitForWindowTreeClient() {
@@ -577,14 +577,14 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
     connector()->ConnectToInterface("mojo:mus", &factory);
 
     mojom::WindowTreeClientPtr tree_client_ptr;
-    ws_client1_.reset(new TestWindowTreeClientImpl());
-    ws_client1_->Bind(GetProxy(&tree_client_ptr));
+    wt_client1_.reset(new TestWindowTreeClientImpl());
+    wt_client1_->Bind(GetProxy(&tree_client_ptr));
 
     factory->CreateWindowTreeHost(GetProxy(&host_),
                                   std::move(tree_client_ptr));
 
     // Next we should get an embed call on the "window manager" client.
-    ws_client1_->WaitForIncomingMethodCall();
+    wt_client1_->WaitForIncomingMethodCall();
 
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
@@ -595,7 +595,7 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
     connection_id_1_ = (*changes1())[0].connection_id;
     ASSERT_FALSE((*changes1())[0].windows.empty());
     root_window_id_ = (*changes1())[0].windows[0].window_id;
-    ASSERT_EQ(root_window_id_, ws_client1_->root_window_id());
+    ASSERT_EQ(root_window_id_, wt_client1_->root_window_id());
     changes1()->clear();
   }
 
@@ -605,9 +605,9 @@ class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
     return true;
   }
 
-  scoped_ptr<TestWindowTreeClientImpl> ws_client1_;
-  scoped_ptr<TestWindowTreeClientImpl> ws_client2_;
-  scoped_ptr<TestWindowTreeClientImpl> ws_client3_;
+  scoped_ptr<TestWindowTreeClientImpl> wt_client1_;
+  scoped_ptr<TestWindowTreeClientImpl> wt_client2_;
+  scoped_ptr<TestWindowTreeClientImpl> wt_client3_;
 
   mojom::WindowTreeHostPtr host_;
 
@@ -631,13 +631,13 @@ TEST_F(WindowTreeAppTest, TwoClientsGetDifferentConnectionIds) {
 // Verifies when Embed() is invoked any child windows are removed.
 TEST_F(WindowTreeAppTest, WindowsRemovedWhenEmbedding) {
   // Two windows 1 and 2. 2 is parented to 1.
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
 
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_2));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   ASSERT_EQ(1u, changes2()->size());
@@ -648,7 +648,7 @@ TEST_F(WindowTreeAppTest, WindowsRemovedWhenEmbedding) {
   // Embed() removed window 2.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_2, &windows);
+    GetWindowTree(wt1(), window_1_2, &windows);
     EXPECT_EQ(WindowParentToString(window_1_2, kNullParentId),
               SingleWindowDescription(windows));
   }
@@ -656,35 +656,35 @@ TEST_F(WindowTreeAppTest, WindowsRemovedWhenEmbedding) {
   // ws2 should not see window 2.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_1_1, &windows);
+    GetWindowTree(wt2(), window_1_1, &windows);
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               SingleWindowDescription(windows));
   }
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_1_2, &windows);
+    GetWindowTree(wt2(), window_1_2, &windows);
     EXPECT_TRUE(windows.empty());
   }
 
   // Windows 3 and 4 in connection 2.
-  Id window_2_3 = ws_client2()->NewWindow(3);
-  Id window_2_4 = ws_client2()->NewWindow(4);
+  Id window_2_3 = wt_client2()->NewWindow(3);
+  Id window_2_4 = wt_client2()->NewWindow(4);
   ASSERT_TRUE(window_2_3);
   ASSERT_TRUE(window_2_4);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_3, window_2_4));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_3, window_2_4));
 
   // Connection 3 rooted at 2.
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_3));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_3));
 
   // Window 4 should no longer have a parent.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_2_3, &windows);
+    GetWindowTree(wt2(), window_2_3, &windows);
     EXPECT_EQ(WindowParentToString(window_2_3, kNullParentId),
               SingleWindowDescription(windows));
 
     windows.clear();
-    GetWindowTree(ws2(), window_2_4, &windows);
+    GetWindowTree(wt2(), window_2_4, &windows);
     EXPECT_EQ(WindowParentToString(window_2_4, kNullParentId),
               SingleWindowDescription(windows));
   }
@@ -692,7 +692,7 @@ TEST_F(WindowTreeAppTest, WindowsRemovedWhenEmbedding) {
   // And window 4 should not be visible to connection 3.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws3(), window_2_3, &windows);
+    GetWindowTree(wt3(), window_2_3, &windows);
     EXPECT_EQ("no windows", SingleWindowDescription(windows));
   }
 }
@@ -703,22 +703,22 @@ TEST_F(WindowTreeAppTest, CantAccessChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
+  Id window_2_2 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_2));
 
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_2));
 
-  Id window_3_3 = ws_client3()->NewWindow(3);
+  Id window_3_3 = wt_client3()->NewWindow(3);
   ASSERT_TRUE(window_3_3);
   ASSERT_TRUE(
-      ws_client3()->AddWindow(ws_client3()->root_window_id(), window_3_3));
+      wt_client3()->AddWindow(wt_client3()->root_window_id(), window_3_3));
 
   // Even though 3 is a child of 2 connection 2 can't see 3 as it's from a
   // different connection.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_2_2, &windows);
+    GetWindowTree(wt2(), window_2_2, &windows);
     EXPECT_EQ(WindowParentToString(window_2_2, window_1_1),
               SingleWindowDescription(windows));
   }
@@ -726,20 +726,20 @@ TEST_F(WindowTreeAppTest, CantAccessChildrenOfEmbeddedWindow) {
   // Connection 2 shouldn't be able to get window 3 at all.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_3_3, &windows);
+    GetWindowTree(wt2(), window_3_3, &windows);
     EXPECT_TRUE(windows.empty());
   }
 
   // Connection 1 should be able to see it all (its the root).
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(3u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               windows[0].ToString());
     // NOTE: we expect a match of WindowParentToString(window_2_2, window_1_1),
     // but the ids are in the id space of client2, which is not the same as
-    // the id space of ws1().
+    // the id space of wt1().
     EXPECT_EQ("window=2,1 parent=1,1", windows[1].ToString());
     // Same thing here, we really want to test for
     // WindowParentToString(window_3_3, window_2_2).
@@ -752,38 +752,38 @@ TEST_F(WindowTreeAppTest, CantModifyChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
 
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_1));
 
-  Id window_2_2 = ws_client2()->NewWindow(2);
+  Id window_2_2 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
   // Connection 2 shouldn't be able to add anything to the window anymore.
-  ASSERT_FALSE(ws_client2()->AddWindow(window_2_1, window_2_2));
+  ASSERT_FALSE(wt_client2()->AddWindow(window_2_1, window_2_2));
 
   // Create window 3 in connection 3 and add it to window 3.
-  Id window_3_1 = ws_client3()->NewWindow(1);
+  Id window_3_1 = wt_client3()->NewWindow(1);
   ASSERT_TRUE(window_3_1);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_2_1, window_3_1));
+  ASSERT_TRUE(wt_client3()->AddWindow(window_2_1, window_3_1));
 
   // Connection 2 shouldn't be able to remove window 3.
-  ASSERT_FALSE(ws_client2()->RemoveWindowFromParent(window_3_1));
+  ASSERT_FALSE(wt_client2()->RemoveWindowFromParent(window_3_1));
 }
 
 // Verifies client gets a valid id.
 TEST_F(WindowTreeAppTest, NewWindow) {
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   EXPECT_TRUE(changes1()->empty());
 
   // Can't create a window with the same id.
-  ASSERT_EQ(0u, ws_client1()->NewWindowWithCompleteId(window_1_1));
+  ASSERT_EQ(0u, wt_client1()->NewWindowWithCompleteId(window_1_1));
   EXPECT_TRUE(changes1()->empty());
 
   // Can't create a window with a bogus connection id.
-  ASSERT_EQ(0u, ws_client1()->NewWindowWithCompleteId(
+  ASSERT_EQ(0u, wt_client1()->NewWindowWithCompleteId(
                     BuildWindowId(connection_id_1() + 1, 1)));
   EXPECT_TRUE(changes1()->empty());
 }
@@ -791,46 +791,46 @@ TEST_F(WindowTreeAppTest, NewWindow) {
 // Verifies AddWindow fails when window is already in position.
 TEST_F(WindowTreeAppTest, AddWindowWithNoChange) {
   // Create the embed point now so that the ids line up.
-  ASSERT_TRUE(ws_client1()->NewWindow(1));
-  Id window_1_2 = ws_client1()->NewWindow(2);
-  Id window_1_3 = ws_client1()->NewWindow(3);
+  ASSERT_TRUE(wt_client1()->NewWindow(1));
+  Id window_1_2 = wt_client1()->NewWindow(2);
+  Id window_1_3 = wt_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(window_1_3);
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Make 3 a child of 2.
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_3));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_2, window_1_3));
 
   // Try again, this should fail.
-  EXPECT_FALSE(ws_client1()->AddWindow(window_1_2, window_1_3));
+  EXPECT_FALSE(wt_client1()->AddWindow(window_1_2, window_1_3));
 }
 
 // Verifies AddWindow fails when window is already in position.
 TEST_F(WindowTreeAppTest, AddAncestorFails) {
   // Create the embed point now so that the ids line up.
-  ASSERT_TRUE(ws_client1()->NewWindow(1));
-  Id window_1_2 = ws_client1()->NewWindow(2);
-  Id window_1_3 = ws_client1()->NewWindow(3);
+  ASSERT_TRUE(wt_client1()->NewWindow(1));
+  Id window_1_2 = wt_client1()->NewWindow(2);
+  Id window_1_3 = wt_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(window_1_3);
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Make 3 a child of 2.
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_3));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_2, window_1_3));
 
   // Try to make 2 a child of 3, this should fail since 2 is an ancestor of 3.
-  EXPECT_FALSE(ws_client1()->AddWindow(window_1_3, window_1_2));
+  EXPECT_FALSE(wt_client1()->AddWindow(window_1_3, window_1_2));
 }
 
 // Verifies adding to root sends right notifications.
 TEST_F(WindowTreeAppTest, AddToRoot) {
   // Create the embed point now so that the ids line up.
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
-  Id window_1_21 = ws_client1()->NewWindow(21);
-  Id window_1_3 = ws_client1()->NewWindow(3);
+  Id window_1_21 = wt_client1()->NewWindow(21);
+  Id window_1_3 = wt_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_21);
   ASSERT_TRUE(window_1_3);
 
@@ -838,42 +838,42 @@ TEST_F(WindowTreeAppTest, AddToRoot) {
   changes2()->clear();
 
   // Make 3 a child of 21.
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_21, window_1_3));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_21, window_1_3));
 
   // Make 21 a child of 1.
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_21));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_21));
 
   // Connection 2 should not be told anything (because the window is from a
   // different connection). Create a window to ensure we got a response from
   // the server.
-  ASSERT_TRUE(ws_client2()->NewWindow(100));
+  ASSERT_TRUE(wt_client2()->NewWindow(100));
   EXPECT_TRUE(changes2()->empty());
 }
 
 // Verifies HierarchyChanged is correctly sent for various adds/removes.
 TEST_F(WindowTreeAppTest, WindowHierarchyChangedWindows) {
   // Create the embed point now so that the ids line up.
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   // 1,2->1,11.
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, true));
-  Id window_1_11 = ws_client1()->NewWindow(11);
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_2, true));
+  Id window_1_11 = wt_client1()->NewWindow(11);
   ASSERT_TRUE(window_1_11);
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_11, true));
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_11));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_11, true));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_2, window_1_11));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
 
-  ASSERT_TRUE(ws_client2()->WaitForAllMessages());
+  ASSERT_TRUE(wt_client2()->WaitForAllMessages());
   changes2()->clear();
 
   // 1,1->1,2->1,11
   {
     // Client 2 should not get anything (1,2 is from another connection).
-    ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
-    ASSERT_TRUE(ws_client2()->WaitForAllMessages());
+    ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_2));
+    ASSERT_TRUE(wt_client2()->WaitForAllMessages());
     EXPECT_TRUE(changes2()->empty());
   }
 
@@ -881,8 +881,8 @@ TEST_F(WindowTreeAppTest, WindowHierarchyChangedWindows) {
   {
     // Client 2 is now connected to the root, so it should have gotten a drawn
     // notification.
-    ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-    ws_client2_->WaitForChangeCount(1u);
+    ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+    wt_client2_->WaitForChangeCount(1u);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_1) + " drawn=true",
         SingleChangeToDescription(*changes2()));
@@ -893,29 +893,29 @@ TEST_F(WindowTreeAppTest, WindowHierarchyChangedWindows) {
     // Client 2 is no longer connected to the root, should get drawn state
     // changed.
     changes2()->clear();
-    ASSERT_TRUE(ws_client1()->RemoveWindowFromParent(window_1_1));
-    ws_client2_->WaitForChangeCount(1);
+    ASSERT_TRUE(wt_client1()->RemoveWindowFromParent(window_1_1));
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_1) + " drawn=false",
         SingleChangeToDescription(*changes2()));
   }
 
   // 1,1->1,2->1,11->1,111.
-  Id window_1_111 = ws_client1()->NewWindow(111);
+  Id window_1_111 = wt_client1()->NewWindow(111);
   ASSERT_TRUE(window_1_111);
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_111, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_111, true));
   {
     changes2()->clear();
-    ASSERT_TRUE(ws_client1()->AddWindow(window_1_11, window_1_111));
-    ASSERT_TRUE(ws_client2()->WaitForAllMessages());
+    ASSERT_TRUE(wt_client1()->AddWindow(window_1_11, window_1_111));
+    ASSERT_TRUE(wt_client2()->WaitForAllMessages());
     EXPECT_TRUE(changes2()->empty());
   }
 
   // 0,1->1,1->1,2->1,11->1,111
   {
     changes2()->clear();
-    ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-    ws_client2_->WaitForChangeCount(1);
+    ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_1) + " drawn=true",
         SingleChangeToDescription(*changes2()));
@@ -928,24 +928,24 @@ TEST_F(WindowTreeAppTest, WindowHierarchyChangedAddingKnownToUnknown) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
-  Id window_2_11 = ws_client2()->NewWindow(11);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  Id window_2_21 = ws_client2()->NewWindow(21);
+  Id window_2_11 = wt_client2()->NewWindow(11);
+  Id window_2_2 = wt_client2()->NewWindow(2);
+  Id window_2_21 = wt_client2()->NewWindow(21);
   ASSERT_TRUE(window_2_11);
   ASSERT_TRUE(window_2_2);
   ASSERT_TRUE(window_2_21);
 
   // Set up the hierarchy.
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_11));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_21));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_11));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_2, window_2_21));
 
   // Remove 11, should result in a hierarchy change for the root.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->RemoveWindowFromParent(window_2_11));
+    ASSERT_TRUE(wt_client2()->RemoveWindowFromParent(window_2_11));
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     // 2,1 should be IdToString(window_2_11), but window_2_11 is in the id
     // space of client2, not client1.
     EXPECT_EQ("HierarchyChanged window=2,1 new_parent=null old_parent=" +
@@ -956,8 +956,8 @@ TEST_F(WindowTreeAppTest, WindowHierarchyChangedAddingKnownToUnknown) {
   // Add 2 to 1.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-    ws_client1_->WaitForChangeCount(1);
+    ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_2));
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_2) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
@@ -973,14 +973,14 @@ TEST_F(WindowTreeAppTest, WindowHierarchyChangedAddingKnownToUnknown) {
 TEST_F(WindowTreeAppTest, ReorderWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
-  Id window_2_1 = ws_client2()->NewWindow(1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  Id window_2_3 = ws_client2()->NewWindow(3);
-  Id window_1_4 = ws_client1()->NewWindow(4);  // Peer to 1,1
-  Id window_1_5 = ws_client1()->NewWindow(5);  // Peer to 1,1
-  Id window_2_6 = ws_client2()->NewWindow(6);  // Child of 1,2.
-  Id window_2_7 = ws_client2()->NewWindow(7);  // Unparented.
-  Id window_2_8 = ws_client2()->NewWindow(8);  // Unparented.
+  Id window_2_1 = wt_client2()->NewWindow(1);
+  Id window_2_2 = wt_client2()->NewWindow(2);
+  Id window_2_3 = wt_client2()->NewWindow(3);
+  Id window_1_4 = wt_client1()->NewWindow(4);  // Peer to 1,1
+  Id window_1_5 = wt_client1()->NewWindow(5);  // Peer to 1,1
+  Id window_2_6 = wt_client2()->NewWindow(6);  // Child of 1,2.
+  Id window_2_7 = wt_client2()->NewWindow(7);  // Unparented.
+  Id window_2_8 = wt_client2()->NewWindow(8);  // Unparented.
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
   ASSERT_TRUE(window_2_3);
@@ -990,20 +990,20 @@ TEST_F(WindowTreeAppTest, ReorderWindow) {
   ASSERT_TRUE(window_2_7);
   ASSERT_TRUE(window_2_8);
 
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_2));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_6));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_3));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_4));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_5));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_1, window_2_2));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_2, window_2_6));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_1, window_2_3));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_4));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_5));
   ASSERT_TRUE(
-      ws_client2()->AddWindow(BuildWindowId(connection_id_1(), 1), window_2_1));
+      wt_client2()->AddWindow(BuildWindowId(connection_id_1(), 1), window_2_1));
 
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
+    ASSERT_TRUE(wt_client2()->ReorderWindow(window_2_2, window_2_3,
                                             mojom::OrderDirection::ABOVE));
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("Reordered window=" + IdToString(window_2_2) + " relative=" +
                   IdToString(window_2_3) + " direction=above",
               SingleChangeToDescription(*changes1()));
@@ -1011,34 +1011,34 @@ TEST_F(WindowTreeAppTest, ReorderWindow) {
 
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
+    ASSERT_TRUE(wt_client2()->ReorderWindow(window_2_2, window_2_3,
                                             mojom::OrderDirection::BELOW));
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("Reordered window=" + IdToString(window_2_2) + " relative=" +
                   IdToString(window_2_3) + " direction=below",
               SingleChangeToDescription(*changes1()));
   }
 
   // view2 is already below view3.
-  EXPECT_FALSE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
+  EXPECT_FALSE(wt_client2()->ReorderWindow(window_2_2, window_2_3,
                                            mojom::OrderDirection::BELOW));
 
   // view4 & 5 are unknown to connection2_.
-  EXPECT_FALSE(ws_client2()->ReorderWindow(window_1_4, window_1_5,
+  EXPECT_FALSE(wt_client2()->ReorderWindow(window_1_4, window_1_5,
                                            mojom::OrderDirection::ABOVE));
 
   // view6 & view3 have different parents.
-  EXPECT_FALSE(ws_client1()->ReorderWindow(window_2_3, window_2_6,
+  EXPECT_FALSE(wt_client1()->ReorderWindow(window_2_3, window_2_6,
                                            mojom::OrderDirection::ABOVE));
 
   // Non-existent window-ids
-  EXPECT_FALSE(ws_client1()->ReorderWindow(BuildWindowId(connection_id_1(), 27),
+  EXPECT_FALSE(wt_client1()->ReorderWindow(BuildWindowId(connection_id_1(), 27),
                                            BuildWindowId(connection_id_1(), 28),
                                            mojom::OrderDirection::ABOVE));
 
   // view7 & view8 are un-parented.
-  EXPECT_FALSE(ws_client1()->ReorderWindow(window_2_7, window_2_8,
+  EXPECT_FALSE(wt_client1()->ReorderWindow(window_2_7, window_2_8,
                                            mojom::OrderDirection::ABOVE));
 }
 
@@ -1046,14 +1046,14 @@ TEST_F(WindowTreeAppTest, ReorderWindow) {
 TEST_F(WindowTreeAppTest, DeleteWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
 
   // Make 2 a child of 1.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-    ws_client1_->WaitForChangeCount(1);
+    ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
@@ -1063,10 +1063,10 @@ TEST_F(WindowTreeAppTest, DeleteWindow) {
   {
     changes1()->clear();
     changes2()->clear();
-    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
+    ASSERT_TRUE(wt_client2()->DeleteWindow(window_2_1));
     EXPECT_TRUE(changes2()->empty());
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
               SingleChangeToDescription(*changes1()));
   }
@@ -1075,7 +1075,7 @@ TEST_F(WindowTreeAppTest, DeleteWindow) {
 // Verifies DeleteWindow isn't allowed from a separate connection.
 TEST_F(WindowTreeAppTest, DeleteWindowFromAnotherConnectionDisallowed) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
-  EXPECT_FALSE(ws_client2()->DeleteWindow(BuildWindowId(connection_id_1(), 1)));
+  EXPECT_FALSE(wt_client2()->DeleteWindow(BuildWindowId(connection_id_1(), 1)));
 }
 
 // Verifies if a window was deleted and then reused that other clients are
@@ -1083,14 +1083,14 @@ TEST_F(WindowTreeAppTest, DeleteWindowFromAnotherConnectionDisallowed) {
 TEST_F(WindowTreeAppTest, ReuseDeletedWindowId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
 
   // Add 2 to 1.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-    ws_client1_->WaitForChangeCount(1);
+    ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
@@ -1101,21 +1101,21 @@ TEST_F(WindowTreeAppTest, ReuseDeletedWindowId) {
   // Delete 2.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
+    ASSERT_TRUE(wt_client2()->DeleteWindow(window_2_1));
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
               SingleChangeToDescription(*changes1()));
   }
 
   // Create 2 again, and add it back to 1. Should get the same notification.
-  window_2_1 = ws_client2()->NewWindow(2);
+  window_2_1 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_1);
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+    ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
 
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
@@ -1130,23 +1130,23 @@ TEST_F(WindowTreeAppTest, GetWindowTree) {
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
   // Create 11 in first connection and make it a child of 1.
-  Id window_1_11 = ws_client1()->NewWindow(11);
+  Id window_1_11 = wt_client1()->NewWindow(11);
   ASSERT_TRUE(window_1_11);
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_11));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_11));
 
   // Create two windows in second connection, 2 and 3, both children of 1.
-  Id window_2_1 = ws_client2()->NewWindow(1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
+  Id window_2_1 = wt_client2()->NewWindow(1);
+  Id window_2_2 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_2));
 
   // Verifies GetWindowTree() on the root. The root connection sees all.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), root_window_id(), &windows);
+    GetWindowTree(wt1(), root_window_id(), &windows);
     ASSERT_EQ(5u, windows.size());
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId),
               windows[0].ToString());
@@ -1160,12 +1160,12 @@ TEST_F(WindowTreeAppTest, GetWindowTree) {
               windows[4].ToString());
   }
 
-  // Verifies GetWindowTree() on the window 1,1 from ws2(). ws2() sees 1,1 as
+  // Verifies GetWindowTree() on the window 1,1 from wt2(). wt2() sees 1,1 as
   // 1,1
-  // is ws2()'s root and ws2() sees all the windows it created.
+  // is wt2()'s root and wt2() sees all the windows it created.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_1_1, &windows);
+    GetWindowTree(wt2(), window_1_1, &windows);
     ASSERT_EQ(3u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               windows[0].ToString());
@@ -1178,43 +1178,43 @@ TEST_F(WindowTreeAppTest, GetWindowTree) {
   // Connection 2 shouldn't be able to get the root tree.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), root_window_id(), &windows);
+    GetWindowTree(wt2(), root_window_id(), &windows);
     ASSERT_EQ(0u, windows.size());
   }
 }
 
 TEST_F(WindowTreeAppTest, SetWindowBounds) {
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   changes2()->clear();
 
-  ws_client2_->set_track_root_bounds_changes(true);
+  wt_client2_->set_track_root_bounds_changes(true);
 
-  ws1()->SetWindowBounds(10, window_1_1,
+  wt1()->SetWindowBounds(10, window_1_1,
                          mojo::Rect::From(gfx::Rect(0, 0, 100, 100)));
-  ASSERT_TRUE(ws_client1()->WaitForChangeCompleted(10));
+  ASSERT_TRUE(wt_client1()->WaitForChangeCompleted(10));
 
-  ws_client2_->WaitForChangeCount(1);
+  wt_client2_->WaitForChangeCount(1);
   EXPECT_EQ("BoundsChanged window=" + IdToString(window_1_1) +
                 " old_bounds=0,0 0x0 new_bounds=0,0 100x100",
             SingleChangeToDescription(*changes2()));
 
   // Should not be possible to change the bounds of a window created by another
   // connection.
-  ws2()->SetWindowBounds(11, window_1_1,
+  wt2()->SetWindowBounds(11, window_1_1,
                          mojo::Rect::From(gfx::Rect(0, 0, 0, 0)));
-  ASSERT_FALSE(ws_client2()->WaitForChangeCompleted(11));
+  ASSERT_FALSE(wt_client2()->WaitForChangeCompleted(11));
 }
 
 // Verify AddWindow fails when trying to manipulate windows in other roots.
 TEST_F(WindowTreeAppTest, CantMoveWindowsFromOtherRoot) {
   // Create 1 and 2 in the first connection.
-  Id window_1_1 = ws_client1()->NewWindow(1);
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_1 = wt_client1()->NewWindow(1);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(window_1_2);
 
@@ -1222,47 +1222,47 @@ TEST_F(WindowTreeAppTest, CantMoveWindowsFromOtherRoot) {
 
   // Try to move 2 to be a child of 1 from connection 2. This should fail as 2
   // should not be able to access 1.
-  ASSERT_FALSE(ws_client2()->AddWindow(window_1_1, window_1_2));
+  ASSERT_FALSE(wt_client2()->AddWindow(window_1_1, window_1_2));
 
   // Try to reparent 1 to the root. A connection is not allowed to reparent its
   // roots.
-  ASSERT_FALSE(ws_client2()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_FALSE(wt_client2()->AddWindow(root_window_id(), window_1_1));
 }
 
 // Verify RemoveWindowFromParent fails for windows that are descendants of the
 // roots.
 TEST_F(WindowTreeAppTest, CantRemoveWindowsInOtherRoots) {
   // Create 1 and 2 in the first connection and parent both to the root.
-  Id window_1_1 = ws_client1()->NewWindow(1);
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_1 = wt_client1()->NewWindow(1);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(window_1_2);
 
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_2));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_2));
 
   // Establish the second connection and give it the root 1.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Connection 2 should not be able to remove window 2 or 1 from its parent.
-  ASSERT_FALSE(ws_client2()->RemoveWindowFromParent(window_1_2));
-  ASSERT_FALSE(ws_client2()->RemoveWindowFromParent(window_1_1));
+  ASSERT_FALSE(wt_client2()->RemoveWindowFromParent(window_1_2));
+  ASSERT_FALSE(wt_client2()->RemoveWindowFromParent(window_1_1));
 
   // Create windows 10 and 11 in 2.
-  Id window_2_10 = ws_client2()->NewWindow(10);
-  Id window_2_11 = ws_client2()->NewWindow(11);
+  Id window_2_10 = wt_client2()->NewWindow(10);
+  Id window_2_11 = wt_client2()->NewWindow(11);
   ASSERT_TRUE(window_2_10);
   ASSERT_TRUE(window_2_11);
 
   // Parent 11 to 10.
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_10, window_2_11));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_10, window_2_11));
   // Remove 11 from 10.
-  ASSERT_TRUE(ws_client2()->RemoveWindowFromParent(window_2_11));
+  ASSERT_TRUE(wt_client2()->RemoveWindowFromParent(window_2_11));
 
   // Verify nothing was actually removed.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), root_window_id(), &windows);
+    GetWindowTree(wt1(), root_window_id(), &windows);
     ASSERT_EQ(3u, windows.size());
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId),
               windows[0].ToString());
@@ -1276,28 +1276,28 @@ TEST_F(WindowTreeAppTest, CantRemoveWindowsInOtherRoots) {
 // Verify GetWindowTree fails for windows that are not descendants of the roots.
 TEST_F(WindowTreeAppTest, CantGetWindowTreeOfOtherRoots) {
   // Create 1 and 2 in the first connection and parent both to the root.
-  Id window_1_1 = ws_client1()->NewWindow(1);
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_1 = wt_client1()->NewWindow(1);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(window_1_2);
 
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_2));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_2));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   std::vector<TestWindow> windows;
 
   // Should get nothing for the root.
-  GetWindowTree(ws2(), root_window_id(), &windows);
+  GetWindowTree(wt2(), root_window_id(), &windows);
   ASSERT_TRUE(windows.empty());
 
   // Should get nothing for window 2.
-  GetWindowTree(ws2(), window_1_2, &windows);
+  GetWindowTree(wt2(), window_1_2, &windows);
   ASSERT_TRUE(windows.empty());
 
   // Should get window 1 if asked for.
-  GetWindowTree(ws2(), window_1_1, &windows);
+  GetWindowTree(wt2(), window_1_1, &windows);
   ASSERT_EQ(1u, windows.size());
   EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
             windows[0].ToString());
@@ -1308,11 +1308,11 @@ TEST_F(WindowTreeAppTest, EmbedWithSameWindowId) {
   changes2()->clear();
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_1_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt1(), window_1_1));
 
   // Connection2 should have been told of the unembed and delete.
   {
-    ws_client2_->WaitForChangeCount(2);
+    wt_client2_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes2())[0]);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_1_1),
@@ -1322,7 +1322,7 @@ TEST_F(WindowTreeAppTest, EmbedWithSameWindowId) {
   // Connection2 has no root. Verify it can't see window 1,1 anymore.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws2(), window_1_1, &windows);
+    GetWindowTree(wt2(), window_1_1, &windows);
     EXPECT_TRUE(windows.empty());
   }
 }
@@ -1332,20 +1332,20 @@ TEST_F(WindowTreeAppTest, EmbedWithSameWindowId2) {
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   changes2()->clear();
 
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_1_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt1(), window_1_1));
 
   // Connection2 should have been told about the unembed and delete.
-  ws_client2_->WaitForChangeCount(2);
+  wt_client2_->WaitForChangeCount(2);
   changes2()->clear();
 
   // Create a window in the third connection and parent it to the root.
-  Id window_3_1 = ws_client3()->NewWindow(1);
+  Id window_3_1 = wt_client3()->NewWindow(1);
   ASSERT_TRUE(window_3_1);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_1_1, window_3_1));
+  ASSERT_TRUE(wt_client3()->AddWindow(window_1_1, window_3_1));
 
   // Connection 1 should have been told about the add (it owns the window).
   {
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_3_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
@@ -1357,40 +1357,40 @@ TEST_F(WindowTreeAppTest, EmbedWithSameWindowId2) {
 
     // We should get a new connection for the new embedding.
     scoped_ptr<TestWindowTreeClientImpl> connection4(
-        EstablishConnectionViaEmbed(ws1(), window_1_1, nullptr));
+        EstablishConnectionViaEmbed(wt1(), window_1_1, nullptr));
     ASSERT_TRUE(connection4.get());
     EXPECT_EQ("[" + WindowParentToString(window_1_1, kNullParentId) + "]",
               ChangeWindowDescription(*connection4->tracker()->changes()));
 
     // And 3 should get an unembed and delete.
-    ws_client3_->WaitForChangeCount(2);
+    wt_client3_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes3())[0]);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes3())[1]);
   }
 
-  // ws3() has no root. Verify it can't see window 1,1 anymore.
+  // wt3() has no root. Verify it can't see window 1,1 anymore.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws3(), window_1_1, &windows);
+    GetWindowTree(wt3(), window_1_1, &windows);
     EXPECT_TRUE(windows.empty());
   }
 
   // Verify 3,1 is no longer parented to 1,1. We have to do this from 1,1 as
-  // ws3() can no longer see 1,1.
+  // wt3() can no longer see 1,1.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(1u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               windows[0].ToString());
   }
 
-  // Verify ws3() can still see the window it created 3,1.
+  // Verify wt3() can still see the window it created 3,1.
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws3(), window_3_1, &windows);
+    GetWindowTree(wt3(), window_3_1, &windows);
     ASSERT_EQ(1u, windows.size());
     EXPECT_EQ(WindowParentToString(window_3_1, kNullParentId),
               windows[0].ToString());
@@ -1400,15 +1400,15 @@ TEST_F(WindowTreeAppTest, EmbedWithSameWindowId2) {
 // Assertions for SetWindowVisibility.
 TEST_F(WindowTreeAppTest, SetWindowVisibility) {
   // Create 1 and 2 in the first connection and parent both to the root.
-  Id window_1_1 = ws_client1()->NewWindow(1);
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_1 = wt_client1()->NewWindow(1);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(window_1_2);
 
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), root_window_id(), &windows);
+    GetWindowTree(wt1(), root_window_id(), &windows);
     ASSERT_EQ(2u, windows.size());
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId) +
                   " visible=true drawn=true",
@@ -1419,11 +1419,11 @@ TEST_F(WindowTreeAppTest, SetWindowVisibility) {
   }
 
   // Show all the windows.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_2, true));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), root_window_id(), &windows);
+    GetWindowTree(wt1(), root_window_id(), &windows);
     ASSERT_EQ(2u, windows.size());
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId) +
                   " visible=true drawn=true",
@@ -1434,10 +1434,10 @@ TEST_F(WindowTreeAppTest, SetWindowVisibility) {
   }
 
   // Hide 1.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, false));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, false));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(1u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()) +
                   " visible=false drawn=false",
@@ -1445,10 +1445,10 @@ TEST_F(WindowTreeAppTest, SetWindowVisibility) {
   }
 
   // Attach 2 to 1.
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_2));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(2u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()) +
                   " visible=false drawn=false",
@@ -1459,10 +1459,10 @@ TEST_F(WindowTreeAppTest, SetWindowVisibility) {
   }
 
   // Show 1.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(2u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()) +
                   " visible=true drawn=true",
@@ -1481,8 +1481,8 @@ TEST_F(WindowTreeAppTest, SetCursor) {
   changes2()->clear();
 
   ASSERT_TRUE(
-      ws_client1()->SetPredefinedCursor(window_1_1, mojom::Cursor::IBEAM));
-  ws_client2_->WaitForChangeCount(1u);
+      wt_client1()->SetPredefinedCursor(window_1_1, mojom::Cursor::IBEAM));
+  wt_client2_->WaitForChangeCount(1u);
 
   EXPECT_EQ("CursorChanged id=" + IdToString(window_1_1) + " cursor_id=4",
             SingleChangeToDescription(*changes2()));
@@ -1491,30 +1491,30 @@ TEST_F(WindowTreeAppTest, SetCursor) {
 // Assertions for SetWindowVisibility sending notifications.
 TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
   // Create 1,1 and 1,2. 1,2 is made a child of 1,1 and 1,1 a child of the root.
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, true));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_2, true));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_2));
 
   // Establish the second connection at 1,2.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnectionWithRoot(window_1_2));
 
   // Add 2,3 as a child of 1,2.
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
-  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_1, true));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_2, window_2_1));
-  ASSERT_TRUE(ws_client1()->WaitForAllMessages());
+  ASSERT_TRUE(wt_client2()->SetWindowVisibility(window_2_1, true));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_2, window_2_1));
+  ASSERT_TRUE(wt_client1()->WaitForAllMessages());
 
   changes2()->clear();
   // Hide 1,2 from connection 1. Connection 2 should see this.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, false));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_2, false));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "VisibilityChanged window=" + IdToString(window_1_2) + " visible=false",
         SingleChangeToDescription(*changes2()));
@@ -1522,9 +1522,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   changes1()->clear();
   // Show 1,2 from connection 2, connection 1 should be notified.
-  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_1_2, true));
+  ASSERT_TRUE(wt_client2()->SetWindowVisibility(window_1_2, true));
   {
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ(
         "VisibilityChanged window=" + IdToString(window_1_2) + " visible=true",
         SingleChangeToDescription(*changes1()));
@@ -1532,9 +1532,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   changes2()->clear();
   // Hide 1,1, connection 2 should be told the draw state changed.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, false));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, false));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=false",
         SingleChangeToDescription(*changes2()));
@@ -1542,9 +1542,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   changes2()->clear();
   // Show 1,1 from connection 1. Connection 2 should see this.
-  ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
+  ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=true",
         SingleChangeToDescription(*changes2()));
@@ -1552,9 +1552,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   // Change visibility of 2,3, connection 1 should see this.
   changes1()->clear();
-  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_1, false));
+  ASSERT_TRUE(wt_client2()->SetWindowVisibility(window_2_1, false));
   {
-    ws_client1_->WaitForChangeCount(1);
+    wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ(
         "VisibilityChanged window=" + IdToString(window_2_1) + " visible=false",
         SingleChangeToDescription(*changes1()));
@@ -1562,9 +1562,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   changes2()->clear();
   // Remove 1,1 from the root, connection 2 should see drawn state changed.
-  ASSERT_TRUE(ws_client1()->RemoveWindowFromParent(window_1_1));
+  ASSERT_TRUE(wt_client1()->RemoveWindowFromParent(window_1_1));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=false",
         SingleChangeToDescription(*changes2()));
@@ -1572,9 +1572,9 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 
   changes2()->clear();
   // Add 1,1 back to the root, connection 2 should see drawn state changed.
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=true",
         SingleChangeToDescription(*changes2()));
@@ -1582,16 +1582,16 @@ TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
 }
 
 TEST_F(WindowTreeAppTest, SetWindowProperty) {
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   changes2()->clear();
 
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), root_window_id(), &windows);
+    GetWindowTree(wt1(), root_window_id(), &windows);
     ASSERT_EQ(2u, windows.size());
     EXPECT_EQ(root_window_id(), windows[0].window_id);
     EXPECT_EQ(window_1_1, windows[1].window_id);
@@ -1601,9 +1601,9 @@ TEST_F(WindowTreeAppTest, SetWindowProperty) {
   // Set properties on 1.
   changes2()->clear();
   std::vector<uint8_t> one(1, '1');
-  ASSERT_TRUE(ws_client1()->SetWindowProperty(window_1_1, "one", &one));
+  ASSERT_TRUE(wt_client1()->SetWindowProperty(window_1_1, "one", &one));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "PropertyChanged window=" + IdToString(window_1_1) + " key=one value=1",
         SingleChangeToDescription(*changes2()));
@@ -1612,7 +1612,7 @@ TEST_F(WindowTreeAppTest, SetWindowProperty) {
   // Test that our properties exist in the window tree
   {
     std::vector<TestWindow> windows;
-    GetWindowTree(ws1(), window_1_1, &windows);
+    GetWindowTree(wt1(), window_1_1, &windows);
     ASSERT_EQ(1u, windows.size());
     ASSERT_EQ(1u, windows[0].properties.size());
     EXPECT_EQ(one, windows[0].properties["one"]);
@@ -1620,9 +1620,9 @@ TEST_F(WindowTreeAppTest, SetWindowProperty) {
 
   changes2()->clear();
   // Set back to null.
-  ASSERT_TRUE(ws_client1()->SetWindowProperty(window_1_1, "one", NULL));
+  ASSERT_TRUE(wt_client1()->SetWindowProperty(window_1_1, "one", NULL));
   {
-    ws_client2_->WaitForChangeCount(1);
+    wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ("PropertyChanged window=" + IdToString(window_1_1) +
                   " key=one value=NULL",
               SingleChangeToDescription(*changes2()));
@@ -1633,24 +1633,24 @@ TEST_F(WindowTreeAppTest, OnEmbeddedAppDisconnected) {
   // Create connection 2 and 3.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
   changes2()->clear();
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_1));
 
   // Connection 1 should get a hierarchy change for window_2_1.
-  ws_client1_->WaitForChangeCount(1);
+  wt_client1_->WaitForChangeCount(1);
   changes1()->clear();
 
   // Close connection 3. Connection 2 (which had previously embedded 3) should
   // be notified of this.
-  ws_client3_.reset();
-  ws_client2_->WaitForChangeCount(1);
+  wt_client3_.reset();
+  wt_client2_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes2()));
 
-  ws_client1_->WaitForChangeCount(1);
+  wt_client1_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes1()));
 }
@@ -1661,20 +1661,20 @@ TEST_F(WindowTreeAppTest, OnParentOfEmbedDisconnects) {
   // Create connection 2 and 3.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  Id window_2_1 = ws_client2()->NewWindow(1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  Id window_2_1 = wt_client2()->NewWindow(1);
+  Id window_2_2 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_2));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_2_1, window_2_2));
   changes2()->clear();
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_2));
   changes3()->clear();
 
   // Close connection 2. Connection 3 should get a delete (for its root).
-  ws_client2_.reset();
-  ws_client3_->WaitForChangeCount(1);
+  wt_client2_.reset();
+  wt_client3_->WaitForChangeCount(1);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
             SingleChangeToDescription(*changes3()));
 }
@@ -1684,25 +1684,25 @@ TEST_F(WindowTreeAppTest, OnParentOfEmbedDisconnects) {
 TEST_F(WindowTreeAppTest, DontCleanMapOnDestroy) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  ASSERT_TRUE(ws_client2()->NewWindow(1));
+  ASSERT_TRUE(wt_client2()->NewWindow(1));
   changes1()->clear();
-  ws_client2_.reset();
-  ws_client1_->WaitForChangeCount(1);
+  wt_client2_.reset();
+  wt_client1_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_1_1),
             SingleChangeToDescription(*changes1()));
   std::vector<TestWindow> windows;
-  GetWindowTree(ws1(), window_1_1, &windows);
+  GetWindowTree(wt1(), window_1_1, &windows);
   EXPECT_FALSE(windows.empty());
 }
 
 // Verifies Embed() works when supplying a WindowTreeClient.
 TEST_F(WindowTreeAppTest, EmbedSupplyingWindowTreeClient) {
-  ASSERT_TRUE(ws_client1()->NewWindow(1));
+  ASSERT_TRUE(wt_client1()->NewWindow(1));
 
   TestWindowTreeClientImpl client2;
   mojom::WindowTreeClientPtr client2_ptr;
   mojo::Binding<WindowTreeClient> client2_binding(&client2, &client2_ptr);
-  ASSERT_TRUE(Embed(ws1(), BuildWindowId(connection_id_1(), 1),
+  ASSERT_TRUE(Embed(wt1(), BuildWindowId(connection_id_1(), 1),
                     std::move(client2_ptr)));
   client2.WaitForOnEmbed();
   EXPECT_EQ("OnEmbed",
@@ -1713,19 +1713,19 @@ TEST_F(WindowTreeAppTest, EmbedFailsFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_1));
 
-  Id window_3_3 = ws_client3()->NewWindow(3);
+  Id window_3_3 = wt_client3()->NewWindow(3);
   ASSERT_TRUE(window_3_3);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_2_1, window_3_3));
+  ASSERT_TRUE(wt_client3()->AddWindow(window_2_1, window_3_3));
 
   // 2 should not be able to embed in window_3_3 as window_3_3 was not created
   // by
   // 2.
-  EXPECT_FALSE(EmbedUrl(connector(), ws2(), test_name(), window_3_3));
+  EXPECT_FALSE(EmbedUrl(connector(), wt2(), test_name(), window_3_3));
 }
 
 // Verifies Embed() from window manager on another connections window works.
@@ -1733,22 +1733,22 @@ TEST_F(WindowTreeAppTest, EmbedFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_1 = ws_client2()->NewWindow(1);
+  Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
 
   changes2()->clear();
 
   // Establish a third connection in window_2_1.
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_2_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt1(), window_2_1));
 
-  ASSERT_TRUE(ws_client2()->WaitForAllMessages());
+  ASSERT_TRUE(wt_client2()->WaitForAllMessages());
   EXPECT_EQ(std::string(), SingleChangeToDescription(*changes2()));
 }
 
 TEST_F(WindowTreeAppTest, CantEmbedFromConnectionRoot) {
   // Shouldn't be able to embed into the root.
-  ASSERT_FALSE(EmbedUrl(connector(), ws1(), test_name(), root_window_id()));
+  ASSERT_FALSE(EmbedUrl(connector(), wt1(), test_name(), root_window_id()));
 
   // Even though the call above failed a WindowTreeClient was obtained. We need
   // to
@@ -1757,24 +1757,24 @@ TEST_F(WindowTreeAppTest, CantEmbedFromConnectionRoot) {
 
   // Don't allow a connection to embed into its own root.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
-  EXPECT_FALSE(EmbedUrl(connector(), ws2(), test_name(),
+  EXPECT_FALSE(EmbedUrl(connector(), wt2(), test_name(),
                         BuildWindowId(connection_id_1(), 1)));
 
   // Need to wait for a WindowTreeClient for same reason as above.
   WaitForWindowTreeClient();
 
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(
-      ws_client1()->AddWindow(BuildWindowId(connection_id_1(), 1), window_1_2));
-  ASSERT_TRUE(ws_client3_.get() == nullptr);
-  ws_client3_ = EstablishConnectionViaEmbedWithPolicyBitmask(
-      ws1(), window_1_2, mojom::WindowTree::kAccessPolicyEmbedRoot, nullptr);
-  ASSERT_TRUE(ws_client3_.get() != nullptr);
+      wt_client1()->AddWindow(BuildWindowId(connection_id_1(), 1), window_1_2));
+  ASSERT_TRUE(wt_client3_.get() == nullptr);
+  wt_client3_ = EstablishConnectionViaEmbedWithPolicyBitmask(
+      wt1(), window_1_2, mojom::WindowTree::kAccessPolicyEmbedRoot, nullptr);
+  ASSERT_TRUE(wt_client3_.get() != nullptr);
 
   // window_1_2 is ws3's root, so even though v3 is an embed root it should not
   // be able to Embed into itself.
-  ASSERT_FALSE(EmbedUrl(connector(), ws3(), test_name(), window_1_2));
+  ASSERT_FALSE(EmbedUrl(connector(), wt3(), test_name(), window_1_2));
 }
 
 // Verifies that a transient window tracks its parent's lifetime.
@@ -1782,24 +1782,24 @@ TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
-  Id window_2_1 = ws_client2()->NewWindow(1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  Id window_2_3 = ws_client2()->NewWindow(3);
+  Id window_2_1 = wt_client2()->NewWindow(1);
+  Id window_2_2 = wt_client2()->NewWindow(2);
+  Id window_2_3 = wt_client2()->NewWindow(3);
   ASSERT_TRUE(window_2_1);
 
   // root -> window_1_1 -> window_2_1
   // root -> window_1_1 -> window_2_2
   // root -> window_1_1 -> window_2_3
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_3));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_2));
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_3));
 
   // window_2_2 and window_2_3 now track the lifetime of window_2_1.
   changes1()->clear();
-  ws2()->AddTransientWindow(10, window_2_1, window_2_2);
-  ws2()->AddTransientWindow(11, window_2_1, window_2_3);
-  ws_client1()->WaitForChangeCount(2);
+  wt2()->AddTransientWindow(10, window_2_1, window_2_2);
+  wt2()->AddTransientWindow(11, window_2_1, window_2_3);
+  wt_client1()->WaitForChangeCount(2);
   EXPECT_EQ("AddTransientWindow parent = " + IdToString(window_2_1) +
                 " child = " + IdToString(window_2_2),
             ChangesToDescription1(*changes1())[0]);
@@ -1808,15 +1808,15 @@ TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
             ChangesToDescription1(*changes1())[1]);
 
   changes1()->clear();
-  ws2()->RemoveTransientWindowFromParent(12, window_2_3);
-  ws_client1()->WaitForChangeCount(1);
+  wt2()->RemoveTransientWindowFromParent(12, window_2_3);
+  wt_client1()->WaitForChangeCount(1);
   EXPECT_EQ("RemoveTransientWindowFromParent parent = " +
                 IdToString(window_2_1) + " child = " + IdToString(window_2_3),
             SingleChangeToDescription(*changes1()));
 
   changes1()->clear();
-  ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
-  ws_client1()->WaitForChangeCount(2);
+  ASSERT_TRUE(wt_client2()->DeleteWindow(window_2_1));
+  wt_client1()->WaitForChangeCount(2);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
             ChangesToDescription1(*changes1())[0]);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
@@ -1824,43 +1824,43 @@ TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
 }
 
 TEST_F(WindowTreeAppTest, Ids) {
-  const Id window_1_100 = ws_client1()->NewWindow(100);
+  const Id window_1_100 = wt_client1()->NewWindow(100);
   ASSERT_TRUE(window_1_100);
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_100));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_100));
 
   // Establish the second connection at 1,100.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnectionWithRoot(window_1_100));
 
-  // 1,100 is the id in the ws_client1's id space. The new client should see
+  // 1,100 is the id in the wt_client1's id space. The new client should see
   // 2,1 (the server id).
   const Id window_1_100_in_ws2 = BuildWindowId(connection_id_1(), 1);
-  EXPECT_EQ(window_1_100_in_ws2, ws_client2()->root_window_id());
+  EXPECT_EQ(window_1_100_in_ws2, wt_client2()->root_window_id());
 
   // The first window created in the second connection gets a server id of 2,1
   // regardless of the id the client uses.
-  const Id window_2_101 = ws_client2()->NewWindow(101);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_100_in_ws2, window_2_101));
+  const Id window_2_101 = wt_client2()->NewWindow(101);
+  ASSERT_TRUE(wt_client2()->AddWindow(window_1_100_in_ws2, window_2_101));
   const Id window_2_101_in_ws1 = BuildWindowId(connection_id_2(), 1);
-  ws_client1()->WaitForChangeCount(1);
+  wt_client1()->WaitForChangeCount(1);
   EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_101_in_ws1) +
                 " new_parent=" + IdToString(window_1_100) + " old_parent=null",
             SingleChangeToDescription(*changes1()));
   changes1()->clear();
 
   // Change the bounds of window_2_101 and make sure server gets it.
-  ws2()->SetWindowBounds(11, window_2_101,
+  wt2()->SetWindowBounds(11, window_2_101,
                          mojo::Rect::From(gfx::Rect(1, 2, 3, 4)));
-  ASSERT_TRUE(ws_client2()->WaitForChangeCompleted(11));
-  ws_client1()->WaitForChangeCount(1);
+  ASSERT_TRUE(wt_client2()->WaitForChangeCompleted(11));
+  wt_client1()->WaitForChangeCount(1);
   EXPECT_EQ("BoundsChanged window=" + IdToString(window_2_101_in_ws1) +
                 " old_bounds=0,0 0x0 new_bounds=1,2 3x4",
             SingleChangeToDescription(*changes1()));
   changes2()->clear();
 
   // Remove 2_101 from wm, client1 should see the change.
-  ws1()->RemoveWindowFromParent(12, window_2_101_in_ws1);
-  ASSERT_TRUE(ws_client1()->WaitForChangeCompleted(12));
-  ws_client2()->WaitForChangeCount(1);
+  wt1()->RemoveWindowFromParent(12, window_2_101_in_ws1);
+  ASSERT_TRUE(wt_client1()->WaitForChangeCompleted(12));
+  wt_client2()->WaitForChangeCount(1);
   EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_101) +
                 " new_parent=null old_parent=" +
                 IdToString(window_1_100_in_ws2),
@@ -1870,50 +1870,50 @@ TEST_F(WindowTreeAppTest, Ids) {
 // Tests that setting capture fails when no input event has occurred, and there
 // is no notification of lost capture.
 TEST_F(WindowTreeAppTest, ExplicitCaptureWithoutInput) {
-  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_1 = wt_client1()->NewWindow(1);
 
   // Add the window to the root, so that they have a Display to handle input
   // capture.
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   changes1()->clear();
 
   // Since there has been no input, capture should not succeed. No lost capture
   // message is expected.
-  ws1()->SetCapture(1, window_1_1);
-  ws_client1_->WaitForAllMessages();
+  wt1()->SetCapture(1, window_1_1);
+  wt_client1_->WaitForAllMessages();
   EXPECT_TRUE(changes1()->empty());
 
   // Since there is no window with capture, lost capture should not be notified.
-  ws1()->ReleaseCapture(3, window_1_1);
-  ws_client1_->WaitForAllMessages();
+  wt1()->ReleaseCapture(3, window_1_1);
+  wt_client1_->WaitForAllMessages();
   EXPECT_TRUE(changes1()->empty());
 }
 
 // TODO(jonross): Enable this once apptests can send input events to the server.
 // Enabling capture requires that the connection be processing events.
 TEST_F(WindowTreeAppTest, DISABLED_ExplicitCapturePropagation) {
-  Id window_1_1 = ws_client1()->NewWindow(1);
-  Id window_1_2 = ws_client1()->NewWindow(2);
+  Id window_1_1 = wt_client1()->NewWindow(1);
+  Id window_1_2 = wt_client1()->NewWindow(2);
 
   // Add the windows to the root, so that they have a Display to handle input
   // capture.
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_2));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_2));
 
   changes1()->clear();
   // Window 1 takes capture then Window 2 takes capture.
   // Verify that window 1 has lost capture.
-  ws1()->SetCapture(1, window_1_1);
-  ws1()->SetCapture(2, window_1_2);
-  ws_client1_->WaitForChangeCount(1);
+  wt1()->SetCapture(1, window_1_1);
+  wt1()->SetCapture(2, window_1_2);
+  wt_client1_->WaitForChangeCount(1);
 
   EXPECT_EQ("OnLostCapture window=" + IdToString(window_1_1),
             SingleChangeToDescription(*changes1()));
 
   changes1()->clear();
   // Explicitly releasing capture should not notify of lost capture.
-  ws1()->ReleaseCapture(3, window_1_2);
-  ws_client1_->WaitForAllMessages();
+  wt1()->ReleaseCapture(3, window_1_2);
+  wt_client1_->WaitForAllMessages();
 
   EXPECT_TRUE(changes1()->empty());
 }