Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/panels/panel_layout_manager_unittest.cc

 // Copyright (c) 2012 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/panels/panel_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
@@ skipping 229 matching lines @@
                                ShelfVisibilityState visibility_state) {
     Shelf* shelf = Shelf::ForWindow(window);
     shelf->shelf_layout_manager()->SetState(visibility_state);
   }
 
   ShelfView* GetShelfView(Shelf* shelf) {
     return test::ShelfTestAPI(shelf).shelf_view();
   }
 
  private:
-  scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
+  std::unique_ptr<test::ShelfViewTestAPI> shelf_view_test_;
 
   bool IsHorizontal(ShelfAlignment alignment) {
     return alignment == SHELF_ALIGNMENT_BOTTOM;
   }
 
   DISALLOW_COPY_AND_ASSIGN(PanelLayoutManagerTest);
 };
 
 class PanelLayoutManagerTextDirectionTest
     : public PanelLayoutManagerTest,
@@ skipping 19 matching lines @@
  private:
   bool is_rtl_;
   std::string original_locale_;
 
   DISALLOW_COPY_AND_ASSIGN(PanelLayoutManagerTextDirectionTest);
 };
 
 // Tests that a created panel window is above the shelf icon in LTR and RTL.
 TEST_P(PanelLayoutManagerTextDirectionTest, AddOnePanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> window(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> window(CreatePanelWindow(bounds));
   EXPECT_EQ(GetPanelContainer(window.get()), window->parent());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(window.get()));
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(window.get()));
 }
 
 // Tests that a created panel window is successfully aligned over a hidden
 // shelf icon.
 TEST_F(PanelLayoutManagerTest, PanelAlignsToHiddenLauncherIcon) {
   gfx::Rect bounds(0, 0, 201, 201);
   SetShelfAutoHideBehavior(Shell::GetPrimaryRootWindow(),
                            SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  scoped_ptr<aura::Window> normal_window(CreateNormalWindow(bounds));
-  scoped_ptr<aura::Window> window(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> normal_window(CreateNormalWindow(bounds));
+  std::unique_ptr<aura::Window> window(CreatePanelWindow(bounds));
   EXPECT_EQ(GetPanelContainer(window.get()), window->parent());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(window.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, PanelAlignsToHiddenLauncherIconSecondDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Keep the displays wide so that shelves have enough space for shelves
   // buttons.
   UpdateDisplay("400x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
-  scoped_ptr<aura::Window> normal_window(
+  std::unique_ptr<aura::Window> normal_window(
       CreateNormalWindow(gfx::Rect(450, 0, 100, 100)));
-  scoped_ptr<aura::Window> panel(CreatePanelWindow(gfx::Rect(400, 0, 50, 50)));
+  std::unique_ptr<aura::Window> panel(
+      CreatePanelWindow(gfx::Rect(400, 0, 50, 50)));
   EXPECT_EQ(root_windows[1], panel->GetRootWindow());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(panel.get()));
   gfx::Rect shelf_visible_position = panel->GetBoundsInScreen();
 
   SetShelfAutoHideBehavior(root_windows[1],
                            SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   // Expect the panel X position to remain the same after the shelf is hidden
   // but the Y to move down.
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(panel.get()));
   EXPECT_EQ(shelf_visible_position.x(), panel->GetBoundsInScreen().x());
   EXPECT_GT(panel->GetBoundsInScreen().y(), shelf_visible_position.y());
 }
 
 // Tests interactions between multiple panels
 TEST_F(PanelLayoutManagerTest, MultiplePanelsAreAboveIcons) {
   gfx::Rect odd_bounds(0, 0, 201, 201);
   gfx::Rect even_bounds(0, 0, 200, 200);
 
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(odd_bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(odd_bounds));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w1.get()));
 
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(even_bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(even_bounds));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w1.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w2.get()));
 
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(odd_bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(odd_bounds));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w1.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w2.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w3.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, MultiplePanelStacking) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   // Default stacking order.
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 
   // Changing the active window should update the stacking order.
   wm::ActivateWindow(w1.get());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(WindowIsAbove(w1.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
 
   wm::ActivateWindow(w2.get());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(WindowIsAbove(w1.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 
   wm::ActivateWindow(w3.get());
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, MultiplePanelStackingVertical) {
   // Set shelf to be aligned on the right.
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_RIGHT);
 
   // Size panels in such a way that ordering them by X coordinate would cause
   // stacking order to be incorrect. Test that stacking order is based on Y.
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(gfx::Rect(0, 0, 210, 201)));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(gfx::Rect(0, 0, 220, 201)));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(gfx::Rect(0, 0, 200, 201)));
+  std::unique_ptr<aura::Window> w1(
+      CreatePanelWindow(gfx::Rect(0, 0, 210, 201)));
+  std::unique_ptr<aura::Window> w2(
+      CreatePanelWindow(gfx::Rect(0, 0, 220, 201)));
+  std::unique_ptr<aura::Window> w3(
+      CreatePanelWindow(gfx::Rect(0, 0, 200, 201)));
 
   // Default stacking order.
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 
   // Changing the active window should update the stacking order.
   wm::ActivateWindow(w1.get());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(WindowIsAbove(w1.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
 
   wm::ActivateWindow(w2.get());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(WindowIsAbove(w1.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 
   wm::ActivateWindow(w3.get());
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, MultiplePanelCallout) {
   gfx::Rect bounds(0, 0, 200, 200);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w4(CreateNormalWindow(gfx::Rect()));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w4(CreateNormalWindow(gfx::Rect()));
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(IsPanelCalloutVisible(w1.get()));
   EXPECT_TRUE(IsPanelCalloutVisible(w2.get()));
   EXPECT_TRUE(IsPanelCalloutVisible(w3.get()));
   wm::ActivateWindow(w1.get());
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(w1.get()));
   wm::ActivateWindow(w2.get());
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(w2.get()));
   wm::ActivateWindow(w3.get());
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(w3.get()));
   wm::ActivateWindow(w4.get());
   wm::ActivateWindow(w3.get());
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(w3.get()));
   w3.reset();
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(w2.get()));
 }
 
 // Tests removing panels.
 TEST_F(PanelLayoutManagerTest, RemoveLeftPanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   // At this point, windows should be stacked with 1 < 2 < 3
   wm::ActivateWindow(w1.get());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   // Now, windows should be stacked 1 > 2 > 3
   w1.reset();
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w2.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, RemoveMiddlePanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   // At this point, windows should be stacked with 1 < 2 < 3
   wm::ActivateWindow(w2.get());
   // Windows should be stacked 1 < 2 > 3
   w2.reset();
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w1.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w3.get()));
   EXPECT_TRUE(WindowIsAbove(w3.get(), w1.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, RemoveRightPanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   // At this point, windows should be stacked with 1 < 2 < 3
   wm::ActivateWindow(w3.get());
   // Order shouldn't change.
   w3.reset();
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w1.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, RemoveNonActivePanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   // At this point, windows should be stacked with 1 < 2 < 3
   wm::ActivateWindow(w2.get());
   // Windows should be stacked 1 < 2 > 3
   w1.reset();
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w2.get()));
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, SplitView) {
   gfx::Rect bounds(0, 0, 90, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
 
   EXPECT_NO_FATAL_FAILURE(PanelsNotOverlapping(w1.get(), w2.get()));
 }
 
 #if defined(OS_WIN)
 // RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
 #define MAYBE_SplitViewOverlapWhenLarge DISABLED_SplitViewOverlapWhenLarge
 #else
 #define MAYBE_SplitViewOverlapWhenLarge SplitViewOverlapWhenLarge
 #endif
 
 TEST_F(PanelLayoutManagerTest, MAYBE_SplitViewOverlapWhenLarge) {
   gfx::Rect bounds(0, 0, 600, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
 
   EXPECT_NO_FATAL_FAILURE(PanelInScreen(w1.get()));
   EXPECT_NO_FATAL_FAILURE(PanelInScreen(w2.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, FanWindows) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   int window_x1 = w1->GetBoundsInRootWindow().CenterPoint().x();
   int window_x2 = w2->GetBoundsInRootWindow().CenterPoint().x();
   int window_x3 = w3->GetBoundsInRootWindow().CenterPoint().x();
   Shelf* shelf = Shelf::ForPrimaryDisplay();
   int icon_x1 = shelf->GetScreenBoundsOfItemIconForWindow(w1.get()).x();
   int icon_x2 = shelf->GetScreenBoundsOfItemIconForWindow(w2.get()).x();
   EXPECT_EQ(window_x2 - window_x1, window_x3 - window_x2);
   int spacing = window_x2 - window_x1;
   EXPECT_GT(spacing, icon_x2 - icon_x1);
 }
 
 TEST_F(PanelLayoutManagerTest, FanLargeWindow) {
   gfx::Rect small_bounds(0, 0, 201, 201);
   gfx::Rect large_bounds(0, 0, 501, 201);
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(small_bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(large_bounds));
-  scoped_ptr<aura::Window> w3(CreatePanelWindow(small_bounds));
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(small_bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(large_bounds));
+  std::unique_ptr<aura::Window> w3(CreatePanelWindow(small_bounds));
 
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   int window_x1 = w1->GetBoundsInRootWindow().CenterPoint().x();
   int window_x2 = w2->GetBoundsInRootWindow().CenterPoint().x();
   int window_x3 = w3->GetBoundsInRootWindow().CenterPoint().x();
   // The distances may not be equidistant with a large panel but the panels
   // should be in the correct order with respect to their midpoints.
   EXPECT_GT(window_x2, window_x1);
   EXPECT_GT(window_x3, window_x2);
 }
 
 TEST_F(PanelLayoutManagerTest, MinimizeRestorePanel) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> window(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> window(CreatePanelWindow(bounds));
   // Activate the window, ensure callout is visible.
   wm::ActivateWindow(window.get());
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(IsPanelCalloutVisible(window.get()));
   // Minimize the panel, callout should be hidden.
   wm::GetWindowState(window.get())->Minimize();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsPanelCalloutVisible(window.get()));
   // Restore the panel; panel should not be activated by default but callout
   // should be visible.
   wm::GetWindowState(window.get())->Unminimize();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(IsPanelCalloutVisible(window.get()));
   // Activate the window, ensure callout is visible.
   wm::ActivateWindow(window.get());
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(IsPanelCalloutVisible(window.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, PanelMoveBetweenMultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Keep the displays wide so that shelves have enough space for launcher
   // buttons.
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
-  scoped_ptr<aura::Window> p1_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
-  scoped_ptr<aura::Window> p2_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
-  scoped_ptr<aura::Window> p1_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
-  scoped_ptr<aura::Window> p2_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p1_d1(
+      CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p2_d1(
+      CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p1_d2(
+      CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p2_d2(
+      CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
 
   ShelfView* shelf_view_1st = GetShelfView(Shelf::ForPrimaryDisplay());
   ShelfView* shelf_view_2nd =
       GetShelfView(Shelf::ForWindow(root_windows[1]));
 
   EXPECT_EQ(root_windows[0], p1_d1->GetRootWindow());
   EXPECT_EQ(root_windows[0], p2_d1->GetRootWindow());
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
   EXPECT_EQ(root_windows[1], p2_d2->GetRootWindow());
 
@@ skipping 56 matching lines @@
 TEST_F(PanelLayoutManagerTest, PanelAttachPositionMultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Keep the displays wide so that shelves have enough space for shelf buttons.
   // Use differently sized displays so the shelf is in a different
   // position on second display.
   UpdateDisplay("600x400,600x600");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
-  scoped_ptr<aura::Window> p1_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
-  scoped_ptr<aura::Window> p1_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p1_d1(
+      CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p1_d2(
+      CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
 
   EXPECT_EQ(root_windows[0], p1_d1->GetRootWindow());
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
 
   IsPanelAboveLauncherIcon(p1_d1.get());
   IsCalloutAboveLauncherIcon(p1_d1.get());
   IsPanelAboveLauncherIcon(p1_d2.get());
   IsCalloutAboveLauncherIcon(p1_d2.get());
 }
 
 TEST_F(PanelLayoutManagerTest, PanelAlignmentSecondDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
-  scoped_ptr<aura::Window> p1_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
+  std::unique_ptr<aura::Window> p1_d2(
+      CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
 
   IsPanelAboveLauncherIcon(p1_d2.get());
   IsCalloutAboveLauncherIcon(p1_d2.get());
 
   SetAlignment(root_windows[1], SHELF_ALIGNMENT_RIGHT);
   IsPanelAboveLauncherIcon(p1_d2.get());
   IsCalloutAboveLauncherIcon(p1_d2.get());
   SetAlignment(root_windows[1], SHELF_ALIGNMENT_LEFT);
   IsPanelAboveLauncherIcon(p1_d2.get());
   IsCalloutAboveLauncherIcon(p1_d2.get());
 }
 
 TEST_F(PanelLayoutManagerTest, AlignmentLeft) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w(CreatePanelWindow(bounds));
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_LEFT);
   IsPanelAboveLauncherIcon(w.get());
   IsCalloutAboveLauncherIcon(w.get());
 }
 
 TEST_F(PanelLayoutManagerTest, AlignmentRight) {
   gfx::Rect bounds(0, 0, 201, 201);
-  scoped_ptr<aura::Window> w(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w(CreatePanelWindow(bounds));
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_RIGHT);
   IsPanelAboveLauncherIcon(w.get());
   IsCalloutAboveLauncherIcon(w.get());
 }
 
 // Tests that panels will hide and restore their state with the shelf visibility
 // state. This ensures that entering full-screen mode will hide your panels
 // until you leave it.
 TEST_F(PanelLayoutManagerTest, PanelsHideAndRestoreWithShelf) {
   gfx::Rect bounds(0, 0, 201, 201);
 
-  scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
-  scoped_ptr<aura::Window> w3;
+  std::unique_ptr<aura::Window> w1(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w2(CreatePanelWindow(bounds));
+  std::unique_ptr<aura::Window> w3;
   // Minimize w2.
   wm::GetWindowState(w2.get())->Minimize();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_FALSE(w2->IsVisible());
 
   SetShelfVisibilityState(Shell::GetPrimaryRootWindow(), SHELF_HIDDEN);
   RunAllPendingInMessageLoop();
 
   // w3 is created while in full-screen mode, should only become visible when
@@ skipping 25 matching lines @@
   // Windows should be restored to their prior state.
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_FALSE(w2->IsVisible());
   EXPECT_TRUE(w3->IsVisible());
 }
 
 // Verifies that touches along the attached edge of a panel do not
 // target the panel itself.
 TEST_F(PanelLayoutManagerTest, TouchHitTestPanel) {
   aura::test::TestWindowDelegate delegate;
-  scoped_ptr<aura::Window> w(
+  std::unique_ptr<aura::Window> w(
       CreatePanelWindowWithDelegate(&delegate, gfx::Rect(0, 0, 200, 200)));
   ui::EventTarget* root = w->GetRootWindow();
   ui::EventTargeter* targeter = root->GetEventTargeter();
 
   // Note that the constants used in the touch locations below are
   // arbitrarily-selected small numbers which will ensure the point is
   // within the default extended region surrounding the panel. This value
   // is calculated as
   // kResizeOutsideBoundsSize * kResizeOutsideBoundsScaleForTouch
   // in src/ash/root_window_controller.cc.
@@ skipping 34 matching lines @@
   // Hit test outside the left edge with a left-aligned shelf.
   touch.set_location(gfx::Point(bounds.x() - 1, bounds.y() + 5));
   target = targeter->FindTargetForEvent(root, &touch);
   EXPECT_NE(w.get(), target);
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, PanelLayoutManagerTextDirectionTest,
                         testing::Bool());
 
 }  // namespace ash