Convert Pass()→std::move() in //chrome/browser/chromeos/policy

chrome/browser/chromeos/policy/user_network_configuration_updater.cc

 // Copyright 2013 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/chromeos/policy/user_network_configuration_updater.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/onc/onc_certificate_importer_impl.h"
@@ skipping 15 matching lines @@
     const user_manager::User& user,
     PolicyService* policy_service,
     chromeos::ManagedNetworkConfigurationHandler* network_config_handler) {
   scoped_ptr<UserNetworkConfigurationUpdater> updater(
       new UserNetworkConfigurationUpdater(profile,
                                           allow_trusted_certs_from_policy,
                                           user,
                                           policy_service,
                                           network_config_handler));
   updater->Init();
-  return updater.Pass();
+  return updater;
 }
 
 void UserNetworkConfigurationUpdater::AddTrustedCertsObserver(
     WebTrustedCertsObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void UserNetworkConfigurationUpdater::RemoveTrustedCertsObserver(
     WebTrustedCertsObserver* observer) {
   observer_list_.RemoveObserver(observer);
@@ skipping 17 matching lines @@
   // call, which is not safe before the profile initialization is finalized.
   // Thus, listen for PROFILE_ADDED notification, on which |cert_importer_|
   // creation should start.
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_ADDED,
                  content::Source<Profile>(profile));
 }
 
 void UserNetworkConfigurationUpdater::SetCertificateImporterForTest(
     scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer) {
-  SetCertificateImporter(certificate_importer.Pass());
+  SetCertificateImporter(std::move(certificate_importer));
 }
 
 void UserNetworkConfigurationUpdater::GetWebTrustedCertificates(
     net::CertificateList* certs) const {
   *certs = web_trust_certs_;
 }
 
 void UserNetworkConfigurationUpdater::OnCertificatesImported(
     bool /* unused success */,
     const net::CertificateList& onc_trusted_certificates) {
@@ skipping 50 matching lines @@
   DCHECK(database);
   SetCertificateImporter(scoped_ptr<chromeos::onc::CertificateImporter>(
       new chromeos::onc::CertificateImporterImpl(
           content::BrowserThread::GetMessageLoopProxyForThread(
               content::BrowserThread::IO),
           database)));
 }
 
 void UserNetworkConfigurationUpdater::SetCertificateImporter(
     scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer) {
-  certificate_importer_ = certificate_importer.Pass();
+  certificate_importer_ = std::move(certificate_importer);
 
   if (pending_certificates_onc_)
     ImportCertificates(*pending_certificates_onc_);
   pending_certificates_onc_.reset();
 }
 
 void UserNetworkConfigurationUpdater::NotifyTrustAnchorsChanged() {
   FOR_EACH_OBSERVER(WebTrustedCertsObserver,
                     observer_list_,
                     OnTrustAnchorsChanged(web_trust_certs_));
 }
 
 }  // namespace policy