Changes ownership of WindowTreeHostConnection

components/mus/ws/window_tree_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 <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 267 matching lines @@
   TestClientConnection* last_connection_;
   WindowTreeHostImpl* window_tree_host_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectionManagerDelegate);
 };
 
 // -----------------------------------------------------------------------------
 
 class TestWindowTreeHostConnection : public WindowTreeHostConnection {
  public:
-  TestWindowTreeHostConnection(scoped_ptr<WindowTreeHostImpl> host_impl,
+  TestWindowTreeHostConnection(WindowTreeHostImpl* host_impl,
                                ConnectionManager* manager)
-      : WindowTreeHostConnection(std::move(host_impl), manager) {}
+      : host_(host_impl), connection_manager_(manager) {}
   ~TestWindowTreeHostConnection() override {}
 
  private:
-  // WindowTreeHostDelegate:
-  void OnDisplayInitialized() override {
-    connection_manager()->AddHost(this);
-    set_window_tree(connection_manager()->EmbedAtWindow(
-        window_tree_host()->root_window(),
-        mus::mojom::WindowTree::kAccessPolicyEmbedRoot,
-        mus::mojom::WindowTreeClientPtr()));
+  // WindowTreeHostConnection:
+  WindowTreeImpl* CreateWindowTree(ServerWindow* root) override {
+    return connection_manager_->EmbedAtWindow(
+        root, mus::mojom::WindowTree::kAccessPolicyEmbedRoot,
+        mus::mojom::WindowTreeClientPtr());
   }
+
+  WindowTreeHostImpl* host_;
+  ConnectionManager* connection_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeHostConnection);
 };
 
 // -----------------------------------------------------------------------------
 // Empty implementation of DisplayManager.
 class TestDisplayManager : public DisplayManager {
  public:
   explicit TestDisplayManager(int32_t* cursor_id_storage)
       : cursor_id_storage_(cursor_id_storage) {}
   ~TestDisplayManager() override {}
@@ skipping 123 matching lines @@
   }
 
   TestWindowTreeClient* wm_client() { return wm_client_; }
   mus::mojom::Cursor cursor_id() {
     return static_cast<mus::mojom::Cursor>(cursor_id_);
   }
 
   TestWindowTreeHostConnection* host_connection() { return host_connection_; }
 
   void DispatchEventWithoutAck(const ui::Event& event) {
-    host_connection()->window_tree_host()->OnEvent(event);
+    window_tree_host_->OnEvent(event);
   }
 
   void set_window_manager_internal(WindowTreeImpl* connection,
                                    mojom::WindowManager* wm_internal) {
     connection->window_manager_internal_ = wm_internal;
   }
 
   void AckPreviousEvent() {
-    while (host_connection()->window_tree_host()->tree_awaiting_input_ack_) {
-      host_connection()
-          ->window_tree_host()
-          ->tree_awaiting_input_ack_->OnWindowInputEventAck(0);
-    }
+    while (window_tree_host_->tree_awaiting_input_ack_)
+      window_tree_host_->tree_awaiting_input_ack_->OnWindowInputEventAck(0);
   }
 
   void DispatchEventAndAckImmediately(const ui::Event& event) {
     DispatchEventWithoutAck(event);
     AckPreviousEvent();
   }
 
   // Creates a new window from wm_connection() and embeds a new connection in
   // it.
   void SetupEventTargeting(TestWindowTreeClient** out_client,
                            WindowTreeImpl** window_tree_connection,
                            ServerWindow** window);
 
  protected:
   // testing::Test:
   void SetUp() override {
     DisplayManager::set_factory_for_testing(&display_manager_factory_);
     // TODO(fsamuel): This is probably broken. We need a root.
     connection_manager_.reset(
         new ConnectionManager(&delegate_, scoped_refptr<SurfacesState>()));
-    WindowTreeHostImpl* host = new WindowTreeHostImpl(
+    window_tree_host_ = new WindowTreeHostImpl(
         connection_manager_.get(), nullptr, scoped_refptr<GpuState>(),
         scoped_refptr<mus::SurfacesState>());
     // TODO(fsamuel): This is way too magical. We need to find a better way to
     // manage lifetime.
     host_connection_ = new TestWindowTreeHostConnection(
-        make_scoped_ptr(host), connection_manager_.get());
-    host->Init(host_connection_);
+        window_tree_host_, connection_manager_.get());
+    window_tree_host_->Init(make_scoped_ptr(host_connection_));
     wm_client_ = delegate_.last_client();
   }
 
- private:
+ protected:
   // TestWindowTreeClient that is used for the WM connection.
   TestWindowTreeClient* wm_client_;
   int32_t cursor_id_;
   TestDisplayManagerFactory display_manager_factory_;
   TestConnectionManagerDelegate delegate_;
   TestWindowTreeHostConnection* host_connection_;
+  WindowTreeHostImpl* window_tree_host_ = nullptr;
   scoped_ptr<ConnectionManager> connection_manager_;
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeTest);
 };
 
 // Creates a new window in wm_connection(), adds it to the root, embeds a
 // new client in the window and creates a child of said window. |window| is
 // set to the child of |window_tree_connection| that is created.
 void WindowTreeTest::SetupEventTargeting(
     TestWindowTreeClient** out_client,
     WindowTreeImpl** window_tree_connection,
     ServerWindow** window) {
   const ClientWindowId embed_window_id =
       BuildClientWindowId(wm_connection(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRootId(wm_connection()),
                                          embed_window_id));
-  host_connection()->window_tree_host()->root_window()->SetBounds(
-      gfx::Rect(0, 0, 100, 100));
+  window_tree_host_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
       GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
                          mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   ServerWindow* embed_window =
       wm_connection()->GetWindowByClientId(embed_window_id);
@@ skipping 31 matching lines @@
       BuildClientWindowId(wm_connection(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   ServerWindow* embed_window =
       wm_connection()->GetWindowByClientId(embed_window_id);
   ASSERT_TRUE(embed_window);
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_connection()));
   const ClientWindowId wm_root_id = FirstRootId(wm_connection());
   EXPECT_TRUE(wm_connection()->AddWindow(wm_root_id, embed_window_id));
-  host_connection()->window_tree_host()->root_window()->SetBounds(
-      gfx::Rect(0, 0, 100, 100));
+  window_tree_host_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
       GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
                          mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   WindowTreeImpl* connection1 =
       connection_manager()->GetConnectionWithRoot(embed_window);
@@ skipping 39 matching lines @@
       "Focused id=2,1",
       ChangesToDescription1(*connection1_client->tracker()->changes())[0]);
 
   DispatchEventAndAckImmediately(CreatePointerUpEvent(21, 22));
   wm_client()->tracker()->changes()->clear();
   connection1_client->tracker()->changes()->clear();
 
   // Press outside of the embedded window. Note that root cannot be focused
   // (because it cannot be activated). So the focus would not move in this case.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(61, 22));
-  EXPECT_EQ(child1, host_connection()->window_tree_host()->GetFocusedWindow());
+  EXPECT_EQ(child1, window_tree_host_->GetFocusedWindow());
 
   DispatchEventAndAckImmediately(CreatePointerUpEvent(21, 22));
   wm_client()->tracker()->changes()->clear();
   connection1_client->tracker()->changes()->clear();
 
   // Press in the same location. Should not get a focus change event (only input
   // event).
   DispatchEventAndAckImmediately(CreatePointerDownEvent(61, 22));
-  EXPECT_EQ(child1, host_connection()->window_tree_host()->GetFocusedWindow());
+  EXPECT_EQ(child1, window_tree_host_->GetFocusedWindow());
   ASSERT_EQ(wm_client()->tracker()->changes()->size(), 1u)
       << SingleChangeToDescription(*wm_client()->tracker()->changes());
   EXPECT_EQ("InputEvent window=0,2 event_action=4",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   EXPECT_TRUE(connection1_client->tracker()->changes()->empty());
 }
 
 TEST_F(WindowTreeTest, BasicInputEventTarget) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
@@ skipping 155 matching lines @@
 
 TEST_F(WindowTreeTest, EventAck) {
   const ClientWindowId embed_window_id =
       BuildClientWindowId(wm_connection(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_connection()));
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRootId(wm_connection()),
                                          embed_window_id));
-  host_connection()->window_tree_host()->root_window()->SetBounds(
-      gfx::Rect(0, 0, 100, 100));
+  window_tree_host_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
 
   wm_client()->tracker()->changes()->clear();
   DispatchEventWithoutAck(CreateMouseMoveEvent(21, 22));
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("InputEvent window=0,2 event_action=5",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   wm_client()->tracker()->changes()->clear();
 
   // Send another event. This event shouldn't reach the client.
   DispatchEventWithoutAck(CreateMouseMoveEvent(21, 22));
@@ skipping 112 matching lines @@
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(root_window->id()));
   EXPECT_EQ(window, host->GetCaptureWindow());
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(window->id()));
   EXPECT_EQ(nullptr, host->GetCaptureWindow());
 }
 
 }  // namespace ws
 }  // namespace mus