OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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/cert/multi_threaded_cert_verifier.h" | 5 #include "net/cert/multi_threaded_cert_verifier.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/files/file_path.h" | 8 #include "base/files/file_path.h" |
9 #include "base/format_macros.h" | 9 #include "base/format_macros.h" |
10 #include "base/stringprintf.h" | 10 #include "base/stringprintf.h" |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
79 base::FilePath certs_dir = GetTestCertsDirectory(); | 79 base::FilePath certs_dir = GetTestCertsDirectory(); |
80 scoped_refptr<X509Certificate> test_cert( | 80 scoped_refptr<X509Certificate> test_cert( |
81 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 81 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
82 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); | 82 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); |
83 | 83 |
84 int error; | 84 int error; |
85 CertVerifyResult verify_result; | 85 CertVerifyResult verify_result; |
86 TestCompletionCallback callback; | 86 TestCompletionCallback callback; |
87 CertVerifier::RequestHandle request_handle; | 87 CertVerifier::RequestHandle request_handle; |
88 | 88 |
89 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 89 error = verifier_.Verify(test_cert.get(), |
90 &verify_result, callback.callback(), | 90 "www.example.com", |
91 &request_handle, BoundNetLog()); | 91 0, |
| 92 NULL, |
| 93 &verify_result, |
| 94 callback.callback(), |
| 95 &request_handle, |
| 96 BoundNetLog()); |
92 ASSERT_EQ(ERR_IO_PENDING, error); | 97 ASSERT_EQ(ERR_IO_PENDING, error); |
93 ASSERT_TRUE(request_handle != NULL); | 98 ASSERT_TRUE(request_handle != NULL); |
94 error = callback.WaitForResult(); | 99 error = callback.WaitForResult(); |
95 ASSERT_TRUE(IsCertificateError(error)); | 100 ASSERT_TRUE(IsCertificateError(error)); |
96 ASSERT_EQ(1u, verifier_.requests()); | 101 ASSERT_EQ(1u, verifier_.requests()); |
97 ASSERT_EQ(0u, verifier_.cache_hits()); | 102 ASSERT_EQ(0u, verifier_.cache_hits()); |
98 ASSERT_EQ(0u, verifier_.inflight_joins()); | 103 ASSERT_EQ(0u, verifier_.inflight_joins()); |
99 ASSERT_EQ(1u, verifier_.GetCacheSize()); | 104 ASSERT_EQ(1u, verifier_.GetCacheSize()); |
100 | 105 |
101 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 106 error = verifier_.Verify(test_cert.get(), |
102 &verify_result, callback.callback(), | 107 "www.example.com", |
103 &request_handle, BoundNetLog()); | 108 0, |
| 109 NULL, |
| 110 &verify_result, |
| 111 callback.callback(), |
| 112 &request_handle, |
| 113 BoundNetLog()); |
104 // Synchronous completion. | 114 // Synchronous completion. |
105 ASSERT_NE(ERR_IO_PENDING, error); | 115 ASSERT_NE(ERR_IO_PENDING, error); |
106 ASSERT_TRUE(IsCertificateError(error)); | 116 ASSERT_TRUE(IsCertificateError(error)); |
107 ASSERT_TRUE(request_handle == NULL); | 117 ASSERT_TRUE(request_handle == NULL); |
108 ASSERT_EQ(2u, verifier_.requests()); | 118 ASSERT_EQ(2u, verifier_.requests()); |
109 ASSERT_EQ(1u, verifier_.cache_hits()); | 119 ASSERT_EQ(1u, verifier_.cache_hits()); |
110 ASSERT_EQ(0u, verifier_.inflight_joins()); | 120 ASSERT_EQ(0u, verifier_.inflight_joins()); |
111 ASSERT_EQ(1u, verifier_.GetCacheSize()); | 121 ASSERT_EQ(1u, verifier_.GetCacheSize()); |
112 } | 122 } |
113 | 123 |
(...skipping 25 matching lines...) Expand all Loading... |
139 intermediates.push_back(intermediate_cert2->os_cert_handle()); | 149 intermediates.push_back(intermediate_cert2->os_cert_handle()); |
140 scoped_refptr<X509Certificate> cert_chain2 = | 150 scoped_refptr<X509Certificate> cert_chain2 = |
141 X509Certificate::CreateFromHandle(server_cert->os_cert_handle(), | 151 X509Certificate::CreateFromHandle(server_cert->os_cert_handle(), |
142 intermediates); | 152 intermediates); |
143 | 153 |
144 int error; | 154 int error; |
145 CertVerifyResult verify_result; | 155 CertVerifyResult verify_result; |
146 TestCompletionCallback callback; | 156 TestCompletionCallback callback; |
147 CertVerifier::RequestHandle request_handle; | 157 CertVerifier::RequestHandle request_handle; |
148 | 158 |
149 error = verifier_.Verify(cert_chain1, "www.example.com", 0, NULL, | 159 error = verifier_.Verify(cert_chain1.get(), |
150 &verify_result, callback.callback(), | 160 "www.example.com", |
151 &request_handle, BoundNetLog()); | 161 0, |
| 162 NULL, |
| 163 &verify_result, |
| 164 callback.callback(), |
| 165 &request_handle, |
| 166 BoundNetLog()); |
152 ASSERT_EQ(ERR_IO_PENDING, error); | 167 ASSERT_EQ(ERR_IO_PENDING, error); |
153 ASSERT_TRUE(request_handle != NULL); | 168 ASSERT_TRUE(request_handle != NULL); |
154 error = callback.WaitForResult(); | 169 error = callback.WaitForResult(); |
155 ASSERT_TRUE(IsCertificateError(error)); | 170 ASSERT_TRUE(IsCertificateError(error)); |
156 ASSERT_EQ(1u, verifier_.requests()); | 171 ASSERT_EQ(1u, verifier_.requests()); |
157 ASSERT_EQ(0u, verifier_.cache_hits()); | 172 ASSERT_EQ(0u, verifier_.cache_hits()); |
158 ASSERT_EQ(0u, verifier_.inflight_joins()); | 173 ASSERT_EQ(0u, verifier_.inflight_joins()); |
159 ASSERT_EQ(1u, verifier_.GetCacheSize()); | 174 ASSERT_EQ(1u, verifier_.GetCacheSize()); |
160 | 175 |
161 error = verifier_.Verify(cert_chain2, "www.example.com", 0, NULL, | 176 error = verifier_.Verify(cert_chain2.get(), |
162 &verify_result, callback.callback(), | 177 "www.example.com", |
163 &request_handle, BoundNetLog()); | 178 0, |
| 179 NULL, |
| 180 &verify_result, |
| 181 callback.callback(), |
| 182 &request_handle, |
| 183 BoundNetLog()); |
164 ASSERT_EQ(ERR_IO_PENDING, error); | 184 ASSERT_EQ(ERR_IO_PENDING, error); |
165 ASSERT_TRUE(request_handle != NULL); | 185 ASSERT_TRUE(request_handle != NULL); |
166 error = callback.WaitForResult(); | 186 error = callback.WaitForResult(); |
167 ASSERT_TRUE(IsCertificateError(error)); | 187 ASSERT_TRUE(IsCertificateError(error)); |
168 ASSERT_EQ(2u, verifier_.requests()); | 188 ASSERT_EQ(2u, verifier_.requests()); |
169 ASSERT_EQ(0u, verifier_.cache_hits()); | 189 ASSERT_EQ(0u, verifier_.cache_hits()); |
170 ASSERT_EQ(0u, verifier_.inflight_joins()); | 190 ASSERT_EQ(0u, verifier_.inflight_joins()); |
171 ASSERT_EQ(2u, verifier_.GetCacheSize()); | 191 ASSERT_EQ(2u, verifier_.GetCacheSize()); |
172 } | 192 } |
173 | 193 |
174 // Tests an inflight join. | 194 // Tests an inflight join. |
175 TEST_F(MultiThreadedCertVerifierTest, InflightJoin) { | 195 TEST_F(MultiThreadedCertVerifierTest, InflightJoin) { |
176 base::FilePath certs_dir = GetTestCertsDirectory(); | 196 base::FilePath certs_dir = GetTestCertsDirectory(); |
177 scoped_refptr<X509Certificate> test_cert( | 197 scoped_refptr<X509Certificate> test_cert( |
178 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 198 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
179 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); | 199 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); |
180 | 200 |
181 int error; | 201 int error; |
182 CertVerifyResult verify_result; | 202 CertVerifyResult verify_result; |
183 TestCompletionCallback callback; | 203 TestCompletionCallback callback; |
184 CertVerifier::RequestHandle request_handle; | 204 CertVerifier::RequestHandle request_handle; |
185 CertVerifyResult verify_result2; | 205 CertVerifyResult verify_result2; |
186 TestCompletionCallback callback2; | 206 TestCompletionCallback callback2; |
187 CertVerifier::RequestHandle request_handle2; | 207 CertVerifier::RequestHandle request_handle2; |
188 | 208 |
189 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 209 error = verifier_.Verify(test_cert.get(), |
190 &verify_result, callback.callback(), | 210 "www.example.com", |
191 &request_handle, BoundNetLog()); | 211 0, |
| 212 NULL, |
| 213 &verify_result, |
| 214 callback.callback(), |
| 215 &request_handle, |
| 216 BoundNetLog()); |
192 ASSERT_EQ(ERR_IO_PENDING, error); | 217 ASSERT_EQ(ERR_IO_PENDING, error); |
193 ASSERT_TRUE(request_handle != NULL); | 218 ASSERT_TRUE(request_handle != NULL); |
194 error = verifier_.Verify( | 219 error = verifier_.Verify(test_cert.get(), |
195 test_cert, "www.example.com", 0, NULL, &verify_result2, | 220 "www.example.com", |
196 callback2.callback(), &request_handle2, BoundNetLog()); | 221 0, |
| 222 NULL, |
| 223 &verify_result2, |
| 224 callback2.callback(), |
| 225 &request_handle2, |
| 226 BoundNetLog()); |
197 ASSERT_EQ(ERR_IO_PENDING, error); | 227 ASSERT_EQ(ERR_IO_PENDING, error); |
198 ASSERT_TRUE(request_handle2 != NULL); | 228 ASSERT_TRUE(request_handle2 != NULL); |
199 error = callback.WaitForResult(); | 229 error = callback.WaitForResult(); |
200 ASSERT_TRUE(IsCertificateError(error)); | 230 ASSERT_TRUE(IsCertificateError(error)); |
201 error = callback2.WaitForResult(); | 231 error = callback2.WaitForResult(); |
202 ASSERT_TRUE(IsCertificateError(error)); | 232 ASSERT_TRUE(IsCertificateError(error)); |
203 ASSERT_EQ(2u, verifier_.requests()); | 233 ASSERT_EQ(2u, verifier_.requests()); |
204 ASSERT_EQ(0u, verifier_.cache_hits()); | 234 ASSERT_EQ(0u, verifier_.cache_hits()); |
205 ASSERT_EQ(1u, verifier_.inflight_joins()); | 235 ASSERT_EQ(1u, verifier_.inflight_joins()); |
206 } | 236 } |
207 | 237 |
208 // Tests that the callback of a canceled request is never made. | 238 // Tests that the callback of a canceled request is never made. |
209 TEST_F(MultiThreadedCertVerifierTest, CancelRequest) { | 239 TEST_F(MultiThreadedCertVerifierTest, CancelRequest) { |
210 base::FilePath certs_dir = GetTestCertsDirectory(); | 240 base::FilePath certs_dir = GetTestCertsDirectory(); |
211 scoped_refptr<X509Certificate> test_cert( | 241 scoped_refptr<X509Certificate> test_cert( |
212 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 242 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
213 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); | 243 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); |
214 | 244 |
215 int error; | 245 int error; |
216 CertVerifyResult verify_result; | 246 CertVerifyResult verify_result; |
217 CertVerifier::RequestHandle request_handle; | 247 CertVerifier::RequestHandle request_handle; |
218 | 248 |
219 error = verifier_.Verify( | 249 error = verifier_.Verify(test_cert.get(), |
220 test_cert, "www.example.com", 0, NULL, &verify_result, | 250 "www.example.com", |
221 base::Bind(&FailTest), &request_handle, BoundNetLog()); | 251 0, |
| 252 NULL, |
| 253 &verify_result, |
| 254 base::Bind(&FailTest), |
| 255 &request_handle, |
| 256 BoundNetLog()); |
222 ASSERT_EQ(ERR_IO_PENDING, error); | 257 ASSERT_EQ(ERR_IO_PENDING, error); |
223 ASSERT_TRUE(request_handle != NULL); | 258 ASSERT_TRUE(request_handle != NULL); |
224 verifier_.CancelRequest(request_handle); | 259 verifier_.CancelRequest(request_handle); |
225 | 260 |
226 // Issue a few more requests to the worker pool and wait for their | 261 // Issue a few more requests to the worker pool and wait for their |
227 // completion, so that the task of the canceled request (which runs on a | 262 // completion, so that the task of the canceled request (which runs on a |
228 // worker thread) is likely to complete by the end of this test. | 263 // worker thread) is likely to complete by the end of this test. |
229 TestCompletionCallback callback; | 264 TestCompletionCallback callback; |
230 for (int i = 0; i < 5; ++i) { | 265 for (int i = 0; i < 5; ++i) { |
231 error = verifier_.Verify( | 266 error = verifier_.Verify(test_cert.get(), |
232 test_cert, "www2.example.com", 0, NULL, &verify_result, | 267 "www2.example.com", |
233 callback.callback(), &request_handle, BoundNetLog()); | 268 0, |
| 269 NULL, |
| 270 &verify_result, |
| 271 callback.callback(), |
| 272 &request_handle, |
| 273 BoundNetLog()); |
234 ASSERT_EQ(ERR_IO_PENDING, error); | 274 ASSERT_EQ(ERR_IO_PENDING, error); |
235 ASSERT_TRUE(request_handle != NULL); | 275 ASSERT_TRUE(request_handle != NULL); |
236 error = callback.WaitForResult(); | 276 error = callback.WaitForResult(); |
237 verifier_.ClearCache(); | 277 verifier_.ClearCache(); |
238 } | 278 } |
239 } | 279 } |
240 | 280 |
241 // Tests that a canceled request is not leaked. | 281 // Tests that a canceled request is not leaked. |
242 TEST_F(MultiThreadedCertVerifierTest, CancelRequestThenQuit) { | 282 TEST_F(MultiThreadedCertVerifierTest, CancelRequestThenQuit) { |
243 base::FilePath certs_dir = GetTestCertsDirectory(); | 283 base::FilePath certs_dir = GetTestCertsDirectory(); |
244 scoped_refptr<X509Certificate> test_cert( | 284 scoped_refptr<X509Certificate> test_cert( |
245 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 285 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
246 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); | 286 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); |
247 | 287 |
248 int error; | 288 int error; |
249 CertVerifyResult verify_result; | 289 CertVerifyResult verify_result; |
250 TestCompletionCallback callback; | 290 TestCompletionCallback callback; |
251 CertVerifier::RequestHandle request_handle; | 291 CertVerifier::RequestHandle request_handle; |
252 | 292 |
253 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 293 error = verifier_.Verify(test_cert.get(), |
254 &verify_result, callback.callback(), | 294 "www.example.com", |
255 &request_handle, BoundNetLog()); | 295 0, |
| 296 NULL, |
| 297 &verify_result, |
| 298 callback.callback(), |
| 299 &request_handle, |
| 300 BoundNetLog()); |
256 ASSERT_EQ(ERR_IO_PENDING, error); | 301 ASSERT_EQ(ERR_IO_PENDING, error); |
257 ASSERT_TRUE(request_handle != NULL); | 302 ASSERT_TRUE(request_handle != NULL); |
258 verifier_.CancelRequest(request_handle); | 303 verifier_.CancelRequest(request_handle); |
259 // Destroy |verifier| by going out of scope. | 304 // Destroy |verifier| by going out of scope. |
260 } | 305 } |
261 | 306 |
262 TEST_F(MultiThreadedCertVerifierTest, RequestParamsComparators) { | 307 TEST_F(MultiThreadedCertVerifierTest, RequestParamsComparators) { |
263 SHA1HashValue a_key; | 308 SHA1HashValue a_key; |
264 memset(a_key.data, 'a', sizeof(a_key.data)); | 309 memset(a_key.data, 'a', sizeof(a_key.data)); |
265 | 310 |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
356 } | 401 } |
357 } | 402 } |
358 } | 403 } |
359 | 404 |
360 TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) { | 405 TEST_F(MultiThreadedCertVerifierTest, CertTrustAnchorProvider) { |
361 MockCertTrustAnchorProvider trust_provider; | 406 MockCertTrustAnchorProvider trust_provider; |
362 verifier_.SetCertTrustAnchorProvider(&trust_provider); | 407 verifier_.SetCertTrustAnchorProvider(&trust_provider); |
363 | 408 |
364 scoped_refptr<X509Certificate> test_cert( | 409 scoped_refptr<X509Certificate> test_cert( |
365 ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem")); | 410 ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem")); |
366 ASSERT_TRUE(test_cert); | 411 ASSERT_TRUE(test_cert.get()); |
367 | 412 |
368 const CertificateList empty_cert_list; | 413 const CertificateList empty_cert_list; |
369 CertificateList cert_list; | 414 CertificateList cert_list; |
370 cert_list.push_back(test_cert); | 415 cert_list.push_back(test_cert); |
371 | 416 |
372 // Check that Verify() asks the |trust_provider| for the current list of | 417 // Check that Verify() asks the |trust_provider| for the current list of |
373 // additional trust anchors. | 418 // additional trust anchors. |
374 int error; | 419 int error; |
375 CertVerifyResult verify_result; | 420 CertVerifyResult verify_result; |
376 TestCompletionCallback callback; | 421 TestCompletionCallback callback; |
377 CertVerifier::RequestHandle request_handle; | 422 CertVerifier::RequestHandle request_handle; |
378 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) | 423 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) |
379 .WillOnce(ReturnRef(empty_cert_list)); | 424 .WillOnce(ReturnRef(empty_cert_list)); |
380 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 425 error = verifier_.Verify(test_cert.get(), |
381 &verify_result, callback.callback(), | 426 "www.example.com", |
382 &request_handle, BoundNetLog()); | 427 0, |
| 428 NULL, |
| 429 &verify_result, |
| 430 callback.callback(), |
| 431 &request_handle, |
| 432 BoundNetLog()); |
383 Mock::VerifyAndClearExpectations(&trust_provider); | 433 Mock::VerifyAndClearExpectations(&trust_provider); |
384 ASSERT_EQ(ERR_IO_PENDING, error); | 434 ASSERT_EQ(ERR_IO_PENDING, error); |
385 ASSERT_TRUE(request_handle); | 435 ASSERT_TRUE(request_handle); |
386 error = callback.WaitForResult(); | 436 error = callback.WaitForResult(); |
387 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); | 437 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); |
388 ASSERT_EQ(1u, verifier_.requests()); | 438 ASSERT_EQ(1u, verifier_.requests()); |
389 ASSERT_EQ(0u, verifier_.cache_hits()); | 439 ASSERT_EQ(0u, verifier_.cache_hits()); |
390 | 440 |
391 // The next Verify() uses the cached result. | 441 // The next Verify() uses the cached result. |
392 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) | 442 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) |
393 .WillOnce(ReturnRef(empty_cert_list)); | 443 .WillOnce(ReturnRef(empty_cert_list)); |
394 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 444 error = verifier_.Verify(test_cert.get(), |
395 &verify_result, callback.callback(), | 445 "www.example.com", |
396 &request_handle, BoundNetLog()); | 446 0, |
| 447 NULL, |
| 448 &verify_result, |
| 449 callback.callback(), |
| 450 &request_handle, |
| 451 BoundNetLog()); |
397 Mock::VerifyAndClearExpectations(&trust_provider); | 452 Mock::VerifyAndClearExpectations(&trust_provider); |
398 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); | 453 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); |
399 EXPECT_FALSE(request_handle); | 454 EXPECT_FALSE(request_handle); |
400 ASSERT_EQ(2u, verifier_.requests()); | 455 ASSERT_EQ(2u, verifier_.requests()); |
401 ASSERT_EQ(1u, verifier_.cache_hits()); | 456 ASSERT_EQ(1u, verifier_.cache_hits()); |
402 | 457 |
403 // Another Verify() for the same certificate but with a different list of | 458 // Another Verify() for the same certificate but with a different list of |
404 // trust anchors will not reuse the cache. | 459 // trust anchors will not reuse the cache. |
405 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) | 460 EXPECT_CALL(trust_provider, GetAdditionalTrustAnchors()) |
406 .WillOnce(ReturnRef(cert_list)); | 461 .WillOnce(ReturnRef(cert_list)); |
407 error = verifier_.Verify(test_cert, "www.example.com", 0, NULL, | 462 error = verifier_.Verify(test_cert.get(), |
408 &verify_result, callback.callback(), | 463 "www.example.com", |
409 &request_handle, BoundNetLog()); | 464 0, |
| 465 NULL, |
| 466 &verify_result, |
| 467 callback.callback(), |
| 468 &request_handle, |
| 469 BoundNetLog()); |
410 Mock::VerifyAndClearExpectations(&trust_provider); | 470 Mock::VerifyAndClearExpectations(&trust_provider); |
411 ASSERT_EQ(ERR_IO_PENDING, error); | 471 ASSERT_EQ(ERR_IO_PENDING, error); |
412 ASSERT_TRUE(request_handle != NULL); | 472 ASSERT_TRUE(request_handle != NULL); |
413 error = callback.WaitForResult(); | 473 error = callback.WaitForResult(); |
414 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); | 474 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, error); |
415 ASSERT_EQ(3u, verifier_.requests()); | 475 ASSERT_EQ(3u, verifier_.requests()); |
416 ASSERT_EQ(1u, verifier_.cache_hits()); | 476 ASSERT_EQ(1u, verifier_.cache_hits()); |
417 } | 477 } |
418 | 478 |
419 } // namespace net | 479 } // namespace net |
OLD | NEW |