diff options
author | Ben Murdoch <benm@google.com> | 2010-07-29 17:14:53 +0100 |
---|---|---|
committer | Ben Murdoch <benm@google.com> | 2010-08-04 14:29:45 +0100 |
commit | c407dc5cd9bdc5668497f21b26b09d988ab439de (patch) | |
tree | 7eaf8707c0309516bdb042ad976feedaf72b0bb1 /chrome/browser/window_sizer_unittest.cc | |
parent | 0998b1cdac5733f299c12d88bc31ef9c8035b8fa (diff) | |
download | external_chromium-c407dc5cd9bdc5668497f21b26b09d988ab439de.zip external_chromium-c407dc5cd9bdc5668497f21b26b09d988ab439de.tar.gz external_chromium-c407dc5cd9bdc5668497f21b26b09d988ab439de.tar.bz2 |
Merge Chromium src@r53293
Change-Id: Ia79acf8670f385cee48c45b0a75371d8e950af34
Diffstat (limited to 'chrome/browser/window_sizer_unittest.cc')
-rw-r--r-- | chrome/browser/window_sizer_unittest.cc | 1002 |
1 files changed, 1002 insertions, 0 deletions
diff --git a/chrome/browser/window_sizer_unittest.cc b/chrome/browser/window_sizer_unittest.cc new file mode 100644 index 0000000..622d114 --- /dev/null +++ b/chrome/browser/window_sizer_unittest.cc @@ -0,0 +1,1002 @@ +// Copyright (c) 2006-2008 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 <vector> + +#include "chrome/browser/window_sizer.h" +#include "base/logging.h" +#include "testing/gtest/include/gtest/gtest.h" + +// Some standard monitor sizes (no task bar). +static const gfx::Rect tentwentyfour(0, 0, 1024, 768); +static const gfx::Rect twelveeighty(0, 0, 1280, 1024); +static const gfx::Rect sixteenhundred(0, 0, 1600, 1200); +static const gfx::Rect sixteeneighty(0, 0, 1680, 1050); +static const gfx::Rect nineteentwenty(0, 0, 1920, 1200); + +// Represents a 1024x768 monitor that is not the primary monitor, arranged to +// the immediate left of the primary 1024x768 monitor. +static const gfx::Rect left_nonprimary(-1024, 0, 1024, 768); + +// Represents a 1024x768 monitor that is not the primary monitor, arranged to +// the immediate right of the primary 1024x768 monitor. +static const gfx::Rect right_nonprimary(1024, 0, 1024, 768); + +// Represents a 1024x768 monitor that is not the primary monitor, arranged to +// the immediate top of the primary 1024x768 monitor. +static const gfx::Rect top_nonprimary(0, -768, 1024, 768); + +// Represents a 1024x768 monitor that is not the primary monitor, arranged to +// the immediate bottom of the primary 1024x768 monitor. +static const gfx::Rect bottom_nonprimary(0, 768, 1024, 768); + +// The work area for 1024x768 monitors with different taskbar orientations. +static const gfx::Rect taskbar_bottom_work_area(0, 0, 1024, 734); +static const gfx::Rect taskbar_top_work_area(0, 34, 1024, 734); +static const gfx::Rect taskbar_left_work_area(107, 0, 917, 768); +static const gfx::Rect taskbar_right_work_area(0, 0, 917, 768); + +static int kWindowTilePixels = WindowSizer::kWindowTilePixels; + +// Testing implementation of WindowSizer::MonitorInfoProvider that we can use +// to fake various monitor layouts and sizes. +class TestMonitorInfoProvider : public WindowSizer::MonitorInfoProvider { + public: + TestMonitorInfoProvider() {} + virtual ~TestMonitorInfoProvider() {} + + void AddMonitor(const gfx::Rect& bounds, const gfx::Rect& work_area) { + DCHECK(bounds.Contains(work_area)); + monitor_bounds_.push_back(bounds); + work_areas_.push_back(work_area); + } + + // Overridden from WindowSizer::MonitorInfoProvider: + virtual gfx::Rect GetPrimaryMonitorWorkArea() const { + return work_areas_[0]; + } + + virtual gfx::Rect GetPrimaryMonitorBounds() const { + return monitor_bounds_[0]; + } + + virtual gfx::Rect GetMonitorWorkAreaMatching( + const gfx::Rect& match_rect) const { + return work_areas_[GetMonitorIndexMatchingBounds(match_rect)]; + } + + virtual gfx::Point GetBoundsOffsetMatching( + const gfx::Rect& match_rect) const { + int monitor_index = GetMonitorIndexMatchingBounds(match_rect); + gfx::Rect bounds = monitor_bounds_[monitor_index]; + const gfx::Rect& work_area = work_areas_[monitor_index]; + return gfx::Point(work_area.x() - bounds.x(), work_area.y() - bounds.y()); + } + + virtual void UpdateWorkAreas() { } + + private: + size_t GetMonitorIndexMatchingBounds(const gfx::Rect& match_rect) const { + int max_area = 0; + size_t max_area_index = 0; + // Loop through all the monitors, finding the one that intersects the + // largest area of the supplied match rect. + for (size_t i = 0; i < work_areas_.size(); ++i) { + gfx::Rect overlap(match_rect.Intersect(work_areas_[i])); + int area = overlap.width() * overlap.height(); + if (area > max_area) { + max_area = area; + max_area_index = i; + } + } + return max_area_index; + } + + std::vector<gfx::Rect> monitor_bounds_; + + DISALLOW_COPY_AND_ASSIGN(TestMonitorInfoProvider); +}; + +// Testing implementation of WindowSizer::StateProvider that we use to fake +// persistent storage and existing windows. +class TestStateProvider : public WindowSizer::StateProvider { + public: + TestStateProvider() + : persistent_maximized_(false), + has_persistent_data_(false), + has_last_active_data_(false) { + } + virtual ~TestStateProvider() {} + + void SetPersistentState(const gfx::Rect& bounds, + bool maximized, + const gfx::Rect& work_area, + bool has_persistent_data) { + persistent_bounds_ = bounds; + persistent_maximized_ = maximized; + persistent_work_area_ = work_area; + has_persistent_data_ = has_persistent_data; + } + + void SetLastActiveState(const gfx::Rect& bounds, bool has_last_active_data) { + last_active_bounds_ = bounds; + has_last_active_data_ = has_last_active_data; + } + + // Overridden from WindowSizer::StateProvider: + virtual bool GetPersistentState(gfx::Rect* bounds, + bool* maximized, + gfx::Rect* saved_work_area) const { + *bounds = persistent_bounds_; + *maximized = persistent_maximized_; + *saved_work_area = persistent_work_area_; + return has_persistent_data_; + } + + virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const { + *bounds = last_active_bounds_; + return has_last_active_data_; + } + + private: + gfx::Rect persistent_bounds_; + bool persistent_maximized_; + gfx::Rect persistent_work_area_; + bool has_persistent_data_; + + gfx::Rect last_active_bounds_; + bool has_last_active_data_; + + DISALLOW_COPY_AND_ASSIGN(TestStateProvider); +}; + +// A convenience function to read the window bounds from the window sizer +// according to the specified configuration. +enum Source { DEFAULT, LAST_ACTIVE, PERSISTED }; +static void GetWindowBounds(const gfx::Rect& monitor1_bounds, + const gfx::Rect& monitor1_work_area, + const gfx::Rect& monitor2_bounds, + const gfx::Rect& state, + bool maximized, + const gfx::Rect& work_area, + Source source, + gfx::Rect* out_bounds, + bool* out_maximized) { + TestMonitorInfoProvider* mip = new TestMonitorInfoProvider; + mip->AddMonitor(monitor1_bounds, monitor1_work_area); + if (!monitor2_bounds.IsEmpty()) + mip->AddMonitor(monitor2_bounds, monitor2_bounds); + TestStateProvider* sp = new TestStateProvider; + if (source == PERSISTED) + sp->SetPersistentState(state, maximized, work_area, true); + else if (source == LAST_ACTIVE) + sp->SetLastActiveState(state, true); + WindowSizer sizer(sp, mip); + sizer.DetermineWindowBounds(gfx::Rect(), out_bounds, out_maximized); +} + +// Test that the window is sized appropriately for the first run experience +// where the default window bounds calculation is invoked. +TEST(WindowSizerTest, DefaultSizeCase) { + { // 4:3 monitor case, 1024x768, no taskbar + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), gfx::Rect(), + false, gfx::Rect(), DEFAULT, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 1024 - kWindowTilePixels * 2, + 768 - kWindowTilePixels * 2), + window_bounds); + } + + { // 4:3 monitor case, 1024x768, taskbar on bottom + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(tentwentyfour, taskbar_bottom_work_area, gfx::Rect(), + gfx::Rect(), false, gfx::Rect(), DEFAULT, &window_bounds, + &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 1024 - kWindowTilePixels * 2, + (taskbar_bottom_work_area.height() - + kWindowTilePixels * 2)), + window_bounds); + } + + { // 4:3 monitor case, 1024x768, taskbar on right + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(tentwentyfour, taskbar_right_work_area, gfx::Rect(), + gfx::Rect(), false, gfx::Rect(), DEFAULT, &window_bounds, + &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + taskbar_right_work_area.width() - kWindowTilePixels*2, + 768 - kWindowTilePixels * 2), + window_bounds); + } + + { // 4:3 monitor case, 1024x768, taskbar on left + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(tentwentyfour, taskbar_left_work_area, gfx::Rect(), + gfx::Rect(), false, gfx::Rect(), DEFAULT, &window_bounds, + &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(taskbar_left_work_area.x() + kWindowTilePixels, + kWindowTilePixels, + taskbar_left_work_area.width() - kWindowTilePixels * 2, + (taskbar_left_work_area.height() - + kWindowTilePixels * 2)), + window_bounds); + } + + { // 4:3 monitor case, 1024x768, taskbar on top + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(tentwentyfour, taskbar_top_work_area, gfx::Rect(), + gfx::Rect(), false, gfx::Rect(), DEFAULT, &window_bounds, + &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, + taskbar_top_work_area.y() + kWindowTilePixels, + 1024 - kWindowTilePixels * 2, + taskbar_top_work_area.height() - kWindowTilePixels * 2), + window_bounds); + } + + { // 4:3 monitor case, 1280x1024 + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(twelveeighty, twelveeighty, gfx::Rect(), gfx::Rect(), + false, gfx::Rect(), DEFAULT, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 1050, + 1024 - kWindowTilePixels * 2), + window_bounds); + } + + { // 4:3 monitor case, 1600x1200 + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(sixteenhundred, sixteenhundred, gfx::Rect(), gfx::Rect(), + false, gfx::Rect(), DEFAULT, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 1050, + 1200 - kWindowTilePixels * 2), + window_bounds); + } + + { // 16:10 monitor case, 1680x1050 + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(sixteeneighty, sixteeneighty, gfx::Rect(), gfx::Rect(), + false, gfx::Rect(), DEFAULT, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 840 - static_cast<int>(kWindowTilePixels * 1.5), + 1050 - kWindowTilePixels * 2), + window_bounds); + } + + { // 16:10 monitor case, 1920x1200 + gfx::Rect window_bounds; + bool maximized; + GetWindowBounds(nineteentwenty, nineteentwenty, gfx::Rect(), gfx::Rect(), + false, gfx::Rect(), DEFAULT, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels, + 960 - static_cast<int>(kWindowTilePixels * 1.5), + 1200 - kWindowTilePixels * 2), + window_bounds); + } +} + +// Test that the next opened window is positioned appropriately given the +// bounds of an existing window of the same type. +TEST(WindowSizerTest, LastWindowBoundsCase) { + { // normal, in the middle of the screen somewhere. + gfx::Rect window_bounds; + bool maximized = false; + GetWindowBounds(tentwentyfour, tentwentyfour, 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; + GetWindowBounds(tentwentyfour, taskbar_top_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, + std::max(kWindowTilePixels * 2, + 34 /* toolbar height */), + 500, 400), window_bounds); + } + + { // too small to satisify the minimum visibility condition. + gfx::Rect window_bounds; + bool maximized = false; + GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), + gfx::Rect(kWindowTilePixels, kWindowTilePixels, 29, 29), + false, gfx::Rect(), LAST_ACTIVE, + &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2, + kWindowTilePixels * 2, + 30 /* not 29 */, + 30 /* not 29 */), + window_bounds); + } + + + { // normal, but maximized + gfx::Rect window_bounds; + bool maximized = false; + GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), + gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400), + true, gfx::Rect(), LAST_ACTIVE, + &window_bounds, &maximized); + EXPECT_FALSE(maximized); + 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) + { // offset would put the new window offscreen at the bottom but the minimum + // visibility condition is barely satisfied without relocation. + gfx::Rect window_bounds; + bool maximized = false; + GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), + gfx::Rect(10, 728, 500, 400), false, gfx::Rect(), + LAST_ACTIVE, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(10 + kWindowTilePixels, 738, + 500, 400), window_bounds); + } + + { // offset would put the new window offscreen at the bottom and the minimum + // visibility condition is satisified by relocation. + 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, 738 /* not 739 */, 500, 400), + window_bounds); + } + + { // offset would put the new window offscreen at the right but the minimum + // visibility condition is barely satisfied without relocation. + gfx::Rect window_bounds; + bool maximized = false; + GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), + gfx::Rect(984, 10, 500, 400), false, gfx::Rect(), + LAST_ACTIVE, &window_bounds, &maximized); + EXPECT_FALSE(maximized); + EXPECT_EQ(gfx::Rect(994, 10 + kWindowTilePixels, 500, 400), window_bounds); + } + + { // offset would put the new window offscreen at the right and the minimum + // visibility condition is satisified by relocation. + 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(994 /* not 995 */, 10 + kWindowTilePixels, + 500, 400), window_bounds); + } + + { // offset would put the new window offscreen at the bottom right and the + // minimum visibility condition is satisified by relocation. + 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(994 /* not 995 */, 738 /* not 739 */, 500, 400), + window_bounds); + } +#endif // !defined(OS_LINUX) +} + +TEST(WindowSizerTest, PersistedWindowOffscreenWithNonAggressiveRepositioning) { + { // off the left but the minimum visibility condition is barely satisfied + // without relocaiton. + gfx::Rect initial_bounds(-470, 50, 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); + } + + { // off the left and the minimum visibility condition is satisfied by + // relocation. + 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(-470 /* not -471 */, 50, 500, 400), window_bounds); + } + + { // off the top + gfx::Rect initial_bounds(50, -370, 500, 400); + + 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 but the minimum visibility condition is barely satisified + // without relocation. + gfx::Rect initial_bounds(994, 50, 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); + } + + { // off the right and the minimum visibility condition is satisified by + // relocation. + 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(994 /* not 995 */, 50, 500, 400), window_bounds); + } + + { // off the bottom but the minimum visibility condition is barely satisified + // without relocation. + gfx::Rect initial_bounds(50, 738, 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); + } + + { // off the bottom and the minimum visibility condition is satisified by + // relocation. + 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, 738 /* 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(-470 /* not -471 */, 0, 500, 400), + window_bounds); + } + + { // off the topright and the minimum visibility condition is satisified by + // relocation. + 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(994 /* not 995 */, 0, 500, 400), + window_bounds); + } + + { // off the bottomleft and the minimum visibility condition is satisified by + // relocation. + 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(-470 /* not -471 */, 738 /* not 739 */, 500, 400), + window_bounds); + } + + { // off the bottomright and the minimum visibility condition is satisified by + // relocation. + 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(994 /* not 995 */, 738 /* 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(-470 /* 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(994 /* 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, 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, 738 /* 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, 500, 400), window_bounds); + } +} +#endif //defined(OS_MACOSX) |