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 26 matching lines @@
 }
 
 QuicStreamSequencer::~QuicStreamSequencer() {
 }
 
 bool QuicStreamSequencer::WillAcceptStreamFrame(
     const QuicStreamFrame& frame) const {
   size_t data_len = frame.data.size();
   DCHECK_LE(data_len, max_frame_memory_);
 
+  if (IsDuplicate(frame)) {
+    return true;
+  }
   QuicStreamOffset byte_offset = frame.offset;
-  if (byte_offset < num_bytes_consumed_ ||
-      frames_.find(byte_offset) != frames_.end()) {
-    return false;
-  }
   if (data_len > max_frame_memory_) {
     // We're never going to buffer this frame and we can't pass it up.
     // The stream might only consume part of it and we'd need a partial ack.
     //
     // Ideally this should never happen, as we check that
     // max_frame_memory_ > kMaxPacketSize and lower levels should reject
     // frames larger than that.
     return false;
   }
   if (byte_offset + data_len - num_bytes_consumed_ > max_frame_memory_) {
     // We can buffer this but not right now.  Toss it.
     // It might be worth trying an experiment where we try best-effort buffering
     return false;
   }
   return true;
 }
 
 bool QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
   if (!WillAcceptStreamFrame(frame)) {
     // This should not happen, as WillAcceptFrame should be called before
     // OnStreamFrame.  Error handling should be done by the caller.
     return false;
   }
+  if (IsDuplicate(frame)) {
+    // Silently ignore duplicates.
+    return true;
+  }
 
   QuicStreamOffset byte_offset = frame.offset;
   const char* data = frame.data.data();
   size_t data_len = frame.data.size();
 
   if (byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
     size_t bytes_consumed = stream_->ProcessData(data, data_len);
     num_bytes_consumed_ += bytes_consumed;
 
     if (MaybeCloseStream()) {
       return true;
     }
     if (bytes_consumed > data_len) {
       stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);
       return false;
     } else if (bytes_consumed == data_len) {
       FlushBufferedFrames();
       return true;  // it's safe to ack this frame.
     } else {
       // Set ourselves up to buffer what's left
       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) {
   const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
 
   // If we have a scheduled termination or close, any new offset should match
@@ skipping 32 matching lines @@
 }
 
 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() {
   FrameMap::iterator it = frames_.find(num_bytes_consumed_);
   while (it != frames_.end()) {
     DVLOG(1) << "Flushing buffered packet at offset " << it->first;
     string* data = &it->second;
     size_t bytes_consumed = stream_->ProcessData(data->c_str(), data->size());
     num_bytes_consumed_ += bytes_consumed;
     if (MaybeCloseStream()) {
       return;
     }
     if (bytes_consumed > data->size()) {
       stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);  // Programming error
       return;
     } else if (bytes_consumed == data->size()) {
       frames_.erase(it);
       it = frames_.find(num_bytes_consumed_);
     } else {
       string new_data = it->second.substr(bytes_consumed);
       frames_.erase(it);
       frames_.insert(make_pair(num_bytes_consumed_, new_data));
       return;
     }
   }
 }
 
 }  // namespace net