Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

net/quic/core/quic_spdy_session.cc

 // Copyright (c) 2015 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/core/quic_spdy_session.h"
 
 #include <utility>
 
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_headers_stream.h"
@@ skipping 103 matching lines @@
 
 void QuicSpdySession::OnConfigNegotiated() {
   QuicSession::OnConfigNegotiated();
   if (config()->HasClientSentConnectionOption(kDHDT, perspective())) {
     headers_stream_->DisableHpackDynamicTable();
   }
   const QuicVersion version = connection()->version();
   if (FLAGS_quic_enable_force_hol_blocking && version > QUIC_VERSION_35 &&
       config()->ForceHolBlocking(perspective())) {
     force_hol_blocking_ = true;
-    // Autotuning makes sure that the headers stream flow control does
-    // not get in the way, and normal stream and connection level flow
-    // control are active anyway. This is really only for the client
-    // side (and mainly there just in tests and toys), where
-    // autotuning and/or large buffers are not enabled by default.
-    headers_stream_->flow_controller()->set_auto_tune_receive_window(true);
+    if (!FLAGS_quic_bugfix_fhol_writev_fin_only_v2) {
+      // Autotuning makes sure that the headers stream flow control does
+      // not get in the way, and normal stream and connection level flow
+      // control are active anyway. This is really only for the client
+      // side (and mainly there just in tests and toys), where
+      // autotuning and/or large buffers are not enabled by default.
+      headers_stream_->flow_controller()->set_auto_tune_receive_window(true);
+    } else {
+      // Since all streams are tunneled through the headers stream, it
+      // is important that headers stream never flow control blocks.
+      // Otherwise, busy-loop behaviour can ensue where data streams
+      // data try repeatedly to write data not realizing that the
+      // tunnel through the headers stream is blocked.
+      headers_stream_->flow_controller()->UpdateReceiveWindowSize(
+          kStreamReceiveWindowLimit);
+      headers_stream_->flow_controller()->UpdateSendWindowOffset(
+          kStreamReceiveWindowLimit);
+    }
   }
 
   if (version > QUIC_VERSION_34) {
     server_push_enabled_ = FLAGS_quic_enable_server_push_by_default;
   }
 }
 
 void QuicSpdySession::OnStreamFrameData(QuicStreamId stream_id,
                                         const char* data,
                                         size_t len,
                                         bool fin) {
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (stream == nullptr) {
     return;
   }
   const QuicStreamOffset offset =
       stream->flow_controller()->highest_received_byte_offset();
   const QuicStreamFrame frame(stream_id, fin, offset, StringPiece(data, len));
   DVLOG(1) << "De-encapsulating DATA frame for stream " << stream_id
            << " offset " << offset << " len " << len << " fin " << fin;
   OnStreamFrame(frame);
 }
 
 bool QuicSpdySession::ShouldReleaseHeadersStreamSequencerBuffer() {
   return false;
 }
 
 }  // namespace net