Remove ScopedVector in //components/bookmarks

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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/managed/managed_bookmarks_tracker.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace bookmarks {
 namespace {
@@ skipping 31 matching lines @@
   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,
+    std::vector<std::unique_ptr<BookmarkPermanentNodeLoader>> loaders,
     int64_t* next_node_id) {
   BookmarkPermanentNodeList extra_nodes;
-  for (auto* loader : loaders)
+  for (auto& loader : loaders)
     extra_nodes.push_back(loader->Load(next_node_id));
   return extra_nodes;
 }
 
 }  // namespace
 
 ManagedBookmarkService::ManagedBookmarkService(
     PrefService* prefs,
     const GetManagementDomainCallback& callback)
     : prefs_(prefs),
@@ skipping 26 matching lines @@
   // 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.
   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::vector<std::unique_ptr<BookmarkPermanentNodeLoader>> loaders;
+  loaders.push_back(base::MakeUnique<BookmarkPermanentNodeLoader>(
       std::move(managed),
       managed_bookmarks_tracker_->GetInitialManagedBookmarks(),
       IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME));
-  loaders.push_back(new BookmarkPermanentNodeLoader(
+  loaders.push_back(base::MakeUnique<BookmarkPermanentNodeLoader>(
       std::move(supervised),
       supervised_bookmarks_tracker_->GetInitialManagedBookmarks(),
       IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME));
 
   return base::Bind(&LoadExtraNodes, base::Passed(&loaders));
 }
 
 bool ManagedBookmarkService::CanSetPermanentNodeTitle(
     const BookmarkNode* node) {
   // |managed_node_| can have its title updated if the user signs in or out,
@@ skipping 45 matching lines @@
   }
 
   managed_bookmarks_tracker_.reset();
   supervised_bookmarks_tracker_.reset();
 
   managed_node_ = nullptr;
   supervised_node_ = nullptr;
 }
 
 }  // namespace bookmarks