Convert Pass()→std::move() in //components/[n-z]*

components/undo/bookmark_undo_service.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 "components/undo/bookmark_undo_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/macros.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node_data.h"
 #include "components/bookmarks/browser/bookmark_undo_provider.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
 #include "components/undo/undo_operation.h"
 #include "grit/components_strings.h"
 
@@ skipping 100 matching lines @@
 BookmarkRemoveOperation::BookmarkRemoveOperation(
     BookmarkModel* model,
     BookmarkUndoProvider* undo_provider,
     const BookmarkNode* parent,
     int index,
     scoped_ptr<BookmarkNode> node)
     : BookmarkUndoOperation(model),
       undo_provider_(undo_provider),
       parent_node_id_(parent->id()),
       index_(index),
-      node_(node.Pass()) {
-}
+      node_(std::move(node)) {}
 
 BookmarkRemoveOperation::~BookmarkRemoveOperation() {
 }
 
 void BookmarkRemoveOperation::Undo() {
   DCHECK(node_.get());
 
   const BookmarkNode* parent = bookmarks::GetBookmarkNodeByID(
       bookmark_model(), parent_node_id_);
   DCHECK(parent);
 
-  undo_provider_->RestoreRemovedNode(parent, index_, node_.Pass());
+  undo_provider_->RestoreRemovedNode(parent, index_, std::move(node_));
 }
 
 int BookmarkRemoveOperation::GetUndoLabelId() const {
   return IDS_BOOKMARK_BAR_UNDO_DELETE;
 }
 
 int BookmarkRemoveOperation::GetRedoLabelId() const {
   return IDS_BOOKMARK_BAR_REDO_ADD;
 }
 
@@ skipping 206 matching lines @@
   undo_manager_.RemoveAllOperations();
 }
 
 void BookmarkUndoService::BookmarkNodeMoved(BookmarkModel* model,
                                             const BookmarkNode* old_parent,
                                             int old_index,
                                             const BookmarkNode* new_parent,
                                             int new_index) {
   scoped_ptr<UndoOperation> op(new BookmarkMoveOperation(
       model, old_parent, old_index, new_parent, new_index));
-  undo_manager()->AddUndoOperation(op.Pass());
+  undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::BookmarkNodeAdded(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   scoped_ptr<UndoOperation> op(
       new BookmarkAddOperation(model, parent, index));
-  undo_manager()->AddUndoOperation(op.Pass());
+  undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::OnWillChangeBookmarkNode(BookmarkModel* model,
                                                    const BookmarkNode* node) {
   scoped_ptr<UndoOperation> op(new BookmarkEditOperation(model, node));
-  undo_manager()->AddUndoOperation(op.Pass());
+  undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::OnWillReorderBookmarkNode(BookmarkModel* model,
                                                     const BookmarkNode* node) {
   scoped_ptr<UndoOperation> op(new BookmarkReorderOperation(model, node));
-  undo_manager()->AddUndoOperation(op.Pass());
+  undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::GroupedBookmarkChangesBeginning(
     BookmarkModel* model) {
   undo_manager()->StartGroupingActions();
 }
 
 void BookmarkUndoService::GroupedBookmarkChangesEnded(BookmarkModel* model) {
   undo_manager()->EndGroupingActions();
 }
 
 void BookmarkUndoService::SetUndoProvider(BookmarkUndoProvider* undo_provider) {
   undo_provider_ = undo_provider;
 }
 
 void BookmarkUndoService::OnBookmarkNodeRemoved(BookmarkModel* model,
                                                 const BookmarkNode* parent,
                                                 int index,
                                                 scoped_ptr<BookmarkNode> node) {
   DCHECK(undo_provider_);
   scoped_ptr<UndoOperation> op(new BookmarkRemoveOperation(
-      model, undo_provider_, parent, index, node.Pass()));
-  undo_manager()->AddUndoOperation(op.Pass());
+      model, undo_provider_, parent, index, std::move(node)));
+  undo_manager()->AddUndoOperation(std::move(op));
 }