Replace scoped_ptr with std::unique_ptr in //ui

ui/views/controls/menu/menu_controller_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/menu/menu_controller.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 158 matching lines @@
 
  private:
   int outstanding_touches_;
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
 // A wrapper around MenuMessageLoop that can be used to track whether a message
 // loop is running or not.
 class TestMenuMessageLoop : public MenuMessageLoop {
  public:
-  explicit TestMenuMessageLoop(scoped_ptr<MenuMessageLoop> original);
+  explicit TestMenuMessageLoop(std::unique_ptr<MenuMessageLoop> original);
   ~TestMenuMessageLoop() override;
 
   bool is_running() const { return is_running_; }
 
  private:
   // MenuMessageLoop:
   void Run(MenuController* controller,
            Widget* owner,
            bool nested_menu) override;
   void QuitNow() override;
   void ClearOwner() override;
 
-  scoped_ptr<MenuMessageLoop> original_;
+  std::unique_ptr<MenuMessageLoop> original_;
   bool is_running_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMenuMessageLoop);
 };
 
-TestMenuMessageLoop::TestMenuMessageLoop(scoped_ptr<MenuMessageLoop> original)
+TestMenuMessageLoop::TestMenuMessageLoop(
+    std::unique_ptr<MenuMessageLoop> original)
     : original_(std::move(original)) {
   DCHECK(original_);
 }
 
 TestMenuMessageLoop::~TestMenuMessageLoop() {}
 
 void TestMenuMessageLoop::Run(MenuController* controller,
                               Widget* owner,
                               bool nested_menu) {
   is_running_ = true;
@@ skipping 53 matching lines @@
     event_generator_->PressKey(key_code, 0);
   }
 
 #if defined(OS_LINUX) && defined(USE_X11)
   void TestEventTargeter() {
     {
       // With the |ui::NullEventTargeter| instantiated and assigned we expect
       // the menu to not handle the key event.
       aura::ScopedWindowTargeter scoped_targeter(
           owner()->GetNativeWindow()->GetRootWindow(),
-          scoped_ptr<ui::EventTargeter>(new ui::NullEventTargeter));
+          std::unique_ptr<ui::EventTargeter>(new ui::NullEventTargeter));
       event_generator_->PressKey(ui::VKEY_ESCAPE, 0);
       EXPECT_EQ(MenuController::EXIT_NONE, menu_exit_type());
     }
     // Now that the targeter has been destroyed, expect to exit the menu
     // normally when hitting escape.
     event_generator_->PressKey(ui::VKEY_ESCAPE, 0);
     EXPECT_EQ(MenuController::EXIT_OUTERMOST, menu_exit_type());
   }
 #endif  // defined(OS_LINUX) && defined(USE_X11)
 
   void TestAsynchronousNestedExitAll() {
     ASSERT_TRUE(test_message_loop_->is_running());
 
-    scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+    std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
         new TestMenuControllerDelegate());
 
     menu_controller()->AddNestedDelegate(nested_delegate.get());
     menu_controller()->SetAsyncRun(true);
 
     int mouse_event_flags = 0;
     MenuItemView* run_result = menu_controller()->Run(
         owner(), nullptr, menu_item(), gfx::Rect(), MENU_ANCHOR_TOPLEFT, false,
         false, &mouse_event_flags);
     EXPECT_EQ(run_result, nullptr);
 
     // Exit all menus and check that the parent menu's message loop is
     // terminated.
     menu_controller()->Cancel(MenuController::EXIT_ALL);
     EXPECT_EQ(MenuController::EXIT_ALL, menu_controller()->exit_type());
     EXPECT_FALSE(test_message_loop_->is_running());
   }
 
   void TestAsynchronousNestedExitOutermost() {
     ASSERT_TRUE(test_message_loop_->is_running());
 
-    scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+    std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
         new TestMenuControllerDelegate());
 
     menu_controller()->AddNestedDelegate(nested_delegate.get());
     menu_controller()->SetAsyncRun(true);
 
     int mouse_event_flags = 0;
     MenuItemView* run_result = menu_controller()->Run(
         owner(), nullptr, menu_item(), gfx::Rect(), MENU_ANCHOR_TOPLEFT, false,
         false, &mouse_event_flags);
     EXPECT_EQ(run_result, nullptr);
@@ skipping 90 matching lines @@
   }
 
   // Note that coordinates of events passed to MenuController must be in that of
   // the MenuScrollViewContainer.
   void ProcessMouseMoved(SubmenuView* source, const ui::MouseEvent& event) {
     menu_controller_->OnMouseMoved(source, event);
   }
 
   void RunMenu() {
 #if defined(USE_AURA)
-    scoped_ptr<MenuKeyEventHandler> key_event_handler(new MenuKeyEventHandler);
+    std::unique_ptr<MenuKeyEventHandler> key_event_handler(
+        new MenuKeyEventHandler);
 #endif
 
     menu_controller_->message_loop_depth_++;
     menu_controller_->RunMessageLoop(false);
     menu_controller_->message_loop_depth_--;
   }
 
   void Accept(MenuItemView* item, int event_flags) {
     menu_controller_->Accept(item, event_flags);
   }
@@ skipping 84 matching lines @@
     menu_controller_delegate_.reset(new TestMenuControllerDelegate);
     menu_controller_ =
         new MenuController(true, menu_controller_delegate_.get());
     menu_controller_->owner_ = owner_.get();
     menu_controller_->showing_ = true;
     menu_controller_->SetSelection(
         menu_item_.get(), MenuController::SELECTION_UPDATE_IMMEDIATELY);
     menu_item_->SetController(menu_controller_);
   }
 
-  scoped_ptr<Widget> owner_;
-  scoped_ptr<ui::test::EventGenerator> event_generator_;
-  scoped_ptr<TestMenuItemViewShown> menu_item_;
-  scoped_ptr<TestMenuControllerDelegate> menu_controller_delegate_;
-  scoped_ptr<MenuDelegate> menu_delegate_;
+  std::unique_ptr<Widget> owner_;
+  std::unique_ptr<ui::test::EventGenerator> event_generator_;
+  std::unique_ptr<TestMenuItemViewShown> menu_item_;
+  std::unique_ptr<TestMenuControllerDelegate> menu_controller_delegate_;
+  std::unique_ptr<MenuDelegate> menu_delegate_;
   MenuController* menu_controller_;
   TestMenuMessageLoop* test_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuControllerTest);
 };
 
 #if defined(OS_LINUX) && defined(USE_X11)
 // Tests that an event targeter which blocks events will be honored by the menu
 // event dispatcher.
 TEST_F(MenuControllerTest, EventTargeter) {
@@ skipping 412 matching lines @@
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
 // Tests that an asynchrnous menu nested within a synchronous menu restores the
 // previous MenuControllerDelegate and synchronous settings.
 TEST_F(MenuControllerTest, AsynchronousNestedDelegate) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
-  scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+  std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
   controller->AddNestedDelegate(nested_delegate.get());
   controller->SetAsyncRun(true);
 
   EXPECT_TRUE(IsAsyncRun());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
   int mouse_event_flags = 0;
@@ skipping 55 matching lines @@
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             controller_delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
 // Tets that an asynchronous menu nested within an asynchronous menu closes both
 // menus, and notifies both delegates.
 TEST_F(MenuControllerTest, DoubleAsynchronousNested) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
-  scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+  std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
   // Sets the run created in SetUp
   controller->SetAsyncRun(true);
 
   // Nested run
   controller->AddNestedDelegate(nested_delegate.get());
   controller->SetAsyncRun(true);
   int mouse_event_flags = 0;
   MenuItemView* run_result =
       controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
                       MENU_ANCHOR_TOPLEFT, false, false, &mouse_event_flags);
   EXPECT_EQ(run_result, nullptr);
 
   controller->CancelAll();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
 // Tests that an asynchronous menu nested within a synchronous menu does not
 // crash when trying to repost events that occur outside of the bounds of the
 // menu. Instead a proper shutdown should occur.
 TEST_F(MenuControllerTest, AsynchronousRepostEvent) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
-  scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+  std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
 
   controller->AddNestedDelegate(nested_delegate.get());
   controller->SetAsyncRun(true);
 
   EXPECT_TRUE(IsAsyncRun());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
@@ skipping 78 matching lines @@
       base::Bind(&MenuControllerTest::TestAsynchronousNestedExitOutermost,
                  base::Unretained(this)));
 
   RunMenu();
 }
 
 // Tests that having the MenuController deleted during RepostEvent does not
 // cause a crash. ASAN bots should not detect use-after-free in MenuController.
 TEST_F(MenuControllerTest, AsynchronousRepostEventDeletesController) {
   MenuController* controller = menu_controller();
-  scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+  std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
 
   controller->AddNestedDelegate(nested_delegate.get());
   controller->SetAsyncRun(true);
 
   EXPECT_TRUE(IsAsyncRun());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
@@ skipping 22 matching lines @@
 
   // Close to remove observers before test TearDown
   sub_menu->Close();
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
 // Tests that having the MenuController deleted during OnGestureEvent does not
 // cause a crash. ASAN bots should not detect use-after-free in MenuController.
 TEST_F(MenuControllerTest, AsynchronousGestureDeletesController) {
   MenuController* controller = menu_controller();
-  scoped_ptr<TestMenuControllerDelegate> nested_delegate(
+  std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
   ASSERT_FALSE(IsAsyncRun());
 
   controller->AddNestedDelegate(nested_delegate.get());
   controller->SetAsyncRun(true);
 
   EXPECT_TRUE(IsAsyncRun());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
   MenuItemView* item = menu_item();
@@ skipping 16 matching lines @@
   DestroyMenuControllerOnMenuClosed(nested_delegate.get());
   controller->OnGestureEvent(sub_menu, &event);
 
   // Close to remove observers before test TearDown
   sub_menu->Close();
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
 }  // namespace test
 }  // namespace views