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 "ash/wm/workspace/workspace_layout_manager.h"
6
7#include <string>
8
9#include "ash/display/display_layout.h"
10#include "ash/display/display_manager.h"
11#include "ash/root_window_controller.h"
12#include "ash/screen_util.h"
13#include "ash/session/session_state_delegate.h"
14#include "ash/shelf/shelf_layout_manager.h"
15#include "ash/shell.h"
16#include "ash/shell_observer.h"
17#include "ash/shell_window_ids.h"
18#include "ash/test/ash_test_base.h"
19#include "ash/wm/maximize_mode/workspace_backdrop_delegate.h"
20#include "ash/wm/window_state.h"
21#include "ash/wm/window_util.h"
22#include "ash/wm/wm_event.h"
23#include "ash/wm/workspace/workspace_window_resizer.h"
24#include "base/basictypes.h"
25#include "base/compiler_specific.h"
26#include "ui/aura/client/aura_constants.h"
27#include "ui/aura/test/test_windows.h"
28#include "ui/aura/window.h"
29#include "ui/aura/window_event_dispatcher.h"
30#include "ui/base/ime/dummy_text_input_client.h"
31#include "ui/base/ime/input_method.h"
32#include "ui/base/ime/text_input_focus_manager.h"
33#include "ui/base/ui_base_switches_util.h"
34#include "ui/base/ui_base_types.h"
35#include "ui/gfx/insets.h"
36#include "ui/gfx/screen.h"
37#include "ui/views/widget/widget.h"
38#include "ui/views/widget/widget_delegate.h"
39#include "ui/wm/core/window_util.h"
40
41namespace ash {
42namespace {
43
44class MaximizeDelegateView : public views::WidgetDelegateView {
45 public:
46  explicit MaximizeDelegateView(const gfx::Rect& initial_bounds)
47      : initial_bounds_(initial_bounds) {
48  }
49  virtual ~MaximizeDelegateView() {}
50
51  virtual bool GetSavedWindowPlacement(
52      const views::Widget* widget,
53      gfx::Rect* bounds,
54      ui::WindowShowState* show_state) const OVERRIDE {
55    *bounds = initial_bounds_;
56    *show_state = ui::SHOW_STATE_MAXIMIZED;
57    return true;
58  }
59
60 private:
61  const gfx::Rect initial_bounds_;
62
63  DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
64};
65
66class TestShellObserver : public ShellObserver {
67 public:
68  TestShellObserver() : call_count_(0),
69                        is_fullscreen_(false) {
70    Shell::GetInstance()->AddShellObserver(this);
71  }
72
73  virtual ~TestShellObserver() {
74    Shell::GetInstance()->RemoveShellObserver(this);
75  }
76
77  virtual void OnFullscreenStateChanged(bool is_fullscreen,
78                                        aura::Window* root_window) OVERRIDE {
79    call_count_++;
80    is_fullscreen_ = is_fullscreen;
81  }
82
83  int call_count() const {
84    return call_count_;
85  }
86
87  bool is_fullscreen() const {
88    return is_fullscreen_;
89  }
90
91 private:
92  int call_count_;
93  bool is_fullscreen_;
94
95  DISALLOW_COPY_AND_ASSIGN(TestShellObserver);
96};
97
98}  // namespace
99
100typedef test::AshTestBase WorkspaceLayoutManagerTest;
101
102// Verifies that a window containing a restore coordinate will be restored to
103// to the size prior to minimize, keeping the restore rectangle in tact (if
104// there is one).
105TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) {
106  scoped_ptr<aura::Window> window(
107      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 3, 4)));
108  gfx::Rect bounds(10, 15, 25, 35);
109  window->SetBounds(bounds);
110
111  wm::WindowState* window_state = wm::GetWindowState(window.get());
112
113  // This will not be used for un-minimizing window.
114  window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
115  window_state->Minimize();
116  window_state->Restore();
117  EXPECT_EQ("0,0 100x100", window_state->GetRestoreBoundsInScreen().ToString());
118  EXPECT_EQ("10,15 25x35", window.get()->bounds().ToString());
119
120  if (!SupportsMultipleDisplays())
121    return;
122
123  UpdateDisplay("400x300,500x400");
124  window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100),
125                            ScreenUtil::GetSecondaryDisplay());
126  EXPECT_EQ(Shell::GetAllRootWindows()[1], window->GetRootWindow());
127  window_state->Minimize();
128  // This will not be used for un-minimizing window.
129  window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
130  window_state->Restore();
131  EXPECT_EQ("600,0 100x100", window->GetBoundsInScreen().ToString());
132
133  // Make sure the unminimized window moves inside the display when
134  // 2nd display is disconnected.
135  window_state->Minimize();
136  UpdateDisplay("400x300");
137  window_state->Restore();
138  EXPECT_EQ(Shell::GetPrimaryRootWindow(), window->GetRootWindow());
139  EXPECT_TRUE(
140      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
141}
142
143TEST_F(WorkspaceLayoutManagerTest, KeepMinimumVisibilityInDisplays) {
144  if (!SupportsMultipleDisplays())
145    return;
146
147  UpdateDisplay("300x400,400x500");
148  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
149
150  DisplayLayout layout(DisplayLayout::TOP, 0);
151  Shell::GetInstance()->display_manager()->
152      SetLayoutForCurrentDisplays(layout);
153  EXPECT_EQ("0,-500 400x500", root_windows[1]->GetBoundsInScreen().ToString());
154
155  scoped_ptr<aura::Window> window1(
156      CreateTestWindowInShellWithBounds(gfx::Rect(10, -400, 200, 200)));
157  EXPECT_EQ("10,-400 200x200", window1->GetBoundsInScreen().ToString());
158
159  // Make sure the caption is visible.
160  scoped_ptr<aura::Window> window2(
161      CreateTestWindowInShellWithBounds(gfx::Rect(10, -600, 200, 200)));
162  EXPECT_EQ("10,-500 200x200", window2->GetBoundsInScreen().ToString());
163}
164
165TEST_F(WorkspaceLayoutManagerTest, NoMinimumVisibilityForPopupWindows) {
166  UpdateDisplay("300x400");
167
168  // Create a popup window out of display boundaries and make sure it is not
169  // moved to have minimum visibility.
170  scoped_ptr<aura::Window> window(
171      CreateTestWindowInShellWithDelegateAndType(NULL,
172                                                 ui::wm::WINDOW_TYPE_POPUP,
173                                                 0,
174                                                 gfx::Rect(400, 100, 50, 50)));
175  EXPECT_EQ("400,100 50x50", window->GetBoundsInScreen().ToString());
176}
177
178TEST_F(WorkspaceLayoutManagerTest, KeepRestoredWindowInDisplay) {
179  if (!SupportsHostWindowResize())
180    return;
181  scoped_ptr<aura::Window> window(
182      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
183  wm::WindowState* window_state = wm::GetWindowState(window.get());
184
185  // Maximized -> Normal transition.
186  window_state->Maximize();
187  window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
188  window_state->Restore();
189  EXPECT_TRUE(
190      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
191  // Y bounds should not be negative.
192  EXPECT_EQ("-20,0 30x40", window->bounds().ToString());
193
194  // Minimized -> Normal transition.
195  window->SetBounds(gfx::Rect(-100, -100, 30, 40));
196  window_state->Minimize();
197  EXPECT_FALSE(
198      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
199  EXPECT_EQ("-100,-100 30x40", window->bounds().ToString());
200  window->Show();
201  EXPECT_TRUE(
202      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
203  // Y bounds should not be negative.
204  EXPECT_EQ("-20,0 30x40", window->bounds().ToString());
205
206  // Fullscreen -> Normal transition.
207  window->SetBounds(gfx::Rect(0, 0, 30, 40));  // reset bounds.
208  ASSERT_EQ("0,0 30x40", window->bounds().ToString());
209  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
210  EXPECT_EQ(window->bounds(), window->GetRootWindow()->bounds());
211  window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
212  window_state->Restore();
213  EXPECT_TRUE(
214      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
215  // Y bounds should not be negative.
216  EXPECT_EQ("-20,0 30x40", window->bounds().ToString());
217}
218
219TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) {
220  if (!SupportsMultipleDisplays())
221    return;
222  UpdateDisplay("300x400,400x500");
223
224  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
225
226  scoped_ptr<aura::Window> window(
227      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
228  EXPECT_EQ(root_windows[0], window->GetRootWindow());
229
230  wm::WindowState* window_state = wm::GetWindowState(window.get());
231  window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
232  // Maximize the window in 2nd display as the restore bounds
233  // is inside 2nd display.
234  window_state->Maximize();
235  EXPECT_EQ(root_windows[1], window->GetRootWindow());
236  EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());
237
238  window_state->Restore();
239  EXPECT_EQ(root_windows[1], window->GetRootWindow());
240  EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());
241
242  // If the restore bounds intersects with the current display,
243  // don't move.
244  window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
245  window_state->Maximize();
246  EXPECT_EQ(root_windows[1], window->GetRootWindow());
247  EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());
248
249  window_state->Restore();
250  EXPECT_EQ(root_windows[1], window->GetRootWindow());
251  EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());
252
253  // Restoring widget state.
254  scoped_ptr<views::Widget> w1(new views::Widget);
255  views::Widget::InitParams params;
256  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
257  params.delegate = new MaximizeDelegateView(gfx::Rect(400, 0, 30, 40));
258  params.context = root_windows[0];
259  w1->Init(params);
260  w1->Show();
261  EXPECT_TRUE(w1->IsMaximized());
262  EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
263  EXPECT_EQ("300,0 400x453", w1->GetWindowBoundsInScreen().ToString());
264  w1->Restore();
265  EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
266  EXPECT_EQ("400,0 30x40", w1->GetWindowBoundsInScreen().ToString());
267}
268
269TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) {
270  if (!SupportsMultipleDisplays())
271    return;
272  UpdateDisplay("300x400,400x500");
273
274  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
275
276  scoped_ptr<aura::Window> window(
277      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
278  EXPECT_EQ(root_windows[0], window->GetRootWindow());
279
280  wm::WindowState* window_state = wm::GetWindowState(window.get());
281  window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
282  // Maximize the window in 2nd display as the restore bounds
283  // is inside 2nd display.
284  window->SetProperty(aura::client::kShowStateKey,
285                      ui::SHOW_STATE_FULLSCREEN);
286  EXPECT_EQ(root_windows[1], window->GetRootWindow());
287  EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());
288
289  window_state->Restore();
290  EXPECT_EQ(root_windows[1], window->GetRootWindow());
291  EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());
292
293  // If the restore bounds intersects with the current display,
294  // don't move.
295  window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
296  window->SetProperty(aura::client::kShowStateKey,
297                      ui::SHOW_STATE_FULLSCREEN);
298  EXPECT_EQ(root_windows[1], window->GetRootWindow());
299  EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());
300
301  window_state->Restore();
302  EXPECT_EQ(root_windows[1], window->GetRootWindow());
303  EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());
304}
305
306// WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
307// This code mirrors what BrowserFrameAsh does. In particular when this code
308// sees the window was maximized it changes the bounds of a secondary
309// window. The secondary window mirrors the status window.
310class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
311 public:
312  DontClobberRestoreBoundsWindowObserver() : window_(NULL) {}
313
314  void set_window(aura::Window* window) { window_ = window; }
315
316  virtual void OnWindowPropertyChanged(aura::Window* window,
317                                       const void* key,
318                                       intptr_t old) OVERRIDE {
319    if (!window_)
320      return;
321
322    if (wm::GetWindowState(window)->IsMaximized()) {
323      aura::Window* w = window_;
324      window_ = NULL;
325
326      gfx::Rect shelf_bounds(Shell::GetPrimaryRootWindowController()->
327                             GetShelfLayoutManager()->GetIdealBounds());
328      const gfx::Rect& window_bounds(w->bounds());
329      w->SetBounds(gfx::Rect(window_bounds.x(), shelf_bounds.y() - 1,
330                             window_bounds.width(), window_bounds.height()));
331    }
332  }
333
334 private:
335  aura::Window* window_;
336
337  DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver);
338};
339
340// Creates a window, maximized the window and from within the maximized
341// notification sets the bounds of a window to overlap the shelf. Verifies this
342// doesn't effect the restore bounds.
343TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) {
344  DontClobberRestoreBoundsWindowObserver window_observer;
345  scoped_ptr<aura::Window> window(new aura::Window(NULL));
346  window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
347  window->Init(aura::WINDOW_LAYER_TEXTURED);
348  window->SetBounds(gfx::Rect(10, 20, 30, 40));
349  // NOTE: for this test to exercise the failure the observer needs to be added
350  // before the parent set. This mimics what BrowserFrameAsh does.
351  window->AddObserver(&window_observer);
352  ParentWindowInPrimaryRootWindow(window.get());
353  window->Show();
354
355  wm::WindowState* window_state = wm::GetWindowState(window.get());
356  window_state->Activate();
357
358  scoped_ptr<aura::Window> window2(
359      CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40)));
360  ::wm::AddTransientChild(window.get(), window2.get());
361  window2->Show();
362
363  window_observer.set_window(window2.get());
364  window_state->Maximize();
365  EXPECT_EQ("10,20 30x40",
366            window_state->GetRestoreBoundsInScreen().ToString());
367  window->RemoveObserver(&window_observer);
368}
369
370// Verifies when a window is maximized all descendant windows have a size.
371TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
372  scoped_ptr<aura::Window> window(
373      CreateTestWindowInShellWithBounds(gfx::Rect(10, 20, 30, 40)));
374  window->Show();
375  wm::WindowState* window_state = wm::GetWindowState(window.get());
376  window_state->Activate();
377  scoped_ptr<aura::Window> child_window(
378      aura::test::CreateTestWindowWithBounds(gfx::Rect(5, 6, 7, 8),
379                                             window.get()));
380  child_window->Show();
381  window_state->Maximize();
382  EXPECT_EQ("5,6 7x8", child_window->bounds().ToString());
383}
384
385// Verifies a window created with maximized state has the maximized
386// bounds.
387TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) {
388  scoped_ptr<aura::Window> window(
389      aura::test::CreateTestWindowWithBounds(gfx::Rect(0, 0, 0, 0),
390                                             NULL));
391  wm::GetWindowState(window.get())->Maximize();
392  aura::Window* default_container = Shell::GetContainer(
393      Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer);
394  default_container->AddChild(window.get());
395  window->Show();
396  gfx::Rect work_area(
397      Shell::GetScreen()->GetPrimaryDisplay().work_area());
398  EXPECT_EQ(work_area.ToString(), window->GetBoundsInScreen().ToString());
399}
400
401TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) {
402  // Normal window bounds shouldn't be changed.
403  gfx::Rect window_bounds(100, 100, 200, 200);
404  scoped_ptr<aura::Window> window(
405      CreateTestWindowInShellWithBounds(window_bounds));
406  EXPECT_EQ(window_bounds, window->bounds());
407
408  // If the window is out of the workspace, it would be moved on screen.
409  gfx::Rect root_window_bounds =
410      Shell::GetInstance()->GetPrimaryRootWindow()->bounds();
411  window_bounds.Offset(root_window_bounds.width(), root_window_bounds.height());
412  ASSERT_FALSE(window_bounds.Intersects(root_window_bounds));
413  scoped_ptr<aura::Window> out_window(
414      CreateTestWindowInShellWithBounds(window_bounds));
415  EXPECT_EQ(window_bounds.size(), out_window->bounds().size());
416  gfx::Rect bounds = out_window->bounds();
417  bounds.Intersect(root_window_bounds);
418
419  // 30% of the window edge must be visible.
420  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
421  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
422
423  aura::Window* parent = out_window->parent();
424  parent->RemoveChild(out_window.get());
425  out_window->SetBounds(gfx::Rect(-200, -200, 200, 200));
426  // UserHasChangedWindowPositionOrSize flag shouldn't turn off this behavior.
427  wm::GetWindowState(window.get())->set_bounds_changed_by_user(true);
428  parent->AddChild(out_window.get());
429  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
430  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
431
432  // Make sure we always make more than 1/3 of the window edge visible even
433  // if the initial bounds intersects with display.
434  window_bounds.SetRect(-150, -150, 200, 200);
435  bounds = window_bounds;
436  bounds.Intersect(root_window_bounds);
437
438  // Make sure that the initial bounds' visible area is less than 26%
439  // so that the auto adjustment logic kicks in.
440  ASSERT_LT(bounds.width(), out_window->bounds().width() * 0.26);
441  ASSERT_LT(bounds.height(), out_window->bounds().height() * 0.26);
442  ASSERT_TRUE(window_bounds.Intersects(root_window_bounds));
443
444  scoped_ptr<aura::Window> partially_out_window(
445      CreateTestWindowInShellWithBounds(window_bounds));
446  EXPECT_EQ(window_bounds.size(), partially_out_window->bounds().size());
447  bounds = partially_out_window->bounds();
448  bounds.Intersect(root_window_bounds);
449  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
450  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
451
452  // Make sure the window whose 30% width/height is bigger than display
453  // will be placed correctly.
454  window_bounds.SetRect(-1900, -1900, 3000, 3000);
455  scoped_ptr<aura::Window> window_bigger_than_display(
456      CreateTestWindowInShellWithBounds(window_bounds));
457  EXPECT_GE(root_window_bounds.width(),
458            window_bigger_than_display->bounds().width());
459  EXPECT_GE(root_window_bounds.height(),
460            window_bigger_than_display->bounds().height());
461
462  bounds = window_bigger_than_display->bounds();
463  bounds.Intersect(root_window_bounds);
464  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
465  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
466}
467
468// Verifies the size of a window is enforced to be smaller than the work area.
469TEST_F(WorkspaceLayoutManagerTest, SizeToWorkArea) {
470  // Normal window bounds shouldn't be changed.
471  gfx::Size work_area(
472      Shell::GetScreen()->GetPrimaryDisplay().work_area().size());
473  const gfx::Rect window_bounds(
474      100, 101, work_area.width() + 1, work_area.height() + 2);
475  scoped_ptr<aura::Window> window(
476      CreateTestWindowInShellWithBounds(window_bounds));
477  EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
478      window->bounds().ToString());
479
480  // Directly setting the bounds triggers a slightly different code path. Verify
481  // that too.
482  window->SetBounds(window_bounds);
483  EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
484      window->bounds().ToString());
485}
486
487TEST_F(WorkspaceLayoutManagerTest, NotifyFullscreenChanges) {
488  TestShellObserver observer;
489  scoped_ptr<aura::Window> window1(
490      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
491  scoped_ptr<aura::Window> window2(
492      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
493  wm::WindowState* window_state1 = wm::GetWindowState(window1.get());
494  wm::WindowState* window_state2 = wm::GetWindowState(window2.get());
495  window_state2->Activate();
496
497  const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
498  window_state2->OnWMEvent(&toggle_fullscreen_event);
499  EXPECT_EQ(1, observer.call_count());
500  EXPECT_TRUE(observer.is_fullscreen());
501
502  // When window1 moves to the front the fullscreen state should change.
503  window_state1->Activate();
504  EXPECT_EQ(2, observer.call_count());
505  EXPECT_FALSE(observer.is_fullscreen());
506
507  // It should change back if window2 becomes active again.
508  window_state2->Activate();
509  EXPECT_EQ(3, observer.call_count());
510  EXPECT_TRUE(observer.is_fullscreen());
511
512  window_state2->OnWMEvent(&toggle_fullscreen_event);
513  EXPECT_EQ(4, observer.call_count());
514  EXPECT_FALSE(observer.is_fullscreen());
515
516  window_state2->OnWMEvent(&toggle_fullscreen_event);
517  EXPECT_EQ(5, observer.call_count());
518  EXPECT_TRUE(observer.is_fullscreen());
519
520  // Closing the window should change the fullscreen state.
521  window2.reset();
522  EXPECT_EQ(6, observer.call_count());
523  EXPECT_FALSE(observer.is_fullscreen());
524}
525
526// Following "Solo" tests were originally written for BaseLayoutManager.
527namespace {
528
529class WorkspaceLayoutManagerSoloTest : public test::AshTestBase {
530 public:
531  WorkspaceLayoutManagerSoloTest() {}
532  virtual ~WorkspaceLayoutManagerSoloTest() {}
533
534  aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
535    return CreateTestWindowInShellWithBounds(bounds);
536  }
537
538 private:
539  DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerSoloTest);
540};
541
542}  // namespace
543
544// Tests normal->maximize->normal.
545TEST_F(WorkspaceLayoutManagerSoloTest, Maximize) {
546  gfx::Rect bounds(100, 100, 200, 200);
547  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
548  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
549  // Maximized window fills the work area, not the whole display.
550  EXPECT_EQ(
551      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(),
552      window->bounds().ToString());
553  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
554  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
555}
556
557// Tests normal->minimize->normal.
558TEST_F(WorkspaceLayoutManagerSoloTest, Minimize) {
559  gfx::Rect bounds(100, 100, 200, 200);
560  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
561  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
562  // Note: Currently minimize doesn't do anything except set the state.
563  // See crbug.com/104571.
564  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
565  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
566  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
567}
568
569// A WindowDelegate which sets the focus when the window
570// becomes visible.
571class FocusDelegate : public aura::test::TestWindowDelegate {
572 public:
573  FocusDelegate()
574      : window_(NULL),
575        show_state_(ui::SHOW_STATE_END) {
576  }
577  virtual ~FocusDelegate() {}
578
579  void set_window(aura::Window* window) { window_ = window; }
580
581  // aura::test::TestWindowDelegate overrides:
582  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
583    if (window_) {
584      if (visible)
585        window_->Focus();
586      show_state_ = window_->GetProperty(aura::client::kShowStateKey);
587    }
588  }
589
590  ui::WindowShowState GetShowStateAndReset() {
591    ui::WindowShowState ret = show_state_;
592    show_state_ = ui::SHOW_STATE_END;
593    return ret;
594  }
595
596 private:
597  aura::Window* window_;
598  ui::WindowShowState show_state_;
599
600  DISALLOW_COPY_AND_ASSIGN(FocusDelegate);
601};
602
603// Make sure that the window's show state is correct in
604// |WindowDelegate::OnWindowTargetVisibilityChanged|, and setting
605// focus in this callback doesn't cause DCHECK error.  See
606// crbug.com/168383.
607TEST_F(WorkspaceLayoutManagerSoloTest, FocusDuringUnminimize) {
608  FocusDelegate delegate;
609  scoped_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
610      &delegate, 0, gfx::Rect(100, 100, 100, 100)));
611  delegate.set_window(window.get());
612  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
613  EXPECT_FALSE(window->IsVisible());
614  EXPECT_EQ(ui::SHOW_STATE_MINIMIZED, delegate.GetShowStateAndReset());
615  window->Show();
616  EXPECT_TRUE(window->IsVisible());
617  EXPECT_EQ(ui::SHOW_STATE_NORMAL, delegate.GetShowStateAndReset());
618}
619
620// Tests maximized window size during root window resize.
621TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeRootWindowResize) {
622  gfx::Rect bounds(100, 100, 200, 200);
623  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
624  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
625  gfx::Rect initial_work_area_bounds =
626      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get());
627  EXPECT_EQ(initial_work_area_bounds.ToString(), window->bounds().ToString());
628  // Enlarge the root window.  We should still match the work area size.
629  UpdateDisplay("900x700");
630  EXPECT_EQ(
631      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(),
632      window->bounds().ToString());
633  EXPECT_NE(
634      initial_work_area_bounds.ToString(),
635      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString());
636}
637
638// Tests normal->fullscreen->normal.
639TEST_F(WorkspaceLayoutManagerSoloTest, Fullscreen) {
640  gfx::Rect bounds(100, 100, 200, 200);
641  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
642  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
643  // Fullscreen window fills the whole display.
644  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
645                window.get()).bounds().ToString(),
646            window->bounds().ToString());
647  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
648  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
649}
650
651// Tests fullscreen window size during root window resize.
652TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenRootWindowResize) {
653  gfx::Rect bounds(100, 100, 200, 200);
654  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
655  // Fullscreen window fills the whole display.
656  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
657  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
658                window.get()).bounds().ToString(),
659            window->bounds().ToString());
660  // Enlarge the root window.  We should still match the display size.
661  UpdateDisplay("800x600");
662  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
663                window.get()).bounds().ToString(),
664            window->bounds().ToString());
665}
666
667// Tests that when the screen gets smaller the windows aren't bigger than
668// the screen.
669TEST_F(WorkspaceLayoutManagerSoloTest, RootWindowResizeShrinksWindows) {
670  scoped_ptr<aura::Window> window(
671      CreateTestWindow(gfx::Rect(10, 20, 500, 400)));
672  gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
673      window.get()).work_area();
674  // Invariant: Window is smaller than work area.
675  EXPECT_LE(window->bounds().width(), work_area.width());
676  EXPECT_LE(window->bounds().height(), work_area.height());
677
678  // Make the root window narrower than our window.
679  UpdateDisplay("300x400");
680  work_area = Shell::GetScreen()->GetDisplayNearestWindow(
681      window.get()).work_area();
682  EXPECT_LE(window->bounds().width(), work_area.width());
683  EXPECT_LE(window->bounds().height(), work_area.height());
684
685  // Make the root window shorter than our window.
686  UpdateDisplay("300x200");
687  work_area = Shell::GetScreen()->GetDisplayNearestWindow(
688      window.get()).work_area();
689  EXPECT_LE(window->bounds().width(), work_area.width());
690  EXPECT_LE(window->bounds().height(), work_area.height());
691
692  // Enlarging the root window does not change the window bounds.
693  gfx::Rect old_bounds = window->bounds();
694  UpdateDisplay("800x600");
695  EXPECT_EQ(old_bounds.width(), window->bounds().width());
696  EXPECT_EQ(old_bounds.height(), window->bounds().height());
697}
698
699// Verifies maximizing sets the restore bounds, and restoring
700// restores the bounds.
701TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeSetsRestoreBounds) {
702  scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(10, 20, 30, 40)));
703  wm::WindowState* window_state = wm::GetWindowState(window.get());
704
705  // Maximize it, which will keep the previous restore bounds.
706  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
707  EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInParent().ToString());
708
709  // Restore it, which should restore bounds and reset restore bounds.
710  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
711  EXPECT_EQ("10,20 30x40", window->bounds().ToString());
712  EXPECT_FALSE(window_state->HasRestoreBounds());
713}
714
715// Verifies maximizing keeps the restore bounds if set.
716TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeResetsRestoreBounds) {
717  scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4)));
718
719  wm::WindowState* window_state = wm::GetWindowState(window.get());
720  window_state->SetRestoreBoundsInParent(gfx::Rect(10, 11, 12, 13));
721
722  // Maximize it, which will keep the previous restore bounds.
723  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
724  EXPECT_EQ("10,11 12x13", window_state->GetRestoreBoundsInParent().ToString());
725}
726
727// Verifies that the restore bounds do not get reset when restoring to a
728// maximzied state from a minimized state.
729TEST_F(WorkspaceLayoutManagerSoloTest,
730       BoundsAfterRestoringToMaximizeFromMinimize) {
731  scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4)));
732  gfx::Rect bounds(10, 15, 25, 35);
733  window->SetBounds(bounds);
734
735  wm::WindowState* window_state = wm::GetWindowState(window.get());
736  // Maximize it, which should reset restore bounds.
737  window_state->Maximize();
738  EXPECT_EQ(bounds.ToString(),
739            window_state->GetRestoreBoundsInParent().ToString());
740  // Minimize the window. The restore bounds should not change.
741  window_state->Minimize();
742  EXPECT_EQ(bounds.ToString(),
743            window_state->GetRestoreBoundsInParent().ToString());
744
745  // Show the window again. The window should be maximized, and the restore
746  // bounds should not change.
747  window->Show();
748  EXPECT_EQ(bounds.ToString(),
749            window_state->GetRestoreBoundsInParent().ToString());
750  EXPECT_TRUE(window_state->IsMaximized());
751
752  window_state->Restore();
753  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
754}
755
756// Verify if the window is not resized during screen lock. See: crbug.com/173127
757TEST_F(WorkspaceLayoutManagerSoloTest, NotResizeWhenScreenIsLocked) {
758  SetCanLockScreen(true);
759  scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4)));
760  // window with AlwaysOnTop will be managed by BaseLayoutManager.
761  window->SetProperty(aura::client::kAlwaysOnTopKey, true);
762  window->Show();
763
764  ShelfLayoutManager* shelf = ShelfLayoutManager::ForShelf(window.get());
765  shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
766
767  window->SetBounds(ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()));
768  gfx::Rect window_bounds = window->bounds();
769  EXPECT_EQ(
770      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(),
771      window_bounds.ToString());
772
773  Shell::GetInstance()->session_state_delegate()->LockScreen();
774  shelf->UpdateVisibilityState();
775  EXPECT_NE(
776      ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(),
777      window_bounds.ToString());
778
779  Shell::GetInstance()->session_state_delegate()->UnlockScreen();
780  shelf->UpdateVisibilityState();
781  EXPECT_EQ(window_bounds.ToString(), window->bounds().ToString());
782}
783
784// Following tests are written to test the backdrop functionality.
785
786namespace {
787
788class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase {
789 public:
790  WorkspaceLayoutManagerBackdropTest() {}
791  virtual ~WorkspaceLayoutManagerBackdropTest() {}
792
793  virtual void SetUp() OVERRIDE {
794    test::AshTestBase::SetUp();
795    UpdateDisplay("800x600");
796    default_container_ = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
797                                             kShellWindowId_DefaultContainer);
798  }
799
800  aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
801    aura::Window* window = CreateTestWindowInShellWithBounds(bounds);
802    return window;
803  }
804
805  // Turn the top window back drop on / off.
806  void ShowTopWindowBackdrop(bool show) {
807    scoped_ptr<ash::WorkspaceLayoutManagerDelegate> backdrop;
808    if (show) {
809      backdrop.reset(new ash::WorkspaceBackdropDelegate(default_container_));
810    }
811    (static_cast<WorkspaceLayoutManager*>(default_container_->layout_manager()))
812        ->SetMaximizeBackdropDelegate(backdrop.Pass());
813    // Closing and / or opening can be a delayed operation.
814    base::MessageLoop::current()->RunUntilIdle();
815  }
816
817  // Return the default container.
818  aura::Window* default_container() { return default_container_; }
819
820  // Return the order of windows (top most first) as they are in the default
821  // container. If the window is visible it will be a big letter, otherwise a
822  // small one. The backdrop will be an X and unknown windows will be shown as
823  // '!'.
824  std::string GetWindowOrderAsString(aura::Window* backdrop,
825                                     aura::Window* wa,
826                                     aura::Window* wb,
827                                     aura::Window* wc) {
828    std::string result;
829    for (int i = static_cast<int>(default_container()->children().size()) - 1;
830         i >= 0;
831         --i) {
832      if (!result.empty())
833        result += ",";
834      if (default_container()->children()[i] == wa)
835        result += default_container()->children()[i]->IsVisible() ? "A" : "a";
836      else if (default_container()->children()[i] == wb)
837        result += default_container()->children()[i]->IsVisible() ? "B" : "b";
838      else if (default_container()->children()[i] == wc)
839        result += default_container()->children()[i]->IsVisible() ? "C" : "c";
840      else if (default_container()->children()[i] == backdrop)
841        result += default_container()->children()[i]->IsVisible() ? "X" : "x";
842      else
843        result += "!";
844    }
845    return result;
846  }
847
848 private:
849  // The default container.
850  aura::Window* default_container_;
851
852  DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerBackdropTest);
853};
854
855}  // namespace
856
857// Check that creating the BackDrop without destroying it does not lead into
858// a crash.
859TEST_F(WorkspaceLayoutManagerBackdropTest, BackdropCrashTest) {
860  ShowTopWindowBackdrop(true);
861}
862
863// Verify basic assumptions about the backdrop.
864TEST_F(WorkspaceLayoutManagerBackdropTest, BasicBackdropTests) {
865  // Create a backdrop and see that there is one window (the backdrop) and
866  // that the size is the same as the default container as well as that it is
867  // not visible.
868  ShowTopWindowBackdrop(true);
869  ASSERT_EQ(1U, default_container()->children().size());
870  EXPECT_FALSE(default_container()->children()[0]->IsVisible());
871
872  {
873    // Add a window and make sure that the backdrop is the second child.
874    scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4)));
875    window->Show();
876    ASSERT_EQ(2U, default_container()->children().size());
877    EXPECT_TRUE(default_container()->children()[0]->IsVisible());
878    EXPECT_TRUE(default_container()->children()[1]->IsVisible());
879    EXPECT_EQ(window.get(), default_container()->children()[1]);
880    EXPECT_EQ(default_container()->bounds().ToString(),
881              default_container()->children()[0]->bounds().ToString());
882  }
883
884  // With the window gone the backdrop should be invisible again.
885  ASSERT_EQ(1U, default_container()->children().size());
886  EXPECT_FALSE(default_container()->children()[0]->IsVisible());
887
888  // Destroying the Backdrop should empty the container.
889  ShowTopWindowBackdrop(false);
890  ASSERT_EQ(0U, default_container()->children().size());
891}
892
893// Verify that the backdrop gets properly created and placed.
894TEST_F(WorkspaceLayoutManagerBackdropTest, VerifyBackdropAndItsStacking) {
895  scoped_ptr<aura::Window> window1(CreateTestWindow(gfx::Rect(1, 2, 3, 4)));
896  window1->Show();
897
898  // Get the default container and check that only a single window is in there.
899  ASSERT_EQ(1U, default_container()->children().size());
900  EXPECT_EQ(window1.get(), default_container()->children()[0]);
901  EXPECT_EQ("A", GetWindowOrderAsString(NULL, window1.get(), NULL, NULL));
902
903  // Create 2 more windows and check that they are also in the container.
904  scoped_ptr<aura::Window> window2(CreateTestWindow(gfx::Rect(10, 2, 3, 4)));
905  scoped_ptr<aura::Window> window3(CreateTestWindow(gfx::Rect(20, 2, 3, 4)));
906  window2->Show();
907  window3->Show();
908
909  aura::Window* backdrop = NULL;
910  EXPECT_EQ("C,B,A",
911            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
912                                   window3.get()));
913
914  // Turn on the backdrop mode and check that the window shows up where it
915  // should be (second highest number).
916  ShowTopWindowBackdrop(true);
917  backdrop = default_container()->children()[2];
918  EXPECT_EQ("C,X,B,A",
919            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
920                                   window3.get()));
921
922  // Switch the order of windows and check that it still remains in that
923  // location.
924  default_container()->StackChildAtTop(window2.get());
925  EXPECT_EQ("B,X,C,A",
926            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
927                                   window3.get()));
928
929  // Make the top window invisible and check.
930  window2.get()->Hide();
931  EXPECT_EQ("b,C,X,A",
932            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
933                                   window3.get()));
934  // Then delete window after window and see that everything is in order.
935  window1.reset();
936  EXPECT_EQ("b,C,X",
937            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
938                                   window3.get()));
939  window3.reset();
940  EXPECT_EQ("b,x",
941            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
942                                   window3.get()));
943  ShowTopWindowBackdrop(false);
944  EXPECT_EQ("b",
945            GetWindowOrderAsString(NULL, window1.get(), window2.get(),
946                                   window3.get()));
947}
948
949// Tests that when hidding the shelf, that the backdrop resizes to fill the
950// entire workspace area.
951TEST_F(WorkspaceLayoutManagerBackdropTest, ShelfVisibilityChangesBounds) {
952  ShelfLayoutManager* shelf_layout_manager =
953      Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
954  ShowTopWindowBackdrop(true);
955  RunAllPendingInMessageLoop();
956
957  ASSERT_EQ(SHELF_VISIBLE, shelf_layout_manager->visibility_state());
958  gfx::Rect initial_bounds = default_container()->children()[0]->bounds();
959  shelf_layout_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
960  shelf_layout_manager->UpdateVisibilityState();
961
962  // When the shelf is re-shown WorkspaceLayoutManager shrinks all children
963  // including the backdrop.
964  shelf_layout_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
965  shelf_layout_manager->UpdateVisibilityState();
966  gfx::Rect reduced_bounds = default_container()->children()[0]->bounds();
967  EXPECT_LT(reduced_bounds.height(), initial_bounds.height());
968
969  shelf_layout_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
970  shelf_layout_manager->UpdateVisibilityState();
971
972  EXPECT_GT(default_container()->children()[0]->bounds().height(),
973            reduced_bounds.height());
974}
975
976class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase {
977 public:
978  WorkspaceLayoutManagerKeyboardTest() {}
979  virtual ~WorkspaceLayoutManagerKeyboardTest() {}
980
981  virtual void SetUp() OVERRIDE {
982    test::AshTestBase::SetUp();
983    UpdateDisplay("800x600");
984    aura::Window* default_container = Shell::GetContainer(
985        Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer);
986    layout_manager_ = static_cast<WorkspaceLayoutManager*>(
987        default_container->layout_manager());
988  }
989
990  aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
991    return CreateTestWindowInShellWithBounds(bounds);
992  }
993
994  void ShowKeyboard() {
995    layout_manager_->OnKeyboardBoundsChanging(keyboard_bounds_);
996    restore_work_area_insets_ = Shell::GetScreen()->GetPrimaryDisplay().
997        GetWorkAreaInsets();
998    Shell::GetInstance()->SetDisplayWorkAreaInsets(
999        Shell::GetPrimaryRootWindow(),
1000        gfx::Insets(0, 0, keyboard_bounds_.height(), 0));
1001  }
1002
1003  void HideKeyboard() {
1004    Shell::GetInstance()->SetDisplayWorkAreaInsets(
1005        Shell::GetPrimaryRootWindow(),
1006        restore_work_area_insets_);
1007    layout_manager_->OnKeyboardBoundsChanging(gfx::Rect());
1008  }
1009
1010  void SetKeyboardBounds(const gfx::Rect& bounds) {
1011    keyboard_bounds_ = bounds;
1012  }
1013
1014  void Focus(ui::TextInputClient* text_input_client) {
1015    if (switches::IsTextInputFocusManagerEnabled()) {
1016      ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(
1017          text_input_client);
1018    } else {
1019      aura::Window* root_window =
1020          ash::Shell::GetInstance()->GetPrimaryRootWindow();
1021      ui::InputMethod* input_method =
1022          root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
1023      input_method->SetFocusedTextInputClient(text_input_client);
1024    }
1025  }
1026
1027  void Blur(ui::TextInputClient* text_input_client) {
1028    if (switches::IsTextInputFocusManagerEnabled()) {
1029      ui::TextInputFocusManager::GetInstance()->BlurTextInputClient(
1030          text_input_client);
1031    } else {
1032      aura::Window* root_window =
1033          ash::Shell::GetInstance()->GetPrimaryRootWindow();
1034      ui::InputMethod* input_method =
1035          root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
1036      input_method->SetFocusedTextInputClient(NULL);
1037    }
1038  }
1039
1040 private:
1041  gfx::Insets restore_work_area_insets_;
1042  gfx::Rect keyboard_bounds_;
1043  WorkspaceLayoutManager* layout_manager_;
1044
1045  DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerKeyboardTest);
1046};
1047
1048class FakeTextInputClient : public ui::DummyTextInputClient {
1049 public:
1050  explicit FakeTextInputClient(gfx::NativeWindow window) : window_(window) {}
1051  virtual ~FakeTextInputClient() {}
1052
1053  virtual gfx::NativeWindow GetAttachedWindow() const OVERRIDE {
1054    return window_;
1055  }
1056
1057 private:
1058  gfx::NativeWindow window_;
1059
1060  DISALLOW_COPY_AND_ASSIGN(FakeTextInputClient);
1061};
1062
1063// Tests that when a child window gains focus the top level window containing it
1064// is resized to fit the remaining workspace area.
1065TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) {
1066  gfx::Rect work_area(
1067      Shell::GetScreen()->GetPrimaryDisplay().work_area());
1068  gfx::Rect keyboard_bounds(work_area.x(),
1069                            work_area.y() + work_area.height() / 2,
1070                            work_area.width(),
1071                            work_area.height() / 2);
1072
1073  SetKeyboardBounds(keyboard_bounds);
1074
1075  aura::test::TestWindowDelegate delegate1;
1076  scoped_ptr<aura::Window> parent_window(CreateTestWindowInShellWithDelegate(
1077      &delegate1, -1, work_area));
1078  aura::test::TestWindowDelegate delegate2;
1079  scoped_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
1080      &delegate2, -1, work_area));
1081  parent_window->AddChild(window.get());
1082
1083  FakeTextInputClient text_input_client(window.get());
1084  Focus(&text_input_client);
1085
1086  int available_height =
1087      Shell::GetScreen()->GetPrimaryDisplay().bounds().height() -
1088      keyboard_bounds.height();
1089
1090  gfx::Rect initial_window_bounds(50, 50, 100, 500);
1091  parent_window->SetBounds(initial_window_bounds);
1092  EXPECT_EQ(initial_window_bounds.ToString(),
1093            parent_window->bounds().ToString());
1094  ShowKeyboard();
1095  EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(),
1096            parent_window->bounds().ToString());
1097  HideKeyboard();
1098  EXPECT_EQ(initial_window_bounds.ToString(),
1099            parent_window->bounds().ToString());
1100
1101  Blur(&text_input_client);
1102}
1103
1104TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) {
1105  gfx::Rect work_area(
1106      Shell::GetScreen()->GetPrimaryDisplay().work_area());
1107  gfx::Rect keyboard_bounds(work_area.x(),
1108                            work_area.y() + work_area.height() / 2,
1109                            work_area.width(),
1110                            work_area.height() / 2);
1111
1112  SetKeyboardBounds(keyboard_bounds);
1113
1114  aura::test::TestWindowDelegate delegate;
1115  scoped_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
1116      &delegate, -1, work_area));
1117
1118  FakeTextInputClient text_input_client(window.get());
1119  Focus(&text_input_client);
1120
1121  int available_height =
1122      Shell::GetScreen()->GetPrimaryDisplay().bounds().height() -
1123      keyboard_bounds.height();
1124
1125  EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString());
1126  ShowKeyboard();
1127  EXPECT_EQ(gfx::Rect(work_area.origin(),
1128            gfx::Size(work_area.width(), available_height)).ToString(),
1129            window->bounds().ToString());
1130  HideKeyboard();
1131  EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString());
1132
1133  gfx::Rect small_window_bound(50, 50, 100, 500);
1134  window->SetBounds(small_window_bound);
1135  EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString());
1136  ShowKeyboard();
1137  EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(),
1138            window->bounds().ToString());
1139  HideKeyboard();
1140  EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString());
1141
1142  gfx::Rect occluded_window_bounds(50,
1143      keyboard_bounds.y() + keyboard_bounds.height()/2, 50,
1144      keyboard_bounds.height()/2);
1145  window->SetBounds(occluded_window_bounds);
1146  EXPECT_EQ(occluded_window_bounds.ToString(),
1147      occluded_window_bounds.ToString());
1148  ShowKeyboard();
1149  EXPECT_EQ(gfx::Rect(50,
1150                      keyboard_bounds.y() - keyboard_bounds.height()/2,
1151                      occluded_window_bounds.width(),
1152                      occluded_window_bounds.height()).ToString(),
1153            window->bounds().ToString());
1154  HideKeyboard();
1155  EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
1156
1157  Blur(&text_input_client);
1158}
1159
1160}  // namespace ash
1161