mojo:: Rename mojo::GetProxy() to mojo::MakeRequest()

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>
 
@@ skipping 190 matching lines @@
   }
 
   MockProxyResolverV8Tracing* mock_proxy_resolver_;
 
   std::unique_ptr<MojoProxyResolverImpl> resolver_impl_;
   interfaces::ProxyResolver* resolver_;
 };
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrl) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
-  TestRequestClient client(mojo::GetProxy(&client_ptr));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   resolver_->GetProxyForUrl(GURL(GURL("http://example.com")),
                             std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
   MockProxyResolverV8Tracing::Job* job =
       mock_proxy_resolver_->pending_jobs()[0].get();
   EXPECT_EQ(GURL(GURL("http://example.com")), job->url);
 
   job->results->UsePacString(
       "PROXY proxy.example.com:1; "
@@ skipping 26 matching lines @@
 
   EXPECT_EQ(ProxyServer::SCHEME_QUIC, servers[4].scheme());
   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));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
   MockProxyResolverV8Tracing::Job* job =
       mock_proxy_resolver_->pending_jobs()[0].get();
   EXPECT_EQ(GURL(GURL("http://example.com")), job->url);
   job->Complete(ERR_FAILED);
   client.WaitForResult();
 
   EXPECT_THAT(client.error(), IsError(ERR_FAILED));
   std::vector<ProxyServer> proxy_servers =
       client.results().proxy_list().GetAll();
   EXPECT_TRUE(proxy_servers.empty());
 }
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
   interfaces::ProxyResolverRequestClientPtr client_ptr1;
-  TestRequestClient client1(mojo::GetProxy(&client_ptr1));
+  TestRequestClient client1(mojo::MakeRequest(&client_ptr1));
   interfaces::ProxyResolverRequestClientPtr client_ptr2;
-  TestRequestClient client2(mojo::GetProxy(&client_ptr2));
+  TestRequestClient client2(mojo::MakeRequest(&client_ptr2));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr1));
   resolver_->GetProxyForUrl(GURL("https://example.com"),
                             std::move(client_ptr2));
   ASSERT_EQ(2u, mock_proxy_resolver_->pending_jobs().size());
   MockProxyResolverV8Tracing::Job* job1 =
       mock_proxy_resolver_->pending_jobs()[0].get();
   EXPECT_EQ(GURL(GURL("http://example.com")), job1->url);
   MockProxyResolverV8Tracing::Job* job2 =
       mock_proxy_resolver_->pending_jobs()[1].get();
@@ skipping 20 matching lines @@
   ASSERT_EQ(1u, proxy_servers1.size());
   ProxyServer& server2 = proxy_servers2[0];
   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;
   std::unique_ptr<TestRequestClient> client(
-      new TestRequestClient(mojo::GetProxy(&client_ptr)));
+      new TestRequestClient(mojo::MakeRequest(&client_ptr)));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
   const MockProxyResolverV8Tracing::Job* job =
       mock_proxy_resolver_->pending_jobs()[0].get();
   EXPECT_EQ(GURL(GURL("http://example.com")), job->url);
   job->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));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
   resolver_impl_.reset();
   client.event_waiter().WaitForEvent(TestRequestClient::CONNECTION_ERROR);
 }
 
 }  // namespace net