Convert //ash from scoped_ptr to std::unique_ptr

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/wm/maximize_mode/maximize_mode_window_manager.h"
 
 #include <string>
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
@@ skipping 142 matching lines @@
 
 // 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);
   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);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-  scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
-  scoped_ptr<aura::Window> w3(
+  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));
-  scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
-  scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
-  scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
-  scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
-  scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
+  std::unique_ptr<aura::Window> w4(
+      CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
+  std::unique_ptr<aura::Window> w5(
+      CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
+  std::unique_ptr<aura::Window> w6(
+      CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
+  std::unique_ptr<aura::Window> w7(
+      CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
+  std::unique_ptr<aura::Window> w8(
+      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();
@@ skipping 34 matching lines @@
 }
 
 // The same test as the above but while a system modal dialog is shown.
 TEST_F(MaximizeModeWindowManagerTest, GoingToMaximizedWithModalDialogPresent) {
   // 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);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-  scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
-  scoped_ptr<aura::Window> w3(
+  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));
-  scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
-  scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
-  scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
-  scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
-  scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
+  std::unique_ptr<aura::Window> w4(
+      CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
+  std::unique_ptr<aura::Window> w5(
+      CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
+  std::unique_ptr<aura::Window> w6(
+      CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
+  std::unique_ptr<aura::Window> w7(
+      CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
+  std::unique_ptr<aura::Window> w8(
+      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());
 
   // Enable system modal dialog, and make sure both shelves are still hidden.
   ash::Shell::GetInstance()->SimulateModalWindowOpenForTesting(true);
   EXPECT_TRUE(ash::Shell::GetInstance()->IsSystemModalWindowOpen());
@@ skipping 38 matching lines @@
 }
 
 // Test that non-maximizable windows get properly handled when going into
 // maximized mode.
 TEST_F(MaximizeModeWindowManagerTest,
        PreCreateNonMaximizableButResizableWindows) {
   // The window bounds.
   gfx::Rect rect(10, 10, 200, 50);
   gfx::Size max_size(300, 200);
   gfx::Size empty_size;
-  scoped_ptr<aura::Window> unlimited_window(
+  std::unique_ptr<aura::Window> unlimited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
-  scoped_ptr<aura::Window> limited_window(
+  std::unique_ptr<aura::Window> limited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
-  scoped_ptr<aura::Window> fixed_window(
+  std::unique_ptr<aura::Window> fixed_window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   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());
 
   gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
       unlimited_window.get()).size();
@@ skipping 38 matching lines @@
   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);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-  scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
-  scoped_ptr<aura::Window> w3(
+  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));
-  scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
-  scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
-  scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
-  scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
-  scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
+  std::unique_ptr<aura::Window> w4(
+      CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect));
+  std::unique_ptr<aura::Window> w5(
+      CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect));
+  std::unique_ptr<aura::Window> w6(
+      CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect));
+  std::unique_ptr<aura::Window> w7(
+      CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect));
+  std::unique_ptr<aura::Window> w8(
+      CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect));
   EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized());
 
   // Make sure that the position of the unresizable window is in the middle of
   // the screen.
   gfx::Size work_area_size =
       ScreenUtil::GetDisplayWorkAreaBoundsInParent(w3.get()).size();
   gfx::Point center =
@@ skipping 34 matching lines @@
 // is active gets restored to a usable (non tiny) size upon switching back.
 TEST_F(MaximizeModeWindowManagerTest,
        CreateWindowInMaximizedModeRestoresToUsefulSize) {
   ash::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);
-  scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                               empty_rect));
+  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();
   ASSERT_TRUE(manager);
 
   gfx::Rect rect(10, 10, 200, 50);
   gfx::Size max_size(300, 200);
   gfx::Size empty_size;
-  scoped_ptr<aura::Window> unlimited_window(
+  std::unique_ptr<aura::Window> unlimited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
-  scoped_ptr<aura::Window> limited_window(
+  std::unique_ptr<aura::Window> limited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
-  scoped_ptr<aura::Window> fixed_window(
+  std::unique_ptr<aura::Window> fixed_window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 
   gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
       unlimited_window.get()).size();
 
   // All windows should be sized now as big as possible and be centered.
   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());
@@ skipping 42 matching lines @@
   }
   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;
-  scoped_ptr<aura::Window> normal_window(
-      CreateWindowWithWidget(bounds));
-  scoped_ptr<aura::Window> maximized_window(
+  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();
   ASSERT_TRUE(manager);
 
   // With the maximization the override states should be returned in its
@@ skipping 25 matching lines @@
 // destroyed while the maximizer is still running.
 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindowsDeleteWhileActive) {
   ash::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);
-    scoped_ptr<aura::Window> w1(
+    std::unique_ptr<aura::Window> w1(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-    scoped_ptr<aura::Window> w2(
+    std::unique_ptr<aura::Window> w2(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
-    scoped_ptr<aura::Window> w3(
+    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();
   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);
-    scoped_ptr<aura::Window> w1(
+    std::unique_ptr<aura::Window> w1(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
-    scoped_ptr<aura::Window> w2(
+    std::unique_ptr<aura::Window> w2(
         CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 60, 200, 50)));
-    scoped_ptr<aura::Window> w3(
-        CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                            gfx::Rect(20, 140, 100, 100)));
+    std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow(
+        ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(20, 140, 100, 100)));
     // Check that the windows got automatically maximized as well.
     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_EQ(0, manager->GetNumberOfManagedWindows());
   DestroyMaximizeModeWindowManager();
 }
 
 // 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);
-  scoped_ptr<aura::Window> window(
+  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();
   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);
-  scoped_ptr<aura::Window> initially_minimized_window(
+  std::unique_ptr<aura::Window> initially_minimized_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> initially_normal_window(
+  std::unique_ptr<aura::Window> initially_normal_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> initially_maximized_window(
+  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();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   EXPECT_TRUE(wm::GetWindowState(
       initially_minimized_window.get())->IsMinimized());
@@ skipping 20 matching lines @@
   EXPECT_TRUE(wm::GetWindowState(
       initially_maximized_window.get())->IsMaximized());
 }
 
 // Check that resizing the desktop does reposition unmaximizable, unresizable &
 // managed windows.
 TEST_F(MaximizeModeWindowManagerTest, DesktopSizeChangeMovesUnmaximizable) {
   UpdateDisplay("400x400");
   // This window will move because it does not fit the new bounds.
   gfx::Rect rect(20, 300, 100, 100);
-  scoped_ptr<aura::Window> window1(
+  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);
-  scoped_ptr<aura::Window> window2(
+  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();
   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);
-  scoped_ptr<aura::Window> window(
+  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();
   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());
   EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString());
   EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString());
 
   // Then resize back to the original desktop size which should move windows
   // to their original location after leaving the maximize mode.
   ResizeDesktop(10);
   DestroyMaximizeModeWindowManager();
   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 }
 
 // Check that enabling of the maximize mode does not have an impact on the MRU
 // order of windows.
 TEST_F(MaximizeModeWindowManagerTest, ModeChangeKeepsMRUOrder) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(
+  std::unique_ptr<aura::Window> w1(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> w3(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> w4(
+  std::unique_ptr<aura::Window> w2(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w3(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w4(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w5(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 
   // The windows should be in the reverse order of creation in the MRU list.
   {
     MruWindowTracker::WindowList windows = ash::Shell::GetInstance()->
         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]);
@@ skipping 24 matching lines @@
     EXPECT_EQ(w2.get(), windows[3]);
     EXPECT_EQ(w3.get(), windows[2]);
     EXPECT_EQ(w4.get(), windows[1]);
     EXPECT_EQ(w5.get(), windows[0]);
   }
 }
 
 // Check that a restore state change does always restore to maximized.
 TEST_F(MaximizeModeWindowManagerTest, IgnoreRestoreStateChages) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   CreateMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsMaximized());
   window_state->Minimize();
   EXPECT_TRUE(window_state->IsMinimized());
   window_state->Restore();
   EXPECT_TRUE(window_state->IsMaximized());
   window_state->Restore();
   EXPECT_TRUE(window_state->IsMaximized());
   DestroyMaximizeModeWindowManager();
 }
 
 // Check that minimize and restore do the right thing.
 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) {
   gfx::Rect rect(10, 10, 100, 100);
-  scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                  rect));
+  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);
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 
   window_state->Minimize();
   EXPECT_FALSE(window_state->IsMaximized());
@@ skipping 10 matching lines @@
   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);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 
   ShelfLayoutManager* shelf =
       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 
   // Allow the shelf to hide.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
@@ skipping 24 matching lines @@
   EXPECT_FALSE(window_state->IsFullscreen());
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 }
 
 // Verifies that if a window is un-full-screened while in maximize mode,
 // other changes to that window's state (such as minimizing it) are
 // preserved upon exiting maximize mode.
 TEST_F(MaximizeModeWindowManagerTest, MinimizePreservedAfterLeavingFullscreen) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 
   ShelfLayoutManager* shelf =
       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 
   // Allow the shelf to hide and enter full screen.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event);
   ASSERT_FALSE(window_state->IsMinimized());
 
   // Enter maximize mode, exit full screen, and then minimize the window.
   CreateMaximizeModeWindowManager();
   window_state->OnWMEvent(&event);
   window_state->Minimize();
   ASSERT_TRUE(window_state->IsMinimized());
 
   // The window should remain minimized when exiting maximize mode.
   DestroyMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsMinimized());
 }
 
 // Check that full screen mode can be turned on in maximized mode and remains
 // upon coming back.
 TEST_F(MaximizeModeWindowManagerTest, AllowFullScreenMode) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
 
   ShelfLayoutManager* shelf =
       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 
   // Allow the shelf to hide.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
   EXPECT_FALSE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->IsMaximized());
@@ skipping 21 matching lines @@
   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 }
 
 // Check that the full screen mode will stay active when the maximize mode is
 // ended.
 TEST_F(MaximizeModeWindowManagerTest,
        FullScreenModeRemainsWhenCreatedInMaximizedMode) {
   CreateMaximizeModeWindowManager();
 
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event_full_screen);
   EXPECT_TRUE(window_state->IsFullscreen());
 
   // After the maximize mode manager is ended, full screen will remain.
   DestroyMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsFullscreen());
 }
 
 // Check that the full screen mode will stay active throughout a maximzied mode
 // session.
 TEST_F(MaximizeModeWindowManagerTest,
        FullScreenModeRemainsThroughMaximizeModeSwitch) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event_full_screen);
   EXPECT_TRUE(window_state->IsFullscreen());
 
   CreateMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsFullscreen());
   DestroyMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsFullscreen());
 }
 
 // Check that an empty window does not get restored to a tiny size.
 TEST_F(MaximizeModeWindowManagerTest,
        CreateAndMaximizeInMaximizeModeShouldRetoreToGoodSizeGoingToDefault) {
   CreateMaximizeModeWindowManager();
   gfx::Rect rect;
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   w1->Show();
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   EXPECT_TRUE(window_state->IsMaximized());
 
   // There is a calling order in which the restore bounds can get set to an
   // empty rectangle. We simulate this here.
   window_state->SetRestoreBoundsInScreen(rect);
   EXPECT_TRUE(window_state->GetRestoreBoundsInScreen().IsEmpty());
 
   // Setting the window to a new size will physically not change the window,
   // but the restore size should get updated so that a restore later on will
   // return to this size.
   gfx::Rect requested_bounds(10, 20, 50, 70);
   w1->SetBounds(requested_bounds);
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_EQ(requested_bounds.ToString(),
             window_state->GetRestoreBoundsInScreen().ToString());
 
   DestroyMaximizeModeWindowManager();
 
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_EQ(w1->bounds().ToString(), requested_bounds.ToString());
 }
 
 // Check that snapping operations get ignored.
 TEST_F(MaximizeModeWindowManagerTest, SnapModeTests) {
   gfx::Rect rect(20, 140, 100, 100);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   wm::WMEvent event_left(wm::WM_EVENT_SNAP_LEFT);
   wm::WMEvent event_right(wm::WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&event_left);
   EXPECT_TRUE(window_state->IsSnapped());
 
   CreateMaximizeModeWindowManager();
 
   // Fullscreen mode should now be off and it should not come back while in
   // maximize mode.
   EXPECT_FALSE(window_state->IsSnapped());
   EXPECT_TRUE(window_state->IsMaximized());
   window_state->OnWMEvent(&event_left);
   EXPECT_FALSE(window_state->IsSnapped());
   EXPECT_TRUE(window_state->IsMaximized());
   window_state->OnWMEvent(&event_right);
   EXPECT_FALSE(window_state->IsSnapped());
   EXPECT_TRUE(window_state->IsMaximized());
 
   DestroyMaximizeModeWindowManager();
   EXPECT_TRUE(window_state->IsSnapped());
 }
 
 // Check that non maximizable windows cannot be dragged by the user.
 TEST_F(MaximizeModeWindowManagerTest, TryToDesktopSizeDragUnmaximizable) {
   gfx::Rect rect(10, 10, 100, 100);
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
 
   // 1. Move the mouse over the caption and check that dragging the window does
   // change the location.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   generator.MoveMouseTo(gfx::Point(rect.x() + 2, rect.y() + 2));
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
@@ skipping 31 matching lines @@
   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);
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-  scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
+  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 =
       Shell::GetInstance()->window_selector_controller();
   window_selector_controller->ToggleOverview();
   ASSERT_TRUE(window_selector_controller->IsSelecting());
   ash::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());
 }
 
 // Test that an edge swipe from the top will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromTop) {
   gfx::Rect rect(10, 10, 200, 50);
-  scoped_ptr<aura::Window>
-      background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window>
-      foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> background_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> foreground_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* background_window_state =
       wm::GetWindowState(background_window.get());
   wm::WindowState* foreground_window_state =
       wm::GetWindowState(foreground_window.get());
   wm::ActivateWindow(foreground_window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen both windows.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
@@ skipping 20 matching lines @@
 
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge swipe from the bottom will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) {
   gfx::Rect rect(10, 10, 200, 50);
-  scoped_ptr<aura::Window>
-      background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window>
-      foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> background_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> foreground_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* background_window_state =
       wm::GetWindowState(background_window.get());
   wm::WindowState* foreground_window_state =
       wm::GetWindowState(foreground_window.get());
   wm::ActivateWindow(foreground_window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen both windows.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
@@ skipping 12 matching lines @@
 
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge touch press at the top will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) {
   gfx::Rect rect(10, 10, 200, 50);
-  scoped_ptr<aura::Window>
-      background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window>
-      foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> background_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> foreground_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* background_window_state =
       wm::GetWindowState(background_window.get());
   wm::WindowState* foreground_window_state =
       wm::GetWindowState(foreground_window.get());
   wm::ActivateWindow(foreground_window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen both windows.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
@@ skipping 12 matching lines @@
   generator.GestureTapAt(gfx::Point(100, 0));
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge touch press at the bottom will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtBottom) {
   gfx::Rect rect(10, 10, 200, 50);
-  scoped_ptr<aura::Window>
-      background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
-  scoped_ptr<aura::Window>
-      foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> background_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
+  std::unique_ptr<aura::Window> foreground_window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* background_window_state =
       wm::GetWindowState(background_window.get());
   wm::WindowState* foreground_window_state =
       wm::GetWindowState(foreground_window.get());
   wm::ActivateWindow(foreground_window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen both windows.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
@@ skipping 14 matching lines @@
       gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1));
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge swipe from the top on an immersive mode window will not end
 // full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, NoExitImmersiveModeWithEdgeSwipeFromTop) {
-  scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                  gfx::Rect(10, 10, 200, 50)));
+  std::unique_ptr<aura::Window> window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   wm::ActivateWindow(window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen the window.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->in_immersive_fullscreen());
   EXPECT_EQ(window.get(), wm::GetActiveWindow());
@@ skipping 10 matching lines @@
   // It should have not exited full screen or immersive mode.
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_TRUE(window_state->in_immersive_fullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge swipe from the bottom will not end immersive mode.
 TEST_F(MaximizeModeWindowManagerTest,
        NoExitImmersiveModeWithEdgeSwipeFromBottom) {
-  scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                               gfx::Rect(10, 10, 200, 50)));
+  std::unique_ptr<aura::Window> window(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   wm::ActivateWindow(window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen the window.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->in_immersive_fullscreen());
   EXPECT_EQ(window.get(), wm::GetActiveWindow());
@@ skipping 16 matching lines @@
 }
 
 // Tests that windows with the always-on-top property are not managed by
 // the MaximizeModeWindowManager while maximize mode is engaged (i.e.,
 // they remain free-floating).
 TEST_F(MaximizeModeWindowManagerTest, AlwaysOnTopWindows) {
   gfx::Rect rect1(10, 10, 200, 50);
   gfx::Rect rect2(20, 140, 100, 100);
 
   // Create two windows with the always-on-top property.
-  scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
-  scoped_ptr<aura::Window> w2(
+  std::unique_ptr<aura::Window> w1(
+      CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1));
+  std::unique_ptr<aura::Window> w2(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2));
   w1->SetProperty(aura::client::kAlwaysOnTopKey, true);
   w2->SetProperty(aura::client::kAlwaysOnTopKey, true);
   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());
 
@@ skipping 44 matching lines @@
   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());
 }
 
 // Tests that docked windows are not maximized, and not tracked.
 TEST_F(MaximizeModeWindowManagerTest, DontMaximizeDockedWindows) {
   gfx::Rect rect(10, 10, 200, 50);
-  scoped_ptr<aura::Window> window(
+  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();
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsDocked());
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 }
 
 #endif  // OS_WIN
 
 }  // namespace ash