Introduce QUIC_VERSION_20: allowing endpoints to set different

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
 #include "net/quic/quic_write_blocked_list.h"
 
 using base::StringPiece;
 using std::min;
 
 namespace net {
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 namespace {
 
 struct iovec MakeIovec(StringPiece data) {
   struct iovec iov = {const_cast<char*>(data.data()),
                       static_cast<size_t>(data.size())};
   return iov;
 }
 
+size_t GetInitialStreamFlowControlWindowToSend(QuicSession* session) {
+  QuicVersion version = session->connection()->version();
+  if (version <= QUIC_VERSION_19) {
+    return session->config()->GetInitialFlowControlWindowToSend();
+  }
+
+  return session->config()->GetInitialStreamFlowControlWindowToSend();
+}
+
+size_t GetReceivedFlowControlWindow(QuicSession* session) {
+  QuicVersion version = session->connection()->version();
+  if (version <= QUIC_VERSION_19) {
+    if (session->config()->HasReceivedInitialFlowControlWindowBytes()) {
+      return session->config()->ReceivedInitialFlowControlWindowBytes();
+    }
+
+    return kDefaultFlowControlSendWindow;
+  }
+
+  // Version must be >= QUIC_VERSION_20, so we check for stream specific flow
+  // control window.
+  if (session->config()->HasReceivedInitialStreamFlowControlWindowBytes()) {
+    return session->config()->ReceivedInitialStreamFlowControlWindowBytes();
+  }
+
+  return kDefaultFlowControlSendWindow;
+}
+
 }  // namespace
 
 // Wrapper that aggregates OnAckNotifications for packets sent using
 // WriteOrBufferData and delivers them to the original
 // QuicAckNotifier::DelegateInterface after all bytes written using
 // WriteOrBufferData are acked.  This level of indirection is
 // necessary because the delegate interface provides no mechanism that
 // WriteOrBufferData can use to inform it that the write required
 // multiple WritevData calls or that only part of the data has been
 // sent out by the time ACKs start arriving.
@@ skipping 82 matching lines @@
       read_side_closed_(false),
       write_side_closed_(false),
       fin_buffered_(false),
       fin_sent_(false),
       fin_received_(false),
       rst_sent_(false),
       rst_received_(false),
       fec_policy_(FEC_PROTECT_OPTIONAL),
       is_server_(session_->is_server()),
       flow_controller_(
-          session_->connection(),
-          id_,
-          is_server_,
-          session_->config()->HasReceivedInitialFlowControlWindowBytes() ?
-              session_->config()->ReceivedInitialFlowControlWindowBytes() :
-              kDefaultFlowControlSendWindow,
-          session_->config()->GetInitialFlowControlWindowToSend(),
-          session_->config()->GetInitialFlowControlWindowToSend()),
+          session_->connection(), id_, is_server_,
+          GetReceivedFlowControlWindow(session),
+          GetInitialStreamFlowControlWindowToSend(session),
+          GetInitialStreamFlowControlWindowToSend(session)),
       connection_flow_controller_(session_->flow_controller()) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
 bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (read_side_closed_) {
     DVLOG(1) << ENDPOINT << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
@@ skipping 344 matching lines @@
     connection_flow_controller_->AddBytesConsumed(bytes);
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   return flow_controller_.IsBlocked() ||
          connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net