Add LoadState reporting to the mojo proxy resolver.

net/proxy/proxy_resolver_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_mojo.h"
 
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 35 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:
   explicit MockMojoProxyResolver(
       mojo::InterfaceRequest<interfaces::ProxyResolver> req);
   ~MockMojoProxyResolver() override;
 
   void AddPacScriptAction(SetPacScriptAction action);
   // Returned script data is UTF8.
   std::string pac_script_data() { return pac_script_data_; }
 
   void AddGetProxyAction(GetProxyForUrlAction action);
 
   void WaitForNextRequest();
 
+  void ClearBlockedClients();
+
  private:
   // Overridden from interfaces::ProxyResolver:
   void SetPacScript(const mojo::String& data,
                     const mojo::Callback<void(int32_t)>& callback) override;
   void GetProxyForUrl(
       const mojo::String& url,
       interfaces::ProxyResolverRequestClientPtr client) override;
 
   void WakeWaiter();
 
   std::string pac_script_data_;
   std::queue<SetPacScriptAction> pac_script_actions_;
 
   std::queue<GetProxyForUrlAction> get_proxy_actions_;
 
   base::Closure quit_closure_;
 
+  ScopedVector<interfaces::ProxyResolverRequestClientPtr> blocked_clients_;
   mojo::Binding<interfaces::ProxyResolver> binding_;
 };
 
 MockMojoProxyResolver::MockMojoProxyResolver(
     mojo::InterfaceRequest<interfaces::ProxyResolver> req)
     : binding_(this, req.Pass()) {
 }
 
 MockMojoProxyResolver::~MockMojoProxyResolver() {
   EXPECT_TRUE(pac_script_actions_.empty())
@@ skipping 35 matching lines @@
     case SetPacScriptAction::COMPLETE:
       callback.Run(action.error);
       break;
     case SetPacScriptAction::DISCONNECT:
       binding_.Close();
       break;
   }
   WakeWaiter();
 }
 
+void MockMojoProxyResolver::ClearBlockedClients() {
+  blocked_clients_.clear();
+}
+
 void MockMojoProxyResolver::GetProxyForUrl(
     const mojo::String& url,
     interfaces::ProxyResolverRequestClientPtr client) {
   ASSERT_FALSE(get_proxy_actions_.empty());
   GetProxyForUrlAction action = get_proxy_actions_.front();
   get_proxy_actions_.pop();
 
   EXPECT_EQ(action.expected_url.spec(), url.To<std::string>());
   switch (action.action) {
     case GetProxyForUrlAction::COMPLETE:
       client->ReportResult(action.error, action.proxy_servers.Pass());
       break;
     case GetProxyForUrlAction::DROP:
       client.reset();
       break;
     case GetProxyForUrlAction::DISCONNECT:
       binding_.Close();
       break;
     case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT:
       ASSERT_FALSE(client.WaitForIncomingMethodCall());
       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 TestMojoProxyResolverFactory : public MojoProxyResolverFactory {
  public:
   TestMojoProxyResolverFactory();
   ~TestMojoProxyResolverFactory();
 
   // Overridden from MojoProxyResolverFactory:
@@ skipping 57 matching lines @@
 class Request {
  public:
   Request(ProxyResolverMojo* 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:
   ProxyResolverMojo* resolver_;
   const GURL url_;
   ProxyInfo results_;
   ProxyResolver::RequestHandle handle_;
   int error_;
   TestCompletionCallback callback_;
 };
 
@@ skipping 199 matching lines @@
   EXPECT_EQ(OK, request->WaitForResult());
 
   EXPECT_EQ("DIRECT", request->results().ToPacString());
 }
 
 TEST_F(ProxyResolverMojoTest, GetProxyForURL_WithoutSetPacScript) {
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve());
 }
 
+TEST_F(ProxyResolverMojoTest, GetProxyForURL_LoadState) {
+  mojo_proxy_resolver_factory_.AddFutureGetProxyAction(
+      0, GetProxyForUrlAction::SendLoadStateChanged(GURL(kExampleUrl)));
+  SetPacScript(0);
+
+  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());
+  mojo_proxy_resolver_factory_.GetMockResolver().ClearBlockedClients();
+  EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult());
+}
+
 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleResults) {
   static const char kPacString[] =
       "PROXY foo1:80;DIRECT;SOCKS foo2:1234;"
       "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888";
   mojo_proxy_resolver_factory_.AddFutureGetProxyAction(
       0, GetProxyForUrlAction::ReturnServers(
              GURL(kExampleUrl), ProxyServersFromPacString(kPacString)));
   SetPacScript(0);
 
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
@@ skipping 153 matching lines @@
   // resolve request.
   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());
 
   EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls());
 }
 
 }  // namespace net