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

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 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 "net/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
-
 #include <cstddef>
+#include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
@@ skipping 346 matching lines @@
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);
 }
 
 SpdySessionDependencies::SpdySessionDependencies(
     NextProto protocol,
     scoped_ptr<ProxyService> proxy_service)
     : host_resolver(new MockHostResolver),
       cert_verifier(new MockCertVerifier),
       transport_security_state(new TransportSecurityState),
-      proxy_service(proxy_service.Pass()),
+      proxy_service(std::move(proxy_service)),
       ssl_config_service(new SSLConfigServiceDefaults),
       socket_factory(new MockClientSocketFactory),
       http_auth_handler_factory(
           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
       enable_ip_pooling(true),
       enable_compression(false),
       enable_ping(false),
       enable_user_alternate_protocol_ports(false),
       enable_npn(true),
       protocol(protocol),
@@ skipping 10 matching lines @@
 SpdySessionDependencies::~SpdySessionDependencies() {}
 
 // static
 scoped_ptr<HttpNetworkSession> SpdySessionDependencies::SpdyCreateSession(
     SpdySessionDependencies* session_deps) {
   HttpNetworkSession::Params params = CreateSessionParams(session_deps);
   params.client_socket_factory = session_deps->socket_factory.get();
   scoped_ptr<HttpNetworkSession> http_session(new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
   pool_peer.SetEnableSendingInitialData(false);
-  return http_session.Pass();
+  return http_session;
 }
 
 // static
 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
     SpdySessionDependencies* session_deps) {
   DCHECK(next_proto_is_spdy(session_deps->protocol)) <<
       "Invalid protocol: " << session_deps->protocol;
 
   HttpNetworkSession::Params params;
   params.host_resolver = session_deps->host_resolver.get();
@@ skipping 117 matching lines @@
                           net_log);
   }
 
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
   EXPECT_EQ(OK, rv);
 
   base::WeakPtr<SpdySession> spdy_session =
       http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
-          key, connection.Pass(), net_log, OK, is_secure);
+          key, std::move(connection), net_log, OK, is_secure);
   // Failure is reported asynchronously.
   EXPECT_TRUE(spdy_session != NULL);
   EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
   return spdy_session;
 }
 
 }  // namespace
 
 base::WeakPtr<SpdySession> CreateInsecureSpdySession(
     HttpNetworkSession* http_session,
@@ skipping 86 matching lines @@
     SpdySessionPool* pool,
     const SpdySessionKey& key,
     Error expected_status) {
   EXPECT_NE(expected_status, ERR_IO_PENDING);
   EXPECT_FALSE(HasSpdySession(pool, key));
   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
   handle->SetSocket(scoped_ptr<StreamSocket>(new FakeSpdySessionClientSocket(
       expected_status == OK ? ERR_IO_PENDING : expected_status)));
   base::WeakPtr<SpdySession> spdy_session =
       pool->CreateAvailableSessionFromSocket(
-          key, handle.Pass(), BoundNetLog(), OK, true /* is_secure */);
+          key, std::move(handle), BoundNetLog(), OK, true /* is_secure */);
   // Failure is reported asynchronously.
   EXPECT_TRUE(spdy_session != NULL);
   EXPECT_TRUE(HasSpdySession(pool, key));
   return spdy_session;
 }
 
 }  // namespace
 
 base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
                                                  const SpdySessionKey& key) {
@@ skipping 51 matching lines @@
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
     base::StringPiece url) const {
   return ConstructHeaderBlock("GET", url, NULL);
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
     base::StringPiece url) const {
   scoped_ptr<SpdyHeaderBlock> headers(ConstructGetHeaderBlock(url));
-  return headers.Pass();
+  return headers;
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeadHeaderBlock(
     base::StringPiece url,
     int64_t content_length) const {
   return ConstructHeaderBlock("HEAD", url, nullptr);
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
     base::StringPiece url,
@@ skipping 47 matching lines @@
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
                                             const char* const extra_headers[],
                                             int extra_header_count,
                                             const char* const tail_headers[],
                                             int tail_header_count) const {
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
   if (tail_headers && tail_header_count)
     AppendToHeaderBlock(tail_headers, tail_header_count, headers.get());
-  return ConstructSpdyFrame(header_info, headers.Pass());
+  return ConstructSpdyFrame(header_info, std::move(headers));
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
     scoped_ptr<SpdyHeaderBlock> headers,
     bool compressed,
     SpdyStreamId stream_id,
     RequestPriority request_priority,
     SpdyFrameType type,
     SpdyControlFlags flags,
     SpdyStreamId associated_stream_id) const {
   EXPECT_GE(type, DATA);
   EXPECT_LE(type, PRIORITY);
   const SpdyHeaderInfo header_info = {
     type,
     stream_id,
     associated_stream_id,
     ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
     flags,
     compressed,
     RST_STREAM_INVALID,  // status
     NULL,  // data
     0,  // length
     DATA_FLAG_NONE
   };
-  return ConstructSpdyFrame(header_info, headers.Pass());
+  return ConstructSpdyFrame(header_info, std::move(headers));
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
     const char* const extra_headers[],
     int extra_header_count,
     bool compressed,
     SpdyStreamId stream_id,
     RequestPriority request_priority,
     SpdyFrameType type,
     SpdyControlFlags flags,
     const char* const* tail_headers,
     int tail_header_size,
     SpdyStreamId associated_stream_id) const {
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
   if (tail_headers && tail_header_size)
     AppendToHeaderBlock(tail_headers, tail_header_size / 2, headers.get());
-  return ConstructSpdyControlFrame(
-      headers.Pass(), compressed, stream_id,
-      request_priority, type, flags, associated_stream_id);
+  return ConstructSpdyControlFrame(std::move(headers), compressed, stream_id,
+                                   request_priority, type, flags,
+                                   associated_stream_id);
 }
 
 std::string SpdyTestUtil::ConstructSpdyReplyString(
     const SpdyHeaderBlock& headers) const {
   std::string reply_string;
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
     std::string key = it->first.as_string();
     // Remove leading colon from "special" headers (for SPDY3 and
     // above).
@@ skipping 422 matching lines @@
         return;
       }
     }
   }
   NOTREACHED();
 }
 
 scoped_ptr<SpdyFramer> SpdyTestUtil::CreateFramer(bool compressed) const {
   scoped_ptr<SpdyFramer> framer(new SpdyFramer(spdy_version_));
   framer->set_enable_compression(compressed);
-  return framer.Pass();
+  return framer;
 }
 
 const char* SpdyTestUtil::GetMethodKey() const {
   return ":method";
 }
 
 const char* SpdyTestUtil::GetStatusKey() const {
   return ":status";
 }
 
@@ skipping 27 matching lines @@
     (*headers)[GetVersionKey()] = "HTTP/1.1";
   }
   (*headers)[GetMethodKey()] = method.as_string();
   (*headers)[GetHostKey()] = host.c_str();
   (*headers)[GetSchemeKey()] = scheme.c_str();
   (*headers)[GetPathKey()] = path.c_str();
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     (*headers)["content-length"] = length_str;
   }
-  return headers.Pass();
+  return headers;
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(
     SpdyFrameWithHeaderBlockIR* frame_ir) const {
   if (include_version_header()) {
     frame_ir->SetHeader(GetVersionKey(), "HTTP/1.1");
   }
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const {
   if (include_version_header()) {
     (*block)[GetVersionKey()] = "HTTP/1.1";
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net