Eliminate WindowTreeConnection

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"
@@ skipping 95 matching lines @@
 }
 
 std::string WindowParentToString(Id window, Id parent) {
   return base::StringPrintf("window=%s parent=%s", IdToString(window).c_str(),
                             IdToString(parent).c_str());
 }
 
 // -----------------------------------------------------------------------------
 
 // A WindowTreeClient implementation that logs all changes to a tracker.
-class TestWindowTreeClientImpl : public mojom::WindowTreeClient,
-                                 public TestChangeTracker::Delegate,
-                                 public mojom::WindowManager {
+class TestWindowTreeClient : public mojom::WindowTreeClient,
+                             public TestChangeTracker::Delegate,
+                             public mojom::WindowManager {
  public:
-  TestWindowTreeClientImpl()
+  TestWindowTreeClient()
       : binding_(this),
         client_id_(0),
         root_window_id_(0),
         // Start with a random large number so tests can use lower ids if they
         // want.
         next_change_id_(10000),
         waiting_change_id_(0),
         on_change_completed_result_(false),
         track_root_bounds_changes_(false) {
     tracker_.set_delegate(this);
@@ skipping 298 matching lines @@
   uint32_t next_change_id_;
   uint32_t waiting_change_id_;
   bool on_change_completed_result_;
   bool track_root_bounds_changes_;
   std::unique_ptr<base::RunLoop> change_completed_run_loop_;
 
   std::unique_ptr<mojo::AssociatedBinding<mojom::WindowManager>>
       window_manager_binding_;
   mojom::WindowManagerClientAssociatedPtr window_manager_client_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClientImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClient);
 };
 
 // -----------------------------------------------------------------------------
 
-// InterfaceFactory for vending TestWindowTreeClientImpls.
+// InterfaceFactory for vending TestWindowTreeClients.
 class WindowTreeClientFactory
     : public shell::InterfaceFactory<WindowTreeClient> {
  public:
   WindowTreeClientFactory() {}
   ~WindowTreeClientFactory() override {}
 
   // Runs a nested MessageLoop until a new instance has been created.
-  std::unique_ptr<TestWindowTreeClientImpl> WaitForInstance() {
+  std::unique_ptr<TestWindowTreeClient> WaitForInstance() {
     if (!client_impl_.get()) {
       DCHECK(!run_loop_);
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
       run_loop_.reset();
     }
     return std::move(client_impl_);
   }
 
  private:
   // InterfaceFactory<WindowTreeClient>:
   void Create(Connection* connection,
               InterfaceRequest<WindowTreeClient> request) override {
-    client_impl_.reset(new TestWindowTreeClientImpl());
+    client_impl_.reset(new TestWindowTreeClient());
     client_impl_->Bind(std::move(request));
     if (run_loop_.get())
       run_loop_->Quit();
   }
 
-  std::unique_ptr<TestWindowTreeClientImpl> client_impl_;
+  std::unique_ptr<TestWindowTreeClient> client_impl_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientFactory);
 };
 
 }  // namespace
 
 class WindowTreeClientTest : public WindowServerShellTestBase {
  public:
   WindowTreeClientTest()
       : client_id_1_(0), client_id_2_(0), root_window_id_(0) {}
 
   ~WindowTreeClientTest() override {}
 
  protected:
   // Returns the changes from the various clients.
   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 clients. |wt1()|, being the first client, has special permissions
   // (it's treated as the window manager).
   WindowTree* wt1() { return wt_client1_->tree(); }
   WindowTree* wt2() { return wt_client2_->tree(); }
   WindowTree* wt3() { return wt_client3_->tree(); }
 
-  TestWindowTreeClientImpl* wt_client1() { return wt_client1_.get(); }
-  TestWindowTreeClientImpl* wt_client2() { return wt_client2_.get(); }
-  TestWindowTreeClientImpl* wt_client3() { return wt_client3_.get(); }
+  TestWindowTreeClient* wt_client1() { return wt_client1_.get(); }
+  TestWindowTreeClient* wt_client2() { return wt_client2_.get(); }
+  TestWindowTreeClient* wt_client3() { return wt_client3_.get(); }
 
   Id root_window_id() const { return root_window_id_; }
 
   int client_id_1() const { return client_id_1_; }
   int client_id_2() const { return client_id_2_; }
 
   void EstablishSecondClientWithRoot(Id root_id) {
     ASSERT_TRUE(wt_client2_.get() == nullptr);
     wt_client2_ =
         EstablishClientViaEmbed(wt1(), root_id, &client_id_2_);
@@ skipping 15 matching lines @@
                 ChangeWindowDescription(*changes2()));
     }
   }
 
   void EstablishThirdClient(WindowTree* owner, Id root_id) {
     ASSERT_TRUE(wt_client3_.get() == nullptr);
     wt_client3_ = EstablishClientViaEmbed(owner, root_id, nullptr);
     ASSERT_TRUE(wt_client3_.get() != nullptr);
   }
 
-  std::unique_ptr<TestWindowTreeClientImpl> WaitForWindowTreeClient() {
+  std::unique_ptr<TestWindowTreeClient> WaitForWindowTreeClient() {
     return client_factory_->WaitForInstance();
   }
 
   // Establishes a new client by way of Embed() on the specified WindowTree.
-  std::unique_ptr<TestWindowTreeClientImpl> EstablishClientViaEmbed(
+  std::unique_ptr<TestWindowTreeClient> EstablishClientViaEmbed(
       WindowTree* owner,
       Id root_id,
       int* client_id) {
     return EstablishClientViaEmbedWithPolicyBitmask(owner, root_id, client_id);
   }
 
-  std::unique_ptr<TestWindowTreeClientImpl>
+  std::unique_ptr<TestWindowTreeClient>
   EstablishClientViaEmbedWithPolicyBitmask(WindowTree* owner,
                                            Id root_id,
                                            int* client_id) {
     if (!EmbedUrl(connector(), owner, test_name(), root_id)) {
       ADD_FAILURE() << "Embed() failed";
       return nullptr;
     }
-    std::unique_ptr<TestWindowTreeClientImpl> client =
+    std::unique_ptr<TestWindowTreeClient> client =
         client_factory_->WaitForInstance();
     if (!client.get()) {
       ADD_FAILURE() << "WaitForInstance failed";
       return nullptr;
     }
     client->WaitForOnEmbed();
 
     EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     if (client_id)
       *client_id = (*client->tracker()->changes())[0].client_id;
     return client;
   }
 
   // WindowServerShellTestBase:
   bool AcceptConnection(shell::Connection* connection) override {
     connection->AddInterface(client_factory_.get());
     return true;
   }
 
   void SetUp() override {
     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_.reset(new TestWindowTreeClient());
     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_->WaitForOnEmbed();
 
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
@@ skipping 11 matching lines @@
   void TearDown() override {
     // Destroy these before the message loop is destroyed (happens in
     // WindowServerShellTestBase::TearDown).
     wt_client1_.reset();
     wt_client2_.reset();
     wt_client3_.reset();
     client_factory_.reset();
     WindowServerShellTestBase::TearDown();
   }
 
-  std::unique_ptr<TestWindowTreeClientImpl> wt_client1_;
-  std::unique_ptr<TestWindowTreeClientImpl> wt_client2_;
-  std::unique_ptr<TestWindowTreeClientImpl> wt_client3_;
+  std::unique_ptr<TestWindowTreeClient> wt_client1_;
+  std::unique_ptr<TestWindowTreeClient> wt_client2_;
+  std::unique_ptr<TestWindowTreeClient> wt_client3_;
 
   mojom::WindowTreeHostPtr host_;
 
  private:
   std::unique_ptr<WindowTreeClientFactory> client_factory_;
   int client_id_1_;
   int client_id_2_;
   Id root_window_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientTest);
@@ skipping 726 matching lines @@
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_3_1) +
                   " old_parent=null new_parent=" + IdToString(window_1_1),
               SingleChangeToDescription(*changes1()));
   }
 
   // Embed 1,1 again.
   {
     changes3()->clear();
 
     // We should get a new client for the new embedding.
-    std::unique_ptr<TestWindowTreeClientImpl> client4(
+    std::unique_ptr<TestWindowTreeClient> client4(
         EstablishClientViaEmbed(wt1(), window_1_1, nullptr));
     ASSERT_TRUE(client4.get());
     EXPECT_EQ("[" + WindowParentToString(window_1_1, kNullParentId) + "]",
               ChangeWindowDescription(*client4->tracker()->changes()));
 
     // And 3 should get an unembed and delete.
     wt_client3_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes3())[0]);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_1_1),
@@ skipping 417 matching lines @@
             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(WindowTreeClientTest, EmbedSupplyingWindowTreeClient) {
   ASSERT_TRUE(wt_client1()->NewWindow(1));
 
-  TestWindowTreeClientImpl client2;
+  TestWindowTreeClient client2;
   mojom::WindowTreeClientPtr client2_ptr;
   mojo::Binding<WindowTreeClient> client2_binding(&client2, &client2_ptr);
   ASSERT_TRUE(Embed(wt1(), BuildWindowId(client_id_1(), 1),
                     std::move(client2_ptr)));
   client2.WaitForOnEmbed();
   EXPECT_EQ("OnEmbed",
             SingleChangeToDescription(*client2.tracker()->changes()));
 }
 
 TEST_F(WindowTreeClientTest, EmbedFailsFromOtherClient) {
@@ skipping 210 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