Replace scoped_ptr with std::unique_ptr in //ui

ui/message_center/message_center_impl_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/message_center_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/message_center_types.h"
 #include "ui/message_center/notification_blocker.h"
@@ skipping 69 matching lines @@
                             NotifierId(NotifierId::APPLICATION, notifier_id),
                             optional_fields, NULL);
   }
 
   void ForceNotificationFlush(const std::string& id) {
     message_center()->ForceNotificationFlush(id);
   }
 
  private:
   MessageCenter* message_center_;
-  scoped_ptr<base::MessageLoop> loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::MessageLoop> loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
   base::Closure closure_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageCenterImplTest);
 };
 
 class MessageCenterImplTestWithChangeQueue : public MessageCenterImplTest {
  public:
   MessageCenterImplTestWithChangeQueue() {}
   ~MessageCenterImplTestWithChangeQueue() override {}
 
@@ skipping 130 matching lines @@
   bool timer_finished() const { return timer_finished_; }
   const std::string& last_id() const { return last_id_; }
 
  private:
   bool timer_finished_;
   std::string last_id_;
   base::Closure quit_closure_;
 };
 
 TEST_F(MessageCenterImplTest, PopupTimersEmptyController) {
-  scoped_ptr<PopupTimersController> popup_timers_controller =
-      make_scoped_ptr(new PopupTimersController(message_center()));
+  std::unique_ptr<PopupTimersController> popup_timers_controller =
+      base::WrapUnique(new PopupTimersController(message_center()));
 
   // Test that all functions succed without any timers created.
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   popup_timers_controller->CancelAll();
   popup_timers_controller->TimerFinished("unknown");
   popup_timers_controller->PauseTimer("unknown");
   popup_timers_controller->CancelTimer("unknown");
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartTimer) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   run_loop()->Run();
   EXPECT_TRUE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseTimer) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->PauseTimer("test");
   run_loop()->RunUntilIdle();
 
   EXPECT_FALSE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerCancelTimer) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->CancelTimer("test");
   run_loop()->RunUntilIdle();
 
   EXPECT_FALSE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseAllTimers) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->PauseAll();
   run_loop()->RunUntilIdle();
 
   EXPECT_FALSE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartAllTimers) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   run_loop()->Run();
 
   EXPECT_TRUE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimers) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(5));
   popup_timers_controller->StartTimer("test2",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->StartTimer("test3",
                                       base::TimeDelta::FromMilliseconds(3));
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   run_loop()->Run();
 
   EXPECT_EQ(popup_timers_controller->last_id(), "test2");
   EXPECT_TRUE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimersPause) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(5));
   popup_timers_controller->StartTimer("test2",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->StartTimer("test3",
                                       base::TimeDelta::FromMilliseconds(3));
   popup_timers_controller->PauseTimer("test2");
 
   run_loop()->Run();
 
   EXPECT_EQ(popup_timers_controller->last_id(), "test3");
   EXPECT_TRUE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerResetTimer) {
-  scoped_ptr<MockPopupTimersController> popup_timers_controller =
-      make_scoped_ptr(
+  std::unique_ptr<MockPopupTimersController> popup_timers_controller =
+      base::WrapUnique(
           new MockPopupTimersController(message_center(), closure()));
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(5));
   popup_timers_controller->StartTimer("test2",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->StartTimer("test3",
                                       base::TimeDelta::FromMilliseconds(3));
   popup_timers_controller->PauseTimer("test2");
   popup_timers_controller->ResetTimer("test",
                                       base::TimeDelta::FromMilliseconds(2));
 
   run_loop()->Run();
 
   EXPECT_EQ(popup_timers_controller->last_id(), "test");
   EXPECT_TRUE(popup_timers_controller->timer_finished());
 }
 
 TEST_F(MessageCenterImplTest, NotificationBlocker) {
   NotifierId notifier_id(NotifierId::APPLICATION, "app1");
   // Multiple blockers to verify the case that one blocker blocks but another
   // doesn't.
   ToggledNotificationBlocker blocker1(message_center());
   ToggledNotificationBlocker blocker2(message_center());
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id, RichNotificationData(), NULL)));
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id, RichNotificationData(), NULL)));
   EXPECT_EQ(2u, message_center()->GetPopupNotifications().size());
   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
 
   // Block all notifications. All popups are gone and message center should be
   // hidden.
   blocker1.SetNotificationsEnabled(false);
@@ skipping 20 matching lines @@
   // aren't shown.
   blocker2.SetNotificationsEnabled(true);
   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
 }
 
 TEST_F(MessageCenterImplTest, NotificationsDuringBlocked) {
   NotifierId notifier_id(NotifierId::APPLICATION, "app1");
   ToggledNotificationBlocker blocker(message_center());
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id, RichNotificationData(), NULL)));
   EXPECT_EQ(1u, message_center()->GetPopupNotifications().size());
   EXPECT_EQ(1u, message_center()->GetVisibleNotifications().size());
 
   // Create a notification during blocked. Still no popups.
   blocker.SetNotificationsEnabled(false);
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id, RichNotificationData(), NULL)));
   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
 
   // Unblock notifications, the id1 should appear as a popup.
   blocker.SetNotificationsEnabled(true);
   NotificationList::PopupNotifications popups =
       message_center()->GetPopupNotifications();
   EXPECT_EQ(1u, popups.size());
   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
 }
 
 // Similar to other blocker cases but this test case allows |notifier_id2| even
 // in blocked.
 TEST_F(MessageCenterImplTest, NotificationBlockerAllowsPopups) {
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
   NotifierId notifier_id2(NotifierId::APPLICATION, "app2");
   PopupNotificationBlocker blocker(message_center(), notifier_id2);
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id1, RichNotificationData(), NULL)));
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id2, RichNotificationData(), NULL)));
 
   // "id1" is closed but "id2" is still visible as a popup.
   blocker.SetNotificationsEnabled(false);
   NotificationList::PopupNotifications popups =
       message_center()->GetPopupNotifications();
   EXPECT_EQ(1u, popups.size());
   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id3", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id1, RichNotificationData(), NULL)));
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id4", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id2, RichNotificationData(), NULL)));
   popups = message_center()->GetPopupNotifications();
   EXPECT_EQ(2u, popups.size());
   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
   EXPECT_TRUE(PopupNotificationsContain(popups, "id4"));
   EXPECT_EQ(4u, message_center()->GetVisibleNotifications().size());
 
   blocker.SetNotificationsEnabled(true);
   popups = message_center()->GetPopupNotifications();
   EXPECT_EQ(3u, popups.size());
   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
   EXPECT_TRUE(PopupNotificationsContain(popups, "id3"));
   EXPECT_TRUE(PopupNotificationsContain(popups, "id4"));
   EXPECT_EQ(4u, message_center()->GetVisibleNotifications().size());
 }
 
 // TotalNotificationBlocker suppresses showing notifications even from the list.
 // This would provide the feature to 'separated' message centers per-profile for
 // ChromeOS multi-login.
 TEST_F(MessageCenterImplTest, TotalNotificationBlocker) {
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
   NotifierId notifier_id2(NotifierId::APPLICATION, "app2");
   TotalNotificationBlocker blocker(message_center(), notifier_id2);
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id1, RichNotificationData(), NULL)));
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id2, RichNotificationData(), NULL)));
 
   // "id1" becomes invisible while "id2" is still visible.
   blocker.SetNotificationsEnabled(false);
   EXPECT_EQ(1u, message_center()->NotificationCount());
   NotificationList::Notifications notifications =
       message_center()->GetVisibleNotifications();
   EXPECT_FALSE(NotificationsContain(notifications, "id1"));
   EXPECT_TRUE(NotificationsContain(notifications, "id2"));
 
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id3", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id1, RichNotificationData(), NULL)));
-  message_center()->AddNotification(scoped_ptr<Notification>(
+  message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id4", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id2, RichNotificationData(), NULL)));
   EXPECT_EQ(2u, message_center()->NotificationCount());
   notifications = message_center()->GetVisibleNotifications();
   EXPECT_FALSE(NotificationsContain(notifications, "id1"));
   EXPECT_TRUE(NotificationsContain(notifications, "id2"));
   EXPECT_FALSE(NotificationsContain(notifications, "id3"));
   EXPECT_TRUE(NotificationsContain(notifications, "id4"));
@@ skipping 22 matching lines @@
   // And remove all including invisible notifications.
   blocker.SetNotificationsEnabled(false);
   message_center()->RemoveAllNotifications(false /* by_user */,
                                            MessageCenter::RemoveType::ALL);
   EXPECT_EQ(0u, message_center()->NotificationCount());
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(MessageCenterImplTest, CachedUnreadCount) {
   message_center()->AddNotification(
-      scoped_ptr<Notification>(CreateSimpleNotification("id1")));
+      std::unique_ptr<Notification>(CreateSimpleNotification("id1")));
   message_center()->AddNotification(
-      scoped_ptr<Notification>(CreateSimpleNotification("id2")));
+      std::unique_ptr<Notification>(CreateSimpleNotification("id2")));
   message_center()->AddNotification(
-      scoped_ptr<Notification>(CreateSimpleNotification("id3")));
+      std::unique_ptr<Notification>(CreateSimpleNotification("id3")));
   ASSERT_EQ(3u, message_center()->UnreadNotificationCount());
 
   // Mark 'displayed' on all notifications by using for-loop. This shouldn't
   // recreate |notifications| inside of the loop.
   const NotificationList::Notifications& notifications =
       message_center()->GetVisibleNotifications();
   for (NotificationList::Notifications::const_iterator iter =
            notifications.begin(); iter != notifications.end(); ++iter) {
     message_center()->DisplayedNotification(
         (*iter)->id(), message_center::DISPLAY_SOURCE_MESSAGE_CENTER);
@@ skipping 15 matching lines @@
 #endif  // OS_CHROMEOS
 
 TEST_F(MessageCenterImplTest, ForceNotificationFlush_InconsistentUpdate) {
   std::string id1("id1");
   std::string id2("id2");
   std::string id3("id3");
 
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Add -> Update (with ID change)
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id1));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id1));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id2));
   message_center()->UpdateNotification(id1, std::move(notification));
 
   // Add (although the same ID exists) -> Update (with ID change) -> Remove
   notification.reset(CreateSimpleNotification(id2));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id3));
   message_center()->UpdateNotification(id2, std::move(notification));
   message_center()->RemoveNotification(id3, false);
 
   // Remove (although the ID has already removed)
   message_center()->RemoveNotification(id3, false);
 
   // Notification is not added since the message center has opened.
   ASSERT_EQ(0u, message_center()->NotificationCount());
 
   // Forced to update.
   ForceNotificationFlush(id3);
 
   // Confirms the chagnes are applied.
   ASSERT_EQ(0u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTest, DisableNotificationsByNotifier) {
   ASSERT_EQ(0u, message_center()->NotificationCount());
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
   ASSERT_EQ(5u, message_center()->NotificationCount());
 
   // Removing all of app1's notifications should only leave app2's.
   message_center()->DisableNotificationsByNotifier(
       NotifierId(NotifierId::APPLICATION, "app1"));
   ASSERT_EQ(3u, message_center()->NotificationCount());
 
   // Now we remove the remaining notifications.
   message_center()->DisableNotificationsByNotifier(
       NotifierId(NotifierId::APPLICATION, "app2"));
   ASSERT_EQ(0u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTest, NotifierEnabledChanged) {
   ASSERT_EQ(0u, message_center()->NotificationCount());
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id1-3", "app1")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-4", "app2")));
-  message_center()->AddNotification(
-      scoped_ptr<Notification>(
-          CreateSimpleNotificationWithNotifierId("id2-5", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id1-3", "app1")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-4", "app2")));
+  message_center()->AddNotification(std::unique_ptr<Notification>(
+      CreateSimpleNotificationWithNotifierId("id2-5", "app2")));
   ASSERT_EQ(8u, message_center()->NotificationCount());
 
   // Enabling an extension should have no effect on the count.
   notifier_settings_observer()->NotifierEnabledChanged(
       NotifierId(NotifierId::APPLICATION, "app1"), true);
   ASSERT_EQ(8u, message_center()->NotificationCount());
 
   // Removing all of app2's notifications should only leave app1's.
   notifier_settings_observer()->NotifierEnabledChanged(
       NotifierId(NotifierId::APPLICATION, "app2"), false);
@@ skipping 10 matching lines @@
   ASSERT_EQ(0u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue, QueueUpdatesWithCenterVisible) {
   std::string id("id1");
   std::string id2("id2");
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
 
   // First, add and update a notification to ensure updates happen
   // normally.
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id2));
   message_center()->UpdateNotification(id, std::move(notification));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 
   // Then open the message center.
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Then update a notification; nothing should have happened.
   notification.reset(CreateSimpleNotification(id));
   message_center()->UpdateNotification(id2, std::move(notification));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 
   // Close the message center; then the update should have propagated.
   message_center()->SetVisibility(VISIBILITY_TRANSIENT);
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue, ComplexQueueing) {
   std::string ids[6] = {"0", "1", "2", "3", "4p", "5"};
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
 
-  scoped_ptr<Notification> notification;
+  std::unique_ptr<Notification> notification;
   // Add some notifications
   int i = 0;
   for (; i < 3; i++) {
     notification.reset(CreateSimpleNotification(ids[i]));
     message_center()->AddNotification(std::move(notification));
   }
   for (i = 0; i < 3; i++) {
     EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[i]));
   }
   for (; i < 6; i++) {
@@ skipping 46 matching lines @@
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[4]));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[5]));
   EXPECT_EQ(message_center()->GetVisibleNotifications().size(), 5u);
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue, UpdateWhileQueueing) {
   std::string ids[11] =
       {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10p"};
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
 
-  scoped_ptr<Notification> notification;
+  std::unique_ptr<Notification> notification;
   // Add some notifications
   int i = 0;
   for (; i < 6; i++) {
     notification.reset(CreateSimpleNotification(ids[i]));
     notification->set_title(base::ASCIIToUTF16("ORIGINAL TITLE"));
     message_center()->AddNotification(std::move(notification));
   }
   for (i = 0; i < 6; i++) {
     EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[i]));
   }
@@ skipping 134 matching lines @@
   std::string id("id1");
   std::string id2("id2");
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
 
   gfx::Size original_size(0, 0);
   // Open the message center to prevent adding notifications
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Create new notification to be added to the queue; images all have the same
   // original size.
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
 
   // Double-check that sizes all match.
   const std::vector<ButtonInfo>& original_buttons = notification->buttons();
   ASSERT_EQ(2u, original_buttons.size());
 
   EXPECT_EQ(original_size, notification->icon().Size());
   EXPECT_EQ(original_size, notification->image().Size());
   EXPECT_EQ(original_size, original_buttons[0].icon.Size());
   EXPECT_EQ(original_size, original_buttons[1].icon.Size());
 
@@ skipping 31 matching lines @@
   EXPECT_EQ(new_size, mc_notification->image().Size());
   EXPECT_EQ(new_size, buttons[0].icon.Size());
   EXPECT_EQ(new_size, buttons[1].icon.Size());
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue, ForceNotificationFlushAdd) {
   std::string id("id1");
 
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
   message_center()->AddNotification(
-      scoped_ptr<Notification>(CreateSimpleNotification(id)));
+      std::unique_ptr<Notification>(CreateSimpleNotification(id)));
 
   // Notification is not added yet.
   ASSERT_EQ(0u, message_center()->NotificationCount());
   // Forced to update.
   ForceNotificationFlush(id);
   // Notification is added.
   ASSERT_EQ(1u, message_center()->NotificationCount());
 }
 
 
 TEST_F(MessageCenterImplTestWithChangeQueue, ForceNotificationFlushUpdate) {
   std::string id("id1");
   std::string id2("id2");
 
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
 
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   notification.reset(CreateSimpleNotification(id2));
   message_center()->UpdateNotification(id, std::move(notification));
 
   // Nothing is changed.
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
@@ skipping 12 matching lines @@
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 
   // Makes sure if there is only one notification.
   ASSERT_EQ(1u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue, ForceNotificationFlushRemove) {
   std::string id("id1");
 
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
 
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
   message_center()->RemoveNotification(id, false);
 
   // Notification is not removed yet.
   ASSERT_EQ(1u, message_center()->NotificationCount());
 
   // Forced to update.
   ForceNotificationFlush(id);
 
   // Notification is removed.
   ASSERT_EQ(0u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTestWithChangeQueue,
        ForceNotificationFlush_ComplexUpdate) {
   std::string id1("id1");
   std::string id2("id2");
   std::string id3("id3");
 
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Add -> Update (with ID change) -> Remove
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id1));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id1));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id2));
   message_center()->UpdateNotification(id1, std::move(notification));
   message_center()->RemoveNotification(id2, false);
 
   // Add -> Update (with ID change)
   notification.reset(CreateSimpleNotification(id2));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id3));
   message_center()->UpdateNotification(id2, std::move(notification));
 
   // Notification is not added since the message center has opened.
   ASSERT_EQ(0u, message_center()->NotificationCount());
 
   // Forced to update.
   ForceNotificationFlush(id3);
 
   // Confirms the chagnes are applied.
   ASSERT_EQ(1u, message_center()->NotificationCount());
 }
 
 TEST_F(MessageCenterImplTestWithoutChangeQueue,
        UpdateWhileMessageCenterVisible) {
   std::string id("id1");
   std::string id2("id2");
   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
 
   // First, add and update a notification to ensure updates happen
   // normally.
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
   notification.reset(CreateSimpleNotification(id2));
   message_center()->UpdateNotification(id, std::move(notification));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 
   // Then open the message center.
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Then update a notification; the update should have propagated.
   notification.reset(CreateSimpleNotification(id));
   message_center()->UpdateNotification(id2, std::move(notification));
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id2));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
 }
 
 TEST_F(MessageCenterImplTestWithoutChangeQueue, AddWhileMessageCenterVisible) {
   std::string id("id1");
 
   // Then open the message center.
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Add a notification and confirm the adding should have propagated.
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
 }
 
 TEST_F(MessageCenterImplTestWithoutChangeQueue,
        RemoveWhileMessageCenterVisible) {
   std::string id("id1");
 
   // First, add a notification to ensure updates happen normally.
-  scoped_ptr<Notification> notification(CreateSimpleNotification(id));
+  std::unique_ptr<Notification> notification(CreateSimpleNotification(id));
   message_center()->AddNotification(std::move(notification));
   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
 
   // Then open the message center.
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Then update a notification; the update should have propagated.
   message_center()->RemoveNotification(id, false);
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 }
 
 }  // namespace internal
 }  // namespace message_center