Convert Pass()→std::move() 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>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/message_center_switches.h"
 #include "ui/message_center/message_center_types.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_blocker.h"
@@ skipping 112 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeQueue::Change
 
 ChangeQueue::Change::Change(ChangeType type,
                             const std::string& id,
                             scoped_ptr<Notification> notification)
     : type_(type),
       notification_list_id_(id),
       by_user_(false),
-      notification_(notification.Pass()) {
+      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() {
-  return notification_.Pass();
+  return std::move(notification_);
 }
 
 void ChangeQueue::Change::ReplaceNotification(
     scoped_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);
     // TODO(dewittj): Replace changes_ with a deque.
     changes_.weak_erase(iter);
-    ApplyChangeInternal(message_center, change.Pass());
+    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.
@@ skipping 12 matching lines @@
 
   while (!changes_for_id.empty()) {
     ApplyChangeInternal(
         message_center, scoped_ptr<Change>(changes_for_id.back()));
     changes_for_id.pop_back();
   }
 }
 
 void ChangeQueue::AddNotification(scoped_ptr<Notification> notification) {
   std::string id = notification->id();
-  changes_.push_back(
-      new Change(CHANGE_TYPE_ADD, id, notification.Pass()));
+  changes_.push_back(new Change(CHANGE_TYPE_ADD, id, std::move(notification)));
 }
 
 void ChangeQueue::UpdateNotification(const std::string& old_id,
                                      scoped_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, notification.Pass()));
+        new Change(CHANGE_TYPE_UPDATE, old_id, std::move(notification)));
     return;
   }
 
   Change* change = *iter;
   switch (change->type()) {
     case CHANGE_TYPE_ADD: {
       std::string id = notification->id();
       // Needs to add the change at the last, because if this change updates
       // its ID, some previous changes may affect new ID.
       // (eg. Add A, Update B->C, and This update A->B).
       changes_.erase(--(iter.base()));
       changes_.push_back(
-          new Change(CHANGE_TYPE_ADD, id, notification.Pass()));
+          new Change(CHANGE_TYPE_ADD, id, std::move(notification)));
       break;
     }
     case CHANGE_TYPE_UPDATE:
       if (notification->id() == old_id) {
         // Safe to place the change at the previous place.
-        change->ReplaceNotification(notification.Pass());
+        change->ReplaceNotification(std::move(notification));
       } else if (change->id() == change->notification_list_id()) {
         std::string id = notification->id();
         // Safe to place the change at the last.
         changes_.erase(--(iter.base()));
-        changes_.push_back(new Change(
-            CHANGE_TYPE_ADD, id, notification.Pass()));
+        changes_.push_back(
+            new Change(CHANGE_TYPE_ADD, id, std::move(notification)));
       } else {
         // Complex case: gives up to optimize.
         changes_.push_back(
-            new Change(CHANGE_TYPE_UPDATE, old_id, notification.Pass()));
+            new Change(CHANGE_TYPE_UPDATE, old_id, std::move(notification)));
       }
       break;
     case CHANGE_TYPE_DELETE:
       // DELETE -> UPDATE. Something is wrong. Treats the UPDATE as ADD.
       changes_.push_back(
-          new Change(CHANGE_TYPE_ADD, old_id, notification.Pass()));
+          new Change(CHANGE_TYPE_ADD, old_id, std::move(notification)));
       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));
     change->set_by_user(by_user);
-    changes_.push_back(change.Pass());
+    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()));
       break;
     case CHANGE_TYPE_UPDATE:
@@ skipping 231 matching lines @@
 //------------------------------------------------------------------------------
 // Client code interface.
 void MessageCenterImpl::AddNotification(scoped_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(notification.Pass());
+    notification_queue_->AddNotification(std::move(notification));
     return;
   }
 
-  AddNotificationImmediately(notification.Pass());
+  AddNotificationImmediately(std::move(notification));
 }
 
 void MessageCenterImpl::AddNotificationImmediately(
     scoped_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(notification.Pass());
+  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));
   }
@@ skipping 17 matching lines @@
     // TODO(dewittj): Ensure this works when the ID is changed by the caller.
     // This shouldn't be an issue in practice since only W3C notifications
     // change the ID on update, and they don't have progress type notifications.
     bool update_keeps_progress_type =
         new_notification->type() == NOTIFICATION_TYPE_PROGRESS &&
         !notification_queue_->Has(old_id) &&
         notification_list_->HasNotificationOfType(old_id,
                                                   NOTIFICATION_TYPE_PROGRESS);
     if (!update_keeps_progress_type) {
       // Updates are allowed only for progress notifications.
-      notification_queue_->UpdateNotification(old_id, new_notification.Pass());
+      notification_queue_->UpdateNotification(old_id,
+                                              std::move(new_notification));
       return;
     }
   }
 
-  UpdateNotificationImmediately(old_id, new_notification.Pass());
+  UpdateNotificationImmediately(old_id, std::move(new_notification));
 }
 
 void MessageCenterImpl::UpdateNotificationImmediately(
     const std::string& old_id,
     scoped_ptr<Notification> new_notification) {
   std::string new_id = new_notification->id();
   notification_list_->UpdateNotificationMessage(old_id,
-                                                new_notification.Pass());
+                                                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_,
                       OnNotificationRemoved(old_id, false));
     FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
                       OnNotificationAdded(new_id));
@@ skipping 293 matching lines @@
 }
 
 void MessageCenterImpl::EnableChangeQueueForTest(bool enable) {
   if (enable)
     notification_queue_.reset(new internal::ChangeQueue());
   else
     notification_queue_.reset();
 }
 
 }  // namespace message_center