Buffer initial response headers in QuicChromiumClientStream

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 14 matching lines @@
     QuicStreamId id,
     QuicClientSessionBase* session,
     const NetLogWithSource& net_log)
     : QuicSpdyStream(id, session),
       net_log_(net_log),
       delegate_(nullptr),
       headers_delivered_(false),
       initial_headers_sent_(false),
       session_(session),
       can_migrate_(true),
+      initial_headers_frame_len_(0),
       weak_factory_(this) {}
 
 QuicChromiumClientStream::~QuicChromiumClientStream() {
   if (delegate_)
     delegate_->OnClose();
 }
 
 void QuicChromiumClientStream::OnInitialHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
 
   SpdyHeaderBlock header_block;
   int64_t length = -1;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &length, &header_block)) {
     DLOG(ERROR) << "Failed to parse header list: " << header_list.DebugString();
     ConsumeHeaderList();
     Reset(QUIC_BAD_APPLICATION_PAYLOAD);
     return;
   }
 
   ConsumeHeaderList();
   session_->OnInitialHeadersComplete(id(), header_block);
 
-  // The delegate will read the headers via a posted task.
-  NotifyDelegateOfHeadersCompleteLater(std::move(header_block), frame_len);
+  if (delegate_) {
+    // The delegate will receive the headers via a posted task.
+    NotifyDelegateOfHeadersCompleteLater(std::move(header_block), frame_len);
+    return;
+  }
+
+  // Buffer the headers and deliver them when the delegate arrives.
+  initial_headers_ = std::move(header_block);
+  initial_headers_frame_len_ = frame_len;
 }
 
 void QuicChromiumClientStream::OnTrailingHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnTrailingHeadersComplete(fin, frame_len, header_list);
   NotifyDelegateOfHeadersCompleteLater(received_trailers().Clone(), frame_len);
 }
 
@@ skipping 22 matching lines @@
   }
 
   if (!sequencer()->HasBytesToRead() && !FinishedReadingTrailers()) {
     // If there is no data to read, wait until either FIN is received or
     // trailers are delivered.
     return;
   }
 
   // The delegate will read the data via a posted task, and
   // will be able to, potentially, read all data which has queued up.
-  NotifyDelegateOfDataAvailableLater();
+  if (delegate_)
+    NotifyDelegateOfDataAvailableLater();
 }
 
 void QuicChromiumClientStream::OnClose() {
   if (delegate_) {
     delegate_->OnClose();
     delegate_ = nullptr;
-    delegate_tasks_.clear();
   }
   QuicStream::OnClose();
 }
 
 void QuicChromiumClientStream::OnCanWrite() {
   QuicStream::OnCanWrite();
 
   if (!HasBufferedData() && !write_callback_.is_null()) {
     base::ResetAndReturn(&write_callback_).Run(OK);
   }
@@ skipping 57 matching lines @@
   }
 
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 void QuicChromiumClientStream::SetDelegate(
     QuicChromiumClientStream::Delegate* delegate) {
   DCHECK(!(delegate_ && delegate));
   delegate_ = delegate;
-  if (delegate == nullptr) {
-    DCHECK(delegate_tasks_.empty());
+  if (delegate == nullptr)
     return;
-  }
-  while (!delegate_tasks_.empty()) {
-    base::Closure closure = delegate_tasks_.front();
-    delegate_tasks_.pop_front();
-    closure.Run();
+
+  // Should this perhaps be via PostTask to make reasoning simpler?
+  if (!initial_headers_.empty()) {
+    delegate_->OnHeadersAvailable(std::move(initial_headers_),
+                                  initial_headers_frame_len_);
   }
 }
 
 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 (IsDoneReading())
     return 0;  // EOF
 
   if (!HasBytesToRead())
     return ERR_IO_PENDING;
 
   iovec iov;
   iov.iov_base = buf->data();
   iov.iov_len = buf_len;
   size_t bytes_read = Readv(&iov, 1);
   // Since HasBytesToRead is true, Readv() must of read some data.
   DCHECK_NE(0u, bytes_read);
   return bytes_read;
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersCompleteLater(
     SpdyHeaderBlock headers,
     size_t frame_len) {
-  RunOrBuffer(base::Bind(
-      &QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
-      weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)), frame_len));
+  DCHECK(delegate_);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      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();
     // 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));
   }
 
   delegate_->OnHeadersAvailable(headers, frame_len);
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailableLater() {
-  RunOrBuffer(
+  DCHECK(delegate_);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
       base::Bind(&QuicChromiumClientStream::NotifyDelegateOfDataAvailable,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailable() {
   if (delegate_)
     delegate_->OnDataAvailable();
 }
 
-void QuicChromiumClientStream::RunOrBuffer(base::Closure closure) {
-  if (delegate_) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
-  } else {
-    delegate_tasks_.push_back(closure);
-  }
-}
-
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net