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"
 #include "net/quic/reliable_quic_stream.h"
 
 using std::min;
 using std::numeric_limits;
 
 namespace net {
 
 QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream)
     : stream_(quic_stream),
       num_bytes_consumed_(0),
       max_frame_memory_(numeric_limits<size_t>::max()),
-      close_offset_(numeric_limits<QuicStreamOffset>::max()),
-      half_close_(true) {
+      close_offset_(numeric_limits<QuicStreamOffset>::max()) {
 }
 
 QuicStreamSequencer::QuicStreamSequencer(size_t max_frame_memory,
                                          ReliableQuicStream* quic_stream)
     : stream_(quic_stream),
       num_bytes_consumed_(0),
       max_frame_memory_(max_frame_memory),
-      close_offset_(numeric_limits<QuicStreamOffset>::max()),
-      half_close_(true) {
+      close_offset_(numeric_limits<QuicStreamOffset>::max()) {
   if (max_frame_memory < kMaxPacketSize) {
     LOG(DFATAL) << "Setting max frame memory to " << max_frame_memory
                 << ".  Some frames will be impossible to handle.";
   }
 }
 
 QuicStreamSequencer::~QuicStreamSequencer() {
 }
 
 bool QuicStreamSequencer::WillAcceptStreamFrame(
@@ skipping 56 matching lines @@
       data_len -= bytes_consumed;
       data += bytes_consumed;
       byte_offset += bytes_consumed;
     }
   }
   DVLOG(1) << "Buffering packet at offset " << byte_offset;
   frames_.insert(make_pair(byte_offset, string(data, data_len)));
   return true;
 }
 
-void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset,
-                                              bool half_close) {
+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_->Close(QUIC_MULTIPLE_TERMINATION_OFFSETS);
-      return;
+    stream_->Close(QUIC_MULTIPLE_TERMINATION_OFFSETS);
+    return;
   }
 
   close_offset_ = offset;
-  // Full close overrides half close.
-  if (half_close == false) {
-    half_close_ = false;
-  }
 
   MaybeCloseStream();
 }
 
 bool QuicStreamSequencer::MaybeCloseStream() {
   if (IsHalfClosed()) {
     DVLOG(1) << "Passing up termination, as we've processed "
              << num_bytes_consumed_ << " of " << close_offset_
              << " bytes.";
     // Technically it's an error if num_bytes_consumed isn't exactly
     // equal, but error handling seems silly at this point.
-    stream_->TerminateFromPeer(half_close_);
+    stream_->TerminateFromPeer(true);
     return true;
   }
   return false;
 }
 
 int QuicStreamSequencer::GetReadableRegions(iovec* iov, size_t iov_len) {
   FrameMap::iterator it = frames_.begin();
   size_t index = 0;
   QuicStreamOffset offset = num_bytes_consumed_;
   while (it != frames_.end() && index < iov_len) {
@@ skipping 76 matching lines @@
 bool QuicStreamSequencer::HasBytesToRead() const {
   FrameMap::const_iterator it = frames_.begin();
 
   return it != frames_.end() && it->first == num_bytes_consumed_;
 }
 
 bool QuicStreamSequencer::IsHalfClosed() const {
   return num_bytes_consumed_ >= close_offset_;
 }
 
-bool QuicStreamSequencer::IsClosed() const {
-  return num_bytes_consumed_ >= close_offset_ && half_close_ == false;
-}
-
 bool QuicStreamSequencer::IsDuplicate(const QuicStreamFrame& frame) const {
   // A frame is duplicate if the frame offset is smaller than our bytes consumed
   // or we have stored the frame in our map.
   // TODO(pwestin): Is it possible that a new frame contain more data even if
   // the offset is the same?
   return frame.offset < num_bytes_consumed_ ||
       frames_.find(frame.offset) != frames_.end();
 }
 
 void QuicStreamSequencer::FlushBufferedFrames() {
@@ skipping 16 matching lines @@
     } else {
       string new_data = it->second.substr(bytes_consumed);
       frames_.erase(it);
       frames_.insert(make_pair(num_bytes_consumed_, new_data));
       return;
     }
   }
 }
 
 }  // namespace net