src/net/http/disk_cache_based_quic_server_info_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "net/http/disk_cache_based_quic_server_info.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/http/mock_http_cache.h"
  13 #include "net/quic/crypto/quic_server_info.h"
  14 #include "net/quic/quic_server_id.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace net {
  18 namespace {
  19
  20 // This is an empty transaction, needed to register the URL and the test mode.
  21 const MockTransaction kHostInfoTransaction1 = {
  22   "quicserverinfo:https://www.google.com:443",
  23   "",
  24   base::Time(),
  25   "",
  26   LOAD_NORMAL,
  27   "",
  28   "",
  29   base::Time(),
  30   "",
  31   TEST_MODE_NORMAL,
  32   NULL,
  33   0
  34 };
  35
  36 const MockTransaction kHostInfoTransaction2 = {
  37   "quicserverinfo:http://www.google.com:80",
  38   "",
  39   base::Time(),
  40   "",
  41   LOAD_NORMAL,
  42   "",
  43   "",
  44   base::Time(),
  45   "",
  46   TEST_MODE_NORMAL,
  47   NULL,
  48   0
  49 };
  50
  51 }  // namespace
  52
  53 // Tests that we can delete a DiskCacheBasedQuicServerInfo object in a
  54 // completion callback for DiskCacheBasedQuicServerInfo::WaitForDataReady.
  55 TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
  56   // Use the blocking mock backend factory to force asynchronous completion
  57   // of quic_server_info->WaitForDataReady(), so that the callback will run.
  58   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
  59   MockHttpCache cache(factory);
  60   QuicServerId server_id("www.verisign.com", 443, true, PRIVACY_MODE_DISABLED);
  61   scoped_ptr<QuicServerInfo> quic_server_info(
  62       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
  63   quic_server_info->Start();
  64   TestCompletionCallback callback;
  65   int rv = quic_server_info->WaitForDataReady(callback.callback());
  66   EXPECT_EQ(ERR_IO_PENDING, rv);
  67   // Now complete the backend creation and let the callback run.
  68   factory->FinishCreation();
  69   EXPECT_EQ(OK, callback.GetResult(rv));
  70 }
  71
  72 // Tests the basic logic of storing, retrieving and updating data.
  73 TEST(DiskCacheBasedQuicServerInfo, Update) {
  74   MockHttpCache cache;
  75   AddMockTransaction(&kHostInfoTransaction1);
  76   TestCompletionCallback callback;
  77
  78   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
  79   scoped_ptr<QuicServerInfo> quic_server_info(
  80       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
  81   quic_server_info->Start();
  82   int rv = quic_server_info->WaitForDataReady(callback.callback());
  83   EXPECT_EQ(OK, callback.GetResult(rv));
  84
  85   QuicServerInfo::State* state = quic_server_info->mutable_state();
  86   EXPECT_TRUE(state->certs.empty());
  87   const string server_config_a = "server_config_a";
  88   const string source_address_token_a = "source_address_token_a";
  89   const string server_config_sig_a = "server_config_sig_a";
  90   const string cert_a = "cert_a";
  91   const string cert_b = "cert_b";
  92
  93   state->server_config = server_config_a;
  94   state->source_address_token = source_address_token_a;
  95   state->server_config_sig = server_config_sig_a;
  96   state->certs.push_back(cert_a);
  97   quic_server_info->Persist();
  98
  99   // Wait until Persist() does the work.
 100   base::MessageLoop::current()->RunUntilIdle();
 101
 102   // Open the stored QuicServerInfo.
 103   quic_server_info.reset(
 104       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 105   quic_server_info->Start();
 106   rv = quic_server_info->WaitForDataReady(callback.callback());
 107   EXPECT_EQ(OK, callback.GetResult(rv));
 108
 109   // And now update the data.
 110   state = quic_server_info->mutable_state();
 111   state->certs.push_back(cert_b);
 112
 113   // Fail instead of DCHECKing double creates.
 114   cache.disk_cache()->set_double_create_check(false);
 115   quic_server_info->Persist();
 116   base::MessageLoop::current()->RunUntilIdle();
 117
 118   // Verify that the state was updated.
 119   quic_server_info.reset(
 120       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 121   quic_server_info->Start();
 122   rv = quic_server_info->WaitForDataReady(callback.callback());
 123   EXPECT_EQ(OK, callback.GetResult(rv));
 124   EXPECT_TRUE(quic_server_info->IsDataReady());
 125
 126   const QuicServerInfo::State& state1 = quic_server_info->state();
 127   EXPECT_EQ(server_config_a, state1.server_config);
 128   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 129   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 130   EXPECT_EQ(2U, state1.certs.size());
 131   EXPECT_EQ(cert_a, state1.certs[0]);
 132   EXPECT_EQ(cert_b, state1.certs[1]);
 133
 134   RemoveMockTransaction(&kHostInfoTransaction1);
 135 }
 136
 137 // Test that demonstrates different info is returned when the ports differ.
 138 TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
 139   MockHttpCache cache;
 140   AddMockTransaction(&kHostInfoTransaction1);
 141   AddMockTransaction(&kHostInfoTransaction2);
 142   TestCompletionCallback callback;
 143
 144   // Persist data for port 443.
 145   QuicServerId server_id1("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 146   scoped_ptr<QuicServerInfo> quic_server_info1(
 147       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
 148   quic_server_info1->Start();
 149   int rv = quic_server_info1->WaitForDataReady(callback.callback());
 150   EXPECT_EQ(OK, callback.GetResult(rv));
 151
 152   QuicServerInfo::State* state1 = quic_server_info1->mutable_state();
 153   EXPECT_TRUE(state1->certs.empty());
 154   const string server_config_a = "server_config_a";
 155   const string source_address_token_a = "source_address_token_a";
 156   const string server_config_sig_a = "server_config_sig_a";
 157   const string cert_a = "cert_a";
 158
 159   state1->server_config = server_config_a;
 160   state1->source_address_token = source_address_token_a;
 161   state1->server_config_sig = server_config_sig_a;
 162   state1->certs.push_back(cert_a);
 163   quic_server_info1->Persist();
 164
 165   // Wait until Persist() does the work.
 166   base::MessageLoop::current()->RunUntilIdle();
 167
 168   // Persist data for port 80.
 169   QuicServerId server_id2("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
 170   scoped_ptr<QuicServerInfo> quic_server_info2(
 171       new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache()));
 172   quic_server_info2->Start();
 173   rv = quic_server_info2->WaitForDataReady(callback.callback());
 174   EXPECT_EQ(OK, callback.GetResult(rv));
 175
 176   QuicServerInfo::State* state2 = quic_server_info2->mutable_state();
 177   EXPECT_TRUE(state2->certs.empty());
 178   const string server_config_b = "server_config_b";
 179   const string source_address_token_b = "source_address_token_b";
 180   const string server_config_sig_b = "server_config_sig_b";
 181   const string cert_b = "cert_b";
 182
 183   state2->server_config = server_config_b;
 184   state2->source_address_token = source_address_token_b;
 185   state2->server_config_sig = server_config_sig_b;
 186   state2->certs.push_back(cert_b);
 187   quic_server_info2->Persist();
 188
 189   // Wait until Persist() does the work.
 190   base::MessageLoop::current()->RunUntilIdle();
 191
 192   // Verify the stored QuicServerInfo for port 443.
 193   scoped_ptr<QuicServerInfo> quic_server_info(
 194       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
 195   quic_server_info->Start();
 196   rv = quic_server_info->WaitForDataReady(callback.callback());
 197   EXPECT_EQ(OK, callback.GetResult(rv));
 198   EXPECT_TRUE(quic_server_info->IsDataReady());
 199
 200   const QuicServerInfo::State& state_a = quic_server_info->state();
 201   EXPECT_EQ(server_config_a, state_a.server_config);
 202   EXPECT_EQ(source_address_token_a, state_a.source_address_token);
 203   EXPECT_EQ(server_config_sig_a, state_a.server_config_sig);
 204   EXPECT_EQ(1U, state_a.certs.size());
 205   EXPECT_EQ(cert_a, state_a.certs[0]);
 206
 207   // Verify the stored QuicServerInfo for port 80.
 208   quic_server_info.reset(
 209       new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache()));
 210   quic_server_info->Start();
 211   rv = quic_server_info->WaitForDataReady(callback.callback());
 212   EXPECT_EQ(OK, callback.GetResult(rv));
 213   EXPECT_TRUE(quic_server_info->IsDataReady());
 214
 215   const QuicServerInfo::State& state_b = quic_server_info->state();
 216   EXPECT_EQ(server_config_b, state_b.server_config);
 217   EXPECT_EQ(source_address_token_b, state_b.source_address_token);
 218   EXPECT_EQ(server_config_sig_b, state_b.server_config_sig);
 219   EXPECT_EQ(1U, state_b.certs.size());
 220   EXPECT_EQ(cert_b, state_b.certs[0]);
 221
 222   RemoveMockTransaction(&kHostInfoTransaction2);
 223   RemoveMockTransaction(&kHostInfoTransaction1);
 224 }
 225
 226 // Test IsReadyToPersist when there is a pending write.
 227 TEST(DiskCacheBasedQuicServerInfo, IsReadyToPersist) {
 228   MockHttpCache cache;
 229   AddMockTransaction(&kHostInfoTransaction1);
 230   TestCompletionCallback callback;
 231
 232   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 233   scoped_ptr<QuicServerInfo> quic_server_info(
 234       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 235   EXPECT_FALSE(quic_server_info->IsDataReady());
 236   quic_server_info->Start();
 237   int rv = quic_server_info->WaitForDataReady(callback.callback());
 238   EXPECT_EQ(OK, callback.GetResult(rv));
 239   EXPECT_TRUE(quic_server_info->IsDataReady());
 240
 241   QuicServerInfo::State* state = quic_server_info->mutable_state();
 242   EXPECT_TRUE(state->certs.empty());
 243   const string server_config_a = "server_config_a";
 244   const string source_address_token_a = "source_address_token_a";
 245   const string server_config_sig_a = "server_config_sig_a";
 246   const string cert_a = "cert_a";
 247
 248   state->server_config = server_config_a;
 249   state->source_address_token = source_address_token_a;
 250   state->server_config_sig = server_config_sig_a;
 251   state->certs.push_back(cert_a);
 252   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 253   quic_server_info->Persist();
 254
 255   // Once we call Persist, IsReadyToPersist should return false until Persist
 256   // has completed.
 257   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 258
 259   // Wait until Persist() does the work.
 260   base::MessageLoop::current()->RunUntilIdle();
 261
 262   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 263
 264   // Verify that the state was updated.
 265   quic_server_info.reset(
 266       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 267   quic_server_info->Start();
 268   rv = quic_server_info->WaitForDataReady(callback.callback());
 269   EXPECT_EQ(OK, callback.GetResult(rv));
 270   EXPECT_TRUE(quic_server_info->IsDataReady());
 271
 272   const QuicServerInfo::State& state1 = quic_server_info->state();
 273   EXPECT_EQ(server_config_a, state1.server_config);
 274   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 275   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 276   EXPECT_EQ(1U, state1.certs.size());
 277   EXPECT_EQ(cert_a, state1.certs[0]);
 278
 279   RemoveMockTransaction(&kHostInfoTransaction1);
 280 }
 281
 282 // Test multiple calls to Persist.
 283 TEST(DiskCacheBasedQuicServerInfo, MultiplePersist) {
 284   MockHttpCache cache;
 285   AddMockTransaction(&kHostInfoTransaction1);
 286   TestCompletionCallback callback;
 287
 288   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 289   scoped_ptr<QuicServerInfo> quic_server_info(
 290       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 291   EXPECT_FALSE(quic_server_info->IsDataReady());
 292   quic_server_info->Start();
 293   int rv = quic_server_info->WaitForDataReady(callback.callback());
 294   EXPECT_EQ(OK, callback.GetResult(rv));
 295   EXPECT_TRUE(quic_server_info->IsDataReady());
 296
 297   // Persist data once.
 298   QuicServerInfo::State* state = quic_server_info->mutable_state();
 299   EXPECT_TRUE(state->certs.empty());
 300   const string server_config_init = "server_config_init";
 301   const string source_address_token_init = "source_address_token_init";
 302   const string server_config_sig_init = "server_config_sig_init";
 303   const string cert_init = "cert_init";
 304
 305   state->server_config = server_config_init;
 306   state->source_address_token = source_address_token_init;
 307   state->server_config_sig = server_config_sig_init;
 308   state->certs.push_back(cert_init);
 309   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 310   quic_server_info->Persist();
 311
 312   // Once we call Persist, IsReadyToPersist should return false until Persist
 313   // has completed.
 314   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 315
 316   // Wait until Persist() does the work.
 317   base::MessageLoop::current()->RunUntilIdle();
 318
 319   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 320
 321   // Persist one more time using the same |quic_server_info| object and without
 322   // doing another Start() and WaitForDataReady.
 323   const string server_config_a = "server_config_a";
 324   const string source_address_token_a = "source_address_token_a";
 325   const string server_config_sig_a = "server_config_sig_a";
 326   const string cert_a = "cert_a";
 327
 328   state->server_config = server_config_a;
 329   state->source_address_token = source_address_token_a;
 330   state->server_config_sig = server_config_sig_a;
 331   state->certs.push_back(cert_a);
 332   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 333   quic_server_info->Persist();
 334
 335   // Once we call Persist, IsReadyToPersist should return false until Persist
 336   // has completed.
 337   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 338
 339   // Wait until Persist() does the work.
 340   base::MessageLoop::current()->RunUntilIdle();
 341
 342   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 343
 344   // Verify that the state was updated.
 345   quic_server_info.reset(
 346       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 347   quic_server_info->Start();
 348   rv = quic_server_info->WaitForDataReady(callback.callback());
 349   EXPECT_EQ(OK, callback.GetResult(rv));
 350   EXPECT_TRUE(quic_server_info->IsDataReady());
 351
 352   const QuicServerInfo::State& state1 = quic_server_info->state();
 353   EXPECT_EQ(server_config_a, state1.server_config);
 354   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 355   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 356   EXPECT_EQ(1U, state1.certs.size());
 357   EXPECT_EQ(cert_a, state1.certs[0]);
 358
 359   RemoveMockTransaction(&kHostInfoTransaction1);
 360 }
 361
 362 TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReady) {
 363   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
 364   MockHttpCache cache(factory);
 365   TestCompletionCallback callback;
 366   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 367   scoped_ptr<QuicServerInfo> quic_server_info(
 368       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 369   EXPECT_FALSE(quic_server_info->IsDataReady());
 370   quic_server_info->Start();
 371   int rv = quic_server_info->WaitForDataReady(callback.callback());
 372   EXPECT_EQ(ERR_IO_PENDING, rv);
 373   // Now cancel the callback.
 374   quic_server_info->CancelWaitForDataReadyCallback();
 375   EXPECT_FALSE(quic_server_info->IsDataReady());
 376   // Now complete the backend creation and let the callback run.
 377   factory->FinishCreation();
 378   EXPECT_TRUE(quic_server_info->IsDataReady());
 379 }
 380
 381 TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReadyButDataIsReady) {
 382   MockHttpCache cache;
 383   AddMockTransaction(&kHostInfoTransaction1);
 384   TestCompletionCallback callback;
 385
 386   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 387   scoped_ptr<QuicServerInfo> quic_server_info(
 388       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 389   EXPECT_FALSE(quic_server_info->IsDataReady());
 390   quic_server_info->Start();
 391   int rv = quic_server_info->WaitForDataReady(callback.callback());
 392   quic_server_info->CancelWaitForDataReadyCallback();
 393   EXPECT_EQ(OK, callback.GetResult(rv));
 394   EXPECT_TRUE(quic_server_info->IsDataReady());
 395   RemoveMockTransaction(&kHostInfoTransaction1);
 396 }
 397
 398 // Test Start() followed by Persist() without calling WaitForDataReady.
 399 TEST(DiskCacheBasedQuicServerInfo, StartAndPersist) {
 400   MockHttpCache cache;
 401   AddMockTransaction(&kHostInfoTransaction1);
 402
 403   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 404   scoped_ptr<QuicServerInfo> quic_server_info(
 405       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 406   EXPECT_FALSE(quic_server_info->IsDataReady());
 407   quic_server_info->Start();
 408   // Wait until Start() does the work.
 409   base::MessageLoop::current()->RunUntilIdle();
 410
 411   EXPECT_TRUE(quic_server_info->IsDataReady());
 412
 413   QuicServerInfo::State* state = quic_server_info->mutable_state();
 414   EXPECT_TRUE(state->certs.empty());
 415   const string server_config_a = "server_config_a";
 416   const string source_address_token_a = "source_address_token_a";
 417   const string server_config_sig_a = "server_config_sig_a";
 418   const string cert_a = "cert_a";
 419
 420   state->server_config = server_config_a;
 421   state->source_address_token = source_address_token_a;
 422   state->server_config_sig = server_config_sig_a;
 423   state->certs.push_back(cert_a);
 424   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 425   quic_server_info->Persist();
 426   quic_server_info->OnExternalCacheHit();
 427
 428   // Once we call Persist, IsReadyToPersist should return false until Persist
 429   // has completed.
 430   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 431
 432   // Wait until Persist() does the work.
 433   base::MessageLoop::current()->RunUntilIdle();
 434
 435   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 436
 437   // Verify that the state was updated.
 438   quic_server_info.reset(
 439       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 440   quic_server_info->Start();
 441   TestCompletionCallback callback;
 442   int rv = quic_server_info->WaitForDataReady(callback.callback());
 443   EXPECT_EQ(OK, callback.GetResult(rv));
 444   EXPECT_TRUE(quic_server_info->IsDataReady());
 445
 446   const QuicServerInfo::State& state1 = quic_server_info->state();
 447   EXPECT_EQ(server_config_a, state1.server_config);
 448   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 449   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 450   EXPECT_EQ(1U, state1.certs.size());
 451   EXPECT_EQ(cert_a, state1.certs[0]);
 452
 453   RemoveMockTransaction(&kHostInfoTransaction1);
 454 }
 455
 456 // Test Persisting data when we are not ready to persist and then verify it
 457 // persists the data when Start() finishes.
 458 TEST(DiskCacheBasedQuicServerInfo, PersistWhenNotReadyToPersist) {
 459   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
 460   MockHttpCache cache(factory);
 461   AddMockTransaction(&kHostInfoTransaction1);
 462   TestCompletionCallback callback;
 463
 464   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 465   scoped_ptr<QuicServerInfo> quic_server_info(
 466       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 467   EXPECT_FALSE(quic_server_info->IsDataReady());
 468   // 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.
 470   quic_server_info->Start();
 471   EXPECT_FALSE(quic_server_info->IsDataReady());
 472
 473   // Persist data once, even though the backend is not ready.
 474   QuicServerInfo::State* state = quic_server_info->mutable_state();
 475   EXPECT_TRUE(state->certs.empty());
 476   const string server_config_init = "server_config_init";
 477   const string source_address_token_init = "source_address_token_init";
 478   const string server_config_sig_init = "server_config_sig_init";
 479   const string cert_init = "cert_init";
 480
 481   state->server_config = server_config_init;
 482   state->source_address_token = source_address_token_init;
 483   state->server_config_sig = server_config_sig_init;
 484   state->certs.push_back(cert_init);
 485   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 486   quic_server_info->Persist();
 487   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 488
 489   // Now complete the backend creation and let the callback run.
 490   factory->FinishCreation();
 491   EXPECT_TRUE(quic_server_info->IsDataReady());
 492
 493   // Wait until Persist() does the work.
 494   base::MessageLoop::current()->RunUntilIdle();
 495
 496   // Verify that the state was updated.
 497   quic_server_info.reset(
 498       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 499   quic_server_info->Start();
 500   int rv = quic_server_info->WaitForDataReady(callback.callback());
 501   EXPECT_EQ(OK, callback.GetResult(rv));
 502   EXPECT_TRUE(quic_server_info->IsDataReady());
 503
 504   const QuicServerInfo::State& state1 = quic_server_info->state();
 505   EXPECT_EQ(server_config_init, state1.server_config);
 506   EXPECT_EQ(source_address_token_init, state1.source_address_token);
 507   EXPECT_EQ(server_config_sig_init, state1.server_config_sig);
 508   EXPECT_EQ(1U, state1.certs.size());
 509   EXPECT_EQ(cert_init, state1.certs[0]);
 510   RemoveMockTransaction(&kHostInfoTransaction1);
 511 }
 512
 513 // Test multiple calls to Persist without waiting for the data to be written.
 514 TEST(DiskCacheBasedQuicServerInfo, MultiplePersistsWithoutWaiting) {
 515   MockHttpCache cache;
 516   AddMockTransaction(&kHostInfoTransaction1);
 517   TestCompletionCallback callback;
 518
 519   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 520   scoped_ptr<QuicServerInfo> quic_server_info(
 521       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 522   EXPECT_FALSE(quic_server_info->IsDataReady());
 523   quic_server_info->Start();
 524   int rv = quic_server_info->WaitForDataReady(callback.callback());
 525   EXPECT_EQ(OK, callback.GetResult(rv));
 526   EXPECT_TRUE(quic_server_info->IsDataReady());
 527
 528   // Persist data once.
 529   QuicServerInfo::State* state = quic_server_info->mutable_state();
 530   EXPECT_TRUE(state->certs.empty());
 531   const string server_config_init = "server_config_init";
 532   const string source_address_token_init = "source_address_token_init";
 533   const string server_config_sig_init = "server_config_sig_init";
 534   const string cert_init = "cert_init";
 535
 536   state->server_config = server_config_init;
 537   state->source_address_token = source_address_token_init;
 538   state->server_config_sig = server_config_sig_init;
 539   state->certs.push_back(cert_init);
 540   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 541   quic_server_info->Persist();
 542
 543   // Once we call Persist, IsReadyToPersist should return false until Persist
 544   // has completed.
 545   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 546
 547   // Persist one more time using the same |quic_server_info| object and without
 548   // doing another Start() and WaitForDataReady.
 549   const string server_config_a = "server_config_a";
 550   const string source_address_token_a = "source_address_token_a";
 551   const string server_config_sig_a = "server_config_sig_a";
 552   const string cert_a = "cert_a";
 553
 554   state->server_config = server_config_a;
 555   state->source_address_token = source_address_token_a;
 556   state->server_config_sig = server_config_sig_a;
 557   state->certs.push_back(cert_a);
 558   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 559   quic_server_info->Persist();
 560
 561   // Wait until Persist() does the work.
 562   base::MessageLoop::current()->RunUntilIdle();
 563
 564   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 565
 566   // Verify that the state was updated.
 567   quic_server_info.reset(
 568       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 569   quic_server_info->Start();
 570   rv = quic_server_info->WaitForDataReady(callback.callback());
 571   EXPECT_EQ(OK, callback.GetResult(rv));
 572   EXPECT_TRUE(quic_server_info->IsDataReady());
 573
 574   // Verify the second time persisted data is persisted.
 575   const QuicServerInfo::State& state1 = quic_server_info->state();
 576   EXPECT_EQ(server_config_a, state1.server_config);
 577   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 578   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 579   EXPECT_EQ(1U, state1.certs.size());
 580   EXPECT_EQ(cert_a, state1.certs[0]);
 581
 582   RemoveMockTransaction(&kHostInfoTransaction1);
 583 }
 584
 585 }  // namespace net