OLD | NEW |
(Empty) | |
| 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_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/run_loop.h" |
| 15 #include "base/stl_util.h" |
| 16 #include "mojo/common/common_type_converters.h" |
| 17 #include "net/base/net_errors.h" |
| 18 #include "net/base/net_log.h" |
| 19 #include "net/base/test_completion_callback.h" |
| 20 #include "net/dns/mock_host_resolver.h" |
| 21 #include "net/proxy/mojo_proxy_resolver_factory.h" |
| 22 #include "net/proxy/mojo_proxy_type_converters.h" |
| 23 #include "net/proxy/proxy_info.h" |
| 24 #include "net/proxy/proxy_resolver_script_data.h" |
| 25 #include "testing/gtest/include/gtest/gtest.h" |
| 26 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h" |
| 27 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h" |
| 28 #include "url/gurl.h" |
| 29 |
| 30 namespace net { |
| 31 |
| 32 namespace { |
| 33 |
| 34 const char kScriptData[] = "FooBarBaz"; |
| 35 const char kScriptData2[] = "BlahBlahBlah"; |
| 36 const char kExampleUrl[] = "http://www.example.com"; |
| 37 |
| 38 struct SetPacScriptAction { |
| 39 enum Action { |
| 40 COMPLETE, |
| 41 DISCONNECT, |
| 42 }; |
| 43 |
| 44 static SetPacScriptAction ReturnResult(Error error) { |
| 45 SetPacScriptAction result; |
| 46 result.error = error; |
| 47 return result; |
| 48 } |
| 49 |
| 50 static SetPacScriptAction Disconnect() { |
| 51 SetPacScriptAction result; |
| 52 result.action = DISCONNECT; |
| 53 return result; |
| 54 } |
| 55 |
| 56 Action action = COMPLETE; |
| 57 Error error = OK; |
| 58 }; |
| 59 |
| 60 struct GetProxyForUrlAction { |
| 61 enum Action { |
| 62 COMPLETE, |
| 63 // Drop the request by closing the reply channel. |
| 64 DROP, |
| 65 // Disconnect the service. |
| 66 DISCONNECT, |
| 67 // Wait for the client pipe to be disconnected. |
| 68 WAIT_FOR_CLIENT_DISCONNECT, |
| 69 }; |
| 70 |
| 71 GetProxyForUrlAction() {} |
| 72 GetProxyForUrlAction(const GetProxyForUrlAction& old) { |
| 73 action = old.action; |
| 74 error = old.error; |
| 75 expected_url = old.expected_url; |
| 76 proxy_servers = old.proxy_servers.Clone(); |
| 77 } |
| 78 |
| 79 static GetProxyForUrlAction ReturnError(const GURL& url, Error error) { |
| 80 GetProxyForUrlAction result; |
| 81 result.expected_url = url; |
| 82 result.error = error; |
| 83 return result; |
| 84 } |
| 85 |
| 86 static GetProxyForUrlAction ReturnServers( |
| 87 const GURL& url, |
| 88 const mojo::Array<interfaces::ProxyServerPtr>& proxy_servers) { |
| 89 GetProxyForUrlAction result; |
| 90 result.expected_url = url; |
| 91 result.proxy_servers = proxy_servers.Clone(); |
| 92 return result; |
| 93 } |
| 94 |
| 95 static GetProxyForUrlAction DropRequest(const GURL& url) { |
| 96 GetProxyForUrlAction result; |
| 97 result.expected_url = url; |
| 98 result.action = DROP; |
| 99 return result; |
| 100 } |
| 101 |
| 102 static GetProxyForUrlAction Disconnect(const GURL& url) { |
| 103 GetProxyForUrlAction result; |
| 104 result.expected_url = url; |
| 105 result.action = DISCONNECT; |
| 106 return result; |
| 107 } |
| 108 |
| 109 static GetProxyForUrlAction WaitForClientDisconnect(const GURL& url) { |
| 110 GetProxyForUrlAction result; |
| 111 result.expected_url = url; |
| 112 result.action = WAIT_FOR_CLIENT_DISCONNECT; |
| 113 return result; |
| 114 } |
| 115 |
| 116 Action action = COMPLETE; |
| 117 Error error = OK; |
| 118 mojo::Array<interfaces::ProxyServerPtr> proxy_servers; |
| 119 GURL expected_url; |
| 120 }; |
| 121 |
| 122 class MockMojoProxyResolver : public interfaces::ProxyResolver { |
| 123 public: |
| 124 explicit MockMojoProxyResolver( |
| 125 mojo::InterfaceRequest<interfaces::ProxyResolver> req); |
| 126 ~MockMojoProxyResolver() override; |
| 127 |
| 128 void AddPacScriptAction(SetPacScriptAction action); |
| 129 // Returned script data is UTF8. |
| 130 std::string pac_script_data() { return pac_script_data_; } |
| 131 |
| 132 void AddGetProxyAction(GetProxyForUrlAction action); |
| 133 |
| 134 void WaitForNextRequest(); |
| 135 |
| 136 private: |
| 137 // Overridden from interfaces::ProxyResolver: |
| 138 void SetPacScript(const mojo::String& data, |
| 139 const mojo::Callback<void(int32_t)>& callback) override; |
| 140 void GetProxyForUrl( |
| 141 const mojo::String& url, |
| 142 interfaces::ProxyResolverRequestClientPtr client) override; |
| 143 |
| 144 void WakeWaiter(); |
| 145 |
| 146 std::string pac_script_data_; |
| 147 std::queue<SetPacScriptAction> pac_script_actions_; |
| 148 |
| 149 std::queue<GetProxyForUrlAction> get_proxy_actions_; |
| 150 |
| 151 base::Closure quit_closure_; |
| 152 |
| 153 mojo::Binding<interfaces::ProxyResolver> binding_; |
| 154 }; |
| 155 |
| 156 MockMojoProxyResolver::MockMojoProxyResolver( |
| 157 mojo::InterfaceRequest<interfaces::ProxyResolver> req) |
| 158 : binding_(this, req.Pass()) { |
| 159 } |
| 160 |
| 161 MockMojoProxyResolver::~MockMojoProxyResolver() { |
| 162 EXPECT_TRUE(pac_script_actions_.empty()) |
| 163 << "Actions remaining: " << pac_script_actions_.size(); |
| 164 EXPECT_TRUE(get_proxy_actions_.empty()) |
| 165 << "Actions remaining: " << get_proxy_actions_.size(); |
| 166 } |
| 167 |
| 168 void MockMojoProxyResolver::AddPacScriptAction(SetPacScriptAction action) { |
| 169 pac_script_actions_.push(action); |
| 170 } |
| 171 |
| 172 void MockMojoProxyResolver::AddGetProxyAction(GetProxyForUrlAction action) { |
| 173 get_proxy_actions_.push(action); |
| 174 } |
| 175 |
| 176 void MockMojoProxyResolver::WaitForNextRequest() { |
| 177 base::RunLoop run_loop; |
| 178 quit_closure_ = run_loop.QuitClosure(); |
| 179 run_loop.Run(); |
| 180 } |
| 181 |
| 182 void MockMojoProxyResolver::WakeWaiter() { |
| 183 if (!quit_closure_.is_null()) |
| 184 quit_closure_.Run(); |
| 185 quit_closure_.Reset(); |
| 186 } |
| 187 |
| 188 void MockMojoProxyResolver::SetPacScript( |
| 189 const mojo::String& data, |
| 190 const mojo::Callback<void(int32_t)>& callback) { |
| 191 pac_script_data_ = data.To<std::string>(); |
| 192 |
| 193 ASSERT_FALSE(pac_script_actions_.empty()); |
| 194 SetPacScriptAction action = pac_script_actions_.front(); |
| 195 pac_script_actions_.pop(); |
| 196 |
| 197 switch (action.action) { |
| 198 case SetPacScriptAction::COMPLETE: |
| 199 callback.Run(action.error); |
| 200 break; |
| 201 case SetPacScriptAction::DISCONNECT: |
| 202 binding_.Close(); |
| 203 break; |
| 204 } |
| 205 WakeWaiter(); |
| 206 } |
| 207 |
| 208 void MockMojoProxyResolver::GetProxyForUrl( |
| 209 const mojo::String& url, |
| 210 interfaces::ProxyResolverRequestClientPtr client) { |
| 211 ASSERT_FALSE(get_proxy_actions_.empty()); |
| 212 GetProxyForUrlAction action = get_proxy_actions_.front(); |
| 213 get_proxy_actions_.pop(); |
| 214 |
| 215 EXPECT_EQ(action.expected_url.spec(), url.To<std::string>()); |
| 216 switch (action.action) { |
| 217 case GetProxyForUrlAction::COMPLETE: |
| 218 client->ReportResult(action.error, action.proxy_servers.Pass()); |
| 219 break; |
| 220 case GetProxyForUrlAction::DROP: |
| 221 client.reset(); |
| 222 break; |
| 223 case GetProxyForUrlAction::DISCONNECT: |
| 224 binding_.Close(); |
| 225 break; |
| 226 case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT: |
| 227 ASSERT_FALSE(client.WaitForIncomingMethodCall()); |
| 228 break; |
| 229 } |
| 230 WakeWaiter(); |
| 231 } |
| 232 |
| 233 class TestMojoProxyResolverFactory : public MojoProxyResolverFactory { |
| 234 public: |
| 235 TestMojoProxyResolverFactory(); |
| 236 ~TestMojoProxyResolverFactory(); |
| 237 |
| 238 // Overridden from MojoProxyResolverFactory: |
| 239 void Create(mojo::InterfaceRequest<interfaces::ProxyResolver> req, |
| 240 interfaces::HostResolverPtr host_resolver) override; |
| 241 |
| 242 MockMojoProxyResolver& GetMockResolver() { return *mock_proxy_resolver_; } |
| 243 |
| 244 void AddFuturePacScriptAction(int creation, SetPacScriptAction action); |
| 245 void AddFutureGetProxyAction(int creation, GetProxyForUrlAction action); |
| 246 |
| 247 int num_create_calls() const { return num_create_calls_; } |
| 248 void FailNextCreate() { fail_next_create_ = true; } |
| 249 |
| 250 private: |
| 251 int num_create_calls_; |
| 252 std::map<int, std::list<SetPacScriptAction>> pac_script_actions_; |
| 253 std::map<int, std::list<GetProxyForUrlAction>> get_proxy_actions_; |
| 254 bool fail_next_create_; |
| 255 |
| 256 scoped_ptr<MockMojoProxyResolver> mock_proxy_resolver_; |
| 257 }; |
| 258 |
| 259 TestMojoProxyResolverFactory::TestMojoProxyResolverFactory() |
| 260 : num_create_calls_(0), fail_next_create_(false) { |
| 261 } |
| 262 |
| 263 TestMojoProxyResolverFactory::~TestMojoProxyResolverFactory() { |
| 264 } |
| 265 |
| 266 void TestMojoProxyResolverFactory::Create( |
| 267 mojo::InterfaceRequest<interfaces::ProxyResolver> req, |
| 268 interfaces::HostResolverPtr host_resolver) { |
| 269 if (fail_next_create_) { |
| 270 req = nullptr; |
| 271 fail_next_create_ = false; |
| 272 } else { |
| 273 mock_proxy_resolver_.reset(new MockMojoProxyResolver(req.Pass())); |
| 274 |
| 275 for (const auto& action : pac_script_actions_[num_create_calls_]) |
| 276 mock_proxy_resolver_->AddPacScriptAction(action); |
| 277 |
| 278 for (const auto& action : get_proxy_actions_[num_create_calls_]) |
| 279 mock_proxy_resolver_->AddGetProxyAction(action); |
| 280 } |
| 281 num_create_calls_++; |
| 282 } |
| 283 |
| 284 void TestMojoProxyResolverFactory::AddFuturePacScriptAction( |
| 285 int creation, |
| 286 SetPacScriptAction action) { |
| 287 pac_script_actions_[creation].push_back(action); |
| 288 } |
| 289 |
| 290 void TestMojoProxyResolverFactory::AddFutureGetProxyAction( |
| 291 int creation, |
| 292 GetProxyForUrlAction action) { |
| 293 get_proxy_actions_[creation].push_back(action); |
| 294 } |
| 295 |
| 296 class Request { |
| 297 public: |
| 298 Request(ProxyResolverMojo* resolver, const GURL& url); |
| 299 |
| 300 int Resolve(); |
| 301 void Cancel(); |
| 302 int WaitForResult(); |
| 303 |
| 304 int error() const { return error_; } |
| 305 const ProxyInfo& results() const { return results_; } |
| 306 |
| 307 private: |
| 308 ProxyResolverMojo* resolver_; |
| 309 const GURL url_; |
| 310 ProxyInfo results_; |
| 311 ProxyResolver::RequestHandle handle_; |
| 312 int error_; |
| 313 TestCompletionCallback callback_; |
| 314 }; |
| 315 |
| 316 Request::Request(ProxyResolverMojo* resolver, const GURL& url) |
| 317 : resolver_(resolver), url_(url), error_(0) { |
| 318 } |
| 319 |
| 320 int Request::Resolve() { |
| 321 BoundNetLog net_log; |
| 322 error_ = resolver_->GetProxyForURL(url_, &results_, callback_.callback(), |
| 323 &handle_, net_log); |
| 324 return error_; |
| 325 } |
| 326 |
| 327 void Request::Cancel() { |
| 328 resolver_->CancelRequest(handle_); |
| 329 } |
| 330 |
| 331 int Request::WaitForResult() { |
| 332 error_ = callback_.WaitForResult(); |
| 333 return error_; |
| 334 } |
| 335 |
| 336 } // namespace |
| 337 |
| 338 class ProxyResolverMojoTest : public testing::Test { |
| 339 public: |
| 340 void SetUp() override { |
| 341 proxy_resolver_mojo_.reset(new ProxyResolverMojo( |
| 342 &mojo_proxy_resolver_factory_, &mock_host_resolver_)); |
| 343 } |
| 344 |
| 345 scoped_ptr<Request> MakeRequest(const GURL& url) { |
| 346 return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url)); |
| 347 } |
| 348 |
| 349 mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString( |
| 350 const std::string& pac_string) { |
| 351 ProxyInfo proxy_info; |
| 352 proxy_info.UsePacString(pac_string); |
| 353 |
| 354 return mojo::Array<interfaces::ProxyServerPtr>::From( |
| 355 proxy_info.proxy_list().GetAll()); |
| 356 } |
| 357 |
| 358 void SetPacScript(int instance) { |
| 359 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 360 instance, SetPacScriptAction::ReturnResult(OK)); |
| 361 TestCompletionCallback callback; |
| 362 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 363 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 364 EXPECT_EQ(OK, callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 365 pac_script, callback.callback()))); |
| 366 } |
| 367 |
| 368 void RunCallbackAndSetPacScript(const net::CompletionCallback& callback, |
| 369 const net::CompletionCallback& pac_callback, |
| 370 int instance, |
| 371 int result) { |
| 372 callback.Run(result); |
| 373 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 374 instance, SetPacScriptAction::ReturnResult(OK)); |
| 375 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 376 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 377 EXPECT_EQ(ERR_IO_PENDING, |
| 378 proxy_resolver_mojo_->SetPacScript(pac_script, pac_callback)); |
| 379 } |
| 380 |
| 381 MockHostResolver mock_host_resolver_; |
| 382 TestMojoProxyResolverFactory mojo_proxy_resolver_factory_; |
| 383 scoped_ptr<ProxyResolverMojo> proxy_resolver_mojo_; |
| 384 }; |
| 385 |
| 386 TEST_F(ProxyResolverMojoTest, SetPacScript) { |
| 387 SetPacScript(0); |
| 388 EXPECT_EQ(kScriptData, |
| 389 mojo_proxy_resolver_factory_.GetMockResolver().pac_script_data()); |
| 390 } |
| 391 |
| 392 TEST_F(ProxyResolverMojoTest, SetPacScript_Empty) { |
| 393 TestCompletionCallback callback; |
| 394 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 395 ProxyResolverScriptData::FromUTF8("")); |
| 396 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, |
| 397 callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 398 pac_script, callback.callback()))); |
| 399 } |
| 400 |
| 401 TEST_F(ProxyResolverMojoTest, SetPacScript_Url) { |
| 402 TestCompletionCallback callback; |
| 403 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 404 ProxyResolverScriptData::FromURL(GURL(kExampleUrl))); |
| 405 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, |
| 406 callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 407 pac_script, callback.callback()))); |
| 408 } |
| 409 |
| 410 TEST_F(ProxyResolverMojoTest, SetPacScript_Failed) { |
| 411 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 412 0, SetPacScriptAction::ReturnResult(ERR_PAC_STATUS_NOT_OK)); |
| 413 |
| 414 TestCompletionCallback callback; |
| 415 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 416 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 417 EXPECT_EQ(ERR_PAC_STATUS_NOT_OK, |
| 418 callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 419 pac_script, callback.callback()))); |
| 420 } |
| 421 |
| 422 TEST_F(ProxyResolverMojoTest, SetPacScript_Disconnected) { |
| 423 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 424 0, SetPacScriptAction::Disconnect()); |
| 425 |
| 426 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 427 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 428 TestCompletionCallback callback; |
| 429 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 430 pac_script, callback.callback())); |
| 431 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, callback.GetResult(ERR_IO_PENDING)); |
| 432 } |
| 433 |
| 434 TEST_F(ProxyResolverMojoTest, SetPacScript_SuccessThenDisconnect) { |
| 435 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 436 0, SetPacScriptAction::ReturnResult(OK)); |
| 437 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 438 0, SetPacScriptAction::Disconnect()); |
| 439 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 440 1, SetPacScriptAction::ReturnResult(ERR_FAILED)); |
| 441 { |
| 442 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 443 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 444 TestCompletionCallback callback; |
| 445 EXPECT_EQ(OK, callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 446 pac_script, callback.callback()))); |
| 447 EXPECT_EQ(kScriptData, |
| 448 mojo_proxy_resolver_factory_.GetMockResolver().pac_script_data()); |
| 449 } |
| 450 |
| 451 { |
| 452 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 453 ProxyResolverScriptData::FromUTF8(kScriptData2)); |
| 454 TestCompletionCallback callback; |
| 455 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 456 pac_script, callback.callback())); |
| 457 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, callback.GetResult(ERR_IO_PENDING)); |
| 458 } |
| 459 |
| 460 { |
| 461 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 462 ProxyResolverScriptData::FromUTF8(kScriptData2)); |
| 463 TestCompletionCallback callback; |
| 464 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 465 pac_script, callback.callback())); |
| 466 EXPECT_EQ(ERR_FAILED, callback.GetResult(ERR_IO_PENDING)); |
| 467 } |
| 468 |
| 469 // The service should have been recreated on the last SetPacScript call. |
| 470 EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls()); |
| 471 } |
| 472 |
| 473 TEST_F(ProxyResolverMojoTest, SetPacScript_Cancel) { |
| 474 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 475 0, SetPacScriptAction::ReturnResult(OK)); |
| 476 |
| 477 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 478 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 479 TestCompletionCallback callback; |
| 480 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 481 pac_script, callback.callback())); |
| 482 proxy_resolver_mojo_->CancelSetPacScript(); |
| 483 |
| 484 // The Mojo request is still made. |
| 485 mojo_proxy_resolver_factory_.GetMockResolver().WaitForNextRequest(); |
| 486 } |
| 487 |
| 488 TEST_F(ProxyResolverMojoTest, SetPacScript_CancelAndSetAgain) { |
| 489 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 490 0, SetPacScriptAction::ReturnResult(ERR_FAILED)); |
| 491 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( |
| 492 0, SetPacScriptAction::ReturnResult(ERR_UNEXPECTED)); |
| 493 |
| 494 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 495 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 496 TestCompletionCallback callback1; |
| 497 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 498 pac_script, callback1.callback())); |
| 499 proxy_resolver_mojo_->CancelSetPacScript(); |
| 500 |
| 501 TestCompletionCallback callback2; |
| 502 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( |
| 503 pac_script, callback2.callback())); |
| 504 EXPECT_EQ(ERR_UNEXPECTED, callback2.GetResult(ERR_IO_PENDING)); |
| 505 } |
| 506 |
| 507 TEST_F(ProxyResolverMojoTest, GetProxyForURL) { |
| 508 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 509 0, GetProxyForUrlAction::ReturnServers( |
| 510 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); |
| 511 SetPacScript(0); |
| 512 |
| 513 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 514 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 515 EXPECT_EQ(OK, request->WaitForResult()); |
| 516 |
| 517 EXPECT_EQ("DIRECT", request->results().ToPacString()); |
| 518 } |
| 519 |
| 520 TEST_F(ProxyResolverMojoTest, GetProxyForURL_WithoutSetPacScript) { |
| 521 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 522 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve()); |
| 523 } |
| 524 |
| 525 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleResults) { |
| 526 static const char kPacString[] = |
| 527 "PROXY foo1:80;DIRECT;SOCKS foo2:1234;" |
| 528 "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888"; |
| 529 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 530 0, GetProxyForUrlAction::ReturnServers( |
| 531 GURL(kExampleUrl), ProxyServersFromPacString(kPacString))); |
| 532 SetPacScript(0); |
| 533 |
| 534 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 535 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 536 EXPECT_EQ(OK, request->WaitForResult()); |
| 537 |
| 538 EXPECT_EQ(kPacString, request->results().ToPacString()); |
| 539 } |
| 540 |
| 541 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Error) { |
| 542 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 543 0, GetProxyForUrlAction::ReturnError(GURL(kExampleUrl), ERR_UNEXPECTED)); |
| 544 SetPacScript(0); |
| 545 |
| 546 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 547 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 548 EXPECT_EQ(ERR_UNEXPECTED, request->WaitForResult()); |
| 549 |
| 550 EXPECT_TRUE(request->results().is_empty()); |
| 551 } |
| 552 |
| 553 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Cancel) { |
| 554 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 555 0, GetProxyForUrlAction::WaitForClientDisconnect(GURL(kExampleUrl))); |
| 556 SetPacScript(0); |
| 557 |
| 558 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 559 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 560 request->Cancel(); |
| 561 |
| 562 // The Mojo request is still made. |
| 563 mojo_proxy_resolver_factory_.GetMockResolver().WaitForNextRequest(); |
| 564 } |
| 565 |
| 566 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleRequests) { |
| 567 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 568 0, GetProxyForUrlAction::ReturnServers( |
| 569 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); |
| 570 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 571 0, GetProxyForUrlAction::ReturnServers( |
| 572 GURL("https://www.chromium.org"), |
| 573 ProxyServersFromPacString("HTTPS foo:443"))); |
| 574 SetPacScript(0); |
| 575 |
| 576 scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl))); |
| 577 EXPECT_EQ(ERR_IO_PENDING, request1->Resolve()); |
| 578 scoped_ptr<Request> request2(MakeRequest(GURL("https://www.chromium.org"))); |
| 579 EXPECT_EQ(ERR_IO_PENDING, request2->Resolve()); |
| 580 |
| 581 EXPECT_EQ(OK, request1->WaitForResult()); |
| 582 EXPECT_EQ(OK, request2->WaitForResult()); |
| 583 |
| 584 EXPECT_EQ("DIRECT", request1->results().ToPacString()); |
| 585 EXPECT_EQ("HTTPS foo:443", request2->results().ToPacString()); |
| 586 } |
| 587 |
| 588 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Disconnect) { |
| 589 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 590 0, GetProxyForUrlAction::Disconnect(GURL(kExampleUrl))); |
| 591 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 592 1, GetProxyForUrlAction::ReturnServers( |
| 593 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); |
| 594 { |
| 595 SetPacScript(0); |
| 596 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 597 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 598 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult()); |
| 599 EXPECT_TRUE(request->results().is_empty()); |
| 600 } |
| 601 |
| 602 { |
| 603 // Calling GetProxyForURL without first setting the pac script should fail. |
| 604 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 605 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve()); |
| 606 } |
| 607 |
| 608 { |
| 609 SetPacScript(1); |
| 610 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 611 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 612 EXPECT_EQ(OK, request->WaitForResult()); |
| 613 EXPECT_EQ("DIRECT", request->results().ToPacString()); |
| 614 } |
| 615 |
| 616 EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls()); |
| 617 } |
| 618 |
| 619 TEST_F(ProxyResolverMojoTest, GetProxyForURL_ClientClosed) { |
| 620 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 621 0, GetProxyForUrlAction::DropRequest(GURL(kExampleUrl))); |
| 622 SetPacScript(0); |
| 623 |
| 624 scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl))); |
| 625 EXPECT_EQ(ERR_IO_PENDING, request1->Resolve()); |
| 626 |
| 627 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request1->WaitForResult()); |
| 628 EXPECT_EQ(1, mojo_proxy_resolver_factory_.num_create_calls()); |
| 629 } |
| 630 |
| 631 TEST_F(ProxyResolverMojoTest, DisconnectAndFailCreate) { |
| 632 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 633 0, GetProxyForUrlAction::Disconnect(GURL(kExampleUrl))); |
| 634 |
| 635 { |
| 636 SetPacScript(0); |
| 637 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 638 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 639 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult()); |
| 640 EXPECT_TRUE(request->results().is_empty()); |
| 641 } |
| 642 |
| 643 // The service should attempt to create a new connection, but that should |
| 644 // fail. |
| 645 { |
| 646 scoped_refptr<ProxyResolverScriptData> pac_script( |
| 647 ProxyResolverScriptData::FromUTF8(kScriptData)); |
| 648 TestCompletionCallback callback; |
| 649 mojo_proxy_resolver_factory_.FailNextCreate(); |
| 650 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, |
| 651 callback.GetResult(proxy_resolver_mojo_->SetPacScript( |
| 652 pac_script, callback.callback()))); |
| 653 } |
| 654 |
| 655 // A third attempt should succeed. |
| 656 SetPacScript(2); |
| 657 |
| 658 EXPECT_EQ(3, mojo_proxy_resolver_factory_.num_create_calls()); |
| 659 } |
| 660 |
| 661 TEST_F(ProxyResolverMojoTest, DisconnectAndReconnectInCallback) { |
| 662 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 663 0, GetProxyForUrlAction::Disconnect(GURL(kExampleUrl))); |
| 664 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( |
| 665 1, GetProxyForUrlAction::ReturnServers( |
| 666 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); |
| 667 |
| 668 // In this first resolve request, the Mojo service is disconnected causing the |
| 669 // request to return ERR_PAC_SCRIPT_TERMINATED. In the request callback, form |
| 670 // a new connection to a Mojo resolver service by calling SetPacScript(). |
| 671 SetPacScript(0); |
| 672 ProxyInfo results; |
| 673 TestCompletionCallback resolve_callback; |
| 674 TestCompletionCallback pac_callback; |
| 675 ProxyResolver::RequestHandle handle; |
| 676 BoundNetLog net_log; |
| 677 int error = proxy_resolver_mojo_->GetProxyForURL( |
| 678 GURL(kExampleUrl), &results, |
| 679 base::Bind(&ProxyResolverMojoTest::RunCallbackAndSetPacScript, |
| 680 base::Unretained(this), resolve_callback.callback(), |
| 681 pac_callback.callback(), 1), |
| 682 &handle, net_log); |
| 683 EXPECT_EQ(ERR_IO_PENDING, error); |
| 684 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, resolve_callback.WaitForResult()); |
| 685 EXPECT_EQ(OK, pac_callback.WaitForResult()); |
| 686 |
| 687 // Setting the PAC script above should have been successful and let us send a |
| 688 // resolve request. |
| 689 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); |
| 690 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); |
| 691 EXPECT_EQ(OK, request->WaitForResult()); |
| 692 EXPECT_EQ("DIRECT", request->results().ToPacString()); |
| 693 |
| 694 EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls()); |
| 695 } |
| 696 |
| 697 } // namespace net |
OLD | NEW |