1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/window_sizer/window_sizer_common_unittest.h"
6
7#include "ash/wm/window_resizer.h"
8#include "base/compiler_specific.h"
9#include "chrome/browser/ui/browser.h"
10#include "chrome/common/chrome_switches.h"
11#include "chrome/test/base/testing_profile.h"
12#include "testing/gtest/include/gtest/gtest.h"
13#include "ui/gfx/display.h"
14#include "ui/gfx/screen.h"
15
16#if defined(USE_AURA)
17#include "ui/aura/window.h"
18#endif
19
20namespace {
21
22class TestScreen : public gfx::Screen {
23 public:
24  TestScreen() {}
25  virtual ~TestScreen() {}
26
27  // Overridden from gfx::Screen:
28  virtual bool IsDIPEnabled() OVERRIDE {
29    NOTREACHED();
30    return false;
31  }
32
33  virtual gfx::Point GetCursorScreenPoint() OVERRIDE {
34    NOTREACHED();
35    return gfx::Point();
36  }
37
38  virtual gfx::NativeWindow GetWindowUnderCursor() OVERRIDE {
39    NOTREACHED();
40    return NULL;
41  }
42
43  virtual gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point)
44      OVERRIDE {
45    NOTREACHED();
46    return NULL;
47  }
48
49  virtual int GetNumDisplays() const OVERRIDE {
50    return displays_.size();
51  }
52
53  virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
54    return displays_;
55  }
56
57  virtual gfx::Display GetDisplayNearestWindow(
58      gfx::NativeView view) const OVERRIDE {
59#if defined(USE_AURA)
60    return GetDisplayMatching(view->GetBoundsInScreen());
61#else
62    NOTREACHED();
63    return gfx::Display();
64#endif
65  }
66
67  virtual gfx::Display GetDisplayNearestPoint(
68      const gfx::Point& point) const OVERRIDE {
69    NOTREACHED();
70    return gfx::Display();
71  }
72
73  virtual gfx::Display GetDisplayMatching(
74      const gfx::Rect& match_rect) const OVERRIDE {
75    int max_area = 0;
76    size_t max_area_index = 0;
77
78    for (size_t i = 0; i < displays_.size(); ++i) {
79      gfx::Rect overlap = displays_[i].bounds();
80      overlap.Intersect(match_rect);
81      int area = overlap.width() * overlap.height();
82      if (area > max_area) {
83        max_area = area;
84        max_area_index = i;
85      }
86    }
87    return displays_[max_area_index];
88  }
89
90  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
91    return displays_[0];
92  }
93
94  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {
95    NOTREACHED();
96  }
97
98  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {
99    NOTREACHED();
100  }
101
102  void AddDisplay(const gfx::Rect& bounds,
103                  const gfx::Rect& work_area) {
104    gfx::Display display(displays_.size(), bounds);
105    display.set_work_area(work_area);
106    displays_.push_back(display);
107  }
108
109 private:
110  std::vector<gfx::Display> displays_;
111
112  DISALLOW_COPY_AND_ASSIGN(TestScreen);
113};
114
115class TestTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
116public:
117  TestTargetDisplayProvider() {}
118  virtual ~TestTargetDisplayProvider() {}
119
120  virtual gfx::Display GetTargetDisplay(
121      const gfx::Screen* screen,
122      const gfx::Rect& bounds) const OVERRIDE {
123    // On ash, the bounds is used as a indicator to specify
124    // the target display.
125    return screen->GetDisplayMatching(bounds);
126  }
127
128 private:
129  DISALLOW_COPY_AND_ASSIGN(TestTargetDisplayProvider);
130};
131
132}  // namespace
133
134TestStateProvider::TestStateProvider():
135    has_persistent_data_(false),
136    persistent_show_state_(ui::SHOW_STATE_DEFAULT),
137    has_last_active_data_(false),
138    last_active_show_state_(ui::SHOW_STATE_DEFAULT) {
139}
140
141void TestStateProvider::SetPersistentState(const gfx::Rect& bounds,
142                                           const gfx::Rect& work_area,
143                                           ui::WindowShowState show_state,
144                                           bool has_persistent_data) {
145  persistent_bounds_ = bounds;
146  persistent_work_area_ = work_area;
147  persistent_show_state_ = show_state;
148  has_persistent_data_ = has_persistent_data;
149}
150
151void TestStateProvider::SetLastActiveState(const gfx::Rect& bounds,
152                                           ui::WindowShowState show_state,
153                                           bool has_last_active_data) {
154  last_active_bounds_ = bounds;
155  last_active_show_state_ = show_state;
156  has_last_active_data_ = has_last_active_data;
157}
158
159bool TestStateProvider::GetPersistentState(
160    gfx::Rect* bounds,
161    gfx::Rect* saved_work_area,
162    ui::WindowShowState* show_state) const {
163  DCHECK(show_state);
164  *bounds = persistent_bounds_;
165  *saved_work_area = persistent_work_area_;
166  if (*show_state == ui::SHOW_STATE_DEFAULT)
167    *show_state = persistent_show_state_;
168  return has_persistent_data_;
169}
170
171bool TestStateProvider::GetLastActiveWindowState(
172    gfx::Rect* bounds,
173    ui::WindowShowState* show_state) const {
174  DCHECK(show_state);
175  *bounds = last_active_bounds_;
176  if (*show_state == ui::SHOW_STATE_DEFAULT)
177    *show_state = last_active_show_state_;
178  return has_last_active_data_;
179}
180
181int kWindowTilePixels = WindowSizer::kWindowTilePixels;
182
183// The window sizer commonly used test functions.
184void GetWindowBoundsAndShowState(
185    const gfx::Rect& monitor1_bounds,
186    const gfx::Rect& monitor1_work_area,
187    const gfx::Rect& monitor2_bounds,
188    const gfx::Rect& bounds,
189    const gfx::Rect& work_area,
190    ui::WindowShowState show_state_persisted,
191    ui::WindowShowState show_state_last,
192    Source source,
193    const Browser* browser,
194    const gfx::Rect& passed_in,
195    gfx::Rect* out_bounds,
196    ui::WindowShowState* out_show_state) {
197  DCHECK(out_show_state);
198  TestScreen test_screen;
199  test_screen.AddDisplay(monitor1_bounds, monitor1_work_area);
200  if (!monitor2_bounds.IsEmpty())
201    test_screen.AddDisplay(monitor2_bounds, monitor2_bounds);
202  scoped_ptr<TestStateProvider> sp(new TestStateProvider);
203  if (source == PERSISTED || source == BOTH)
204    sp->SetPersistentState(bounds, work_area, show_state_persisted, true);
205  if (source == LAST_ACTIVE || source == BOTH)
206    sp->SetLastActiveState(bounds, show_state_last, true);
207  scoped_ptr<WindowSizer::TargetDisplayProvider> tdp(
208      new TestTargetDisplayProvider);
209
210  WindowSizer sizer(sp.PassAs<WindowSizer::StateProvider>(),
211                    tdp.Pass(), &test_screen, browser);
212  sizer.DetermineWindowBoundsAndShowState(passed_in,
213                                          out_bounds,
214                                          out_show_state);
215}
216
217void GetWindowBounds(const gfx::Rect& monitor1_bounds,
218                            const gfx::Rect& monitor1_work_area,
219                            const gfx::Rect& monitor2_bounds,
220                            const gfx::Rect& bounds,
221                            const gfx::Rect& work_area,
222                            Source source,
223                            const Browser* browser,
224                            const gfx::Rect& passed_in,
225                            gfx::Rect* out_bounds) {
226  ui::WindowShowState out_show_state = ui::SHOW_STATE_DEFAULT;
227  GetWindowBoundsAndShowState(
228      monitor1_bounds, monitor1_work_area, monitor2_bounds, bounds, work_area,
229      ui::SHOW_STATE_DEFAULT, ui::SHOW_STATE_DEFAULT, source, browser,
230      passed_in, out_bounds, &out_show_state);
231}
232
233ui::WindowShowState GetWindowShowState(
234    ui::WindowShowState show_state_persisted,
235    ui::WindowShowState show_state_last,
236    Source source,
237    const Browser* browser,
238    const gfx::Rect& display_config) {
239  gfx::Rect bounds = display_config;
240  gfx::Rect work_area = display_config;
241  TestScreen test_screen;
242  test_screen.AddDisplay(display_config, display_config);
243  scoped_ptr<TestStateProvider> sp(new TestStateProvider);
244  if (source == PERSISTED || source == BOTH)
245    sp->SetPersistentState(bounds, work_area, show_state_persisted, true);
246  if (source == LAST_ACTIVE || source == BOTH)
247    sp->SetLastActiveState(bounds, show_state_last, true);
248  scoped_ptr<WindowSizer::TargetDisplayProvider> tdp(
249      new TestTargetDisplayProvider);
250
251  WindowSizer sizer(sp.PassAs<WindowSizer::StateProvider>(),
252                    tdp.Pass(), &test_screen, browser);
253
254  ui::WindowShowState out_show_state = ui::SHOW_STATE_DEFAULT;
255  gfx::Rect out_bounds;
256  sizer.DetermineWindowBoundsAndShowState(
257      gfx::Rect(),
258      &out_bounds,
259      &out_show_state);
260  return out_show_state;
261}
262
263#if !defined(OS_MACOSX)
264TEST(WindowSizerTestCommon,
265     PersistedWindowOffscreenWithNonAggressiveRepositioning) {
266  { // off the left but the minimum visibility condition is barely satisfied
267    // without relocaiton.
268    gfx::Rect initial_bounds(-470, 50, 500, 400);
269
270    gfx::Rect window_bounds;
271    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
272                    initial_bounds, gfx::Rect(), PERSISTED,
273                    NULL, gfx::Rect(), &window_bounds);
274    EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
275  }
276
277  { // off the left and the minimum visibility condition is satisfied by
278    // relocation.
279    gfx::Rect window_bounds;
280    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
281                    gfx::Rect(-471, 50, 500, 400), gfx::Rect(), PERSISTED,
282                    NULL, gfx::Rect(), &window_bounds);
283    EXPECT_EQ(gfx::Rect(-470 /* not -471 */, 50, 500, 400).ToString(),
284              window_bounds.ToString());
285  }
286
287  { // off the top
288    gfx::Rect initial_bounds(50, -370, 500, 400);
289
290    gfx::Rect window_bounds;
291    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
292                    gfx::Rect(50, -370, 500, 400), gfx::Rect(), PERSISTED,
293                    NULL, gfx::Rect(), &window_bounds);
294    EXPECT_EQ("50,0 500x400", window_bounds.ToString());
295  }
296
297  { // off the right but the minimum visibility condition is barely satisified
298    // without relocation.
299    gfx::Rect initial_bounds(994, 50, 500, 400);
300
301    gfx::Rect window_bounds;
302    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
303                    initial_bounds, gfx::Rect(), PERSISTED,
304                    NULL, gfx::Rect(), &window_bounds);
305    EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
306  }
307
308  { // off the right and the minimum visibility condition is satisified by
309    // relocation.
310    gfx::Rect window_bounds;
311    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
312                    gfx::Rect(995, 50, 500, 400), gfx::Rect(), PERSISTED,
313                    NULL, gfx::Rect(), &window_bounds);
314    EXPECT_EQ(gfx::Rect(994 /* not 995 */, 50, 500, 400).ToString(),
315              window_bounds.ToString());
316  }
317
318  { // off the bottom but the minimum visibility condition is barely satisified
319    // without relocation.
320    gfx::Rect initial_bounds(50, 738, 500, 400);
321
322    gfx::Rect window_bounds;
323    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
324                    initial_bounds, gfx::Rect(), PERSISTED,
325                    NULL, gfx::Rect(), &window_bounds);
326    EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
327  }
328
329  { // off the bottom and the minimum visibility condition is satisified by
330    // relocation.
331    gfx::Rect window_bounds;
332    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
333                    gfx::Rect(50, 739, 500, 400), gfx::Rect(), PERSISTED,
334                    NULL, gfx::Rect(), &window_bounds);
335    EXPECT_EQ(gfx::Rect(50, 738 /* not 739 */, 500, 400).ToString(),
336              window_bounds.ToString());
337  }
338
339  { // off the topleft
340    gfx::Rect window_bounds;
341    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
342                    gfx::Rect(-471, -371, 500, 400), gfx::Rect(), PERSISTED,
343                    NULL, gfx::Rect(), &window_bounds);
344    EXPECT_EQ(gfx::Rect(-470 /* not -471 */, 0, 500, 400).ToString(),
345              window_bounds.ToString());
346  }
347
348  { // off the topright and the minimum visibility condition is satisified by
349    // relocation.
350    gfx::Rect window_bounds;
351    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
352                    gfx::Rect(995, -371, 500, 400), gfx::Rect(), PERSISTED,
353                    NULL, gfx::Rect(), &window_bounds);
354    EXPECT_EQ(gfx::Rect(994 /* not 995 */, 0, 500, 400).ToString(),
355              window_bounds.ToString());
356  }
357
358  { // off the bottomleft and the minimum visibility condition is satisified by
359    // relocation.
360    gfx::Rect window_bounds;
361    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
362                    gfx::Rect(-471, 739, 500, 400), gfx::Rect(), PERSISTED,
363                    NULL, gfx::Rect(), &window_bounds);
364    EXPECT_EQ(gfx::Rect(-470 /* not -471 */,
365                        738 /* not 739 */,
366                        500,
367                        400).ToString(),
368              window_bounds.ToString());
369  }
370
371  { // off the bottomright and the minimum visibility condition is satisified by
372    // relocation.
373    gfx::Rect window_bounds;
374    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
375                    gfx::Rect(995, 739, 500, 400), gfx::Rect(), PERSISTED,
376                    NULL, gfx::Rect(), &window_bounds);
377    EXPECT_EQ(gfx::Rect(994 /* not 995 */,
378                        738 /* not 739 */,
379                        500,
380                        400).ToString(),
381              window_bounds.ToString());
382  }
383
384  { // entirely off left
385    gfx::Rect window_bounds;
386    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
387                    gfx::Rect(-700, 50, 500, 400), gfx::Rect(), PERSISTED,
388                    NULL, gfx::Rect(), &window_bounds);
389    EXPECT_EQ(gfx::Rect(-470 /* not -700 */, 50, 500, 400).ToString(),
390              window_bounds.ToString());
391  }
392
393  { // entirely off left (monitor was detached since last run)
394    gfx::Rect window_bounds;
395    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
396                    gfx::Rect(-700, 50, 500, 400), left_s1024x768, PERSISTED,
397                    NULL, gfx::Rect(), &window_bounds);
398    EXPECT_EQ("0,50 500x400", window_bounds.ToString());
399  }
400
401  { // entirely off top
402    gfx::Rect window_bounds;
403    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
404                    gfx::Rect(50, -500, 500, 400), gfx::Rect(), PERSISTED,
405                    NULL, gfx::Rect(), &window_bounds);
406    EXPECT_EQ("50,0 500x400", window_bounds.ToString());
407  }
408
409  { // entirely off top (monitor was detached since last run)
410    gfx::Rect window_bounds;
411    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
412                    gfx::Rect(50, -500, 500, 400), top_s1024x768,
413                    PERSISTED, NULL, gfx::Rect(), &window_bounds);
414    EXPECT_EQ("50,0 500x400", window_bounds.ToString());
415  }
416
417  { // entirely off right
418    gfx::Rect window_bounds;
419    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
420                    gfx::Rect(1200, 50, 500, 400), gfx::Rect(), PERSISTED,
421                    NULL, gfx::Rect(), &window_bounds);
422    EXPECT_EQ(gfx::Rect(994 /* not 1200 */, 50, 500, 400).ToString(),
423              window_bounds.ToString());
424  }
425
426  { // entirely off right (monitor was detached since last run)
427    gfx::Rect window_bounds;
428    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
429                    gfx::Rect(1200, 50, 500, 400), right_s1024x768,
430                    PERSISTED, NULL, gfx::Rect(), &window_bounds);
431    EXPECT_EQ("524,50 500x400", window_bounds.ToString());
432  }
433
434  { // entirely off bottom
435    gfx::Rect window_bounds;
436    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
437                    gfx::Rect(50, 800, 500, 400), gfx::Rect(), PERSISTED,
438                    NULL, gfx::Rect(), &window_bounds);
439    EXPECT_EQ(gfx::Rect(50, 738 /* not 800 */, 500, 400).ToString(),
440              window_bounds.ToString());
441  }
442
443  { // entirely off bottom (monitor was detached since last run)
444    gfx::Rect window_bounds;
445    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
446                    gfx::Rect(50, 800, 500, 400), bottom_s1024x768,
447                    PERSISTED, NULL, gfx::Rect(), &window_bounds);
448    EXPECT_EQ("50,368 500x400", window_bounds.ToString());
449  }
450}
451
452// Test that the window is sized appropriately for the first run experience
453// where the default window bounds calculation is invoked.
454TEST(WindowSizerTestCommon, AdjustFitSize) {
455  { // Check that the window gets resized to the screen.
456    gfx::Rect window_bounds;
457    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), gfx::Rect(),
458                    gfx::Rect(), DEFAULT, NULL,
459                    gfx::Rect(-10, -10, 1024 + 20, 768 + 20), &window_bounds);
460    EXPECT_EQ("0,0 1024x768", window_bounds.ToString());
461  }
462
463  { // Check that a window which hangs out of the screen get moved back in.
464    gfx::Rect window_bounds;
465    GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), gfx::Rect(),
466                    gfx::Rect(), DEFAULT, NULL,
467                    gfx::Rect(1020, 700, 100, 100), &window_bounds);
468    EXPECT_EQ("924,668 100x100", window_bounds.ToString());
469  }
470}
471
472#endif // defined(OS_MACOSX)
473