Desktop aura: Break aura::Window::SetParent in two.

ash/wm/activation_controller_unittest.cc

 // Copyright (c) 2012 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 "ash/wm/activation_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_activation_delegate.h"
@@ skipping 54 matching lines @@
   aura::Window* w7() { return w7_.get(); }
 
   void DestroyWindow2() {
     w2_.reset();
   }
 
  private:
   void CreateWindows() {
     // Create four windows, the first and third are not activatable, the second
     // and fourth are.
-    w1_.reset(CreateWindow(1, &ad_1_, kDefaultContainerID));
-    w2_.reset(CreateWindow(2, &ad_2_, kDefaultContainerID));
-    w3_.reset(CreateWindow(3, &ad_3_, kDefaultContainerID));
-    w4_.reset(CreateWindow(4, &ad_4_, kDefaultContainerID));
-    w5_.reset(CreateWindow(5, &ad_5_, c2));
-    w6_.reset(CreateWindow(6, &ad_6_, c2));
-    w7_.reset(CreateWindow(7, &ad_7_, c3));
+    w1_.reset(CreateWindowInShell(1, &ad_1_));
+    w2_.reset(CreateWindowInShell(2, &ad_2_));
+    w3_.reset(CreateWindowInShell(3, &ad_3_));
+    w4_.reset(CreateWindowInShell(4, &ad_4_));
+    w5_.reset(CreateWindowWithID(5, &ad_5_, c2));
+    w6_.reset(CreateWindowWithID(6, &ad_6_, c2));
+    w7_.reset(CreateWindowWithID(7, &ad_7_, c3));
   }
 
-  aura::Window* CreateWindow(int id,
-                             TestActivationDelegate* delegate,
-                             int container_id) {
-    aura::Window* parent = container_id == kDefaultContainerID ? NULL :
+  aura::Window* CreateWindowInShell(int id,
+                                    TestActivationDelegate* delegate) {
+    aura::Window* window = CreateTestWindowInShellWithDelegate(
+        &delegate_,
+        id,
+        gfx::Rect());
+    delegate->SetWindow(window);
+    return window;
+  }
+
+  aura::Window* CreateWindowWithID(int id,
+                                   TestActivationDelegate* delegate,
+                                   int container_id) {
+    aura::Window* parent =
         Shell::GetContainer(Shell::GetPrimaryRootWindow(), container_id);
     aura::Window* window = aura::test::CreateTestWindowWithDelegate(
         &delegate_,
         id,
         gfx::Rect(),
         parent);
     delegate->SetWindow(window);
     return window;
   }
 
@@ skipping 87 matching lines @@
   EXPECT_TRUE(wm::IsActiveWindow(w4()));
 }
 
 // Test if the clicking on a menu picks the transient parent as activatable
 // window.
 TEST_F(ActivationControllerTest, ClickOnMenu) {
   aura::test::TestWindowDelegate wd;
   TestActivationDelegate ad1;
   TestActivationDelegate ad2(false);
 
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, 1, gfx::Rect(100, 100), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, 1, gfx::Rect(100, 100)));
   ad1.SetWindow(w1.get());
   EXPECT_EQ(NULL, wm::GetActiveWindow());
 
   // Clicking on an activatable window activates the window.
   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), w1.get());
   generator.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
   // Creates a menu that covers the transient parent.
-  scoped_ptr<aura::Window> menu(aura::test::CreateTestWindowWithDelegateAndType(
-      &wd, aura::client::WINDOW_TYPE_MENU, 2, gfx::Rect(100, 100), NULL));
+  scoped_ptr<aura::Window> menu(CreateTestWindowInShellWithDelegateAndType(
+      &wd, aura::client::WINDOW_TYPE_MENU, 2, gfx::Rect(100, 100)));
   ad2.SetWindow(menu.get());
   w1->AddTransientChild(menu.get());
 
   // Clicking on a menu whose transient parent is active window shouldn't
   // change the active window.
   generator.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 }
 
 // Various assertions for activating/deactivating.
 TEST_F(ActivationControllerTest, Deactivate) {
   aura::test::TestWindowDelegate d1;
   aura::test::TestWindowDelegate d2;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &d1, 1, gfx::Rect(), NULL));
-  scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &d2, 2, gfx::Rect(), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &d1, 1, gfx::Rect()));
+  scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate(
+      &d2, 2, gfx::Rect()));
   aura::Window* parent = w1->parent();
   parent->Show();
   ASSERT_TRUE(parent);
   ASSERT_EQ(2u, parent->children().size());
   // Activate w2 and make sure it's active and frontmost.
   wm::ActivateWindow(w2.get());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
   EXPECT_EQ(w2.get(), parent->children()[1]);
 
   // Activate w1 and make sure it's active and frontmost.
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
   EXPECT_EQ(w1.get(), parent->children()[1]);
 
   // Deactivate w1 and make sure w2 becomes active and frontmost.
   wm::DeactivateWindow(w1.get());
   EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_EQ(w2.get(), parent->children()[1]);
 }
 
 // Verifies that when WindowDelegate::OnLostActive is invoked the window is not
 // active.
 TEST_F(ActivationControllerTest, NotActiveInLostActive) {
   TestActivationDelegate ad1;
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, 1, gfx::Rect(10, 10, 50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, 1, gfx::Rect(10, 10, 50, 50)));
   ad1.SetWindow(w1.get());
-  scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      NULL, 1, gfx::Rect(10, 10, 50, 50), NULL));
+  scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate(
+      NULL, 1, gfx::Rect(10, 10, 50, 50)));
 
   // Activate w1.
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_EQ(1, ad1.activated_count());
   // Should not have gotten a OnLostActive yet.
   EXPECT_EQ(0, ad1.lost_active_count());
 
   // Deactivate the active window.
   wm::DeactivateWindow(w1.get());
@@ skipping 16 matching lines @@
   // active window in OnLostActive.
   EXPECT_EQ(0, ad1.activated_count());
   EXPECT_EQ(1, ad1.lost_active_count());
   EXPECT_FALSE(ad1.window_was_active());
 }
 
 // Verifies that focusing another window or its children causes it to become
 // active.
 TEST_F(ActivationControllerTest, FocusTriggersActivation) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, -1, gfx::Rect(50, 50), NULL));
-  scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &wd, -2, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, -1, gfx::Rect(50, 50)));
+  scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate(
+      &wd, -2, gfx::Rect(50, 50)));
   scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate(
       &wd, -21, gfx::Rect(50, 50), w2.get()));
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->HasFocus());
 
   w2->Focus();
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w2->HasFocus());
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->HasFocus());
 
   w21->Focus();
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w21->HasFocus());
 }
 
 // Verifies that we prevent all attempts to focus a child of a non-activatable
 // window from claiming focus to that window.
 TEST_F(ActivationControllerTest, PreventFocusToNonActivatableWindow) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, -1, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, -1, gfx::Rect(50, 50)));
   // The RootWindow is a non-activatable parent.
   scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
       &wd, -2, gfx::Rect(50, 50), Shell::GetPrimaryRootWindow()));
   scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate(
       &wd, -21, gfx::Rect(50, 50), w2.get()));
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->HasFocus());
 
@@ skipping 17 matching lines @@
   EXPECT_FALSE(w21->HasFocus());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->HasFocus());
 }
 
 TEST_F(ActivationControllerTest, CanActivateWindowIteselfTest)
 {
   aura::test::TestWindowDelegate wd;
 
   // Normal Window
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, -1, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, -1, gfx::Rect(50, 50)));
   EXPECT_TRUE(wm::CanActivateWindow(w1.get()));
 
   // The RootWindow is a non-activatable parent.
   scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
       &wd, -2, gfx::Rect(50, 50), Shell::GetPrimaryRootWindow()));
   scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate(
       &wd, -21, gfx::Rect(50, 50), w2.get()));
   EXPECT_FALSE(wm::CanActivateWindow(w2.get()));
   EXPECT_FALSE(wm::CanActivateWindow(w21.get()));
 
   // The window has a transient child.
-  scoped_ptr<aura::Window> w3(aura::test::CreateTestWindowWithDelegate(
-      &wd, -3, gfx::Rect(50, 50), NULL));
-  scoped_ptr<aura::Window> w31(aura::test::CreateTestWindowWithDelegate(
-      &wd, -31, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w3(CreateTestWindowInShellWithDelegate(
+      &wd, -3, gfx::Rect(50, 50)));
+  scoped_ptr<aura::Window> w31(CreateTestWindowInShellWithDelegate(
+      &wd, -31, gfx::Rect(50, 50)));
   w3->AddTransientChild(w31.get());
   EXPECT_TRUE(wm::CanActivateWindow(w3.get()));
   EXPECT_TRUE(wm::CanActivateWindow(w31.get()));
 
   // The window has a transient window-modal child.
-  scoped_ptr<aura::Window> w4(aura::test::CreateTestWindowWithDelegate(
-      &wd, -4, gfx::Rect(50, 50), NULL));
-  scoped_ptr<aura::Window> w41(aura::test::CreateTestWindowWithDelegate(
-      &wd, -41, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w4(CreateTestWindowInShellWithDelegate(
+      &wd, -4, gfx::Rect(50, 50)));
+  scoped_ptr<aura::Window> w41(CreateTestWindowInShellWithDelegate(
+      &wd, -41, gfx::Rect(50, 50)));
   w4->AddTransientChild(w41.get());
   w41->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   EXPECT_FALSE(wm::CanActivateWindow(w4.get()));
   EXPECT_TRUE(wm::CanActivateWindow(w41.get()));
 
   // The window has a transient system-modal child.
-  scoped_ptr<aura::Window> w5(aura::test::CreateTestWindowWithDelegate(
-      &wd, -5, gfx::Rect(50, 50), NULL));
-  scoped_ptr<aura::Window> w51(aura::test::CreateTestWindowWithDelegate(
-      &wd, -51, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w5(CreateTestWindowInShellWithDelegate(
+      &wd, -5, gfx::Rect(50, 50)));
+  scoped_ptr<aura::Window> w51(CreateTestWindowInShellWithDelegate(
+      &wd, -51, gfx::Rect(50, 50)));
   w5->AddTransientChild(w51.get());
   w51->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
   EXPECT_TRUE(wm::CanActivateWindow(w5.get()));
   EXPECT_TRUE(wm::CanActivateWindow(w51.get()));
 }
 
 // Verifies code in ActivationController::OnWindowVisibilityChanged() that keeps
 // hiding windows layers stacked above the newly active window while they
 // animate away.
 TEST_F(ActivationControllerTest, AnimateHideMaintainsStacking) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-    &wd, -1, gfx::Rect(50, 50, 50, 50), NULL));
-  scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &wd, -2, gfx::Rect(75, 75, 50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+    &wd, -1, gfx::Rect(50, 50, 50, 50)));
+  scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate(
+      &wd, -2, gfx::Rect(75, 75, 50, 50)));
   wm::ActivateWindow(w2.get());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   w2->Hide();
   typedef std::vector<ui::Layer*> Layers;
   const Layers& children = w1->parent()->layer()->children();
   Layers::const_iterator w1_iter =
       std::find(children.begin(), children.end(), w1->layer());
   Layers::const_iterator w2_iter =
       std::find(children.begin(), children.end(), w2->layer());
   EXPECT_TRUE(w2_iter > w1_iter);
 }
 
 // Verifies that activating a minimized window would restore it.
 TEST_F(ActivationControllerTest, ActivateMinimizedWindow) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &wd, -1, gfx::Rect(50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+      &wd, -1, gfx::Rect(50, 50)));
 
   wm::MinimizeWindow(w1.get());
   EXPECT_TRUE(wm::IsWindowMinimized(w1.get()));
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_FALSE(wm::IsWindowMinimized(w1.get()));
 }
 
 // Verifies that a minimized window would not be automatically activated as
 // a replacement active window.
 TEST_F(ActivationControllerTest, NoAutoActivateMinimizedWindow) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-    &wd, -1, gfx::Rect(50, 50, 50, 50), NULL));
-  scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &wd, -2, gfx::Rect(75, 75, 50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+    &wd, -1, gfx::Rect(50, 50, 50, 50)));
+  scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate(
+      &wd, -2, gfx::Rect(75, 75, 50, 50)));
 
   wm::MinimizeWindow(w1.get());
   EXPECT_TRUE(wm::IsWindowMinimized(w1.get()));
 
   wm::ActivateWindow(w2.get());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 
   w2->Hide();
 
   EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(wm::IsWindowMinimized(w1.get()));
 }
 
 // Verifies that a window with a hidden layer can be activated.
 TEST_F(ActivationControllerTest, ActivateWithHiddenLayer) {
   aura::test::TestWindowDelegate wd;
-  scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-    &wd, -1, gfx::Rect(50, 50, 50, 50), NULL));
+  scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
+    &wd, -1, gfx::Rect(50, 50, 50, 50)));
 
   EXPECT_TRUE(wm::CanActivateWindow(w1.get()));
   w1->layer()->SetVisible(false);
   EXPECT_TRUE(wm::CanActivateWindow(w1.get()));
 }
 
 // Verifies that a unrelated window cannot be activated when in a system modal
 // dialog.
 TEST_F(ActivationControllerTest, DontActivateWindowWhenInSystemModalDialog) {
-  scoped_ptr<aura::Window> normal_window(
-      aura::test::CreateTestWindowWithId(-1, NULL));
+  scoped_ptr<aura::Window> normal_window(CreateTestWindowInShellWithId(-1));
   EXPECT_FALSE(wm::IsActiveWindow(normal_window.get()));
   wm::ActivateWindow(normal_window.get());
   EXPECT_TRUE(wm::IsActiveWindow(normal_window.get()));
 
   // Create and activate a system modal window.
   aura::Window* modal_container =
       ash::Shell::GetContainer(
           Shell::GetPrimaryRootWindow(),
           ash::internal::kShellWindowId_SystemModalContainer);
   scoped_ptr<aura::Window> modal_window(
@@ skipping 26 matching lines @@
   scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
     &wd, -1, gfx::Rect(50, 50, 50, 50), lock_container));
 
   lock_container->layer()->SetVisible(false);
   w1->Focus();
   EXPECT_TRUE(w1->HasFocus());
 }
 
 }  // namespace test
 }  // namespace ash