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

chrome/browser/ssl/certificate_reporting_test_utils.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/ssl/certificate_reporting_test_utils.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
@@ skipping 13 matching lines @@
 
 using safe_browsing::SafeBrowsingService;
 using safe_browsing::SafeBrowsingUIManager;
 
 namespace {
 
 void SetMockReporter(
     SafeBrowsingService* safe_browsing_service,
     scoped_ptr<certificate_reporting::ErrorReporter> reporter) {
   safe_browsing_service->ping_manager()->SetCertificateErrorReporterForTesting(
-      reporter.Pass());
+      std::move(reporter));
 }
 
 // This is a test implementation of the interface that blocking pages
 // use to send certificate reports. It checks that the blocking page
 // calls or does not call the report method when a report should or
 // should not be sent, respectively.
 class MockSSLCertReporter : public SSLCertReporter {
  public:
   MockSSLCertReporter(
       const scoped_refptr<SafeBrowsingUIManager>& safe_browsing_ui_manager,
@@ skipping 110 matching lines @@
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   EXPECT_TRUE(sb_service);
   if (!sb_service)
     return nullptr;
 
   scoped_ptr<MockSSLCertReporter> ssl_cert_reporter(new MockSSLCertReporter(
       sb_service->ui_manager(), expect_report == CERT_REPORT_EXPECTED
                                     ? run_loop->QuitClosure()
                                     : base::Bind(&base::DoNothing)));
   ssl_cert_reporter->set_expect_report(expect_report == CERT_REPORT_EXPECTED);
-  return ssl_cert_reporter.Pass();
+  return std::move(ssl_cert_reporter);
 }
 
 ExpectReport GetReportExpectedFromFinch() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       CertReportHelper::kFinchExperimentName);
 
   if (group_name == CertReportHelper::kFinchGroupShowPossiblySend) {
     const std::string param = variations::GetVariationParamValue(
         CertReportHelper::kFinchExperimentName,
         CertReportHelper::kFinchParamName);
     double sendingThreshold;
     if (!base::StringToDouble(param, &sendingThreshold))
       return CERT_REPORT_NOT_EXPECTED;
 
     if (sendingThreshold == 1.0)
       return certificate_reporting_test_utils::CERT_REPORT_EXPECTED;
   }
   return certificate_reporting_test_utils::CERT_REPORT_NOT_EXPECTED;
 }
 
 }  // namespace certificate_reporting_test_utils