Update from https://crrev.com/306655

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"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_headers_stream.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::max;
 using std::vector;
@@ skipping 410 matching lines @@
 void QuicSession::UpdateFlowControlOnFinalReceivedByteOffset(
     QuicStreamId stream_id, QuicStreamOffset final_byte_offset) {
   map<QuicStreamId, QuicStreamOffset>::iterator it =
       locally_closed_streams_highest_offset_.find(stream_id);
   if (it == locally_closed_streams_highest_offset_.end()) {
     return;
   }
 
   DVLOG(1) << ENDPOINT << "Received final byte offset " << final_byte_offset
            << " for stream " << stream_id;
-  uint64 offset_diff = final_byte_offset - it->second;
+  QuicByteCount offset_diff = final_byte_offset - it->second;
   if (flow_controller_->UpdateHighestReceivedOffset(
       flow_controller_->highest_received_byte_offset() + offset_diff)) {
     // If the final offset violates flow control, close the connection now.
     if (flow_controller_->FlowControlViolation()) {
       connection_->SendConnectionClose(
           QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
       return;
     }
   }
 
   flow_controller_->AddBytesConsumed(offset_diff);
   locally_closed_streams_highest_offset_.erase(it);
 }
 
 bool QuicSession::IsEncryptionEstablished() {
   return GetCryptoStream()->encryption_established();
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
   QuicVersion version = connection()->version();
 
-  if (FLAGS_quic_allow_more_open_streams) {
-    uint32 max_streams = config_.MaxStreamsPerConnection();
-    if (is_server()) {
-      // 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.
-      // Use a minimum number of additional streams, or a percentage increase,
-      // whichever is larger.
-      max_streams =
-          max(max_streams + kMaxStreamsMinimumIncrement,
-              static_cast<uint32>(max_streams * kMaxStreamsMultiplier));
-    }
-    set_max_open_streams(max_streams);
+  uint32 max_streams = config_.MaxStreamsPerConnection();
+  if (is_server()) {
+    // 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.
+    // Use a minimum number of additional streams, or a percentage increase,
+    // whichever is larger.
+    max_streams =
+        max(max_streams + kMaxStreamsMinimumIncrement,
+            static_cast<uint32>(max_streams * kMaxStreamsMultiplier));
   }
+  set_max_open_streams(max_streams);
 
   if (version == QUIC_VERSION_19) {
     // QUIC_VERSION_19 doesn'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.
-      uint32 new_window = config_.ReceivedInitialFlowControlWindowBytes();
+      QuicStreamOffset new_window =
+          config_.ReceivedInitialFlowControlWindowBytes();
       OnNewStreamFlowControlWindow(new_window);
       OnNewSessionFlowControlWindow(new_window);
     }
 
     return;
   }
 
   // QUIC_VERSION_21 and higher can have independent stream and session flow
   // control windows.
   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());
   }
 }
 
-void QuicSession::OnNewStreamFlowControlWindow(uint32 new_window) {
+void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kDefaultFlowControlSendWindow) {
     LOG(ERROR)
         << "Peer sent us an invalid stream flow control send window: "
         << new_window << ", below default: " << kDefaultFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
 
   // Inform all existing streams about the new window.
   if (connection_->version() >= QUIC_VERSION_21) {
     GetCryptoStream()->UpdateSendWindowOffset(new_window);
     headers_stream_->UpdateSendWindowOffset(new_window);
   }
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     it->second->UpdateSendWindowOffset(new_window);
   }
 }
 
-void QuicSession::OnNewSessionFlowControlWindow(uint32 new_window) {
+void QuicSession::OnNewSessionFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kDefaultFlowControlSendWindow) {
     LOG(ERROR)
         << "Peer sent us an invalid session flow control send window: "
         << new_window << ", below default: " << kDefaultFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
 
@@ skipping 12 matching lines @@
       // decrypted by the peer.
       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();
-      if (!FLAGS_quic_allow_more_open_streams) {
-        max_open_streams_ = config_.MaxStreamsPerConnection();
-      }
       break;
 
     default:
       LOG(ERROR) << ENDPOINT << "Got unknown handshake event: " << event;
   }
 }
 
 void QuicSession::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
 }
@@ skipping 202 matching lines @@
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     if (it->second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net