Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

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 <memory>

[danakj, 2016/04/25 18:32:58]

dont need then

[dcheng, 2016/04/25 19:55:06]

See previous.

 #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 74 matching lines @@
 // Handles the undo of the deletion of a bookmark node. For a bookmark folder,
 // the information for all descendant bookmark nodes is maintained.
 //
 // The BookmarkModel allows only single bookmark node to be removed.
 class BookmarkRemoveOperation : public BookmarkUndoOperation {
  public:
   BookmarkRemoveOperation(BookmarkModel* model,
                           BookmarkUndoProvider* undo_provider,
                           const BookmarkNode* parent,
                           int index,
-                          scoped_ptr<BookmarkNode> node);
+                          std::unique_ptr<BookmarkNode> node);
   ~BookmarkRemoveOperation() override;
 
   // UndoOperation:
   void Undo() override;
   int GetUndoLabelId() const override;
   int GetRedoLabelId() const override;
 
  private:
   BookmarkUndoProvider* undo_provider_;
   const int64_t parent_node_id_;
   const int index_;
-  scoped_ptr<BookmarkNode> node_;
+  std::unique_ptr<BookmarkNode> node_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkRemoveOperation);
 };
 
 BookmarkRemoveOperation::BookmarkRemoveOperation(
     BookmarkModel* model,
     BookmarkUndoProvider* undo_provider,
     const BookmarkNode* parent,
     int index,
-    scoped_ptr<BookmarkNode> node)
+    std::unique_ptr<BookmarkNode> node)
     : BookmarkUndoOperation(model),
       undo_provider_(undo_provider),
       parent_node_id_(parent->id()),
       index_(index),
       node_(std::move(node)) {}
 
 BookmarkRemoveOperation::~BookmarkRemoveOperation() {
 }
 
 void BookmarkRemoveOperation::Undo() {
@@ skipping 221 matching lines @@
 
 void BookmarkUndoService::BookmarkModelBeingDeleted(BookmarkModel* model) {
   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(
+  std::unique_ptr<UndoOperation> op(new BookmarkMoveOperation(
       model, old_parent, old_index, new_parent, new_index));
   undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::BookmarkNodeAdded(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
-  scoped_ptr<UndoOperation> op(
+  std::unique_ptr<UndoOperation> op(
       new BookmarkAddOperation(model, parent, index));
   undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::OnWillChangeBookmarkNode(BookmarkModel* model,
                                                    const BookmarkNode* node) {
-  scoped_ptr<UndoOperation> op(new BookmarkEditOperation(model, node));
+  std::unique_ptr<UndoOperation> op(new BookmarkEditOperation(model, node));
   undo_manager()->AddUndoOperation(std::move(op));
 }
 
 void BookmarkUndoService::OnWillReorderBookmarkNode(BookmarkModel* model,
                                                     const BookmarkNode* node) {
-  scoped_ptr<UndoOperation> op(new BookmarkReorderOperation(model, node));
+  std::unique_ptr<UndoOperation> op(new BookmarkReorderOperation(model, node));
   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) {
+void BookmarkUndoService::OnBookmarkNodeRemoved(
+    BookmarkModel* model,
+    const BookmarkNode* parent,
+    int index,
+    std::unique_ptr<BookmarkNode> node) {
   DCHECK(undo_provider_);
-  scoped_ptr<UndoOperation> op(new BookmarkRemoveOperation(
+  std::unique_ptr<UndoOperation> op(new BookmarkRemoveOperation(
       model, undo_provider_, parent, index, std::move(node)));
   undo_manager()->AddUndoOperation(std::move(op));
 }