Convert mus apptests to shelltests

components/mus/ws/window_tree_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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "components/mus/public/cpp/tests/window_server_shelltest_base.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/test_change_tracker.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/shell/public/cpp/application_test_base.h"
+#include "mojo/shell/public/cpp/shell_test.h"
 
 using mojo::Array;
 using mojo::Callback;
 using mojo::Connection;
 using mojo::InterfaceRequest;
 using mojo::RectPtr;
 using mojo::ShellClient;
 using mojo::String;
 using mus::mojom::ErrorCode;
 using mus::mojom::EventPtr;
@@ skipping 435 matching lines @@
   }
 
   scoped_ptr<TestWindowTreeClientImpl> client_impl_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientFactory);
 };
 
 }  // namespace
 
-class WindowTreeAppTest : public mojo::test::ApplicationTestBase,
-                          public mojo::ShellClient {
+class WindowTreeClientTest : public WindowServerShellTestBase {
  public:
-  WindowTreeAppTest()
+  WindowTreeClientTest()
       : connection_id_1_(0), connection_id_2_(0), root_window_id_(0) {}
-  ~WindowTreeAppTest() override {}
+
+  ~WindowTreeClientTest() override {}
 
  protected:
   // Returns the changes from the various connections.
   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. |wt1()|, being the first connection, has special
   // permissions (it's treated as the window manager).
   WindowTree* wt1() { return wt_client1_->tree(); }
@@ skipping 69 matching lines @@
     }
     client->WaitForOnEmbed();
 
     EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     if (connection_id)
       *connection_id = (*client->tracker()->changes())[0].connection_id;
     return client;
   }
 
-  // ApplicationTestBase:
-  mojo::ShellClient* GetShellClient() override { return this; }
+  // WindowServerShellTestBase:
+  bool AcceptConnection(mojo::Connection* connection) override {
+    connection->AddInterface(client_factory_.get());
+    return true;
+  }
+
   void SetUp() override {
-    ApplicationTestBase::SetUp();
     client_factory_.reset(new WindowTreeClientFactory());
 
+    WindowServerShellTestBase::SetUp();
+
     mojom::WindowTreeHostFactoryPtr factory;
     connector()->ConnectToInterface("mojo:mus", &factory);
 
     mojom::WindowTreeClientPtr 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.
     wt_client1_->WaitForIncomingMethodCall();
 
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
     // All these tests assume 1 for the client id. The only real assertion here
     // is the client id is not zero, but adding this as rest of code here
     // assumes 1.
     ASSERT_GT((*changes1())[0].connection_id, 0);
     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_, wt_client1_->root_window_id());
     changes1()->clear();
   }
 
-  // mojo::ShellClient implementation.
-  bool AcceptConnection(Connection* connection) override {
-    connection->AddInterface(client_factory_.get());
-    return true;
-  }
-
   scoped_ptr<TestWindowTreeClientImpl> wt_client1_;
   scoped_ptr<TestWindowTreeClientImpl> wt_client2_;
   scoped_ptr<TestWindowTreeClientImpl> wt_client3_;
 
   mojom::WindowTreeHostPtr host_;
 
  private:
   scoped_ptr<WindowTreeClientFactory> client_factory_;
   int connection_id_1_;
   int connection_id_2_;
   Id root_window_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(WindowTreeAppTest);
+  DISALLOW_COPY_AND_ASSIGN(WindowTreeClientTest);
 };
 
 // Verifies two clients/connections get different ids.
-TEST_F(WindowTreeAppTest, TwoClientsGetDifferentConnectionIds) {
+TEST_F(WindowTreeClientTest, TwoClientsGetDifferentConnectionIds) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   ASSERT_EQ(1u, changes2()->size());
   ASSERT_NE(connection_id_1(), connection_id_2());
 }
 
 // Verifies when Embed() is invoked any child windows are removed.
-TEST_F(WindowTreeAppTest, WindowsRemovedWhenEmbedding) {
+TEST_F(WindowTreeClientTest, WindowsRemovedWhenEmbedding) {
   // Two windows 1 and 2. 2 is parented to 1.
   Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
 
   Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(wt_client1()->AddWindow(window_1_1, window_1_2));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
@@ skipping 49 matching lines @@
   // And window 4 should not be visible to connection 3.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt3(), window_2_3, &windows);
     EXPECT_EQ("no windows", SingleWindowDescription(windows));
   }
 }
 
 // Verifies once Embed() has been invoked the parent connection can't see any
 // children.
-TEST_F(WindowTreeAppTest, CantAccessChildrenOfEmbeddedWindow) {
+TEST_F(WindowTreeClientTest, CantAccessChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_2 = wt_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
   ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_2));
 
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_2));
 
   Id window_3_3 = wt_client3()->NewWindow(3);
@@ skipping 28 matching lines @@
     // but the ids are in the id space of client2, which is not the same as
     // 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).
     EXPECT_EQ("window=3,1 parent=2,1", windows[2].ToString());
   }
 }
 
 // Verifies once Embed() has been invoked the parent can't mutate the children.
-TEST_F(WindowTreeAppTest, CantModifyChildrenOfEmbeddedWindow) {
+TEST_F(WindowTreeClientTest, CantModifyChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(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_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(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 = wt_client3()->NewWindow(1);
   ASSERT_TRUE(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(wt_client2()->RemoveWindowFromParent(window_3_1));
 }
 
 // Verifies client gets a valid id.
-TEST_F(WindowTreeAppTest, NewWindow) {
+TEST_F(WindowTreeClientTest, NewWindow) {
   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, wt_client1()->NewWindowWithCompleteId(window_1_1));
   EXPECT_TRUE(changes1()->empty());
 
   // Can't create a window with a bogus connection id.
   ASSERT_EQ(0u, wt_client1()->NewWindowWithCompleteId(
                     BuildWindowId(connection_id_1() + 1, 1)));
   EXPECT_TRUE(changes1()->empty());
 }
 
 // Verifies AddWindow fails when window is already in position.
-TEST_F(WindowTreeAppTest, AddWindowWithNoChange) {
+TEST_F(WindowTreeClientTest, AddWindowWithNoChange) {
   // Create the embed point now so that the ids line up.
   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(wt_client1()->AddWindow(window_1_2, window_1_3));
 
   // Try again, this should fail.
   EXPECT_FALSE(wt_client1()->AddWindow(window_1_2, window_1_3));
 }
 
 // Verifies AddWindow fails when window is already in position.
-TEST_F(WindowTreeAppTest, AddAncestorFails) {
+TEST_F(WindowTreeClientTest, AddAncestorFails) {
   // Create the embed point now so that the ids line up.
   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(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(wt_client1()->AddWindow(window_1_3, window_1_2));
 }
 
 // Verifies adding to root sends right notifications.
-TEST_F(WindowTreeAppTest, AddToRoot) {
+TEST_F(WindowTreeClientTest, AddToRoot) {
   // Create the embed point now so that the ids line up.
   Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   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);
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   changes2()->clear();
 
   // Make 3 a child of 21.
   ASSERT_TRUE(wt_client1()->AddWindow(window_1_21, window_1_3));
 
   // Make 21 a child of 1.
   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(wt_client2()->NewWindow(100));
   EXPECT_TRUE(changes2()->empty());
 }
 
 // Verifies HierarchyChanged is correctly sent for various adds/removes.
-TEST_F(WindowTreeAppTest, WindowHierarchyChangedWindows) {
+TEST_F(WindowTreeClientTest, WindowHierarchyChangedWindows) {
   // Create the embed point now so that the ids line up.
   Id window_1_1 = wt_client1()->NewWindow(1);
   // 1,2->1,11.
   Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_2, true));
   Id window_1_11 = wt_client1()->NewWindow(11);
   ASSERT_TRUE(window_1_11);
   ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_11, true));
   ASSERT_TRUE(wt_client1()->AddWindow(window_1_2, window_1_11));
@@ skipping 50 matching lines @@
   {
     changes2()->clear();
     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()));
   }
 }
 
-TEST_F(WindowTreeAppTest, WindowHierarchyChangedAddingKnownToUnknown) {
+TEST_F(WindowTreeClientTest, WindowHierarchyChangedAddingKnownToUnknown) {
   // Create the following structure: root -> 1 -> 11 and 2->21 (2 has no
   // parent).
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
   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);
@@ skipping 27 matching lines @@
               SingleChangeToDescription(*changes1()));
     // "window=2,3 parent=2,2]" should be,
     // WindowParentToString(window_2_21, window_2_2), but isn't because of
     // differing id spaces.
     EXPECT_EQ("[" + WindowParentToString(window_2_2, window_1_1) +
                   "],[window=2,3 parent=2,2]",
               ChangeWindowDescription(*changes1()));
   }
 }
 
-TEST_F(WindowTreeAppTest, ReorderWindow) {
+TEST_F(WindowTreeClientTest, ReorderWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   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.
@@ skipping 52 matching lines @@
   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(wt_client1()->ReorderWindow(window_2_7, window_2_8,
                                            mojom::OrderDirection::ABOVE));
 }
 
 // Verifies DeleteWindow works.
-TEST_F(WindowTreeAppTest, DeleteWindow) {
+TEST_F(WindowTreeClientTest, DeleteWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
 
   // Make 2 a child of 1.
   {
     changes1()->clear();
     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()));
   }
 
   // Delete 2.
   {
     changes1()->clear();
     changes2()->clear();
     ASSERT_TRUE(wt_client2()->DeleteWindow(window_2_1));
     EXPECT_TRUE(changes2()->empty());
 
     wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
               SingleChangeToDescription(*changes1()));
   }
 }
 
 // Verifies DeleteWindow isn't allowed from a separate connection.
-TEST_F(WindowTreeAppTest, DeleteWindowFromAnotherConnectionDisallowed) {
+TEST_F(WindowTreeClientTest, DeleteWindowFromAnotherConnectionDisallowed) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   EXPECT_FALSE(wt_client2()->DeleteWindow(BuildWindowId(connection_id_1(), 1)));
 }
 
 // Verifies if a window was deleted and then reused that other clients are
 // properly notified.
-TEST_F(WindowTreeAppTest, ReuseDeletedWindowId) {
+TEST_F(WindowTreeClientTest, ReuseDeletedWindowId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
 
   // Add 2 to 1.
   {
     changes1()->clear();
     ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
     wt_client1_->WaitForChangeCount(1);
@@ skipping 24 matching lines @@
     wt_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
     EXPECT_EQ("[" + WindowParentToString(window_2_1, window_1_1) + "]",
               ChangeWindowDescription(*changes1()));
   }
 }
 
 // Assertions for GetWindowTree.
-TEST_F(WindowTreeAppTest, GetWindowTree) {
+TEST_F(WindowTreeClientTest, GetWindowTree) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   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 = wt_client1()->NewWindow(11);
   ASSERT_TRUE(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.
@@ skipping 37 matching lines @@
   }
 
   // Connection 2 shouldn't be able to get the root tree.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt2(), root_window_id(), &windows);
     ASSERT_EQ(0u, windows.size());
   }
 }
 
-TEST_F(WindowTreeAppTest, SetWindowBounds) {
+TEST_F(WindowTreeClientTest, SetWindowBounds) {
   Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   changes2()->clear();
 
   wt_client2_->set_track_root_bounds_changes(true);
 
   wt1()->SetWindowBounds(10, window_1_1,
                          mojo::Rect::From(gfx::Rect(0, 0, 100, 100)));
   ASSERT_TRUE(wt_client1()->WaitForChangeCompleted(10));
 
   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.
   wt2()->SetWindowBounds(11, window_1_1,
                          mojo::Rect::From(gfx::Rect(0, 0, 0, 0)));
   ASSERT_FALSE(wt_client2()->WaitForChangeCompleted(11));
 }
 
 // Verify AddWindow fails when trying to manipulate windows in other roots.
-TEST_F(WindowTreeAppTest, CantMoveWindowsFromOtherRoot) {
+TEST_F(WindowTreeClientTest, CantMoveWindowsFromOtherRoot) {
   // Create 1 and 2 in the first connection.
   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_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // 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(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(wt_client2()->AddWindow(root_window_id(), window_1_1));
 }
 
 // Verify RemoveWindowFromParent fails for windows that are descendants of the
 // roots.
-TEST_F(WindowTreeAppTest, CantRemoveWindowsInOtherRoots) {
+TEST_F(WindowTreeClientTest, CantRemoveWindowsInOtherRoots) {
   // Create 1 and 2 in the first connection and parent both to the root.
   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(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.
@@ skipping 22 matching lines @@
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId),
               windows[0].ToString());
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()),
               windows[1].ToString());
     EXPECT_EQ(WindowParentToString(window_1_2, root_window_id()),
               windows[2].ToString());
   }
 }
 
 // Verify GetWindowTree fails for windows that are not descendants of the roots.
-TEST_F(WindowTreeAppTest, CantGetWindowTreeOfOtherRoots) {
+TEST_F(WindowTreeClientTest, CantGetWindowTreeOfOtherRoots) {
   // Create 1 and 2 in the first connection and parent both to the root.
   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(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(wt2(), root_window_id(), &windows);
   ASSERT_TRUE(windows.empty());
 
   // Should get nothing for window 2.
   GetWindowTree(wt2(), window_1_2, &windows);
   ASSERT_TRUE(windows.empty());
 
   // Should get window 1 if asked for.
   GetWindowTree(wt2(), window_1_1, &windows);
   ASSERT_EQ(1u, windows.size());
   EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
             windows[0].ToString());
 }
 
-TEST_F(WindowTreeAppTest, EmbedWithSameWindowId) {
+TEST_F(WindowTreeClientTest, EmbedWithSameWindowId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   changes2()->clear();
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt1(), window_1_1));
 
   // Connection2 should have been told of the unembed and delete.
   {
     wt_client2_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes2())[0]);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes2())[1]);
   }
 
   // Connection2 has no root. Verify it can't see window 1,1 anymore.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt2(), window_1_1, &windows);
     EXPECT_TRUE(windows.empty());
   }
 }
 
-TEST_F(WindowTreeAppTest, EmbedWithSameWindowId2) {
+TEST_F(WindowTreeClientTest, EmbedWithSameWindowId2) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   changes2()->clear();
 
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt1(), window_1_1));
 
   // Connection2 should have been told about the unembed and delete.
   wt_client2_->WaitForChangeCount(2);
   changes2()->clear();
 
@@ skipping 50 matching lines @@
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt3(), window_3_1, &windows);
     ASSERT_EQ(1u, windows.size());
     EXPECT_EQ(WindowParentToString(window_3_1, kNullParentId),
               windows[0].ToString());
   }
 }
 
 // Assertions for SetWindowVisibility.
-TEST_F(WindowTreeAppTest, SetWindowVisibility) {
+TEST_F(WindowTreeClientTest, SetWindowVisibility) {
   // Create 1 and 2 in the first connection and parent both to the root.
   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(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt1(), root_window_id(), &windows);
@@ skipping 55 matching lines @@
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()) +
                   " visible=true drawn=true",
               windows[0].ToString2());
     EXPECT_EQ(WindowParentToString(window_1_2, window_1_1) +
                   " visible=true drawn=true",
               windows[1].ToString2());
   }
 }
 
 // Test that we hear the cursor change in other connections.
-TEST_F(WindowTreeAppTest, SetCursor) {
+TEST_F(WindowTreeClientTest, SetCursor) {
   // Get a second connection to listen in.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   changes2()->clear();
 
   ASSERT_TRUE(
       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()));
 }
 
 // Assertions for SetWindowVisibility sending notifications.
-TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
+TEST_F(WindowTreeClientTest, 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 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(wt_client1()->SetWindowVisibility(window_1_1, true));
   Id window_1_2 = wt_client1()->NewWindow(2);
   ASSERT_TRUE(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));
 
@@ skipping 71 matching lines @@
   // Add 1,1 back to the root, connection 2 should see drawn state changed.
   ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
     wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=true",
         SingleChangeToDescription(*changes2()));
   }
 }
 
-TEST_F(WindowTreeAppTest, SetWindowProperty) {
+TEST_F(WindowTreeClientTest, SetWindowProperty) {
   Id window_1_1 = wt_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   changes2()->clear();
 
   ASSERT_TRUE(wt_client1()->AddWindow(root_window_id(), window_1_1));
   {
     std::vector<TestWindow> windows;
     GetWindowTree(wt1(), root_window_id(), &windows);
@@ skipping 27 matching lines @@
   // Set back to null.
   ASSERT_TRUE(wt_client1()->SetWindowProperty(window_1_1, "one", NULL));
   {
     wt_client2_->WaitForChangeCount(1);
     EXPECT_EQ("PropertyChanged window=" + IdToString(window_1_1) +
                   " key=one value=NULL",
               SingleChangeToDescription(*changes2()));
   }
 }
 
-TEST_F(WindowTreeAppTest, OnEmbeddedAppDisconnected) {
+TEST_F(WindowTreeClientTest, 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 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(wt_client2()->AddWindow(window_1_1, window_2_1));
   changes2()->clear();
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(wt2(), window_2_1));
 
   // Connection 1 should get a hierarchy change for window_2_1.
   wt_client1_->WaitForChangeCount(1);
   changes1()->clear();
 
   // Close connection 3. Connection 2 (which had previously embedded 3) should
   // be notified of this.
   wt_client3_.reset();
   wt_client2_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes2()));
 
   wt_client1_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes1()));
 }
 
 // Verifies when the parent of an Embed() is destroyed the embedded app gets
 // a WindowDeleted (and doesn't trigger a DCHECK).
-TEST_F(WindowTreeAppTest, OnParentOfEmbedDisconnects) {
+TEST_F(WindowTreeClientTest, OnParentOfEmbedDisconnects) {
   // Create connection 2 and 3.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   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(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(wt2(), window_2_2));
   changes3()->clear();
 
   // Close connection 2. Connection 3 should get a delete (for its root).
   wt_client2_.reset();
   wt_client3_->WaitForChangeCount(1);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
             SingleChangeToDescription(*changes3()));
 }
 
 // Verifies WindowTreeImpl doesn't incorrectly erase from its internal
 // map when a window from another connection with the same window_id is removed.
-TEST_F(WindowTreeAppTest, DontCleanMapOnDestroy) {
+TEST_F(WindowTreeClientTest, DontCleanMapOnDestroy) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   ASSERT_TRUE(wt_client2()->NewWindow(1));
   changes1()->clear();
   wt_client2_.reset();
   wt_client1_->WaitForChangeCount(1);
   EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_1_1),
             SingleChangeToDescription(*changes1()));
   std::vector<TestWindow> windows;
   GetWindowTree(wt1(), window_1_1, &windows);
   EXPECT_FALSE(windows.empty());
 }
 
 // Verifies Embed() works when supplying a WindowTreeClient.
-TEST_F(WindowTreeAppTest, EmbedSupplyingWindowTreeClient) {
+TEST_F(WindowTreeClientTest, EmbedSupplyingWindowTreeClient) {
   ASSERT_TRUE(wt_client1()->NewWindow(1));
 
   TestWindowTreeClientImpl client2;
   mojom::WindowTreeClientPtr client2_ptr;
   mojo::Binding<WindowTreeClient> client2_binding(&client2, &client2_ptr);
   ASSERT_TRUE(Embed(wt1(), BuildWindowId(connection_id_1(), 1),
                     std::move(client2_ptr)));
   client2.WaitForOnEmbed();
   EXPECT_EQ("OnEmbed",
             SingleChangeToDescription(*client2.tracker()->changes()));
 }
 
-TEST_F(WindowTreeAppTest, EmbedFailsFromOtherConnection) {
+TEST_F(WindowTreeClientTest, EmbedFailsFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(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 = wt_client3()->NewWindow(3);
   ASSERT_TRUE(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(), wt2(), test_name(), window_3_3));
 }
 
 // Verifies Embed() from window manager on another connections window works.
-TEST_F(WindowTreeAppTest, EmbedFromOtherConnection) {
+TEST_F(WindowTreeClientTest, EmbedFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = wt_client2()->NewWindow(1);
   ASSERT_TRUE(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(wt1(), window_2_1));
 
   ASSERT_TRUE(wt_client2()->WaitForAllMessages());
   EXPECT_EQ(std::string(), SingleChangeToDescription(*changes2()));
 }
 
-TEST_F(WindowTreeAppTest, CantEmbedFromConnectionRoot) {
+TEST_F(WindowTreeClientTest, CantEmbedFromConnectionRoot) {
   // Shouldn't be able to embed into the root.
   ASSERT_FALSE(EmbedUrl(connector(), wt1(), test_name(), root_window_id()));
 
   // Even though the call above failed a WindowTreeClient was obtained. We need
   // to
   // wait for it else we throw off the next connect.
   WaitForWindowTreeClient();
 
   // Don't allow a connection to embed into its own root.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
@@ skipping 11 matching lines @@
   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(), wt3(), test_name(), window_1_2));
 }
 
 // Verifies that a transient window tracks its parent's lifetime.
-TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
+TEST_F(WindowTreeClientTest, TransientWindowTracksTransientParentLifetime) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
   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
@@ skipping 24 matching lines @@
 
   changes1()->clear();
   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),
             ChangesToDescription1(*changes1())[1]);
 }
 
-TEST_F(WindowTreeAppTest, Ids) {
+TEST_F(WindowTreeClientTest, Ids) {
   const Id window_1_100 = wt_client1()->NewWindow(100);
   ASSERT_TRUE(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 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);
@@ skipping 25 matching lines @@
   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),
             SingleChangeToDescription(*changes2()));
 }
 
 // Tests that setting capture fails when no input event has occurred, and there
 // is no notification of lost capture.
-TEST_F(WindowTreeAppTest, ExplicitCaptureWithoutInput) {
+TEST_F(WindowTreeClientTest, ExplicitCaptureWithoutInput) {
   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(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.
   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.
   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) {
+TEST_F(WindowTreeClientTest, DISABLED_ExplicitCapturePropagation) {
   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(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.
@@ skipping 19 matching lines @@
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus