Remove OnDataAvailable() notification when trailers are to be delivered

net/quic/chromium/bidirectional_stream_quic_impl_unittest.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/callback_helpers.h"
 #include "base/memory/ptr_util.h"
@@ skipping 65 matching lines @@
         next_proto_(kProtoUnknown),
         received_bytes_(0),
         sent_bytes_(0),
         has_load_timing_info_(false),
         error_(OK),
         on_data_read_count_(0),
         on_data_sent_count_(0),
         not_expect_callback_(false),
         on_failed_called_(false),
         send_request_headers_automatically_(true),
-        is_ready_(false) {
+        is_ready_(false),
+        trailers_expected_(false),
+        trailers_received_(false) {
     loop_.reset(new base::RunLoop);
   }
 
   ~TestDelegateBase() override {}
 
   void OnStreamReady(bool request_headers_sent) override {
     CHECK(!is_ready_);
     CHECK(!on_failed_called_);
     EXPECT_EQ(send_request_headers_automatically_, request_headers_sent);
     CHECK(!not_expect_callback_);
     is_ready_ = true;
     loop_->Quit();
   }
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
     response_headers_ = response_headers.Clone();
     loop_->Quit();
   }
 
   void OnDataRead(int bytes_read) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     CHECK(!callback_.is_null());
 
+    // If read EOF, make sure this callback is after trailers callback.
+    if (bytes_read == 0)
+      EXPECT_TRUE(!trailers_expected_ || trailers_received_);
     ++on_data_read_count_;
     CHECK_GE(bytes_read, OK);
     data_received_.append(read_buf_->data(), bytes_read);
     base::ResetAndReturn(&callback_).Run(bytes_read);
   }
 
   void OnDataSent() override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
     ++on_data_sent_count_;
     loop_->Quit();
   }
 
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
+    trailers_received_ = true;
     trailers_ = trailers.Clone();
     loop_->Quit();
   }
 
   void OnFailed(int error) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     CHECK_EQ(OK, error_);
     CHECK_NE(OK, error);
 
@@ skipping 77 matching lines @@
 
   // Deletes |stream_|.
   void DeleteStream() {
     next_proto_ = stream_->GetProtocol();
     received_bytes_ = stream_->GetTotalReceivedBytes();
     sent_bytes_ = stream_->GetTotalSentBytes();
     has_load_timing_info_ = stream_->GetLoadTimingInfo(&load_timing_info_);
     stream_.reset();
   }
 
+  void set_trailers_expected(bool trailers_expected) {
+    trailers_expected_ = trailers_expected;
+  }
   // Const getters for internal states.
   const std::string& data_received() const { return data_received_; }
   int error() const { return error_; }
   const SpdyHeaderBlock& response_headers() const { return response_headers_; }
   const SpdyHeaderBlock& trailers() const { return trailers_; }
   int on_data_read_count() const { return on_data_read_count_; }
   int on_data_sent_count() const { return on_data_sent_count_; }
   bool on_failed_called() const { return on_failed_called_; }
   bool is_ready() const { return is_ready_; }
 
@@ skipping 18 matching lines @@
   int error_;
   int on_data_read_count_;
   int on_data_sent_count_;
   // This is to ensure that delegate callback is not invoked synchronously when
   // calling into |stream_|.
   bool not_expect_callback_;
   bool on_failed_called_;
   CompletionCallback callback_;
   bool send_request_headers_automatically_;
   bool is_ready_;
+  bool trailers_expected_;
+  bool trailers_received_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 };
 
 // A delegate that deletes the stream in a particular callback.
 class DeleteStreamDelegate : public TestDelegateBase {
  public:
   // Specifies in which callback the stream can be deleted.
   enum Phase {
     ON_HEADERS_RECEIVED,
@@ skipping 422 matching lines @@
 
   BidirectionalStreamRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
+  delegate->set_trailers_expected(true);
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
   delegate->WaitUntilNextCallback();  // OnStreamReady
   ConfirmHandshake();
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
@@ skipping 1038 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net