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

net/http/transport_security_state.cc

 // Copyright (c) 2012 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 "net/http/transport_security_state.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/base64.h"
 #include "base/build_time.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 33 matching lines @@
     const net::X509Certificate* cert_chain) {
   if (!cert_chain)
     return make_scoped_ptr(new base::ListValue());
 
   scoped_ptr<base::ListValue> result(new base::ListValue());
   std::vector<std::string> pem_encoded_chain;
   cert_chain->GetPEMEncodedChain(&pem_encoded_chain);
   for (const std::string& cert : pem_encoded_chain)
     result->Append(make_scoped_ptr(new base::StringValue(cert)));
 
-  return result.Pass();
+  return result;
 }
 
 bool HashReportForCache(const base::DictionaryValue& report,
                         const GURL& report_uri,
                         std::string* cache_key) {
   char hashed[crypto::kSHA256Length];
   std::string to_hash;
   if (!base::JSONWriter::Write(report, &to_hash))
     return false;
   to_hash += "," + report_uri.spec();
@@ skipping 17 matching lines @@
   base::Time now = base::Time::Now();
   report.SetString("hostname", host_port_pair.host());
   report.SetInteger("port", host_port_pair.port());
   report.SetBoolean("include-subdomains", pkp_state.include_subdomains);
   report.SetString("noted-hostname", pkp_state.domain);
 
   scoped_ptr<base::ListValue> served_certificate_chain_list =
       GetPEMEncodedChainAsList(served_certificate_chain);
   scoped_ptr<base::ListValue> validated_certificate_chain_list =
       GetPEMEncodedChainAsList(validated_certificate_chain);
-  report.Set("served-certificate-chain", served_certificate_chain_list.Pass());
+  report.Set("served-certificate-chain",
+             std::move(served_certificate_chain_list));
   report.Set("validated-certificate-chain",
-             validated_certificate_chain_list.Pass());
+             std::move(validated_certificate_chain_list));
 
   scoped_ptr<base::ListValue> known_pin_list(new base::ListValue());
   for (const auto& hash_value : pkp_state.spki_hashes) {
     std::string known_pin;
 
     switch (hash_value.tag) {
       case HASH_VALUE_SHA1:
         known_pin += "pin-sha1=";
         break;
       case HASH_VALUE_SHA256:
         known_pin += "pin-sha256=";
         break;
     }
 
     std::string base64_value;
     base::Base64Encode(
         base::StringPiece(reinterpret_cast<const char*>(hash_value.data()),
                           hash_value.size()),
         &base64_value);
     known_pin += "\"" + base64_value + "\"";
 
     known_pin_list->Append(
         scoped_ptr<base::Value>(new base::StringValue(known_pin)));
   }
 
-  report.Set("known-pins", known_pin_list.Pass());
+  report.Set("known-pins", std::move(known_pin_list));
 
   // For the sent reports cache, do not include the effective expiration
   // date. The expiration date will likely change every time the user
   // visits the site, so it would prevent reports from being effectively
   // deduplicated.
   if (!HashReportForCache(report, pkp_state.report_uri, cache_key)) {
     LOG(ERROR) << "Failed to compute cache key for HPKP violation report.";
     return false;
   }
 
@@ skipping 1159 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace