Replace scoped_ptr with std::unique_ptr in //ui

ui/views/controls/button/menu_button_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 "ui/views/controls/button/menu_button.h"
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/animation/test/test_ink_drop_delegate.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
@@ skipping 78 matching lines @@
 
     widget_ = new Widget;
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     widget_->Init(params);
   }
 
   Widget* widget_;
   TestMenuButton* button_;
-  scoped_ptr<ui::test::EventGenerator> generator_;
+  std::unique_ptr<ui::test::EventGenerator> generator_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuButtonTest);
 };
 
 class TestButtonListener : public ButtonListener {
  public:
   TestButtonListener()
       : last_sender_(nullptr),
         last_sender_state_(Button::STATE_NORMAL),
         last_event_type_(ui::ET_UNKNOWN) {}
@@ skipping 59 matching lines @@
                            const gfx::Point& point,
                            const ui::Event* event) override {
     pressed_lock_.reset(new MenuButton::PressedLock(menu_button_));
     if (release_lock_)
       pressed_lock_.reset();
   }
 
  private:
   MenuButton* menu_button_;
 
-  scoped_ptr<MenuButton::PressedLock> pressed_lock_;
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock_;
 
   // The |pressed_lock_| will be released when true.
   bool release_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PressStateMenuButtonListener);
 };
 
 // Basic implementation of a DragController, to test input behaviour for
 // MenuButtons that can be dragged.
 class TestDragController : public DragController {
@@ skipping 144 matching lines @@
 
 // Test that the MenuButton stays pressed while there are any PressedLocks.
 TEST_F(MenuButtonTest, ButtonStateForMenuButtonsWithPressedLocks) {
   CreateMenuButtonWithNoListener();
 
   // Move the mouse over the button; the button should be in a hovered state.
   generator()->MoveMouseTo(gfx::Point(10, 10));
   EXPECT_EQ(Button::STATE_HOVERED, button()->state());
 
   // Introduce a PressedLock, which should make the button pressed.
-  scoped_ptr<MenuButton::PressedLock> pressed_lock1(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Even if we move the mouse outside of the button, it should remain pressed.
   generator()->MoveMouseTo(gfx::Point(300, 10));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Creating a new lock should obviously keep the button pressed.
-  scoped_ptr<MenuButton::PressedLock> pressed_lock2(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // The button should remain pressed while any locks are active.
   pressed_lock1.reset();
   EXPECT_EQ(Button::STATE_PRESSED, button()->state());
 
   // Reseting the final lock should return the button's state to normal...
   pressed_lock2.reset();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
@@ skipping 104 matching lines @@
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop_delegate.state());
 }
 
 TEST_F(MenuButtonTest, InkDropStateForMenuButtonsWithPressedLocks) {
   CreateMenuButtonWithNoListener();
   TestInkDropDelegate ink_drop_delegate;
   button()->set_ink_drop_delegate(&ink_drop_delegate);
 
-  scoped_ptr<MenuButton::PressedLock> pressed_lock1(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
 
-  scoped_ptr<MenuButton::PressedLock> pressed_lock2(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
 
   pressed_lock1.reset();
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
 
   pressed_lock2.reset();
   EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop_delegate.state());
 }
 
 // Verifies only one ink drop animation is triggered when multiple PressedLocks
 // are attached to a MenuButton.
 TEST_F(MenuButtonTest, OneInkDropAnimationForReentrantPressedLocks) {
   CreateMenuButtonWithNoListener();
   TestInkDropDelegate ink_drop_delegate;
   button()->set_ink_drop_delegate(&ink_drop_delegate);
 
-  scoped_ptr<MenuButton::PressedLock> pressed_lock1(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTIVATED, ink_drop_delegate.state());
   ink_drop_delegate.OnAction(InkDropState::ACTION_PENDING);
 
-  scoped_ptr<MenuButton::PressedLock> pressed_lock2(
+  std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
   EXPECT_EQ(InkDropState::ACTION_PENDING, ink_drop_delegate.state());
 }
 
 // Verifies the InkDropState is left as ACTIVATED if a PressedLock is active
 // before another Activation occurs.
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonWithPressedLockBeforeActivation) {
   TestMenuButtonListener menu_button_listener;
@@ skipping 76 matching lines @@
   generator()->MoveTouch(gfx::Point(10, 30));
   generator()->ReleaseTouch();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 }
 
 #endif  // !defined(OS_MACOSX) || defined(USE_AURA)
 
 }  // namespace views
 }  // namespace test