Replace scoped_ptr with std::unique_ptr in //ui

ui/message_center/message_center_impl.cc

 // Copyright (c) 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 <algorithm>
 #include <deque>
 #include <utility>
 
@@ skipping 28 matching lines @@
   // Change represents an operation made on a notification.  Since it contains
   // the final state of the notification, we only keep the last change for a
   // particular notification that is in the notification list around.  There are
   // two ids; |id_| is the newest notification id that has been assigned by an
   // update, and |notification_list_id_| is the id of the notification it should
   // be updating as it exists in the notification list.
   class Change {
    public:
     Change(ChangeType type,
            const std::string& id,
-           scoped_ptr<Notification> notification);
+           std::unique_ptr<Notification> notification);
     ~Change();
 
     // Used to transfer ownership of the contained notification.
-    scoped_ptr<Notification> PassNotification();
+    std::unique_ptr<Notification> PassNotification();
 
     Notification* notification() const { return notification_.get(); }
     // Returns the post-update ID. It means:
     // - ADD event: ID of the notification to be added.
     // - UPDATE event: ID of the notification after the change. If the change
     //   doesn't update its ID, this value is same as |notification_list_id|.
     // - DELETE event: ID of the notification to be deleted.
     const std::string& id() const { return id_; }
     ChangeType type() const { return type_; }
     bool by_user() const { return by_user_; }
     void set_by_user(bool by_user) { by_user_ = by_user; }
     // Returns the ID which is used in the notification list. In other word, it
     // means the ID before the change.
     const std::string& notification_list_id() const {
       return notification_list_id_;
     }
     void set_type(const ChangeType new_type) {
       type_ = new_type;
     }
-    void ReplaceNotification(scoped_ptr<Notification> new_notification);
+    void ReplaceNotification(std::unique_ptr<Notification> new_notification);
 
    private:
     ChangeType type_;
     std::string id_;
     std::string notification_list_id_;
     bool by_user_;
-    scoped_ptr<Notification> notification_;
+    std::unique_ptr<Notification> notification_;
 
     DISALLOW_COPY_AND_ASSIGN(Change);
   };
 
   ChangeQueue();
   ~ChangeQueue();
 
   // Called when the message center has appropriate visibility.  Modifies
   // |message_center| but does not retain it.  This also causes the queue to
   // empty itself.
   void ApplyChanges(MessageCenterImpl* message_center);
 
   // Applies only the changes of the given ID.
   void ApplyChangesForId(MessageCenterImpl* message_center,
                          const std::string& id);
 
   // Causes a TYPE_ADD change to be added to the queue.
-  void AddNotification(scoped_ptr<Notification> notification);
+  void AddNotification(std::unique_ptr<Notification> notification);
 
   // Causes a TYPE_UPDATE change to be added to the queue.
   void UpdateNotification(const std::string& old_id,
-                          scoped_ptr<Notification> notification);
+                          std::unique_ptr<Notification> notification);
 
   // Causes a TYPE_DELETE change to be added to the queue.
   void EraseNotification(const std::string& id, bool by_user);
 
   // Returns whether the queue matches an id.  The id given will be matched
   // against the ID of all changes post-update, not the id of the notification
   // as it stands in the notification list.
   bool Has(const std::string& id) const;
 
   // Returns a Change that can be modified by the caller.  ChangeQueue retains
   // ownership of the Change; pointers should not be retained.
   Notification* GetLatestNotification(const std::string& id) const;
 
  private:
   void ApplyChangeInternal(MessageCenterImpl* message_center,
-                           scoped_ptr<Change> change);
+                           std::unique_ptr<Change> change);
 
   ScopedVector<Change> changes_;
 
   DISALLOW_COPY_AND_ASSIGN(ChangeQueue);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeFinder
 
 struct ChangeFinder {
   explicit ChangeFinder(const std::string& id) : id(id) {}
   bool operator()(ChangeQueue::Change* change) { return change->id() == id; }
 
   std::string id;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeQueue::Change
 
 ChangeQueue::Change::Change(ChangeType type,
                             const std::string& id,
-                            scoped_ptr<Notification> notification)
+                            std::unique_ptr<Notification> notification)
     : type_(type),
       notification_list_id_(id),
       by_user_(false),
       notification_(std::move(notification)) {
   DCHECK(!id.empty());
   DCHECK(type != CHANGE_TYPE_DELETE || notification_.get() == NULL);
 
   id_ = notification_ ? notification_->id() : notification_list_id_;
 }
 
 ChangeQueue::Change::~Change() {}
 
-scoped_ptr<Notification> ChangeQueue::Change::PassNotification() {
+std::unique_ptr<Notification> ChangeQueue::Change::PassNotification() {
   return std::move(notification_);
 }
 
 void ChangeQueue::Change::ReplaceNotification(
-    scoped_ptr<Notification> new_notification) {
+    std::unique_ptr<Notification> new_notification) {
   id_ = new_notification ? new_notification->id() : notification_list_id_;
   notification_.swap(new_notification);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeQueue
 
 ChangeQueue::ChangeQueue() {}
 
 ChangeQueue::~ChangeQueue() {}
 
 void ChangeQueue::ApplyChanges(MessageCenterImpl* message_center) {
   // This method is re-entrant.
   while (!changes_.empty()) {
     ScopedVector<Change>::iterator iter = changes_.begin();
-    scoped_ptr<Change> change(*iter);
+    std::unique_ptr<Change> change(*iter);
     // TODO(dewittj): Replace changes_ with a deque.
     changes_.weak_erase(iter);
     ApplyChangeInternal(message_center, std::move(change));
   }
 }
 
 void ChangeQueue::ApplyChangesForId(MessageCenterImpl* message_center,
                                     const std::string& id) {
   std::deque<Change*> changes_for_id;
   std::string interesting_id = id;
 
   // Traverses the queue in reverse so shat we can track changes which change
   // the notification's ID.
   ScopedVector<Change>::iterator iter = changes_.end();
   while (iter != changes_.begin()) {
     --iter;
     if (interesting_id != (*iter)->id())
       continue;
-    scoped_ptr<Change> change(*iter);
+    std::unique_ptr<Change> change(*iter);
 
     interesting_id = change->notification_list_id();
 
     iter = changes_.weak_erase(iter);
     changes_for_id.push_back(change.release());
   }
 
   while (!changes_for_id.empty()) {
-    ApplyChangeInternal(
-        message_center, scoped_ptr<Change>(changes_for_id.back()));
+    ApplyChangeInternal(message_center,
+                        std::unique_ptr<Change>(changes_for_id.back()));
     changes_for_id.pop_back();
   }
 }
 
-void ChangeQueue::AddNotification(scoped_ptr<Notification> notification) {
+void ChangeQueue::AddNotification(std::unique_ptr<Notification> notification) {
   std::string id = notification->id();
   changes_.push_back(new Change(CHANGE_TYPE_ADD, id, std::move(notification)));
 }
 
-void ChangeQueue::UpdateNotification(const std::string& old_id,
-                                     scoped_ptr<Notification> notification) {
+void ChangeQueue::UpdateNotification(
+    const std::string& old_id,
+    std::unique_ptr<Notification> notification) {
   ScopedVector<Change>::reverse_iterator iter =
     std::find_if(changes_.rbegin(), changes_.rend(), ChangeFinder(old_id));
   if (iter == changes_.rend()) {
     changes_.push_back(
         new Change(CHANGE_TYPE_UPDATE, old_id, std::move(notification)));
     return;
   }
 
   Change* change = *iter;
   switch (change->type()) {
@@ skipping 30 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 }
 
 void ChangeQueue::EraseNotification(const std::string& id, bool by_user) {
   ScopedVector<Change>::reverse_iterator iter =
     std::find_if(changes_.rbegin(), changes_.rend(), ChangeFinder(id));
   if (iter == changes_.rend()) {
-    scoped_ptr<Change> change(new Change(CHANGE_TYPE_DELETE, id, nullptr));
+    std::unique_ptr<Change> change(new Change(CHANGE_TYPE_DELETE, id, nullptr));
     change->set_by_user(by_user);
     changes_.push_back(std::move(change));
     return;
   }
 
   Change* change = *iter;
   switch (change->type()) {
     case CHANGE_TYPE_ADD:
       // ADD -> DELETE. Just removes both.
       changes_.erase(--(iter.base()));
@@ skipping 23 matching lines @@
 Notification* ChangeQueue::GetLatestNotification(const std::string& id) const {
   ScopedVector<Change>::const_iterator iter =
       std::find_if(changes_.begin(), changes_.end(), ChangeFinder(id));
   if (iter == changes_.end())
     return NULL;
 
   return (*iter)->notification();
 }
 
 void ChangeQueue::ApplyChangeInternal(MessageCenterImpl* message_center,
-                                      scoped_ptr<Change> change) {
+                                      std::unique_ptr<Change> change) {
   switch (change->type()) {
     case CHANGE_TYPE_ADD:
       message_center->AddNotificationImmediately(change->PassNotification());
       break;
     case CHANGE_TYPE_UPDATE:
       message_center->UpdateNotificationImmediately(
           change->notification_list_id(), change->PassNotification());
       break;
     case CHANGE_TYPE_DELETE:
       message_center->RemoveNotificationImmediately(
@@ skipping 181 matching lines @@
   return notification_list_->GetPopupNotifications(blockers_, NULL);
 }
 
 void MessageCenterImpl::ForceNotificationFlush(const std::string& id) {
   if (notification_queue_)
     notification_queue_->ApplyChangesForId(this, id);
 }
 
 //------------------------------------------------------------------------------
 // Client code interface.
-void MessageCenterImpl::AddNotification(scoped_ptr<Notification> notification) {
+void MessageCenterImpl::AddNotification(
+    std::unique_ptr<Notification> notification) {
   DCHECK(notification);
   const std::string id = notification->id();
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
   if (notification_queue_ &&
       notification_list_->is_message_center_visible()) {
     notification_queue_->AddNotification(std::move(notification));
     return;
   }
 
   AddNotificationImmediately(std::move(notification));
 }
 
 void MessageCenterImpl::AddNotificationImmediately(
-    scoped_ptr<Notification> notification) {
+    std::unique_ptr<Notification> notification) {
   const std::string id = notification->id();
 
   // Sometimes the notification can be added with the same id and the
   // |notification_list| will replace the notification instead of adding new.
   // This is essentially an update rather than addition.
   bool already_exists = (notification_list_->GetNotificationById(id) != NULL);
   notification_list_->AddNotification(std::move(notification));
   notification_cache_.Rebuild(
       notification_list_->GetVisibleNotifications(blockers_));
 
   if (already_exists) {
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
   } else {
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnNotificationAdded(id));
   }
 }
 
 void MessageCenterImpl::UpdateNotification(
     const std::string& old_id,
-    scoped_ptr<Notification> new_notification) {
+    std::unique_ptr<Notification> new_notification) {
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
   if (notification_queue_ &&
       notification_list_->is_message_center_visible()) {
     // We will allow notifications that are progress types (and stay progress
     // types) to be updated even if the message center is open.  There are 3
     // requirements here:
     //  * Notification of type PROGRESS exists with same ID in the center
     //  * There are no queued updates for this notification (they imply a change
@@ skipping 13 matching lines @@
                                               std::move(new_notification));
       return;
     }
   }
 
   UpdateNotificationImmediately(old_id, std::move(new_notification));
 }
 
 void MessageCenterImpl::UpdateNotificationImmediately(
     const std::string& old_id,
-    scoped_ptr<Notification> new_notification) {
+    std::unique_ptr<Notification> new_notification) {
   std::string new_id = new_notification->id();
   notification_list_->UpdateNotificationMessage(old_id,
                                                 std::move(new_notification));
   notification_cache_.Rebuild(
      notification_list_->GetVisibleNotifications(blockers_));
   if (old_id == new_id) {
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnNotificationUpdated(new_id));
   } else {
     FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
@@ skipping 293 matching lines @@
 }
 
 void MessageCenterImpl::EnableChangeQueueForTest(bool enable) {
   if (enable)
     notification_queue_.reset(new internal::ChangeQueue());
   else
     notification_queue_.reset();
 }
 
 }  // namespace message_center