Changes ownership of WindowTreeClient

services/ui/public/cpp/tests/window_server_test_base.cc

 // Copyright 2015 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 "services/ui/public/cpp/tests/window_server_test_base.h"
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/cpp/window_tree_host_factory.h"
 
 namespace ui {
 namespace {
 
 base::RunLoop* current_run_loop = nullptr;
 
 void TimeoutRunLoop(const base::Closure& timeout_task, bool* timeout) {
   CHECK(current_run_loop);
   *timeout = true;
   timeout_task.Run();
 }
 
 }  // namespace
 
 WindowServerTestBase::WindowServerTestBase()
     : most_recent_client_(nullptr),
       window_manager_(nullptr),
       window_manager_delegate_(nullptr),
-      window_manager_client_(nullptr),
-      window_tree_client_destroyed_(false) {}
+      window_manager_client_(nullptr) {}
 
-WindowServerTestBase::~WindowServerTestBase() {}
+WindowServerTestBase::~WindowServerTestBase() {
+  window_tree_clients_.clear();
+}
 
 // static
 bool WindowServerTestBase::DoRunLoopWithTimeout() {
   if (current_run_loop != nullptr)
     return false;
 
   bool timeout = false;
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&TimeoutRunLoop, run_loop.QuitClosure(), &timeout),
       TestTimeouts::action_timeout());
 
   current_run_loop = &run_loop;
   current_run_loop->Run();
   current_run_loop = nullptr;
   return !timeout;
 }
 
 // static
 bool WindowServerTestBase::QuitRunLoop() {
   if (!current_run_loop)
     return false;
 
   current_run_loop->Quit();
   current_run_loop = nullptr;
   return true;
 }
 
+void WindowServerTestBase::DeleteWindowTreeClient(
+    ui::WindowTreeClient* client) {
+  for (auto iter = window_tree_clients_.begin();
+       iter != window_tree_clients_.end(); ++iter) {
+    if (iter->get() == client) {
+      window_tree_clients_.erase(iter);
+      return;
+    }
+  }
+  NOTREACHED();
+}
+
 void WindowServerTestBase::SetUp() {
   WindowServerServiceTestBase::SetUp();
 
-  CreateWindowTreeHost(connector(), this, &host_, this);
+  std::unique_ptr<WindowTreeClient> window_manager_window_tree_client =
+      CreateWindowTreeHost(connector(), this, &host_, this);
+  window_manager_ = window_manager_window_tree_client.get();
+  window_tree_clients_.insert(std::move(window_manager_window_tree_client));
 
   ASSERT_TRUE(DoRunLoopWithTimeout());  // RunLoop should be quit by OnEmbed().
-  std::swap(window_manager_, most_recent_client_);
 }
 
 bool WindowServerTestBase::OnConnect(const shell::Identity& remote_identity,
                                      shell::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::WindowTreeClient>(this);
   return true;
 }
 
 void WindowServerTestBase::OnEmbed(Window* root) {
   most_recent_client_ = root->window_tree();
   EXPECT_TRUE(QuitRunLoop());
   ASSERT_TRUE(window_manager_client_);
   window_manager_client_->AddActivationParent(root);
 }
 
-void WindowServerTestBase::OnDidDestroyClient(WindowTreeClient* client) {
-  window_tree_client_destroyed_ = true;
+void WindowServerTestBase::OnLostConnection(WindowTreeClient* client) {
+  window_tree_client_lost_connection_ = true;
+  DeleteWindowTreeClient(client);
+}
+
+void WindowServerTestBase::OnEmbedRootDestroyed(Window* root) {
+  DeleteWindowTreeClient(root->window_tree());
 }
 
 void WindowServerTestBase::OnPointerEventObserved(const ui::PointerEvent& event,
                                                   Window* target) {}
 
 void WindowServerTestBase::SetWindowManagerClient(WindowManagerClient* client) {
   window_manager_client_ = client;
 }
 
 bool WindowServerTestBase::OnWmSetBounds(Window* window, gfx::Rect* bounds) {
@@ skipping 49 matching lines @@
 
 mojom::EventResult WindowServerTestBase::OnAccelerator(uint32_t accelerator_id,
                                                        const ui::Event& event) {
   return window_manager_delegate_
              ? window_manager_delegate_->OnAccelerator(accelerator_id, event)
              : mojom::EventResult::UNHANDLED;
 }
 
 void WindowServerTestBase::Create(const shell::Identity& remote_identity,
                                   mojom::WindowTreeClientRequest request) {
-  new WindowTreeClient(this, nullptr, std::move(request));
+  window_tree_clients_.insert(
+      base::MakeUnique<WindowTreeClient>(this, nullptr, std::move(request)));
 }
 
 }  // namespace ui