Remove the code to store and load QUIC server configs in the disk cache.

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 7850 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 /* is_main_cache */);
-
-  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 3047 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