OLD | NEW |
1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/base/host_resolver_impl.h" | 5 #include "net/base/host_resolver_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
10 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
11 #include "base/ref_counted.h" | 11 #include "base/ref_counted.h" |
12 #include "base/string_util.h" | 12 #include "base/string_util.h" |
13 #include "net/base/address_list.h" | 13 #include "net/base/address_list.h" |
14 #include "net/base/completion_callback.h" | 14 #include "net/base/completion_callback.h" |
15 #include "net/base/load_log_unittest.h" | |
16 #include "net/base/mock_host_resolver.h" | 15 #include "net/base/mock_host_resolver.h" |
17 #include "net/base/mock_network_change_notifier.h" | 16 #include "net/base/mock_network_change_notifier.h" |
18 #include "net/base/net_errors.h" | 17 #include "net/base/net_errors.h" |
| 18 #include "net/base/net_log_unittest.h" |
19 #include "net/base/net_util.h" | 19 #include "net/base/net_util.h" |
20 #include "net/base/sys_addrinfo.h" | 20 #include "net/base/sys_addrinfo.h" |
21 #include "net/base/test_completion_callback.h" | 21 #include "net/base/test_completion_callback.h" |
22 #include "testing/gtest/include/gtest/gtest.h" | 22 #include "testing/gtest/include/gtest/gtest.h" |
23 | 23 |
24 // TODO(eroman): | 24 // TODO(eroman): |
25 // - Test mixing async with sync (in particular how does sync update the | 25 // - Test mixing async with sync (in particular how does sync update the |
26 // cache while an async is already pending). | 26 // cache while an async is already pending). |
27 | 27 |
28 namespace net { | 28 namespace net { |
(...skipping 226 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
255 const int kPortnum = 80; | 255 const int kPortnum = 80; |
256 | 256 |
257 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = | 257 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = |
258 new RuleBasedHostResolverProc(NULL); | 258 new RuleBasedHostResolverProc(NULL); |
259 resolver_proc->AddRule("just.testing", "192.168.1.42"); | 259 resolver_proc->AddRule("just.testing", "192.168.1.42"); |
260 | 260 |
261 scoped_refptr<HostResolver> host_resolver( | 261 scoped_refptr<HostResolver> host_resolver( |
262 CreateHostResolverImpl(resolver_proc)); | 262 CreateHostResolverImpl(resolver_proc)); |
263 | 263 |
264 HostResolver::RequestInfo info("just.testing", kPortnum); | 264 HostResolver::RequestInfo info("just.testing", kPortnum); |
265 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 265 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
266 int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, log); | 266 int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, log.bound()); |
267 EXPECT_EQ(OK, err); | 267 EXPECT_EQ(OK, err); |
268 | 268 |
269 EXPECT_EQ(2u, log->entries().size()); | 269 EXPECT_EQ(2u, log.entries().size()); |
270 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 270 EXPECT_TRUE(LogContainsBeginEvent( |
271 EXPECT_TRUE(LogContainsEndEvent(*log, 1, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 271 log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
| 272 EXPECT_TRUE(LogContainsEndEvent( |
| 273 log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
272 | 274 |
273 const struct addrinfo* ainfo = adrlist.head(); | 275 const struct addrinfo* ainfo = adrlist.head(); |
274 EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next); | 276 EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next); |
275 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); | 277 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); |
276 | 278 |
277 const struct sockaddr* sa = ainfo->ai_addr; | 279 const struct sockaddr* sa = ainfo->ai_addr; |
278 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; | 280 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; |
279 EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port); | 281 EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port); |
280 EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr); | 282 EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr); |
281 } | 283 } |
282 | 284 |
283 TEST_F(HostResolverImplTest, AsynchronousLookup) { | 285 TEST_F(HostResolverImplTest, AsynchronousLookup) { |
284 AddressList adrlist; | 286 AddressList adrlist; |
285 const int kPortnum = 80; | 287 const int kPortnum = 80; |
286 | 288 |
287 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = | 289 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = |
288 new RuleBasedHostResolverProc(NULL); | 290 new RuleBasedHostResolverProc(NULL); |
289 resolver_proc->AddRule("just.testing", "192.168.1.42"); | 291 resolver_proc->AddRule("just.testing", "192.168.1.42"); |
290 | 292 |
291 scoped_refptr<HostResolver> host_resolver( | 293 scoped_refptr<HostResolver> host_resolver( |
292 CreateHostResolverImpl(resolver_proc)); | 294 CreateHostResolverImpl(resolver_proc)); |
293 | 295 |
294 HostResolver::RequestInfo info("just.testing", kPortnum); | 296 HostResolver::RequestInfo info("just.testing", kPortnum); |
295 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 297 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
296 int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, log); | 298 int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, |
| 299 log.bound()); |
297 EXPECT_EQ(ERR_IO_PENDING, err); | 300 EXPECT_EQ(ERR_IO_PENDING, err); |
298 | 301 |
299 EXPECT_EQ(1u, log->entries().size()); | 302 EXPECT_EQ(1u, log.entries().size()); |
300 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 303 EXPECT_TRUE(LogContainsBeginEvent( |
| 304 log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
301 | 305 |
302 MessageLoop::current()->Run(); | 306 MessageLoop::current()->Run(); |
303 | 307 |
304 ASSERT_TRUE(callback_called_); | 308 ASSERT_TRUE(callback_called_); |
305 ASSERT_EQ(OK, callback_result_); | 309 ASSERT_EQ(OK, callback_result_); |
306 | 310 |
307 EXPECT_EQ(2u, log->entries().size()); | 311 EXPECT_EQ(2u, log.entries().size()); |
308 EXPECT_TRUE(LogContainsEndEvent(*log, 1, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 312 EXPECT_TRUE(LogContainsEndEvent( |
| 313 log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
309 | 314 |
310 const struct addrinfo* ainfo = adrlist.head(); | 315 const struct addrinfo* ainfo = adrlist.head(); |
311 EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next); | 316 EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next); |
312 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); | 317 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); |
313 | 318 |
314 const struct sockaddr* sa = ainfo->ai_addr; | 319 const struct sockaddr* sa = ainfo->ai_addr; |
315 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; | 320 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; |
316 EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port); | 321 EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port); |
317 EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr); | 322 EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr); |
318 } | 323 } |
319 | 324 |
320 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) { | 325 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) { |
321 scoped_refptr<WaitingHostResolverProc> resolver_proc = | 326 scoped_refptr<WaitingHostResolverProc> resolver_proc = |
322 new WaitingHostResolverProc(NULL); | 327 new WaitingHostResolverProc(NULL); |
323 | 328 |
324 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 329 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
325 { | 330 { |
326 scoped_refptr<HostResolver> host_resolver( | 331 scoped_refptr<HostResolver> host_resolver( |
327 CreateHostResolverImpl(resolver_proc)); | 332 CreateHostResolverImpl(resolver_proc)); |
328 AddressList adrlist; | 333 AddressList adrlist; |
329 const int kPortnum = 80; | 334 const int kPortnum = 80; |
330 | 335 |
331 HostResolver::RequestInfo info("just.testing", kPortnum); | 336 HostResolver::RequestInfo info("just.testing", kPortnum); |
332 int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, log); | 337 int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, |
| 338 log.bound()); |
333 EXPECT_EQ(ERR_IO_PENDING, err); | 339 EXPECT_EQ(ERR_IO_PENDING, err); |
334 | 340 |
335 // Make sure we will exit the queue even when callback is not called. | 341 // Make sure we will exit the queue even when callback is not called. |
336 MessageLoop::current()->PostDelayedTask(FROM_HERE, | 342 MessageLoop::current()->PostDelayedTask(FROM_HERE, |
337 new MessageLoop::QuitTask(), | 343 new MessageLoop::QuitTask(), |
338 1000); | 344 1000); |
339 MessageLoop::current()->Run(); | 345 MessageLoop::current()->Run(); |
340 } | 346 } |
341 | 347 |
342 resolver_proc->Signal(); | 348 resolver_proc->Signal(); |
343 | 349 |
344 EXPECT_EQ(3u, log->entries().size()); | 350 EXPECT_EQ(3u, log.entries().size()); |
345 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 351 EXPECT_TRUE(LogContainsBeginEvent( |
| 352 log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
346 EXPECT_TRUE(LogContainsEvent( | 353 EXPECT_TRUE(LogContainsEvent( |
347 *log, 1, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | 354 log.entries(), 1, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE)); |
348 EXPECT_TRUE(LogContainsEndEvent(*log, 2, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 355 EXPECT_TRUE(LogContainsEndEvent( |
| 356 log.entries(), 2, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
349 | 357 |
350 EXPECT_FALSE(callback_called_); | 358 EXPECT_FALSE(callback_called_); |
351 } | 359 } |
352 | 360 |
353 TEST_F(HostResolverImplTest, NumericIPv4Address) { | 361 TEST_F(HostResolverImplTest, NumericIPv4Address) { |
354 // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in. | 362 // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in. |
355 | 363 |
356 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = | 364 scoped_refptr<RuleBasedHostResolverProc> resolver_proc = |
357 new RuleBasedHostResolverProc(NULL); | 365 new RuleBasedHostResolverProc(NULL); |
358 resolver_proc->AllowDirectLookup("*"); | 366 resolver_proc->AllowDirectLookup("*"); |
(...skipping 526 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
885 CreateHostResolverImpl(NULL)); | 893 CreateHostResolverImpl(NULL)); |
886 | 894 |
887 CapturingObserver observer; | 895 CapturingObserver observer; |
888 | 896 |
889 host_resolver->AddObserver(&observer); | 897 host_resolver->AddObserver(&observer); |
890 | 898 |
891 AddressList addrlist; | 899 AddressList addrlist; |
892 | 900 |
893 // Resolve "host1". | 901 // Resolve "host1". |
894 HostResolver::RequestInfo info1("host1", 70); | 902 HostResolver::RequestInfo info1("host1", 70); |
895 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 903 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
896 int rv = host_resolver->Resolve(info1, &addrlist, NULL, NULL, log); | 904 int rv = host_resolver->Resolve(info1, &addrlist, NULL, NULL, log.bound()); |
897 EXPECT_EQ(OK, rv); | 905 EXPECT_EQ(OK, rv); |
898 | 906 |
899 EXPECT_EQ(6u, log->entries().size()); | 907 EXPECT_EQ(6u, log.entries().size()); |
900 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | |
901 EXPECT_TRUE(LogContainsBeginEvent( | 908 EXPECT_TRUE(LogContainsBeginEvent( |
902 *log, 1, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART)); | 909 log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
| 910 EXPECT_TRUE(LogContainsBeginEvent( |
| 911 log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART)); |
903 EXPECT_TRUE(LogContainsEndEvent( | 912 EXPECT_TRUE(LogContainsEndEvent( |
904 *log, 2, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART)); | 913 log.entries(), 2, NetLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART)); |
905 EXPECT_TRUE(LogContainsBeginEvent( | 914 EXPECT_TRUE(LogContainsBeginEvent( |
906 *log, 3, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH)); | 915 log.entries(), 3, NetLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH)); |
907 EXPECT_TRUE(LogContainsEndEvent( | 916 EXPECT_TRUE(LogContainsEndEvent( |
908 *log, 4, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH)); | 917 log.entries(), 4, NetLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH)); |
909 EXPECT_TRUE(LogContainsEndEvent( | 918 EXPECT_TRUE(LogContainsEndEvent( |
910 *log, 5, LoadLog::TYPE_HOST_RESOLVER_IMPL)); | 919 log.entries(), 5, NetLog::TYPE_HOST_RESOLVER_IMPL)); |
911 | 920 |
912 EXPECT_EQ(1U, observer.start_log.size()); | 921 EXPECT_EQ(1U, observer.start_log.size()); |
913 EXPECT_EQ(1U, observer.finish_log.size()); | 922 EXPECT_EQ(1U, observer.finish_log.size()); |
914 EXPECT_EQ(0U, observer.cancel_log.size()); | 923 EXPECT_EQ(0U, observer.cancel_log.size()); |
915 EXPECT_TRUE(observer.start_log[0] == | 924 EXPECT_TRUE(observer.start_log[0] == |
916 CapturingObserver::StartOrCancelEntry(0, info1)); | 925 CapturingObserver::StartOrCancelEntry(0, info1)); |
917 EXPECT_TRUE(observer.finish_log[0] == | 926 EXPECT_TRUE(observer.finish_log[0] == |
918 CapturingObserver::FinishEntry(0, true, info1)); | 927 CapturingObserver::FinishEntry(0, true, info1)); |
919 | 928 |
920 // Resolve "host1" again -- this time it will be served from cache, but it | 929 // Resolve "host1" again -- this time it will be served from cache, but it |
(...skipping 557 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1478 // z = value of address family | 1487 // z = value of address family |
1479 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[0].head())); | 1488 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[0].head())); |
1480 EXPECT_EQ("192.1.98.2", NetAddressToString(addrlist[1].head())); | 1489 EXPECT_EQ("192.1.98.2", NetAddressToString(addrlist[1].head())); |
1481 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[2].head())); | 1490 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[2].head())); |
1482 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[3].head())); | 1491 EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[3].head())); |
1483 } | 1492 } |
1484 | 1493 |
1485 } // namespace | 1494 } // namespace |
1486 | 1495 |
1487 } // namespace net | 1496 } // namespace net |
OLD | NEW |