Split ProxyResolverV8Tracing into an implementation and a wrapper.

net/proxy/proxy_resolver_factory_mojo_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/proxy_resolver_factory_mojo.h"
 
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 83 matching lines @@
 
 struct GetProxyForUrlAction {
   enum Action {
     COMPLETE,
     // Drop the request by closing the reply channel.
     DROP,
     // Disconnect the service.
     DISCONNECT,
     // Wait for the client pipe to be disconnected.
     WAIT_FOR_CLIENT_DISCONNECT,
-    // Send a LoadStateChanged message and keep the client pipe open.
-    SEND_LOAD_STATE_AND_BLOCK,
   };
 
   GetProxyForUrlAction() {}
   GetProxyForUrlAction(const GetProxyForUrlAction& old) {
     action = old.action;
     error = old.error;
     expected_url = old.expected_url;
     proxy_servers = old.proxy_servers.Clone();
   }
 
@@ skipping 27 matching lines @@
     return result;
   }
 
   static GetProxyForUrlAction WaitForClientDisconnect(const GURL& url) {
     GetProxyForUrlAction result;
     result.expected_url = url;
     result.action = WAIT_FOR_CLIENT_DISCONNECT;
     return result;
   }
 
-  static GetProxyForUrlAction SendLoadStateChanged(const GURL& url) {
-    GetProxyForUrlAction result;
-    result.expected_url = url;
-    result.action = SEND_LOAD_STATE_AND_BLOCK;
-    return result;
-  }
-
   Action action = COMPLETE;
   Error error = OK;
   mojo::Array<interfaces::ProxyServerPtr> proxy_servers;
   GURL expected_url;
 };
 
 class MockMojoProxyResolver : public interfaces::ProxyResolver {
  public:
   MockMojoProxyResolver();
   ~MockMojoProxyResolver() override;
@@ skipping 73 matching lines @@
       break;
     case GetProxyForUrlAction::DROP:
       client.reset();
       break;
     case GetProxyForUrlAction::DISCONNECT:
       binding_.Close();
       break;
     case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT:
       ASSERT_FALSE(client.WaitForIncomingResponse());
       break;
-    case GetProxyForUrlAction::SEND_LOAD_STATE_AND_BLOCK:
-      client->LoadStateChanged(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
-      blocked_clients_.push_back(
-          new interfaces::ProxyResolverRequestClientPtr(client.Pass()));
-      break;
   }
   WakeWaiter();
 }
 
 class Request {
  public:
   Request(ProxyResolver* resolver, const GURL& url);
 
   int Resolve();
   void Cancel();
   int WaitForResult();
 
   int error() const { return error_; }
   const ProxyInfo& results() const { return results_; }
-  LoadState load_state() { return resolver_->GetLoadState(handle_); }
 
  private:
   ProxyResolver* resolver_;
   const GURL url_;
   ProxyInfo results_;
   ProxyResolver::RequestHandle handle_;
   int error_;
   TestCompletionCallback callback_;
 };
 
@@ skipping 309 matching lines @@
       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
   CreateProxyResolver();
 
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
 
   EXPECT_EQ("DIRECT", request->results().ToPacString());
 }
 
-TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_LoadState) {
-  mock_proxy_resolver_.AddGetProxyAction(
-      GetProxyForUrlAction::SendLoadStateChanged(GURL(kExampleUrl)));
-  CreateProxyResolver();
-
-  scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, request->load_state());
-  while (request->load_state() == LOAD_STATE_RESOLVING_PROXY_FOR_URL)
-    base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT, request->load_state());
-  mock_proxy_resolver_.ClearBlockedClients();
-  EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult());
-}
-
 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleResults) {
   static const char kPacString[] =
       "PROXY foo1:80;DIRECT;SOCKS foo2:1234;"
       "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888";
   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
       GURL(kExampleUrl), ProxyServersFromPacString(kPacString)));
   CreateProxyResolver();
 
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
@@ skipping 114 matching lines @@
           &handle, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net