Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

net/quic/core/quic_headers_stream.cc

 // Copyright 2013 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_headers_stream.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 296 matching lines @@
   }
 
   void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                 SpdyFrameType type,
                                 size_t frame_len) override {
     if (stream_->IsConnected()) {
       stream_->OnCompressedFrameSize(frame_len);
     }
   }
 
+  void set_max_uncompressed_header_bytes(
+      size_t set_max_uncompressed_header_bytes) {
+    header_list_.set_max_uncompressed_header_bytes(
+        set_max_uncompressed_header_bytes);
+  }
+
  private:
   void CloseConnection(const string& details) {
     if (stream_->IsConnected()) {
       stream_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                           details);
     }
   }
 
  private:
   QuicHeadersStream* stream_;
@@ skipping 53 matching lines @@
 
   // PUSH_PROMISE must not be the last frame sent out, at least followed by
   // response headers.
   push_promise.set_fin(false);
 
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(push_promise));
   WriteOrBufferData(StringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
-void QuicHeadersStream::WriteDataFrame(
-    QuicStreamId id,
-    StringPiece data,
-    bool fin,
-    QuicAckListenerInterface* ack_notifier_delegate) {
-  SpdyDataIR spdy_data(id, data);
-  spdy_data.set_fin(fin);
-  SpdySerializedFrame frame(spdy_framer_.SerializeFrame(spdy_data));
-  scoped_refptr<ForceHolAckListener> ack_listener;
-  if (ack_notifier_delegate != nullptr) {
-    ack_listener = new ForceHolAckListener(ack_notifier_delegate,
-                                           frame.size() - data.length());
-  }
-  // Use buffered writes so that coherence of framing is preserved
-  // between streams.
-  WriteOrBufferData(StringPiece(frame.data(), frame.size()), false,
-                    ack_listener.get());
-}
-
 QuicConsumedData QuicHeadersStream::WritevStreamData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
   const size_t max_len = kSpdyInitialFrameSizeLimit -
                          SpdyConstants::GetDataFrameMinimumSize(HTTP2);
 
   QuicConsumedData result(0, false);
   size_t total_length = iov.total_length;
 
-  if (!FLAGS_quic_bugfix_fhol_writev_fin_only_v2) {
-    // Encapsulate the data into HTTP/2 DATA frames.  The outer loop
-    // handles each element of the source iov, the inner loop handles
-    // the possibility of fragmenting eacho of those into multiple DATA
-    // frames, as the DATA frames have a max size of 16KB.
-    for (int i = 0; i < iov.iov_count; i++) {
-      size_t offset = 0;
-      const struct iovec* src_iov = &iov.iov[i];
-      do {
-        size_t len = std::min(std::min(src_iov->iov_len - offset, max_len),
-                              total_length);
-        char* data = static_cast<char*>(src_iov->iov_base) + offset;
-        SpdyDataIR spdy_data(id, StringPiece(data, len));
-        offset += len;
-        // fin handling, only set it for the final HTTP/2 DATA frame.
-        bool last_iov = i == iov.iov_count - 1;
-        bool last_fragment_within_iov = offset >= src_iov->iov_len;
-        bool frame_fin = (last_iov && last_fragment_within_iov) ? fin : false;
-        spdy_data.set_fin(frame_fin);
-        if (frame_fin) {
-          result.fin_consumed = true;
-        }
-        SpdySerializedFrame frame(spdy_framer_.SerializeFrame(spdy_data));
-        DVLOG(1) << "Encapsulating in DATA frame for stream " << id << " len "
-                 << len << " fin " << spdy_data.fin() << " remaining "
-                 << src_iov->iov_len - offset;
+  // Encapsulate the data into HTTP/2 DATA frames.  The outer loop
+  // handles each element of the source iov, the inner loop handles
+  // the possibility of fragmenting eacho of those into multiple DATA
+  // frames, as the DATA frames have a max size of 16KB.
+  for (int i = 0; i < iov.iov_count; i++) {
+    size_t offset = 0;
+    const struct iovec* src_iov = &iov.iov[i];
+    do {
+      size_t len =
+          std::min(std::min(src_iov->iov_len - offset, max_len), total_length);
+      char* data = static_cast<char*>(src_iov->iov_base) + offset;
+      SpdyDataIR spdy_data(id, StringPiece(data, len));
+      offset += len;
+      // fin handling, set it only it only very last generated HTTP/2
+      // DATA frame.
+      bool last_iov = i == iov.iov_count - 1;
+      bool last_fragment_within_iov = offset >= src_iov->iov_len;
+      bool frame_fin = (last_iov && last_fragment_within_iov) ? fin : false;
+      spdy_data.set_fin(frame_fin);
+      if (frame_fin) {
+        result.fin_consumed = true;
+      }
+      SpdySerializedFrame frame(spdy_framer_.SerializeFrame(spdy_data));
+      DVLOG(1) << "Encapsulating in DATA frame for stream " << id << " len "
+               << len << " fin " << spdy_data.fin() << " remaining "
+               << src_iov->iov_len - offset;
 
-        scoped_refptr<ForceHolAckListener> ack_listener;
-        if (ack_notifier_delegate != nullptr) {
-          ack_listener = new ForceHolAckListener(ack_notifier_delegate,
-                                                 frame.size() - len);
-        }
+      scoped_refptr<ForceHolAckListener> ack_listener;
+      if (ack_notifier_delegate != nullptr) {
+        ack_listener =
+            new ForceHolAckListener(ack_notifier_delegate, frame.size() - len);
+      }
 
-        WriteOrBufferData(StringPiece(frame.data(), frame.size()), false,
-                          ack_listener.get());
-        result.bytes_consumed += len;
-        total_length -= len;
-        if (total_length <= 0) {
-          return result;
-        }
-      } while (offset < src_iov->iov_len);
-    }
-  } else {
-    if (total_length == 0 && fin) {
-      WriteDataFrame(id, StringPiece(), true, ack_notifier_delegate);
-      result.fin_consumed = true;
-      return result;
-    }
-
-    // Encapsulate the data into HTTP/2 DATA frames.  The outer loop
-    // handles each element of the source iov, the inner loop handles
-    // the possibility of fragmenting each of those into multiple DATA
-    // frames, as the DATA frames have a max size of 16KB.
-    for (int i = 0; i < iov.iov_count; i++) {
-      size_t src_iov_offset = 0;
-      const struct iovec* src_iov = &iov.iov[i];
-      do {
-        if (queued_data_bytes() > 0) {
-          // Limit the amount of buffering to the minimum needed to
-          // preserve framing.
-          return result;
-        }
-        size_t len = std::min(
-            std::min(src_iov->iov_len - src_iov_offset, max_len), total_length);
-        char* data = static_cast<char*>(src_iov->iov_base) + src_iov_offset;
-        src_iov_offset += len;
-        offset += len;
-        // fin handling, only set it for the final HTTP/2 DATA frame.
-        bool last_iov = i == iov.iov_count - 1;
-        bool last_fragment_within_iov = src_iov_offset >= src_iov->iov_len;
-        bool frame_fin = (last_iov && last_fragment_within_iov) ? fin : false;
-        WriteDataFrame(id, StringPiece(data, len), frame_fin,
-                       ack_notifier_delegate);
-        result.bytes_consumed += len;
-        if (frame_fin) {
-          result.fin_consumed = true;
-        }
-        DCHECK_GE(total_length, len);
-        total_length -= len;
-        if (total_length <= 0) {
-          return result;
-        }
-      } while (src_iov_offset < src_iov->iov_len);
-    }
+      WriteOrBufferData(StringPiece(frame.data(), frame.size()), false,
+                        ack_listener.get());
+      result.bytes_consumed += len;
+      total_length -= len;
+      if (total_length <= 0) {
+        return result;
+      }
+    } while (offset < src_iov->iov_len);
   }
-
   return result;
 }
 
 void QuicHeadersStream::OnDataAvailable() {
   char buffer[1024];
   struct iovec iov;
   QuicTime timestamp(QuicTime::Zero());
   while (true) {
     iov.iov_base = buffer;
     iov.iov_len = arraysize(buffer);
     if (!sequencer()->GetReadableRegion(&iov, &timestamp)) {
       // No more data to read.
       break;
     }
     DCHECK(timestamp.IsInitialized());
     cur_max_timestamp_ = std::max(timestamp, cur_max_timestamp_);
     if (spdy_framer_.ProcessInput(static_cast<char*>(iov.iov_base),
                                   iov.iov_len) != iov.iov_len) {
       // Error processing data.
       return;
     }
     sequencer()->MarkConsumed(iov.iov_len);
   }
 }
 
+void QuicHeadersStream::set_max_uncompressed_header_bytes(
+    size_t set_max_uncompressed_header_bytes) {
+  spdy_framer_visitor_->set_max_uncompressed_header_bytes(
+      set_max_uncompressed_header_bytes);
+}
+
 void QuicHeadersStream::OnHeaders(SpdyStreamId stream_id,
                                   bool has_priority,
                                   SpdyPriority priority,
                                   bool fin) {
   if (has_priority) {
     if (session()->perspective() == Perspective::IS_CLIENT) {
       CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                  "Server must not send priorities.");
       return;
     }
@@ skipping 164 matching lines @@
     return true;
   }
   frame_len_ -= len;
   // Ignore fin_ while there is more data coming, if frame_len_ > 0.
   spdy_session_->OnStreamFrameData(stream_id, data, len,
                                    frame_len_ > 0 ? false : fin_);
   return true;
 }
 
 }  // namespace net