net/proxy/proxy_resolver_factory_mojo_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/proxy/proxy_resolver_factory_mojo.h"
   6
   7 #include <list>
   8 #include <map>
   9 #include <queue>
  10 #include <string>
  11
  12 #include "base/bind.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/run_loop.h"
  16 #include "base/stl_util.h"
  17 #include "base/values.h"
  18 #include "mojo/common/common_type_converters.h"
  19 #include "net/base/load_states.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/base/test_completion_callback.h"
  22 #include "net/dns/host_resolver.h"
  23 #include "net/log/test_net_log.h"
  24 #include "net/proxy/mojo_proxy_resolver_factory.h"
  25 #include "net/proxy/mojo_proxy_type_converters.h"
  26 #include "net/proxy/proxy_info.h"
  27 #include "net/proxy/proxy_resolver.h"
  28 #include "net/proxy/proxy_resolver_error_observer.h"
  29 #include "net/proxy/proxy_resolver_script_data.h"
  30 #include "net/test/event_waiter.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
  33 #include "url/gurl.h"
  34
  35 namespace net {
  36
  37 namespace {
  38
  39 const char kScriptData[] = "FooBarBaz";
  40 const char kExampleUrl[] = "http://www.example.com";
  41
  42 struct CreateProxyResolverAction {
  43   enum Action {
  44     COMPLETE,
  45     DROP_CLIENT,
  46     DROP_RESOLVER,
  47     DROP_BOTH,
  48     WAIT_FOR_CLIENT_DISCONNECT,
  49     MAKE_DNS_REQUEST,
  50   };
  51
  52   static CreateProxyResolverAction ReturnResult(
  53       const std::string& expected_pac_script,
  54       Error error) {
  55     CreateProxyResolverAction result;
  56     result.expected_pac_script = expected_pac_script;
  57     result.error = error;
  58     return result;
  59   }
  60
  61   static CreateProxyResolverAction DropClient(
  62       const std::string& expected_pac_script) {
  63     CreateProxyResolverAction result;
  64     result.expected_pac_script = expected_pac_script;
  65     result.action = DROP_CLIENT;
  66     return result;
  67   }
  68
  69   static CreateProxyResolverAction DropResolver(
  70       const std::string& expected_pac_script) {
  71     CreateProxyResolverAction result;
  72     result.expected_pac_script = expected_pac_script;
  73     result.action = DROP_RESOLVER;
  74     return result;
  75   }
  76
  77   static CreateProxyResolverAction DropBoth(
  78       const std::string& expected_pac_script) {
  79     CreateProxyResolverAction result;
  80     result.expected_pac_script = expected_pac_script;
  81     result.action = DROP_BOTH;
  82     return result;
  83   }
  84
  85   static CreateProxyResolverAction WaitForClientDisconnect(
  86       const std::string& expected_pac_script) {
  87     CreateProxyResolverAction result;
  88     result.expected_pac_script = expected_pac_script;
  89     result.action = WAIT_FOR_CLIENT_DISCONNECT;
  90     return result;
  91   }
  92
  93   static CreateProxyResolverAction MakeDnsRequest(
  94       const std::string& expected_pac_script) {
  95     CreateProxyResolverAction result;
  96     result.expected_pac_script = expected_pac_script;
  97     result.action = MAKE_DNS_REQUEST;
  98     return result;
  99   }
 100
 101   std::string expected_pac_script;
 102   Action action = COMPLETE;
 103   Error error = OK;
 104 };
 105
 106 struct GetProxyForUrlAction {
 107   enum Action {
 108     COMPLETE,
 109     // Drop the request by closing the reply channel.
 110     DROP,
 111     // Disconnect the service.
 112     DISCONNECT,
 113     // Wait for the client pipe to be disconnected.
 114     WAIT_FOR_CLIENT_DISCONNECT,
 115     // Make a DNS request.
 116     MAKE_DNS_REQUEST,
 117   };
 118
 119   GetProxyForUrlAction() {}
 120   GetProxyForUrlAction(const GetProxyForUrlAction& old) {
 121     action = old.action;
 122     error = old.error;
 123     expected_url = old.expected_url;
 124     proxy_servers = old.proxy_servers.Clone();
 125   }
 126
 127   static GetProxyForUrlAction ReturnError(const GURL& url, Error error) {
 128     GetProxyForUrlAction result;
 129     result.expected_url = url;
 130     result.error = error;
 131     return result;
 132   }
 133
 134   static GetProxyForUrlAction ReturnServers(
 135       const GURL& url,
 136       const mojo::Array<interfaces::ProxyServerPtr>& proxy_servers) {
 137     GetProxyForUrlAction result;
 138     result.expected_url = url;
 139     result.proxy_servers = proxy_servers.Clone();
 140     return result;
 141   }
 142
 143   static GetProxyForUrlAction DropRequest(const GURL& url) {
 144     GetProxyForUrlAction result;
 145     result.expected_url = url;
 146     result.action = DROP;
 147     return result;
 148   }
 149
 150   static GetProxyForUrlAction Disconnect(const GURL& url) {
 151     GetProxyForUrlAction result;
 152     result.expected_url = url;
 153     result.action = DISCONNECT;
 154     return result;
 155   }
 156
 157   static GetProxyForUrlAction WaitForClientDisconnect(const GURL& url) {
 158     GetProxyForUrlAction result;
 159     result.expected_url = url;
 160     result.action = WAIT_FOR_CLIENT_DISCONNECT;
 161     return result;
 162   }
 163
 164   static GetProxyForUrlAction MakeDnsRequest(const GURL& url) {
 165     GetProxyForUrlAction result;
 166     result.expected_url = url;
 167     result.action = MAKE_DNS_REQUEST;
 168     return result;
 169   }
 170
 171   Action action = COMPLETE;
 172   Error error = OK;
 173   mojo::Array<interfaces::ProxyServerPtr> proxy_servers;
 174   GURL expected_url;
 175 };
 176
 177 class MockMojoProxyResolver : public interfaces::ProxyResolver {
 178  public:
 179   MockMojoProxyResolver();
 180   ~MockMojoProxyResolver() override;
 181
 182   void AddGetProxyAction(GetProxyForUrlAction action);
 183
 184   void WaitForNextRequest();
 185
 186   void ClearBlockedClients();
 187
 188   void AddConnection(mojo::InterfaceRequest<interfaces::ProxyResolver> req);
 189
 190  private:
 191   // Overridden from interfaces::ProxyResolver:
 192   void GetProxyForUrl(
 193       const mojo::String& url,
 194       interfaces::ProxyResolverRequestClientPtr client) override;
 195
 196   void WakeWaiter();
 197
 198   std::string pac_script_data_;
 199
 200   std::queue<GetProxyForUrlAction> get_proxy_actions_;
 201
 202   base::Closure quit_closure_;
 203
 204   ScopedVector<interfaces::ProxyResolverRequestClientPtr> blocked_clients_;
 205   mojo::Binding<interfaces::ProxyResolver> binding_;
 206 };
 207
 208 MockMojoProxyResolver::~MockMojoProxyResolver() {
 209   EXPECT_TRUE(get_proxy_actions_.empty())
 210       << "Actions remaining: " << get_proxy_actions_.size();
 211 }
 212
 213 MockMojoProxyResolver::MockMojoProxyResolver() : binding_(this) {
 214 }
 215
 216 void MockMojoProxyResolver::AddGetProxyAction(GetProxyForUrlAction action) {
 217   get_proxy_actions_.push(action);
 218 }
 219
 220 void MockMojoProxyResolver::WaitForNextRequest() {
 221   base::RunLoop run_loop;
 222   quit_closure_ = run_loop.QuitClosure();
 223   run_loop.Run();
 224 }
 225
 226 void MockMojoProxyResolver::WakeWaiter() {
 227   if (!quit_closure_.is_null())
 228     quit_closure_.Run();
 229   quit_closure_.Reset();
 230 }
 231
 232 void MockMojoProxyResolver::ClearBlockedClients() {
 233   blocked_clients_.clear();
 234 }
 235
 236 void MockMojoProxyResolver::AddConnection(
 237     mojo::InterfaceRequest<interfaces::ProxyResolver> req) {
 238   if (binding_.is_bound())
 239     binding_.Close();
 240   binding_.Bind(req.Pass());
 241 }
 242
 243 void MockMojoProxyResolver::GetProxyForUrl(
 244     const mojo::String& url,
 245     interfaces::ProxyResolverRequestClientPtr client) {
 246   ASSERT_FALSE(get_proxy_actions_.empty());
 247   GetProxyForUrlAction action = get_proxy_actions_.front();
 248   get_proxy_actions_.pop();
 249
 250   EXPECT_EQ(action.expected_url.spec(), url.To<std::string>());
 251   client->Alert(url);
 252   client->OnError(12345, url);
 253   switch (action.action) {
 254     case GetProxyForUrlAction::COMPLETE: {
 255       client->ReportResult(action.error, action.proxy_servers.Pass());
 256       break;
 257     }
 258     case GetProxyForUrlAction::DROP: {
 259       client.reset();
 260       break;
 261     }
 262     case GetProxyForUrlAction::DISCONNECT: {
 263       binding_.Close();
 264       break;
 265     }
 266     case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT: {
 267       ASSERT_FALSE(client.WaitForIncomingResponse());
 268       break;
 269     }
 270     case GetProxyForUrlAction::MAKE_DNS_REQUEST: {
 271       interfaces::HostResolverRequestInfoPtr request(
 272           interfaces::HostResolverRequestInfo::New());
 273       request->host = url;
 274       request->port = 12345;
 275       interfaces::HostResolverRequestClientPtr dns_client;
 276       mojo::GetProxy(&dns_client);
 277       client->ResolveDns(request.Pass(), dns_client.Pass());
 278       blocked_clients_.push_back(
 279           new interfaces::ProxyResolverRequestClientPtr(client.Pass()));
 280       break;
 281     }
 282   }
 283   WakeWaiter();
 284 }
 285
 286 class Request {
 287  public:
 288   Request(ProxyResolver* resolver, const GURL& url);
 289
 290   int Resolve();
 291   void Cancel();
 292   int WaitForResult();
 293
 294   int error() const { return error_; }
 295   const ProxyInfo& results() const { return results_; }
 296   LoadState load_state() { return resolver_->GetLoadState(handle_); }
 297   BoundTestNetLog& net_log() { return net_log_; }
 298
 299  private:
 300   ProxyResolver* resolver_;
 301   const GURL url_;
 302   ProxyInfo results_;
 303   ProxyResolver::RequestHandle handle_;
 304   int error_;
 305   TestCompletionCallback callback_;
 306   BoundTestNetLog net_log_;
 307 };
 308
 309 Request::Request(ProxyResolver* resolver, const GURL& url)
 310     : resolver_(resolver), url_(url), error_(0) {
 311 }
 312
 313 int Request::Resolve() {
 314   error_ = resolver_->GetProxyForURL(url_, &results_, callback_.callback(),
 315                                      &handle_, net_log_.bound());
 316   return error_;
 317 }
 318
 319 void Request::Cancel() {
 320   resolver_->CancelRequest(handle_);
 321 }
 322
 323 int Request::WaitForResult() {
 324   error_ = callback_.WaitForResult();
 325   return error_;
 326 }
 327
 328 class MockMojoProxyResolverFactory : public interfaces::ProxyResolverFactory {
 329  public:
 330   MockMojoProxyResolverFactory(
 331       MockMojoProxyResolver* resolver,
 332       mojo::InterfaceRequest<interfaces::ProxyResolverFactory> req);
 333   ~MockMojoProxyResolverFactory() override;
 334
 335   void AddCreateProxyResolverAction(CreateProxyResolverAction action);
 336
 337   void WaitForNextRequest();
 338
 339   void ClearBlockedClients();
 340
 341  private:
 342   // Overridden from interfaces::ProxyResolver:
 343   void CreateResolver(
 344       const mojo::String& pac_url,
 345       mojo::InterfaceRequest<interfaces::ProxyResolver> request,
 346       interfaces::ProxyResolverFactoryRequestClientPtr client) override;
 347
 348   void WakeWaiter();
 349
 350   MockMojoProxyResolver* resolver_;
 351   std::queue<CreateProxyResolverAction> create_resolver_actions_;
 352
 353   base::Closure quit_closure_;
 354
 355   ScopedVector<interfaces::ProxyResolverFactoryRequestClientPtr>
 356       blocked_clients_;
 357   ScopedVector<mojo::InterfaceRequest<interfaces::ProxyResolver>>
 358       blocked_resolver_requests_;
 359   mojo::Binding<interfaces::ProxyResolverFactory> binding_;
 360 };
 361
 362 MockMojoProxyResolverFactory::MockMojoProxyResolverFactory(
 363     MockMojoProxyResolver* resolver,
 364     mojo::InterfaceRequest<interfaces::ProxyResolverFactory> req)
 365     : resolver_(resolver), binding_(this, req.Pass()) {
 366 }
 367
 368 MockMojoProxyResolverFactory::~MockMojoProxyResolverFactory() {
 369   EXPECT_TRUE(create_resolver_actions_.empty())
 370       << "Actions remaining: " << create_resolver_actions_.size();
 371 }
 372
 373 void MockMojoProxyResolverFactory::AddCreateProxyResolverAction(
 374     CreateProxyResolverAction action) {
 375   create_resolver_actions_.push(action);
 376 }
 377
 378 void MockMojoProxyResolverFactory::WaitForNextRequest() {
 379   base::RunLoop run_loop;
 380   quit_closure_ = run_loop.QuitClosure();
 381   run_loop.Run();
 382 }
 383
 384 void MockMojoProxyResolverFactory::WakeWaiter() {
 385   if (!quit_closure_.is_null())
 386     quit_closure_.Run();
 387   quit_closure_.Reset();
 388 }
 389
 390 void MockMojoProxyResolverFactory::ClearBlockedClients() {
 391   blocked_clients_.clear();
 392 }
 393
 394 void MockMojoProxyResolverFactory::CreateResolver(
 395     const mojo::String& pac_script,
 396     mojo::InterfaceRequest<interfaces::ProxyResolver> request,
 397     interfaces::ProxyResolverFactoryRequestClientPtr client) {
 398   ASSERT_FALSE(create_resolver_actions_.empty());
 399   CreateProxyResolverAction action = create_resolver_actions_.front();
 400   create_resolver_actions_.pop();
 401
 402   EXPECT_EQ(action.expected_pac_script, pac_script.To<std::string>());
 403   client->Alert(pac_script);
 404   client->OnError(12345, pac_script);
 405   switch (action.action) {
 406     case CreateProxyResolverAction::COMPLETE: {
 407       if (action.error == OK)
 408         resolver_->AddConnection(request.Pass());
 409       client->ReportResult(action.error);
 410       break;
 411     }
 412     case CreateProxyResolverAction::DROP_CLIENT: {
 413       // Save |request| so its pipe isn't closed.
 414       blocked_resolver_requests_.push_back(
 415           new mojo::InterfaceRequest<interfaces::ProxyResolver>(
 416               request.Pass()));
 417       break;
 418     }
 419     case CreateProxyResolverAction::DROP_RESOLVER: {
 420       // Save |client| so its pipe isn't closed.
 421       blocked_clients_.push_back(
 422           new interfaces::ProxyResolverFactoryRequestClientPtr(client.Pass()));
 423       break;
 424     }
 425     case CreateProxyResolverAction::DROP_BOTH: {
 426       // Both |request| and |client| will be closed.
 427       break;
 428     }
 429     case CreateProxyResolverAction::WAIT_FOR_CLIENT_DISCONNECT: {
 430       ASSERT_FALSE(client.WaitForIncomingResponse());
 431       break;
 432     }
 433     case CreateProxyResolverAction::MAKE_DNS_REQUEST: {
 434       interfaces::HostResolverRequestInfoPtr request(
 435           interfaces::HostResolverRequestInfo::New());
 436       request->host = pac_script;
 437       request->port = 12345;
 438       interfaces::HostResolverRequestClientPtr dns_client;
 439       mojo::GetProxy(&dns_client);
 440       client->ResolveDns(request.Pass(), dns_client.Pass());
 441       blocked_clients_.push_back(
 442           new interfaces::ProxyResolverFactoryRequestClientPtr(client.Pass()));
 443       break;
 444     }
 445   }
 446   WakeWaiter();
 447 }
 448
 449 void DeleteResolverFactoryRequestCallback(
 450     scoped_ptr<ProxyResolverFactory::Request>* request,
 451     const CompletionCallback& callback,
 452     int result) {
 453   ASSERT_TRUE(request);
 454   EXPECT_TRUE(request->get());
 455   request->reset();
 456   callback.Run(result);
 457 }
 458
 459 class MockHostResolver : public HostResolver {
 460  public:
 461   enum Event {
 462     DNS_REQUEST,
 463   };
 464
 465   // HostResolver overrides.
 466   int Resolve(const RequestInfo& info,
 467               RequestPriority priority,
 468               AddressList* addresses,
 469               const CompletionCallback& callback,
 470               RequestHandle* request_handle,
 471               const BoundNetLog& source_net_log) override {
 472     waiter_.NotifyEvent(DNS_REQUEST);
 473     return ERR_IO_PENDING;
 474   }
 475   int ResolveFromCache(const RequestInfo& info,
 476                        AddressList* addresses,
 477                        const BoundNetLog& source_net_log) override {
 478     return ERR_DNS_CACHE_MISS;
 479   }
 480   void CancelRequest(RequestHandle req) override {}
 481   HostCache* GetHostCache() override { return nullptr; }
 482
 483   EventWaiter<Event>& waiter() { return waiter_; }
 484
 485  private:
 486   EventWaiter<Event> waiter_;
 487 };
 488
 489 void CheckCapturedNetLogEntries(const std::string& expected_string,
 490                                 const TestNetLogEntry::List& entries) {
 491   ASSERT_EQ(2u, entries.size());
 492   EXPECT_EQ(NetLog::TYPE_PAC_JAVASCRIPT_ALERT, entries[0].type);
 493   std::string message;
 494   ASSERT_TRUE(entries[0].GetStringValue("message", &message));
 495   EXPECT_EQ(expected_string, message);
 496   ASSERT_FALSE(entries[0].params->HasKey("line_number"));
 497   message.clear();
 498   EXPECT_EQ(NetLog::TYPE_PAC_JAVASCRIPT_ERROR, entries[1].type);
 499   ASSERT_TRUE(entries[1].GetStringValue("message", &message));
 500   EXPECT_EQ(expected_string, message);
 501   int line_number = 0;
 502   ASSERT_TRUE(entries[1].GetIntegerValue("line_number", &line_number));
 503   EXPECT_EQ(12345, line_number);
 504 }
 505
 506 }  // namespace
 507
 508 class ProxyResolverFactoryMojoTest : public testing::Test,
 509                                      public MojoProxyResolverFactory {
 510  public:
 511   void SetUp() override {
 512     mock_proxy_resolver_factory_.reset(new MockMojoProxyResolverFactory(
 513         &mock_proxy_resolver_, mojo::GetProxy(&factory_ptr_)));
 514     proxy_resolver_factory_mojo_.reset(new ProxyResolverFactoryMojo(
 515         this, &host_resolver_,
 516         base::Callback<scoped_ptr<ProxyResolverErrorObserver>()>(), &net_log_));
 517   }
 518
 519   scoped_ptr<Request> MakeRequest(const GURL& url) {
 520     return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url));
 521   }
 522
 523   scoped_ptr<base::ScopedClosureRunner> CreateResolver(
 524       const mojo::String& pac_script,
 525       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
 526       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
 527     factory_ptr_->CreateResolver(pac_script, req.Pass(), client.Pass());
 528     return make_scoped_ptr(
 529         new base::ScopedClosureRunner(on_delete_callback_.closure()));
 530   }
 531
 532   mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
 533       const std::string& pac_string) {
 534     ProxyInfo proxy_info;
 535     proxy_info.UsePacString(pac_string);
 536
 537     return mojo::Array<interfaces::ProxyServerPtr>::From(
 538         proxy_info.proxy_list().GetAll());
 539   }
 540
 541   void CreateProxyResolver() {
 542     mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 543         CreateProxyResolverAction::ReturnResult(kScriptData, OK));
 544     TestCompletionCallback callback;
 545     scoped_refptr<ProxyResolverScriptData> pac_script(
 546         ProxyResolverScriptData::FromUTF8(kScriptData));
 547     scoped_ptr<ProxyResolverFactory::Request> request;
 548     ASSERT_EQ(
 549         OK,
 550         callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 551             pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 552     EXPECT_TRUE(request);
 553     ASSERT_TRUE(proxy_resolver_mojo_);
 554   }
 555
 556   void DeleteProxyResolverCallback(const CompletionCallback& callback,
 557                                    int result) {
 558     proxy_resolver_mojo_.reset();
 559     callback.Run(result);
 560   }
 561
 562   MockHostResolver host_resolver_;
 563   TestNetLog net_log_;
 564   scoped_ptr<MockMojoProxyResolverFactory> mock_proxy_resolver_factory_;
 565   interfaces::ProxyResolverFactoryPtr factory_ptr_;
 566   scoped_ptr<ProxyResolverFactory> proxy_resolver_factory_mojo_;
 567
 568   MockMojoProxyResolver mock_proxy_resolver_;
 569   scoped_ptr<ProxyResolver> proxy_resolver_mojo_;
 570   TestClosure on_delete_callback_;
 571 };
 572
 573 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver) {
 574   CreateProxyResolver();
 575   TestNetLogEntry::List entries;
 576   net_log_.GetEntries(&entries);
 577   CheckCapturedNetLogEntries(kScriptData, entries);
 578 }
 579
 580 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Empty) {
 581   TestCompletionCallback callback;
 582   scoped_refptr<ProxyResolverScriptData> pac_script(
 583       ProxyResolverScriptData::FromUTF8(""));
 584   scoped_ptr<ProxyResolverFactory::Request> request;
 585   EXPECT_EQ(
 586       ERR_PAC_SCRIPT_FAILED,
 587       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 588           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 589   EXPECT_FALSE(request);
 590 }
 591
 592 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Url) {
 593   TestCompletionCallback callback;
 594   scoped_refptr<ProxyResolverScriptData> pac_script(
 595       ProxyResolverScriptData::FromURL(GURL(kExampleUrl)));
 596   scoped_ptr<ProxyResolverFactory::Request> request;
 597   EXPECT_EQ(
 598       ERR_PAC_SCRIPT_FAILED,
 599       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 600           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 601   EXPECT_FALSE(request);
 602 }
 603
 604 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Failed) {
 605   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 606       CreateProxyResolverAction::ReturnResult(kScriptData,
 607                                               ERR_PAC_STATUS_NOT_OK));
 608
 609   TestCompletionCallback callback;
 610   scoped_refptr<ProxyResolverScriptData> pac_script(
 611       ProxyResolverScriptData::FromUTF8(kScriptData));
 612   scoped_ptr<ProxyResolverFactory::Request> request;
 613   EXPECT_EQ(
 614       ERR_PAC_STATUS_NOT_OK,
 615       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 616           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 617   EXPECT_TRUE(request);
 618   on_delete_callback_.WaitForResult();
 619
 620   // A second attempt succeeds.
 621   CreateProxyResolver();
 622 }
 623
 624 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_BothDisconnected) {
 625   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 626       CreateProxyResolverAction::DropBoth(kScriptData));
 627
 628   scoped_refptr<ProxyResolverScriptData> pac_script(
 629       ProxyResolverScriptData::FromUTF8(kScriptData));
 630   scoped_ptr<ProxyResolverFactory::Request> request;
 631   TestCompletionCallback callback;
 632   EXPECT_EQ(
 633       ERR_PAC_SCRIPT_TERMINATED,
 634       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 635           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 636   EXPECT_TRUE(request);
 637 }
 638
 639 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_ClientDisconnected) {
 640   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 641       CreateProxyResolverAction::DropClient(kScriptData));
 642
 643   scoped_refptr<ProxyResolverScriptData> pac_script(
 644       ProxyResolverScriptData::FromUTF8(kScriptData));
 645   scoped_ptr<ProxyResolverFactory::Request> request;
 646   TestCompletionCallback callback;
 647   EXPECT_EQ(
 648       ERR_PAC_SCRIPT_TERMINATED,
 649       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 650           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 651   EXPECT_TRUE(request);
 652 }
 653
 654 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_ResolverDisconnected) {
 655   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 656       CreateProxyResolverAction::DropResolver(kScriptData));
 657
 658   scoped_refptr<ProxyResolverScriptData> pac_script(
 659       ProxyResolverScriptData::FromUTF8(kScriptData));
 660   scoped_ptr<ProxyResolverFactory::Request> request;
 661   TestCompletionCallback callback;
 662   EXPECT_EQ(
 663       ERR_PAC_SCRIPT_TERMINATED,
 664       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 665           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
 666   EXPECT_TRUE(request);
 667   on_delete_callback_.WaitForResult();
 668 }
 669
 670 TEST_F(ProxyResolverFactoryMojoTest,
 671        CreateProxyResolver_ResolverDisconnected_DeleteRequestInCallback) {
 672   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 673       CreateProxyResolverAction::DropResolver(kScriptData));
 674
 675   scoped_refptr<ProxyResolverScriptData> pac_script(
 676       ProxyResolverScriptData::FromUTF8(kScriptData));
 677   scoped_ptr<ProxyResolverFactory::Request> request;
 678   TestCompletionCallback callback;
 679   EXPECT_EQ(
 680       ERR_PAC_SCRIPT_TERMINATED,
 681       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
 682           pac_script, &proxy_resolver_mojo_,
 683           base::Bind(&DeleteResolverFactoryRequestCallback, &request,
 684                      callback.callback()),
 685           &request)));
 686   on_delete_callback_.WaitForResult();
 687 }
 688
 689 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Cancel) {
 690   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 691       CreateProxyResolverAction::WaitForClientDisconnect(kScriptData));
 692
 693   scoped_refptr<ProxyResolverScriptData> pac_script(
 694       ProxyResolverScriptData::FromUTF8(kScriptData));
 695   scoped_ptr<ProxyResolverFactory::Request> request;
 696   TestCompletionCallback callback;
 697   EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_factory_mojo_->CreateProxyResolver(
 698                                 pac_script, &proxy_resolver_mojo_,
 699                                 callback.callback(), &request));
 700   ASSERT_TRUE(request);
 701   request.reset();
 702
 703   // The Mojo request is still made.
 704   mock_proxy_resolver_factory_->WaitForNextRequest();
 705   on_delete_callback_.WaitForResult();
 706 }
 707
 708 TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_DnsRequest) {
 709   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
 710       CreateProxyResolverAction::MakeDnsRequest(kScriptData));
 711
 712   scoped_refptr<ProxyResolverScriptData> pac_script(
 713       ProxyResolverScriptData::FromUTF8(kScriptData));
 714   scoped_ptr<ProxyResolverFactory::Request> request;
 715   TestCompletionCallback callback;
 716   EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_factory_mojo_->CreateProxyResolver(
 717                                 pac_script, &proxy_resolver_mojo_,
 718                                 callback.callback(), &request));
 719   ASSERT_TRUE(request);
 720   host_resolver_.waiter().WaitForEvent(MockHostResolver::DNS_REQUEST);
 721   mock_proxy_resolver_factory_->ClearBlockedClients();
 722   callback.WaitForResult();
 723 }
 724
 725 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL) {
 726   const GURL url(kExampleUrl);
 727   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
 728       url, ProxyServersFromPacString("DIRECT")));
 729   CreateProxyResolver();
 730   net_log_.Clear();
 731
 732   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 733   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 734   EXPECT_EQ(OK, request->WaitForResult());
 735
 736   EXPECT_EQ("DIRECT", request->results().ToPacString());
 737
 738   TestNetLogEntry::List entries;
 739   net_log_.GetEntries(&entries);
 740   CheckCapturedNetLogEntries(url.spec(), entries);
 741   entries.clear();
 742   request->net_log().GetEntries(&entries);
 743   CheckCapturedNetLogEntries(url.spec(), entries);
 744 }
 745
 746 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleResults) {
 747   static const char kPacString[] =
 748       "PROXY foo1:80;DIRECT;SOCKS foo2:1234;"
 749       "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888";
 750   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
 751       GURL(kExampleUrl), ProxyServersFromPacString(kPacString)));
 752   CreateProxyResolver();
 753
 754   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 755   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 756   EXPECT_EQ(OK, request->WaitForResult());
 757
 758   EXPECT_EQ(kPacString, request->results().ToPacString());
 759 }
 760
 761 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Error) {
 762   mock_proxy_resolver_.AddGetProxyAction(
 763       GetProxyForUrlAction::ReturnError(GURL(kExampleUrl), ERR_UNEXPECTED));
 764   CreateProxyResolver();
 765
 766   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 767   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 768   EXPECT_EQ(ERR_UNEXPECTED, request->WaitForResult());
 769
 770   EXPECT_TRUE(request->results().is_empty());
 771 }
 772
 773 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Cancel) {
 774   mock_proxy_resolver_.AddGetProxyAction(
 775       GetProxyForUrlAction::WaitForClientDisconnect(GURL(kExampleUrl)));
 776   CreateProxyResolver();
 777
 778   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 779   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 780   request->Cancel();
 781
 782   // The Mojo request is still made.
 783   mock_proxy_resolver_.WaitForNextRequest();
 784 }
 785
 786 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleRequests) {
 787   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
 788       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
 789   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
 790       GURL("https://www.chromium.org"),
 791       ProxyServersFromPacString("HTTPS foo:443")));
 792   CreateProxyResolver();
 793
 794   scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl)));
 795   EXPECT_EQ(ERR_IO_PENDING, request1->Resolve());
 796   scoped_ptr<Request> request2(MakeRequest(GURL("https://www.chromium.org")));
 797   EXPECT_EQ(ERR_IO_PENDING, request2->Resolve());
 798
 799   EXPECT_EQ(OK, request1->WaitForResult());
 800   EXPECT_EQ(OK, request2->WaitForResult());
 801
 802   EXPECT_EQ("DIRECT", request1->results().ToPacString());
 803   EXPECT_EQ("HTTPS foo:443", request2->results().ToPacString());
 804 }
 805
 806 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Disconnect) {
 807   mock_proxy_resolver_.AddGetProxyAction(
 808       GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
 809   CreateProxyResolver();
 810   {
 811     scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 812     EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 813     EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult());
 814     EXPECT_TRUE(request->results().is_empty());
 815   }
 816
 817   {
 818     // Calling GetProxyForURL after a disconnect should fail.
 819     scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 820     EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve());
 821   }
 822 }
 823
 824 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_ClientClosed) {
 825   mock_proxy_resolver_.AddGetProxyAction(
 826       GetProxyForUrlAction::DropRequest(GURL(kExampleUrl)));
 827   CreateProxyResolver();
 828
 829   scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl)));
 830   EXPECT_EQ(ERR_IO_PENDING, request1->Resolve());
 831
 832   EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request1->WaitForResult());
 833 }
 834
 835 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DeleteInCallback) {
 836   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
 837       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
 838   CreateProxyResolver();
 839
 840   ProxyInfo results;
 841   TestCompletionCallback callback;
 842   ProxyResolver::RequestHandle handle;
 843   BoundNetLog net_log;
 844   EXPECT_EQ(
 845       OK,
 846       callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
 847           GURL(kExampleUrl), &results,
 848           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
 849                      base::Unretained(this), callback.callback()),
 850           &handle, net_log)));
 851   on_delete_callback_.WaitForResult();
 852 }
 853
 854 TEST_F(ProxyResolverFactoryMojoTest,
 855        GetProxyForURL_DeleteInCallbackFromDisconnect) {
 856   mock_proxy_resolver_.AddGetProxyAction(
 857       GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
 858   CreateProxyResolver();
 859
 860   ProxyInfo results;
 861   TestCompletionCallback callback;
 862   ProxyResolver::RequestHandle handle;
 863   BoundNetLog net_log;
 864   EXPECT_EQ(
 865       ERR_PAC_SCRIPT_TERMINATED,
 866       callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
 867           GURL(kExampleUrl), &results,
 868           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
 869                      base::Unretained(this), callback.callback()),
 870           &handle, net_log)));
 871   on_delete_callback_.WaitForResult();
 872 }
 873
 874 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DnsRequest) {
 875   mock_proxy_resolver_.AddGetProxyAction(
 876       GetProxyForUrlAction::MakeDnsRequest(GURL(kExampleUrl)));
 877   CreateProxyResolver();
 878
 879   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
 880   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
 881   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, request->load_state());
 882
 883   host_resolver_.waiter().WaitForEvent(MockHostResolver::DNS_REQUEST);
 884   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT, request->load_state());
 885   mock_proxy_resolver_.ClearBlockedClients();
 886   request->WaitForResult();
 887 }
 888
 889 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
 890   CreateProxyResolver();
 891   proxy_resolver_mojo_.reset();
 892   on_delete_callback_.WaitForResult();
 893 }
 894 }  // namespace net