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 <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_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_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_script_data.h"
@@ skipping 43 matching lines @@
 
   void AddPacScriptAction(SetPacScriptAction action);
   // Returned script data is UTF8.
   std::string GetPacScriptData() { return pac_script_data_; }
   int GetPacScriptCalls() { return pac_script_calls_; }
 
   void AddProxyResult(const GURL& url,
                       int error,
                       mojo::Array<interfaces::ProxyServerPtr> proxy_servers);
   void CloseRequestClient(const GURL& url);
+  void BlockProxyRequest(const GURL& url);
 
   void Disconnect() { binding_.Close(); }
 
   void WaitForSetPacScript();
 
+  void ClearBlockedClients();
+
  private:
   struct ProxyResults {
-    explicit ProxyResults(bool close)
-        : close(close), error(OK), proxy_servers() {}
+    ProxyResults(bool close, bool block)
+        : close(close), block(block), error(OK), proxy_servers() {}
     ProxyResults(int err, mojo::Array<interfaces::ProxyServerPtr>& s)
-        : close(false), error(err), proxy_servers(s.Pass()) {}
+        : close(false), block(false), error(err), proxy_servers(s.Pass()) {}
 
     bool close;
+    bool block;
     int error;
     mojo::Array<interfaces::ProxyServerPtr> proxy_servers;
   };
 
   // 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;
 
   std::string pac_script_data_;
   std::list<SetPacScriptAction> pac_script_actions_;
   int pac_script_calls_;
   base::Closure pac_script_quit_closure_;
 
   std::map<GURL, ProxyResults*> proxy_results_;
 
+  ScopedVector<interfaces::ProxyResolverRequestClientPtr> blocked_clients_;
   mojo::Binding<interfaces::ProxyResolver> binding_;
 };
 
 void MockMojoProxyResolver::AddProxyResult(
     const GURL& url,
     int error,
     mojo::Array<interfaces::ProxyServerPtr> proxy_servers) {
   proxy_results_[url] = new ProxyResults(error, proxy_servers);
 }
 
 void MockMojoProxyResolver::CloseRequestClient(const GURL& url) {
-  proxy_results_[url] = new ProxyResults(true);
+  proxy_results_[url] = new ProxyResults(true, false);
+}
+
+void MockMojoProxyResolver::BlockProxyRequest(const GURL& url) {
+  proxy_results_[url] = new ProxyResults(false, true);
 }
 
 void MockMojoProxyResolver::AddPacScriptAction(SetPacScriptAction action) {
   pac_script_actions_.push_back(action);
 }
 
 void MockMojoProxyResolver::SetPacScript(
     const mojo::String& data,
     const mojo::Callback<void(int32_t)>& callback) {
   pac_script_data_ = data.To<std::string>();
@@ skipping 19 matching lines @@
 
 void MockMojoProxyResolver::WaitForSetPacScript() {
   if (pac_script_calls_)
     return;
 
   base::RunLoop run_loop;
   pac_script_quit_closure_ = run_loop.QuitClosure();
   run_loop.Run();
 }
 
+void MockMojoProxyResolver::ClearBlockedClients() {
+  blocked_clients_.clear();
+}
+
 void MockMojoProxyResolver::GetProxyForUrl(
     const mojo::String& url,
     interfaces::ProxyResolverRequestClientPtr client) {
   ProxyResults* result = proxy_results_[url.To<GURL>()];
   ASSERT_NE(nullptr, result);
   if (result->close) {
     client.reset();
+  } else if (result->block) {
+    client->LoadStateChanged(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
+    blocked_clients_.push_back(
+        new interfaces::ProxyResolverRequestClientPtr(client.Pass()));
   } else {
     client->ReportResult(result->error, result->proxy_servers.Clone());
   }
 }
 
 class TestMojoProxyResolverFactory : public MojoProxyResolverFactory {
  public:
   TestMojoProxyResolverFactory();
   ~TestMojoProxyResolverFactory();
 
@@ skipping 56 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:
   // Completion callback for ProxyResolverMojo::Resolve.
   void OnResolveDone(int error);
 
   ProxyResolverMojo* resolver_;
   const GURL url_;
   ProxyInfo results_;
   ProxyResolver::RequestHandle handle_;
   int error_;
@@ skipping 181 matching lines @@
 TEST_F(ProxyResolverMojoTest, GetProxyForURL) {
   scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com")));
   mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult(
       GURL("http://www.example.com"), OK, ProxyServersFromPacString("DIRECT"));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
 
   EXPECT_EQ("DIRECT", request->results().ToPacString());
 }
 
+TEST_F(ProxyResolverMojoTest, GetProxyForURL_LoadState) {
+  scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com")));
+  mojo_proxy_resolver_factory_.GetMockResolver()->BlockProxyRequest(
+      GURL("http://www.example.com"));
+  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_FAILED, 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";
   scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com")));
   mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult(
       GURL("http://www.example.com"), OK,
       ProxyServersFromPacString(kPacString));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
@@ skipping 69 matching lines @@
   scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com")));
   mojo_proxy_resolver_factory_.GetMockResolver()->CloseRequestClient(
       GURL("http://www.example.com"));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, request->WaitForResult());
 
   EXPECT_TRUE(request->results().is_empty());
 }
 
 }  // namespace net