diff options
Diffstat (limited to 'chrome/browser/window_sizer_unittest.cc')
| -rw-r--r-- | chrome/browser/window_sizer_unittest.cc | 619 |
1 files changed, 619 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..910820d --- /dev/null +++ b/chrome/browser/window_sizer_unittest.cc @@ -0,0 +1,619 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#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; + 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; + 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; + 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; + 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; + 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); + } +} |