ash: fix regression where ctrl+n put new window on wrong desktop

chrome/browser/ui/window_sizer/window_sizer_ash_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/common/scoped_root_window_for_new_windows.h"
 #include "ash/common/wm/window_positioner.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
@@ skipping 398 matching lines @@
               window_bounds.ToString());
   }
 }
 
 // Test the placement of newly created windows.
 TEST_F(WindowSizerAshTest, PlaceNewWindows) {
   // Create a browser to pass into the GetWindowBounds function.
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
-  Browser::CreateParams native_params(profile.get());
+  Browser::CreateParams native_params(profile.get(), true);
   std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
-  Browser::CreateParams params2(profile.get());
+  Browser::CreateParams params2(profile.get(), true);
   std::unique_ptr<Browser> browser2(CreateTestBrowser(
       CreateTestWindowInShellWithId(0), gfx::Rect(16, 32, 640, 320), &params2));
   BrowserWindow* browser_window = browser2->window();
 
   // Creating a popup to make sure it does not interfere with the positioning.
-  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get());
+  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get(), true);
   std::unique_ptr<Browser> browser_popup(
       CreateTestBrowser(CreateTestWindowInShellWithId(1),
                         gfx::Rect(16, 32, 128, 256), &params_popup));
 
   // Creating a panel to make sure it does not interfere with the positioning.
-  Browser::CreateParams params_panel(Browser::TYPE_POPUP, profile.get());
+  Browser::CreateParams params_panel(Browser::TYPE_POPUP, profile.get(), true);
   std::unique_ptr<Browser> browser_panel(
       CreateTestBrowser(CreateTestWindowInShellWithId(2),
                         gfx::Rect(32, 48, 256, 512), &params_panel));
 
   browser_window->Show();
   { // Make sure that popups do not get changed.
     gfx::Rect window_bounds;
     GetWindowBounds(p1600x1200, p1600x1200, gfx::Rect(),
                     gfx::Rect(50, 100, 300, 150), bottom_s1600x1200, PERSISTED,
                     browser_popup.get(), gfx::Rect(), &window_bounds);
@@ skipping 27 matching lines @@
         window_bounds.ToString());
   }
 }
 
 // Test the placement of newly created windows on an empty desktop.
 // This test supplements "PlaceNewWindows" by testing the creation of a newly
 // created browser window on an empty desktop.
 TEST_F(WindowSizerAshTest, PlaceNewBrowserWindowOnEmptyDesktop) {
   // Create a browser to pass into the GetWindowBoundsAndShowState function.
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
-  Browser::CreateParams native_params(profile.get());
+  Browser::CreateParams native_params(profile.get(), true);
   std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 
   // A common screen size for Chrome OS devices where this behavior is
   // desirable.
   const gfx::Rect p1366x768(0, 0, 1366, 768);
 
   // If there is no previous state the window should get maximized if the
   // screen is less than or equal to our limit (1366 pixels width).
   gfx::Rect window_bounds;
@@ skipping 64 matching lines @@
 TEST_F(WindowSizerAshTest, MAYBE_PlaceNewWindowsOnMultipleDisplays) {
   UpdateDisplay("1600x1200,1600x1200");
   gfx::Rect primary_bounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
   gfx::Rect secondary_bounds =
       display_manager()->GetSecondaryDisplay().bounds();
 
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
 
   // Create browser windows that are used as reference.
-  Browser::CreateParams params(profile.get());
+  Browser::CreateParams params(profile.get(), true);
   std::unique_ptr<Browser> browser(CreateTestBrowser(
       CreateTestWindowInShellWithId(0), gfx::Rect(10, 10, 200, 200), &params));
   BrowserWindow* browser_window = browser->window();
   gfx::NativeWindow native_window = browser_window->GetNativeWindow();
   browser_window->Show();
   EXPECT_EQ(native_window->GetRootWindow(), ash::Shell::GetTargetRootWindow());
 
-  Browser::CreateParams another_params(profile.get());
+  Browser::CreateParams another_params(profile.get(), true);
   std::unique_ptr<Browser> another_browser(
       CreateTestBrowser(CreateTestWindowInShellWithId(1),
                         gfx::Rect(400, 10, 300, 300), &another_params));
   BrowserWindow* another_browser_window = another_browser->window();
   gfx::NativeWindow another_native_window =
       another_browser_window->GetNativeWindow();
   another_browser_window->Show();
 
   // Creating a new window to verify the new placement.
-  Browser::CreateParams new_params(profile.get());
+  Browser::CreateParams new_params(profile.get(), true);
   std::unique_ptr<Browser> new_browser(CreateTestBrowser(
       CreateTestWindowInShellWithId(0), gfx::Rect(), &new_params));
 
   // Make sure the primary root is active.
   ASSERT_EQ(ash::Shell::GetPrimaryRootWindow(),
             ash::Shell::GetTargetRootWindow());
 
   // First new window should be in the primary.
   {
     gfx::Rect window_bounds;
@@ skipping 48 matching lines @@
     // RearrangeVisibleWindowOnShow.
     EXPECT_TRUE(primary_bounds.Contains(window_bounds));
   }
 }
 
 // Test that the show state is properly returned for non default cases.
 TEST_F(WindowSizerAshTest, TestShowState) {
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
 
   // Creating a browser & window to play with.
-  Browser::CreateParams params(Browser::TYPE_TABBED, profile.get());
+  Browser::CreateParams params(Browser::TYPE_TABBED, profile.get(), true);
   std::unique_ptr<Browser> browser(CreateTestBrowser(
       CreateTestWindowInShellWithId(0), gfx::Rect(16, 32, 640, 320), &params));
 
   // Create also a popup browser since that behaves different.
-  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get());
+  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get(), true);
   std::unique_ptr<Browser> browser_popup(
       CreateTestBrowser(CreateTestWindowInShellWithId(1),
                         gfx::Rect(16, 32, 640, 320), &params_popup));
 
   // Tabbed windows should retrieve the saved window state - since there is a
   // top window.
   EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED,
             GetWindowShowState(ui::SHOW_STATE_MAXIMIZED, ui::SHOW_STATE_NORMAL,
                                BOTH, browser.get(), p1600x1200, p1600x1200));
   // A window that is smaller than the whole work area is set to default state.
@@ skipping 11 matching lines @@
                          browser_popup.get(), p1600x1200, p1600x1200));
   // The non tabbed window will take the status of the last active of its kind.
   EXPECT_EQ(
       ui::SHOW_STATE_NORMAL,
       GetWindowShowState(ui::SHOW_STATE_DEFAULT, ui::SHOW_STATE_NORMAL, BOTH,
                          browser_popup.get(), p1600x1200, p1600x1200));
 
   // Now create a top level window and check again for both. Only the tabbed
   // window should follow the top level window's state.
   // Creating a browser & window to play with.
-  Browser::CreateParams params2(Browser::TYPE_TABBED, profile.get());
+  Browser::CreateParams params2(Browser::TYPE_TABBED, profile.get(), true);
   std::unique_ptr<Browser> browser2(CreateTestBrowser(
       CreateTestWindowInShellWithId(3), gfx::Rect(16, 32, 640, 320), &params2));
 
   // A tabbed window should now take the top level window state.
   EXPECT_EQ(ui::SHOW_STATE_DEFAULT,
             GetWindowShowState(ui::SHOW_STATE_MAXIMIZED, ui::SHOW_STATE_DEFAULT,
                                BOTH, browser.get(), p1600x1200, p1600x1200));
   // Non tabbed windows should always follow the window saved visibility state.
   EXPECT_EQ(
       ui::SHOW_STATE_MAXIMIZED,
@@ skipping 15 matching lines @@
         GetWindowShowState(ui::SHOW_STATE_MAXIMIZED, ui::SHOW_STATE_DEFAULT,
                            BOTH, browser2.get(), tiny_screen, tiny_screen));
   }
 }
 
 // Test that the default show state override behavior is properly handled.
 TEST_F(WindowSizerAshTest, TestShowStateDefaults) {
   // Creating a browser & window to play with.
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
 
-  Browser::CreateParams params(Browser::TYPE_TABBED, profile.get());
+  Browser::CreateParams params(Browser::TYPE_TABBED, profile.get(), true);
   std::unique_ptr<Browser> browser(CreateTestBrowser(
       CreateTestWindowInShellWithId(0), gfx::Rect(16, 32, 640, 320), &params));
 
   // Create also a popup browser since that behaves slightly different for
   // defaults.
-  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get());
+  Browser::CreateParams params_popup(Browser::TYPE_POPUP, profile.get(), true);
   std::unique_ptr<Browser> browser_popup(
       CreateTestBrowser(CreateTestWindowInShellWithId(1),
                         gfx::Rect(16, 32, 128, 256), &params_popup));
 
   // Check that a browser creation state always get used if not given as
   // SHOW_STATE_DEFAULT. On Windows ASH it should be SHOW_STATE_MAXIMIZED.
   ui::WindowShowState window_show_state =
       GetWindowShowState(ui::SHOW_STATE_MAXIMIZED, ui::SHOW_STATE_MAXIMIZED,
                          DEFAULT, browser.get(), p1600x1200, p1600x1200);
 #if defined(OS_WIN)
@@ skipping 30 matching lines @@
   // The popup should favor the initial show state over the command line.
   EXPECT_EQ(
       GetWindowShowState(ui::SHOW_STATE_NORMAL, ui::SHOW_STATE_NORMAL, BOTH,
                          browser_popup.get(), p1600x1200, p1600x1200),
       ui::SHOW_STATE_NORMAL);
 }
 
 TEST_F(WindowSizerAshTest, DefaultStateBecomesMaximized) {
   // Create a browser to pass into the GetWindowBounds function.
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
-  Browser::CreateParams native_params(profile.get());
+  Browser::CreateParams native_params(profile.get(), true);
   std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 
   gfx::Rect display_bounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
   gfx::Rect specified_bounds = display_bounds;
 
   // Make a window bigger than the display work area.
   specified_bounds.Inset(-20, -20);
   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
@@ skipping 45 matching lines @@
         NULL,
         &bounds,
         &show_state);
     EXPECT_TRUE(second_root->GetBoundsInScreen().Contains(bounds));
   }
 }
 
 TEST_F(WindowSizerAshTest, TrustedPopupBehavior) {
   std::unique_ptr<TestingProfile> profile(new TestingProfile());
   Browser::CreateParams trusted_popup_create_params(Browser::TYPE_POPUP,
-                                                    profile.get());
+                                                    profile.get(), true);
   trusted_popup_create_params.trusted_source = true;
 
   std::unique_ptr<Browser> trusted_popup(CreateTestBrowser(
       CreateTestWindowInShellWithId(1), gfx::Rect(16, 32, 640, 320),
       &trusted_popup_create_params));
   // Trusted popup windows should follow the saved show state and ignore the
   // last show state.
   EXPECT_EQ(
       ui::SHOW_STATE_DEFAULT,
       GetWindowShowState(ui::SHOW_STATE_DEFAULT, ui::SHOW_STATE_NORMAL, BOTH,
                          trusted_popup.get(), p1280x1024, p1600x1200));
   // A popup that is sized to occupy the whole work area has default state.
   EXPECT_EQ(
       ui::SHOW_STATE_DEFAULT,
       GetWindowShowState(ui::SHOW_STATE_DEFAULT, ui::SHOW_STATE_NORMAL, BOTH,
                          trusted_popup.get(), p1600x1200, p1600x1200));
 }