ash/wm/workspace/workspace_layout_manager_unittest.cc

   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
  41 namespace ash {
  42 namespace {
  43
  44 class 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
  66 class 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
 100 typedef 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).
 105 TEST_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
 143 TEST_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
 165 TEST_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
 178 TEST_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
 219 TEST_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
 269 TEST_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.
 310 class 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.
 343 TEST_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.
 371 TEST_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.
 387 TEST_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
 401 TEST_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.
 469 TEST_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
 487 TEST_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.
 527 namespace {
 528
 529 class 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.
 545 TEST_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.
 558 TEST_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.
 571 class 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.
 607 TEST_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.
 621 TEST_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.
 639 TEST_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.
 652 TEST_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.
 669 TEST_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.
 701 TEST_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.
 716 TEST_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.
 729 TEST_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
 757 TEST_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
 786 namespace {
 787
 788 class 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.
 859 TEST_F(WorkspaceLayoutManagerBackdropTest, BackdropCrashTest) {
 860   ShowTopWindowBackdrop(true);
 861 }
 862
 863 // Verify basic assumptions about the backdrop.
 864 TEST_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.
 894 TEST_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.
 951 TEST_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
 976 class 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
1048 class 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.
1065 TEST_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
1104 TEST_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