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_; | |
Sam McNally
2015/03/02 06:51:17
std::queue here too?
Anand Mistry (off Chromium)
2015/03/02 07:01:30
No. You can't use std::queue with range-based for
| |
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 protected: | |
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 MockHostResolver mock_host_resolver_; | |
369 TestMojoProxyResolverFactory mojo_proxy_resolver_factory_; | |
370 scoped_ptr<ProxyResolverMojo> proxy_resolver_mojo_; | |
371 }; | |
372 | |
373 TEST_F(ProxyResolverMojoTest, SetPacScript) { | |
374 SetPacScript(0); | |
375 EXPECT_EQ(kScriptData, | |
376 mojo_proxy_resolver_factory_.GetMockResolver().pac_script_data()); | |
377 } | |
378 | |
379 TEST_F(ProxyResolverMojoTest, SetPacScript_Empty) { | |
380 TestCompletionCallback callback; | |
381 scoped_refptr<ProxyResolverScriptData> pac_script( | |
382 ProxyResolverScriptData::FromUTF8("")); | |
383 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, | |
384 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
385 pac_script, callback.callback()))); | |
386 } | |
387 | |
388 TEST_F(ProxyResolverMojoTest, SetPacScript_Url) { | |
389 TestCompletionCallback callback; | |
390 scoped_refptr<ProxyResolverScriptData> pac_script( | |
391 ProxyResolverScriptData::FromURL(GURL(kExampleUrl))); | |
392 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, | |
393 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
394 pac_script, callback.callback()))); | |
395 } | |
396 | |
397 TEST_F(ProxyResolverMojoTest, SetPacScript_Failed) { | |
398 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
399 0, SetPacScriptAction::ReturnResult(ERR_PAC_STATUS_NOT_OK)); | |
400 | |
401 TestCompletionCallback callback; | |
402 scoped_refptr<ProxyResolverScriptData> pac_script( | |
403 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
404 EXPECT_EQ(ERR_PAC_STATUS_NOT_OK, | |
405 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
406 pac_script, callback.callback()))); | |
407 } | |
408 | |
409 TEST_F(ProxyResolverMojoTest, SetPacScript_Disconnected) { | |
410 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
411 0, SetPacScriptAction::Disconnect()); | |
412 | |
413 scoped_refptr<ProxyResolverScriptData> pac_script( | |
414 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
415 TestCompletionCallback callback; | |
416 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
417 pac_script, callback.callback())); | |
418 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, callback.GetResult(ERR_IO_PENDING)); | |
419 } | |
420 | |
421 TEST_F(ProxyResolverMojoTest, SetPacScript_SuccessThenDisconnect) { | |
422 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
423 0, SetPacScriptAction::ReturnResult(OK)); | |
424 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
425 0, SetPacScriptAction::Disconnect()); | |
426 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
427 1, SetPacScriptAction::ReturnResult(ERR_FAILED)); | |
428 { | |
429 scoped_refptr<ProxyResolverScriptData> pac_script( | |
430 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
431 TestCompletionCallback callback; | |
432 EXPECT_EQ(OK, callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
433 pac_script, callback.callback()))); | |
434 EXPECT_EQ(kScriptData, | |
435 mojo_proxy_resolver_factory_.GetMockResolver().pac_script_data()); | |
436 } | |
437 | |
438 { | |
439 scoped_refptr<ProxyResolverScriptData> pac_script( | |
440 ProxyResolverScriptData::FromUTF8(kScriptData2)); | |
441 TestCompletionCallback callback; | |
442 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
443 pac_script, callback.callback())); | |
444 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, callback.GetResult(ERR_IO_PENDING)); | |
445 } | |
446 | |
447 { | |
448 scoped_refptr<ProxyResolverScriptData> pac_script( | |
449 ProxyResolverScriptData::FromUTF8(kScriptData2)); | |
450 TestCompletionCallback callback; | |
451 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
452 pac_script, callback.callback())); | |
453 EXPECT_EQ(ERR_FAILED, callback.GetResult(ERR_IO_PENDING)); | |
454 } | |
455 | |
456 // The service should have been recreated on the last SetPacScript call. | |
457 EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls()); | |
458 } | |
459 | |
460 TEST_F(ProxyResolverMojoTest, SetPacScript_Cancel) { | |
461 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
462 0, SetPacScriptAction::ReturnResult(OK)); | |
463 | |
464 scoped_refptr<ProxyResolverScriptData> pac_script( | |
465 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
466 TestCompletionCallback callback; | |
467 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
468 pac_script, callback.callback())); | |
469 proxy_resolver_mojo_->CancelSetPacScript(); | |
470 | |
471 // The Mojo request is still made. | |
472 mojo_proxy_resolver_factory_.GetMockResolver().WaitForNextRequest(); | |
473 } | |
474 | |
475 TEST_F(ProxyResolverMojoTest, SetPacScript_CancelAndSetAgain) { | |
476 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
477 0, SetPacScriptAction::ReturnResult(ERR_FAILED)); | |
478 mojo_proxy_resolver_factory_.AddFuturePacScriptAction( | |
479 0, SetPacScriptAction::ReturnResult(ERR_UNEXPECTED)); | |
480 | |
481 scoped_refptr<ProxyResolverScriptData> pac_script( | |
482 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
483 TestCompletionCallback callback1; | |
484 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
485 pac_script, callback1.callback())); | |
486 proxy_resolver_mojo_->CancelSetPacScript(); | |
487 | |
488 TestCompletionCallback callback2; | |
489 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
490 pac_script, callback2.callback())); | |
491 EXPECT_EQ(ERR_UNEXPECTED, callback2.GetResult(ERR_IO_PENDING)); | |
492 } | |
493 | |
494 TEST_F(ProxyResolverMojoTest, GetProxyForURL) { | |
495 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
496 0, GetProxyForUrlAction::ReturnServers( | |
497 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); | |
498 SetPacScript(0); | |
499 | |
500 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
501 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
502 EXPECT_EQ(OK, request->WaitForResult()); | |
503 | |
504 EXPECT_EQ("DIRECT", request->results().ToPacString()); | |
505 } | |
506 | |
507 TEST_F(ProxyResolverMojoTest, GetProxyForURL_WithoutSetPacScript) { | |
508 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
509 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve()); | |
510 } | |
511 | |
512 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleResults) { | |
513 static const char kPacString[] = | |
514 "PROXY foo1:80;DIRECT;SOCKS foo2:1234;" | |
515 "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888"; | |
516 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
517 0, GetProxyForUrlAction::ReturnServers( | |
518 GURL(kExampleUrl), ProxyServersFromPacString(kPacString))); | |
519 SetPacScript(0); | |
520 | |
521 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
522 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
523 EXPECT_EQ(OK, request->WaitForResult()); | |
524 | |
525 EXPECT_EQ(kPacString, request->results().ToPacString()); | |
526 } | |
527 | |
528 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Error) { | |
529 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
530 0, GetProxyForUrlAction::ReturnError(GURL(kExampleUrl), ERR_UNEXPECTED)); | |
531 SetPacScript(0); | |
532 | |
533 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
534 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
535 EXPECT_EQ(ERR_UNEXPECTED, request->WaitForResult()); | |
536 | |
537 EXPECT_TRUE(request->results().is_empty()); | |
538 } | |
539 | |
540 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Cancel) { | |
541 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
542 0, GetProxyForUrlAction::WaitForClientDisconnect(GURL(kExampleUrl))); | |
543 SetPacScript(0); | |
544 | |
545 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
546 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
547 request->Cancel(); | |
548 | |
549 // The Mojo request is still made. | |
550 mojo_proxy_resolver_factory_.GetMockResolver().WaitForNextRequest(); | |
551 } | |
552 | |
553 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleRequests) { | |
554 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
555 0, GetProxyForUrlAction::ReturnServers( | |
556 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); | |
557 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
558 0, GetProxyForUrlAction::ReturnServers( | |
559 GURL("https://www.chromium.org"), | |
560 ProxyServersFromPacString("HTTPS foo:443"))); | |
561 SetPacScript(0); | |
562 | |
563 scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl))); | |
564 EXPECT_EQ(ERR_IO_PENDING, request1->Resolve()); | |
565 scoped_ptr<Request> request2(MakeRequest(GURL("https://www.chromium.org"))); | |
566 EXPECT_EQ(ERR_IO_PENDING, request2->Resolve()); | |
567 | |
568 EXPECT_EQ(OK, request1->WaitForResult()); | |
569 EXPECT_EQ(OK, request2->WaitForResult()); | |
570 | |
571 EXPECT_EQ("DIRECT", request1->results().ToPacString()); | |
572 EXPECT_EQ("HTTPS foo:443", request2->results().ToPacString()); | |
573 } | |
574 | |
575 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Disconnect) { | |
576 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
577 0, GetProxyForUrlAction::Disconnect(GURL(kExampleUrl))); | |
578 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
579 1, GetProxyForUrlAction::ReturnServers( | |
580 GURL(kExampleUrl), ProxyServersFromPacString("DIRECT"))); | |
581 { | |
582 SetPacScript(0); | |
583 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
584 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
585 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult()); | |
586 EXPECT_TRUE(request->results().is_empty()); | |
587 } | |
588 | |
589 { | |
590 // Calling GetProxyForURL without first setting the pac script should fail. | |
591 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
592 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->Resolve()); | |
593 } | |
594 | |
595 { | |
596 SetPacScript(1); | |
597 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
598 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
599 EXPECT_EQ(OK, request->WaitForResult()); | |
600 EXPECT_EQ("DIRECT", request->results().ToPacString()); | |
601 } | |
602 | |
603 EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls()); | |
604 } | |
605 | |
606 TEST_F(ProxyResolverMojoTest, GetProxyForURL_ClientClosed) { | |
607 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
608 0, GetProxyForUrlAction::DropRequest(GURL(kExampleUrl))); | |
609 SetPacScript(0); | |
610 | |
611 scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl))); | |
612 EXPECT_EQ(ERR_IO_PENDING, request1->Resolve()); | |
613 | |
614 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request1->WaitForResult()); | |
615 EXPECT_EQ(1, mojo_proxy_resolver_factory_.num_create_calls()); | |
616 } | |
617 | |
618 TEST_F(ProxyResolverMojoTest, DisconnectAndFailCreate) { | |
619 mojo_proxy_resolver_factory_.AddFutureGetProxyAction( | |
620 0, GetProxyForUrlAction::Disconnect(GURL(kExampleUrl))); | |
621 | |
622 { | |
623 SetPacScript(0); | |
624 scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl))); | |
625 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
626 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request->WaitForResult()); | |
627 EXPECT_TRUE(request->results().is_empty()); | |
628 } | |
629 | |
630 // The service should attempt to create a new connection, but that should | |
631 // fail. | |
632 { | |
633 scoped_refptr<ProxyResolverScriptData> pac_script( | |
634 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
635 TestCompletionCallback callback; | |
636 mojo_proxy_resolver_factory_.FailNextCreate(); | |
637 EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, | |
638 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
639 pac_script, callback.callback()))); | |
640 } | |
641 | |
642 // A third attempt should succeed. | |
643 SetPacScript(2); | |
644 | |
645 EXPECT_EQ(3, mojo_proxy_resolver_factory_.num_create_calls()); | |
646 } | |
647 | |
648 } // namespace net | |
OLD | NEW |