Land Recent QUIC changes.

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "net/quic/quic_session.h"
 #include "net/quic/quic_spdy_decompressor.h"
 
 using base::StringPiece;
@@ skipping 40 matching lines @@
     DLOG(INFO) << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
     return true;
   }
   // Note: This count include duplicate data received.
   stream_bytes_read_ += frame.data.length();
 
   bool accepted = sequencer_.OnStreamFrame(frame);
 
   if (frame.fin) {
-    sequencer_.CloseStreamAtOffset(frame.offset + frame.data.size(), true);
+    sequencer_.CloseStreamAtOffset(frame.offset + frame.data.size());
   }
 
   return accepted;
 }
 
 void ReliableQuicStream::OnStreamReset(QuicRstStreamErrorCode error) {
   stream_error_ = error;
   TerminateFromPeer(false);  // Full close.
 }
 
 void ReliableQuicStream::ConnectionClose(QuicErrorCode error, bool from_peer) {
-  if (IsClosed()) {
+  if (read_side_closed_ && write_side_closed_) {
     return;
   }
   if (error != QUIC_NO_ERROR) {
     stream_error_ = QUIC_STREAM_CONNECTION_ERROR;
     connection_error_ = error;
   }
 
   if (from_peer) {
     TerminateFromPeer(false);
   } else {
@@ skipping 52 matching lines @@
   return 1;
 }
 
 bool ReliableQuicStream::IsHalfClosed() const {
   if (!headers_decompressed_ || !decompressed_headers_.empty()) {
     return false;
   }
   return sequencer_.IsHalfClosed();
 }
 
-bool ReliableQuicStream::IsClosed() const {
-  return write_side_closed_ && (read_side_closed_ || IsHalfClosed());
-}
-
 bool ReliableQuicStream::HasBytesToRead() const {
   return !decompressed_headers_.empty() || sequencer_.HasBytesToRead();
 }
 
 const IPEndPoint& ReliableQuicStream::GetPeerAddress() const {
   return session_->peer_address();
 }
 
 QuicSpdyCompressor* ReliableQuicStream::compressor() {
   return session_->compressor();
@@ skipping 197 matching lines @@
           StringPiece(static_cast<char*>(iovecs[i].iov_base),
                       iovecs[i].iov_len), this);
 
       headers_decompressed_ =
           session_->decompressor()->current_header_id() != headers_id_;
     }
   }
 
   // Either the headers are complete, or the all data as been consumed.
   sequencer_.MarkConsumed(total_bytes_consumed);
-
   ProcessHeaderData();  // Unprocessed headers remain in decompressed_headers_.
-
-  if (headers_decompressed_ && decompressed_headers_.empty()) {
+  if (IsHalfClosed()) {
+    TerminateFromPeer(true);
+  } else if (headers_decompressed_ && decompressed_headers_.empty()) {
     sequencer_.FlushBufferedFrames();
   }
 }
 
 bool ReliableQuicStream::OnDecompressedData(StringPiece data) {
   data.AppendToString(&decompressed_headers_);
   return true;
 }
 
 void ReliableQuicStream::OnDecompressionError() {
@@ skipping 21 matching lines @@
   if (visitor_) {
     Visitor* visitor = visitor_;
     // Calling Visitor::OnClose() may result the destruction of the visitor,
     // so we need to ensure we don't call it again.
     visitor_ = NULL;
     visitor->OnClose(this);
   }
 }
 
 }  // namespace net