Wires up transient windows for aura-mus

ui/aura/mus/window_tree_client_unittest.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/common/common_type_converters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
+#include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
@@ skipping 794 matching lines @@
   ASSERT_FALSE(transport_properties.is_null());
   std::map<std::string, std::vector<uint8_t>> properties =
       transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
   ASSERT_EQ(1u, properties.count(kTestPropertyServerKey1));
   ASSERT_EQ(1u, properties[kTestPropertyServerKey1].size());
   EXPECT_EQ(explicitly_set_test_property1_value,
             properties[kTestPropertyServerKey1][0]);
   ASSERT_EQ(0u, properties.count(kTestPropertyServerKey2));
 }
 
-/*
-// Tests that if the client has multiple unowned windows, and one of them is a
-// transient child to another, the  teardown can happen cleanly.
-TEST_F(WindowTreeClientWmTest, MultipleUnOwnedWindowsDuringDestruction) {
-  std::unique_ptr<WindowTreeSetup> setup(new WindowTreeSetup());
-  Window* root1 = setup->GetFirstRoot();
-  ASSERT_TRUE(root1);
-  Window* root2 = setup->client()->NewTopLevelWindow(nullptr);
-  ASSERT_TRUE(root2);
-  root1->AddTransientWindow(root2);
+// Assertions around transient windows.
+TEST_F(WindowTreeClientClientTest, Transients) {
+  client::TransientWindowClient* transient_client =
+      client::GetTransientWindowClient();
+  Window parent(nullptr);
+  parent.Init(ui::LAYER_NOT_DRAWN);
+  root_window()->AddChild(&parent);
+  Window transient(nullptr);

[msw, 2016/10/27 23:46:10]

Is this |transient| owned by |parent|, like |transient_child| on line 975? If
not, I fail to see how a difference in ownership is established. Is it the
removal of the transient from its parent within this test fixture (that somehow
restores ownership to the local |transient| object) versus the destruction of
|transient_parent| at line 992 that somehow determines the lifetime/ownership of
the Window object? That doesn't make sense... I'm just a bit confused.

[sky, 2016/10/28 03:16:32]

This test changes the transient status a bunch. So, transient is transient at
line 842, then made not transient at 849, transient again at 855 and finally
removed as a transient on 860.
Hopefully my description clears it up. 

The test WindowDestroyedWhileTransientChildHasCapture destroys a window with a
transient still around and verifies the transient is actually destroyed.

+  transient.Init(ui::LAYER_NOT_DRAWN);
+  root_window()->AddChild(&transient);
+  window_tree()->AckAllChanges();
+  transient_client->AddTransientChild(&parent, &transient);
+  ASSERT_EQ(1u, window_tree()->GetChangeCountForType(
+                    WindowTreeChangeType::ADD_TRANSIENT));
+  EXPECT_EQ(server_id(&parent), window_tree()->transient_data().parent_id);
+  EXPECT_EQ(server_id(&transient), window_tree()->transient_data().child_id);
 
-  WindowTracker tracker;
-  tracker.Add(root1);
-  tracker.Add(root2);
-  reset();
-  EXPECT_TRUE(tracker.windows().empty());
+  // Remove from the server side.
+  window_tree_client()->OnTransientWindowRemoved(server_id(&parent),
+                                                 server_id(&transient));
+  EXPECT_EQ(nullptr, transient_client->GetTransientParent(&transient));
+  window_tree()->AckAllChanges();
+
+  // Add from the server.
+  window_tree_client()->OnTransientWindowAdded(server_id(&parent),
+                                               server_id(&transient));
+  EXPECT_EQ(&parent, transient_client->GetTransientParent(&transient));
+
+  // Remove locally.
+  transient_client->RemoveTransientChild(&parent, &transient);
+  ASSERT_EQ(1u, window_tree()->GetChangeCountForType(
+                    WindowTreeChangeType::REMOVE_TRANSIENT));
+  EXPECT_EQ(server_id(&transient), window_tree()->transient_data().child_id);
 }
-*/
 
 TEST_F(WindowTreeClientClientTest,
        TopLevelWindowDestroyedBeforeCreateComplete) {
   const size_t initial_root_count =
       window_tree_client_impl()->GetRoots().size();
   std::unique_ptr<Window> top_level(base::MakeUnique<Window>(nullptr));
   top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   top_level->Init(ui::LAYER_NOT_DRAWN);
   EXPECT_EQ(initial_root_count + 1,
             window_tree_client_impl()->GetRoots().size());
@@ skipping 86 matching lines @@
 
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::CAPTURE, false));
   EXPECT_FALSE(child.HasCapture());
   EXPECT_TRUE(root_window()->HasCapture());
 
   window_tree_client()->OnCaptureChanged(0, server_id(root_window()));
   EXPECT_FALSE(root_window()->HasCapture());
 }
 
-/*
 TEST_F(WindowTreeClientWmTest, WindowDestroyedWhileTransientChildHasCapture) {
-  WindowTreeSetup setup;
-  Window* root = GetFirstRoot();
-  Window* transient_parent = client()->NewWindow();
-  Window* transient_child = client()->NewWindow();
-  transient_parent->SetVisible(true);
-  transient_child->SetVisible(true);
-  root->AddChild(transient_parent);
-  root->AddChild(transient_child);
+  std::unique_ptr<Window> transient_parent(base::MakeUnique<Window>(nullptr));
+  transient_parent->Init(ui::LAYER_NOT_DRAWN);
+  // Owned by |transient_parent|.
+  Window* transient_child = new Window(nullptr);
+  transient_child->Init(ui::LAYER_NOT_DRAWN);
+  transient_parent->Show();
+  transient_child->Show();
+  root_window()->AddChild(transient_parent.get());
+  root_window()->AddChild(transient_child);
 
-  transient_parent->AddTransientWindow(transient_child);
+  client::GetTransientWindowClient()->AddTransientChild(transient_parent.get(),
+                                                        transient_child);
 
   WindowTracker tracker;
-  tracker.Add(transient_parent);
+  tracker.Add(transient_parent.get());
   tracker.Add(transient_child);
   // Request a capture on the transient child, then destroy the transient
   // parent. That will destroy both windows, and should reset the capture window
   // correctly.
   transient_child->SetCapture();
-  transient_parent->Destroy();
+  transient_parent.reset();
   EXPECT_TRUE(tracker.windows().empty());
 
   // Create a new Window, and attempt to place capture on that.
-  Window* child = client()->NewWindow();
-  child->SetVisible(true);
-  root->AddChild(child);
-  child->SetCapture();
-  EXPECT_TRUE(child->HasCapture());
+  Window child(nullptr);
+  child.Init(ui::LAYER_NOT_DRAWN);
+  child.Show();
+  root_window()->AddChild(&child);
+  child.SetCapture();
+  EXPECT_TRUE(child.HasCapture());
 }
-*/
 
 namespace {
 
 class CaptureRecorder : public client::CaptureClientObserver {
  public:
   explicit CaptureRecorder(Window* root_window) : root_window_(root_window) {
     client::GetCaptureClient(root_window)->AddObserver(this);
   }
 
   ~CaptureRecorder() override {
@@ skipping 68 matching lines @@
 
   // Changes originating from server should notify observers too.
   window_tree_client()->OnCaptureChanged(server_id(&child2), 0);
   EXPECT_EQ(1, capture_recorder.capture_changed_count());
   EXPECT_EQ(child2_id, capture_recorder.last_gained_capture_window_id());
   EXPECT_EQ(0, capture_recorder.last_lost_capture_window_id());
   capture_recorder.reset_capture_captured_count();
 }
 
 }  // namespace aura