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 56 matching lines @@
   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;
   }
 
-  if (frame.fin) {
-    CloseStreamAtOffset(frame.offset + frame.data.size());
-  }
-
   QuicStreamOffset byte_offset = frame.offset;
   const char* data = frame.data.data();
   size_t data_len = frame.data.size();
 
-  if (data_len == 0) {
-    // TODO(rch): Close the stream if there was no data and no fin.
-    return true;
+  if (data_len == 0 && !frame.fin) {
+    // Stream frames must have data or a fin flag.
+    stream_->ConnectionClose(QUIC_INVALID_STREAM_FRAME, false);
+    return false;
+  }
+
+  if (frame.fin) {
+    CloseStreamAtOffset(frame.offset + frame.data.size());
+    if (data_len == 0) {
+      return true;
+    }
   }
 
   if (byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
     size_t bytes_consumed = stream_->ProcessRawData(data, data_len);
     num_bytes_consumed_ += bytes_consumed;
 
     if (MaybeCloseStream()) {
       return true;
     }
     if (bytes_consumed > data_len) {
-      stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);
+      stream_->Close(QUIC_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;
     }
@@ skipping 94 matching lines @@
 void QuicStreamSequencer::MarkConsumed(size_t num_bytes_consumed) {
   size_t end_offset = num_bytes_consumed_ + num_bytes_consumed;
   while (!frames_.empty() && end_offset != num_bytes_consumed_) {
     FrameMap::iterator it = frames_.begin();
     if (it->first != num_bytes_consumed_) {
       LOG(DFATAL) << "Invalid argument to MarkConsumed. "
                   << " num_bytes_consumed_: " << num_bytes_consumed_
                   << " end_offset: " << end_offset
                   << " offset: " << it->first
                   << " length: " << it->second.length();
-      stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);
+      stream_->Close(QUIC_ERROR_PROCESSING_STREAM);
       return;
     }
 
     if (it->first + it->second.length() <= end_offset) {
       num_bytes_consumed_ += it->second.length();
       // This chunk is entirely consumed.
       frames_.erase(it);
       continue;
     }
 
@@ skipping 30 matching lines @@
   while (it != frames_.end()) {
     DVLOG(1) << "Flushing buffered packet at offset " << it->first;
     string* data = &it->second;
     size_t bytes_consumed = stream_->ProcessRawData(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
+      stream_->Close(QUIC_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