Changes ownership of WindowTreeClient

services/ui/ws/window_manager_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/logging.h"
 #include "base/macros.h"
@@ skipping 913 matching lines @@
     WaitForWindowToHaveFocus(focused[index]);
     EXPECT_TRUE(focused[index]->HasFocus());
     EXPECT_EQ(parent->children().back(), expecteds[index]);
   }
 }
 
 namespace {
 
 class DestroyedChangedObserver : public WindowObserver {
  public:
-  DestroyedChangedObserver(WindowServerTestBase* test,
-                           Window* window,
-                           bool* got_destroy)
-      : test_(test), window_(window), got_destroy_(got_destroy) {
+  DestroyedChangedObserver(Window* window, bool* got_destroy)
+      : window_(window), got_destroy_(got_destroy) {
     window_->AddObserver(this);
   }
   ~DestroyedChangedObserver() override {
     if (window_)
       window_->RemoveObserver(this);
   }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDestroyed(Window* window) override {
     EXPECT_EQ(window, window_);
     window_->RemoveObserver(this);
     *got_destroy_ = true;
     window_ = nullptr;
-
-    // We should always get OnWindowDestroyed() before
-    // OnDidDestroyClient().
-    EXPECT_FALSE(test_->window_tree_client_destroyed());
   }
 
-  WindowServerTestBase* test_;
   Window* window_;
   bool* got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a WindowServer sends the right notifications.
 TEST_F(WindowServerTest, DeleteWindowServer) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
   WindowTreeClient* client = Embed(window).client;
   ASSERT_TRUE(client);
   bool got_destroy = false;
-  DestroyedChangedObserver observer(this, GetFirstRoot(client),
-                                    &got_destroy);
-  delete client;
-  EXPECT_TRUE(window_tree_client_destroyed());
+  DestroyedChangedObserver observer(GetFirstRoot(client), &got_destroy);
+  DeleteWindowTreeClient(client);
   EXPECT_TRUE(got_destroy);
 }
 
-// Verifies two Embed()s in the same window trigger deletion of the first
-// WindowServer.
-TEST_F(WindowServerTest, DisconnectTriggersDelete) {
-  Window* window = window_manager()->NewWindow();
-  ASSERT_NE(nullptr, window);
-  window->SetVisible(true);
-  GetFirstWMRoot()->AddChild(window);
-  WindowTreeClient* client = Embed(window).client;
-  EXPECT_NE(client, window_manager());
-  Window* embedded_window = client->NewWindow();
-  // Embed again, this should trigger disconnect and deletion of client.
-  bool got_destroy;
-  DestroyedChangedObserver observer(this, embedded_window, &got_destroy);
-  EXPECT_FALSE(window_tree_client_destroyed());
-  Embed(window);
-  EXPECT_TRUE(window_tree_client_destroyed());
-}
-
 class WindowRemovedFromParentObserver : public WindowObserver {
  public:
   explicit WindowRemovedFromParentObserver(Window* window)
       : window_(window), was_removed_(false) {
     window_->AddObserver(this);
   }
   ~WindowRemovedFromParentObserver() override { window_->RemoveObserver(this); }
 
   bool was_removed() const { return was_removed_; }
 
@@ skipping 25 matching lines @@
   // Run the message loop so the Embed() call above completes. Without this
   // we may end up reconnecting to the test and rerunning the test, which is
   // problematic since the other services don't shut down.
   ASSERT_TRUE(DoRunLoopWithTimeout());
 }
 
 namespace {
 
 class DestroyObserver : public WindowObserver {
  public:
-  DestroyObserver(WindowServerTestBase* test,
-                  WindowTreeClient* client,
-                  bool* got_destroy)
-      : test_(test), got_destroy_(got_destroy) {
+  DestroyObserver(WindowTreeClient* client, bool* got_destroy)
+      : got_destroy_(got_destroy) {
     GetFirstRoot(client)->AddObserver(this);
   }
   ~DestroyObserver() override {}
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDestroyed(Window* window) override {
     *got_destroy_ = true;
     window->RemoveObserver(this);
 
-    // We should always get OnWindowDestroyed() before
-    // OnWindowManagerDestroyed().
-    EXPECT_FALSE(test_->window_tree_client_destroyed());
-
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
-  WindowServerTestBase* test_;
   bool* got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a Window that is the root of another client notifies
 // observers in the right order (OnWindowDestroyed() before
 // OnWindowManagerDestroyed()).
 TEST_F(WindowServerTest, WindowServerDestroyedAfterRootObserver) {
   Window* embed_window = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(embed_window);
 
   WindowTreeClient* embedded_client = Embed(embed_window).client;
 
   bool got_destroy = false;
-  DestroyObserver observer(this, embedded_client, &got_destroy);
+  DestroyObserver observer(embedded_client, &got_destroy);
   // Delete the window |embedded_client| is embedded in. This is async,
   // but will eventually trigger deleting |embedded_client|.
   embed_window->Destroy();
   EXPECT_TRUE(DoRunLoopWithTimeout());
   EXPECT_TRUE(got_destroy);
 }
 
 TEST_F(WindowServerTest, ClientAreaChanged) {
   Window* embed_window = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(embed_window);
@@ skipping 48 matching lines @@
   WindowTreeClient* client_;
   std::unique_ptr<base::RunLoop> run_loop_;
   Window* created_window_;
 
   DISALLOW_COPY_AND_ASSIGN(EstablishConnectionViaFactoryDelegate);
 };
 
 TEST_F(WindowServerTest, EstablishConnectionViaFactory) {
   EstablishConnectionViaFactoryDelegate delegate(window_manager());
   set_window_manager_delegate(&delegate);
-  std::unique_ptr<WindowTreeClient> second_client(
-      new WindowTreeClient(this, nullptr, nullptr));
-  second_client->ConnectViaWindowTreeFactory(connector());
-  Window* window_in_second_client =
-      second_client->NewTopLevelWindow(nullptr);
+  WindowTreeClient second_client(this, nullptr, nullptr);
+  second_client.ConnectViaWindowTreeFactory(connector());
+  Window* window_in_second_client = second_client.NewTopLevelWindow(nullptr);
   ASSERT_TRUE(window_in_second_client);
-  ASSERT_TRUE(second_client->GetRoots().count(window_in_second_client) >
-              0);
+  ASSERT_TRUE(second_client.GetRoots().count(window_in_second_client) > 0);
   // Wait for the window to appear in the wm.
   ASSERT_TRUE(delegate.QuitOnCreate());
 
   Window* window_in_wm = delegate.created_window();
   ASSERT_TRUE(window_in_wm);
 
   // Change the bounds in the wm, and make sure the child sees it.
   window_in_wm->SetBounds(gfx::Rect(1, 11, 12, 101));
   ASSERT_TRUE(WaitForBoundsToChange(window_in_second_client));
   EXPECT_EQ(gfx::Rect(1, 11, 12, 101), window_in_second_client->bounds());
 }
 
 }  // namespace ws
 }  // namespace ui