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