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

net/url_request/url_request_ftp_job_unittest.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/url_request/url_request_ftp_job.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_states.h"
 #include "net/base/request_priority.h"
 #include "net/ftp/ftp_auth_cache.h"
 #include "net/http/http_transaction_test_util.h"
@@ skipping 22 matching lines @@
 
   int CreateProxyResolver(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
       scoped_ptr<ProxyResolver>* resolver,
       const CompletionCallback& callback,
       scoped_ptr<Request>* request) override {
     EXPECT_FALSE(resolver_);
     scoped_ptr<MockAsyncProxyResolver> owned_resolver(
         new MockAsyncProxyResolver());
     resolver_ = owned_resolver.get();
-    *resolver = owned_resolver.Pass();
+    *resolver = std::move(owned_resolver);
     return OK;
   }
 
   MockAsyncProxyResolver* resolver() { return resolver_; }
 
  private:
   MockAsyncProxyResolver* resolver_;
 };
 
 }  // namespace
 
 class FtpTestURLRequestContext : public TestURLRequestContext {
  public:
   FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
                            scoped_ptr<ProxyService> proxy_service,
                            NetworkDelegate* network_delegate,
                            FtpTransactionFactory* ftp_transaction_factory)
       : TestURLRequestContext(true),
         ftp_protocol_handler_(new FtpProtocolHandler(ftp_transaction_factory)) {
     set_client_socket_factory(socket_factory);
-    context_storage_.set_proxy_service(proxy_service.Pass());
+    context_storage_.set_proxy_service(std::move(proxy_service));
     set_network_delegate(network_delegate);
     scoped_ptr<URLRequestJobFactoryImpl> job_factory =
         make_scoped_ptr(new URLRequestJobFactoryImpl);
     job_factory->SetProtocolHandler("ftp",
                                     make_scoped_ptr(ftp_protocol_handler_));
-    context_storage_.set_job_factory(job_factory.Pass());
+    context_storage_.set_job_factory(std::move(job_factory));
     Init();
   }
 
   FtpAuthCache* GetFtpAuthCache() {
     return ftp_protocol_handler_->ftp_auth_cache_.get();
   }
 
   void set_proxy_service(scoped_ptr<ProxyService> proxy_service) {
-    context_storage_.set_proxy_service(proxy_service.Pass());
+    context_storage_.set_proxy_service(std::move(proxy_service));
   }
 
  private:
   FtpProtocolHandler* ftp_protocol_handler_;
 };
 
 namespace {
 
 class SimpleProxyConfigService : public ProxyConfigService {
  public:
@@ skipping 218 matching lines @@
 // Regression test for http://crbug.com/237526.
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestOrphanJob) {
   scoped_ptr<MockProxyResolverFactory> owned_resolver_factory(
       new MockProxyResolverFactory());
   MockProxyResolverFactory* resolver_factory = owned_resolver_factory.get();
 
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
   request_context()->set_proxy_service(make_scoped_ptr(new ProxyService(
       make_scoped_ptr(new ProxyConfigServiceFixed(
           ProxyConfig::CreateFromCustomPacURL(GURL("http://foo")))),
-      owned_resolver_factory.Pass(), nullptr)));
+      std::move(owned_resolver_factory), nullptr)));
 
   TestDelegate request_delegate;
   scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
       GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
   url_request->Start();
 
   // Verify PAC request is in progress.
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
   EXPECT_EQ(1u, resolver_factory->resolver()->pending_requests().size());
@@ skipping 10 matching lines @@
 // above test is not sufficient.
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestCancelRequest) {
   scoped_ptr<MockProxyResolverFactory> owned_resolver_factory(
       new MockProxyResolverFactory());
   MockProxyResolverFactory* resolver_factory = owned_resolver_factory.get();
 
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
   request_context()->set_proxy_service(make_scoped_ptr(new ProxyService(
       make_scoped_ptr(new ProxyConfigServiceFixed(
           ProxyConfig::CreateFromCustomPacURL(GURL("http://foo")))),
-      owned_resolver_factory.Pass(), nullptr)));
+      std::move(owned_resolver_factory), nullptr)));
 
   TestDelegate request_delegate;
   scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
       GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
 
   // Verify PAC request is in progress.
   url_request->Start();
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
   EXPECT_EQ(1u, resolver_factory->resolver()->pending_requests().size());
@@ skipping 424 matching lines @@
   EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate2.data_received());
 }
 
 }  // namespace
 
 }  // namespace net