[Mac] Be more aggressive in repositioning windows that are offscreen.

BUG=http://crbug.com/18713
TEST=Windows that can fit entirely onscreen should appear entirely onscreen.
Review URL: http://codereview.chromium.org/293052

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@29688 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 373 insertions, 131 deletions

diff --git a/chrome/browser/window_sizer_unittest.cc b/chrome/browser/window_sizer_unittest.cc
index 1c125eb..622d114 100644
--- a/chrome/browser/window_sizer_unittest.cc
+++ b/chrome/browser/window_sizer_unittest.cc
@@ -311,18 +311,6 @@ TEST(WindowSizerTest, LastWindowBoundsCase) {
                         kWindowTilePixels * 2, 500, 400), window_bounds);
   }
 
-  { // taskbar on left.
-    gfx::Rect window_bounds;
-    bool maximized = false;
-    GetWindowBounds(tentwentyfour, taskbar_left_work_area, gfx::Rect(),
-                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
-                    false, gfx::Rect(), LAST_ACTIVE,
-                    &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
-                        kWindowTilePixels * 2, 500, 400), window_bounds);
-  }
-
   { // taskbar on top.
     gfx::Rect window_bounds;
     bool maximized = false;
@@ -364,6 +352,377 @@ TEST(WindowSizerTest, LastWindowBoundsCase) {
     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
                         kWindowTilePixels * 2, 500, 400), window_bounds);
   }
+}
+
+// Test that the window opened is sized appropriately given persisted sizes.
+TEST(WindowSizerTest, PersistedBoundsCase) {
+  { // normal, in the middle of the screen somewhere.
+    gfx::Rect initial_bounds(kWindowTilePixels, kWindowTilePixels, 500, 400);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), initial_bounds,
+                    false, gfx::Rect(), PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(initial_bounds, window_bounds);
+  }
+
+  { // normal, maximized.
+    gfx::Rect initial_bounds(0, 0, 1024, 768);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), initial_bounds,
+                    true, gfx::Rect(), PERSISTED, &window_bounds, &maximized);
+    EXPECT_TRUE(maximized);
+    EXPECT_EQ(initial_bounds, window_bounds);
+  }
+
+  { // normal, on non-primary monitor in negative coords.
+    gfx::Rect initial_bounds(-600, 10, 500, 400);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary,
+                    initial_bounds, false, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(initial_bounds, window_bounds);
+  }
+
+  { // normal, on non-primary monitor in negative coords, maximized.
+    gfx::Rect initial_bounds(-1024, 0, 1024, 768);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary,
+                    initial_bounds, true, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_TRUE(maximized);
+    EXPECT_EQ(initial_bounds, window_bounds);
+  }
+
+  { // Non-primary monitor resoultion has changed, but the monitor still
+    // completely contains the window.
+
+    gfx::Rect initial_bounds(1074, 50, 600, 500);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
+                    initial_bounds, false, right_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(initial_bounds, window_bounds);
+  }
+
+  { // Non-primary monitor resoultion has changed, and the window is partially
+    // off-screen.
+
+    gfx::Rect initial_bounds(1274, 50, 600, 500);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
+                    initial_bounds, false, right_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(1224, 50, 600, 500), window_bounds);
+  }
+
+  { // Non-primary monitor resoultion has changed, and the window is now too
+    // large for the monitor.
+
+    gfx::Rect initial_bounds(1274, 50, 900, 700);
+
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
+                    initial_bounds, false, right_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(1024, 0, 800, 600), window_bounds);
+  }
+
+  { // width and height too small
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 29, 29),
+                    false, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
+                        30 /* not 29 */, 30 /* not 29 */),
+              window_bounds);
+  }
+
+#if defined(OS_MACOSX)
+  { // Saved state is too tall to possibly be resized.  Mac resizers
+    // are at the bottom of the window, and no piece of a window can
+    // be moved higher than the menubar.  (Perhaps the user changed
+    // resolution to something smaller before relaunching Chrome?)
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 30, 5000),
+                    false, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(tentwentyfour.height(), window_bounds.height());
+  }
+#endif  // defined(OS_MACOSX)
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// The following unittests have different results on Mac/non-Mac because we
+// reposition windows aggressively on Mac.  The *WithAggressiveReposition tests
+// are run on Mac, and the *WithNonAggressiveRepositioning tests are run on
+// other platforms.
+
+#if defined(OS_MACOSX)
+TEST(WindowSizerTest, LastWindowOffscreenWithAggressiveRepositioning) {
+  { // taskbar on left.  The new window overlaps slightly with the taskbar, so
+    // it is moved to be flush with the left edge of the work area.
+    gfx::Rect window_bounds;
+    bool maximized = false;
+    GetWindowBounds(tentwentyfour, taskbar_left_work_area, gfx::Rect(),
+                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
+                    false, gfx::Rect(), LAST_ACTIVE,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(taskbar_left_work_area.x(),
+                        kWindowTilePixels * 2, 500, 400), window_bounds);
+  }
+
+  { // offset would put the new window offscreen at the bottom
+    gfx::Rect window_bounds;
+    bool maximized = false;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(10, 729, 500, 400), false, gfx::Rect(),
+                    LAST_ACTIVE, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(10 + kWindowTilePixels,
+                        0 /* not 729 + kWindowTilePixels */,
+                        500, 400),
+              window_bounds);
+  }
+
+  { // offset would put the new window offscreen at the right
+    gfx::Rect window_bounds;
+    bool maximized = false;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(985, 10, 500, 400), false, gfx::Rect(),
+                    LAST_ACTIVE, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 985 + kWindowTilePixels*/,
+                        10 + kWindowTilePixels,
+                        500, 400),
+              window_bounds);
+  }
+
+  { // offset would put the new window offscreen at the bottom right
+    gfx::Rect window_bounds;
+    bool maximized = false;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(985, 729, 500, 400), false, gfx::Rect(),
+                    LAST_ACTIVE, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 985 + kWindowTilePixels*/,
+                        0 /* not 729 + kWindowTilePixels*/,
+                        500, 400),
+              window_bounds);
+  }
+}
+
+TEST(WindowSizerTest, PersistedWindowOffscreenWithAggressiveRepositioning) {
+  { // off the left
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-471, 50, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not -471 */, 50, 500, 400), window_bounds);
+  }
+
+  { // off the top
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, -370, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
+  }
+
+  { // off the right
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(995, 50, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 995 */, 50, 500, 400), window_bounds);
+  }
+
+  { // off the bottom
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, 739, 500, 400), false, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 0 /* not 739 */, 500, 400), window_bounds);
+  }
+
+  { // off the topleft
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-471, -371, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not -471 */, 0 /* not -371 */, 500, 400),
+              window_bounds);
+  }
+
+  { // off the topright
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(995, -371, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 995 */, 0 /* not -371 */, 500, 400),
+                        window_bounds);
+  }
+
+  { // off the bottomleft
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-471, 739, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not -471 */, 0 /* not 739 */, 500, 400),
+                        window_bounds);
+  }
+
+  { // off the bottomright
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(995, 739, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 995 */, 0 /* not 739 */, 500, 400),
+                        window_bounds);
+  }
+
+  { // entirely off left
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-700, 50, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not -700 */, 50, 500, 400), window_bounds);
+  }
+
+  { // entirely off left (monitor was detached since last run)
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-700, 50, 500, 400), false, left_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0, 50, 500, 400), window_bounds);
+  }
+
+  { // entirely off top
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, -500, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
+  }
+
+  { // entirely off top (monitor was detached since last run)
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, -500, 500, 400), false, top_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
+  }
+
+  { // entirely off right
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(1200, 50, 500, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not 1200 */, 50, 500, 400), window_bounds);
+  }
+
+  { // entirely off right (monitor was detached since last run)
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(1200, 50, 500, 400), false, right_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(524 /* not 1200 */, 50, 500, 400), window_bounds);
+  }
+
+  { // entirely off bottom
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, 800, 500, 400), false, gfx::Rect(), PERSISTED,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 0 /* not 800 */, 500, 400), window_bounds);
+  }
+
+  { // entirely off bottom (monitor was detached since last run)
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(50, 800, 500, 400), false, bottom_nonprimary,
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(50, 368 /* not 800 */, 500, 400), window_bounds);
+  }
+
+  { // wider than the screen. off both the left and right
+    gfx::Rect window_bounds;
+    bool maximized;
+    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
+                    gfx::Rect(-100, 50, 2000, 400), false, gfx::Rect(),
+                    PERSISTED, &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(0 /* not -100 */, 50, 2000, 400), window_bounds);
+  }
+}
+#else
+TEST(WindowSizerTest, LastWindowOffscreenWithNonAggressiveRepositioning) {
+  { // taskbar on left.
+    gfx::Rect window_bounds;
+    bool maximized = false;
+    GetWindowBounds(tentwentyfour, taskbar_left_work_area, gfx::Rect(),
+                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
+                    false, gfx::Rect(), LAST_ACTIVE,
+                    &window_bounds, &maximized);
+    EXPECT_FALSE(maximized);
+    EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
+                        kWindowTilePixels * 2, 500, 400), window_bounds);
+  }
 
   // Linux does not tile windows, so tile adjustment tests don't make sense.
 #if !defined(OS_LINUX)
@@ -428,54 +787,7 @@ TEST(WindowSizerTest, LastWindowBoundsCase) {
 #endif  // !defined(OS_LINUX)
 }
 
-// Test that the window opened is sized appropriately given persisted sizes.
-TEST(WindowSizerTest, PersistedBoundsCase) {
-  { // normal, in the middle of the screen somewhere.
-    gfx::Rect initial_bounds(kWindowTilePixels, kWindowTilePixels, 500, 400);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), initial_bounds,
-                    false, gfx::Rect(), PERSISTED, &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(initial_bounds, window_bounds);
-  }
-
-  { // normal, maximized.
-    gfx::Rect initial_bounds(0, 0, 1024, 768);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), initial_bounds,
-                    true, gfx::Rect(), PERSISTED, &window_bounds, &maximized);
-    EXPECT_TRUE(maximized);
-    EXPECT_EQ(initial_bounds, window_bounds);
-  }
-
-  { // normal, on non-primary monitor in negative coords.
-    gfx::Rect initial_bounds(-600, 10, 500, 400);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary,
-                    initial_bounds, false, gfx::Rect(), PERSISTED,
-                    &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(initial_bounds, window_bounds);
-  }
-
-  { // normal, on non-primary monitor in negative coords, maximized.
-    gfx::Rect initial_bounds(-1024, 0, 1024, 768);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary,
-                    initial_bounds, true, gfx::Rect(), PERSISTED,
-                    &window_bounds, &maximized);
-    EXPECT_TRUE(maximized);
-    EXPECT_EQ(initial_bounds, window_bounds);
-  }
-
+TEST(WindowSizerTest, PersistedWindowOffscreenWithNonAggressiveRepositioning) {
   { // off the left but the minimum visibility condition is barely satisfied
     // without relocaiton.
     gfx::Rect initial_bounds(-470, 50, 500, 400);
@@ -686,75 +998,5 @@ TEST(WindowSizerTest, PersistedBoundsCase) {
     EXPECT_FALSE(maximized);
     EXPECT_EQ(gfx::Rect(50, 368, 500, 400), window_bounds);
   }
-
-  { // Non-primary monitor resoultion has changed, but the monitor still
-    // completely contains the window.
-
-    gfx::Rect initial_bounds(1074, 50, 600, 500);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
-                    initial_bounds, false, right_nonprimary,
-                    PERSISTED, &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(initial_bounds, window_bounds);
-  }
-
-  { // Non-primary monitor resoultion has changed, and the window is partially
-    // off-screen.
-
-    gfx::Rect initial_bounds(1274, 50, 600, 500);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
-                    initial_bounds, false, right_nonprimary,
-                    PERSISTED, &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(gfx::Rect(1224, 50, 600, 500), window_bounds);
-  }
-
-  { // Non-primary monitor resoultion has changed, and the window is now too
-    // large for the monitor.
-
-    gfx::Rect initial_bounds(1274, 50, 900, 700);
-
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(1024, 0, 800, 600),
-                    initial_bounds, false, right_nonprimary,
-                    PERSISTED, &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(gfx::Rect(1024, 0, 800, 600), window_bounds);
-  }
-
-  { // width and height too small
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
-                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 29, 29),
-                    false, gfx::Rect(), PERSISTED,
-                    &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
-                        30 /* not 29 */, 30 /* not 29 */),
-              window_bounds);
-  }
-
-#if defined(OS_MACOSX)
-  { // Saved state is too tall to possibly be resized.  Mac resizers
-    // are at the bottom of the window, and no piece of a window can
-    // be moved higher than the menubar.  (Perhaps the user changed
-    // resolution to something smaller before relaunching Chrome?)
-    gfx::Rect window_bounds;
-    bool maximized;
-    GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
-                    gfx::Rect(kWindowTilePixels, kWindowTilePixels, 30, 5000),
-                    false, gfx::Rect(), PERSISTED,
-                    &window_bounds, &maximized);
-    EXPECT_FALSE(maximized);
-    EXPECT_EQ(tentwentyfour.height(), window_bounds.height());
-  }
-#endif  // defined(OS_MACOSX)
 }
+#endif  //defined(OS_MACOSX)