Landing recent QUIC changes until 6/24/2016 14:00 UTC

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 "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/crypto/proof_verifier.h"
@@ skipping 13 matching lines @@
 using net::SpdyPriority;
 
 namespace net {
 
 #define ENDPOINT \
   (perspective() == Perspective::IS_SERVER ? "Server: " : " Client: ")
 
 QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       config_(config),
-      max_open_outgoing_streams_(config_.MaxStreamsPerConnection()),
-      max_open_incoming_streams_(config_.MaxStreamsPerConnection()),
+      max_open_outgoing_streams_(kDefaultMaxStreamsPerConnection),
+      max_open_incoming_streams_(config_.GetMaxIncomingDynamicStreamsToSend()),
       next_outgoing_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 3),
       largest_peer_created_stream_id_(
           perspective() == Perspective::IS_SERVER ? 1 : 0),
       num_dynamic_incoming_streams_(0),
       num_draining_incoming_streams_(0),
       num_locally_closed_incoming_streams_highest_offset_(0),
       error_(QUIC_NO_ERROR),
       flow_controller_(connection_.get(),
                        0,
                        perspective(),
@@ skipping 338 matching lines @@
   return GetCryptoStream()->encryption_established();
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
 
-  uint32_t max_streams = config_.MaxStreamsPerConnection();
+  const QuicVersion version = connection()->version();
+  uint32_t max_streams = 0;
+  if (version > QUIC_VERSION_34 &&
+      config_.HasReceivedMaxIncomingDynamicStreams()) {
+    max_streams = config_.ReceivedMaxIncomingDynamicStreams();
+  } else {
+    max_streams = config_.MaxStreamsPerConnection();
+  }
+  set_max_open_outgoing_streams(max_streams);
   if (!FLAGS_quic_enable_autotune_by_default &&
       perspective() == Perspective::IS_SERVER) {
     if (config_.HasReceivedConnectionOptions()) {
       if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kAFCW)) {
         // The following variations change the initial receive flow control
         // window sizes.
         if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW5)) {
           AdjustInitialFlowControlWindows(32 * 1024);
         }
         if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW6)) {
           AdjustInitialFlowControlWindows(64 * 1024);
         }
         if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW7)) {
           AdjustInitialFlowControlWindows(128 * 1024);
         }
         EnableAutoTuneReceiveWindow();
       }
     }
   }
 
-  set_max_open_outgoing_streams(max_streams);
-
-  // A small number of additional incoming streams beyond the limit should be
-  // allowed. This helps avoid early connection termination when FIN/RSTs for
-  // old streams are lost or arrive out of order.
-  // Use a minimum number of additional streams, or a percentage increase,
-  // whichever is larger.
-  uint32_t max_incoming_streams =
-      max(max_streams + kMaxStreamsMinimumIncrement,
-          static_cast<uint32_t>(max_streams * kMaxStreamsMultiplier));
-  set_max_open_incoming_streams(max_incoming_streams);
+  if (version <= QUIC_VERSION_34) {
+    // A small number of additional incoming streams beyond the limit should be
+    // allowed. This helps avoid early connection termination when FIN/RSTs for
+    // old streams are lost or arrive out of order.
+    // Use a minimum number of additional streams, or a percentage increase,
+    // whichever is larger.
+    uint32_t max_incoming_streams =
+        max(max_streams + kMaxStreamsMinimumIncrement,
+            static_cast<uint32_t>(max_streams * kMaxStreamsMultiplier));
+    set_max_open_incoming_streams(max_incoming_streams);
+  } else {
+    uint32_t max_incoming_streams_to_send =
+        config_.GetMaxIncomingDynamicStreamsToSend();
+    uint32_t max_incoming_streams =
+        max(max_incoming_streams_to_send + kMaxStreamsMinimumIncrement,
+            static_cast<uint32_t>(max_incoming_streams_to_send *
+                                  kMaxStreamsMultiplier));
+    set_max_open_incoming_streams(max_incoming_streams);
+  }
 
   if (config_.HasReceivedInitialStreamFlowControlWindowBytes()) {
     // Streams which were created before the SHLO was received (0-RTT
     // requests) are now informed of the peer's initial flow control window.
     OnNewStreamFlowControlWindow(
         config_.ReceivedInitialStreamFlowControlWindowBytes());
   }
   if (config_.HasReceivedInitialSessionFlowControlWindowBytes()) {
     OnNewSessionFlowControlWindow(
         config_.ReceivedInitialSessionFlowControlWindowBytes());
@@ skipping 381 matching lines @@
 
 size_t QuicSession::MaxAvailableStreams() const {
   return max_open_incoming_streams_ * kMaxAvailableStreamsMultiplier;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net