Add an URLRequestTest to test the quic server info factory setup at the creation of HttpCache.

net/url_request/url_request_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ skipping 37 matching lines @@
 #include "base/values.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/directory_listing.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_module.h"
 #include "net/base/request_priority.h"
+#include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/base/url_util.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/ct_policy_status.h"
 #include "net/cert/do_nothing_ct_verifier.h"
 #include "net/cert/ev_root_ca_metadata.h"
 #include "net/cert/mock_cert_verifier.h"
+#include "net/cert/multi_log_ct_verifier.h"
 #include "net/cert/signed_certificate_timestamp_and_status.h"
 #include "net/cert/test_root_certs.h"
 #include "net/cert_net/nss_ocsp.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store_test_helpers.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
+#include "net/http/http_server_properties_impl.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/net_features.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
+#include "net/quic/chromium/mock_crypto_client_stream_factory.h"
+#include "net/quic/chromium/quic_server_info.h"
+#include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/ssl/token_binding.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
@@ skipping 7620 matching lines @@
   RequestPriority job_priority;
   std::unique_ptr<URLRequestJob> job(new PriorityMonitoringURLRequestJob(
       req.get(), &default_network_delegate_, &job_priority));
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   // Should trigger |job| to be started.
   base::RunLoop().Run();
   EXPECT_EQ(LOW, job_priority);
 }
 
+TEST_F(URLRequestTest, QuicServerInfoFactoryTest) {
+  HttpNetworkSession::Params params;
+
+  MockClientSocketFactory socket_factory;
+  MockCryptoClientStreamFactory crypto_client_stream_factory;
+  MockHostResolver host_resolver;
+  MockCertVerifier cert_verifier;
+  CTPolicyEnforcer ct_policy_enforcer;
+  TransportSecurityState transport_security_state;
+  std::unique_ptr<CTVerifier> cert_transparency_verifier(
+      new MultiLogCTVerifier());
+  std::unique_ptr<ProxyService> proxy_service = ProxyService::CreateDirect();
+  scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
+      new SSLConfigServiceDefaults);
+  HttpServerPropertiesImpl http_server_properties;
+  // Set up the quic stream factory.
+  params.enable_quic = true;
+  params.client_socket_factory = &socket_factory;
+  params.quic_crypto_client_stream_factory = &crypto_client_stream_factory;
+  params.host_resolver = &host_resolver;
+  params.cert_verifier = &cert_verifier;
+  params.ct_policy_enforcer = &ct_policy_enforcer;
+  params.transport_security_state = &transport_security_state;
+  params.cert_transparency_verifier = cert_transparency_verifier.get();
+
+  params.proxy_service = proxy_service.get();
+  params.ssl_config_service = ssl_config_service.get();
+  params.http_server_properties = &http_server_properties;
+
+  HttpNetworkSession session(params);
+  DCHECK(session.quic_stream_factory());
+
+  std::unique_ptr<HttpNetworkLayer> network_layer1(
+      new HttpNetworkLayer(&session));
+
+  HttpCache main_cache(std::move(network_layer1),
+                       HttpCache::DefaultBackend::InMemory(0), true);
+
+  EXPECT_TRUE(session.quic_stream_factory()->has_quic_server_info_factory());
+
+  default_context_.set_http_transaction_factory(&main_cache);
+
+  QuicServerInfoFactory* quic_server_info_factory =
+      session.quic_stream_factory()->quic_server_info_factory();
+  DCHECK(quic_server_info_factory);
+
+  QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
+  const string server_config_a = "server_config_a";
+  const string source_address_token_a = "source_address_token_a";
+  const string cert_sct_a = "cert_sct_a";
+  const string chlo_hash_a = "chlo_hash_a";
+  const string server_config_sig_a = "server_config_sig_a";
+  const string cert_a = "cert_a";
+  const string cert_b = "cert_b";
+
+  {
+    // Store a QuicServerInfo to the quic server info factory.
+    TestCompletionCallback cb;
+    std::unique_ptr<QuicServerInfo> quic_server_info =
+        quic_server_info_factory->GetForServer(server_id);
+    quic_server_info->Start();
+    int rv = quic_server_info->WaitForDataReady(cb.callback());
+    EXPECT_THAT(cb.GetResult(rv), IsOk());
+
+    QuicServerInfo::State* state = quic_server_info->mutable_state();
+    EXPECT_TRUE(state->certs.empty());
+
+    state->server_config = server_config_a;
+    state->source_address_token = source_address_token_a;
+    state->cert_sct = cert_sct_a;
+    state->chlo_hash = chlo_hash_a;
+    state->server_config_sig = server_config_sig_a;
+    state->certs.push_back(cert_a);
+    quic_server_info->Persist();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  // Retrieve the QuicServerInfo from the quic server info factory and verify
+  // the data is correct.
+  {
+    TestCompletionCallback cb;
+    std::unique_ptr<QuicServerInfo> quic_server_info =
+        quic_server_info_factory->GetForServer(server_id);
+    quic_server_info->Start();
+    int rv = quic_server_info->WaitForDataReady(cb.callback());
+    EXPECT_THAT(cb.GetResult(rv), IsOk());
+
+    QuicServerInfo::State* state = quic_server_info->mutable_state();
+    EXPECT_TRUE(quic_server_info->IsDataReady());
+    EXPECT_EQ(server_config_a, state->server_config);
+    EXPECT_EQ(source_address_token_a, state->source_address_token);
+    EXPECT_EQ(cert_sct_a, state->cert_sct);
+    EXPECT_EQ(chlo_hash_a, state->chlo_hash);
+    EXPECT_EQ(server_config_sig_a, state->server_config_sig);
+    EXPECT_EQ(1U, state->certs.size());
+    EXPECT_EQ(cert_a, state->certs[0]);
+
+    // Update the data.
+    state->certs.push_back(cert_b);
+    quic_server_info->Persist();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  {
+    // Verify data has been successfully updated.
+    TestCompletionCallback cb;
+    std::unique_ptr<QuicServerInfo> quic_server_info =
+        quic_server_info_factory->GetForServer(server_id);
+    quic_server_info->Start();
+    int rv = quic_server_info->WaitForDataReady(cb.callback());
+    EXPECT_THAT(cb.GetResult(rv), IsOk());
+
+    QuicServerInfo::State* state = quic_server_info->mutable_state();
+    EXPECT_TRUE(quic_server_info->IsDataReady());
+    EXPECT_EQ(2U, state->certs.size());
+    EXPECT_EQ(cert_a, state->certs[0]);
+    EXPECT_EQ(cert_b, state->certs[1]);
+  }
+}
+
 // Check that creating a network request while entering/exiting suspend mode
 // fails as it should.  This is the only case where an HttpTransactionFactory
 // does not return an HttpTransaction.
 TEST_F(URLRequestTestHTTP, NetworkSuspendTest) {
   // Create a new HttpNetworkLayer that thinks it's suspended.
   std::unique_ptr<HttpNetworkLayer> network_layer(new HttpNetworkLayer(
       default_context_.http_transaction_factory()->GetSession()));
   network_layer->OnSuspend();
 
   HttpCache http_cache(std::move(network_layer),
@@ skipping 3000 matching lines @@
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ERR_ABORTED, d.request_status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net