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 <map> | |
8 #include <string> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/memory/scoped_ptr.h" | |
12 #include "base/run_loop.h" | |
13 #include "base/stl_util.h" | |
14 #include "mojo/common/common_type_converters.h" | |
15 #include "net/base/net_log.h" | |
16 #include "net/base/test_completion_callback.h" | |
17 #include "net/dns/mock_host_resolver.h" | |
18 #include "net/proxy/mojo_proxy_resolver_factory.h" | |
19 #include "net/proxy/mojo_type_converters.h" | |
20 #include "net/proxy/proxy_info.h" | |
21 #include "net/proxy/proxy_resolver_script_data.h" | |
22 #include "testing/gtest/include/gtest/gtest.h" | |
23 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h" | |
24 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h" | |
25 #include "url/gurl.h" | |
26 | |
27 namespace net { | |
28 | |
29 namespace { | |
30 | |
31 static const char kScriptData[] = "FooBarBaz"; | |
32 | |
33 class MockMojoProxyResolver : public interfaces::ProxyResolver { | |
34 public: | |
35 explicit MockMojoProxyResolver( | |
36 mojo::InterfaceRequest<interfaces::ProxyResolver> req) | |
37 : pac_script_result_(OK), | |
38 pac_script_calls_(0), | |
39 binding_(this, req.Pass()) {} | |
40 ~MockMojoProxyResolver() override { | |
41 STLDeleteContainerPairSecondPointers(proxy_results_.begin(), | |
42 proxy_results_.end()); | |
43 }; | |
44 | |
45 void SetPacScriptResult(int result) { pac_script_result_ = result; } | |
46 // Returned script data is UTF8. | |
47 std::string GetPacScriptData() { return pac_script_data_; } | |
48 int GetPacScriptCalls() { return pac_script_calls_; } | |
49 | |
50 void AddProxyResult(const GURL& url, | |
51 int error, | |
52 mojo::Array<interfaces::ProxyServerPtr> proxy_servers); | |
53 void CloseRequestClient(const GURL& url); | |
54 | |
55 void Disconnect() { binding_.Close(); } | |
56 | |
57 void WaitForSetPacScript(); | |
58 | |
59 private: | |
60 struct ProxyResults { | |
61 explicit ProxyResults(bool close) | |
62 : close(close), error(OK), proxy_servers() {} | |
63 ProxyResults(int err, mojo::Array<interfaces::ProxyServerPtr>& s) | |
64 : close(false), error(err), proxy_servers(s.Pass()) {} | |
65 | |
66 bool close; | |
67 int error; | |
68 mojo::Array<interfaces::ProxyServerPtr> proxy_servers; | |
69 }; | |
70 | |
71 // Overridden from interfaces::ProxyResolver: | |
72 void SetPacScript(const mojo::String& data, | |
73 const mojo::Callback<void(int32_t)>& callback) override; | |
74 void GetProxyForUrl( | |
75 const mojo::String& url, | |
76 interfaces::ProxyResolverRequestClientPtr client) override; | |
77 | |
78 std::string pac_script_data_; | |
79 int pac_script_result_; | |
80 int pac_script_calls_; | |
81 base::Closure pac_script_quit_closure_; | |
82 | |
83 std::map<GURL, ProxyResults*> proxy_results_; | |
84 | |
85 mojo::Binding<interfaces::ProxyResolver> binding_; | |
86 }; | |
87 | |
88 void MockMojoProxyResolver::AddProxyResult( | |
89 const GURL& url, | |
90 int error, | |
91 mojo::Array<interfaces::ProxyServerPtr> proxy_servers) { | |
92 proxy_results_[url] = new ProxyResults(error, proxy_servers); | |
93 } | |
94 | |
95 void MockMojoProxyResolver::CloseRequestClient(const GURL& url) { | |
96 proxy_results_[url] = new ProxyResults(true); | |
97 } | |
98 | |
99 void MockMojoProxyResolver::SetPacScript( | |
100 const mojo::String& data, | |
101 const mojo::Callback<void(int32_t)>& callback) { | |
102 pac_script_data_ = data.To<std::string>(); | |
103 pac_script_calls_++; | |
104 callback.Run(pac_script_result_); | |
105 if (!pac_script_quit_closure_.is_null()) | |
106 pac_script_quit_closure_.Run(); | |
107 pac_script_quit_closure_.Reset(); | |
108 } | |
109 | |
110 void MockMojoProxyResolver::WaitForSetPacScript() { | |
111 if (pac_script_calls_) | |
112 return; | |
113 | |
114 base::RunLoop run_loop; | |
115 pac_script_quit_closure_ = run_loop.QuitClosure(); | |
116 run_loop.Run(); | |
117 } | |
118 | |
119 void MockMojoProxyResolver::GetProxyForUrl( | |
120 const mojo::String& url, | |
121 interfaces::ProxyResolverRequestClientPtr client) { | |
122 ProxyResults* result = proxy_results_[url.To<GURL>()]; | |
123 ASSERT_NE(nullptr, result); | |
124 if (result->close) { | |
125 client.reset(); | |
126 } else { | |
127 client->ReportResult(result->error, result->proxy_servers.Clone()); | |
128 } | |
129 } | |
130 | |
131 class TestMojoProxyResolverFactory : public MojoProxyResolverFactory { | |
132 public: | |
133 TestMojoProxyResolverFactory(); | |
134 ~TestMojoProxyResolverFactory(); | |
135 | |
136 // Overridden from MojoProxyResolverFactory: | |
137 void Create(mojo::InterfaceRequest<interfaces::ProxyResolver> req, | |
138 interfaces::HostResolverPtr host_resolver) override; | |
139 | |
140 MockMojoProxyResolver* GetMockResolver() { | |
141 return mock_proxy_resolver_.get(); | |
142 } | |
143 | |
144 int NumCreateCalls() const { return num_create_calls_; } | |
145 | |
146 private: | |
147 int num_create_calls_; | |
148 | |
149 scoped_ptr<MockMojoProxyResolver> mock_proxy_resolver_; | |
150 }; | |
151 | |
152 TestMojoProxyResolverFactory::TestMojoProxyResolverFactory() | |
153 : num_create_calls_(0) { | |
154 } | |
155 | |
156 TestMojoProxyResolverFactory::~TestMojoProxyResolverFactory() { | |
157 } | |
158 | |
159 void TestMojoProxyResolverFactory::Create( | |
160 mojo::InterfaceRequest<interfaces::ProxyResolver> req, | |
161 interfaces::HostResolverPtr host_resolver) { | |
162 num_create_calls_++; | |
163 mock_proxy_resolver_.reset(new MockMojoProxyResolver(req.Pass())); | |
164 } | |
165 | |
166 class Request { | |
167 public: | |
168 Request(ProxyResolverMojo* resolver, const GURL& url); | |
169 | |
170 int Resolve(); | |
171 void Cancel(); | |
172 int WaitForResult(); | |
173 | |
174 int error() const { return error_; } | |
175 const ProxyInfo& results() const { return results_; } | |
176 | |
177 private: | |
178 // Completion callback for ProxyResolverMojo::Resolve. | |
179 void OnResolveDone(int error); | |
180 | |
181 ProxyResolverMojo* resolver_; | |
182 const GURL url_; | |
183 ProxyInfo results_; | |
184 ProxyResolver::RequestHandle handle_; | |
185 int error_; | |
186 | |
187 base::RunLoop run_loop_; | |
188 }; | |
189 | |
190 Request::Request(ProxyResolverMojo* resolver, const GURL& url) | |
191 : resolver_(resolver), url_(url), error_(0) { | |
192 } | |
193 | |
194 int Request::Resolve() { | |
195 BoundNetLog net_log; | |
196 error_ = resolver_->GetProxyForURL( | |
197 url_, &results_, | |
198 base::Bind(&Request::OnResolveDone, base::Unretained(this)), &handle_, | |
199 net_log); | |
200 return error_; | |
201 } | |
202 | |
203 void Request::Cancel() { | |
204 resolver_->CancelRequest(handle_); | |
205 } | |
206 | |
207 void Request::OnResolveDone(int error) { | |
208 error_ = error; | |
209 run_loop_.Quit(); | |
210 } | |
211 | |
212 int Request::WaitForResult() { | |
213 run_loop_.Run(); | |
214 return error_; | |
215 } | |
216 | |
217 } // namespace | |
218 | |
219 class ProxyResolverMojoTest : public testing::Test { | |
220 protected: | |
221 void SetUp() override { | |
222 mock_host_resolver_.rules()->AddRule("example.com", "1.2.3.4"); | |
223 | |
224 proxy_resolver_mojo_.reset(new ProxyResolverMojo( | |
225 &mojo_proxy_resolver_factory_, &mock_host_resolver_)); | |
226 } | |
227 | |
228 Request* MakeRequest(const GURL& url) { | |
Sam McNally
2015/02/16 05:52:38
scoped_ptr<Request>
Anand Mistry (off Chromium)
2015/02/17 05:49:21
Done.
| |
229 return new Request(proxy_resolver_mojo_.get(), url); | |
230 } | |
231 | |
232 mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString( | |
233 const std::string& pac_string) { | |
234 ProxyInfo proxy_info; | |
235 proxy_info.UsePacString(pac_string); | |
236 | |
237 return mojo::Array<interfaces::ProxyServerPtr>::From( | |
238 proxy_info.proxy_list().GetAll()); | |
239 } | |
240 | |
241 MockHostResolver mock_host_resolver_; | |
242 TestMojoProxyResolverFactory mojo_proxy_resolver_factory_; | |
243 scoped_ptr<ProxyResolverMojo> proxy_resolver_mojo_; | |
244 }; | |
245 | |
246 TEST_F(ProxyResolverMojoTest, SetPacScript) { | |
247 TestCompletionCallback callback; | |
248 scoped_refptr<ProxyResolverScriptData> pac_script( | |
249 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
250 EXPECT_EQ(OK, callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
251 pac_script, callback.callback()))); | |
252 EXPECT_EQ(kScriptData, | |
253 mojo_proxy_resolver_factory_.GetMockResolver()->GetPacScriptData()); | |
254 } | |
255 | |
256 TEST_F(ProxyResolverMojoTest, SetPacScript_Empty) { | |
257 TestCompletionCallback callback; | |
258 scoped_refptr<ProxyResolverScriptData> pac_script( | |
259 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
Sam McNally
2015/02/16 05:52:38
That isn't empty.
Anand Mistry (off Chromium)
2015/02/17 05:49:21
Done.
| |
260 EXPECT_EQ(OK, callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
261 pac_script, callback.callback()))); | |
262 EXPECT_EQ(kScriptData, | |
263 mojo_proxy_resolver_factory_.GetMockResolver()->GetPacScriptData()); | |
264 } | |
265 | |
266 TEST_F(ProxyResolverMojoTest, SetPacScript_Url) { | |
267 TestCompletionCallback callback; | |
268 scoped_refptr<ProxyResolverScriptData> pac_script( | |
269 ProxyResolverScriptData::FromURL(GURL("http://www.example.com"))); | |
270 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, | |
271 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
272 pac_script, callback.callback()))); | |
273 } | |
274 | |
275 TEST_F(ProxyResolverMojoTest, SetPacScript_Failed) { | |
276 TestCompletionCallback callback; | |
277 scoped_refptr<ProxyResolverScriptData> pac_script( | |
278 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
279 mojo_proxy_resolver_factory_.GetMockResolver()->SetPacScriptResult( | |
280 ERR_PAC_STATUS_NOT_OK); | |
281 EXPECT_EQ(ERR_PAC_STATUS_NOT_OK, | |
282 callback.GetResult(proxy_resolver_mojo_->SetPacScript( | |
283 pac_script, callback.callback()))); | |
284 } | |
285 | |
286 TEST_F(ProxyResolverMojoTest, SetPacScript_Disconnected) { | |
287 scoped_refptr<ProxyResolverScriptData> pac_script( | |
288 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
289 TestCompletionCallback callback; | |
290 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
291 pac_script, callback.callback())); | |
292 mojo_proxy_resolver_factory_.GetMockResolver()->Disconnect(); | |
293 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.GetResult(ERR_IO_PENDING)); | |
294 | |
295 // Run any additional queued callbacks, including the disconnection. | |
296 base::RunLoop().RunUntilIdle(); | |
297 | |
298 // The service should have been recreated transparently. | |
299 EXPECT_EQ(2, mojo_proxy_resolver_factory_.NumCreateCalls()); | |
300 | |
301 // Wait for SetPacScript() to be run. | |
302 mojo_proxy_resolver_factory_.GetMockResolver()->WaitForSetPacScript(); | |
303 | |
304 EXPECT_EQ( | |
305 1, mojo_proxy_resolver_factory_.GetMockResolver()->GetPacScriptCalls()); | |
306 EXPECT_EQ(kScriptData, | |
307 mojo_proxy_resolver_factory_.GetMockResolver()->GetPacScriptData()); | |
308 } | |
309 | |
310 TEST_F(ProxyResolverMojoTest, SetPacScript_Cancel) { | |
311 scoped_refptr<ProxyResolverScriptData> pac_script( | |
312 ProxyResolverScriptData::FromUTF8(kScriptData)); | |
313 TestCompletionCallback callback; | |
314 EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_mojo_->SetPacScript( | |
315 pac_script, callback.callback())); | |
316 proxy_resolver_mojo_->CancelSetPacScript(); | |
317 } | |
318 | |
319 TEST_F(ProxyResolverMojoTest, GetProxyForURL) { | |
320 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
321 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
322 GURL("http://www.example.com"), OK, ProxyServersFromPacString("DIRECT")); | |
323 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
324 EXPECT_EQ(OK, request->WaitForResult()); | |
325 | |
326 EXPECT_EQ("DIRECT", request->results().ToPacString()); | |
327 } | |
328 | |
329 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleResults) { | |
330 static const char kPacString[] = | |
331 "PROXY foo1:80;DIRECT;SOCKS foo2:1234;" | |
332 "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888"; | |
333 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
334 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
335 GURL("http://www.example.com"), OK, | |
336 ProxyServersFromPacString(kPacString)); | |
337 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
338 EXPECT_EQ(OK, request->WaitForResult()); | |
339 | |
340 EXPECT_EQ(kPacString, request->results().ToPacString()); | |
341 } | |
342 | |
343 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Error) { | |
344 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
345 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
346 GURL("http://www.example.com"), ERR_UNEXPECTED, | |
347 mojo::Array<interfaces::ProxyServerPtr>()); | |
348 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
349 EXPECT_EQ(ERR_UNEXPECTED, request->WaitForResult()); | |
350 | |
351 EXPECT_TRUE(request->results().is_empty()); | |
352 } | |
353 | |
354 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Cancel) { | |
355 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
356 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
357 GURL("http://www.example.com"), OK, ProxyServersFromPacString("DIRECT")); | |
358 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
359 request->Cancel(); | |
360 } | |
361 | |
362 TEST_F(ProxyResolverMojoTest, GetProxyForURL_MultipleRequests) { | |
363 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
364 GURL("http://www.example.com"), OK, ProxyServersFromPacString("DIRECT")); | |
365 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
366 GURL("https://www.chromium.org"), OK, | |
367 ProxyServersFromPacString("HTTPS foo:443")); | |
368 | |
369 scoped_ptr<Request> request1(MakeRequest(GURL("http://www.example.com"))); | |
370 EXPECT_EQ(ERR_IO_PENDING, request1->Resolve()); | |
371 scoped_ptr<Request> request2(MakeRequest(GURL("https://www.chromium.org"))); | |
372 EXPECT_EQ(ERR_IO_PENDING, request2->Resolve()); | |
373 | |
374 EXPECT_EQ(OK, request1->WaitForResult()); | |
375 EXPECT_EQ(OK, request2->WaitForResult()); | |
376 | |
377 EXPECT_EQ("DIRECT", request1->results().ToPacString()); | |
378 EXPECT_EQ("HTTPS foo:443", request2->results().ToPacString()); | |
379 } | |
380 | |
381 TEST_F(ProxyResolverMojoTest, GetProxyForURL_Disconnect) { | |
382 { | |
383 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
384 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
385 GURL("http://www.example.com"), OK, | |
386 ProxyServersFromPacString("DIRECT")); | |
387 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
388 mojo_proxy_resolver_factory_.GetMockResolver()->Disconnect(); | |
389 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, request->WaitForResult()); | |
390 EXPECT_TRUE(request->results().is_empty()); | |
391 } | |
392 | |
393 { | |
394 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
395 mojo_proxy_resolver_factory_.GetMockResolver()->AddProxyResult( | |
396 GURL("http://www.example.com"), OK, | |
397 ProxyServersFromPacString("DIRECT")); | |
398 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
399 EXPECT_EQ(OK, request->WaitForResult()); | |
400 EXPECT_EQ("DIRECT", request->results().ToPacString()); | |
401 } | |
402 | |
403 EXPECT_EQ(2, mojo_proxy_resolver_factory_.NumCreateCalls()); | |
404 } | |
405 | |
406 TEST_F(ProxyResolverMojoTest, GetProxyForURL_ClientClosed) { | |
407 scoped_ptr<Request> request(MakeRequest(GURL("http://www.example.com"))); | |
408 mojo_proxy_resolver_factory_.GetMockResolver()->CloseRequestClient( | |
409 GURL("http://www.example.com")); | |
410 EXPECT_EQ(ERR_IO_PENDING, request->Resolve()); | |
411 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, request->WaitForResult()); | |
412 | |
413 EXPECT_TRUE(request->results().is_empty()); | |
414 } | |
415 | |
416 } // namespace net | |
OLD | NEW |