Land Recent QUIC changes.

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"
 
@@ skipping 205 matching lines @@
   negotiated_ = true;
   negotiated_tag_ = *received_tags;
   return QUIC_NO_ERROR;
 }
 
 QuicConfig::QuicConfig() :
     congestion_control_(kCGST, QuicNegotiableValue::PRESENCE_REQUIRED),
     idle_connection_state_lifetime_seconds_(
         kICSL, QuicNegotiableValue::PRESENCE_REQUIRED),
     keepalive_timeout_seconds_(kKATO, QuicNegotiableValue::PRESENCE_OPTIONAL),
-    max_streams_per_connection_(kMSPC, QuicNegotiableValue::PRESENCE_REQUIRED) {
+    max_streams_per_connection_(kMSPC, QuicNegotiableValue::PRESENCE_REQUIRED),
+    max_time_before_crypto_handshake_(QuicTime::Delta::Zero()) {
   idle_connection_state_lifetime_seconds_.set(0, 0);
   keepalive_timeout_seconds_.set(0, 0);
 }
 
 QuicConfig::~QuicConfig() {}
 
 void QuicConfig::set_congestion_control(
     const QuicTagVector& congestion_control,
     QuicTag default_congestion_control) {
   congestion_control_.set(congestion_control, default_congestion_control);
@@ skipping 23 matching lines @@
 
 void QuicConfig::set_max_streams_per_connection(size_t max_streams,
                                                 size_t default_streams) {
   max_streams_per_connection_.set(max_streams, default_streams);
 }
 
 uint32 QuicConfig::max_streams_per_connection() 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_;
+}
+
 bool QuicConfig::negotiated() {
   return congestion_control_.negotiated() &&
       idle_connection_state_lifetime_seconds_.negotiated() &&
       keepalive_timeout_seconds_.negotiated() &&
       max_streams_per_connection_.negotiated();
 }
 
 void QuicConfig::SetDefaults() {
   congestion_control_.set(QuicTagVector(1, kQBIC), kQBIC);
   idle_connection_state_lifetime_seconds_.set(kDefaultTimeoutSecs,
-                                              kDefaultTimeoutSecs);
+                                              kDefaultInitialTimeoutSecs);
   // kKATO is optional. Return 0 if not negotiated.
   keepalive_timeout_seconds_.set(0, 0);
   max_streams_per_connection_.set(kDefaultMaxStreamsPerConnection,
                                   kDefaultMaxStreamsPerConnection);
+  max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
+      kDefaultMaxTimeForCryptoHandshakeSecs);
 }
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   congestion_control_.ToHandshakeMessage(out);
   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
   keepalive_timeout_seconds_.ToHandshakeMessage(out);
   max_streams_per_connection_.ToHandshakeMessage(out);
 }
 
 QuicErrorCode QuicConfig::ProcessClientHello(
@@ skipping 39 matching lines @@
   }
   if (error == QUIC_NO_ERROR) {
     error = max_streams_per_connection_.ProcessServerHello(
         server_hello, error_details);
   }
   return error;
 }
 
 }  // namespace net