QUIC - minor cleanup of the following field trials and used defaults for

net/quic/quic_stream_factory_test.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 "net/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 107 matching lines @@
 
   static void DisableConnectionPooling(QuicStreamFactory* factory) {
     factory->disable_connection_pooling_ = true;
   }
 
   static void SetTaskRunner(QuicStreamFactory* factory,
                             base::TaskRunner* task_runner) {
     factory->task_runner_ = task_runner;
   }
 
-  static void SetLoadServerInfoTimeout(QuicStreamFactory* factory,
-                                       size_t load_server_info_timeout) {
-    factory->load_server_info_timeout_ms_ = load_server_info_timeout;
-  }
-
   static void SetEnableConnectionRacing(QuicStreamFactory* factory,
                                         bool enable_connection_racing) {
     factory->enable_connection_racing_ = enable_connection_racing;
   }
 
   static void SetDisableDiskCache(QuicStreamFactory* factory,
                                   bool disable_disk_cache) {
     factory->disable_disk_cache_ = disable_disk_cache;
   }
 
@@ skipping 57 matching lines @@
                  &transport_security_state_,
                  &crypto_client_stream_factory_,
                  &random_generator_,
                  clock_,
                  kDefaultMaxPacketSize,
                  std::string(),
                  SupportedVersions(GetParam().version),
                  /*enable_port_selection=*/true,
                  /*always_require_handshake_confirmation=*/false,
                  /*disable_connection_pooling=*/false,
-                 /*load_server_info_timeout=*/0u,
                  /*load_server_info_timeout_srtt_multiplier=*/0.0f,
-                 /*enable_truncated_connection_ids=*/true,
                  /*enable_connection_racing=*/false,
                  /*enable_non_blocking_io=*/true,
                  /*disable_disk_cache=*/false,
                  /*receive_buffer_size=*/0,
                  QuicTagVector()),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
         is_https_(false),
         privacy_mode_(PRIVACY_MODE_DISABLED) {
     factory_.set_require_confirmation(false);
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
@@ skipping 1383 matching lines @@
     HostPortPair host_port_pair2(r4_host_name, 80);
     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config->LookupOrCreate(server_id2);
     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->source_address_token().empty());
     EXPECT_FALSE(cached2->proof_valid());
   }
 }
 
-TEST_P(QuicStreamFactoryTest, CancelWaitForDataReady) {
-  // Don't race quic connections when testing cancel reading of server config
-  // from disk cache.
-  if (GetParam().enable_connection_racing)
-    return;
-  factory_.set_quic_server_info_factory(&quic_server_info_factory_);
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  const size_t kLoadServerInfoTimeoutMs = 50;
-  QuicStreamFactoryPeer::SetLoadServerInfoTimeout(
-      &factory_, kLoadServerInfoTimeoutMs);
-
-  MockRead reads[] = {
-    MockRead(ASYNC, OK, 0)  // EOF
-  };
-  DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
-  socket_factory_.AddSocketDataProvider(&socket_data);
-  socket_data.StopAfter(1);
-
-  crypto_client_stream_factory_.set_handshake_mode(
-      MockCryptoClientStream::ZERO_RTT);
-  host_resolver_.set_synchronous_mode(true);
-  host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
-                                           "192.168.0.1", "");
-
-  QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
-
-  // Verify that the CancelWaitForDataReady task has been posted.
-  ASSERT_EQ(1u, runner_->GetPostedTasks().size());
-  EXPECT_EQ(base::TimeDelta::FromMilliseconds(kLoadServerInfoTimeoutMs),
-            runner_->GetPostedTasks()[0].delay);
-
-  runner_->RunNextTask();
-  ASSERT_EQ(0u, runner_->GetPostedTasks().size());
-
-  scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
-  EXPECT_TRUE(stream.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-}
-
 TEST_P(QuicStreamFactoryTest, RacingConnections) {
   if (!GetParam().enable_connection_racing)
     return;
   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  const size_t kLoadServerInfoTimeoutMs = 50;
-  QuicStreamFactoryPeer::SetLoadServerInfoTimeout(&factory_,
-                                                  kLoadServerInfoTimeoutMs);
-
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   MockRead reads2[] = {
       MockRead(ASYNC, 0, 0)  // EOF
   };
@@ skipping 21 matching lines @@
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_EQ(0u,
             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
 }
 
 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  const size_t kLoadServerInfoTimeoutMs = 50;
-  QuicStreamFactoryPeer::SetLoadServerInfoTimeout(&factory_,
-                                                  kLoadServerInfoTimeoutMs);
   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   crypto_client_stream_factory_.set_handshake_mode(
@@ skipping 11 matching lines @@
   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net