| // 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 "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 top of the primary 1024x768 monitor. |
| static const gfx::Rect top_nonprimary(0, -768, 1024, 768); |
| |
| // The working 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); |
| |
| // 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_rect) { |
| DCHECK(bounds.Contains(work_rect)); |
| monitor_bounds_.push_back(work_rect); |
| monitor_work_rects_.push_back(work_rect); |
| } |
| |
| // Overridden from WindowSizer::MonitorInfoProvider: |
| virtual gfx::Rect GetPrimaryMonitorWorkingRect() const { |
| return monitor_work_rects_[0]; |
| } |
| virtual gfx::Rect GetPrimaryMonitorBounds() const { |
| return monitor_bounds_[0]; |
| } |
| virtual gfx::Rect GetMonitorBoundsMatching( |
| const gfx::Rect& match_rect) const { |
| return GetWorkingRectAt(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]; |
| gfx::Rect work_rect = monitor_work_rects_[monitor_index]; |
| return gfx::Point(work_rect.x() - bounds.x(), work_rect.y() - bounds.y()); |
| } |
| virtual int GetMonitorCount() const { |
| return static_cast<int>(monitor_work_rects_.size()); |
| } |
| virtual gfx::Rect GetWorkingRectAt(int index) const { |
| DCHECK(index >= 0 && index < GetMonitorCount()); |
| return monitor_work_rects_.at(index); |
| } |
| |
| private: |
| int GetMonitorIndexMatchingBounds(const gfx::Rect& match_rect) const { |
| int monitor_count = GetMonitorCount(); |
| int max_area = 0; |
| int max_area_index = 0; |
| // Loop through all the monitors, finding the one that intersects the |
| // largest area of the supplied match rect. |
| for (int i = 0; i < monitor_count; ++i) { |
| gfx::Rect current_rect = GetWorkingRectAt(i); |
| if (match_rect.right() < current_rect.right() && |
| match_rect.right() >= current_rect.x() && |
| match_rect.bottom() < current_rect.bottom() && |
| match_rect.bottom() >= current_rect.y()) { |
| int covered_width, covered_height; |
| if (match_rect.x() < current_rect.x()) { |
| covered_width = match_rect.right() - current_rect.x(); |
| } else if (match_rect.right() > current_rect.right()) { |
| covered_width = current_rect.right() - match_rect.x(); |
| } else { |
| covered_width = match_rect.width(); |
| } |
| if (match_rect.y() < current_rect.y()) { |
| covered_height = match_rect.bottom() - current_rect.y(); |
| } else if (match_rect.bottom() > current_rect.bottom()) { |
| covered_height = current_rect.bottom() - match_rect.y(); |
| } else { |
| covered_height = match_rect.height(); |
| } |
| int area = covered_width * covered_height; |
| if (area > max_area) { |
| max_area = area; |
| max_area_index = i; |
| } |
| } |
| } |
| return max_area_index; |
| } |
| |
| std::vector<gfx::Rect> monitor_bounds_; |
| std::vector<gfx::Rect> monitor_work_rects_; |
| |
| DISALLOW_EVIL_CONSTRUCTORS(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, |
| bool has_persistent_data) { |
| persistent_bounds_ = bounds; |
| persistent_maximized_ = maximized; |
| 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) const { |
| *bounds = persistent_bounds_; |
| *maximized = persistent_maximized_; |
| 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_; |
| bool has_persistent_data_; |
| |
| gfx::Rect last_active_bounds_; |
| bool has_last_active_data_; |
| |
| DISALLOW_EVIL_CONSTRUCTORS(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_rect, |
| const gfx::Rect& monitor2_bounds, |
| const gfx::Rect& state, |
| bool maximized, |
| Source source, |
| gfx::Rect* out_bounds, |
| bool* out_maximized) { |
| TestMonitorInfoProvider* mip = new TestMonitorInfoProvider; |
| mip->AddMonitor(monitor1_bounds, monitor1_work_rect); |
| if (!monitor2_bounds.IsEmpty()) |
| mip->AddMonitor(monitor2_bounds, monitor2_bounds); |
| TestStateProvider* sp = new TestStateProvider; |
| if (source == PERSISTED) |
| sp->SetPersistentState(state, maximized, 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, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 1004, 748), 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, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 1004, 714), 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, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 897, 748), 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, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(117, 10, 897, 748), 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, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 44, 1004, 714), window_bounds); |
| } |
| |
| { // 4:3 monitor case, 1280x1024 |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(twelveeighty, twelveeighty, gfx::Rect(), gfx::Rect(), |
| false, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 1050, 1004), window_bounds); |
| } |
| |
| { // 4:3 monitor case, 1600x1200 |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(sixteenhundred, sixteenhundred, gfx::Rect(), gfx::Rect(), |
| false, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 1050, 1180), window_bounds); |
| } |
| |
| { // 16:10 monitor case, 1680x1050 |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(sixteeneighty, sixteeneighty, gfx::Rect(), gfx::Rect(), |
| false, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 810, 1030), window_bounds); |
| } |
| |
| { // 16:10 monitor case, 1920x1200 |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(nineteentwenty, nineteentwenty, gfx::Rect(), gfx::Rect(), |
| false, DEFAULT, &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 930, 1180), 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(10, 10, 500, 400), false, LAST_ACTIVE, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(20, 20, 500, 400), window_bounds); |
| } |
| |
| { // normal, but maximized |
| gfx::Rect window_bounds; |
| bool maximized = false; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(10, 10, 500, 400), true, LAST_ACTIVE, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(20, 20, 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, 360, 500, 400), false, LAST_ACTIVE, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(20, 358, 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(520, 10, 500, 400), false, LAST_ACTIVE, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 20, 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(520, 360, 500, 400), false, LAST_ACTIVE, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 358, 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(10, 10, 500, 400); |
| |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), initial_bounds, |
| false, 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, 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, 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, PERSISTED, &window_bounds, |
| &maximized); |
| EXPECT_TRUE(maximized); |
| EXPECT_EQ(initial_bounds, window_bounds); |
| } |
| |
| { // a little off the left |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(-10, 50, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 50, 500, 400), window_bounds); |
| } |
| |
| { // a little off the top |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(50, -10, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(50, 10, 500, 400), window_bounds); |
| } |
| |
| { // a little off the right |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(534, 50, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 50, 500, 400), window_bounds); |
| } |
| |
| { // a little off the bottom |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(50, 378, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(50, 358, 500, 400), window_bounds); |
| } |
| |
| { // a little off the topleft |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(-10, -10, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 500, 400), window_bounds); |
| } |
| |
| { // a little off the topright |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(534, -10, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 10, 500, 400), window_bounds); |
| } |
| |
| { // a little off the bottomleft |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(-10, 378, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 358, 500, 400), window_bounds); |
| } |
| |
| { // a little off the bottomright |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(534, 378, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 358, 500, 400), window_bounds); |
| } |
| |
| { // split across two, bias right |
| gfx::Rect initial_bounds(-50, 50, 500, 400); |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary, |
| initial_bounds, false, PERSISTED, &window_bounds, |
| &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(initial_bounds, window_bounds); |
| } |
| |
| { // split across two, bias left |
| gfx::Rect initial_bounds(-450, 50, 500, 400); |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary, |
| initial_bounds, false, PERSISTED, &window_bounds, |
| &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(initial_bounds, window_bounds); |
| } |
| |
| { // split across two, a little off left |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, top_nonprimary, |
| gfx::Rect(-50, -50, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, -50, 500, 400), window_bounds); |
| } |
| |
| { // split across two, a little off right |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, top_nonprimary, |
| gfx::Rect(534, -50, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, -50, 500, 400), window_bounds); |
| } |
| |
| { // split across two, a little off top |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary, |
| gfx::Rect(-50, -50, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(-50, 10, 500, 400), window_bounds); |
| } |
| |
| { // split across two, a little off bottom |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, left_nonprimary, |
| gfx::Rect(-50, 378, 500, 400), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(-50, 358, 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, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 50, 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, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(50, 10, 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, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(514, 50, 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, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(50, 358, 500, 400), window_bounds); |
| } |
| |
| { // width and height too large (monitor screen resolution changed since last |
| // run) |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(), |
| gfx::Rect(10, 10, 1200, 900), false, PERSISTED, |
| &window_bounds, &maximized); |
| EXPECT_FALSE(maximized); |
| EXPECT_EQ(gfx::Rect(10, 10, 1004, 748), window_bounds); |
| } |
| |
| { // Handles taskbar offset on the top. |
| gfx::Rect initial_bounds(10, 10, 500, 400); |
| |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, taskbar_top_work_area, gfx::Rect(), |
| initial_bounds, false, PERSISTED, &window_bounds, |
| &maximized); |
| EXPECT_FALSE(maximized); |
| initial_bounds.Offset(taskbar_top_work_area.x(), taskbar_top_work_area.y()); |
| EXPECT_EQ(initial_bounds, window_bounds); |
| } |
| |
| { // Handles taskbar offset on the left. |
| gfx::Rect initial_bounds(10, 10, 500, 400); |
| |
| gfx::Rect window_bounds; |
| bool maximized; |
| GetWindowBounds(tentwentyfour, taskbar_left_work_area, gfx::Rect(), |
| initial_bounds, false, PERSISTED, &window_bounds, |
| &maximized); |
| EXPECT_FALSE(maximized); |
| initial_bounds.Offset(taskbar_left_work_area.x(), |
| taskbar_left_work_area.y()); |
| EXPECT_EQ(initial_bounds, window_bounds); |
| } |
| } |
| |