Persist server's crypto config data to disk cache for 0-RTT

net/http/disk_cache_based_quic_server_info_unittest.cc

Index: net/http/disk_cache_based_quic_server_info_unittest.cc
diff --git a/net/http/disk_cache_based_quic_server_info_unittest.cc b/net/http/disk_cache_based_quic_server_info_unittest.cc
index 9d5af3f3414ddbdc15f7fec710f22982efdf70e1..752df73924ef19fd2ab0fe4711c5fe3575d57c26 100644
--- a/net/http/disk_cache_based_quic_server_info_unittest.cc
+++ b/net/http/disk_cache_based_quic_server_info_unittest.cc
@@ -2,12 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "net/http/disk_cache_based_quic_server_info.h"
+
+#include <vector>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/net_errors.h"
-#include "net/http/disk_cache_based_quic_server_info.h"
 #include "net/http/mock_http_cache.h"
 #include "net/quic/crypto/quic_server_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -40,6 +43,14 @@ TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
   scoped_ptr<net::QuicServerInfo> quic_server_info(
       new net::DiskCacheBasedQuicServerInfo("https://www.verisign.com",
                                             cache.http_cache()));
+  string server_config;
+  string source_address_token;
+  std::vector<string> certs;
+  string server_config_sig;
+  net::QuicServerInfo::State* state = quic_server_info->mutable_state();
+  state->SetConfigData(&server_config, &source_address_token, &certs,
+                       &server_config_sig);
+
   quic_server_info->Start();
   net::TestCompletionCallback callback;
   int rv = quic_server_info->WaitForDataReady(callback.callback());
@@ -53,37 +64,63 @@ TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
 TEST(DiskCacheBasedQuicServerInfo, Update) {
   MockHttpCache cache;
   AddMockTransaction(&kHostInfoTransaction);
-  net::TestCompletionCallback callback;
 
   scoped_ptr<net::QuicServerInfo> quic_server_info(
       new net::DiskCacheBasedQuicServerInfo("https://www.google.com",
                                             cache.http_cache()));
+  string server_config;
+  string source_address_token;
+  std::vector<string> certs;
+  string server_config_sig;
+  net::QuicServerInfo::State* state = quic_server_info->mutable_state();
+  state->SetConfigData(&server_config, &source_address_token, &certs,
+                       &server_config_sig);
   quic_server_info->Start();
+  net::TestCompletionCallback callback;
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(net::OK, callback.GetResult(rv));
 
-  net::QuicServerInfo::State* state = quic_server_info->mutable_state();
-  // TODO(rtenneti): Flesh out details of net::QuicServerInfo::State.
-  EXPECT_TRUE(state->data.empty());
-  state->data.push_back(std::string("foo"));
+  EXPECT_TRUE(state->certs->empty());
+  const string server_config_a = "server_config_a";
+  const string source_address_token_a = "source_address_token_a";
+  const string server_config_sig_a = "server_config_sig_a";
+  const string cert_a = "cert_a";
+  const string cert_b = "cert_b";
+
+  server_config = server_config_a;
+  source_address_token = source_address_token_a;
+  server_config_sig = server_config_sig_a;
+  certs.push_back(cert_a);
   quic_server_info->Persist();
 
   // Wait until Persist() does the work.
   base::MessageLoop::current()->RunUntilIdle();
 
-  // Open the stored net::QuicCryptoClientConfig::CachedState.
+  // Open the stored QuicServerInfo.
   quic_server_info.reset(
       new net::DiskCacheBasedQuicServerInfo("https://www.google.com",
                                             cache.http_cache()));
+  state = quic_server_info->mutable_state();
+  string server_config_2;
+  string source_address_token_2;
+  std::vector<string> certs_2;
+  string server_config_sig_2;
+  state->SetConfigData(&server_config_2, &source_address_token_2, &certs_2,
+                       &server_config_sig_2);
   quic_server_info->Start();
   rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(net::OK, callback.GetResult(rv));
 
+  const net::QuicServerInfo::State& state1 = quic_server_info->state();
+  EXPECT_TRUE(quic_server_info->IsDataReady());
+  EXPECT_EQ(server_config_a, *state1.server_config);
+  EXPECT_EQ(source_address_token_a, *state1.source_address_token);
+  EXPECT_EQ(server_config_sig_a, *state1.server_config_sig);
+  EXPECT_EQ(1U, state1.certs->size());
+  EXPECT_EQ(cert_a, (*state1.certs)[0]);
+
   // And now update the data.
-  state = quic_server_info->mutable_state();
-  // TODO(rtenneti): Flesh out details of net::QuicServerInfo::State.
-  // Verify the data after we implement save and restore of the data.
-  state->data.push_back(std::string("bar"));
+  certs_2.push_back(cert_b);
 
   // Fail instead of DCHECKing double creates.
   cache.disk_cache()->set_double_create_check(false);
@@ -94,13 +131,25 @@ TEST(DiskCacheBasedQuicServerInfo, Update) {
   quic_server_info.reset(
       new net::DiskCacheBasedQuicServerInfo("https://www.google.com",
                                             cache.http_cache()));
+  state = quic_server_info->mutable_state();
+  string restored_server_config;
+  string restored_source_address_token;
+  std::vector<string> restored_certs;
+  string restored_server_config_sig;
+  state->SetConfigData(&restored_server_config, &restored_source_address_token,
+                       &restored_certs, &restored_server_config_sig);
   quic_server_info->Start();
   rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_EQ(net::OK, callback.GetResult(rv));
 
-  state = quic_server_info->mutable_state();
-  // TODO(rtenneti): Flesh out details of net::QuicServerInfo::State.
-  // Verify the data after we implement save and restore of the data.
+  const net::QuicServerInfo::State& state2 = quic_server_info->state();
+  EXPECT_TRUE(quic_server_info->IsDataReady());
+  EXPECT_EQ(server_config_a, *state2.server_config);
+  EXPECT_EQ(source_address_token_a, *state2.source_address_token);
+  EXPECT_EQ(server_config_sig_a, *state2.server_config_sig);
+  EXPECT_EQ(2U, state2.certs->size());
+  EXPECT_EQ(cert_a, (*state2.certs)[0]);
+  EXPECT_EQ(cert_b, (*state2.certs)[1]);
 
   RemoveMockTransaction(&kHostInfoTransaction);
 }