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

net/proxy/mojo_proxy_resolver_impl_unittest.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 "net/proxy/mojo_proxy_resolver_impl.h"
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_v8_tracing.h"
 #include "net/proxy/proxy_server.h"
@@ skipping 35 matching lines @@
   Error error_ = ERR_FAILED;
   mojo::Array<interfaces::ProxyServerPtr> results_;
 
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 
   EventWaiter<Event> event_waiter_;
 };
 
 TestRequestClient::TestRequestClient(
     mojo::InterfaceRequest<interfaces::ProxyResolverRequestClient> request)
-    : binding_(this, request.Pass()) {
+    : binding_(this, std::move(request)) {
   binding_.set_connection_error_handler(base::Bind(
       &TestRequestClient::OnConnectionError, base::Unretained(this)));
 }
 
 void TestRequestClient::WaitForResult() {
   if (done_)
     return;
 
   event_waiter_.WaitForEvent(RESULT_RECEIVED);
   ASSERT_TRUE(done_);
 }
 
 void TestRequestClient::ReportResult(
     int32_t error,
     mojo::Array<interfaces::ProxyServerPtr> results) {
   event_waiter_.NotifyEvent(RESULT_RECEIVED);
   ASSERT_FALSE(done_);
   error_ = static_cast<Error>(error);
-  results_ = results.Pass();
+  results_ = std::move(results);
   done_ = true;
 }
 
 void TestRequestClient::Alert(const mojo::String& message) {
 }
 
 void TestRequestClient::OnError(int32_t line_number,
                                 const mojo::String& message) {
 }
 
@@ skipping 77 matching lines @@
 }
 
 }  // namespace
 
 class MojoProxyResolverImplTest : public testing::Test {
  protected:
   void SetUp() override {
     scoped_ptr<MockProxyResolverV8Tracing> mock_resolver(
         new MockProxyResolverV8Tracing);
     mock_proxy_resolver_ = mock_resolver.get();
-    resolver_impl_.reset(new MojoProxyResolverImpl(mock_resolver.Pass()));
+    resolver_impl_.reset(new MojoProxyResolverImpl(std::move(mock_resolver)));
     resolver_ = resolver_impl_.get();
   }
 
   MockProxyResolverV8Tracing* mock_proxy_resolver_;
 
   scoped_ptr<MojoProxyResolverImpl> resolver_impl_;
   interfaces::ProxyResolver* resolver_;
 };
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrl) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
-  resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
+  resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request.url);
 
   request.results->UsePacString(
       "PROXY proxy.example.com:1; "
       "SOCKS4 socks4.example.com:2; "
       "SOCKS5 socks5.example.com:3; "
       "HTTPS https.example.com:4; "
@@ skipping 26 matching lines @@
   EXPECT_EQ("quic.example.com", servers[4].host_port_pair().host());
   EXPECT_EQ(65000, servers[4].host_port_pair().port());
 
   EXPECT_EQ(ProxyServer::SCHEME_DIRECT, servers[5].scheme());
 }
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrlFailure) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
-  resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
+  resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request.url);
   request.callback.Run(ERR_FAILED);
   client.WaitForResult();
 
   EXPECT_EQ(ERR_FAILED, client.error());
   std::vector<ProxyServer> proxy_servers =
       client.results().To<std::vector<ProxyServer>>();
   EXPECT_TRUE(proxy_servers.empty());
 }
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
   interfaces::ProxyResolverRequestClientPtr client_ptr1;
   TestRequestClient client1(mojo::GetProxy(&client_ptr1));
   interfaces::ProxyResolverRequestClientPtr client_ptr2;
   TestRequestClient client2(mojo::GetProxy(&client_ptr2));
 
-  resolver_->GetProxyForUrl("http://example.com", client_ptr1.Pass());
-  resolver_->GetProxyForUrl("https://example.com", client_ptr2.Pass());
+  resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr1));
+  resolver_->GetProxyForUrl("https://example.com", std::move(client_ptr2));
   ASSERT_EQ(2u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request1 =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request1.url);
   const MockProxyResolverV8Tracing::Request& request2 =
       mock_proxy_resolver_->pending_requests()[1];
   EXPECT_EQ(GURL("https://example.com"), request2.url);
   request1.results->UsePacString("HTTPS proxy.example.com:12345");
   request1.callback.Run(OK);
   request2.results->UsePacString("SOCKS5 another-proxy.example.com:6789");
@@ skipping 18 matching lines @@
   EXPECT_EQ(ProxyServer::SCHEME_SOCKS5, server2.scheme());
   EXPECT_EQ("another-proxy.example.com", server2.host_port_pair().host());
   EXPECT_EQ(6789, server2.host_port_pair().port());
 }
 
 TEST_F(MojoProxyResolverImplTest, DestroyClient) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   scoped_ptr<TestRequestClient> client(
       new TestRequestClient(mojo::GetProxy(&client_ptr)));
 
-  resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
+  resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request.url);
   request.results->UsePacString("PROXY proxy.example.com:8080");
   client.reset();
   mock_proxy_resolver_->WaitForCancel();
 }
 
 TEST_F(MojoProxyResolverImplTest, DestroyService) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
-  resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
+  resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   resolver_impl_.reset();
   client.event_waiter().WaitForEvent(TestRequestClient::CONNECTION_ERROR);
 }
 
 }  // namespace net