Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/bubble/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 "components/bubble/bubble_manager.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "components/bubble/bubble_controller.h"
 #include "components/bubble/bubble_manager_mocks.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // A "show chain" happens when a bubble decides to show another bubble on close.
 // All bubbles must be iterated to handle a close event. If a bubble shows
 // another bubble while it's being closed, the iterator can get messed up.
 class ChainShowBubbleDelegate : public MockBubbleDelegate {
  public:
   // |chained_bubble| can be nullptr if not interested in getting a reference to
   // the chained bubble.
   ChainShowBubbleDelegate(BubbleManager* manager,
-                          scoped_ptr<BubbleDelegate> delegate,
+                          std::unique_ptr<BubbleDelegate> delegate,
                           BubbleReference* chained_bubble)
       : manager_(manager),
         delegate_(std::move(delegate)),
         chained_bubble_(chained_bubble),
         closed_(false) {
     EXPECT_CALL(*this, ShouldClose(testing::_)).WillOnce(testing::Return(true));
   }
 
   ~ChainShowBubbleDelegate() override { EXPECT_TRUE(closed_); }
 
   void DidClose(BubbleCloseReason reason) override {
     MockBubbleDelegate::DidClose(reason);
     BubbleReference ref = manager_->ShowBubble(std::move(delegate_));
     if (chained_bubble_)
       *chained_bubble_ = ref;
     closed_ = true;
   }
 
  private:
   BubbleManager* manager_;
-  scoped_ptr<BubbleDelegate> delegate_;
+  std::unique_ptr<BubbleDelegate> delegate_;
   BubbleReference* chained_bubble_;
   bool closed_;
 
   DISALLOW_COPY_AND_ASSIGN(ChainShowBubbleDelegate);
 };
 
 // A "close chain" happens when a close event is received while another close
 // event is in progress. Ex: Closing the BubbleUi will hide the bubble, causing
 // it to lose focus, which causes another close event. This test simulates this
 // by sending a close event during the |DidClose| method of a BubbleDelegate.
@@ skipping 33 matching lines @@
 
 class BubbleManagerTest : public testing::Test {
  public:
   BubbleManagerTest();
   ~BubbleManagerTest() override {}
 
   void SetUp() override;
   void TearDown() override;
 
  protected:
-  scoped_ptr<BubbleManagerSubclass> manager_;
+  std::unique_ptr<BubbleManagerSubclass> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BubbleManagerTest);
 };
 
 BubbleManagerTest::BubbleManagerTest() {}
 
 void BubbleManagerTest::SetUp() {
   testing::Test::SetUp();
   manager_.reset(new BubbleManagerSubclass);
 }
 
 void BubbleManagerTest::TearDown() {
   manager_.reset();
   testing::Test::TearDown();
 }
 
 TEST_F(BubbleManagerTest, ManagerShowsBubbleUi) {
-  scoped_ptr<MockBubbleDelegate> delegate = MockBubbleDelegate::Default();
+  std::unique_ptr<MockBubbleDelegate> delegate = MockBubbleDelegate::Default();
 
   MockBubbleUi* bubble_ui = delegate->bubble_ui();
   EXPECT_CALL(*bubble_ui, Destroyed());
   EXPECT_CALL(*bubble_ui, Show(testing::_));
   EXPECT_CALL(*bubble_ui, Close());
   EXPECT_CALL(*bubble_ui, UpdateAnchorPosition()).Times(0);
 
   manager_->ShowBubble(std::move(delegate));
 }
 
 TEST_F(BubbleManagerTest, ManagerUpdatesBubbleUiAnchor) {
-  scoped_ptr<MockBubbleDelegate> delegate = MockBubbleDelegate::Default();
+  std::unique_ptr<MockBubbleDelegate> delegate = MockBubbleDelegate::Default();
 
   MockBubbleUi* bubble_ui = delegate->bubble_ui();
   EXPECT_CALL(*bubble_ui, Destroyed());
   EXPECT_CALL(*bubble_ui, Show(testing::_));
   EXPECT_CALL(*bubble_ui, Close());
   EXPECT_CALL(*bubble_ui, UpdateAnchorPosition());
 
   manager_->ShowBubble(std::move(delegate));
   manager_->UpdateAllBubbleAnchors();
 }
@@ skipping 112 matching lines @@
   EXPECT_TRUE(ref3);
 
   ref2->CloseBubble(BUBBLE_CLOSE_FOCUS_LOST);
 
   EXPECT_TRUE(ref1);
   EXPECT_FALSE(ref2);
   EXPECT_TRUE(ref3);
 }
 
 TEST_F(BubbleManagerTest, CloseOwnedByShouldLeaveUnowned) {
-  scoped_ptr<MockBubbleDelegate> delegate1 = MockBubbleDelegate::Default();
-  scoped_ptr<MockBubbleDelegate> delegate2 = MockBubbleDelegate::Default();
-  scoped_ptr<MockBubbleDelegate> delegate3 = MockBubbleDelegate::Default();
+  std::unique_ptr<MockBubbleDelegate> delegate1 = MockBubbleDelegate::Default();
+  std::unique_ptr<MockBubbleDelegate> delegate2 = MockBubbleDelegate::Default();
+  std::unique_ptr<MockBubbleDelegate> delegate3 = MockBubbleDelegate::Default();
   MockBubbleDelegate& delegate1_ref = *delegate1;
   MockBubbleDelegate& delegate2_ref = *delegate2;
   MockBubbleDelegate& delegate3_ref = *delegate3;
   BubbleReference ref1 = manager_->ShowBubble(std::move(delegate1));
   BubbleReference ref2 = manager_->ShowBubble(std::move(delegate2));
   BubbleReference ref3 = manager_->ShowBubble(std::move(delegate3));
 
   // These pointers are only compared for equality, not dereferenced.
   const content::RenderFrameHost* const frame1 =
       reinterpret_cast<const content::RenderFrameHost*>(&ref1);
@@ skipping 37 matching lines @@
 
   // Bubble should NOT get a close event because it's already closed.
   manager_->CloseAllBubbles(BUBBLE_CLOSE_FOCUS_LOST);
 }
 
 // This test validates that it's possible to show another bubble when
 // |CloseBubble| is called.
 TEST_F(BubbleManagerTest, AllowBubbleChainingOnClose) {
   BubbleReference chained_bubble;
   BubbleReference ref =
-      manager_->ShowBubble(make_scoped_ptr(new ChainShowBubbleDelegate(
+      manager_->ShowBubble(base::WrapUnique(new ChainShowBubbleDelegate(
           manager_.get(), MockBubbleDelegate::Default(), &chained_bubble)));
   ASSERT_FALSE(chained_bubble);  // Bubble not yet visible.
   ASSERT_TRUE(manager_->CloseBubble(ref, BUBBLE_CLOSE_FORCED));
   ASSERT_TRUE(chained_bubble);  // Bubble is now visible.
 }
 
 // This test validates that it's possible to show another bubble when
 // |CloseAllBubbles| is called.
 TEST_F(BubbleManagerTest, AllowBubbleChainingOnCloseAll) {
   BubbleReference chained_bubble;
   BubbleReference ref =
-      manager_->ShowBubble(make_scoped_ptr(new ChainShowBubbleDelegate(
+      manager_->ShowBubble(base::WrapUnique(new ChainShowBubbleDelegate(
           manager_.get(), MockBubbleDelegate::Default(), &chained_bubble)));
   ASSERT_FALSE(chained_bubble);  // Bubble not yet visible.
   manager_->CloseAllBubbles(BUBBLE_CLOSE_FORCED);
   ASSERT_TRUE(chained_bubble);  // Bubble is now visible.
 }
 
 // This test validates that a show chain will not happen in the destructor.
 // While chaining is during the normal life span of the manager, it should NOT
 // happen when the manager is being destroyed.
 TEST_F(BubbleManagerTest, BubblesDoNotChainOnDestroy) {
   MockBubbleManagerObserver metrics;
   // |chained_delegate| should never be shown.
   EXPECT_CALL(metrics, OnBubbleNeverShown(testing::_));
   // The ChainShowBubbleDelegate should be closed when the manager is destroyed.
   EXPECT_CALL(metrics, OnBubbleClosed(testing::_, BUBBLE_CLOSE_FORCED));
   manager_->AddBubbleManagerObserver(&metrics);
 
-  scoped_ptr<MockBubbleDelegate> chained_delegate(new MockBubbleDelegate);
+  std::unique_ptr<MockBubbleDelegate> chained_delegate(new MockBubbleDelegate);
   EXPECT_CALL(*chained_delegate->bubble_ui(), Show(testing::_)).Times(0);
   EXPECT_CALL(*chained_delegate, ShouldClose(testing::_)).Times(0);
   EXPECT_CALL(*chained_delegate, DidClose(testing::_)).Times(0);
 
-  manager_->ShowBubble(make_scoped_ptr(new ChainShowBubbleDelegate(
+  manager_->ShowBubble(base::WrapUnique(new ChainShowBubbleDelegate(
       manager_.get(), std::move(chained_delegate), nullptr)));
   manager_.reset();
 }
 
 TEST_F(BubbleManagerTest, BubbleCloseReasonIsCalled) {
   MockBubbleManagerObserver metrics;
   EXPECT_CALL(metrics, OnBubbleNeverShown(testing::_)).Times(0);
   EXPECT_CALL(metrics, OnBubbleClosed(testing::_, BUBBLE_CLOSE_ACCEPTED));
   manager_->AddBubbleManagerObserver(&metrics);
 
   BubbleReference ref = manager_->ShowBubble(MockBubbleDelegate::Default());
   ref->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 
   // Destroy to verify no events are sent to |metrics| in destructor.
   manager_.reset();
 }
 
 // In a close chain, it should be possible for the bubble in the second close
 // event to close.
 TEST_F(BubbleManagerTest, BubbleCloseChainCloseClose) {
-  scoped_ptr<ChainCloseBubbleDelegate> closing_bubble(
+  std::unique_ptr<ChainCloseBubbleDelegate> closing_bubble(
       new ChainCloseBubbleDelegate(manager_.get()));
   EXPECT_CALL(*closing_bubble, ShouldClose(testing::_))
       .WillOnce(testing::Return(true));
 
   BubbleReference other_bubble_ref =
       manager_->ShowBubble(MockBubbleDelegate::Default());
 
   BubbleReference closing_bubble_ref =
       manager_->ShowBubble(std::move(closing_bubble));
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 
   closing_bubble_ref->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 
   EXPECT_FALSE(other_bubble_ref);
   EXPECT_FALSE(closing_bubble_ref);
 }
 
 // In a close chain, it should be possible for the bubble in the second close
 // event to remain open because close is a request.
 TEST_F(BubbleManagerTest, BubbleCloseChainCloseNoClose) {
-  scoped_ptr<ChainCloseBubbleDelegate> closing_bubble(
+  std::unique_ptr<ChainCloseBubbleDelegate> closing_bubble(
       new ChainCloseBubbleDelegate(manager_.get()));
   EXPECT_CALL(*closing_bubble, ShouldClose(testing::_))
       .WillOnce(testing::Return(true));
 
   BubbleReference other_bubble_ref =
       manager_->ShowBubble(MockBubbleDelegate::Stubborn());
 
   BubbleReference closing_bubble_ref =
       manager_->ShowBubble(std::move(closing_bubble));
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 
   closing_bubble_ref->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_FALSE(closing_bubble_ref);
 }
 
 // This test is a sanity check. |closing_bubble| will attempt to close all other
 // bubbles if it's closed, but it doesn't want to close. Sending a close request
 // should keep it open without starting a close chain.
 TEST_F(BubbleManagerTest, BubbleCloseChainNoCloseNoClose) {
-  scoped_ptr<ChainCloseBubbleDelegate> closing_bubble(
+  std::unique_ptr<ChainCloseBubbleDelegate> closing_bubble(
       new ChainCloseBubbleDelegate(manager_.get()));
   EXPECT_CALL(*closing_bubble, ShouldClose(testing::_))
       .WillRepeatedly(testing::Return(false));
 
   BubbleReference other_bubble_ref =
       manager_->ShowBubble(MockBubbleDelegate::Default());
 
   BubbleReference closing_bubble_ref =
       manager_->ShowBubble(std::move(closing_bubble));
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 
   closing_bubble_ref->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 
   EXPECT_TRUE(other_bubble_ref);
   EXPECT_TRUE(closing_bubble_ref);
 }
 
 }  // namespace