Replace scoped_ptr with std::unique_ptr in //ui

ui/message_center/notification_list_unittest.cc

 // Copyright (c) 2012 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/notification_list.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 22 matching lines @@
     counter_ = 0;
   }
 
  protected:
   // Currently NotificationListTest doesn't care about some fields like title or
   // message, so put a simple template on it. Returns the id of the new
   // notification.
   std::string AddNotification(
       const message_center::RichNotificationData& optional_fields) {
     std::string new_id;
-    scoped_ptr<Notification> notification(
+    std::unique_ptr<Notification> notification(
         MakeNotification(optional_fields, &new_id));
     notification_list_->AddNotification(std::move(notification));
     counter_++;
     return new_id;
   }
 
   std::string AddNotification() {
     return AddNotification(message_center::RichNotificationData());
   }
 
   // Construct a new notification for testing, but don't add it to the list yet.
-  scoped_ptr<Notification> MakeNotification(
+  std::unique_ptr<Notification> MakeNotification(
       const message_center::RichNotificationData& optional_fields,
       std::string* id_out) {
     *id_out = base::StringPrintf(kIdFormat, counter_);
-    scoped_ptr<Notification> notification(new Notification(
+    std::unique_ptr<Notification> notification(new Notification(
         message_center::NOTIFICATION_TYPE_SIMPLE, *id_out,
         UTF8ToUTF16(base::StringPrintf(kTitleFormat, counter_)),
         UTF8ToUTF16(base::StringPrintf(kMessageFormat, counter_)), gfx::Image(),
         UTF8ToUTF16(kDisplaySource), GURL(),
         NotifierId(NotifierId::APPLICATION, kExtensionId), optional_fields,
         NULL));
     return notification;
   }
 
-  scoped_ptr<Notification> MakeNotification(std::string* id_out) {
+  std::unique_ptr<Notification> MakeNotification(std::string* id_out) {
     return MakeNotification(message_center::RichNotificationData(), id_out);
   }
 
   // Utility methods of AddNotification.
   std::string AddPriorityNotification(NotificationPriority priority) {
     message_center::RichNotificationData optional;
     optional.priority = priority;
     return AddNotification(optional);
   }
 
@@ skipping 16 matching lines @@
   NotificationList* notification_list() { return notification_list_.get(); }
   const NotificationBlockers& blockers() const { return blockers_; }
 
   static const char kIdFormat[];
   static const char kTitleFormat[];
   static const char kMessageFormat[];
   static const char kDisplaySource[];
   static const char kExtensionId[];
 
  private:
-  scoped_ptr<NotificationList> notification_list_;
+  std::unique_ptr<NotificationList> notification_list_;
   NotificationBlockers blockers_;
   size_t counter_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationListTest);
 };
 
 bool IsInNotifications(const NotificationList::Notifications& notifications,
                        const std::string& id) {
   for (NotificationList::Notifications::const_iterator iter =
            notifications.begin(); iter != notifications.end(); ++iter) {
@@ skipping 62 matching lines @@
   notification_list()->MarkSinglePopupAsDisplayed(id0);
   EXPECT_EQ(1u, notification_list()->UnreadCount(blockers()));
   notification_list()->MarkSinglePopupAsDisplayed(id1);
   EXPECT_EQ(0u, notification_list()->UnreadCount(blockers()));
 }
 
 TEST_F(NotificationListTest, UpdateNotification) {
   std::string id0 = AddNotification();
   std::string replaced = id0 + "_replaced";
   EXPECT_EQ(1u, notification_list()->NotificationCount(blockers()));
-  scoped_ptr<Notification> notification(
+  std::unique_ptr<Notification> notification(
       new Notification(message_center::NOTIFICATION_TYPE_SIMPLE, replaced,
                        UTF8ToUTF16("newtitle"), UTF8ToUTF16("newbody"),
                        gfx::Image(), UTF8ToUTF16(kDisplaySource), GURL(),
                        NotifierId(NotifierId::APPLICATION, kExtensionId),
                        message_center::RichNotificationData(), NULL));
   notification_list()->UpdateNotificationMessage(id0, std::move(notification));
   EXPECT_EQ(1u, notification_list()->NotificationCount(blockers()));
   const NotificationList::Notifications notifications =
       notification_list()->GetVisibleNotifications(blockers());
   EXPECT_EQ(replaced, (*notifications.begin())->id());
   EXPECT_EQ(UTF8ToUTF16("newtitle"), (*notifications.begin())->title());
   EXPECT_EQ(UTF8ToUTF16("newbody"), (*notifications.begin())->message());
 }
 
 TEST_F(NotificationListTest, GetNotificationsByNotifierId) {
   NotifierId id0(NotifierId::APPLICATION, "ext0");
   NotifierId id1(NotifierId::APPLICATION, "ext1");
   NotifierId id2(GURL("http://example.com"));
   NotifierId id3(NotifierId::SYSTEM_COMPONENT, "system-notifier");
-  scoped_ptr<Notification> notification(new Notification(
+  std::unique_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, "id0", UTF8ToUTF16("title0"),
       UTF8ToUTF16("message0"), gfx::Image(), UTF8ToUTF16("source0"), GURL(),
       id0, message_center::RichNotificationData(), NULL));
   notification_list()->AddNotification(std::move(notification));
   notification.reset(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title1"),
       UTF8ToUTF16("message1"), gfx::Image(), UTF8ToUTF16("source0"), GURL(),
       id0, message_center::RichNotificationData(), NULL));
   notification_list()->AddNotification(std::move(notification));
   notification.reset(new Notification(
@@ skipping 157 matching lines @@
   EXPECT_EQ(0u, GetPopupCounts());
 }
 
 TEST_F(NotificationListTest, PriorityPromotion) {
   std::string id0 = AddPriorityNotification(LOW_PRIORITY);
   std::string replaced = id0 + "_replaced";
   EXPECT_EQ(1u, notification_list()->NotificationCount(blockers()));
   EXPECT_EQ(0u, GetPopupCounts());
   message_center::RichNotificationData optional;
   optional.priority = 1;
-  scoped_ptr<Notification> notification(new Notification(
+  std::unique_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, replaced,
       UTF8ToUTF16("newtitle"), UTF8ToUTF16("newbody"), gfx::Image(),
       UTF8ToUTF16(kDisplaySource), GURL(),
       NotifierId(NotifierId::APPLICATION, kExtensionId), optional, NULL));
   notification_list()->UpdateNotificationMessage(id0, std::move(notification));
   EXPECT_EQ(1u, notification_list()->NotificationCount(blockers()));
   EXPECT_EQ(1u, GetPopupCounts());
   const NotificationList::Notifications notifications =
       notification_list()->GetVisibleNotifications(blockers());
   EXPECT_EQ(replaced, (*notifications.begin())->id());
   EXPECT_EQ(UTF8ToUTF16("newtitle"), (*notifications.begin())->title());
   EXPECT_EQ(UTF8ToUTF16("newbody"), (*notifications.begin())->message());
   EXPECT_EQ(1, (*notifications.begin())->priority());
 }
 
 TEST_F(NotificationListTest, PriorityPromotionWithPopups) {
   std::string id0 = AddPriorityNotification(LOW_PRIORITY);
   std::string id1 = AddPriorityNotification(DEFAULT_PRIORITY);
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id1, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // id0 promoted to LOW->DEFAULT, it'll appear as toast (popup).
   message_center::RichNotificationData priority;
   priority.priority = DEFAULT_PRIORITY;
-  scoped_ptr<Notification> notification(new Notification(
+  std::unique_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, id0, UTF8ToUTF16("newtitle"),
       UTF8ToUTF16("newbody"), gfx::Image(), UTF8ToUTF16(kDisplaySource), GURL(),
       NotifierId(NotifierId::APPLICATION, kExtensionId), priority, NULL));
   notification_list()->UpdateNotificationMessage(id0, std::move(notification));
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id0, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // update with no promotion change for id0, it won't appear as a toast.
   notification.reset(new Notification(
@@ skipping 33 matching lines @@
       message_center::NOTIFICATION_TYPE_SIMPLE, id1, UTF8ToUTF16("newtitle3"),
       UTF8ToUTF16("newbody3"), gfx::Image(), UTF8ToUTF16(kDisplaySource),
       GURL(), NotifierId(NotifierId::APPLICATION, kExtensionId), priority,
       NULL));
   notification_list()->UpdateNotificationMessage(id1, std::move(notification));
   EXPECT_EQ(0u, GetPopupCounts());
 }
 
 TEST_F(NotificationListTest, WebNotificationUpdatePromotion) {
   std::string notification_id = "replaced-web-notification";
-  scoped_ptr<Notification> original_notification(new Notification(
+  std::unique_ptr<Notification> original_notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, notification_id,
       UTF8ToUTF16("Web Notification"), UTF8ToUTF16("Notification contents"),
       gfx::Image(), UTF8ToUTF16(kDisplaySource), GURL(),
       NotifierId(GURL("https://example.com/")),
       message_center::RichNotificationData(), NULL));
 
   EXPECT_EQ(0u, GetPopupCounts());
   notification_list()->AddNotification(std::move(original_notification));
   EXPECT_EQ(1u, GetPopupCounts());
 
   notification_list()->MarkSinglePopupAsShown(notification_id, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
-  scoped_ptr<Notification> replaced_notification(new Notification(
+  std::unique_ptr<Notification> replaced_notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, notification_id,
       UTF8ToUTF16("Web Notification Replacement"),
       UTF8ToUTF16("New notification contents"), gfx::Image(),
       UTF8ToUTF16(kDisplaySource), GURL(),
       NotifierId(GURL("https://example.com/")),
       message_center::RichNotificationData(), NULL));
 
   // Web Notifications will be re-shown as popups even if their priority didn't
   // change, to match the behavior of the Web Notification API.
   notification_list()->UpdateNotificationMessage(
@@ skipping 86 matching lines @@
   EXPECT_FALSE(n1->shown_as_popup());
   EXPECT_TRUE(n1->IsRead());
 
   notification_list()->MarkSinglePopupAsShown(id1, true);
 
   n1 = GetNotification(id1);
   EXPECT_TRUE(n1->shown_as_popup());
   EXPECT_TRUE(n1->IsRead());
 
   const std::string replaced("test-replaced-id");
-  scoped_ptr<Notification> notification(
+  std::unique_ptr<Notification> notification(
       new Notification(message_center::NOTIFICATION_TYPE_SIMPLE, replaced,
                        UTF8ToUTF16("newtitle"), UTF8ToUTF16("newbody"),
                        gfx::Image(), UTF8ToUTF16(kDisplaySource), GURL(),
                        NotifierId(NotifierId::APPLICATION, kExtensionId),
                        message_center::RichNotificationData(), NULL));
   notification_list()->UpdateNotificationMessage(id1, std::move(notification));
   n1 = GetNotification(id1);
   EXPECT_TRUE(n1 == NULL);
   const Notification* nr = GetNotification(replaced);
   EXPECT_TRUE(nr->shown_as_popup());
@@ skipping 21 matching lines @@
   std::string id = AddNotification();
   EXPECT_EQ(1u, notification_list()->UnreadCount(blockers()));
 
   notification_list()->MarkSinglePopupAsDisplayed(id);
   EXPECT_EQ(0u, notification_list()->UnreadCount(blockers()));
   notification_list()->MarkSinglePopupAsShown(
       id, false /* mark_notification_as_read */);
   EXPECT_EQ(1u, notification_list()->UnreadCount(blockers()));
 
   // Updates the notification  and verifies unread_count doesn't change.
-  scoped_ptr<Notification> updated_notification(new Notification(
+  std::unique_ptr<Notification> updated_notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, id, UTF8ToUTF16("updated"),
       UTF8ToUTF16("updated"), gfx::Image(), base::string16(), GURL(),
       NotifierId(), RichNotificationData(), NULL));
   notification_list()->AddNotification(std::move(updated_notification));
   EXPECT_EQ(1u, notification_list()->UnreadCount(blockers()));
 }
 
 TEST_F(NotificationListTest, TestPushingShownNotification) {
   // Create a notification and mark it as shown.
   std::string id1;
-  scoped_ptr<Notification> notification(MakeNotification(&id1));
+  std::unique_ptr<Notification> notification(MakeNotification(&id1));
   notification->set_shown_as_popup(true);
 
   // Call PushNotification on this notification.
   notification_list()->PushNotification(std::move(notification));
 
   // Ensure it is still marked as shown.
   EXPECT_TRUE(GetNotification(id1)->shown_as_popup());
 }
 
 TEST_F(NotificationListTest, TestHasNotificationOfType) {
   std::string id = AddNotification();
 
   EXPECT_TRUE(notification_list()->HasNotificationOfType(
       id, message_center::NOTIFICATION_TYPE_SIMPLE));
   EXPECT_FALSE(notification_list()->HasNotificationOfType(
       id, message_center::NOTIFICATION_TYPE_PROGRESS));
 
-  scoped_ptr<Notification> updated_notification(new Notification(
+  std::unique_ptr<Notification> updated_notification(new Notification(
       message_center::NOTIFICATION_TYPE_PROGRESS, id, UTF8ToUTF16("updated"),
       UTF8ToUTF16("updated"), gfx::Image(), base::string16(), GURL(),
       NotifierId(), RichNotificationData(), NULL));
   notification_list()->AddNotification(std::move(updated_notification));
 
   EXPECT_FALSE(notification_list()->HasNotificationOfType(
       id, message_center::NOTIFICATION_TYPE_SIMPLE));
   EXPECT_TRUE(notification_list()->HasNotificationOfType(
       id, message_center::NOTIFICATION_TYPE_PROGRESS));
 }
 
 }  // namespace message_center