Allow number of open QUIC streams to grow 10% beyond configured limit at

net/quic/quic_session.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_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
@@ skipping 458 matching lines @@
   return GetCryptoStream()->encryption_established();
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
   QuicVersion version = connection()->version();
+
+  // A server should accept a small number of additional streams beyond the
+  // limit sent to the client. This helps avoid early connection termination
+  // when FIN/RSTs for old streams are lost or arrive out of order.
+  if (FLAGS_quic_allow_more_open_streams) {
+    set_max_open_streams((is_server() ? kMaxStreamsMultiplier : 1.0) *
+                         config_.max_streams_per_connection());
+  }
+
   if (version <= QUIC_VERSION_16) {
     return;
   }
 
   if (version <= QUIC_VERSION_19) {
     // QUIC_VERSION_17,18,19 don't support independent stream/session flow
     // control windows.
     if (config_.HasReceivedInitialFlowControlWindowBytes()) {
       // Streams which were created before the SHLO was received (0-RTT
       // requests) are now informed of the peer's initial flow control window.
@@ skipping 68 matching lines @@
       connection_->RetransmitUnackedPackets(ALL_INITIAL_RETRANSMISSION);
       break;
 
     case HANDSHAKE_CONFIRMED:
       LOG_IF(DFATAL, !config_.negotiated()) << ENDPOINT
           << "Handshake confirmed without parameter negotiation.";
       // Discard originally encrypted packets, since they can't be decrypted by
       // the peer.
       connection_->NeuterUnencryptedPackets();
       connection_->SetOverallConnectionTimeout(QuicTime::Delta::Infinite());
-      max_open_streams_ = config_.max_streams_per_connection();
+      if (!FLAGS_quic_allow_more_open_streams) {
+        max_open_streams_ = config_.max_streams_per_connection();
+      }
       break;
 
     default:
       LOG(ERROR) << ENDPOINT << "Got unknown handshake event: " << event;
   }
 }
 
 void QuicSession::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
 }
@@ skipping 94 matching lines @@
     largest_peer_created_stream_id_ = stream_id;
   }
   QuicDataStream* stream = CreateIncomingDataStream(stream_id);
   if (stream == NULL) {
     return NULL;
   }
   ActivateStream(stream);
   return stream;
 }
 
+void QuicSession::set_max_open_streams(size_t max_open_streams) {
+  DVLOG(1) << "Setting max_open_streams_ to " << max_open_streams;
+  max_open_streams_ = max_open_streams;
+}
+
 bool QuicSession::IsClosedStream(QuicStreamId id) {
   DCHECK_NE(0u, id);
   if (id == kCryptoStreamId) {
     return false;
   }
   if (id == kHeadersStreamId) {
     return false;
   }
   if (ContainsKey(stream_map_, id)) {
     // Stream is active
@@ skipping 67 matching lines @@
   }
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     if (version <= QUIC_VERSION_16) {
       it->second->flow_controller()->Disable();
     }
   }
 }
 
 }  // namespace net