OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/http/disk_cache_based_quic_server_info.h" | 5 #include "net/http/disk_cache_based_quic_server_info.h" |
6 | 6 |
| 7 #include <string> |
| 8 |
7 #include "base/bind.h" | 9 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
9 #include "base/compiler_specific.h" | 11 #include "base/compiler_specific.h" |
10 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
11 #include "net/base/net_errors.h" | 13 #include "net/base/net_errors.h" |
12 #include "net/http/mock_http_cache.h" | 14 #include "net/http/mock_http_cache.h" |
13 #include "net/quic/crypto/quic_server_info.h" | 15 #include "net/quic/crypto/quic_server_info.h" |
14 #include "net/quic/quic_server_id.h" | 16 #include "net/quic/quic_server_id.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
16 | 18 |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 | 79 |
78 QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED); | 80 QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED); |
79 scoped_ptr<QuicServerInfo> quic_server_info( | 81 scoped_ptr<QuicServerInfo> quic_server_info( |
80 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 82 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
81 quic_server_info->Start(); | 83 quic_server_info->Start(); |
82 int rv = quic_server_info->WaitForDataReady(callback.callback()); | 84 int rv = quic_server_info->WaitForDataReady(callback.callback()); |
83 EXPECT_EQ(OK, callback.GetResult(rv)); | 85 EXPECT_EQ(OK, callback.GetResult(rv)); |
84 | 86 |
85 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 87 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
86 EXPECT_TRUE(state->certs.empty()); | 88 EXPECT_TRUE(state->certs.empty()); |
87 const string server_config_a = "server_config_a"; | 89 const std::string server_config_a = "server_config_a"; |
88 const string source_address_token_a = "source_address_token_a"; | 90 const std::string source_address_token_a = "source_address_token_a"; |
89 const string server_config_sig_a = "server_config_sig_a"; | 91 const std::string server_config_sig_a = "server_config_sig_a"; |
90 const string cert_a = "cert_a"; | 92 const std::string cert_a = "cert_a"; |
91 const string cert_b = "cert_b"; | 93 const std::string cert_b = "cert_b"; |
92 | 94 |
93 state->server_config = server_config_a; | 95 state->server_config = server_config_a; |
94 state->source_address_token = source_address_token_a; | 96 state->source_address_token = source_address_token_a; |
95 state->server_config_sig = server_config_sig_a; | 97 state->server_config_sig = server_config_sig_a; |
96 state->certs.push_back(cert_a); | 98 state->certs.push_back(cert_a); |
97 quic_server_info->Persist(); | 99 quic_server_info->Persist(); |
98 | 100 |
99 // Wait until Persist() does the work. | 101 // Wait until Persist() does the work. |
100 base::MessageLoop::current()->RunUntilIdle(); | 102 base::MessageLoop::current()->RunUntilIdle(); |
101 | 103 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 // Persist data for port 443. | 146 // Persist data for port 443. |
145 QuicServerId server_id1("www.google.com", 443, true, PRIVACY_MODE_DISABLED); | 147 QuicServerId server_id1("www.google.com", 443, true, PRIVACY_MODE_DISABLED); |
146 scoped_ptr<QuicServerInfo> quic_server_info1( | 148 scoped_ptr<QuicServerInfo> quic_server_info1( |
147 new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache())); | 149 new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache())); |
148 quic_server_info1->Start(); | 150 quic_server_info1->Start(); |
149 int rv = quic_server_info1->WaitForDataReady(callback.callback()); | 151 int rv = quic_server_info1->WaitForDataReady(callback.callback()); |
150 EXPECT_EQ(OK, callback.GetResult(rv)); | 152 EXPECT_EQ(OK, callback.GetResult(rv)); |
151 | 153 |
152 QuicServerInfo::State* state1 = quic_server_info1->mutable_state(); | 154 QuicServerInfo::State* state1 = quic_server_info1->mutable_state(); |
153 EXPECT_TRUE(state1->certs.empty()); | 155 EXPECT_TRUE(state1->certs.empty()); |
154 const string server_config_a = "server_config_a"; | 156 const std::string server_config_a = "server_config_a"; |
155 const string source_address_token_a = "source_address_token_a"; | 157 const std::string source_address_token_a = "source_address_token_a"; |
156 const string server_config_sig_a = "server_config_sig_a"; | 158 const std::string server_config_sig_a = "server_config_sig_a"; |
157 const string cert_a = "cert_a"; | 159 const std::string cert_a = "cert_a"; |
158 | 160 |
159 state1->server_config = server_config_a; | 161 state1->server_config = server_config_a; |
160 state1->source_address_token = source_address_token_a; | 162 state1->source_address_token = source_address_token_a; |
161 state1->server_config_sig = server_config_sig_a; | 163 state1->server_config_sig = server_config_sig_a; |
162 state1->certs.push_back(cert_a); | 164 state1->certs.push_back(cert_a); |
163 quic_server_info1->Persist(); | 165 quic_server_info1->Persist(); |
164 | 166 |
165 // Wait until Persist() does the work. | 167 // Wait until Persist() does the work. |
166 base::MessageLoop::current()->RunUntilIdle(); | 168 base::MessageLoop::current()->RunUntilIdle(); |
167 | 169 |
168 // Persist data for port 80. | 170 // Persist data for port 80. |
169 QuicServerId server_id2("www.google.com", 80, false, PRIVACY_MODE_DISABLED); | 171 QuicServerId server_id2("www.google.com", 80, false, PRIVACY_MODE_DISABLED); |
170 scoped_ptr<QuicServerInfo> quic_server_info2( | 172 scoped_ptr<QuicServerInfo> quic_server_info2( |
171 new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache())); | 173 new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache())); |
172 quic_server_info2->Start(); | 174 quic_server_info2->Start(); |
173 rv = quic_server_info2->WaitForDataReady(callback.callback()); | 175 rv = quic_server_info2->WaitForDataReady(callback.callback()); |
174 EXPECT_EQ(OK, callback.GetResult(rv)); | 176 EXPECT_EQ(OK, callback.GetResult(rv)); |
175 | 177 |
176 QuicServerInfo::State* state2 = quic_server_info2->mutable_state(); | 178 QuicServerInfo::State* state2 = quic_server_info2->mutable_state(); |
177 EXPECT_TRUE(state2->certs.empty()); | 179 EXPECT_TRUE(state2->certs.empty()); |
178 const string server_config_b = "server_config_b"; | 180 const std::string server_config_b = "server_config_b"; |
179 const string source_address_token_b = "source_address_token_b"; | 181 const std::string source_address_token_b = "source_address_token_b"; |
180 const string server_config_sig_b = "server_config_sig_b"; | 182 const std::string server_config_sig_b = "server_config_sig_b"; |
181 const string cert_b = "cert_b"; | 183 const std::string cert_b = "cert_b"; |
182 | 184 |
183 state2->server_config = server_config_b; | 185 state2->server_config = server_config_b; |
184 state2->source_address_token = source_address_token_b; | 186 state2->source_address_token = source_address_token_b; |
185 state2->server_config_sig = server_config_sig_b; | 187 state2->server_config_sig = server_config_sig_b; |
186 state2->certs.push_back(cert_b); | 188 state2->certs.push_back(cert_b); |
187 quic_server_info2->Persist(); | 189 quic_server_info2->Persist(); |
188 | 190 |
189 // Wait until Persist() does the work. | 191 // Wait until Persist() does the work. |
190 base::MessageLoop::current()->RunUntilIdle(); | 192 base::MessageLoop::current()->RunUntilIdle(); |
191 | 193 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
233 scoped_ptr<QuicServerInfo> quic_server_info( | 235 scoped_ptr<QuicServerInfo> quic_server_info( |
234 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 236 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
235 EXPECT_FALSE(quic_server_info->IsDataReady()); | 237 EXPECT_FALSE(quic_server_info->IsDataReady()); |
236 quic_server_info->Start(); | 238 quic_server_info->Start(); |
237 int rv = quic_server_info->WaitForDataReady(callback.callback()); | 239 int rv = quic_server_info->WaitForDataReady(callback.callback()); |
238 EXPECT_EQ(OK, callback.GetResult(rv)); | 240 EXPECT_EQ(OK, callback.GetResult(rv)); |
239 EXPECT_TRUE(quic_server_info->IsDataReady()); | 241 EXPECT_TRUE(quic_server_info->IsDataReady()); |
240 | 242 |
241 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 243 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
242 EXPECT_TRUE(state->certs.empty()); | 244 EXPECT_TRUE(state->certs.empty()); |
243 const string server_config_a = "server_config_a"; | 245 const std::string server_config_a = "server_config_a"; |
244 const string source_address_token_a = "source_address_token_a"; | 246 const std::string source_address_token_a = "source_address_token_a"; |
245 const string server_config_sig_a = "server_config_sig_a"; | 247 const std::string server_config_sig_a = "server_config_sig_a"; |
246 const string cert_a = "cert_a"; | 248 const std::string cert_a = "cert_a"; |
247 | 249 |
248 state->server_config = server_config_a; | 250 state->server_config = server_config_a; |
249 state->source_address_token = source_address_token_a; | 251 state->source_address_token = source_address_token_a; |
250 state->server_config_sig = server_config_sig_a; | 252 state->server_config_sig = server_config_sig_a; |
251 state->certs.push_back(cert_a); | 253 state->certs.push_back(cert_a); |
252 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 254 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
253 quic_server_info->Persist(); | 255 quic_server_info->Persist(); |
254 | 256 |
255 // Once we call Persist, IsReadyToPersist should return false until Persist | 257 // Once we call Persist, IsReadyToPersist should return false until Persist |
256 // has completed. | 258 // has completed. |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
290 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 292 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
291 EXPECT_FALSE(quic_server_info->IsDataReady()); | 293 EXPECT_FALSE(quic_server_info->IsDataReady()); |
292 quic_server_info->Start(); | 294 quic_server_info->Start(); |
293 int rv = quic_server_info->WaitForDataReady(callback.callback()); | 295 int rv = quic_server_info->WaitForDataReady(callback.callback()); |
294 EXPECT_EQ(OK, callback.GetResult(rv)); | 296 EXPECT_EQ(OK, callback.GetResult(rv)); |
295 EXPECT_TRUE(quic_server_info->IsDataReady()); | 297 EXPECT_TRUE(quic_server_info->IsDataReady()); |
296 | 298 |
297 // Persist data once. | 299 // Persist data once. |
298 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 300 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
299 EXPECT_TRUE(state->certs.empty()); | 301 EXPECT_TRUE(state->certs.empty()); |
300 const string server_config_init = "server_config_init"; | 302 const std::string server_config_init = "server_config_init"; |
301 const string source_address_token_init = "source_address_token_init"; | 303 const std::string source_address_token_init = "source_address_token_init"; |
302 const string server_config_sig_init = "server_config_sig_init"; | 304 const std::string server_config_sig_init = "server_config_sig_init"; |
303 const string cert_init = "cert_init"; | 305 const std::string cert_init = "cert_init"; |
304 | 306 |
305 state->server_config = server_config_init; | 307 state->server_config = server_config_init; |
306 state->source_address_token = source_address_token_init; | 308 state->source_address_token = source_address_token_init; |
307 state->server_config_sig = server_config_sig_init; | 309 state->server_config_sig = server_config_sig_init; |
308 state->certs.push_back(cert_init); | 310 state->certs.push_back(cert_init); |
309 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 311 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
310 quic_server_info->Persist(); | 312 quic_server_info->Persist(); |
311 | 313 |
312 // Once we call Persist, IsReadyToPersist should return false until Persist | 314 // Once we call Persist, IsReadyToPersist should return false until Persist |
313 // has completed. | 315 // has completed. |
314 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); | 316 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); |
315 | 317 |
316 // Wait until Persist() does the work. | 318 // Wait until Persist() does the work. |
317 base::MessageLoop::current()->RunUntilIdle(); | 319 base::MessageLoop::current()->RunUntilIdle(); |
318 | 320 |
319 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 321 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
320 | 322 |
321 // Persist one more time using the same |quic_server_info| object and without | 323 // Persist one more time using the same |quic_server_info| object and without |
322 // doing another Start() and WaitForDataReady. | 324 // doing another Start() and WaitForDataReady. |
323 const string server_config_a = "server_config_a"; | 325 const std::string server_config_a = "server_config_a"; |
324 const string source_address_token_a = "source_address_token_a"; | 326 const std::string source_address_token_a = "source_address_token_a"; |
325 const string server_config_sig_a = "server_config_sig_a"; | 327 const std::string server_config_sig_a = "server_config_sig_a"; |
326 const string cert_a = "cert_a"; | 328 const std::string cert_a = "cert_a"; |
327 | 329 |
328 state->server_config = server_config_a; | 330 state->server_config = server_config_a; |
329 state->source_address_token = source_address_token_a; | 331 state->source_address_token = source_address_token_a; |
330 state->server_config_sig = server_config_sig_a; | 332 state->server_config_sig = server_config_sig_a; |
331 state->certs.push_back(cert_a); | 333 state->certs.push_back(cert_a); |
332 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 334 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
333 quic_server_info->Persist(); | 335 quic_server_info->Persist(); |
334 | 336 |
335 // Once we call Persist, IsReadyToPersist should return false until Persist | 337 // Once we call Persist, IsReadyToPersist should return false until Persist |
336 // has completed. | 338 // has completed. |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
405 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 407 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
406 EXPECT_FALSE(quic_server_info->IsDataReady()); | 408 EXPECT_FALSE(quic_server_info->IsDataReady()); |
407 quic_server_info->Start(); | 409 quic_server_info->Start(); |
408 // Wait until Start() does the work. | 410 // Wait until Start() does the work. |
409 base::MessageLoop::current()->RunUntilIdle(); | 411 base::MessageLoop::current()->RunUntilIdle(); |
410 | 412 |
411 EXPECT_TRUE(quic_server_info->IsDataReady()); | 413 EXPECT_TRUE(quic_server_info->IsDataReady()); |
412 | 414 |
413 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 415 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
414 EXPECT_TRUE(state->certs.empty()); | 416 EXPECT_TRUE(state->certs.empty()); |
415 const string server_config_a = "server_config_a"; | 417 const std::string server_config_a = "server_config_a"; |
416 const string source_address_token_a = "source_address_token_a"; | 418 const std::string source_address_token_a = "source_address_token_a"; |
417 const string server_config_sig_a = "server_config_sig_a"; | 419 const std::string server_config_sig_a = "server_config_sig_a"; |
418 const string cert_a = "cert_a"; | 420 const std::string cert_a = "cert_a"; |
419 | 421 |
420 state->server_config = server_config_a; | 422 state->server_config = server_config_a; |
421 state->source_address_token = source_address_token_a; | 423 state->source_address_token = source_address_token_a; |
422 state->server_config_sig = server_config_sig_a; | 424 state->server_config_sig = server_config_sig_a; |
423 state->certs.push_back(cert_a); | 425 state->certs.push_back(cert_a); |
424 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 426 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
425 quic_server_info->Persist(); | 427 quic_server_info->Persist(); |
426 quic_server_info->OnExternalCacheHit(); | 428 quic_server_info->OnExternalCacheHit(); |
427 | 429 |
428 // Once we call Persist, IsReadyToPersist should return false until Persist | 430 // Once we call Persist, IsReadyToPersist should return false until Persist |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
466 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 468 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
467 EXPECT_FALSE(quic_server_info->IsDataReady()); | 469 EXPECT_FALSE(quic_server_info->IsDataReady()); |
468 // We do a Start(), but don't call WaitForDataReady(). Because we haven't | 470 // We do a Start(), but don't call WaitForDataReady(). Because we haven't |
469 // created the backend, we will wait and data wouldn't be ready. | 471 // created the backend, we will wait and data wouldn't be ready. |
470 quic_server_info->Start(); | 472 quic_server_info->Start(); |
471 EXPECT_FALSE(quic_server_info->IsDataReady()); | 473 EXPECT_FALSE(quic_server_info->IsDataReady()); |
472 | 474 |
473 // Persist data once, even though the backend is not ready. | 475 // Persist data once, even though the backend is not ready. |
474 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 476 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
475 EXPECT_TRUE(state->certs.empty()); | 477 EXPECT_TRUE(state->certs.empty()); |
476 const string server_config_init = "server_config_init"; | 478 const std::string server_config_init = "server_config_init"; |
477 const string source_address_token_init = "source_address_token_init"; | 479 const std::string source_address_token_init = "source_address_token_init"; |
478 const string server_config_sig_init = "server_config_sig_init"; | 480 const std::string server_config_sig_init = "server_config_sig_init"; |
479 const string cert_init = "cert_init"; | 481 const std::string cert_init = "cert_init"; |
480 | 482 |
481 state->server_config = server_config_init; | 483 state->server_config = server_config_init; |
482 state->source_address_token = source_address_token_init; | 484 state->source_address_token = source_address_token_init; |
483 state->server_config_sig = server_config_sig_init; | 485 state->server_config_sig = server_config_sig_init; |
484 state->certs.push_back(cert_init); | 486 state->certs.push_back(cert_init); |
485 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); | 487 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); |
486 quic_server_info->Persist(); | 488 quic_server_info->Persist(); |
487 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); | 489 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); |
488 | 490 |
489 // Now complete the backend creation and let the callback run. | 491 // Now complete the backend creation and let the callback run. |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
521 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); | 523 new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache())); |
522 EXPECT_FALSE(quic_server_info->IsDataReady()); | 524 EXPECT_FALSE(quic_server_info->IsDataReady()); |
523 quic_server_info->Start(); | 525 quic_server_info->Start(); |
524 int rv = quic_server_info->WaitForDataReady(callback.callback()); | 526 int rv = quic_server_info->WaitForDataReady(callback.callback()); |
525 EXPECT_EQ(OK, callback.GetResult(rv)); | 527 EXPECT_EQ(OK, callback.GetResult(rv)); |
526 EXPECT_TRUE(quic_server_info->IsDataReady()); | 528 EXPECT_TRUE(quic_server_info->IsDataReady()); |
527 | 529 |
528 // Persist data once. | 530 // Persist data once. |
529 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 531 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
530 EXPECT_TRUE(state->certs.empty()); | 532 EXPECT_TRUE(state->certs.empty()); |
531 const string server_config_init = "server_config_init"; | 533 const std::string server_config_init = "server_config_init"; |
532 const string source_address_token_init = "source_address_token_init"; | 534 const std::string source_address_token_init = "source_address_token_init"; |
533 const string server_config_sig_init = "server_config_sig_init"; | 535 const std::string server_config_sig_init = "server_config_sig_init"; |
534 const string cert_init = "cert_init"; | 536 const std::string cert_init = "cert_init"; |
535 | 537 |
536 state->server_config = server_config_init; | 538 state->server_config = server_config_init; |
537 state->source_address_token = source_address_token_init; | 539 state->source_address_token = source_address_token_init; |
538 state->server_config_sig = server_config_sig_init; | 540 state->server_config_sig = server_config_sig_init; |
539 state->certs.push_back(cert_init); | 541 state->certs.push_back(cert_init); |
540 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); | 542 EXPECT_TRUE(quic_server_info->IsReadyToPersist()); |
541 quic_server_info->Persist(); | 543 quic_server_info->Persist(); |
542 | 544 |
543 // Once we call Persist, IsReadyToPersist should return false until Persist | 545 // Once we call Persist, IsReadyToPersist should return false until Persist |
544 // has completed. | 546 // has completed. |
545 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); | 547 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); |
546 | 548 |
547 // Persist one more time using the same |quic_server_info| object and without | 549 // Persist one more time using the same |quic_server_info| object and without |
548 // doing another Start() and WaitForDataReady. | 550 // doing another Start() and WaitForDataReady. |
549 const string server_config_a = "server_config_a"; | 551 const std::string server_config_a = "server_config_a"; |
550 const string source_address_token_a = "source_address_token_a"; | 552 const std::string source_address_token_a = "source_address_token_a"; |
551 const string server_config_sig_a = "server_config_sig_a"; | 553 const std::string server_config_sig_a = "server_config_sig_a"; |
552 const string cert_a = "cert_a"; | 554 const std::string cert_a = "cert_a"; |
553 | 555 |
554 state->server_config = server_config_a; | 556 state->server_config = server_config_a; |
555 state->source_address_token = source_address_token_a; | 557 state->source_address_token = source_address_token_a; |
556 state->server_config_sig = server_config_sig_a; | 558 state->server_config_sig = server_config_sig_a; |
557 state->certs.push_back(cert_a); | 559 state->certs.push_back(cert_a); |
558 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); | 560 EXPECT_FALSE(quic_server_info->IsReadyToPersist()); |
559 quic_server_info->Persist(); | 561 quic_server_info->Persist(); |
560 | 562 |
561 // Wait until Persist() does the work. | 563 // Wait until Persist() does the work. |
562 base::MessageLoop::current()->RunUntilIdle(); | 564 base::MessageLoop::current()->RunUntilIdle(); |
(...skipping 13 matching lines...) Expand all Loading... |
576 EXPECT_EQ(server_config_a, state1.server_config); | 578 EXPECT_EQ(server_config_a, state1.server_config); |
577 EXPECT_EQ(source_address_token_a, state1.source_address_token); | 579 EXPECT_EQ(source_address_token_a, state1.source_address_token); |
578 EXPECT_EQ(server_config_sig_a, state1.server_config_sig); | 580 EXPECT_EQ(server_config_sig_a, state1.server_config_sig); |
579 EXPECT_EQ(1U, state1.certs.size()); | 581 EXPECT_EQ(1U, state1.certs.size()); |
580 EXPECT_EQ(cert_a, state1.certs[0]); | 582 EXPECT_EQ(cert_a, state1.certs[0]); |
581 | 583 |
582 RemoveMockTransaction(&kHostInfoTransaction1); | 584 RemoveMockTransaction(&kHostInfoTransaction1); |
583 } | 585 } |
584 | 586 |
585 } // namespace net | 587 } // namespace net |
OLD | NEW |