chromeos: wires transients using the WindowTreeHost window

ui/views/mus/desktop_window_tree_host_mus_unittest.cc

 // Copyright 2016 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/views/mus/desktop_window_tree_host_mus.h"
 
 #include "base/debug/stack_trace.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/cursor_client.h"
+#include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/test/mus/change_completion_waiter.h"
 #include "ui/aura/window.h"
 #include "ui/views/mus/mus_client.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_observer.h"
 
 namespace views {
 
 class DesktopWindowTreeHostMusTest : public ViewsTestBase,
                                      public WidgetObserver {
  public:
   DesktopWindowTreeHostMusTest()
       : widget_activated_(nullptr),
         widget_deactivated_(nullptr),
         waiting_for_deactivate_(nullptr) {}
   ~DesktopWindowTreeHostMusTest() override {}
 
   // Creates a test widget. Takes ownership of |delegate|.
-  std::unique_ptr<Widget> CreateWidget(WidgetDelegate* delegate) {
+  std::unique_ptr<Widget> CreateWidget(WidgetDelegate* delegate = nullptr,
+                                       aura::Window* parent = nullptr) {
     std::unique_ptr<Widget> widget = base::MakeUnique<Widget>();
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
     params.delegate = delegate;
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.bounds = gfx::Rect(0, 1, 111, 123);
+    params.parent = parent;
     widget->Init(params);
     widget->AddObserver(this);
     return widget;
   }
 
   const Widget* widget_activated() const { return widget_activated_; }
   const Widget* widget_deactivated() const { return widget_deactivated_; }
 
   void DeactivateAndWait(Widget* to_deactivate) {
     waiting_for_deactivate_ = to_deactivate;
@@ skipping 50 matching lines @@
     EXPECT_FALSE(cursor_client);
     window_->RemoveObserver(this);
     window_ = nullptr;
   }
 
   aura::Window* window_;
   DISALLOW_COPY_AND_ASSIGN(ExpectsNullCursorClientDuringTearDown);
 };
 
 TEST_F(DesktopWindowTreeHostMusTest, Visibility) {
-  std::unique_ptr<Widget> widget(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget(CreateWidget());
   EXPECT_FALSE(widget->IsVisible());
   EXPECT_FALSE(widget->GetNativeView()->IsVisible());
   // It's important the parent is also hidden as this value is sent to the
   // server.
   EXPECT_FALSE(widget->GetNativeView()->parent()->IsVisible());
   widget->Show();
   EXPECT_TRUE(widget->IsVisible());
   EXPECT_TRUE(widget->GetNativeView()->IsVisible());
   EXPECT_TRUE(widget->GetNativeView()->parent()->IsVisible());
   widget->Hide();
   EXPECT_FALSE(widget->IsVisible());
   EXPECT_FALSE(widget->GetNativeView()->IsVisible());
   EXPECT_FALSE(widget->GetNativeView()->parent()->IsVisible());
 }
 
 TEST_F(DesktopWindowTreeHostMusTest, Deactivate) {
-  std::unique_ptr<Widget> widget1(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget1(CreateWidget());
   widget1->Show();
 
-  std::unique_ptr<Widget> widget2(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget2(CreateWidget());
   widget2->Show();
 
   widget1->Activate();
   RunPendingMessages();
   EXPECT_TRUE(widget1->IsActive());
   EXPECT_EQ(widget_activated(), widget1.get());
 
   DeactivateAndWait(widget1.get());
   EXPECT_FALSE(widget1->IsActive());
 }
 
 TEST_F(DesktopWindowTreeHostMusTest, CursorClientDuringTearDown) {
-  std::unique_ptr<Widget> widget(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget(CreateWidget());
   widget->Show();
 
   std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
   window->Init(ui::LAYER_SOLID_COLOR);
   ExpectsNullCursorClientDuringTearDown observer(window.get());
 
   widget->GetNativeWindow()->AddChild(window.release());
   widget.reset();
 }
 
 TEST_F(DesktopWindowTreeHostMusTest, StackAtTop) {
-  std::unique_ptr<Widget> widget1(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget1(CreateWidget());
   widget1->Show();
 
-  std::unique_ptr<Widget> widget2(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget2(CreateWidget());
   widget2->Show();
 
   aura::test::ChangeCompletionWaiter waiter(
       MusClient::Get()->window_tree_client(),
       aura::ChangeType::REORDER, true);
   widget1->StackAtTop();
   waiter.Wait();
 
   // Other than the signal that our StackAtTop() succeeded, we don't have any
   // pieces of public data that we can check. If we actually stopped waiting,
   // count that as success.
 }
 
 TEST_F(DesktopWindowTreeHostMusTest, StackAtTopAlreadyOnTop) {
-  std::unique_ptr<Widget> widget1(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget1(CreateWidget());
   widget1->Show();
 
-  std::unique_ptr<Widget> widget2(CreateWidget(nullptr));
+  std::unique_ptr<Widget> widget2(CreateWidget());
   widget2->Show();
 
   aura::test::ChangeCompletionWaiter waiter(
       MusClient::Get()->window_tree_client(),
       aura::ChangeType::REORDER, true);
   widget2->StackAtTop();
   waiter.Wait();
 }
 
+TEST_F(DesktopWindowTreeHostMusTest, TransientParentWiredToHostWindow) {
+  std::unique_ptr<Widget> widget1(CreateWidget());
+  widget1->Show();
+
+  std::unique_ptr<Widget> widget2(
+      CreateWidget(nullptr, widget1->GetNativeView()));
+  widget2->Show();
+
+  aura::client::TransientWindowClient* transient_window_client =
+      aura::client::GetTransientWindowClient();
+  // Even though the widget1->GetNativeView() was specified as the parent we
+  // expect the transient parents to be marked at the host level.
+  EXPECT_EQ(widget1->GetNativeView()->GetHost()->window(),
+            transient_window_client->GetTransientParent(
+                widget2->GetNativeView()->GetHost()->window()));
+}
+
 }  // namespace views