src/ash/wm/maximize_mode/maximize_mode_window_manager_unittest.cc

   1 // Copyright 2014 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/maximize_mode/maximize_mode_window_manager.h"
   6
   7 #include <string>
   8
   9 #include "ash/root_window_controller.h"
  10 #include "ash/screen_util.h"
  11 #include "ash/shelf/shelf_layout_manager.h"
  12 #include "ash/shell.h"
  13 #include "ash/switchable_windows.h"
  14 #include "ash/test/ash_test_base.h"
  15 #include "ash/test/shell_test_api.h"
  16 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
  17 #include "ash/wm/mru_window_tracker.h"
  18 #include "ash/wm/overview/window_selector_controller.h"
  19 #include "ash/wm/window_properties.h"
  20 #include "ash/wm/window_state.h"
  21 #include "ash/wm/window_util.h"
  22 #include "ash/wm/wm_event.h"
  23 #include "base/strings/stringprintf.h"
  24 #include "base/strings/utf_string_conversions.h"
  25 #include "base/values.h"
  26 #include "ui/aura/client/aura_constants.h"
  27 #include "ui/aura/test/event_generator.h"
  28 #include "ui/aura/test/test_window_delegate.h"
  29 #include "ui/aura/test/test_windows.h"
  30 #include "ui/aura/window.h"
  31 #include "ui/base/hit_test.h"
  32
  33 namespace ash {
  34
  35 // TODO(skuhne): These tests are failing on Widows because maximized is there
  36 // differently handled. Fix this!
  37 #if !defined(OS_WIN)
  38
  39 class MaximizeModeWindowManagerTest : public test::AshTestBase {
  40  public:
  41   MaximizeModeWindowManagerTest() {}
  42   virtual ~MaximizeModeWindowManagerTest() {}
  43
  44   // Creates a window which has a fixed size.
  45   aura::Window* CreateFixedSizeNonMaximizableWindow(ui::wm::WindowType type,
  46                                                     const gfx::Rect& bounds) {
  47     return CreateWindowInWatchedContainer(
  48         type, bounds, gfx::Size(), false, false);
  49   }
  50
  51   // Creates a window which can not be maximized, but resized. |max_size|
  52   // denotes the maximal possible size, if the size is empty, the window has no
  53   // upper limit. Note: This function will only work with a single root window.
  54   aura::Window* CreateNonMaximizableWindow(ui::wm::WindowType type,
  55                                            const gfx::Rect& bounds,
  56                                            const gfx::Size& max_size) {
  57     return CreateWindowInWatchedContainer(type, bounds, max_size, false, true);
  58   }
  59
  60   // Creates a maximizable and resizable window.
  61   aura::Window* CreateWindow(ui::wm::WindowType type,
  62                              const gfx::Rect bounds) {
  63     return CreateWindowInWatchedContainer(
  64         type, bounds, gfx::Size(), true, true);
  65   }
  66
  67   // Creates a window which also has a widget.
  68   aura::Window* CreateWindowWithWidget(const gfx::Rect& bounds) {
  69     views::Widget* widget = new views::Widget();
  70     views::Widget::InitParams params;
  71     params.context = CurrentContext();
  72     // Note: The widget will get deleted with the window.
  73     widget->Init(params);
  74     widget->Show();
  75     aura::Window* window = widget->GetNativeWindow();
  76     window->SetBounds(bounds);
  77     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
  78
  79     return window;
  80   }
  81
  82   // Create the Maximized mode window manager.
  83   ash::MaximizeModeWindowManager* CreateMaximizeModeWindowManager() {
  84     EXPECT_FALSE(maximize_mode_window_manager());
  85     Shell::GetInstance()->maximize_mode_controller()->
  86         EnableMaximizeModeWindowManager(true);
  87     return maximize_mode_window_manager();
  88   }
  89
  90   // Destroy the maximized mode window manager.
  91   void DestroyMaximizeModeWindowManager() {
  92     Shell::GetInstance()->maximize_mode_controller()->
  93         EnableMaximizeModeWindowManager(false);
  94     EXPECT_FALSE(maximize_mode_window_manager());
  95   }
  96
  97   // Get the maximze window manager.
  98   ash::MaximizeModeWindowManager* maximize_mode_window_manager() {
  99     return Shell::GetInstance()->maximize_mode_controller()->
 100         maximize_mode_window_manager_.get();
 101   }
 102
 103   // Resize our desktop.
 104   void ResizeDesktop(int width_delta) {
 105     gfx::Size size = Shell::GetScreen()->GetDisplayNearestWindow(
 106         Shell::GetPrimaryRootWindow()).size();
 107     size.Enlarge(0, width_delta);
 108     UpdateDisplay(size.ToString());
 109   }
 110
 111  private:
 112   // Create a window in one of the containers which are watched by the
 113   // MaximizeModeWindowManager. Note that this only works with one root window.
 114   // If |can_maximize| is not set, |max_size| is the upper limiting size for
 115   // the window, whereas an empty size means that there is no limit.
 116   aura::Window* CreateWindowInWatchedContainer(ui::wm::WindowType type,
 117                                                const gfx::Rect& bounds,
 118                                                const gfx::Size& max_size,
 119                                                bool can_maximize,
 120                                                bool can_resize) {
 121     aura::test::TestWindowDelegate* delegate = NULL;
 122     if (!can_maximize) {
 123       delegate = aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate();
 124       delegate->set_window_component(HTCAPTION);
 125       if (!max_size.IsEmpty())
 126         delegate->set_maximum_size(max_size);
 127     }
 128     aura::Window* window = aura::test::CreateTestWindowWithDelegateAndType(
 129         delegate, type, 0, bounds, NULL);
 130     window->SetProperty(aura::client::kCanMaximizeKey, can_maximize);
 131     if (!can_resize)
 132       window->SetProperty(aura::client::kCanResizeKey, false);
 133     aura::Window* container = Shell::GetContainer(
 134         Shell::GetPrimaryRootWindow(),
 135         kSwitchableWindowContainerIds[0]);
 136     container->AddChild(window);
 137     return window;
 138   }
 139
 140   DISALLOW_COPY_AND_ASSIGN(MaximizeModeWindowManagerTest);
 141 };
 142
 143 // Test that creating the object and destroying it without any windows should
 144 // not cause any problems.
 145 TEST_F(MaximizeModeWindowManagerTest, SimpleStart) {
 146   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 147   ASSERT_TRUE(manager);
 148   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 149   DestroyMaximizeModeWindowManager();
 150 }
 151
 152 // Test that existing windows will handled properly when going into maximized
 153 // mode.
 154 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindows) {
 155   // Bounds for windows we know can be controlled.
 156   gfx::Rect rect1(10, 10, 200, 50);
 157   gfx::Rect rect2(10, 60, 200, 50);
 158   gfx::Rect rect3(20, 140, 100, 100);
 159   // Bounds for anything else.
 160   gfx::Rect rect(80, 90, 100, 110);
 161   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
 162   scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 163   scoped_ptr<aura::Window> w3(
 164       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3));
 165   scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
 166   scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
 167   scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
 168   scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
 169   scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
 170   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
 171   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
 172   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 173   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
 174   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
 175   EXPECT_EQ(rect3.ToString(), w3->bounds().ToString());
 176
 177   // Create the manager and make sure that all qualifying windows were detected
 178   // and changed.
 179   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 180   ASSERT_TRUE(manager);
 181   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 182   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
 183   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
 184   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 185   EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString());
 186   EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString());
 187
 188   // All other windows should not have been touched.
 189   EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized());
 190   EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized());
 191   EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized());
 192   EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized());
 193   EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized());
 194   EXPECT_EQ(rect.ToString(), w4->bounds().ToString());
 195   EXPECT_EQ(rect.ToString(), w5->bounds().ToString());
 196   EXPECT_EQ(rect.ToString(), w6->bounds().ToString());
 197   EXPECT_EQ(rect.ToString(), w7->bounds().ToString());
 198   EXPECT_EQ(rect.ToString(), w8->bounds().ToString());
 199
 200   // Destroy the manager again and check that the windows return to their
 201   // previous state.
 202   DestroyMaximizeModeWindowManager();
 203   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
 204   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
 205   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 206   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
 207   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
 208   EXPECT_EQ(rect3.ToString(), w3->bounds().ToString());
 209   EXPECT_EQ(rect.ToString(), w4->bounds().ToString());
 210   EXPECT_EQ(rect.ToString(), w5->bounds().ToString());
 211   EXPECT_EQ(rect.ToString(), w6->bounds().ToString());
 212   EXPECT_EQ(rect.ToString(), w7->bounds().ToString());
 213   EXPECT_EQ(rect.ToString(), w8->bounds().ToString());
 214 }
 215
 216 // Test that non-maximizable windows get properly handled when going into
 217 // maximized mode.
 218 TEST_F(MaximizeModeWindowManagerTest,
 219        PreCreateNonMaximizableButResizableWindows) {
 220   // The window bounds.
 221   gfx::Rect rect(10, 10, 200, 50);
 222   gfx::Size max_size(300, 200);
 223   gfx::Size empty_size;
 224   scoped_ptr<aura::Window> unlimited_window(
 225       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
 226   scoped_ptr<aura::Window> limited_window(
 227       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
 228   scoped_ptr<aura::Window> fixed_window(
 229       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 230   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
 231   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
 232   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
 233   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
 234   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
 235   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 236
 237   gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
 238       unlimited_window.get()).size();
 239
 240   // Create the manager and make sure that all qualifying windows were detected
 241   // and changed.
 242   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 243   ASSERT_TRUE(manager);
 244   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 245   // The unlimited window should have the size of the workspace / parent window.
 246   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
 247   EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString());
 248   EXPECT_EQ(workspace_size.ToString(),
 249             unlimited_window->bounds().size().ToString());
 250   // The limited window should have the size of the upper possible bounds.
 251   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
 252   EXPECT_NE(rect.origin().ToString(),
 253             limited_window->bounds().origin().ToString());
 254   EXPECT_EQ(max_size.ToString(),
 255             limited_window->bounds().size().ToString());
 256   // The fixed size window should have the size of the original window.
 257   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
 258   EXPECT_NE(rect.origin().ToString(),
 259             fixed_window->bounds().origin().ToString());
 260   EXPECT_EQ(rect.size().ToString(),
 261             fixed_window->bounds().size().ToString());
 262
 263   // Destroy the manager again and check that the windows return to their
 264   // previous state.
 265   DestroyMaximizeModeWindowManager();
 266   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
 267   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
 268   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
 269   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
 270   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
 271   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 272 }
 273
 274 // Test that creating windows while a maximizer exists picks them properly up.
 275 TEST_F(MaximizeModeWindowManagerTest, CreateWindows) {
 276   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 277   ASSERT_TRUE(manager);
 278   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 279
 280   // Create the windows and see that the window manager picks them up.
 281   // Rects for windows we know can be controlled.
 282   gfx::Rect rect1(10, 10, 200, 50);
 283   gfx::Rect rect2(10, 60, 200, 50);
 284   gfx::Rect rect3(20, 140, 100, 100);
 285   // One rect for anything else.
 286   gfx::Rect rect(80, 90, 100, 110);
 287   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
 288   scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 289   scoped_ptr<aura::Window> w3(
 290       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3));
 291   scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
 292   scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
 293   scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
 294   scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
 295   scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
 296   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
 297   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
 298   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 299   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 300
 301   // Make sure that the position of the unresizable window is in the middle of
 302   // the screen.
 303   gfx::Size work_area_size =
 304       ScreenUtil::GetDisplayWorkAreaBoundsInParent(w3.get()).size();
 305   gfx::Point center =
 306       gfx::Point((work_area_size.width() - rect3.size().width()) / 2,
 307                  (work_area_size.height() - rect3.size().height()) / 2);
 308   gfx::Rect centered_window_bounds = gfx::Rect(center, rect3.size());
 309   EXPECT_EQ(centered_window_bounds.ToString(), w3->bounds().ToString());
 310
 311   // All other windows should not have been touched.
 312   EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized());
 313   EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized());
 314   EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized());
 315   EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized());
 316   EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized());
 317   EXPECT_EQ(rect.ToString(), w4->bounds().ToString());
 318   EXPECT_EQ(rect.ToString(), w5->bounds().ToString());
 319   EXPECT_EQ(rect.ToString(), w6->bounds().ToString());
 320   EXPECT_EQ(rect.ToString(), w7->bounds().ToString());
 321   EXPECT_EQ(rect.ToString(), w8->bounds().ToString());
 322
 323   // After the maximize mode was disabled all windows fall back into the mode
 324   // they were created for.
 325   DestroyMaximizeModeWindowManager();
 326   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
 327   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
 328   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 329   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
 330   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
 331   EXPECT_EQ(rect3.ToString(), w3->bounds().ToString());
 332   EXPECT_EQ(rect.ToString(), w4->bounds().ToString());
 333   EXPECT_EQ(rect.ToString(), w5->bounds().ToString());
 334   EXPECT_EQ(rect.ToString(), w6->bounds().ToString());
 335   EXPECT_EQ(rect.ToString(), w7->bounds().ToString());
 336   EXPECT_EQ(rect.ToString(), w8->bounds().ToString());
 337 }
 338
 339 // Test that a window which got created while the maximize mode window manager
 340 // is active gets restored to a usable (non tiny) size upon switching back.
 341 TEST_F(MaximizeModeWindowManagerTest,
 342        CreateWindowInMaximizedModeRestoresToUsefulSize) {
 343   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 344   ASSERT_TRUE(manager);
 345   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 346
 347   // We pass in an empty rectangle to simulate a window creation with no
 348   // particular size.
 349   gfx::Rect empty_rect(0, 0, 0, 0);
 350   scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
 351                                                empty_rect));
 352   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
 353   EXPECT_NE(empty_rect.ToString(), window->bounds().ToString());
 354   gfx::Rect maximized_size = window->bounds();
 355
 356   // Destroy the maximize mode and check that the resulting size of the window
 357   // is remaining as it is (but not maximized).
 358   DestroyMaximizeModeWindowManager();
 359
 360   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
 361   EXPECT_EQ(maximized_size.ToString(), window->bounds().ToString());
 362 }
 363
 364 // Test that non-maximizable windows get properly handled when created in
 365 // maximized mode.
 366 TEST_F(MaximizeModeWindowManagerTest,
 367        CreateNonMaximizableButResizableWindows) {
 368   // Create the manager and make sure that all qualifying windows were detected
 369   // and changed.
 370   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 371   ASSERT_TRUE(manager);
 372
 373   gfx::Rect rect(10, 10, 200, 50);
 374   gfx::Size max_size(300, 200);
 375   gfx::Size empty_size;
 376   scoped_ptr<aura::Window> unlimited_window(
 377       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
 378   scoped_ptr<aura::Window> limited_window(
 379       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
 380   scoped_ptr<aura::Window> fixed_window(
 381       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 382
 383   gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
 384       unlimited_window.get()).size();
 385
 386   // All windows should be sized now as big as possible and be centered.
 387   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 388   // The unlimited window should have the size of the workspace / parent window.
 389   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
 390   EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString());
 391   EXPECT_EQ(workspace_size.ToString(),
 392             unlimited_window->bounds().size().ToString());
 393   // The limited window should have the size of the upper possible bounds.
 394   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
 395   EXPECT_NE(rect.origin().ToString(),
 396             limited_window->bounds().origin().ToString());
 397   EXPECT_EQ(max_size.ToString(),
 398             limited_window->bounds().size().ToString());
 399   // The fixed size window should have the size of the original window.
 400   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
 401   EXPECT_NE(rect.origin().ToString(),
 402             fixed_window->bounds().origin().ToString());
 403   EXPECT_EQ(rect.size().ToString(),
 404             fixed_window->bounds().size().ToString());
 405
 406   // Destroy the manager again and check that the windows return to their
 407   // creation state.
 408   DestroyMaximizeModeWindowManager();
 409
 410   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
 411   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
 412   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
 413   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
 414   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
 415   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 416 }
 417
 418 // Create a string which consists of the bounds and the state for comparison.
 419 std::string GetPlacementString(const gfx::Rect& bounds,
 420                                ui::WindowShowState state) {
 421   return bounds.ToString() + base::StringPrintf(" %d", state);
 422 }
 423
 424 // Retrieves the window's restore state override - if any - and returns it as a
 425 // string.
 426 std::string GetPlacementOverride(aura::Window* window) {
 427   gfx::Rect* bounds = window->GetProperty(ash::kRestoreBoundsOverrideKey);
 428   if (bounds) {
 429     gfx::Rect restore_bounds = *bounds;
 430     ui::WindowShowState restore_state =
 431         window->GetProperty(ash::kRestoreShowStateOverrideKey);
 432     return GetPlacementString(restore_bounds, restore_state);
 433   }
 434   return std::string();
 435 }
 436
 437 // Test that the restore state will be kept at its original value for
 438 // session restauration purposes.
 439 TEST_F(MaximizeModeWindowManagerTest, TestRestoreIntegrety) {
 440   gfx::Rect bounds(10, 10, 200, 50);
 441   gfx::Size empty_size;
 442   gfx::Rect empty_bounds;
 443   scoped_ptr<aura::Window> normal_window(
 444       CreateWindowWithWidget(bounds));
 445   scoped_ptr<aura::Window> maximized_window(
 446       CreateWindowWithWidget(bounds));
 447   wm::GetWindowState(maximized_window.get())->Maximize();
 448
 449   EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get()));
 450   EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get()));
 451
 452   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 453   ASSERT_TRUE(manager);
 454
 455   // With the maximization the override states should be returned in its
 456   // pre-maximized state.
 457   EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_NORMAL),
 458             GetPlacementOverride(normal_window.get()));
 459   EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED),
 460             GetPlacementOverride(maximized_window.get()));
 461
 462   // Changing a window's state now does not change the returned result.
 463   wm::GetWindowState(maximized_window.get())->Minimize();
 464   EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED),
 465             GetPlacementOverride(maximized_window.get()));
 466
 467   // Destroy the manager again and check that the overrides get reset.
 468   DestroyMaximizeModeWindowManager();
 469   EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get()));
 470   EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get()));
 471
 472   // Changing a window's state now does not bring the overrides back.
 473   wm::GetWindowState(maximized_window.get())->Restore();
 474   gfx::Rect new_bounds(10, 10, 200, 50);
 475   maximized_window->SetBounds(new_bounds);
 476
 477   EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get()));
 478 }
 479
 480 // Test that windows which got created before the maximizer was created can be
 481 // destroyed while the maximizer is still running.
 482 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindowsDeleteWhileActive) {
 483   ash::MaximizeModeWindowManager* manager = NULL;
 484   {
 485     // Bounds for windows we know can be controlled.
 486     gfx::Rect rect1(10, 10, 200, 50);
 487     gfx::Rect rect2(10, 60, 200, 50);
 488     gfx::Rect rect3(20, 140, 100, 100);
 489     // Bounds for anything else.
 490     gfx::Rect rect(80, 90, 100, 110);
 491     scoped_ptr<aura::Window> w1(
 492         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
 493     scoped_ptr<aura::Window> w2(
 494         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 495     scoped_ptr<aura::Window> w3(
 496         CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3));
 497
 498     // Create the manager and make sure that all qualifying windows were
 499     // detected and changed.
 500     manager = CreateMaximizeModeWindowManager();
 501     ASSERT_TRUE(manager);
 502     EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 503   }
 504   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 505   DestroyMaximizeModeWindowManager();
 506 }
 507
 508 // Test that windows which got created while the maximizer was running can get
 509 // destroyed before the maximizer gets destroyed.
 510 TEST_F(MaximizeModeWindowManagerTest, CreateWindowsAndDeleteWhileActive) {
 511   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 512   ASSERT_TRUE(manager);
 513   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 514   {
 515     // Bounds for windows we know can be controlled.
 516     gfx::Rect rect1(10, 10, 200, 50);
 517     gfx::Rect rect2(10, 60, 200, 50);
 518     gfx::Rect rect3(20, 140, 100, 100);
 519     scoped_ptr<aura::Window> w1(
 520         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
 521     scoped_ptr<aura::Window> w2(
 522         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 60, 200, 50)));
 523     scoped_ptr<aura::Window> w3(
 524         CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL,
 525                                             gfx::Rect(20, 140, 100, 100)));
 526     // Check that the windows got automatically maximized as well.
 527     EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 528     EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
 529     EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
 530     EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 531   }
 532   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 533   DestroyMaximizeModeWindowManager();
 534 }
 535
 536 // Test that windows which were maximized stay maximized.
 537 TEST_F(MaximizeModeWindowManagerTest, MaximizedShouldRemainMaximized) {
 538   // Bounds for windows we know can be controlled.
 539   gfx::Rect rect(10, 10, 200, 50);
 540   scoped_ptr<aura::Window> window(
 541       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 542   wm::GetWindowState(window.get())->Maximize();
 543
 544   // Create the manager and make sure that the window gets detected.
 545   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 546   ASSERT_TRUE(manager);
 547   EXPECT_EQ(1, manager->GetNumberOfManagedWindows());
 548   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
 549
 550   // Destroy the manager again and check that the window will remain maximized.
 551   DestroyMaximizeModeWindowManager();
 552   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
 553   wm::GetWindowState(window.get())->Restore();
 554   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 555 }
 556
 557 // Test that minimized windows do neither get maximized nor restored upon
 558 // entering maximized mode and get restored to their previous state after
 559 // leaving.
 560 TEST_F(MaximizeModeWindowManagerTest, MinimizedWindowBehavior) {
 561   // Bounds for windows we know can be controlled.
 562   gfx::Rect rect(10, 10, 200, 50);
 563   scoped_ptr<aura::Window> initially_minimized_window(
 564       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 565   scoped_ptr<aura::Window> initially_normal_window(
 566       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 567   scoped_ptr<aura::Window> initially_maximized_window(
 568       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 569   wm::GetWindowState(initially_minimized_window.get())->Minimize();
 570   wm::GetWindowState(initially_maximized_window.get())->Maximize();
 571
 572   // Create the manager and make sure that the window gets detected.
 573   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 574   ASSERT_TRUE(manager);
 575   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
 576   EXPECT_TRUE(wm::GetWindowState(
 577       initially_minimized_window.get())->IsMinimized());
 578   EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMaximized());
 579   EXPECT_TRUE(wm::GetWindowState(
 580       initially_maximized_window.get())->IsMaximized());
 581   // Now minimize the second window to check that upon leaving the window
 582   // will get restored to its minimized state.
 583   wm::GetWindowState(initially_normal_window.get())->Minimize();
 584   wm::GetWindowState(initially_maximized_window.get())->Minimize();
 585   EXPECT_TRUE(wm::GetWindowState(
 586       initially_minimized_window.get())->IsMinimized());
 587   EXPECT_TRUE(wm::GetWindowState(
 588       initially_normal_window.get())->IsMinimized());
 589   EXPECT_TRUE(wm::GetWindowState(
 590       initially_maximized_window.get())->IsMinimized());
 591
 592   // Destroy the manager again and check that the window will get minimized.
 593   DestroyMaximizeModeWindowManager();
 594   EXPECT_TRUE(wm::GetWindowState(
 595       initially_minimized_window.get())->IsMinimized());
 596   EXPECT_FALSE(wm::GetWindowState(
 597                    initially_normal_window.get())->IsMinimized());
 598   EXPECT_TRUE(wm::GetWindowState(
 599       initially_maximized_window.get())->IsMaximized());
 600 }
 601
 602 // Check that resizing the desktop does reposition unmaximizable, unresizable &
 603 // managed windows.
 604 TEST_F(MaximizeModeWindowManagerTest, DesktopSizeChangeMovesUnmaximizable) {
 605   UpdateDisplay("400x400");
 606   // This window will move because it does not fit the new bounds.
 607   gfx::Rect rect(20, 300, 100, 100);
 608   scoped_ptr<aura::Window> window1(
 609       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 610   EXPECT_EQ(rect.ToString(), window1->bounds().ToString());
 611
 612   // This window will not move because it does fit the new bounds.
 613   gfx::Rect rect2(20, 140, 100, 100);
 614   scoped_ptr<aura::Window> window2(
 615       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 616
 617   // Turning on the manager will reposition (but not resize) the window.
 618   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 619   ASSERT_TRUE(manager);
 620   EXPECT_EQ(2, manager->GetNumberOfManagedWindows());
 621   gfx::Rect moved_bounds(window1->bounds());
 622   EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString());
 623   EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString());
 624
 625   // Simulating a desktop resize should move the window again.
 626   UpdateDisplay("300x300");
 627   gfx::Rect new_moved_bounds(window1->bounds());
 628   EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString());
 629   EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString());
 630   EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString());
 631
 632   // Turning off the mode should not restore to the initial coordinates since
 633   // the new resolution is smaller and the window was on the edge.
 634   DestroyMaximizeModeWindowManager();
 635   EXPECT_NE(rect.ToString(), window1->bounds().ToString());
 636   EXPECT_EQ(rect2.ToString(), window2->bounds().ToString());
 637 }
 638
 639 // Check that windows return to original location if desktop size changes to
 640 // something else and back while in maximize mode.
 641 TEST_F(MaximizeModeWindowManagerTest, SizeChangeReturnWindowToOriginalPos) {
 642   gfx::Rect rect(20, 140, 100, 100);
 643   scoped_ptr<aura::Window> window(
 644       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 645
 646   // Turning on the manager will reposition (but not resize) the window.
 647   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 648   ASSERT_TRUE(manager);
 649   EXPECT_EQ(1, manager->GetNumberOfManagedWindows());
 650   gfx::Rect moved_bounds(window->bounds());
 651   EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString());
 652   EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString());
 653
 654   // Simulating a desktop resize should move the window again.
 655   ResizeDesktop(-10);
 656   gfx::Rect new_moved_bounds(window->bounds());
 657   EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString());
 658   EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString());
 659   EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString());
 660
 661   // Then resize back to the original desktop size which should move windows
 662   // to their original location after leaving the maximize mode.
 663   ResizeDesktop(10);
 664   DestroyMaximizeModeWindowManager();
 665   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 666 }
 667
 668 // Check that enabling of the maximize mode does not have an impact on the MRU
 669 // order of windows.
 670 TEST_F(MaximizeModeWindowManagerTest, ModeChangeKeepsMRUOrder) {
 671   gfx::Rect rect(20, 140, 100, 100);
 672   scoped_ptr<aura::Window> w1(
 673       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 674   scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 675   scoped_ptr<aura::Window> w3(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 676   scoped_ptr<aura::Window> w4(
 677       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 678   scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 679
 680   // The windows should be in the reverse order of creation in the MRU list.
 681   {
 682     MruWindowTracker::WindowList windows =
 683         MruWindowTracker::BuildWindowList(false);
 684     EXPECT_EQ(w1.get(), windows[4]);
 685     EXPECT_EQ(w2.get(), windows[3]);
 686     EXPECT_EQ(w3.get(), windows[2]);
 687     EXPECT_EQ(w4.get(), windows[1]);
 688     EXPECT_EQ(w5.get(), windows[0]);
 689   }
 690
 691   // Activating the window manager should keep the order.
 692   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
 693   ASSERT_TRUE(manager);
 694   EXPECT_EQ(5, manager->GetNumberOfManagedWindows());
 695   {
 696     MruWindowTracker::WindowList windows =
 697         MruWindowTracker::BuildWindowList(false);
 698     // We do not test maximization here again since that was done already.
 699     EXPECT_EQ(w1.get(), windows[4]);
 700     EXPECT_EQ(w2.get(), windows[3]);
 701     EXPECT_EQ(w3.get(), windows[2]);
 702     EXPECT_EQ(w4.get(), windows[1]);
 703     EXPECT_EQ(w5.get(), windows[0]);
 704   }
 705
 706   // Destroying should still keep the order.
 707   DestroyMaximizeModeWindowManager();
 708   {
 709     MruWindowTracker::WindowList windows =
 710         MruWindowTracker::BuildWindowList(false);
 711     // We do not test maximization here again since that was done already.
 712     EXPECT_EQ(w1.get(), windows[4]);
 713     EXPECT_EQ(w2.get(), windows[3]);
 714     EXPECT_EQ(w3.get(), windows[2]);
 715     EXPECT_EQ(w4.get(), windows[1]);
 716     EXPECT_EQ(w5.get(), windows[0]);
 717   }
 718 }
 719
 720 // Check that a restore state change does always restore to maximized.
 721 TEST_F(MaximizeModeWindowManagerTest, IgnoreRestoreStateChages) {
 722   gfx::Rect rect(20, 140, 100, 100);
 723   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 724   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 725   CreateMaximizeModeWindowManager();
 726   EXPECT_TRUE(window_state->IsMaximized());
 727   window_state->Minimize();
 728   EXPECT_TRUE(window_state->IsMinimized());
 729   window_state->Restore();
 730   EXPECT_TRUE(window_state->IsMaximized());
 731   window_state->Restore();
 732   EXPECT_TRUE(window_state->IsMaximized());
 733   DestroyMaximizeModeWindowManager();
 734 }
 735
 736 // Check that minimize and restore do the right thing.
 737 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) {
 738   gfx::Rect rect(10, 10, 100, 100);
 739   scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
 740                                   rect));
 741   wm::WindowState* window_state = wm::GetWindowState(window.get());
 742   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 743   ash::Shell::GetInstance()->maximize_mode_controller()->
 744       EnableMaximizeModeWindowManager(true);
 745   EXPECT_TRUE(window_state->IsMaximized());
 746   EXPECT_FALSE(window_state->IsMinimized());
 747   EXPECT_TRUE(window->IsVisible());
 748
 749   window_state->Minimize();
 750   EXPECT_FALSE(window_state->IsMaximized());
 751   EXPECT_TRUE(window_state->IsMinimized());
 752   EXPECT_FALSE(window->IsVisible());
 753
 754   window_state->Maximize();
 755   EXPECT_TRUE(window_state->IsMaximized());
 756   EXPECT_FALSE(window_state->IsMinimized());
 757   EXPECT_TRUE(window->IsVisible());
 758
 759   ash::Shell::GetInstance()->maximize_mode_controller()->
 760       EnableMaximizeModeWindowManager(false);
 761   EXPECT_FALSE(window_state->IsMaximized());
 762   EXPECT_FALSE(window_state->IsMinimized());
 763   EXPECT_TRUE(window->IsVisible());
 764 }
 765
 766 // Check that a full screen window is staying full screen in maximize mode,
 767 // and that it returns to full screen thereafter (if left).
 768 TEST_F(MaximizeModeWindowManagerTest, KeepFullScreenModeOn) {
 769   gfx::Rect rect(20, 140, 100, 100);
 770   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 771   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 772
 773   ShelfLayoutManager* shelf =
 774       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 775
 776   // Allow the shelf to hide.
 777   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 778   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 779
 780   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 781   window_state->OnWMEvent(&event);
 782
 783   // With full screen, the shelf should get hidden.
 784   EXPECT_TRUE(window_state->IsFullscreen());
 785   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 786
 787   CreateMaximizeModeWindowManager();
 788
 789   // The Full screen mode should continue to be on.
 790   EXPECT_TRUE(window_state->IsFullscreen());
 791   EXPECT_FALSE(window_state->IsMaximized());
 792   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 793
 794   // With leaving the fullscreen mode, the maximized mode should return and the
 795   // shelf should become visible.
 796   window_state->OnWMEvent(&event);
 797   EXPECT_FALSE(window_state->IsFullscreen());
 798   EXPECT_TRUE(window_state->IsMaximized());
 799   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 800
 801   // Ending the maximize mode should return to full screen and the shelf should
 802   // be hidden again.
 803   DestroyMaximizeModeWindowManager();
 804   EXPECT_TRUE(window_state->IsFullscreen());
 805   EXPECT_FALSE(window_state->IsMaximized());
 806   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 807 }
 808
 809 // Check that full screen mode can be turned on in maximized mode and remains
 810 // upon coming back.
 811 TEST_F(MaximizeModeWindowManagerTest, AllowFullScreenMode) {
 812   gfx::Rect rect(20, 140, 100, 100);
 813   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 814   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 815
 816   ShelfLayoutManager* shelf =
 817       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 818
 819   // Allow the shelf to hide.
 820   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 821
 822   EXPECT_FALSE(window_state->IsFullscreen());
 823   EXPECT_FALSE(window_state->IsMaximized());
 824   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 825
 826   CreateMaximizeModeWindowManager();
 827
 828   // Fullscreen mode should still be off and the shelf should be visible.
 829   EXPECT_FALSE(window_state->IsFullscreen());
 830   EXPECT_TRUE(window_state->IsMaximized());
 831   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 832
 833   // After going into fullscreen mode, the shelf should be hidden.
 834   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 835   window_state->OnWMEvent(&event);
 836   EXPECT_TRUE(window_state->IsFullscreen());
 837   EXPECT_FALSE(window_state->IsMaximized());
 838   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 839
 840   // With the destruction of the manager we should remain in full screen.
 841   DestroyMaximizeModeWindowManager();
 842   EXPECT_TRUE(window_state->IsFullscreen());
 843   EXPECT_FALSE(window_state->IsMaximized());
 844   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 845 }
 846
 847 // Check that the full screen mode will stay active when the maximize mode is
 848 // ended.
 849 TEST_F(MaximizeModeWindowManagerTest,
 850        FullScreenModeRemainsWhenCreatedInMaximizedMode) {
 851   CreateMaximizeModeWindowManager();
 852
 853   gfx::Rect rect(20, 140, 100, 100);
 854   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 855   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 856   wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 857   window_state->OnWMEvent(&event_full_screen);
 858   EXPECT_TRUE(window_state->IsFullscreen());
 859
 860   // After the maximize mode manager is ended, full screen will remain.
 861   DestroyMaximizeModeWindowManager();
 862   EXPECT_TRUE(window_state->IsFullscreen());
 863 }
 864
 865 // Check that the full screen mode will stay active throughout a maximzied mode
 866 // session.
 867 TEST_F(MaximizeModeWindowManagerTest,
 868        FullScreenModeRemainsThroughMaximizeModeSwitch) {
 869   gfx::Rect rect(20, 140, 100, 100);
 870   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 871   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 872   wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 873   window_state->OnWMEvent(&event_full_screen);
 874   EXPECT_TRUE(window_state->IsFullscreen());
 875
 876   CreateMaximizeModeWindowManager();
 877   EXPECT_TRUE(window_state->IsFullscreen());
 878   DestroyMaximizeModeWindowManager();
 879   EXPECT_TRUE(window_state->IsFullscreen());
 880 }
 881
 882 // Check that an empty window does not get restored to a tiny size.
 883 TEST_F(MaximizeModeWindowManagerTest,
 884        CreateAndMaximizeInMaximizeModeShouldRetoreToGoodSizeGoingToDefault) {
 885   CreateMaximizeModeWindowManager();
 886   gfx::Rect rect;
 887   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 888   w1->Show();
 889   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 890   EXPECT_TRUE(window_state->IsMaximized());
 891
 892   // There is a calling order in which the restore bounds can get set to an
 893   // empty rectangle. We simulate this here.
 894   window_state->SetRestoreBoundsInScreen(rect);
 895   EXPECT_TRUE(window_state->GetRestoreBoundsInScreen().IsEmpty());
 896
 897   // Setting the window to a new size will physically not change the window,
 898   // but the restore size should get updated so that a restore later on will
 899   // return to this size.
 900   gfx::Rect requested_bounds(10, 20, 50, 70);
 901   w1->SetBounds(requested_bounds);
 902   EXPECT_TRUE(window_state->IsMaximized());
 903   EXPECT_EQ(requested_bounds.ToString(),
 904             window_state->GetRestoreBoundsInScreen().ToString());
 905
 906   DestroyMaximizeModeWindowManager();
 907
 908   EXPECT_FALSE(window_state->IsMaximized());
 909   EXPECT_EQ(w1->bounds().ToString(), requested_bounds.ToString());
 910 }
 911
 912 // Check that snapping operations get ignored.
 913 TEST_F(MaximizeModeWindowManagerTest, SnapModeTests) {
 914   gfx::Rect rect(20, 140, 100, 100);
 915   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 916   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 917   wm::WMEvent event_left(wm::WM_EVENT_SNAP_LEFT);
 918   wm::WMEvent event_right(wm::WM_EVENT_SNAP_RIGHT);
 919   window_state->OnWMEvent(&event_left);
 920   EXPECT_TRUE(window_state->IsSnapped());
 921
 922   CreateMaximizeModeWindowManager();
 923
 924   // Fullscreen mode should now be off and it should not come back while in
 925   // maximize mode.
 926   EXPECT_FALSE(window_state->IsSnapped());
 927   EXPECT_TRUE(window_state->IsMaximized());
 928   window_state->OnWMEvent(&event_left);
 929   EXPECT_FALSE(window_state->IsSnapped());
 930   EXPECT_TRUE(window_state->IsMaximized());
 931   window_state->OnWMEvent(&event_right);
 932   EXPECT_FALSE(window_state->IsSnapped());
 933   EXPECT_TRUE(window_state->IsMaximized());
 934
 935   DestroyMaximizeModeWindowManager();
 936   EXPECT_TRUE(window_state->IsSnapped());
 937 }
 938
 939 // Check that non maximizable windows cannot be dragged by the user.
 940 TEST_F(MaximizeModeWindowManagerTest, TryToDesktopSizeDragUnmaximizable) {
 941   gfx::Rect rect(10, 10, 100, 100);
 942   scoped_ptr<aura::Window> window(
 943       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 944   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 945
 946   // 1. Move the mouse over the caption and check that dragging the window does
 947   // change the location.
 948   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 949   generator.MoveMouseTo(gfx::Point(rect.x() + 2, rect.y() + 2));
 950   generator.PressLeftButton();
 951   generator.MoveMouseBy(10, 5);
 952   RunAllPendingInMessageLoop();
 953   generator.ReleaseLeftButton();
 954   gfx::Point first_dragged_origin = window->bounds().origin();
 955   EXPECT_EQ(rect.x() + 10, first_dragged_origin.x());
 956   EXPECT_EQ(rect.y() + 5, first_dragged_origin.y());
 957
 958   // 2. Check that turning on the manager will stop allowing the window from
 959   // dragging.
 960   ash::Shell::GetInstance()->maximize_mode_controller()->
 961       EnableMaximizeModeWindowManager(true);
 962   gfx::Rect center_bounds(window->bounds());
 963   EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString());
 964   generator.MoveMouseTo(gfx::Point(center_bounds.x() + 1,
 965                                    center_bounds.y() + 1));
 966   generator.PressLeftButton();
 967   generator.MoveMouseBy(10, 5);
 968   RunAllPendingInMessageLoop();
 969   generator.ReleaseLeftButton();
 970   EXPECT_EQ(center_bounds.x(), window->bounds().x());
 971   EXPECT_EQ(center_bounds.y(), window->bounds().y());
 972   ash::Shell::GetInstance()->maximize_mode_controller()->
 973       EnableMaximizeModeWindowManager(false);
 974
 975   // 3. Releasing the mazimize manager again will restore the window to its
 976   // previous bounds and
 977   generator.MoveMouseTo(gfx::Point(first_dragged_origin.x() + 1,
 978                                    first_dragged_origin.y() + 1));
 979   generator.PressLeftButton();
 980   generator.MoveMouseBy(10, 5);
 981   RunAllPendingInMessageLoop();
 982   generator.ReleaseLeftButton();
 983   EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x());
 984   EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y());
 985 }
 986
 987 // Test that overview is exited before entering / exiting maximize mode so that
 988 // the window changes made by MaximizeModeWindowManager do not conflict with
 989 // those made in WindowOverview.
 990 TEST_F(MaximizeModeWindowManagerTest, ExitsOverview) {
 991   // Bounds for windows we know can be controlled.
 992   gfx::Rect rect1(10, 10, 200, 50);
 993   gfx::Rect rect2(10, 60, 200, 50);
 994   scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
 995   scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 996
 997   WindowSelectorController* window_selector_controller =
 998       Shell::GetInstance()->window_selector_controller();
 999   window_selector_controller->ToggleOverview();
1000   ASSERT_TRUE(window_selector_controller->IsSelecting());
1001   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
1002   ASSERT_TRUE(manager);
1003   EXPECT_FALSE(window_selector_controller->IsSelecting());
1004
1005   window_selector_controller->ToggleOverview();
1006   ASSERT_TRUE(window_selector_controller->IsSelecting());
1007   // Destroy the manager again and check that the windows return to their
1008   // previous state.
1009   DestroyMaximizeModeWindowManager();
1010   EXPECT_FALSE(window_selector_controller->IsSelecting());
1011 }
1012
1013 // Test that an edge swipe from the top will end full screen mode.
1014 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromTop) {
1015   gfx::Rect rect(10, 10, 200, 50);
1016   scoped_ptr<aura::Window>
1017       background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1018   scoped_ptr<aura::Window>
1019       foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1020   wm::WindowState* background_window_state =
1021       wm::GetWindowState(background_window.get());
1022   wm::WindowState* foreground_window_state =
1023       wm::GetWindowState(foreground_window.get());
1024   wm::ActivateWindow(foreground_window.get());
1025   CreateMaximizeModeWindowManager();
1026
1027   // Fullscreen both windows.
1028   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1029   background_window_state->OnWMEvent(&event);
1030   foreground_window_state->OnWMEvent(&event);
1031   EXPECT_TRUE(background_window_state->IsFullscreen());
1032   EXPECT_TRUE(foreground_window_state->IsFullscreen());
1033   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
1034
1035   // Do an edge swipe top into screen.
1036   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1037   generator.GestureScrollSequence(gfx::Point(50, 0),
1038                                   gfx::Point(50, 100),
1039                                   base::TimeDelta::FromMilliseconds(20),
1040                                   10);
1041
1042   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1043   EXPECT_TRUE(background_window_state->IsFullscreen());
1044
1045   // Do a second edge swipe top into screen.
1046   generator.GestureScrollSequence(gfx::Point(50, 0),
1047                                   gfx::Point(50, 100),
1048                                   base::TimeDelta::FromMilliseconds(20),
1049                                   10);
1050
1051   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1052   EXPECT_TRUE(background_window_state->IsFullscreen());
1053
1054   DestroyMaximizeModeWindowManager();
1055 }
1056
1057 // Test that an edge swipe from the bottom will end full screen mode.
1058 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) {
1059   gfx::Rect rect(10, 10, 200, 50);
1060   scoped_ptr<aura::Window>
1061       background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1062   scoped_ptr<aura::Window>
1063       foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1064   wm::WindowState* background_window_state =
1065       wm::GetWindowState(background_window.get());
1066   wm::WindowState* foreground_window_state =
1067       wm::GetWindowState(foreground_window.get());
1068   wm::ActivateWindow(foreground_window.get());
1069   CreateMaximizeModeWindowManager();
1070
1071   // Fullscreen both windows.
1072   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1073   background_window_state->OnWMEvent(&event);
1074   foreground_window_state->OnWMEvent(&event);
1075   EXPECT_TRUE(background_window_state->IsFullscreen());
1076   EXPECT_TRUE(foreground_window_state->IsFullscreen());
1077   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
1078
1079   // Do an edge swipe bottom into screen.
1080   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1081   int y = Shell::GetPrimaryRootWindow()->bounds().bottom();
1082   generator.GestureScrollSequence(gfx::Point(50, y),
1083                                   gfx::Point(50, y - 100),
1084                                   base::TimeDelta::FromMilliseconds(20),
1085                                   10);
1086
1087   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1088   EXPECT_TRUE(background_window_state->IsFullscreen());
1089
1090   DestroyMaximizeModeWindowManager();
1091 }
1092
1093 // Test that an edge touch press at the top will end full screen mode.
1094 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) {
1095   gfx::Rect rect(10, 10, 200, 50);
1096   scoped_ptr<aura::Window>
1097       background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1098   scoped_ptr<aura::Window>
1099       foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1100   wm::WindowState* background_window_state =
1101       wm::GetWindowState(background_window.get());
1102   wm::WindowState* foreground_window_state =
1103       wm::GetWindowState(foreground_window.get());
1104   wm::ActivateWindow(foreground_window.get());
1105   CreateMaximizeModeWindowManager();
1106
1107   // Fullscreen both windows.
1108   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1109   background_window_state->OnWMEvent(&event);
1110   foreground_window_state->OnWMEvent(&event);
1111   EXPECT_TRUE(background_window_state->IsFullscreen());
1112   EXPECT_TRUE(foreground_window_state->IsFullscreen());
1113   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
1114
1115   // Touch tap on the top edge.
1116   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1117   generator.GestureTapAt(gfx::Point(100, 0));
1118   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1119   EXPECT_TRUE(background_window_state->IsFullscreen());
1120
1121   // Try the same again and see that nothing changes.
1122   generator.GestureTapAt(gfx::Point(100, 0));
1123   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1124   EXPECT_TRUE(background_window_state->IsFullscreen());
1125
1126   DestroyMaximizeModeWindowManager();
1127 }
1128
1129 // Test that an edge touch press at the bottom will end full screen mode.
1130 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtBottom) {
1131   gfx::Rect rect(10, 10, 200, 50);
1132   scoped_ptr<aura::Window>
1133       background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1134   scoped_ptr<aura::Window>
1135       foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
1136   wm::WindowState* background_window_state =
1137       wm::GetWindowState(background_window.get());
1138   wm::WindowState* foreground_window_state =
1139       wm::GetWindowState(foreground_window.get());
1140   wm::ActivateWindow(foreground_window.get());
1141   CreateMaximizeModeWindowManager();
1142
1143   // Fullscreen both windows.
1144   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1145   background_window_state->OnWMEvent(&event);
1146   foreground_window_state->OnWMEvent(&event);
1147   EXPECT_TRUE(background_window_state->IsFullscreen());
1148   EXPECT_TRUE(foreground_window_state->IsFullscreen());
1149   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
1150
1151   // Touch tap on the bottom edge.
1152   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1153   generator.GestureTapAt(
1154       gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1));
1155   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1156   EXPECT_TRUE(background_window_state->IsFullscreen());
1157
1158   // Try the same again and see that nothing changes.
1159   generator.GestureTapAt(
1160       gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1));
1161   EXPECT_FALSE(foreground_window_state->IsFullscreen());
1162   EXPECT_TRUE(background_window_state->IsFullscreen());
1163
1164   DestroyMaximizeModeWindowManager();
1165 }
1166
1167 // Test that an edge swipe from the top on an immersive mode window will not end
1168 // full screen mode.
1169 TEST_F(MaximizeModeWindowManagerTest, NoExitImmersiveModeWithEdgeSwipeFromTop) {
1170   scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
1171                                   gfx::Rect(10, 10, 200, 50)));
1172   wm::WindowState* window_state = wm::GetWindowState(window.get());
1173   wm::ActivateWindow(window.get());
1174   CreateMaximizeModeWindowManager();
1175
1176   // Fullscreen the window.
1177   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1178   window_state->OnWMEvent(&event);
1179   EXPECT_TRUE(window_state->IsFullscreen());
1180   EXPECT_FALSE(window_state->in_immersive_fullscreen());
1181   EXPECT_EQ(window.get(), wm::GetActiveWindow());
1182
1183   window_state->set_in_immersive_fullscreen(true);
1184
1185   // Do an edge swipe top into screen.
1186   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1187   generator.GestureScrollSequence(gfx::Point(50, 0),
1188                                   gfx::Point(50, 100),
1189                                   base::TimeDelta::FromMilliseconds(20),
1190                                   10);
1191
1192   // It should have not exited full screen or immersive mode.
1193   EXPECT_TRUE(window_state->IsFullscreen());
1194   EXPECT_TRUE(window_state->in_immersive_fullscreen());
1195
1196   DestroyMaximizeModeWindowManager();
1197 }
1198
1199 // Test that an edge swipe from the bottom will not end immersive mode.
1200 TEST_F(MaximizeModeWindowManagerTest,
1201        NoExitImmersiveModeWithEdgeSwipeFromBottom) {
1202   scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
1203                                                gfx::Rect(10, 10, 200, 50)));
1204   wm::WindowState* window_state = wm::GetWindowState(window.get());
1205   wm::ActivateWindow(window.get());
1206   CreateMaximizeModeWindowManager();
1207
1208   // Fullscreen the window.
1209   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
1210   window_state->OnWMEvent(&event);
1211   EXPECT_TRUE(window_state->IsFullscreen());
1212   EXPECT_FALSE(window_state->in_immersive_fullscreen());
1213   EXPECT_EQ(window.get(), wm::GetActiveWindow());
1214   window_state->set_in_immersive_fullscreen(true);
1215   EXPECT_TRUE(window_state->in_immersive_fullscreen());
1216
1217   // Do an edge swipe bottom into screen.
1218   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1219   int y = Shell::GetPrimaryRootWindow()->bounds().bottom();
1220   generator.GestureScrollSequence(gfx::Point(50, y),
1221                                   gfx::Point(50, y - 100),
1222                                   base::TimeDelta::FromMilliseconds(20),
1223                                   10);
1224
1225   // The window should still be full screen and immersive.
1226   EXPECT_TRUE(window_state->IsFullscreen());
1227   EXPECT_TRUE(window_state->in_immersive_fullscreen());
1228
1229   DestroyMaximizeModeWindowManager();
1230 }
1231
1232 #endif  // OS_WIN
1233
1234 }  // namespace ash