Remove OnDataAvailable() notification when trailers are to be delivered

net/quic/chromium/bidirectional_stream_quic_impl.cc

 // Copyright 2016 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/bidirectional_stream_quic_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 228 matching lines @@
     has_received_headers_ = true;
     connect_timing_ = session_->GetConnectTiming();
     if (delegate_)
       delegate_->OnHeadersReceived(headers);
   } else {
     if (stream_->IsDoneReading()) {
       // If the write side is closed, OnFinRead() will call
       // BidirectionalStreamQuicImpl::OnClose().
       stream_->OnFinRead();
     }
-    if (delegate_)
-      delegate_->OnTrailersReceived(headers);
+    if (!delegate_)
+      return;
+    // Complete any remaining read. The task is posted because
+    // |delegate_|->OnTrailersReceived() might destroy |this|.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyDataRead,

[mef, 2016/10/05 17:58:42]

Is this right thing to do? What if there is a lot of data buffered, but not read
by the client? NotifyDataRead with 0 length would loose it, right? 

[xunjieli, 2016/10/05 18:10:30]

Ah, that's right. Thanks for catching this! Done.

+                              weak_factory_.GetWeakPtr(), 0));
+    delegate_->OnTrailersReceived(headers);
+    // |this| can be destroyed after this point.
   }
 }
 
 void BidirectionalStreamQuicImpl::OnDataAvailable() {
   // Return early if ReadData has not been called.
   if (!read_buffer_)
     return;
 
-  CHECK(read_buffer_);
-  CHECK_NE(0, read_buffer_len_);
+  DCHECK(read_buffer_);
+  DCHECK_NE(0, read_buffer_len_);
   int rv = ReadData(read_buffer_.get(), read_buffer_len_);
   if (rv == ERR_IO_PENDING) {
     // Spurrious notification. Wait for the next one.
     return;
   }
-  read_buffer_ = nullptr;
-  read_buffer_len_ = 0;
-  if (delegate_)
-    delegate_->OnDataRead(rv);
+  NotifyDataRead(rv);
 }
 
 void BidirectionalStreamQuicImpl::OnClose() {
   DCHECK(stream_);
 
   if (stream_->connection_error() == QUIC_NO_ERROR &&
       stream_->stream_error() == QUIC_STREAM_NO_ERROR) {
     ResetStream();
     return;
   }
@@ skipping 65 matching lines @@
 }
 
 void BidirectionalStreamQuicImpl::NotifyStreamReady() {
   if (send_request_headers_automatically_) {
     SendRequestHeaders();
   }
   if (delegate_)
     delegate_->OnStreamReady(has_sent_headers_);
 }
 
+void BidirectionalStreamQuicImpl::NotifyDataRead(int bytes_read) {
+  if (!read_buffer_) {
+    return;
+  }
+  read_buffer_ = nullptr;
+  read_buffer_len_ = 0;
+  if (delegate_)
+    delegate_->OnDataRead(bytes_read);
+}
+
 void BidirectionalStreamQuicImpl::ResetStream() {
   if (!stream_)
     return;
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   closed_is_first_stream_ = stream_->IsFirstStream();
   stream_->SetDelegate(nullptr);
   stream_ = nullptr;
 }
 
 }  // namespace net