OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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/async_host_resolver.h" | 5 #include "net/dns/async_host_resolver.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/message_loop.h" | |
10 #include "base/stl_util.h" | |
11 #include "net/base/host_cache.h" | 9 #include "net/base/host_cache.h" |
12 #include "net/base/net_errors.h" | |
13 #include "net/base/net_log.h" | 10 #include "net/base/net_log.h" |
| 11 #include "net/base/rand_callback.h" |
14 #include "net/base/sys_addrinfo.h" | 12 #include "net/base/sys_addrinfo.h" |
15 #include "net/base/test_completion_callback.h" | |
16 #include "net/dns/dns_client.h" | |
17 #include "net/dns/dns_query.h" | |
18 #include "net/dns/dns_response.h" | |
19 #include "net/dns/dns_test_util.h" | 13 #include "net/dns/dns_test_util.h" |
| 14 #include "net/socket/socket_test_util.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
21 | 16 |
22 namespace net { | 17 namespace net { |
23 | 18 |
24 namespace { | 19 namespace { |
25 | 20 |
26 const int kPortNum = 80; | |
27 const size_t kMaxTransactions = 2; | |
28 const size_t kMaxPendingRequests = 1; | |
29 | |
30 void VerifyAddressList(const std::vector<const char*>& ip_addresses, | 21 void VerifyAddressList(const std::vector<const char*>& ip_addresses, |
31 int port, | 22 int port, |
32 const AddressList& addrlist) { | 23 const AddressList& addrlist) { |
33 ASSERT_LT(0u, ip_addresses.size()); | 24 ASSERT_LT(0u, ip_addresses.size()); |
34 ASSERT_NE(static_cast<addrinfo*>(NULL), addrlist.head()); | 25 ASSERT_NE(static_cast<addrinfo*>(NULL), addrlist.head()); |
35 | 26 |
36 IPAddressNumber ip_number; | 27 IPAddressNumber ip_number; |
37 const struct addrinfo* ainfo = addrlist.head(); | 28 const struct addrinfo* ainfo = addrlist.head(); |
38 for (std::vector<const char*>::const_iterator i = ip_addresses.begin(); | 29 for (std::vector<const char*>::const_iterator i = ip_addresses.begin(); |
39 i != ip_addresses.end(); ++i, ainfo = ainfo->ai_next) { | 30 i != ip_addresses.end(); ++i, ainfo = ainfo->ai_next) { |
40 ASSERT_NE(static_cast<addrinfo*>(NULL), ainfo); | 31 ASSERT_NE(static_cast<addrinfo*>(NULL), ainfo); |
41 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); | 32 EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen); |
42 | 33 |
43 const struct sockaddr* sa = ainfo->ai_addr; | 34 const struct sockaddr* sa = ainfo->ai_addr; |
44 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; | 35 const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa; |
45 EXPECT_TRUE(htons(port) == sa_in->sin_port); | 36 EXPECT_TRUE(htons(port) == sa_in->sin_port); |
46 EXPECT_STREQ(*i, NetAddressToString(sa, ainfo->ai_addrlen).c_str()); | 37 EXPECT_STREQ(*i, NetAddressToString(sa, ainfo->ai_addrlen).c_str()); |
47 } | 38 } |
48 ASSERT_EQ(static_cast<addrinfo*>(NULL), ainfo); | 39 ASSERT_EQ(static_cast<addrinfo*>(NULL), ainfo); |
49 } | 40 } |
50 | 41 |
51 class MockDnsClient : public DnsClient, | |
52 public base::SupportsWeakPtr<MockDnsClient> { | |
53 public: | |
54 // Using WeakPtr to support cancellation. | |
55 // All MockRequests succeed unless canceled or MockDnsClient is destroyed. | |
56 class MockRequest : public DnsClient::Request, | |
57 public base::SupportsWeakPtr<MockRequest> { | |
58 public: | |
59 MockRequest(const base::StringPiece& qname, | |
60 uint16 qtype, | |
61 const RequestCallback& callback, | |
62 const base::WeakPtr<MockDnsClient>& client) | |
63 : Request(qname, qtype, callback), started_(false), client_(client) { | |
64 } | |
65 | |
66 virtual int Start() OVERRIDE { | |
67 EXPECT_FALSE(started_); | |
68 started_ = true; | |
69 MessageLoop::current()->PostTask( | |
70 FROM_HERE, | |
71 base::Bind(&MockRequest::Finish, AsWeakPtr())); | |
72 return ERR_IO_PENDING; | |
73 } | |
74 | |
75 private: | |
76 void Finish() { | |
77 if (!client_) { | |
78 DoCallback(ERR_DNS_SERVER_FAILED, NULL); | |
79 return; | |
80 } | |
81 DoCallback(OK, client_->responses[Key(qname(), qtype())]); | |
82 } | |
83 | |
84 bool started_; | |
85 base::WeakPtr<MockDnsClient> client_; | |
86 }; | |
87 | |
88 typedef std::pair<std::string, uint16> Key; | |
89 | |
90 MockDnsClient() : num_requests(0) {} | |
91 ~MockDnsClient() { | |
92 STLDeleteValues(&responses); | |
93 } | |
94 | |
95 Request* CreateRequest(const base::StringPiece& qname, | |
96 uint16 qtype, | |
97 const RequestCallback& callback, | |
98 const BoundNetLog&) { | |
99 ++num_requests; | |
100 return new MockRequest(qname, qtype, callback, AsWeakPtr()); | |
101 } | |
102 | |
103 int num_requests; | |
104 std::map<Key, DnsResponse*> responses; | |
105 }; | |
106 | |
107 } // namespace | 42 } // namespace |
108 | 43 |
| 44 static const int kPortNum = 80; |
| 45 static const size_t kMaxTransactions = 2; |
| 46 static const size_t kMaxPendingRequests = 1; |
| 47 static int transaction_ids[] = {0, 1, 2, 3}; |
109 | 48 |
110 // The following fixture sets up an environment for four different lookups | 49 // The following fixture sets up an environment for four different lookups |
111 // with their data defined in dns_test_util.h. All tests make use of these | 50 // with their data defined in dns_test_util.h. All tests make use of these |
112 // predefined variables instead of each defining their own, to avoid | 51 // predefined variables instead of each defining their own, to avoid |
113 // boilerplate code in every test. Assuming every coming query is for a | 52 // boilerplate code in every test. Assuming every coming query is for a |
114 // distinct hostname, as |kMaxTransactions| is set to 2 and | 53 // distinct hostname, as |kMaxTransactions| is set to 2 and |
115 // |kMaxPendingRequests| is set to 1, first two queries start immediately | 54 // |kMaxPendingRequests| is set to 1, first two queries start immediately |
116 // and the next one is sent to pending queue; as a result, the next query | 55 // and the next one is sent to pending queue; as a result, the next query |
117 // should either fail itself or cause the pending query to fail depending | 56 // should either fail itself or cause the pending query to fail depending |
118 // on its priority. | 57 // on its priority. |
119 class AsyncHostResolverTest : public testing::Test { | 58 class AsyncHostResolverTest : public testing::Test { |
120 public: | 59 public: |
121 AsyncHostResolverTest() | 60 AsyncHostResolverTest() |
122 : info0_(HostPortPair(kT0HostName, kPortNum)), | 61 : info0_(HostPortPair(kT0HostName, kPortNum)), |
123 info1_(HostPortPair(kT1HostName, kPortNum)), | 62 info1_(HostPortPair(kT1HostName, kPortNum)), |
124 info2_(HostPortPair(kT2HostName, kPortNum)), | 63 info2_(HostPortPair(kT2HostName, kPortNum)), |
125 info3_(HostPortPair(kT3HostName, kPortNum)), | 64 info3_(HostPortPair(kT3HostName, kPortNum)), |
126 ip_addresses0_(kT0IpAddresses, | 65 ip_addresses0_(kT0IpAddresses, |
127 kT0IpAddresses + arraysize(kT0IpAddresses)), | 66 kT0IpAddresses + arraysize(kT0IpAddresses)), |
128 ip_addresses1_(kT1IpAddresses, | 67 ip_addresses1_(kT1IpAddresses, |
129 kT1IpAddresses + arraysize(kT1IpAddresses)), | 68 kT1IpAddresses + arraysize(kT1IpAddresses)), |
130 ip_addresses2_(kT2IpAddresses, | 69 ip_addresses2_(kT2IpAddresses, |
131 kT2IpAddresses + arraysize(kT2IpAddresses)), | 70 kT2IpAddresses + arraysize(kT2IpAddresses)), |
132 ip_addresses3_(kT3IpAddresses, | 71 ip_addresses3_(kT3IpAddresses, |
133 kT3IpAddresses + arraysize(kT3IpAddresses)) { | 72 kT3IpAddresses + arraysize(kT3IpAddresses)), |
| 73 test_prng_(std::deque<int>( |
| 74 transaction_ids, transaction_ids + arraysize(transaction_ids))) { |
| 75 rand_int_cb_ = base::Bind(&TestPrng::GetNext, |
| 76 base::Unretained(&test_prng_)); |
134 // AF_INET only for now. | 77 // AF_INET only for now. |
135 info0_.set_address_family(ADDRESS_FAMILY_IPV4); | 78 info0_.set_address_family(ADDRESS_FAMILY_IPV4); |
136 info1_.set_address_family(ADDRESS_FAMILY_IPV4); | 79 info1_.set_address_family(ADDRESS_FAMILY_IPV4); |
137 info2_.set_address_family(ADDRESS_FAMILY_IPV4); | 80 info2_.set_address_family(ADDRESS_FAMILY_IPV4); |
138 info3_.set_address_family(ADDRESS_FAMILY_IPV4); | 81 info3_.set_address_family(ADDRESS_FAMILY_IPV4); |
139 | 82 |
140 client_.reset(new MockDnsClient()); | 83 // Setup socket read/writes for transaction 0. |
| 84 writes0_.push_back( |
| 85 MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram), |
| 86 arraysize(kT0QueryDatagram))); |
| 87 reads0_.push_back( |
| 88 MockRead(true, reinterpret_cast<const char*>(kT0ResponseDatagram), |
| 89 arraysize(kT0ResponseDatagram))); |
| 90 data0_.reset(new StaticSocketDataProvider(&reads0_[0], reads0_.size(), |
| 91 &writes0_[0], writes0_.size())); |
141 | 92 |
142 AddResponse(std::string(kT0DnsName, arraysize(kT0DnsName)), kT0Qtype, | 93 // Setup socket read/writes for transaction 1. |
143 new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram), | 94 writes1_.push_back( |
144 arraysize(kT0ResponseDatagram), | 95 MockWrite(true, reinterpret_cast<const char*>(kT1QueryDatagram), |
145 arraysize(kT0QueryDatagram))); | 96 arraysize(kT1QueryDatagram))); |
| 97 reads1_.push_back( |
| 98 MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram), |
| 99 arraysize(kT1ResponseDatagram))); |
| 100 data1_.reset(new StaticSocketDataProvider(&reads1_[0], reads1_.size(), |
| 101 &writes1_[0], writes1_.size())); |
146 | 102 |
147 AddResponse(std::string(kT1DnsName, arraysize(kT1DnsName)), kT1Qtype, | 103 // Setup socket read/writes for transaction 2. |
148 new DnsResponse(reinterpret_cast<const char*>(kT1ResponseDatagram), | 104 writes2_.push_back( |
149 arraysize(kT1ResponseDatagram), | 105 MockWrite(true, reinterpret_cast<const char*>(kT2QueryDatagram), |
150 arraysize(kT1QueryDatagram))); | 106 arraysize(kT2QueryDatagram))); |
| 107 reads2_.push_back( |
| 108 MockRead(true, reinterpret_cast<const char*>(kT2ResponseDatagram), |
| 109 arraysize(kT2ResponseDatagram))); |
| 110 data2_.reset(new StaticSocketDataProvider(&reads2_[0], reads2_.size(), |
| 111 &writes2_[0], writes2_.size())); |
151 | 112 |
152 AddResponse(std::string(kT2DnsName, arraysize(kT2DnsName)), kT2Qtype, | 113 // Setup socket read/writes for transaction 3. |
153 new DnsResponse(reinterpret_cast<const char*>(kT2ResponseDatagram), | 114 writes3_.push_back( |
154 arraysize(kT2ResponseDatagram), | 115 MockWrite(true, reinterpret_cast<const char*>(kT3QueryDatagram), |
155 arraysize(kT2QueryDatagram))); | 116 arraysize(kT3QueryDatagram))); |
| 117 reads3_.push_back( |
| 118 MockRead(true, reinterpret_cast<const char*>(kT3ResponseDatagram), |
| 119 arraysize(kT3ResponseDatagram))); |
| 120 data3_.reset(new StaticSocketDataProvider(&reads3_[0], reads3_.size(), |
| 121 &writes3_[0], writes3_.size())); |
156 | 122 |
157 AddResponse(std::string(kT3DnsName, arraysize(kT3DnsName)), kT3Qtype, | 123 factory_.AddSocketDataProvider(data0_.get()); |
158 new DnsResponse(reinterpret_cast<const char*>(kT3ResponseDatagram), | 124 factory_.AddSocketDataProvider(data1_.get()); |
159 arraysize(kT3ResponseDatagram), | 125 factory_.AddSocketDataProvider(data2_.get()); |
160 arraysize(kT3QueryDatagram))); | 126 factory_.AddSocketDataProvider(data3_.get()); |
| 127 |
| 128 IPEndPoint dns_server; |
| 129 bool rv0 = CreateDnsAddress(kDnsIp, kDnsPort, &dns_server); |
| 130 DCHECK(rv0); |
161 | 131 |
162 resolver_.reset( | 132 resolver_.reset( |
163 new AsyncHostResolver(kMaxTransactions, kMaxPendingRequests, | 133 new AsyncHostResolver( |
164 HostCache::CreateDefaultCache(), | 134 dns_server, kMaxTransactions, kMaxPendingRequests, rand_int_cb_, |
165 client_.get(), NULL)); | 135 HostCache::CreateDefaultCache(), &factory_, NULL)); |
166 } | |
167 | |
168 void AddResponse(const std::string& name, uint8 type, DnsResponse* response) { | |
169 client_->responses[MockDnsClient::Key(name, type)] = response; | |
170 } | 136 } |
171 | 137 |
172 protected: | 138 protected: |
173 AddressList addrlist0_, addrlist1_, addrlist2_, addrlist3_; | 139 AddressList addrlist0_, addrlist1_, addrlist2_, addrlist3_; |
174 HostResolver::RequestInfo info0_, info1_, info2_, info3_; | 140 HostResolver::RequestInfo info0_, info1_, info2_, info3_; |
| 141 std::vector<MockWrite> writes0_, writes1_, writes2_, writes3_; |
| 142 std::vector<MockRead> reads0_, reads1_, reads2_, reads3_; |
| 143 scoped_ptr<StaticSocketDataProvider> data0_, data1_, data2_, data3_; |
175 std::vector<const char*> ip_addresses0_, ip_addresses1_, | 144 std::vector<const char*> ip_addresses0_, ip_addresses1_, |
176 ip_addresses2_, ip_addresses3_; | 145 ip_addresses2_, ip_addresses3_; |
| 146 MockClientSocketFactory factory_; |
| 147 TestPrng test_prng_; |
| 148 RandIntCallback rand_int_cb_; |
177 scoped_ptr<HostResolver> resolver_; | 149 scoped_ptr<HostResolver> resolver_; |
178 scoped_ptr<MockDnsClient> client_; | |
179 TestCompletionCallback callback0_, callback1_, callback2_, callback3_; | 150 TestCompletionCallback callback0_, callback1_, callback2_, callback3_; |
180 }; | 151 }; |
181 | 152 |
182 TEST_F(AsyncHostResolverTest, EmptyHostLookup) { | 153 TEST_F(AsyncHostResolverTest, EmptyHostLookup) { |
183 info0_.set_host_port_pair(HostPortPair("", kPortNum)); | 154 info0_.set_host_port_pair(HostPortPair("", kPortNum)); |
184 int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, | 155 int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, |
185 BoundNetLog()); | 156 BoundNetLog()); |
186 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); | 157 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); |
187 } | 158 } |
188 | 159 |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
264 VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_); | 235 VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_); |
265 | 236 |
266 rv1 = callback1_.WaitForResult(); | 237 rv1 = callback1_.WaitForResult(); |
267 EXPECT_EQ(OK, rv1); | 238 EXPECT_EQ(OK, rv1); |
268 VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_); | 239 VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_); |
269 | 240 |
270 rv2 = callback2_.WaitForResult(); | 241 rv2 = callback2_.WaitForResult(); |
271 EXPECT_EQ(OK, rv2); | 242 EXPECT_EQ(OK, rv2); |
272 VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_); | 243 VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_); |
273 | 244 |
274 EXPECT_EQ(3, client_->num_requests); | 245 EXPECT_EQ(3u, factory_.udp_client_sockets().size()); |
275 } | 246 } |
276 | 247 |
277 TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) { | 248 TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) { |
278 // We pass the info0_ to all requests. | 249 // We pass the info0_ to all requests. |
279 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, | 250 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, |
280 BoundNetLog()); | 251 BoundNetLog()); |
281 int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL, | 252 int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL, |
282 BoundNetLog()); | 253 BoundNetLog()); |
283 int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL, | 254 int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL, |
284 BoundNetLog()); | 255 BoundNetLog()); |
285 EXPECT_EQ(ERR_IO_PENDING, rv0); | 256 EXPECT_EQ(ERR_IO_PENDING, rv0); |
286 EXPECT_EQ(ERR_IO_PENDING, rv1); | 257 EXPECT_EQ(ERR_IO_PENDING, rv1); |
287 EXPECT_EQ(ERR_IO_PENDING, rv2); | 258 EXPECT_EQ(ERR_IO_PENDING, rv2); |
288 | 259 |
289 rv0 = callback0_.WaitForResult(); | 260 rv0 = callback0_.WaitForResult(); |
290 EXPECT_EQ(OK, rv0); | 261 EXPECT_EQ(OK, rv0); |
291 VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_); | 262 VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_); |
292 | 263 |
293 rv1 = callback1_.WaitForResult(); | 264 rv1 = callback1_.WaitForResult(); |
294 EXPECT_EQ(OK, rv1); | 265 EXPECT_EQ(OK, rv1); |
295 VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_); | 266 VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_); |
296 | 267 |
297 rv2 = callback2_.WaitForResult(); | 268 rv2 = callback2_.WaitForResult(); |
298 EXPECT_EQ(OK, rv2); | 269 EXPECT_EQ(OK, rv2); |
299 VerifyAddressList(ip_addresses0_, kPortNum, addrlist2_); | 270 VerifyAddressList(ip_addresses0_, kPortNum, addrlist2_); |
300 | 271 |
301 // Although we have three lookups, a single UDP socket was used. | 272 // Although we have three lookups, a single UDP socket was used. |
302 EXPECT_EQ(1, client_->num_requests); | 273 EXPECT_EQ(1u, factory_.udp_client_sockets().size()); |
303 } | 274 } |
304 | 275 |
305 TEST_F(AsyncHostResolverTest, CancelLookup) { | 276 TEST_F(AsyncHostResolverTest, CancelLookup) { |
306 HostResolver::RequestHandle req0 = NULL, req2 = NULL; | 277 HostResolver::RequestHandle req0 = NULL, req2 = NULL; |
307 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), | 278 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), |
308 &req0, BoundNetLog()); | 279 &req0, BoundNetLog()); |
309 int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, | 280 int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, |
310 BoundNetLog()); | 281 BoundNetLog()); |
311 int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), | 282 int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), |
312 &req2, BoundNetLog()); | 283 &req2, BoundNetLog()); |
(...skipping 28 matching lines...) Expand all Loading... |
341 EXPECT_EQ(ERR_IO_PENDING, rv1); | 312 EXPECT_EQ(ERR_IO_PENDING, rv1); |
342 | 313 |
343 resolver_->CancelRequest(req0); | 314 resolver_->CancelRequest(req0); |
344 MessageLoop::current()->RunAllPending(); | 315 MessageLoop::current()->RunAllPending(); |
345 EXPECT_FALSE(callback0_.have_result()); | 316 EXPECT_FALSE(callback0_.have_result()); |
346 | 317 |
347 rv1 = callback1_.WaitForResult(); | 318 rv1 = callback1_.WaitForResult(); |
348 EXPECT_EQ(OK, rv1); | 319 EXPECT_EQ(OK, rv1); |
349 VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_); | 320 VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_); |
350 | 321 |
351 EXPECT_EQ(1, client_->num_requests); | 322 EXPECT_EQ(1u, factory_.udp_client_sockets().size()); |
352 } | 323 } |
353 | 324 |
354 // Test that a queued lookup completes. | 325 // Test that a queued lookup completes. |
355 TEST_F(AsyncHostResolverTest, QueuedLookup) { | 326 TEST_F(AsyncHostResolverTest, QueuedLookup) { |
356 // kMaxTransactions is 2, thus the following requests consume all | 327 // kMaxTransactions is 2, thus the following requests consume all |
357 // available transactions. | 328 // available transactions. |
358 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, | 329 int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL, |
359 BoundNetLog()); | 330 BoundNetLog()); |
360 int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, | 331 int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL, |
361 BoundNetLog()); | 332 BoundNetLog()); |
(...skipping 148 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
510 rv_fail = callback_fail.WaitForResult(); | 481 rv_fail = callback_fail.WaitForResult(); |
511 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv_fail); | 482 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv_fail); |
512 EXPECT_EQ(static_cast<addrinfo*>(NULL), addrlist_fail.head()); | 483 EXPECT_EQ(static_cast<addrinfo*>(NULL), addrlist_fail.head()); |
513 | 484 |
514 rv2 = callback2_.WaitForResult(); | 485 rv2 = callback2_.WaitForResult(); |
515 EXPECT_EQ(OK, rv2); | 486 EXPECT_EQ(OK, rv2); |
516 VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_); | 487 VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_); |
517 } | 488 } |
518 | 489 |
519 } // namespace net | 490 } // namespace net |
OLD | NEW |