Makes a window that has been resized to maximized bounds, then maximized and then restored shrink

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/scoped_target_root_window.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_positioner.h"
@@ skipping 451 matching lines @@
 // On desktop linux aura, we currently don't use the ash frame, breaking some
 // tests which expect ash sizes: http://crbug.com/303862
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #define MAYBE_PlaceNewWindows DISABLED_PlaceNewWindows
 #else
 #define MAYBE_PlaceNewWindows PlaceNewWindows
 #endif
 
 // Test the placement of newly created windows.
 TEST_F(WindowSizerAshTest, MAYBE_PlaceNewWindows) {
-  // Create a browser which we can use to pass into the GetWindowBounds
-  // function.
+  // Create a browser to pass into the GetWindowBounds function.
   scoped_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(),
                                       chrome::HOST_DESKTOP_TYPE_ASH);
   scoped_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
@@ skipping 58 matching lines @@
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #define MAYBE_PlaceNewBrowserWindowOnEmptyDesktop DISABLED_PlaceNewBrowserWindowOnEmptyDesktop
 #else
 #define MAYBE_PlaceNewBrowserWindowOnEmptyDesktop PlaceNewBrowserWindowOnEmptyDesktop
 #endif
 
 // 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, MAYBE_PlaceNewBrowserWindowOnEmptyDesktop) {
-  // Create a browser which we can use to pass into the GetWindowBounds
-  // function.
+  // Create a browser to pass into the GetWindowBoundsAndShowState function.
   scoped_ptr<TestingProfile> profile(new TestingProfile());
   Browser::CreateParams native_params(profile.get(),
                                       chrome::HOST_DESKTOP_TYPE_ASH);
   scoped_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);
 
@@ skipping 181 matching lines @@
       Browser::CreateParams(Browser::TYPE_POPUP, profile.get(),
                             chrome::HOST_DESKTOP_TYPE_ASH)));
 
   // 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_window->browser(),
+                               p1600x1200,
                                p1600x1200));
+  // A window that is smaller than the whole work area is set to default state.
   EXPECT_EQ(ui::SHOW_STATE_DEFAULT,
             GetWindowShowState(ui::SHOW_STATE_DEFAULT,
                                ui::SHOW_STATE_NORMAL,
                                BOTH,
                                browser_window->browser(),
+                               p1280x1024,
+                               p1600x1200));
+  // A window that is sized to occupy the whole work area is maximized.
+  EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED,
+            GetWindowShowState(ui::SHOW_STATE_DEFAULT,
+                               ui::SHOW_STATE_NORMAL,
+                               BOTH,
+                               browser_window->browser(),
+                               p1600x1200,
                                p1600x1200));
   // Non tabbed windows should always follow the window saved visibility state.
   EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED,
             GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                ui::SHOW_STATE_NORMAL,
                                BOTH,
                                browser_popup->browser(),
+                               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->browser(),
+                               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.
   scoped_ptr<TestBrowserWindowAura> browser_window2(CreateTestBrowserWindow(
       CreateTestWindowInShellWithId(3),
       gfx::Rect(16, 32, 640, 320),
       Browser::CreateParams(Browser::TYPE_TABBED, profile.get(),
                             chrome::HOST_DESKTOP_TYPE_ASH)));
 
   // 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_window->browser(),
+                               p1600x1200,
                                p1600x1200));
   // Non tabbed windows should always follow the window saved visibility state.
   EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED,
             GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                ui::SHOW_STATE_MINIMIZED,
                                BOTH,
                                browser_popup->browser(),
+                               p1600x1200,
                                p1600x1200));
 
   // In smaller screen resolutions we default to maximized if there is no other
   // window visible.
   int min_size = ash::WindowPositioner::GetForceMaximizedWidthLimit() / 2;
   if (min_size > 0) {
     const gfx::Rect tiny_screen(0, 0, min_size, min_size);
     EXPECT_EQ(ui::SHOW_STATE_DEFAULT,
               GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                  ui::SHOW_STATE_DEFAULT,
                                  BOTH,
                                  browser_window->browser(),
+                                 tiny_screen,
                                  tiny_screen));
     browser_window->Hide();
     EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED,
               GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                  ui::SHOW_STATE_DEFAULT,
                                  BOTH,
                                  browser_window2->browser(),
+                                 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.
   scoped_ptr<TestingProfile> profile(new TestingProfile());
 
@@ skipping 11 matching lines @@
       Browser::CreateParams(Browser::TYPE_POPUP, profile.get(),
                             chrome::HOST_DESKTOP_TYPE_ASH)));
 
   // 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_window->browser(),
+                         p1600x1200,
                          p1600x1200);
 #if defined(OS_WIN)
   EXPECT_EQ(window_show_state, ui::SHOW_STATE_MAXIMIZED);
 #else
   EXPECT_EQ(window_show_state, ui::SHOW_STATE_DEFAULT);
 #endif
 
   browser_window->browser()->set_initial_show_state(ui::SHOW_STATE_MINIMIZED);
   EXPECT_EQ(GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                ui::SHOW_STATE_MAXIMIZED,
                                BOTH,
                                browser_window->browser(),
+                               p1600x1200,
                                p1600x1200), ui::SHOW_STATE_MINIMIZED);
   browser_window->browser()->set_initial_show_state(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(GetWindowShowState(ui::SHOW_STATE_MAXIMIZED,
                                ui::SHOW_STATE_MAXIMIZED,
                                BOTH,
                                browser_window->browser(),
+                               p1600x1200,
                                p1600x1200), ui::SHOW_STATE_NORMAL);
   browser_window->browser()->set_initial_show_state(ui::SHOW_STATE_MAXIMIZED);
   EXPECT_EQ(GetWindowShowState(ui::SHOW_STATE_NORMAL,
                                ui::SHOW_STATE_NORMAL,
                                BOTH,
                                browser_window->browser(),
+                               p1600x1200,
                                p1600x1200), ui::SHOW_STATE_MAXIMIZED);
 
   // Check that setting the maximized command line option is forcing the
   // maximized state.
   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kStartMaximized);
 
   browser_window->browser()->set_initial_show_state(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(GetWindowShowState(ui::SHOW_STATE_NORMAL,
                                ui::SHOW_STATE_NORMAL,
                                BOTH,
                                browser_window->browser(),
+                               p1600x1200,
                                p1600x1200), ui::SHOW_STATE_MAXIMIZED);
 
   // 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->browser(),
+                               p1600x1200,
                                p1600x1200), ui::SHOW_STATE_NORMAL);
 }
 
-// Test that the target root window is used as the destionation of
+TEST_F(WindowSizerAshTest, DefaultStateBecomesMaximized) {
+  // Create a browser to pass into the GetWindowBounds function.
+  scoped_ptr<TestingProfile> profile(new TestingProfile());
+  Browser::CreateParams native_params(profile.get(),
+                                      chrome::HOST_DESKTOP_TYPE_ASH);
+  scoped_ptr<Browser> browser(
+      chrome::CreateBrowserWithTestWindowForParams(&native_params));
+
+  gfx::Rect display_bounds = ash::Shell::GetInstance()->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;
+  gfx::Rect bounds;
+  WindowSizer::GetBrowserWindowBoundsAndShowState(
+      std::string(), specified_bounds, browser.get(), &bounds, &show_state);
+  // The window should start maximized with its restore bounds shrunken.
+  EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED, show_state);
+  EXPECT_NE(display_bounds.ToString(), bounds.ToString());
+  EXPECT_TRUE(display_bounds.Contains(bounds));
+
+  // Make a window smaller than the display work area.
+  specified_bounds.Inset(100, 100);
+  show_state = ui::SHOW_STATE_DEFAULT;
+  WindowSizer::GetBrowserWindowBoundsAndShowState(
+      std::string(), specified_bounds, browser.get(), &bounds, &show_state);
+  // The window should start in default state.
+  EXPECT_EQ(ui::SHOW_STATE_DEFAULT, show_state);
+  EXPECT_EQ(specified_bounds.ToString(), bounds.ToString());
+}
+
+// Test that the target root window is used as the destination of
 // the non browser window. This differ from PersistedBoundsCase
 // in that this uses real ash shell implementations + StateProvider
 // TargetDisplayProvider, rather than mocks.
 TEST_F(WindowSizerAshTest, DefaultBoundsInTargetDisplay) {
   if (!SupportsMultipleDisplays() || !chrome::ShouldOpenAshOnStartup())
     return;
   UpdateDisplay("500x500,600x600");
   {
     aura::Window* first_root =
         ash::Shell::GetAllRootWindows()[0];
@@ skipping 34 matching lines @@
       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->browser(),
+                               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->browser(),
+                               p1600x1200,
                                p1600x1200));
 }