Landing Recent QUIC Changes.

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 93 matching lines @@
     : 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),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
-  if (connection_->version() <= QUIC_VERSION_19) {
+  if (connection_->version() == QUIC_VERSION_19) {
     flow_controller_.reset(new QuicFlowController(
         connection_.get(), 0, is_server(), kDefaultFlowControlSendWindow,
         config_.GetInitialFlowControlWindowToSend(),
         config_.GetInitialFlowControlWindowToSend()));
   } else {
     flow_controller_.reset(new QuicFlowController(
         connection_.get(), 0, is_server(), kDefaultFlowControlSendWindow,
         config_.GetInitialSessionFlowControlWindowToSend(),
         config_.GetInitialSessionFlowControlWindowToSend()));
   }
@@ skipping 355 matching lines @@
       // 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_17,18,19 don't support independent stream/session flow
+  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();
       OnNewStreamFlowControlWindow(new_window);
       OnNewSessionFlowControlWindow(new_window);
     }
 
     return;
@@ skipping 206 matching lines @@
     return false;
   }
   if (id % 2 == next_stream_id_ % 2) {
     // Locally created streams are strictly in-order.  If the id is in the
     // range of created streams and it's not active, it must have been closed.
     return id < next_stream_id_;
   }
   // For peer created streams, we also need to consider implicitly created
   // streams.
   return id <= largest_peer_created_stream_id_ &&
-      implicitly_created_streams_.count(id) == 0;
+      !ContainsKey(implicitly_created_streams_, id);
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
   return stream_map_.size() + implicitly_created_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != nullptr) {
@@ skipping 34 matching lines @@
 
   if (FLAGS_close_quic_connection_unfinished_streams_2 &&
       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) {
-  if (version < QUIC_VERSION_19) {
-    flow_controller_->Disable();
-  }
-
   // 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