Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/system_modal_container_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/system_modal_container_layout_manager.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 177 matching lines @@
     } else {
       keyboard->HideKeyboard(keyboard::KeyboardController::HIDE_REASON_MANUAL);
     }
 
     DCHECK_EQ(show, keyboard->keyboard_visible());
   }
 
 };
 
 TEST_F(SystemModalContainerLayoutManagerTest, NonModalTransient) {
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
   aura::Window* transient = OpenTestWindowWithParent(parent.get(), false);
   TransientWindowObserver destruction_observer;
   transient->AddObserver(&destruction_observer);
 
   EXPECT_EQ(parent.get(), ::wm::GetTransientParent(transient));
   EXPECT_EQ(parent->parent(), transient->parent());
 
   // The transient should be destroyed with its parent.
   parent.reset();
   EXPECT_TRUE(destruction_observer.destroyed());
 }
 
 TEST_F(SystemModalContainerLayoutManagerTest, ModalTransient) {
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
   // parent should be active.
   EXPECT_TRUE(wm::IsActiveWindow(parent.get()));
   aura::Window* t1 = OpenTestWindowWithParent(parent.get(), true);
 
   TransientWindowObserver do1;
   t1->AddObserver(&do1);
 
   EXPECT_EQ(parent.get(), ::wm::GetTransientParent(t1));
   EXPECT_EQ(GetModalContainer(), t1->parent());
 
@@ skipping 20 matching lines @@
   e2.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(t2));
 
   // Both transients should be destroyed with parent.
   parent.reset();
   EXPECT_TRUE(do1.destroyed());
   EXPECT_TRUE(do2.destroyed());
 }
 
 TEST_F(SystemModalContainerLayoutManagerTest, ModalNonTransient) {
-  scoped_ptr<aura::Window> t1(OpenToplevelTestWindow(true));
+  std::unique_ptr<aura::Window> t1(OpenToplevelTestWindow(true));
   // parent should be active.
   EXPECT_TRUE(wm::IsActiveWindow(t1.get()));
   TransientWindowObserver do1;
   t1->AddObserver(&do1);
 
   EXPECT_EQ(NULL, ::wm::GetTransientParent(t1.get()));
   EXPECT_EQ(GetModalContainer(), t1->parent());
 
   // t1 should now be active.
   EXPECT_TRUE(wm::IsActiveWindow(t1.get()));
@@ skipping 21 matching lines @@
 
   // Both transients should be destroyed with parent.
   t1.reset();
   EXPECT_TRUE(do1.destroyed());
   EXPECT_TRUE(do2.destroyed());
 }
 
 // Tests that we can activate an unrelated window after a modal window is closed
 // for a window.
 TEST_F(SystemModalContainerLayoutManagerTest, CanActivateAfterEndModalSession) {
-  scoped_ptr<aura::Window> unrelated(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> unrelated(OpenToplevelTestWindow(false));
   unrelated->SetBounds(gfx::Rect(100, 100, 50, 50));
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
   // parent should be active.
   EXPECT_TRUE(wm::IsActiveWindow(parent.get()));
 
-  scoped_ptr<aura::Window> transient(
+  std::unique_ptr<aura::Window> transient(
       OpenTestWindowWithParent(parent.get(), true));
   // t1 should now be active.
   EXPECT_TRUE(wm::IsActiveWindow(transient.get()));
 
   // Attempting to click the parent should result in no activation change.
   ui::test::EventGenerator e1(Shell::GetPrimaryRootWindow(), parent.get());
   e1.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(transient.get()));
 
   // Now close the transient.
   transient->Hide();
   TestWindow::CloseTestWindow(transient.release());
 
   base::RunLoop().RunUntilIdle();
 
   // parent should now be active again.
   EXPECT_TRUE(wm::IsActiveWindow(parent.get()));
 
   // Attempting to click unrelated should activate it.
   ui::test::EventGenerator e2(Shell::GetPrimaryRootWindow(), unrelated.get());
   e2.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(unrelated.get()));
 }
 
 TEST_F(SystemModalContainerLayoutManagerTest, EventFocusContainers) {
   // Create a normal window and attempt to receive a click event.
   EventTestWindow* main_delegate = new EventTestWindow(false);
-  scoped_ptr<aura::Window> main(
+  std::unique_ptr<aura::Window> main(
       main_delegate->OpenTestWindowWithContext(CurrentContext()));
   EXPECT_TRUE(wm::IsActiveWindow(main.get()));
   ui::test::EventGenerator e1(Shell::GetPrimaryRootWindow(), main.get());
   e1.ClickLeftButton();
   EXPECT_EQ(1, main_delegate->mouse_presses());
 
   // Create a modal window for the main window and verify that the main window
   // no longer receives mouse events.
   EventTestWindow* transient_delegate = new EventTestWindow(true);
   aura::Window* transient =
       transient_delegate->OpenTestWindowWithParent(main.get());
   EXPECT_TRUE(wm::IsActiveWindow(transient));
   e1.ClickLeftButton();
   EXPECT_EQ(1, transient_delegate->mouse_presses());
 
   for (int block_reason = FIRST_BLOCK_REASON;
        block_reason < NUMBER_OF_BLOCK_REASONS;
        ++block_reason) {
     // Create a window in the lock screen container and ensure that it receives
     // the mouse event instead of the modal window (crbug.com/110920).
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     EventTestWindow* lock_delegate = new EventTestWindow(false);
-    scoped_ptr<aura::Window> lock(lock_delegate->OpenTestWindowWithParent(
+    std::unique_ptr<aura::Window> lock(lock_delegate->OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
             ash::kShellWindowId_LockScreenContainer)));
     EXPECT_TRUE(wm::IsActiveWindow(lock.get()));
     e1.ClickLeftButton();
     EXPECT_EQ(1, lock_delegate->mouse_presses());
 
     // Make sure that a modal container created by the lock screen can still
     // receive mouse events.
     EventTestWindow* lock_modal_delegate = new EventTestWindow(true);
     aura::Window* lock_modal =
@@ skipping 12 matching lines @@
 // Makes sure we don't crash if a modal window is shown while the parent window
 // is hidden.
 TEST_F(SystemModalContainerLayoutManagerTest, ShowModalWhileHidden) {
   // Hide the lock screen.
   Shell::GetPrimaryRootWindowController()
       ->GetContainer(kShellWindowId_SystemModalContainer)
       ->layer()
       ->SetOpacity(0);
 
   // Create a modal window.
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   parent->Show();
   modal_window->Show();
 }
 
 // Verifies we generate a capture lost when showing a modal window.
 TEST_F(SystemModalContainerLayoutManagerTest, ChangeCapture) {
   views::Widget* widget = views::Widget::CreateWindowWithContext(
       new TestWindow(false), CurrentContext());
-  scoped_ptr<aura::Window> widget_window(widget->GetNativeView());
+  std::unique_ptr<aura::Window> widget_window(widget->GetNativeView());
   views::test::CaptureTrackingView* view = new views::test::CaptureTrackingView;
   widget->GetContentsView()->AddChildView(view);
   view->SetBoundsRect(widget->GetContentsView()->bounds());
   widget->Show();
 
   gfx::Point center(view->width() / 2, view->height() / 2);
   views::View::ConvertPointToScreen(view, &center);
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), center);
   generator.PressLeftButton();
   EXPECT_TRUE(view->got_press());
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(widget->GetNativeView(), true));
   modal_window->Show();
   EXPECT_TRUE(view->got_capture_lost());
 }
 
 // Verifies that the window gets moved into the visible screen area upon screen
 // resize.
 TEST_F(SystemModalContainerLayoutManagerTest, KeepVisible) {
   GetModalContainer()->SetBounds(gfx::Rect(0, 0, 1024, 768));
-  scoped_ptr<aura::Window> main(OpenTestWindowWithParent(GetModalContainer(),
-                                                         true));
+  std::unique_ptr<aura::Window> main(
+      OpenTestWindowWithParent(GetModalContainer(), true));
   main->SetBounds(gfx::Rect(924, 668, 100, 100));
   // We set now the bounds of the root window to something new which will
   // Then trigger the repos operation.
   GetModalContainer()->SetBounds(gfx::Rect(0, 0, 800, 600));
 
   gfx::Rect bounds = main->bounds();
   EXPECT_EQ(bounds, gfx::Rect(700, 500, 100, 100));
 }
 
 // Verifies that centered windows will remain centered after the visible screen
 // area changed.
 TEST_F(SystemModalContainerLayoutManagerTest, KeepCentered) {
   GetModalContainer()->SetBounds(gfx::Rect(0, 0, 800, 600));
-  scoped_ptr<aura::Window> main(OpenTestWindowWithParent(GetModalContainer(),
-                                                         true));
+  std::unique_ptr<aura::Window> main(
+      OpenTestWindowWithParent(GetModalContainer(), true));
   // Center the window.
   main->SetBounds(gfx::Rect((800 - 512) / 2, (600 - 256) / 2, 512, 256));
 
   // We set now the bounds of the root window to something new which will
   // Then trigger the reposition operation.
   GetModalContainer()->SetBounds(gfx::Rect(0, 0, 1024, 768));
 
   // The window should still be centered.
   gfx::Rect bounds = main->bounds();
   EXPECT_EQ(bounds.ToString(), gfx::Rect(256, 256, 512, 256).ToString());
 }
 
 TEST_F(SystemModalContainerLayoutManagerTest, ShowNormalBackgroundOrLocked) {
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   parent->Show();
   modal_window->Show();
 
   // Normal system modal window.  Shows normal system modal background and not
   // locked.
   EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
 
   TestWindow::CloseTestWindow(modal_window.release());
   EXPECT_FALSE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
 
   for (int block_reason = FIRST_BLOCK_REASON;
        block_reason < NUMBER_OF_BLOCK_REASONS;
        ++block_reason) {
     // Normal system modal window while blocked.  Shows blocked system modal
     // background.
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
-    scoped_ptr<aura::Window> lock_parent(OpenTestWindowWithParent(
+    std::unique_ptr<aura::Window> lock_parent(OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
             ash::kShellWindowId_LockScreenContainer),
         false));
-    scoped_ptr<aura::Window> lock_modal_window(OpenTestWindowWithParent(
-        lock_parent.get(), true));
+    std::unique_ptr<aura::Window> lock_modal_window(
+        OpenTestWindowWithParent(lock_parent.get(), true));
     lock_parent->Show();
     lock_modal_window->Show();
     EXPECT_FALSE(AllRootWindowsHaveModalBackgrounds());
     EXPECT_TRUE(AllRootWindowsHaveLockedModalBackgrounds());
     TestWindow::CloseTestWindow(lock_modal_window.release());
 
     // Normal system modal window while blocked, but it belongs to the normal
     // window.  Shouldn't show blocked system modal background, but normal.
-    scoped_ptr<aura::Window> modal_window(
+    std::unique_ptr<aura::Window> modal_window(
         OpenTestWindowWithParent(parent.get(), true));
     modal_window->Show();
     EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
     EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
     TestWindow::CloseTestWindow(modal_window.release());
     UnblockUserSession();
     // Here we should check the behavior of the locked system modal dialog when
     // unlocked, but such case isn't handled very well right now.
     // See crbug.com/157660
     // TODO(mukai): add the test case when the bug is fixed.
   }
 }
 
 TEST_F(SystemModalContainerLayoutManagerTest, MultiDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("500x500,500x500");
 
-  scoped_ptr<aura::Window> normal(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> normal(OpenToplevelTestWindow(false));
   normal->SetBounds(gfx::Rect(100, 100, 50, 50));
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(2U, root_windows.size());
   aura::Window* container1 = Shell::GetContainer(
       root_windows[0], ash::kShellWindowId_SystemModalContainer);
   aura::Window* container2 = Shell::GetContainer(
       root_windows[1], ash::kShellWindowId_SystemModalContainer);
 
-  scoped_ptr<aura::Window> modal1(
+  std::unique_ptr<aura::Window> modal1(
       OpenTestWindowWithParent(container1, true));
   EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_TRUE(wm::IsActiveWindow(modal1.get()));
 
-  scoped_ptr<aura::Window> modal11(
+  std::unique_ptr<aura::Window> modal11(
       OpenTestWindowWithParent(container1, true));
   EXPECT_TRUE(wm::IsActiveWindow(modal11.get()));
 
-  scoped_ptr<aura::Window> modal2(
+  std::unique_ptr<aura::Window> modal2(
       OpenTestWindowWithParent(container2, true));
   EXPECT_TRUE(wm::IsActiveWindow(modal2.get()));
 
   // Sanity check if they're on the correct containers.
   EXPECT_EQ(container1, modal1->parent());
   EXPECT_EQ(container1, modal11->parent());
   EXPECT_EQ(container2, modal2->parent());
 
   TestWindow::CloseTestWindow(modal2.release());
   EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
@@ skipping 24 matching lines @@
        SystemModalDialogGetPushedFromKeyboard) {
   const gfx::Rect& container_bounds = GetModalContainer()->bounds();
   // Place the window at the bottom of the screen.
   gfx::Size modal_size(100, 100);
   gfx::Point modal_origin = gfx::Point(
       (container_bounds.right() - modal_size.width()) / 2,  // X centered
       container_bounds.bottom() - modal_size.height());     // at bottom
   gfx::Rect modal_bounds = gfx::Rect(modal_origin, modal_size);
 
   // Create a modal window.
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   modal_window->SetBounds(modal_bounds);
   parent->Show();
   modal_window->Show();
 
   EXPECT_EQ(modal_bounds.ToString(), modal_window->bounds().ToString());
 
   // The keyboard gets shown and the dialog should get pushed.
   ShowKeyboard(true);
   EXPECT_NE(modal_bounds.ToString(), modal_window->bounds().ToString());
@@ skipping 15 matching lines @@
   const gfx::Rect& container_bounds = GetModalContainer()->bounds();
   const gfx::Size screen_size = Shell::GetPrimaryRootWindow()->bounds().size();
   // Place the window at the bottom of the screen.
   gfx::Size modal_size(100, screen_size.height() - 70);
   gfx::Point modal_origin = gfx::Point(
       (container_bounds.right() - modal_size.width()) / 2,  // X centered
       container_bounds.bottom() - modal_size.height());     // at bottom
   gfx::Rect modal_bounds = gfx::Rect(modal_origin, modal_size);
 
   // Create a modal window.
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   modal_window->SetBounds(modal_bounds);
   parent->Show();
   modal_window->Show();
 
   EXPECT_EQ(modal_bounds.ToString(), modal_window->bounds().ToString());
 
   // The keyboard gets shown and the dialog should get pushed up, but not get
   // cropped (and aligned to the top).
   ShowKeyboard(true);
   EXPECT_EQ(modal_size.ToString(), modal_window->bounds().size().ToString());
   EXPECT_EQ(modal_origin.x(), modal_window->bounds().x());
   EXPECT_EQ(0, modal_window->bounds().y());
 
   ShowKeyboard(false);
 }
 
 // Test that windows will not get cropped through the visible virtual keyboard -
 // if not centered.
 TEST_F(SystemModalContainerLayoutManagerTest,
        SystemModalDialogGetPushedButNotCroppedFromKeyboardIfNotCentered) {
   const gfx::Size screen_size = Shell::GetPrimaryRootWindow()->bounds().size();
   // Place the window at the bottom of the screen.
   gfx::Size modal_size(100, screen_size.height() - 70);
   gfx::Point modal_origin = gfx::Point(10, 20);
   gfx::Rect modal_bounds = gfx::Rect(modal_origin, modal_size);
 
   // Create a modal window.
-  scoped_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
-  scoped_ptr<aura::Window> modal_window(
+  std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
+  std::unique_ptr<aura::Window> modal_window(
       OpenTestWindowWithParent(parent.get(), true));
   modal_window->SetBounds(modal_bounds);
   parent->Show();
   modal_window->Show();
 
   EXPECT_EQ(modal_bounds.ToString(), modal_window->bounds().ToString());
 
   // The keyboard gets shown and the dialog should get pushed up, but not get
   // cropped (and aligned to the top).
   ShowKeyboard(true);
   EXPECT_EQ(modal_size.ToString(), modal_window->bounds().size().ToString());
   EXPECT_EQ(modal_origin.x(), modal_window->bounds().x());
   EXPECT_EQ(0, modal_window->bounds().y());
 
   ShowKeyboard(false);
 }
 
 }  // namespace test
 }  // namespace ash