Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/immersive_fullscreen_controller_unittest.cc

 // Copyright 2013 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/immersive_fullscreen_controller.h"
 
 #include "ash/display/display_manager.h"
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 232 matching lines @@
         views::View::ConvertPointToScreen(top_container_, &end);
         ui::test::EventGenerator& event_generator(GetEventGenerator());
         event_generator.GestureScrollSequence(
             start, end,
             base::TimeDelta::FromMilliseconds(30), 1);
         break;
       }
     }
   }
 
-  scoped_ptr<ImmersiveFullscreenController> controller_;
-  scoped_ptr<MockImmersiveFullscreenControllerDelegate> delegate_;
+  std::unique_ptr<ImmersiveFullscreenController> controller_;
+  std::unique_ptr<MockImmersiveFullscreenControllerDelegate> delegate_;
   views::Widget* widget_;  // Owned by the native widget.
   views::View* top_container_;  // Owned by |widget_|'s root-view.
   views::NativeViewHost* content_view_;  // Owned by |widget_|'s root-view.
 
   DISALLOW_COPY_AND_ASSIGN(ImmersiveFullscreenControllerTest);
 };
 
 // Test the initial state and that the delegate gets notified of the
 // top-of-window views getting hidden and revealed.
 TEST_F(ImmersiveFullscreenControllerTest, Delegate) {
@@ skipping 18 matching lines @@
 
   // Disabling ends the immersive reveal.
   SetEnabled(false);
   EXPECT_FALSE(controller()->IsEnabled());
   EXPECT_FALSE(controller()->IsRevealed());
   EXPECT_FALSE(delegate()->is_enabled());
 }
 
 // GetRevealedLock() specific tests.
 TEST_F(ImmersiveFullscreenControllerTest, RevealedLock) {
-  scoped_ptr<ImmersiveRevealedLock> lock1;
-  scoped_ptr<ImmersiveRevealedLock> lock2;
+  std::unique_ptr<ImmersiveRevealedLock> lock1;
+  std::unique_ptr<ImmersiveRevealedLock> lock2;
 
   // Immersive fullscreen is not on by default.
   EXPECT_FALSE(controller()->IsEnabled());
 
   // 1) Test acquiring and releasing a revealed state lock while immersive
   // fullscreen is disabled. Acquiring or releasing the lock should have no
   // effect till immersive fullscreen is enabled.
   lock1.reset(controller()->GetRevealedLock(
       ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
   EXPECT_FALSE(controller()->IsEnabled());
@@ skipping 272 matching lines @@
   ASSERT_FALSE(top_container()->GetBoundsInScreen().Intersects(
       popup_widget->GetWindowBoundsInScreen()));
   event_generator.MoveMouseTo(x, y_top_edge + 1);
   MoveMouse(x, y_top_edge - 2);
   EXPECT_TRUE(controller()->IsRevealed());
 }
 
 // Test behavior when the mouse becomes hovered without moving.
 TEST_F(ImmersiveFullscreenControllerTest, MouseHoveredWithoutMoving) {
   SetEnabled(true);
-  scoped_ptr<ImmersiveRevealedLock> lock;
+  std::unique_ptr<ImmersiveRevealedLock> lock;
 
   // 1) Test that if the mouse becomes hovered without the mouse moving due to a
   // lock causing the top-of-window views to be revealed (and the mouse
   // happening to be near the top of the screen), the top-of-window views do not
   // hide till the mouse moves off of the top-of-window views.
   SetHovered(true);
   EXPECT_FALSE(controller()->IsRevealed());
   lock.reset(controller()->GetRevealedLock(
       ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
   EXPECT_TRUE(controller()->IsRevealed());
@@ skipping 89 matching lines @@
   EXPECT_FALSE(controller()->IsRevealed());
 
   // The top-of-window views should no longer have focus. Clearing focus is
   // important because it closes focus-related popup windows like the touch
   // selection handles.
   EXPECT_FALSE(top_container()->HasFocus());
 
   // If some other code is holding onto a lock, a gesture should not be able to
   // end the reveal.
   AttemptReveal(MODALITY_MOUSE);
-  scoped_ptr<ImmersiveRevealedLock> lock(controller()->GetRevealedLock(
+  std::unique_ptr<ImmersiveRevealedLock> lock(controller()->GetRevealedLock(
       ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
   EXPECT_TRUE(controller()->IsRevealed());
   AttemptUnreveal(MODALITY_GESTURE_SCROLL);
   EXPECT_TRUE(controller()->IsRevealed());
   lock.reset();
   EXPECT_FALSE(controller()->IsRevealed());
 }
 
 // Tests that touch-gesture can be used to reveal the top-of-window views when
 // the child window consumes all events.
 TEST_F(ImmersiveFullscreenControllerTest, RevealViaGestureChildConsumesEvents) {
   // Enabling initially hides the top views.
   SetEnabled(true);
   EXPECT_TRUE(controller()->IsEnabled());
   EXPECT_FALSE(controller()->IsRevealed());
 
   aura::test::TestWindowDelegate child_delegate;
-  scoped_ptr<aura::Window> child(
-      CreateTestWindowInShellWithDelegateAndType(&child_delegate,
-                                                 ui::wm::WINDOW_TYPE_CONTROL,
-                                                 1234,
-                                                 gfx::Rect()));
+  std::unique_ptr<aura::Window> child(
+      CreateTestWindowInShellWithDelegateAndType(
+          &child_delegate, ui::wm::WINDOW_TYPE_CONTROL, 1234, gfx::Rect()));
   content_view()->Attach(child.get());
   child->Show();
 
   ConsumeEventHandler handler;
   child->AddPreTargetHandler(&handler);
 
   // Reveal the top views using a touch-scroll gesture. The child window should
   // not receive the touch events.
   AttemptReveal(MODALITY_GESTURE_SCROLL);
   EXPECT_TRUE(controller()->IsRevealed());
   EXPECT_EQ(0, handler.num_touch_events());
 
   AttemptUnreveal(MODALITY_GESTURE_TAP);
   EXPECT_FALSE(controller()->IsRevealed());
   EXPECT_GT(handler.num_touch_events(), 0);
   child->RemovePreTargetHandler(&handler);
 }
 
 // Make sure touch events towards the top of the window do not leak through to
 // windows underneath.
 TEST_F(ImmersiveFullscreenControllerTest, EventsDoNotLeakToWindowUnderneath) {
   gfx::Rect window_bounds = window()->GetBoundsInScreen();
   aura::test::TestWindowDelegate child_delegate;
-  scoped_ptr<aura::Window> behind(CreateTestWindowInShellWithDelegate(
+  std::unique_ptr<aura::Window> behind(CreateTestWindowInShellWithDelegate(
       &child_delegate, 1234, window_bounds));
   behind->Show();
   behind->SetBounds(window_bounds);
   widget()->StackAbove(behind.get());
 
   // Make sure the windows are aligned on top.
   EXPECT_EQ(behind->GetBoundsInScreen().y(), window()->GetBoundsInScreen().y());
   int top = behind->GetBoundsInScreen().y();
 
   ui::TouchEvent touch(ui::ET_TOUCH_MOVED, gfx::Point(10, top), 0,
@@ skipping 79 matching lines @@
   EXPECT_FALSE(controller()->IsRevealed());
   unrelated_view->RequestFocus();
   SetEnabled(true);
   EXPECT_FALSE(controller()->IsRevealed());
 
   // Repeat test but with a revealed lock acquired when immersive mode is
   // disabled because the code path is different.
   child_view->RequestFocus();
   EXPECT_TRUE(controller()->IsRevealed());
   SetEnabled(false);
-  scoped_ptr<ImmersiveRevealedLock> lock(controller()->GetRevealedLock(
+  std::unique_ptr<ImmersiveRevealedLock> lock(controller()->GetRevealedLock(
       ImmersiveFullscreenController::ANIMATE_REVEAL_NO));
   EXPECT_FALSE(controller()->IsRevealed());
   unrelated_view->RequestFocus();
   SetEnabled(true);
   EXPECT_TRUE(controller()->IsRevealed());
   lock.reset();
   EXPECT_FALSE(controller()->IsRevealed());
 }
 
 // Test how transient windows affect whether the top-of-window views are
 // revealed.
 TEST_F(ImmersiveFullscreenControllerTest, Transient) {
   views::Widget* top_container_widget = top_container()->GetWidget();
 
   SetEnabled(true);
   ASSERT_FALSE(controller()->IsRevealed());
 
   // 1) Test that a transient window which is not a bubble does not trigger a
   // reveal but does keep the top-of-window views revealed if they are already
   // revealed.
   views::Widget::InitParams transient_params;
   transient_params.ownership =
       views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   transient_params.parent = top_container_widget->GetNativeView();
   transient_params.bounds = gfx::Rect(0, 100, 100, 100);
-  scoped_ptr<views::Widget> transient_widget(new views::Widget());
+  std::unique_ptr<views::Widget> transient_widget(new views::Widget());
   transient_widget->Init(transient_params);
 
   EXPECT_FALSE(controller()->IsRevealed());
   AttemptReveal(MODALITY_MOUSE);
   EXPECT_TRUE(controller()->IsRevealed());
   transient_widget->Show();
   SetHovered(false);
   EXPECT_TRUE(controller()->IsRevealed());
   transient_widget.reset();
   EXPECT_FALSE(controller()->IsRevealed());
 
   // 2) Test that activating a non-transient window does not keep the
   // top-of-window views revealed.
   views::Widget::InitParams non_transient_params;
   non_transient_params.ownership =
       views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   non_transient_params.context = top_container_widget->GetNativeView();
   non_transient_params.bounds = gfx::Rect(0, 100, 100, 100);
-  scoped_ptr<views::Widget> non_transient_widget(new views::Widget());
+  std::unique_ptr<views::Widget> non_transient_widget(new views::Widget());
   non_transient_widget->Init(non_transient_params);
 
   EXPECT_FALSE(controller()->IsRevealed());
   AttemptReveal(MODALITY_MOUSE);
   EXPECT_TRUE(controller()->IsRevealed());
   non_transient_widget->Show();
   SetHovered(false);
   EXPECT_FALSE(controller()->IsRevealed());
 }
 
 // Test how bubbles affect whether the top-of-window views are revealed.
 TEST_F(ImmersiveFullscreenControllerTest, Bubbles) {
-  scoped_ptr<ImmersiveRevealedLock> revealed_lock;
+  std::unique_ptr<ImmersiveRevealedLock> revealed_lock;
   views::Widget* top_container_widget = top_container()->GetWidget();
 
   // Add views to the view hierarchy to which we will anchor bubbles.
   views::View* child_view = new views::View();
   child_view->SetBounds(0, 0, 10, 10);
   top_container()->AddChildView(child_view);
   views::View* unrelated_view = new views::View();
   unrelated_view->SetBounds(0, 100, 10, 10);
   top_container()->parent()->AddChildView(unrelated_view);
 
@@ skipping 143 matching lines @@
   EXPECT_EQ(ash::SHELF_AUTO_HIDE, shelf->visibility_state());
 
   // Disabling immersive fullscreen maintains the user's auto-hide selection.
   SetEnabled(false);
   window()->SetProperty(aura::client::kShowStateKey,
                         ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(ash::SHELF_AUTO_HIDE, shelf->visibility_state());
 }
 
 }  // namespase ash