Convert Pass()→std::move() in //chrome

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "components/url_formatter/url_fixer.h"
 
 namespace {
 
 // Keys of relevant managed user settings.
 const char kKeyLink[] = "SupervisedBookmarkLink";
@@ skipping 127 matching lines @@
     if (!ExtractIdAndValue(value, &parent_id, &name))
       continue;
     links_.push_back(Link(url, name, parent_id));
   }
 }
 
 scoped_ptr<base::ListValue> SupervisedUserBookmarksHandler::BuildTree() {
   root_.reset(new base::ListValue);
   AddFoldersToTree();
   AddLinksToTree();
-  return root_.Pass();
+  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);
       node->SetIntegerWithoutPathExpansion(kId, folder.id);
       node->SetStringWithoutPathExpansion(kName, folder.name);
       node->SetWithoutPathExpansion(kChildren, new base::ListValue);
-      if (!AddNodeToTree(folder.parent_id, node.Pass()))
+      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);
     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, node.Pass())) {
+    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) {
   base::ListValue* parent = FindFolder(root_.get(), parent_id);
   if (!parent)
     return false;
   parent->Append(node.release());
   return true;
 }