QuicChromiumClientStream handle Read() after trailers are received but not yet delivered

net/quic/chromium/quic_chromium_client_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/chromium/quic_chromium_client_stream.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 231 matching lines @@
 void QuicChromiumClientStream::OnError(int error) {
   if (delegate_) {
     QuicChromiumClientStream::Delegate* delegate = delegate_;
     delegate_ = nullptr;
     delegate_tasks_.clear();
     delegate->OnError(error);
   }
 }
 
 int QuicChromiumClientStream::Read(IOBuffer* buf, int buf_len) {
-  if (sequencer()->IsClosed())
+  if (IsDoneReading())
     return 0;  // EOF
 
   if (!HasBytesToRead())
     return ERR_IO_PENDING;
 
   iovec iov;
   iov.iov_base = buf->data();
   iov.iov_len = buf_len;
-  return Readv(&iov, 1);
+  size_t bytes_read = Readv(&iov, 1);
+  // If no more body bytes and trailers are to be delivered, return
+  // ERR_IO_PENDING now because onDataAvailable() will be called after trailers.
+  if (bytes_read == 0 && !FinishedReadingTrailers())
+    return ERR_IO_PENDING;
+  return bytes_read;
 }
 
 bool QuicChromiumClientStream::CanWrite(const CompletionCallback& callback) {
   bool can_write = session()->connection()->CanWrite(HAS_RETRANSMITTABLE_DATA);
   if (!can_write) {
     session()->MarkConnectionLevelWriteBlocked(id());
     DCHECK(callback_.is_null());
     callback_ = callback;
   }
   return can_write;
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersCompleteLater(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   RunOrBuffer(base::Bind(
       &QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
       weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)), frame_len));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersComplete(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   if (!delegate_)
     return;
   // Only mark trailers consumed when we are about to notify delegate.
   if (headers_delivered_) {
     MarkTrailersConsumed(decompressed_trailers().length());
     MarkTrailersConsumed();
+    // Post an async task to notify delegate of the FIN flag.
+    NotifyDelegateOfDataAvailableLater();
     net_log_.AddEvent(
         NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   } else {
     headers_delivered_ = true;
     net_log_.AddEvent(
         NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   }
 
@@ skipping 21 matching lines @@
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net