Moves Shell::maximize_mode_controller() to WmShell

ash/wm/maximize_mode/maximize_mode_window_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
 
 #include <string>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
@@ skipping 64 matching lines @@
     widget->Init(params);
     widget->Show();
     aura::Window* window = widget->GetNativeWindow();
     window->SetBounds(bounds);
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 
     return window;
   }
 
   // Create the Maximized mode window manager.
-  ash::MaximizeModeWindowManager* CreateMaximizeModeWindowManager() {
+  MaximizeModeWindowManager* CreateMaximizeModeWindowManager() {
     EXPECT_FALSE(maximize_mode_window_manager());
-    Shell::GetInstance()
-        ->maximize_mode_controller()
-        ->EnableMaximizeModeWindowManager(true);
+    WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+        true);
     return maximize_mode_window_manager();
   }
 
   // Destroy the maximized mode window manager.
   void DestroyMaximizeModeWindowManager() {
-    Shell::GetInstance()
-        ->maximize_mode_controller()
-        ->EnableMaximizeModeWindowManager(false);
+    WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+        false);
     EXPECT_FALSE(maximize_mode_window_manager());
   }
 
   // Get the maximze window manager.
-  ash::MaximizeModeWindowManager* maximize_mode_window_manager() {
-    return Shell::GetInstance()
+  MaximizeModeWindowManager* maximize_mode_window_manager() {
+    return WmShell::Get()
         ->maximize_mode_controller()
         ->maximize_mode_window_manager_.get();
   }
 
   // Resize our desktop.
   void ResizeDesktop(int width_delta) {
     gfx::Size size =
         display::Screen::GetScreen()
             ->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow())
             .size();
@@ skipping 28 matching lines @@
     container->AddChild(window);
     return window;
   }
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeModeWindowManagerTest);
 };
 
 // Test that creating the object and destroying it without any windows should
 // not cause any problems.
 TEST_F(MaximizeModeWindowManagerTest, SimpleStart) {
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that existing windows will handled properly when going into maximized
 // mode.
 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindows) {
   // Bounds for windows we know can be controlled.
   gfx::Rect rect1(10, 10, 200, 50);
@@ skipping 19 matching lines @@
       CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
   EXPECT_EQ(rect3.ToString(), w3->bounds().ToString());
 
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
   EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString());
   EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString());
 
   // All other windows should not have been touched.
   EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized());
@@ skipping 53 matching lines @@
   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
   EXPECT_EQ(rect3.ToString(), w3->bounds().ToString());
 
   // Enable system modal dialog, and make sure both shelves are still hidden.
   WmShell::Get()->SimulateModalWindowOpenForTesting(true);
   EXPECT_TRUE(WmShell::Get()->IsSystemModalWindowOpen());
 
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
   EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString());
   EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString());
 
   // All other windows should not have been touched.
   EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized());
@@ skipping 43 matching lines @@
   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 
   gfx::Size workspace_size =
       ScreenUtil::GetMaximizedWindowBoundsInParent(unlimited_window.get())
           .size();
 
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   // The unlimited window should have the size of the workspace / parent window.
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString());
   EXPECT_EQ(workspace_size.ToString(),
             unlimited_window->bounds().size().ToString());
   // The limited window should have the size of the upper possible bounds.
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_NE(rect.origin().ToString(),
@@ skipping 11 matching lines @@
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 }
 
 // Test that creating windows while a maximizer exists picks them properly up.
 TEST_F(MaximizeModeWindowManagerTest, CreateWindows) {
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 
   // Create the windows and see that the window manager picks them up.
   // Rects for windows we know can be controlled.
   gfx::Rect rect1(10, 10, 200, 50);
   gfx::Rect rect2(10, 60, 200, 50);
   gfx::Rect rect3(20, 140, 100, 100);
   // One rect for anything else.
   gfx::Rect rect(80, 90, 100, 110);
@@ skipping 53 matching lines @@
   EXPECT_EQ(rect.ToString(), w5->bounds().ToString());
   EXPECT_EQ(rect.ToString(), w6->bounds().ToString());
   EXPECT_EQ(rect.ToString(), w7->bounds().ToString());
   EXPECT_EQ(rect.ToString(), w8->bounds().ToString());
 }
 
 // Test that a window which got created while the maximize mode window manager
 // is active gets restored to a usable (non tiny) size upon switching back.
 TEST_F(MaximizeModeWindowManagerTest,
        CreateWindowInMaximizedModeRestoresToUsefulSize) {
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 
   // We pass in an empty rectangle to simulate a window creation with no
   // particular size.
   gfx::Rect empty_rect(0, 0, 0, 0);
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, empty_rect));
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_NE(empty_rect.ToString(), window->bounds().ToString());
   gfx::Rect maximized_size = window->bounds();
 
   // Destroy the maximize mode and check that the resulting size of the window
   // is remaining as it is (but not maximized).
   DestroyMaximizeModeWindowManager();
 
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_EQ(maximized_size.ToString(), window->bounds().ToString());
 }
 
 // Test that non-maximizable windows get properly handled when created in
 // maximized mode.
 TEST_F(MaximizeModeWindowManagerTest, CreateNonMaximizableButResizableWindows) {
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
 
   gfx::Rect rect(10, 10, 200, 50);
   gfx::Size max_size(300, 200);
   gfx::Size empty_size;
   std::unique_ptr<aura::Window> unlimited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
   std::unique_ptr<aura::Window> limited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
   std::unique_ptr<aura::Window> fixed_window(
@@ skipping 35 matching lines @@
 
 // Create a string which consists of the bounds and the state for comparison.
 std::string GetPlacementString(const gfx::Rect& bounds,
                                ui::WindowShowState state) {
   return bounds.ToString() + base::StringPrintf(" %d", state);
 }
 
 // Retrieves the window's restore state override - if any - and returns it as a
 // string.
 std::string GetPlacementOverride(aura::Window* window) {
-  gfx::Rect* bounds = window->GetProperty(ash::kRestoreBoundsOverrideKey);
+  gfx::Rect* bounds = window->GetProperty(kRestoreBoundsOverrideKey);
   if (bounds) {
     gfx::Rect restore_bounds = *bounds;
     ui::WindowShowState restore_state =
-        window->GetProperty(ash::kRestoreShowStateOverrideKey);
+        window->GetProperty(kRestoreShowStateOverrideKey);
     return GetPlacementString(restore_bounds, restore_state);
   }
   return std::string();
 }
 
 // Test that the restore state will be kept at its original value for
 // session restauration purposes.
 TEST_F(MaximizeModeWindowManagerTest, TestRestoreIntegrety) {
   gfx::Rect bounds(10, 10, 200, 50);
   gfx::Size empty_size;
   gfx::Rect empty_bounds;
   std::unique_ptr<aura::Window> normal_window(CreateWindowWithWidget(bounds));
   std::unique_ptr<aura::Window> maximized_window(
       CreateWindowWithWidget(bounds));
   wm::GetWindowState(maximized_window.get())->Maximize();
 
   EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get()));
   EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get()));
 
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
 
   // With the maximization the override states should be returned in its
   // pre-maximized state.
   EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_NORMAL),
             GetPlacementOverride(normal_window.get()));
   EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED),
             GetPlacementOverride(maximized_window.get()));
 
   // Changing a window's state now does not change the returned result.
@@ skipping 10 matching lines @@
   wm::GetWindowState(maximized_window.get())->Restore();
   gfx::Rect new_bounds(10, 10, 200, 50);
   maximized_window->SetBounds(new_bounds);
 
   EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get()));
 }
 
 // Test that windows which got created before the maximizer was created can be
 // destroyed while the maximizer is still running.
 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindowsDeleteWhileActive) {
-  ash::MaximizeModeWindowManager* manager = NULL;
+  MaximizeModeWindowManager* manager = NULL;
   {
     // Bounds for windows we know can be controlled.
     gfx::Rect rect1(10, 10, 200, 50);
     gfx::Rect rect2(10, 60, 200, 50);
     gfx::Rect rect3(20, 140, 100, 100);
     // Bounds for anything else.
     gfx::Rect rect(80, 90, 100, 110);
     std::unique_ptr<aura::Window> w1(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
     std::unique_ptr<aura::Window> w2(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
     std::unique_ptr<aura::Window> w3(
         CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3));
 
     // Create the manager and make sure that all qualifying windows were
     // detected and changed.
     manager = CreateMaximizeModeWindowManager();
     ASSERT_TRUE(manager);
     EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   }
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that windows which got created while the maximizer was running can get
 // destroyed before the maximizer gets destroyed.
 TEST_F(MaximizeModeWindowManagerTest, CreateWindowsAndDeleteWhileActive) {
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
   {
     // Bounds for windows we know can be controlled.
     gfx::Rect rect1(10, 10, 200, 50);
     gfx::Rect rect2(10, 60, 200, 50);
     gfx::Rect rect3(20, 140, 100, 100);
     std::unique_ptr<aura::Window> w1(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
     std::unique_ptr<aura::Window> w2(
@@ skipping 12 matching lines @@
 
 // Test that windows which were maximized stay maximized.
 TEST_F(MaximizeModeWindowManagerTest, MaximizedShouldRemainMaximized) {
   // Bounds for windows we know can be controlled.
   gfx::Rect rect(10, 10, 200, 50);
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::GetWindowState(window.get())->Maximize();
 
   // Create the manager and make sure that the window gets detected.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(1, manager->GetNumberOfManagedWindows());
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
 
   // Destroy the manager again and check that the window will remain maximized.
   DestroyMaximizeModeWindowManager();
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
   wm::GetWindowState(window.get())->Restore();
   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 }
 
 // Test that minimized windows do neither get maximized nor restored upon
 // entering maximized mode and get restored to their previous state after
 // leaving.
 TEST_F(MaximizeModeWindowManagerTest, MinimizedWindowBehavior) {
   // Bounds for windows we know can be controlled.
   gfx::Rect rect(10, 10, 200, 50);
   std::unique_ptr<aura::Window> initially_minimized_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   std::unique_ptr<aura::Window> initially_normal_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   std::unique_ptr<aura::Window> initially_maximized_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::GetWindowState(initially_minimized_window.get())->Minimize();
   wm::GetWindowState(initially_maximized_window.get())->Maximize();
 
   // Create the manager and make sure that the window gets detected.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   EXPECT_TRUE(
       wm::GetWindowState(initially_minimized_window.get())->IsMinimized());
   EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMaximized());
   EXPECT_TRUE(
       wm::GetWindowState(initially_maximized_window.get())->IsMaximized());
   // Now minimize the second window to check that upon leaving the window
   // will get restored to its minimized state.
   wm::GetWindowState(initially_normal_window.get())->Minimize();
@@ skipping 23 matching lines @@
   std::unique_ptr<aura::Window> window1(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   EXPECT_EQ(rect.ToString(), window1->bounds().ToString());
 
   // This window will not move because it does fit the new bounds.
   gfx::Rect rect2(20, 140, 100, 100);
   std::unique_ptr<aura::Window> window2(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 
   // Turning on the manager will reposition (but not resize) the window.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(2, manager->GetNumberOfManagedWindows());
   gfx::Rect moved_bounds(window1->bounds());
   EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString());
   EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString());
 
   // Simulating a desktop resize should move the window again.
   UpdateDisplay("300x300");
   gfx::Rect new_moved_bounds(window1->bounds());
   EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString());
   EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString());
   EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString());
 
   // Turning off the mode should not restore to the initial coordinates since
   // the new resolution is smaller and the window was on the edge.
   DestroyMaximizeModeWindowManager();
   EXPECT_NE(rect.ToString(), window1->bounds().ToString());
   EXPECT_EQ(rect2.ToString(), window2->bounds().ToString());
 }
 
 // Check that windows return to original location if desktop size changes to
 // something else and back while in maximize mode.
 TEST_F(MaximizeModeWindowManagerTest, SizeChangeReturnWindowToOriginalPos) {
   gfx::Rect rect(20, 140, 100, 100);
   std::unique_ptr<aura::Window> window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 
   // Turning on the manager will reposition (but not resize) the window.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(1, manager->GetNumberOfManagedWindows());
   gfx::Rect moved_bounds(window->bounds());
   EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString());
   EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString());
 
   // Simulating a desktop resize should move the window again.
   ResizeDesktop(-10);
   gfx::Rect new_moved_bounds(window->bounds());
   EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString());
@@ skipping 28 matching lines @@
         WmShell::Get()->mru_window_tracker()->BuildMruWindowList());
 
     EXPECT_EQ(w1.get(), windows[4]);
     EXPECT_EQ(w2.get(), windows[3]);
     EXPECT_EQ(w3.get(), windows[2]);
     EXPECT_EQ(w4.get(), windows[1]);
     EXPECT_EQ(w5.get(), windows[0]);
   }
 
   // Activating the window manager should keep the order.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(5, manager->GetNumberOfManagedWindows());
   {
     aura::Window::Windows windows = WmWindowAura::ToAuraWindows(
         WmShell::Get()->mru_window_tracker()->BuildMruWindowList());
     // We do not test maximization here again since that was done already.
     EXPECT_EQ(w1.get(), windows[4]);
     EXPECT_EQ(w2.get(), windows[3]);
     EXPECT_EQ(w3.get(), windows[2]);
     EXPECT_EQ(w4.get(), windows[1]);
@@ skipping 31 matching lines @@
   DestroyMaximizeModeWindowManager();
 }
 
 // Check that minimize and restore do the right thing.
 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) {
   gfx::Rect rect(10, 10, 100, 100);
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
-  ash::Shell::GetInstance()
-      ->maximize_mode_controller()
-      ->EnableMaximizeModeWindowManager(true);
+  WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+      true);
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 
   window_state->Minimize();
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_TRUE(window_state->IsMinimized());
   EXPECT_FALSE(window->IsVisible());
 
   window_state->Maximize();
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 
-  ash::Shell::GetInstance()
-      ->maximize_mode_controller()
-      ->EnableMaximizeModeWindowManager(false);
+  WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+      false);
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 }
 
 // Check that a full screen window remains full screen upon entering maximize
 // mode. Furthermore, checks that this window is not full screen upon exiting
 // maximize mode if it was un-full-screened while in maximize mode.
 TEST_F(MaximizeModeWindowManagerTest, KeepFullScreenModeOn) {
   gfx::Rect rect(20, 140, 100, 100);
@@ skipping 364 matching lines @@
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   gfx::Point first_dragged_origin = window->bounds().origin();
   EXPECT_EQ(rect.x() + 10, first_dragged_origin.x());
   EXPECT_EQ(rect.y() + 5, first_dragged_origin.y());
 
   // 2. Check that turning on the manager will stop allowing the window from
   // dragging.
-  ash::Shell::GetInstance()
-      ->maximize_mode_controller()
-      ->EnableMaximizeModeWindowManager(true);
+  WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+      true);
   gfx::Rect center_bounds(window->bounds());
   EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString());
   generator.MoveMouseTo(
       gfx::Point(center_bounds.x() + 1, center_bounds.y() + 1));
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   EXPECT_EQ(center_bounds.x(), window->bounds().x());
   EXPECT_EQ(center_bounds.y(), window->bounds().y());
-  ash::Shell::GetInstance()
-      ->maximize_mode_controller()
-      ->EnableMaximizeModeWindowManager(false);
+  WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+      false);
 
   // 3. Releasing the mazimize manager again will restore the window to its
   // previous bounds and
   generator.MoveMouseTo(
       gfx::Point(first_dragged_origin.x() + 1, first_dragged_origin.y() + 1));
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x());
   EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y());
 }
 
 // Test that overview is exited before entering / exiting maximize mode so that
 // the window changes made by MaximizeModeWindowManager do not conflict with
 // those made in WindowOverview.
 TEST_F(MaximizeModeWindowManagerTest, ExitsOverview) {
   // Bounds for windows we know can be controlled.
   gfx::Rect rect1(10, 10, 200, 50);
   gfx::Rect rect2(10, 60, 200, 50);
   std::unique_ptr<aura::Window> w1(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
   std::unique_ptr<aura::Window> w2(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
 
   WindowSelectorController* window_selector_controller =
       WmShell::Get()->window_selector_controller();
   window_selector_controller->ToggleOverview();
   ASSERT_TRUE(window_selector_controller->IsSelecting());
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_FALSE(window_selector_controller->IsSelecting());
 
   window_selector_controller->ToggleOverview();
   ASSERT_TRUE(window_selector_controller->IsSelecting());
   // Destroy the manager again and check that the windows return to their
   // previous state.
   DestroyMaximizeModeWindowManager();
   EXPECT_FALSE(window_selector_controller->IsSelecting());
 }
@@ skipping 224 matching lines @@
   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
   EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged());
 
   // Enter maximize mode. Neither window should be managed because they have
   // the always-on-top property set, which means that none of their properties
   // should change.
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
   EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_EQ(rect1.ToString(), w1->bounds().ToString());
   EXPECT_EQ(rect2.ToString(), w2->bounds().ToString());
   EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged());
 
   // Remove the always-on-top property from both windows while in maximize
@@ skipping 38 matching lines @@
 TEST_F(MaximizeModeWindowManagerTest, DontMaximizeDockedWindows) {
   gfx::Rect rect(10, 10, 200, 50);
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   wm::GetWindowState(window.get())->OnWMEvent(&dock_event);
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsDocked());
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
 
-  ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
+  MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsDocked());
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 }
 
 #endif  // OS_WIN
 
 }  // namespace ash