Land Recent QUIC Changes.

net/quic/quic_stream_sequencer.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_stream_sequencer.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 12 matching lines @@
       close_offset_(numeric_limits<QuicStreamOffset>::max()),
       blocked_(false),
       num_bytes_buffered_(0),
       num_frames_received_(0),
       num_duplicate_frames_received_(0) {
 }
 
 QuicStreamSequencer::~QuicStreamSequencer() {
 }
 
-bool QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
+void QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
   ++num_frames_received_;
   if (IsDuplicate(frame)) {
     ++num_duplicate_frames_received_;
     // Silently ignore duplicates.
-    return true;
+    return;
   }
 
   if (FrameOverlapsBufferedData(frame)) {
     stream_->CloseConnectionWithDetails(
         QUIC_INVALID_STREAM_FRAME, "Stream frame overlaps with buffered data.");
-    return false;
+    return;
   }
 
   QuicStreamOffset byte_offset = frame.offset;
   size_t data_len = frame.data.TotalBufferSize();
   if (data_len == 0 && !frame.fin) {
     // Stream frames must have data or a fin flag.
     stream_->CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME,
                                         "Empty stream frame without FIN set.");
-    return false;
+    return;
   }
 
   if (frame.fin) {
     CloseStreamAtOffset(frame.offset + data_len);
     if (data_len == 0) {
-      return true;
+      return;
     }
   }
 
   IOVector data;
   data.AppendIovec(frame.data.iovec(), frame.data.Size());
 
   // If the frame has arrived in-order then we can process it immediately, only
   // buffering if the stream is unable to process it.
   if (!blocked_ && byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
     size_t bytes_consumed = 0;
     for (size_t i = 0; i < data.Size(); ++i) {
       bytes_consumed += stream_->ProcessRawData(
           static_cast<char*>(data.iovec()[i].iov_base),
           data.iovec()[i].iov_len);
     }
     num_bytes_consumed_ += bytes_consumed;
     stream_->AddBytesConsumed(bytes_consumed);
 
     if (MaybeCloseStream()) {
-      return true;
+      return;
     }
     if (bytes_consumed > data_len) {
       stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);
-      return false;
+      return;
     } else if (bytes_consumed == data_len) {
       FlushBufferedFrames();
-      return true;  // it's safe to ack this frame.
+      return;  // it's safe to ack this frame.
     } else {
       // Set ourselves up to buffer what's left.
       data_len -= bytes_consumed;
       data.Consume(bytes_consumed);
       byte_offset += bytes_consumed;
     }
   }
 
   // Buffer any remaining data to be consumed by the stream when ready.
   for (size_t i = 0; i < data.Size(); ++i) {
     DVLOG(1) << "Buffering stream data at offset " << byte_offset;
     const iovec& iov = data.iovec()[i];
     buffered_frames_.insert(make_pair(
         byte_offset, string(static_cast<char*>(iov.iov_base), iov.iov_len)));
     byte_offset += iov.iov_len;
     num_bytes_buffered_ += iov.iov_len;
   }
-  return true;
+  return;
 }
 
 void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset) {
   const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
 
   // If we have a scheduled termination or close, any new offset should match
   // it.
   if (close_offset_ != kMaxOffset && offset != close_offset_) {
     stream_->Reset(QUIC_MULTIPLE_TERMINATION_OFFSETS);
     return;
@@ skipping 169 matching lines @@
 }
 
 void QuicStreamSequencer::RecordBytesConsumed(size_t bytes_consumed) {
   num_bytes_consumed_ += bytes_consumed;
   num_bytes_buffered_ -= bytes_consumed;
 
   stream_->AddBytesConsumed(bytes_consumed);
 }
 
 }  // namespace net