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

chrome/browser/ssl/captive_portal_blocking_page_browsertest.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/captive_portal_blocking_page.h"
 
 #include <string>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/interstitials/security_interstitial_page_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/cert_report_helper.h"
@@ skipping 45 matching lines @@
       const GURL& request_url,
       const GURL& login_url,
       scoped_ptr<SSLCertReporter> ssl_cert_reporter,
       const net::SSLInfo& ssl_info,
       const base::Callback<void(bool)>& callback,
       bool is_wifi,
       const std::string& wifi_ssid)
       : CaptivePortalBlockingPage(web_contents,
                                   request_url,
                                   login_url,
-                                  ssl_cert_reporter.Pass(),
+                                  std::move(ssl_cert_reporter),
                                   ssl_info,
                                   callback),
         is_wifi_(is_wifi),
         wifi_ssid_(wifi_ssid) {}
 
  private:
   bool IsWifiConnection() const override { return is_wifi_; }
   std::string GetWiFiSSID() const override { return wifi_ssid_; }
   const bool is_wifi_;
   const std::string wifi_ssid_;
@@ skipping 45 matching lines @@
     const std::string& expected_login_hostname) {
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   DCHECK(contents);
   net::SSLInfo ssl_info;
   ssl_info.cert = new net::X509Certificate(
       login_url.host(), "CA", base::Time::Max(), base::Time::Max());
   // Blocking page is owned by the interstitial.
   CaptivePortalBlockingPage* blocking_page =
       new CaptivePortalBlockingPageForTesting(
-          contents, GURL(kBrokenSSL), login_url, ssl_cert_reporter.Pass(),
+          contents, GURL(kBrokenSSL), login_url, std::move(ssl_cert_reporter),
           ssl_info, base::Callback<void(bool)>(), is_wifi_connection,
           wifi_ssid);
   blocking_page->Show();
 
   WaitForInterstitialAttach(contents);
   EXPECT_TRUE(
       WaitForRenderFrameReady(contents->GetInterstitialPage()->GetMainFrame()));
   EXPECT_EQ(expect_wifi == EXPECT_WIFI_YES,
             IsInterstitialDisplayingText(contents->GetInterstitialPage(),
                                          "Wi-Fi"));
@@ skipping 24 matching lines @@
 
 void CaptivePortalBlockingPageTest::TestInterstitial(
     bool is_wifi_connection,
     const std::string& wifi_ssid,
     const GURL& login_url,
     ExpectWiFi expect_wifi,
     ExpectWiFiSSID expect_wifi_ssid,
     ExpectLoginURL expect_login_url,
     scoped_ptr<SSLCertReporter> ssl_cert_reporter) {
   TestInterstitial(is_wifi_connection, wifi_ssid, login_url, expect_wifi,
-                   expect_wifi_ssid, expect_login_url, ssl_cert_reporter.Pass(),
-                   login_url.host());
+                   expect_wifi_ssid, expect_login_url,
+                   std::move(ssl_cert_reporter), login_url.host());
 }
 
 void CaptivePortalBlockingPageTest::TestCertReporting(
     certificate_reporting_test_utils::OptIn opt_in) {
   ASSERT_NO_FATAL_FAILURE(SetUpMockReporter());
 
   certificate_reporting_test_utils::SetCertReportingOptIn(browser(), opt_in);
   base::RunLoop run_loop;
   scoped_ptr<SSLCertReporter> ssl_cert_reporter =
       certificate_reporting_test_utils::SetUpMockSSLCertReporter(
           &run_loop,
           opt_in == certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN
               ? certificate_reporting_test_utils::CERT_REPORT_EXPECTED
               : certificate_reporting_test_utils::CERT_REPORT_NOT_EXPECTED);
 
   const GURL kLandingUrl(captive_portal::CaptivePortalDetector::kDefaultURL);
   TestInterstitial(true, std::string(), kLandingUrl, EXPECT_WIFI_YES,
                    EXPECT_WIFI_SSID_NO, EXPECT_LOGIN_URL_NO,
-                   ssl_cert_reporter.Pass());
+                   std::move(ssl_cert_reporter));
 
   EXPECT_EQ(std::string(), GetLatestHostnameReported());
 
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   tab->GetInterstitialPage()->DontProceed();
 
   if (opt_in == certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN) {
     // Check that the mock reporter received a request to send a report.
     run_loop.Run();
@@ skipping 103 matching lines @@
             base::Callback<void(bool)>(), false, "");
     return blocking_page;
   }
 };
 
 // Test that an IDN login domain is decoded properly.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBlockingPageIDNTest,
                        ShowLoginIDNIfPortalRedirectsDetectionURL) {
   EXPECT_TRUE(VerifyIDNDecoded());
 }