OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 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/dns/host_resolver_mojo.h" | 5 #include "net/dns/host_resolver_mojo.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 void SetUp() override { | 160 void SetUp() override { |
161 mock_resolver_.reset(new MockMojoHostResolver( | 161 mock_resolver_.reset(new MockMojoHostResolver( |
162 base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_), | 162 base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_), |
163 ConnectionErrorSource::REQUEST))); | 163 ConnectionErrorSource::REQUEST))); |
164 resolver_.reset(new HostResolverMojo(mock_resolver_.get())); | 164 resolver_.reset(new HostResolverMojo(mock_resolver_.get())); |
165 } | 165 } |
166 | 166 |
167 int Resolve(const HostResolver::RequestInfo& request_info, | 167 int Resolve(const HostResolver::RequestInfo& request_info, |
168 AddressList* result) { | 168 AddressList* result) { |
169 TestCompletionCallback callback; | 169 TestCompletionCallback callback; |
170 return callback.GetResult(resolver_->Resolve(request_info, DEFAULT_PRIORITY, | 170 return callback.GetResult( |
171 result, callback.callback(), | 171 resolver_->Resolve(request_info, DEFAULT_PRIORITY, result, |
172 &request_, BoundNetLog())); | 172 callback.callback(), &request_, NetLogWithSource())); |
173 } | 173 } |
174 | 174 |
175 std::unique_ptr<MockMojoHostResolver> mock_resolver_; | 175 std::unique_ptr<MockMojoHostResolver> mock_resolver_; |
176 | 176 |
177 std::unique_ptr<HostResolverMojo> resolver_; | 177 std::unique_ptr<HostResolverMojo> resolver_; |
178 | 178 |
179 std::unique_ptr<HostResolver::Request> request_; | 179 std::unique_ptr<HostResolver::Request> request_; |
180 | 180 |
181 Waiter waiter_; | 181 Waiter waiter_; |
182 }; | 182 }; |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
252 request_info1.set_is_my_ip_address(true); | 252 request_info1.set_is_my_ip_address(true); |
253 HostResolver::RequestInfo request_info2( | 253 HostResolver::RequestInfo request_info2( |
254 HostPortPair::FromString("example.org:80")); | 254 HostPortPair::FromString("example.org:80")); |
255 request_info2.set_address_family(ADDRESS_FAMILY_IPV6); | 255 request_info2.set_address_family(ADDRESS_FAMILY_IPV6); |
256 AddressList result1; | 256 AddressList result1; |
257 AddressList result2; | 257 AddressList result2; |
258 std::unique_ptr<HostResolver::Request> request1; | 258 std::unique_ptr<HostResolver::Request> request1; |
259 std::unique_ptr<HostResolver::Request> request2; | 259 std::unique_ptr<HostResolver::Request> request2; |
260 TestCompletionCallback callback1; | 260 TestCompletionCallback callback1; |
261 TestCompletionCallback callback2; | 261 TestCompletionCallback callback2; |
262 ASSERT_EQ(ERR_IO_PENDING, | 262 ASSERT_EQ(ERR_IO_PENDING, resolver_->Resolve(request_info1, DEFAULT_PRIORITY, |
263 resolver_->Resolve(request_info1, DEFAULT_PRIORITY, &result1, | 263 &result1, callback1.callback(), |
264 callback1.callback(), &request1, BoundNetLog())); | 264 &request1, NetLogWithSource())); |
265 ASSERT_EQ(ERR_IO_PENDING, | 265 ASSERT_EQ(ERR_IO_PENDING, resolver_->Resolve(request_info2, DEFAULT_PRIORITY, |
266 resolver_->Resolve(request_info2, DEFAULT_PRIORITY, &result2, | 266 &result2, callback2.callback(), |
267 callback2.callback(), &request2, BoundNetLog())); | 267 &request2, NetLogWithSource())); |
268 EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk()); | 268 EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk()); |
269 EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING), | 269 EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING), |
270 IsError(ERR_NAME_NOT_RESOLVED)); | 270 IsError(ERR_NAME_NOT_RESOLVED)); |
271 ASSERT_EQ(1u, result1.size()); | 271 ASSERT_EQ(1u, result1.size()); |
272 EXPECT_EQ(address_list[0], result1[0]); | 272 EXPECT_EQ(address_list[0], result1[0]); |
273 ASSERT_EQ(0u, result2.size()); | 273 ASSERT_EQ(0u, result2.size()); |
274 | 274 |
275 ASSERT_EQ(2u, mock_resolver_->requests().size()); | 275 ASSERT_EQ(2u, mock_resolver_->requests().size()); |
276 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; | 276 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; |
277 EXPECT_EQ("example.com", info1.host.To<std::string>()); | 277 EXPECT_EQ("example.com", info1.host.To<std::string>()); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
315 } | 315 } |
316 | 316 |
317 TEST_F(HostResolverMojoTest, Cancel) { | 317 TEST_F(HostResolverMojoTest, Cancel) { |
318 mock_resolver_->AddAction(HostResolverAction::RetainRequest()); | 318 mock_resolver_->AddAction(HostResolverAction::RetainRequest()); |
319 HostResolver::RequestInfo request_info( | 319 HostResolver::RequestInfo request_info( |
320 HostPortPair::FromString("example.com:80")); | 320 HostPortPair::FromString("example.com:80")); |
321 request_info.set_address_family(ADDRESS_FAMILY_IPV6); | 321 request_info.set_address_family(ADDRESS_FAMILY_IPV6); |
322 AddressList result; | 322 AddressList result; |
323 std::unique_ptr<HostResolver::Request> request; | 323 std::unique_ptr<HostResolver::Request> request; |
324 resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail), | 324 resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail), |
325 &request, BoundNetLog()); | 325 &request, NetLogWithSource()); |
326 request.reset(); | 326 request.reset(); |
327 waiter_.WaitForEvent(ConnectionErrorSource::REQUEST); | 327 waiter_.WaitForEvent(ConnectionErrorSource::REQUEST); |
328 EXPECT_TRUE(result.empty()); | 328 EXPECT_TRUE(result.empty()); |
329 | 329 |
330 ASSERT_EQ(1u, mock_resolver_->requests().size()); | 330 ASSERT_EQ(1u, mock_resolver_->requests().size()); |
331 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; | 331 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; |
332 EXPECT_EQ("example.com", info1.host.To<std::string>()); | 332 EXPECT_EQ("example.com", info1.host.To<std::string>()); |
333 EXPECT_EQ(80, info1.port); | 333 EXPECT_EQ(80, info1.port); |
334 EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family); | 334 EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family); |
335 EXPECT_FALSE(info1.is_my_ip_address); | 335 EXPECT_FALSE(info1.is_my_ip_address); |
(...skipping 12 matching lines...) Expand all Loading... |
348 EXPECT_EQ("example.com", info2.host.To<std::string>()); | 348 EXPECT_EQ("example.com", info2.host.To<std::string>()); |
349 EXPECT_EQ(1, info2.port); | 349 EXPECT_EQ(1, info2.port); |
350 EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family); | 350 EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family); |
351 EXPECT_FALSE(info2.is_my_ip_address); | 351 EXPECT_FALSE(info2.is_my_ip_address); |
352 } | 352 } |
353 | 353 |
354 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) { | 354 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) { |
355 HostResolver::RequestInfo request_info( | 355 HostResolver::RequestInfo request_info( |
356 HostPortPair::FromString("example.com:8080")); | 356 HostPortPair::FromString("example.com:8080")); |
357 AddressList result; | 357 AddressList result; |
358 EXPECT_EQ(ERR_DNS_CACHE_MISS, | 358 EXPECT_EQ(ERR_DNS_CACHE_MISS, resolver_->ResolveFromCache( |
359 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); | 359 request_info, &result, NetLogWithSource())); |
360 EXPECT_TRUE(result.empty()); | 360 EXPECT_TRUE(result.empty()); |
361 } | 361 } |
362 | 362 |
363 TEST_F(HostResolverMojoTest, ResolveFromCache_Hit) { | 363 TEST_F(HostResolverMojoTest, ResolveFromCache_Hit) { |
364 AddressList address_list; | 364 AddressList address_list; |
365 IPAddress address(1, 2, 3, 4); | 365 IPAddress address(1, 2, 3, 4); |
366 address_list.push_back(IPEndPoint(address, 12345)); | 366 address_list.push_back(IPEndPoint(address, 12345)); |
367 address_list.push_back( | 367 address_list.push_back( |
368 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); | 368 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); |
369 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); | 369 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); |
370 HostResolver::RequestInfo request_info( | 370 HostResolver::RequestInfo request_info( |
371 HostPortPair::FromString("example.com:12345")); | 371 HostPortPair::FromString("example.com:12345")); |
372 AddressList result; | 372 AddressList result; |
373 ASSERT_THAT(Resolve(request_info, &result), IsOk()); | 373 ASSERT_THAT(Resolve(request_info, &result), IsOk()); |
374 EXPECT_EQ(1u, mock_resolver_->requests().size()); | 374 EXPECT_EQ(1u, mock_resolver_->requests().size()); |
375 | 375 |
376 result.clear(); | 376 result.clear(); |
377 EXPECT_EQ(OK, | 377 EXPECT_EQ(OK, resolver_->ResolveFromCache(request_info, &result, |
378 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); | 378 NetLogWithSource())); |
379 ASSERT_EQ(2u, result.size()); | 379 ASSERT_EQ(2u, result.size()); |
380 EXPECT_EQ(address_list[0], result[0]); | 380 EXPECT_EQ(address_list[0], result[0]); |
381 EXPECT_EQ(address_list[1], result[1]); | 381 EXPECT_EQ(address_list[1], result[1]); |
382 EXPECT_EQ(1u, mock_resolver_->requests().size()); | 382 EXPECT_EQ(1u, mock_resolver_->requests().size()); |
383 } | 383 } |
384 | 384 |
385 TEST_F(HostResolverMojoTest, ResolveFromCache_CacheNotAllowed) { | 385 TEST_F(HostResolverMojoTest, ResolveFromCache_CacheNotAllowed) { |
386 AddressList address_list; | 386 AddressList address_list; |
387 IPAddress address(1, 2, 3, 4); | 387 IPAddress address(1, 2, 3, 4); |
388 address_list.push_back(IPEndPoint(address, 12345)); | 388 address_list.push_back(IPEndPoint(address, 12345)); |
389 address_list.push_back( | 389 address_list.push_back( |
390 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); | 390 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); |
391 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); | 391 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); |
392 HostResolver::RequestInfo request_info( | 392 HostResolver::RequestInfo request_info( |
393 HostPortPair::FromString("example.com:12345")); | 393 HostPortPair::FromString("example.com:12345")); |
394 AddressList result; | 394 AddressList result; |
395 ASSERT_THAT(Resolve(request_info, &result), IsOk()); | 395 ASSERT_THAT(Resolve(request_info, &result), IsOk()); |
396 EXPECT_EQ(1u, mock_resolver_->requests().size()); | 396 EXPECT_EQ(1u, mock_resolver_->requests().size()); |
397 | 397 |
398 result.clear(); | 398 result.clear(); |
399 request_info.set_allow_cached_response(false); | 399 request_info.set_allow_cached_response(false); |
400 EXPECT_EQ(ERR_DNS_CACHE_MISS, | 400 EXPECT_EQ(ERR_DNS_CACHE_MISS, resolver_->ResolveFromCache( |
401 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); | 401 request_info, &result, NetLogWithSource())); |
402 EXPECT_TRUE(result.empty()); | 402 EXPECT_TRUE(result.empty()); |
403 } | 403 } |
404 | 404 |
405 TEST_F(HostResolverMojoTest, GetHostCache) { | 405 TEST_F(HostResolverMojoTest, GetHostCache) { |
406 EXPECT_TRUE(resolver_->GetHostCache()); | 406 EXPECT_TRUE(resolver_->GetHostCache()); |
407 } | 407 } |
408 | 408 |
409 } // namespace net | 409 } // namespace net |
OLD | NEW |