Convert //chrome/browser/supervised_user from scoped_ptr to std::unique_ptr

chrome/browser/supervised_user/supervised_user_bookmarks_handler.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 "chrome/browser/supervised_user/supervised_user_bookmarks_handler.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 80 matching lines @@
     const std::string& url, const std::string& name, int parent_id)
     : url(url), name(name), parent_id(parent_id) {
 }
 
 SupervisedUserBookmarksHandler::SupervisedUserBookmarksHandler() {
 }
 
 SupervisedUserBookmarksHandler::~SupervisedUserBookmarksHandler() {
 }
 
-scoped_ptr<base::ListValue> SupervisedUserBookmarksHandler::BuildBookmarksTree(
+std::unique_ptr<base::ListValue>
+SupervisedUserBookmarksHandler::BuildBookmarksTree(
     const base::DictionaryValue& settings) {
   SupervisedUserBookmarksHandler handler;
   handler.ParseSettings(settings);
   return handler.BuildTree();
 }
 
 void SupervisedUserBookmarksHandler::ParseSettings(
     const base::DictionaryValue& settings) {
   const base::DictionaryValue* folders;
   if (settings.GetDictionary(kKeyFolder, &folders))
@@ skipping 30 matching lines @@
     std::string value;
     it.value().GetAsString(&value);
     std::string name;
     int parent_id;
     if (!ExtractIdAndValue(value, &parent_id, &name))
       continue;
     links_.push_back(Link(url, name, parent_id));
   }
 }
 
-scoped_ptr<base::ListValue> SupervisedUserBookmarksHandler::BuildTree() {
+std::unique_ptr<base::ListValue> SupervisedUserBookmarksHandler::BuildTree() {
   root_.reset(new base::ListValue);
   AddFoldersToTree();
   AddLinksToTree();
   return std::move(root_);
 }
 
 void SupervisedUserBookmarksHandler::AddFoldersToTree() {
   // Go over all folders and try inserting them into the correct position in the
   // tree. This requires the respective parent folder to be there already. Since
   // the parent might appear later in |folders_|, we might need multiple rounds
   // until all folders can be added successfully.
   // To avoid an infinite loop in the case of a non-existing parent, we take
   // care to stop when no folders could be added in a round.
   std::vector<Folder> folders = folders_;
   std::vector<Folder> folders_failed;
   while (!folders.empty() && folders.size() != folders_failed.size()) {
     folders_failed.clear();
     for (const auto& folder : folders) {
-      scoped_ptr<base::DictionaryValue> node(new base::DictionaryValue);
+      std::unique_ptr<base::DictionaryValue> node(new base::DictionaryValue);
       node->SetIntegerWithoutPathExpansion(kId, folder.id);
       node->SetStringWithoutPathExpansion(kName, folder.name);
       node->SetWithoutPathExpansion(kChildren, new base::ListValue);
       if (!AddNodeToTree(folder.parent_id, std::move(node)))
         folders_failed.push_back(folder);
     }
     folders.swap(folders_failed);
   }
   if (!folders_failed.empty()) {
     LOG(WARNING) << "SupervisedUserBookmarksHandler::AddFoldersToTree"
                  << " failed adding the following folders (id,name,parent):";
     for (const Folder& folder : folders_failed) {
       LOG(WARNING) << folder.id << ", " << folder.name << ", "
                    << folder.parent_id;
     }
   }
 }
 
 void SupervisedUserBookmarksHandler::AddLinksToTree() {
   for (const auto& link : links_) {
-    scoped_ptr<base::DictionaryValue> node(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> node(new base::DictionaryValue);
     GURL url = url_formatter::FixupURL(link.url, std::string());
     if (!url.is_valid()) {
       LOG(WARNING) << "Got invalid URL: " << link.url;
       continue;
     }
     node->SetStringWithoutPathExpansion(kUrl, url.spec());
     node->SetStringWithoutPathExpansion(kName, link.name);
     if (!AddNodeToTree(link.parent_id, std::move(node))) {
       LOG(WARNING) << "SupervisedUserBookmarksHandler::AddLinksToTree"
                    << " failed to add link (url,name,parent): "
                    << link.url << ", " << link.name << ", " << link.parent_id;
     }
   }
 }
 
 bool SupervisedUserBookmarksHandler::AddNodeToTree(
     int parent_id,
-    scoped_ptr<base::DictionaryValue> node) {
+    std::unique_ptr<base::DictionaryValue> node) {
   base::ListValue* parent = FindFolder(root_.get(), parent_id);
   if (!parent)
     return false;
   parent->Append(node.release());
   return true;
 }