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