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