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

components/bookmarks/managed/managed_bookmark_service.cc

 // Copyright 2015 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/managed/managed_bookmark_service.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <utility>
 #include <vector>
@@ skipping 11 matching lines @@
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace bookmarks {
 namespace {
 
 // BookmarkPermanentNodeLoader initializes a BookmarkPermanentNode from a JSON
 // representation, title id and starting node id.
 class BookmarkPermanentNodeLoader {
  public:
-  BookmarkPermanentNodeLoader(scoped_ptr<BookmarkPermanentNode> node,
-                              scoped_ptr<base::ListValue> initial_bookmarks,
-                              int title_id)
+  BookmarkPermanentNodeLoader(
+      std::unique_ptr<BookmarkPermanentNode> node,
+      std::unique_ptr<base::ListValue> initial_bookmarks,
+      int title_id)
       : node_(std::move(node)),
         initial_bookmarks_(std::move(initial_bookmarks)),
         title_id_(title_id) {
     DCHECK(node_);
   }
 
   ~BookmarkPermanentNodeLoader() {}
 
   // Initializes |node_| from |initial_bookmarks_| and |title_id_| and returns
   // it. The ids are assigned starting at |next_node_id| and the value is
   // updated as a side-effect.
-  scoped_ptr<BookmarkPermanentNode> Load(int64_t* next_node_id) {
+  std::unique_ptr<BookmarkPermanentNode> Load(int64_t* next_node_id) {
     node_->set_id(*next_node_id);
     *next_node_id = ManagedBookmarksTracker::LoadInitial(
         node_.get(), initial_bookmarks_.get(), node_->id() + 1);
     node_->set_visible(!node_->empty());
     node_->SetTitle(l10n_util::GetStringUTF16(title_id_));
     return std::move(node_);
   }
 
  private:
-  scoped_ptr<BookmarkPermanentNode> node_;
-  scoped_ptr<base::ListValue> initial_bookmarks_;
+  std::unique_ptr<BookmarkPermanentNode> node_;
+  std::unique_ptr<base::ListValue> initial_bookmarks_;
   int title_id_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkPermanentNodeLoader);
 };
 
 // Returns a list of initialized BookmarkPermanentNodes using |next_node_id| to
 // start assigning id. |next_node_id| is updated as a side effect of calling
 // this method.
 BookmarkPermanentNodeList LoadExtraNodes(
     ScopedVector<BookmarkPermanentNodeLoader> loaders,
@@ skipping 32 matching lines @@
 
   GetManagementDomainCallback unbound_callback;
   supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
       bookmark_model_, prefs_, true /* is_supervised */, unbound_callback));
 }
 
 LoadExtraCallback ManagedBookmarkService::GetLoadExtraNodesCallback() {
   // Create two BookmarkPermanentNode with a temporary id of 0. They will be
   // populated and assigned proper ids in the LoadExtraNodes callback. Until
   // then, they are owned by the returned closure.
-  scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0));
-  scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(0));
+  std::unique_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0));
+  std::unique_ptr<BookmarkPermanentNode> supervised(
+      new BookmarkPermanentNode(0));
 
   managed_node_ = managed.get();
   supervised_node_ = supervised.get();
 
   ScopedVector<BookmarkPermanentNodeLoader> loaders;
   loaders.push_back(new BookmarkPermanentNodeLoader(
       std::move(managed),
       managed_bookmarks_tracker_->GetInitialManagedBookmarks(),
       IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME));
   loaders.push_back(new BookmarkPermanentNodeLoader(
@@ skipping 55 matching lines @@
   }
 
   managed_bookmarks_tracker_.reset();
   supervised_bookmarks_tracker_.reset();
 
   managed_node_ = nullptr;
   supervised_node_ = nullptr;
 }
 
 }  // namespace bookmarks