Replace scoped_ptr with std::unique_ptr in //ui

ui/message_center/views/message_center_view_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 "ui/message_center/views/message_center_view.h"
 
 #include <map>
+#include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/message_center/fake_message_center.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_list.h"
 #include "ui/message_center/notification_types.h"
 #include "ui/message_center/views/message_center_button_bar.h"
 #include "ui/message_center/views/message_center_controller.h"
 #include "ui/message_center/views/message_list_view.h"
@@ skipping 100 matching lines @@
   void TearDown() override;
 
   MessageCenterView* GetMessageCenterView();
   MessageListView* GetMessageListView();
   FakeMessageCenterImpl* GetMessageCenter() const;
   NotificationView* GetNotificationView(const std::string& id);
   views::BoundsAnimator* GetAnimator();
   int GetNotificationCount();
   int GetCallCount(CallType type);
   int GetCalculatedMessageListViewHeight();
-  void AddNotification(scoped_ptr<Notification> notification);
+  void AddNotification(std::unique_ptr<Notification> notification);
   void UpdateNotification(const std::string& notification_id,
-                          scoped_ptr<Notification> notification);
+                          std::unique_ptr<Notification> notification);
 
- // Overridden from MessageCenterController:
+  // Overridden from MessageCenterController:
   void ClickOnNotification(const std::string& notification_id) override;
   void RemoveNotification(const std::string& notification_id,
                           bool by_user) override;
-  scoped_ptr<ui::MenuModel> CreateMenuModel(
+  std::unique_ptr<ui::MenuModel> CreateMenuModel(
       const NotifierId& notifier_id,
       const base::string16& display_source) override;
   bool HasClickedListener(const std::string& notification_id) override;
   void ClickOnNotificationButton(const std::string& notification_id,
                                  int button_index) override;
   void ClickOnSettingsButton(const std::string& notification_id) override;
 
   // Overridden from MockNotificationView::Test
   void RegisterCall(CallType type) override;
 
   void FireOnMouseExitedEvent();
 
   void LogBounds(int depth, views::View* view);
 
   MessageCenterButtonBar* GetButtonBar() const;
 
  private:
   views::View* MakeParent(views::View* child1, views::View* child2);
 
   base::MessageLoopForUI message_loop_;
 
   NotificationList::Notifications notifications_;
-  scoped_ptr<MessageCenterView> message_center_view_;
-  scoped_ptr<FakeMessageCenterImpl> message_center_;
+  std::unique_ptr<MessageCenterView> message_center_view_;
+  std::unique_ptr<FakeMessageCenterImpl> message_center_;
   std::map<CallType,int> callCounts_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageCenterViewTest);
 };
 
 MessageCenterViewTest::MessageCenterViewTest() {
 }
 
 MessageCenterViewTest::~MessageCenterViewTest() {
 }
@@ skipping 72 matching lines @@
   return callCounts_[type];
 }
 
 void MessageCenterViewTest::ClickOnNotification(
     const std::string& notification_id) {
   // For this test, this method should not be invoked.
   NOTREACHED();
 }
 
 void MessageCenterViewTest::AddNotification(
-    scoped_ptr<Notification> notification) {
+    std::unique_ptr<Notification> notification) {
   std::string notification_id = notification->id();
   notifications_.insert(notification.release());
   message_center_->SetVisibleNotifications(notifications_);
   message_center_view_->OnNotificationAdded(notification_id);
 }
 
 void MessageCenterViewTest::UpdateNotification(
     const std::string& notification_id,
-    scoped_ptr<Notification> notification) {
+    std::unique_ptr<Notification> notification) {
   for (auto it = notifications_.begin(); it != notifications_.end(); it++) {
     if ((*it)->id() == notification_id) {
       delete *it;
       notifications_.erase(it);
       break;
     }
   }
   // |notifications| is a "set" container so we don't need to be aware the
   // order.
   notifications_.insert(notification.release());
   message_center_->SetVisibleNotifications(notifications_);
   message_center_view_->OnNotificationUpdated(notification_id);
 }
 
 void MessageCenterViewTest::RemoveNotification(
     const std::string& notification_id,
     bool by_user) {
   for (auto it = notifications_.begin(); it != notifications_.end(); it++) {
     if ((*it)->id() == notification_id) {
       delete *it;
       notifications_.erase(it);
       break;
     }
   }
   message_center_->SetVisibleNotifications(notifications_);
   message_center_view_->OnNotificationRemoved(notification_id, by_user);
 }
 
-scoped_ptr<ui::MenuModel> MessageCenterViewTest::CreateMenuModel(
+std::unique_ptr<ui::MenuModel> MessageCenterViewTest::CreateMenuModel(
     const NotifierId& notifier_id,
     const base::string16& display_source) {
   // For this test, this method should not be invoked.
   NOTREACHED();
   return nullptr;
 }
 
 bool MessageCenterViewTest::HasClickedListener(
     const std::string& notification_id) {
   return true;
@@ skipping 68 matching lines @@
           (kMarginBetweenItems - MessageView::GetShadowInsets().bottom()) +
           GetNotificationView(kNotificationId2)->GetHeightForWidth(width) +
           GetMessageListView()->GetInsets().height());
 }
 
 TEST_F(MessageCenterViewTest, SizeAfterUpdate) {
   EXPECT_EQ(2, GetMessageListView()->child_count());
   int width =
       GetMessageListView()->width() - GetMessageListView()->GetInsets().width();
 
-  scoped_ptr<Notification> notification(new Notification(
+  std::unique_ptr<Notification> notification(new Notification(
       NOTIFICATION_TYPE_SIMPLE, std::string(kNotificationId2),
       base::UTF8ToUTF16("title2"),
       base::UTF8ToUTF16("message\nwhich\nis\nvertically\nlong\n."),
       gfx::Image(), base::UTF8ToUTF16("display source"), GURL(),
       NotifierId(NotifierId::APPLICATION, "extension_id"),
       message_center::RichNotificationData(), NULL));
 
   EXPECT_EQ(
       GetMessageListView()->height(),
       GetNotificationView(kNotificationId1)->GetHeightForWidth(width) +
@@ skipping 47 matching lines @@
   // Make sure that the notification 2 is placed above the notification 1.
   EXPECT_LT(GetNotificationView(kNotificationId2)->bounds().y(),
             GetNotificationView(kNotificationId1)->bounds().y());
 
   int previous_vertical_pos_from_bottom =
       GetMessageListView()->height() -
       GetNotificationView(kNotificationId1)->bounds().y();
   GetMessageListView()->SetRepositionTargetForTest(
       GetNotificationView(kNotificationId1)->bounds());
 
-  scoped_ptr<Notification> notification(new Notification(
+  std::unique_ptr<Notification> notification(new Notification(
       NOTIFICATION_TYPE_SIMPLE, std::string(kNotificationId2),
       base::UTF8ToUTF16("title2"),
       base::UTF8ToUTF16("message\nwhich\nis\nvertically\nlong\n."),
       gfx::Image(), base::UTF8ToUTF16("display source"), GURL(),
       NotifierId(NotifierId::APPLICATION, "extension_id"),
       message_center::RichNotificationData(), NULL));
   UpdateNotification(kNotificationId2, std::move(notification));
 
   // Wait until the animation finishes if available.
   if (GetAnimator()->IsAnimating())
@@ skipping 94 matching lines @@
   Notification pinned_notification(
       NOTIFICATION_TYPE_SIMPLE, std::string(kNotificationId2),
       base::UTF8ToUTF16("title2"),
       base::UTF8ToUTF16("message\nwhich\nis\nvertically\nlong\n."),
       gfx::Image(), base::UTF8ToUTF16("display source"), GURL(),
       NotifierId(NotifierId::APPLICATION, "extension_id"),
       message_center::RichNotificationData(), NULL);
   pinned_notification.set_pinned(true);
 
   AddNotification(
-      scoped_ptr<Notification>(new Notification(normal_notification)));
+      std::unique_ptr<Notification>(new Notification(normal_notification)));
 
   // There should be 1 non-pinned notification.
   EXPECT_EQ(1u, GetMessageCenter()->GetVisibleNotifications().size());
   EXPECT_TRUE(close_button->enabled());
 
   AddNotification(
-      scoped_ptr<Notification>(new Notification(pinned_notification)));
+      std::unique_ptr<Notification>(new Notification(pinned_notification)));
 
   // There should be 1 normal notification and 1 pinned notification.
   EXPECT_EQ(2u, GetMessageCenter()->GetVisibleNotifications().size());
   EXPECT_TRUE(close_button->enabled());
 
   RemoveNotification(kNotificationId1, false);
 
   // There should be 1 pinned notification.
   EXPECT_EQ(1u, GetMessageCenter()->GetVisibleNotifications().size());
   EXPECT_FALSE(close_button->enabled());
 
   RemoveNotification(kNotificationId2, false);
 
   // There should be no notification.
   EXPECT_EQ(0u, GetMessageCenter()->GetVisibleNotifications().size());
   EXPECT_FALSE(close_button->enabled());
 
   AddNotification(
-      scoped_ptr<Notification>(new Notification(pinned_notification)));
+      std::unique_ptr<Notification>(new Notification(pinned_notification)));
 
   // There should be 1 pinned notification.
   EXPECT_EQ(1u, GetMessageCenter()->GetVisibleNotifications().size());
   EXPECT_FALSE(close_button->enabled());
 #endif  // defined(OS_CHROMEOS)
 }
 
 }  // namespace message_center