Convert //components/bookmarks from scoped_ptr to std::unique_ptr

components/bookmarks/browser/bookmark_model.cc

 // Copyright 2014 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/bookmarks/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 80 matching lines @@
  public:
   EmptyUndoDelegate() {}
   ~EmptyUndoDelegate() override {}
 
  private:
   // BookmarkUndoDelegate:
   void SetUndoProvider(BookmarkUndoProvider* provider) override {}
   void OnBookmarkNodeRemoved(BookmarkModel* model,
                              const BookmarkNode* parent,
                              int index,
-                             scoped_ptr<BookmarkNode> node) override {}
+                             std::unique_ptr<BookmarkNode> node) override {}
 
   DISALLOW_COPY_AND_ASSIGN(EmptyUndoDelegate);
 };
 
 }  // namespace
 
 // BookmarkModel --------------------------------------------------------------
 
-BookmarkModel::BookmarkModel(scoped_ptr<BookmarkClient> client)
+BookmarkModel::BookmarkModel(std::unique_ptr<BookmarkClient> client)
     : client_(std::move(client)),
       loaded_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       mobile_node_(NULL),
       next_node_id_(1),
       observers_(
           base::ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       loaded_signal_(true, false),
@@ skipping 130 matching lines @@
   EndExtensiveChanges();
   if (store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkAllUserNodesRemoved(this, removed_urls));
 
   BeginGroupedChanges();
   for (const auto& removed_node_data : removed_node_data_list) {
     undo_delegate()->OnBookmarkNodeRemoved(
-        this,
-        removed_node_data.parent,
-        removed_node_data.index,
-        scoped_ptr<BookmarkNode>(removed_node_data.node));
+        this, removed_node_data.parent, removed_node_data.index,
+        std::unique_ptr<BookmarkNode>(removed_node_data.node));
   }
   EndGroupedChanges();
 }
 
 void BookmarkModel::Move(const BookmarkNode* node,
                          const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
       is_root_node(new_parent) || is_permanent_node(node)) {
     NOTREACHED();
@@ skipping 376 matching lines @@
 
   if (!parent || !parent->is_folder() || is_root_node(parent) ||
       parent->child_count() <= 1) {
     return;
   }
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillReorderBookmarkNode(this, parent));
 
   UErrorCode error = U_ZERO_ERROR;
-  scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
+  std::unique_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
   if (U_FAILURE(error))
     collator.reset(NULL);
   BookmarkNode* mutable_parent = AsMutable(parent);
   std::sort(mutable_parent->children().begin(),
             mutable_parent->children().end(),
             SortComparator(collator.get()));
 
   if (store_.get())
     store_->ScheduleSave();
 
@@ skipping 74 matching lines @@
     case BookmarkNode::OTHER_NODE:
       return other_node_;
     case BookmarkNode::MOBILE:
       return mobile_node_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
-void BookmarkModel::RestoreRemovedNode(const BookmarkNode* parent,
-                                       int index,
-                                       scoped_ptr<BookmarkNode> scoped_node) {
+void BookmarkModel::RestoreRemovedNode(
+    const BookmarkNode* parent,
+    int index,
+    std::unique_ptr<BookmarkNode> scoped_node) {
   BookmarkNode* node = scoped_node.release();
   AddNode(AsMutable(parent), index, node);
 
   // We might be restoring a folder node that have already contained a set of
   // child nodes. We need to notify all of them.
   NotifyNodeAddedForAllDescendents(node);
 }
 
 void BookmarkModel::NotifyNodeAddedForAllDescendents(const BookmarkNode* node) {
   for (int i = 0; i < node->child_count(); ++i) {
@@ skipping 22 matching lines @@
     removed_urls->insert(node->url());
   }
 
   CancelPendingFaviconLoadRequests(node);
 
   // Recurse through children.
   for (int i = node->child_count() - 1; i >= 0; --i)
     RemoveNode(node->GetChild(i), removed_urls);
 }
 
-void BookmarkModel::DoneLoading(scoped_ptr<BookmarkLoadDetails> details) {
+void BookmarkModel::DoneLoading(std::unique_ptr<BookmarkLoadDetails> details) {
   DCHECK(details);
   if (loaded_) {
     // We should only ever be loaded once.
     NOTREACHED();
     return;
   }
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/467179
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
@@ skipping 71 matching lines @@
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile6(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("467179 BookmarkModel::DoneLoading6"));
 
   // Notify our direct observers.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelLoaded(this, details->ids_reassigned()));
 }
 
 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) {
-  scoped_ptr<BookmarkNode> node(delete_me);
+  std::unique_ptr<BookmarkNode> node(delete_me);
 
   const BookmarkNode* parent = node->parent();
   DCHECK(parent);
   int index = parent->GetIndexOf(node.get());
   DCHECK_NE(-1, index);
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillRemoveBookmarks(this, parent, index, node.get()));
 
   std::set<GURL> removed_urls;
@@ skipping 178 matching lines @@
   if (node->is_url())
     nodes_ordered_by_url_set_.insert(node);
   for (int i = 0; i < node->child_count(); ++i)
     PopulateNodesByURL(node->GetChild(i));
 }
 
 int64_t BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
-scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails() {
+std::unique_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails() {
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
-  return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
-      bb_node,
-      other_node,
-      mobile_node,
-      client_->GetLoadExtraNodesCallback(),
-      new BookmarkIndex(client_.get()),
-      next_node_id_));
+  return std::unique_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
+      bb_node, other_node, mobile_node, client_->GetLoadExtraNodesCallback(),
+      new BookmarkIndex(client_.get()), next_node_id_));
 }
 
 void BookmarkModel::SetUndoDelegate(BookmarkUndoDelegate* undo_delegate) {
   undo_delegate_ = undo_delegate;
   if (undo_delegate_)
     undo_delegate_->SetUndoProvider(this);
 }
 
 BookmarkUndoDelegate* BookmarkModel::undo_delegate() const {
   return undo_delegate_ ? undo_delegate_ : empty_undo_delegate_.get();
 }
 
 }  // namespace bookmarks