Change the pre-handshake idle timeout to 5s from 120s, and the default

net/quic/quic_config.cc

 // Copyright (c) 2013 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_config.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 407 matching lines @@
       }
       break;
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicConfig::QuicConfig()
-    : congestion_feedback_(kCGST, PRESENCE_REQUIRED),
+    : max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
+      max_idle_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
+      congestion_feedback_(kCGST, PRESENCE_REQUIRED),
       connection_options_(kCOPT, PRESENCE_OPTIONAL),
       idle_connection_state_lifetime_seconds_(kICSL, PRESENCE_REQUIRED),
       keepalive_timeout_seconds_(kKATO, PRESENCE_OPTIONAL),
       max_streams_per_connection_(kMSPC, PRESENCE_REQUIRED),
-      max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
       initial_congestion_window_(kSWND, PRESENCE_OPTIONAL),
       initial_round_trip_time_us_(kIRTT, PRESENCE_OPTIONAL),
       // TODO(rjshade): Remove this when retiring QUIC_VERSION_19.
       initial_flow_control_window_bytes_(kIFCW, PRESENCE_OPTIONAL),
       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
       // QUIC_VERSION_19.
       initial_stream_flow_control_window_bytes_(kSFCW, PRESENCE_OPTIONAL),
       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
       // QUIC_VERSION_19.
       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
@@ skipping 53 matching lines @@
 
 void QuicConfig::SetMaxStreamsPerConnection(size_t max_streams,
                                             size_t default_streams) {
   max_streams_per_connection_.set(max_streams, default_streams);
 }
 
 uint32 QuicConfig::MaxStreamsPerConnection() const {
   return max_streams_per_connection_.GetUint32();
 }
 
-void QuicConfig::set_max_time_before_crypto_handshake(
-    QuicTime::Delta max_time_before_crypto_handshake) {
-  max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
-}
-
-QuicTime::Delta QuicConfig::max_time_before_crypto_handshake() const {
-  return max_time_before_crypto_handshake_;
-}
-
 void QuicConfig::SetInitialCongestionWindowToSend(size_t initial_window) {
   initial_congestion_window_.SetSendValue(initial_window);
 }
 
 bool QuicConfig::HasReceivedInitialCongestionWindow() const {
   return initial_congestion_window_.HasReceivedValue();
 }
 
 uint32 QuicConfig::ReceivedInitialCongestionWindow() const {
   return initial_congestion_window_.GetReceivedValue();
@@ skipping 94 matching lines @@
 }
 
 bool QuicConfig::HasReceivedSocketReceiveBuffer() const {
   return socket_receive_buffer_.HasReceivedValue();
 }
 
 uint32 QuicConfig::ReceivedSocketReceiveBuffer() const {
   return socket_receive_buffer_.GetReceivedValue();
 }
 
-bool QuicConfig::negotiated() {
+bool QuicConfig::negotiated() const {
   // TODO(ianswett): Add the negotiated parameters once and iterate over all
   // of them in negotiated, ToHandshakeMessage, ProcessClientHello, and
   // ProcessServerHello.
   return congestion_feedback_.negotiated() &&
       idle_connection_state_lifetime_seconds_.negotiated() &&
       keepalive_timeout_seconds_.negotiated() &&
       max_streams_per_connection_.negotiated();
 }
 
 void QuicConfig::SetDefaults() {
   QuicTagVector congestion_feedback;
   congestion_feedback.push_back(kQBIC);
   congestion_feedback_.set(congestion_feedback, kQBIC);
   idle_connection_state_lifetime_seconds_.set(kMaximumIdleTimeoutSecs,
-                                              kDefaultInitialTimeoutSecs);
+                                              kDefaultIdleTimeoutSecs);
   // kKATO is optional. Return 0 if not negotiated.
   keepalive_timeout_seconds_.set(0, 0);
   SetMaxStreamsPerConnection(kDefaultMaxStreamsPerConnection,
                              kDefaultMaxStreamsPerConnection);
-  max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
-      kDefaultMaxTimeForCryptoHandshakeSecs);
+  max_time_before_crypto_handshake_ =
+      QuicTime::Delta::FromSeconds(kMaxTimeForCryptoHandshakeSecs);
+  max_idle_time_before_crypto_handshake_ =
+      QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs);
 
   SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
   SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
   SetInitialSessionFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 }
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   congestion_feedback_.ToHandshakeMessage(out);
   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
   keepalive_timeout_seconds_.ToHandshakeMessage(out);
@@ skipping 55 matching lines @@
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = connection_options_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net