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

ash/wm/workspace/workspace_manager_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/workspace/workspace_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
@@ skipping 36 matching lines @@
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     return window;
   }
 
   aura::Window* CreateTestWindow() {
     aura::Window* window = new aura::Window(NULL);
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
-    window->SetParent(NULL);
+    AddToRootWindow(window);
     return window;
   }
 
   aura::Window* GetViewport() {
     return Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                kShellWindowId_DefaultContainer);
   }
 
   const std::vector<Workspace*>& workspaces() const {
     return manager_->workspaces_;
@@ skipping 245 matching lines @@
   // workspace.
   w1->SetBounds(gfx::Rect(0, 0, 200, 500));
   EXPECT_EQ(200, w1->bounds().width());
   EXPECT_EQ(500, w1->bounds().height());
 }
 
 // Verifies the bounds is not altered when showing and grid is enabled.
 TEST_F(WorkspaceManagerTest, SnapToGrid) {
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   w1->SetBounds(gfx::Rect(1, 6, 25, 30));
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   // We are not aligning this anymore this way. When the window gets shown
   // the window is expected to be handled differently, but this cannot be
   // tested with this test. So the result of this test should be that the
   // bounds are exactly as passed in.
   EXPECT_EQ("1,6 25x30", w1->bounds().ToString());
 }
 
 // Assertions around a fullscreen window.
 TEST_F(WorkspaceManagerTest, SingleFullscreenWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
@@ skipping 495 matching lines @@
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   ASSERT_EQ("0 M2 active=1", StateString());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
   // Create another transient child of |w1|. We do this unparented, set up the
   // transient parent then set parent. This is how NativeWidgetAura does things
   // too.
   scoped_ptr<Window> w3(CreateTestWindowUnparented());
   w1->AddTransientChild(w3.get());
-  w3->SetParent(NULL);
+  AddToRootWindow(w3.get());
   w3->Show();
   ASSERT_EQ("0 M3 active=1", StateString());
 
   // Minimize the window. All the transients are hidden as a result, so it ends
   // up in pending.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   ASSERT_EQ("0 P=M3 active=0", StateString());
 
   // Restore and everything should go back to the first workspace.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
@@ skipping 169 matching lines @@
 // . minimize a maximized window.
 // . remove the window (which happens when switching displays).
 // . add the window back.
 // . show the window and during the bounds change activate it.
 TEST_F(WorkspaceManagerTest, DontCrashOnChangeAndActivate) {
   // Force the shelf
   ShelfLayoutManager* shelf = shelf_layout_manager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 
   DontCrashOnChangeAndActivateDelegate delegate;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&delegate, 1000, gfx::Rect(10, 11, 250, 251),

[sky, 2012/11/21 23:35:59]

Doesn't this still work (well, removing the last arg)?

-                                   NULL));
+  scoped_ptr<Window> w1(new Window(&delegate));
+  w1->set_id(1000);
+  w1->SetType(aura::client::WINDOW_TYPE_NORMAL);
+  w1->Init(ui::LAYER_TEXTURED);
+  w1->SetBounds(gfx::Rect(10, 11, 250, 251));
+  w1->SetProperty(aura::client::kCanMaximizeKey, true);
+  AddToRootWindow(w1.get());
+
   w1->Show();
   wm::ActivateWindow(w1.get());
   wm::MaximizeWindow(w1.get());
   wm::MinimizeWindow(w1.get());
 
   w1->parent()->RemoveChild(w1.get());
 
   // Do this so that when we Show() the window a resize occurs and we make the
   // window active.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   delegate.set_window(w1.get());
   w1->Show();
 }
 
 // Verifies a window with a transient parent not managed by workspace works.
 TEST_F(WorkspaceManagerTest, TransientParent) {
   // Normal window with no transient parent.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Window with a transient parent. We set the transient parent to the root,
   // which would never happen but is enough to exercise the bug.
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   Shell::GetInstance()->GetPrimaryRootWindow()->AddTransientChild(w1.get());
   w1->SetBounds(gfx::Rect(10, 11, 250, 251));
-  w1->SetParent(NULL);
+  AddToRootWindow(w1.get());
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // The window with the transient parent should get added to the same parent as
   // the normal window.
   EXPECT_EQ(w2->parent(), w1->parent());
 }
 
 // Verifies changing TrackedByWorkspace works.
 TEST_F(WorkspaceManagerTest, TrackedByWorkspace) {
   // Create a window maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create a second window maximized and mark it not tracked by workspace
   // manager.
   scoped_ptr<Window> w2(CreateTestWindowUnparented());
   w2->SetBounds(gfx::Rect(1, 6, 25, 30));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  w2->SetParent(NULL);
+  AddToRootWindow(w2.get());
   w2->Show();
   SetTrackedByWorkspace(w2.get(), false);
   wm::ActivateWindow(w2.get());
 
   // Activating |w2| should force it to have the same parent as |w1|.
   EXPECT_EQ(w1->parent(), w2->parent());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
 
@@ skipping 37 matching lines @@
   // Activate |w1|, should result in dropping |w2| to the desktop.
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("1 M1 active=1", StateString());
 }
 
 // Test the basic auto placement of one and or two windows in a "simulated
 // session" of sequential window operations.
 TEST_F(WorkspaceManagerTest, BasicAutoPlacing) {
   // Test 1: In case there is no manageable window, no window should shift.
 
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
 
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   // Trigger the auto window placement function by making it visible.
   // Note that the bounds are getting changed while it is invisible.
   window2->Hide();
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window2->Show();
 
   // Check the initial position of the windows is unchanged.
   EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
   EXPECT_EQ("32,48 256x512", window2->bounds().ToString());
 
   // Remove the second window and make sure that the first window
   // does NOT get centered.
   window2.reset();
   EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
 
   // Test 2: Set up two managed windows and check their auto positioning.
   ash::wm::SetWindowPositionManaged(window1.get(), true);
-  scoped_ptr<aura::Window> window3(
-      aura::test::CreateTestWindowWithId(2, NULL));
+  scoped_ptr<aura::Window> window3(CreateTestWindowInShellWithId(2));
   ash::wm::SetWindowPositionManaged(window3.get(), true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window3->Hide();
   window3->SetBounds(gfx::Rect(32, 48, 256, 512));
   window3->Show();
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window3->bounds().width()) +
             ",48 256x512", window3->bounds().ToString());
 
   // After removing |window3|, |window1| should be centered again.
   window3.reset();
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
 
   // Test 3: Set up a manageable and a non manageable window and check
   // positioning.
-  scoped_ptr<aura::Window> window4(
-      aura::test::CreateTestWindowWithId(3, NULL));
+  scoped_ptr<aura::Window> window4(CreateTestWindowInShellWithId(3));
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   window4->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Show();
   // |window1| should be centered and |window4| untouched.
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("32,48 256x512", window4->bounds().ToString());
 
   // Test4: A single manageable window should get centered.
   window4.reset();
   ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), false);
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
   // |window1| should be centered.
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
 }
 
 // Test the proper usage of user window movement interaction.
 TEST_F(WorkspaceManagerTest, TestUserMovedWindowRepositioning) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
   EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window2.get()));
 
   // Check that the current location gets preserved if the user has
   // positioned it previously.
@@ skipping 20 matching lines @@
   // Going back to one shown window should keep the state.
   ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), true);
   window2->Hide();
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_TRUE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
 }
 
 // Test that user placed windows go back to their user placement after the user
 // closes all other windows.
 TEST_F(WorkspaceManagerTest, TestUserHandledWindowRestore) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   gfx::Rect user_pos = gfx::Rect(16, 42, 640, 320);
   window1->SetBounds(user_pos);
   ash::wm::SetPreAutoManageWindowBounds(window1.get(), user_pos);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   // Create a second window to let the auto manager kick in.
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window1->Show();
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0," + base::IntToString(user_pos.y()) +
             " 640x320", window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
       ",48 256x512", window2->bounds().ToString());
   window2->Hide();
 
   // After the other window get hidden the window has to move back to the
   // previous position and the bounds should still be set and unchanged.
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
   ASSERT_TRUE(ash::wm::GetPreAutoManageWindowBounds(window1.get()));
   EXPECT_EQ(user_pos.ToString(),
             ash::wm::GetPreAutoManageWindowBounds(window1.get())->ToString());
 }
 
 // Test that a window from normal to minimize will repos the remaining.
 TEST_F(WorkspaceManagerTest, ToMinimizeRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
 
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   ash::wm::MinimizeWindow(window1.get());
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 
   ash::wm::RestoreWindow(window1.get());
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // Test that minimizing an initially maximized window will repos the remaining.
 TEST_F(WorkspaceManagerTest, MaxToMinRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   ash::wm::MaximizeWindow(window1.get());
   ash::wm::MinimizeWindow(window1.get());
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, minimizing will repos the remaining.
 TEST_F(WorkspaceManagerTest, NormToMaxToMinRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
   ash::wm::MaximizeWindow(window1.get());
   ash::wm::MinimizeWindow(window1.get());
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",40 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, normal will repos the remaining.
 TEST_F(WorkspaceManagerTest, NormToMaxToNormRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
   ash::wm::MaximizeWindow(window1.get());
   ash::wm::RestoreWindow(window1.get());
 
   // |window1| should be flush right and |window2| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 }
 
 // Test that animations are triggered.
 TEST_F(WorkspaceManagerTest, AnimatedNormToMaxToNormRepositionsRemaining) {
   ui::LayerAnimator::set_disable_animations_for_test(false);
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
+  scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
+  scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->Hide();
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   // Make sure nothing is animating.
   window1->layer()->GetAnimator()->StopAnimating();
   window2->layer()->GetAnimator()->StopAnimating();
   window2->Show();
 
@@ skipping 10 matching lines @@
   window2->layer()->GetAnimator()->StopAnimating();
   // |window1| should be flush right and |window2| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 }  // namespace internal
 }  // namespace ash