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 77 matching lines @@
 
 void ReliableQuicStream::TerminateFromPeer(bool half_close) {
   if (!half_close) {
     CloseWriteSide();
   }
   CloseReadSide();
 }
 
 void ReliableQuicStream::Close(QuicRstStreamErrorCode error) {
   stream_error_ = error;
-  session()->SendRstStream(id(), error);
+  if (error != QUIC_STREAM_NO_ERROR)  {
+    // Sending a RstStream results in calling CloseStream.
+    session()->SendRstStream(id(), error);
+  } else {
+    session_->CloseStream(id());
+  }
 }
 
 int ReliableQuicStream::Readv(const struct iovec* iov, size_t iov_len) {
   if (headers_decompressed_ && decompressed_headers_.empty()) {
     return sequencer_.Readv(iov, iov_len);
   }
   size_t bytes_consumed = 0;
   size_t iov_index = 0;
   while (iov_index < iov_len &&
          decompressed_headers_.length() > bytes_consumed) {
@@ skipping 39 matching lines @@
 
 const IPEndPoint& ReliableQuicStream::GetPeerAddress() const {
   return session_->peer_address();
 }
 
 QuicSpdyCompressor* ReliableQuicStream::compressor() {
   return session_->compressor();
 }
 
 QuicConsumedData ReliableQuicStream::WriteData(StringPiece data, bool fin) {
+  DCHECK(data.size() > 0 || fin);
   return WriteOrBuffer(data, fin);
 }
 
 QuicConsumedData ReliableQuicStream::WriteOrBuffer(StringPiece data, bool fin) {
   DCHECK(!fin_buffered_);
 
   QuicConsumedData consumed_data(0, false);
   fin_buffered_ = fin;
 
   if (queued_data_.empty()) {
@@ skipping 37 matching lines @@
     return QuicConsumedData(0, false);
   }
 
   QuicConsumedData consumed_data =
       session()->WriteData(id(), data, stream_bytes_written_, fin);
   stream_bytes_written_ += consumed_data.bytes_consumed;
   if (consumed_data.bytes_consumed == data.length()) {
     if (fin && consumed_data.fin_consumed) {
       fin_sent_ = true;
       CloseWriteSide();
+    } else if (fin && !consumed_data.fin_consumed) {
+      session_->MarkWriteBlocked(id());
     }
   } else {
     session_->MarkWriteBlocked(id());
   }
   return consumed_data;
 }
 
 void ReliableQuicStream::CloseReadSide() {
   if (read_side_closed_) {
     return;
@@ skipping 169 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