Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/chrome_bubble_manager_unittest.cc

 // Copyright 2015 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 "chrome/browser/ui/chrome_bubble_manager.h"
 
 #include "base/macros.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "components/bubble/bubble_controller.h"
 #include "components/bubble/bubble_manager_mocks.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_renderer_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class ChromeBubbleManagerTest : public BrowserWithTestWindowTest {
  public:
   ChromeBubbleManagerTest() {}
 
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
  protected:
-  scoped_ptr<ChromeBubbleManager> manager_;
+  std::unique_ptr<ChromeBubbleManager> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeBubbleManagerTest);
 };
 
 void ChromeBubbleManagerTest::SetUp() {
   BrowserWithTestWindowTest::SetUp();
   manager_.reset(new ChromeBubbleManager(browser()->tab_strip_model()));
 }
 
@@ skipping 15 matching lines @@
   bubble1->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
   bubble2->CloseBubble(BUBBLE_CLOSE_CANCELED);
 
   ASSERT_FALSE(bubble1);
   ASSERT_FALSE(bubble2);
 }
 
 TEST_F(ChromeBubbleManagerTest, CloseMockBubbleOnNavigate) {
   AddTab(browser(), GURL("https://foo/0"));
 
-  scoped_ptr<MockBubbleDelegate> delegate(new MockBubbleDelegate);
+  std::unique_ptr<MockBubbleDelegate> delegate(new MockBubbleDelegate);
   EXPECT_CALL(*delegate, ShouldClose(BUBBLE_CLOSE_NAVIGATED))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*delegate, DidClose(BUBBLE_CLOSE_NAVIGATED));
   EXPECT_CALL(*delegate, Destroyed());
 
   BubbleReference bubble_ref = manager_->ShowBubble(std::move(delegate));
 
   NavigateAndCommitActiveTab(GURL("https://foo/1"));
 
   ASSERT_FALSE(bubble_ref);
 }
 
 TEST_F(ChromeBubbleManagerTest, CloseMockBubbleOnOwningFrameDestroy) {
   AddTab(browser(), GURL("https://foo/0"));
 
   content::RenderFrameHostTester* main_frame =
       content::RenderFrameHostTester::For(
           browser()->tab_strip_model()->GetWebContentsAt(0)->GetMainFrame());
 
   content::RenderFrameHost* subframe0 = main_frame->AppendChild("subframe0");
   content::RenderFrameHostTester* subframe0_tester =
       content::RenderFrameHostTester::For(subframe0);
 
   content::RenderFrameHost* subframe1 = main_frame->AppendChild("subframe1");
   content::RenderFrameHostTester* subframe1_tester =
       content::RenderFrameHostTester::For(subframe1);
 
-  scoped_ptr<MockBubbleDelegate> delegate(new MockBubbleDelegate);
+  std::unique_ptr<MockBubbleDelegate> delegate(new MockBubbleDelegate);
   EXPECT_CALL(*delegate, OwningFrame())
       .WillRepeatedly(testing::Return(subframe0));
   EXPECT_CALL(*delegate, ShouldClose(BUBBLE_CLOSE_FRAME_DESTROYED))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*delegate, DidClose(BUBBLE_CLOSE_FRAME_DESTROYED));
   EXPECT_CALL(*delegate, Destroyed());
 
   BubbleReference bubble_ref = manager_->ShowBubble(std::move(delegate));
 
   subframe1_tester->Detach();
   EXPECT_TRUE(bubble_ref) << "The bubble shouldn't be destroyed when a "
                              "non-owning frame is destroyed.";
 
   subframe0_tester->Detach();
   EXPECT_FALSE(bubble_ref);
 }
 
 }  // namespace