Remove ProxyResolver::(Cancel)SetPacScript and LegacyProxyResolverFactory.

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 <vector>
 
 #include "base/run_loop.h"
@@ skipping 74 matching lines @@
 
 void TestRequestClient::LoadStateChanged(int32_t load_state) {
   event_waiter_.NotifyEvent(LOAD_STATE_CHANGED);
   load_state_ = static_cast<LoadState>(load_state);
 }
 
 void TestRequestClient::OnConnectionError() {
   event_waiter_.NotifyEvent(CONNECTION_ERROR);
 }
 
-class CallbackMockProxyResolver : public MockAsyncProxyResolverExpectsBytes {
+class CallbackMockProxyResolver : public MockAsyncProxyResolver {
  public:
   CallbackMockProxyResolver() {}
   ~CallbackMockProxyResolver() override;
 
-  // MockAsyncProxyResolverExpectsBytes overrides.
+  // MockAsyncProxyResolver overrides.
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
                      RequestHandle* request_handle,
                      const BoundNetLog& net_log) override;
   void CancelRequest(RequestHandle request_handle) override;
 
   // Wait until the mock resolver has received a CancelRequest call.
   void WaitForCancel();
 
@@ skipping 13 matching lines @@
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
     RequestHandle* request_handle,
     const BoundNetLog& net_log) {
   if (sync_result_) {
     *results = *sync_result_;
     sync_result_.reset();
     return OK;
   }
-  return MockAsyncProxyResolverExpectsBytes::GetProxyForURL(
-      url, results, callback, request_handle, net_log);
+  return MockAsyncProxyResolver::GetProxyForURL(url, results, callback,
+                                                request_handle, net_log);
 }
 
 void CallbackMockProxyResolver::CancelRequest(RequestHandle request_handle) {
-  MockAsyncProxyResolverExpectsBytes::CancelRequest(request_handle);
+  MockAsyncProxyResolver::CancelRequest(request_handle);
   if (!cancel_callback_.is_null()) {
     cancel_callback_.Run();
     cancel_callback_.Reset();
   }
 }
 
 void CallbackMockProxyResolver::WaitForCancel() {
   while (cancelled_requests().empty()) {
     base::RunLoop run_loop;
     cancel_callback_ = run_loop.QuitClosure();
@@ skipping 34 matching lines @@
   interfaces::ProxyResolver* resolver_;
   ProxyResolver::LoadStateChangedCallback load_state_changed_callback_;
 };
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrl) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request =
+  scoped_refptr<MockAsyncProxyResolver::Request> request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request->url());
 
   ASSERT_FALSE(load_state_changed_callback_.is_null());
   load_state_changed_callback_.Run(request.get(),
                                    LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
   client.event_waiter().WaitForEvent(TestRequestClient::LOAD_STATE_CHANGED);
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT, client.load_state());
 
   request->results()->UsePacString(
@@ skipping 51 matching lines @@
   ProxyServer& server = proxy_servers[0];
   EXPECT_TRUE(server.is_direct());
 }
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrlFailure) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl("http://example.com", client_ptr.Pass());
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request =
+  scoped_refptr<MockAsyncProxyResolver::Request> request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request->url());
   request->CompleteNow(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());
   ASSERT_EQ(2u, mock_proxy_resolver_->pending_requests().size());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request1 =
+  scoped_refptr<MockAsyncProxyResolver::Request> request1 =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request1->url());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request2 =
+  scoped_refptr<MockAsyncProxyResolver::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->CompleteNow(OK);
   request2->results()->UsePacString("SOCKS5 another-proxy.example.com:6789");
   request2->CompleteNow(OK);
   client1.WaitForResult();
   client2.WaitForResult();
 
   EXPECT_EQ(OK, client1.error());
@@ skipping 15 matching lines @@
   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());
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request =
+  scoped_refptr<MockAsyncProxyResolver::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());
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
-  scoped_refptr<MockAsyncProxyResolverBase::Request> request =
+  scoped_refptr<MockAsyncProxyResolver::Request> request =
       mock_proxy_resolver_->pending_requests()[0];
   resolver_impl_.reset();
   client.event_waiter().WaitForEvent(TestRequestClient::CONNECTION_ERROR);
 }
 
 }  // namespace net