Update from https://crrev.com/311076

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_flow_controller.h"
@@ skipping 86 matching lines @@
 };
 
 QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.MaxStreamsPerConnection()),
       next_stream_id_(is_server() ? 2 : 5),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
+      flow_controller_(new QuicFlowController(
+          connection_.get(),
+          0,
+          is_server(),
+          kMinimumFlowControlSendWindow,
+          config_.GetInitialSessionFlowControlWindowToSend(),
+          config_.GetInitialSessionFlowControlWindowToSend())),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
-  if (connection_->version() == QUIC_VERSION_19) {
-    flow_controller_.reset(new QuicFlowController(
-        connection_.get(), 0, is_server(), kMinimumFlowControlSendWindow,
-        config_.GetInitialFlowControlWindowToSend(),
-        config_.GetInitialFlowControlWindowToSend()));
-  } else {
-    flow_controller_.reset(new QuicFlowController(
-        connection_.get(), 0, is_server(), kMinimumFlowControlSendWindow,
-        config_.GetInitialSessionFlowControlWindowToSend(),
-        config_.GetInitialSessionFlowControlWindowToSend()));
-  }
 }
 
 void QuicSession::InitializeSession() {
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
   headers_stream_.reset(new QuicHeadersStream(this));
 }
 
 QuicSession::~QuicSession() {
   STLDeleteElements(&closed_streams_);
@@ skipping 326 matching lines @@
 bool QuicSession::IsEncryptionEstablished() {
   return GetCryptoStream()->encryption_established();
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
-  QuicVersion version = connection()->version();
 
   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.
-      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());
   }
@@ skipping 232 matching lines @@
          connection_->HasQueuedData();
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
-  closed_streams_.clear();
 
   if (connection()->connected() &&
       locally_closed_streams_highest_offset_.size() > max_open_streams_) {
     // A buggy client may fail to send FIN/RSTs. Don't tolerate this.
     connection_->SendConnectionClose(QUIC_TOO_MANY_UNFINISHED_STREAMS);
   }
 }
 
-void QuicSession::OnSuccessfulVersionNegotiation(const QuicVersion& version) {
-  // Disable stream level flow control based on negotiated version. Streams may
-  // have been created with a different version.
-  if (version < QUIC_VERSION_21) {
-    GetCryptoStream()->flow_controller()->Disable();
-    headers_stream_->flow_controller()->Disable();
-  }
-}
-
 bool QuicSession::IsConnectionFlowControlBlocked() const {
   return flow_controller_->IsBlocked();
 }
 
 bool QuicSession::IsStreamFlowControlBlocked() {
   if (headers_stream_->flow_controller()->IsBlocked() ||
       GetCryptoStream()->flow_controller()->IsBlocked()) {
     return true;
   }
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
     if (it->second->flow_controller()->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net