Coalesce small buffers in net::BidirectionalStream

net/quic/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/bidirectional_stream_quic_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 56 matching lines @@
   TestDelegateBase(IOBuffer* read_buf,
                    int read_buf_len,
                    std::unique_ptr<base::Timer> timer)
       : read_buf_(read_buf),
         read_buf_len_(read_buf_len),
         timer_(std::move(timer)),
         loop_(nullptr),
         error_(OK),
         on_data_read_count_(0),
         on_data_sent_count_(0),
-        not_expect_callback_(false) {
+        not_expect_callback_(false),
+        disable_auto_flush_(false) {
     loop_.reset(new base::RunLoop);
   }
 
   ~TestDelegateBase() override {}
 
-  void OnHeadersSent() override {
+  void OnStreamReady() override {
     CHECK(!not_expect_callback_);
     loop_->Quit();
   }
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     CHECK(!not_expect_callback_);
 
     response_headers_ = response_headers;
     loop_->Quit();
   }
@@ skipping 28 matching lines @@
     CHECK_NE(OK, error);
 
     error_ = error;
     loop_->Quit();
   }
 
   void Start(const BidirectionalStreamRequestInfo* request_info,
              const BoundNetLog& net_log,
              const base::WeakPtr<QuicChromiumClientSession> session) {
     stream_job_.reset(new BidirectionalStreamQuicImpl(session));
-    stream_job_->Start(request_info, net_log, this, nullptr);
+    stream_job_->Start(request_info, net_log, disable_auto_flush_, this,
+                       nullptr);
   }
 
   void SendData(IOBuffer* data, int length, bool end_of_stream) {
     not_expect_callback_ = true;
     stream_job_->SendData(data, length, end_of_stream);
     not_expect_callback_ = false;
   }
 
+  void SendvData(const std::vector<IOBuffer*>& data,
+                 const std::vector<int>& lengths,
+                 bool end_of_stream) {
+    not_expect_callback_ = true;
+    stream_job_->SendvData(data, lengths, end_of_stream);
+    not_expect_callback_ = false;
+  }
+
   // Waits until next Delegate callback.
   void WaitUntilNextCallback() {
     loop_->Run();
     loop_.reset(new base::RunLoop);
   }
 
   // Calls ReadData on the |stream_| and updates |data_received_|.
   int ReadData(const CompletionCallback& callback) {
     not_expect_callback_ = true;
     int rv = stream_job_->ReadData(read_buf_.get(), read_buf_len_);
     not_expect_callback_ = false;
     if (rv > 0)
       data_received_.append(read_buf_->data(), rv);
     if (rv == ERR_IO_PENDING)
       callback_ = callback;
     return rv;
   }
 
   // Cancels |stream_|.
   void CancelStream() { stream_job_->Cancel(); }
 
   NextProto GetProtocol() const { return stream_job_->GetProtocol(); }
 
   int64_t GetTotalReceivedBytes() const {
     return stream_job_->GetTotalReceivedBytes();
   }
 
   int64_t GetTotalSentBytes() const { return stream_job_->GetTotalSentBytes(); }
 
+  void DisableAutoFlush() { disable_auto_flush_ = true; }
+
   // 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_; }
 
  protected:
   // Quits |loop_|.
@@ skipping 11 matching lines @@
   std::unique_ptr<base::RunLoop> loop_;
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
   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_;
   CompletionCallback callback_;
+  bool disable_auto_flush_;
 
   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 159 matching lines @@
       bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
     std::unique_ptr<QuicReceivedPacket> packet(maker_.MakeDataPacket(
         packet_number, stream_id_, should_include_version, fin, offset, data));
     DVLOG(2) << "packet(" << packet_number << "): " << std::endl
              << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
     return packet;
   }
+  // Construct a data packet with multiple data frames
+  std::unique_ptr<QuicReceivedPacket> ConstructMultipleDataFramesPacket(
+      QuicPacketNumber packet_number,
+      bool should_include_version,
+      bool fin,
+      QuicStreamOffset offset,
+      const std::vector<std::string>& data_writes) {
+    std::unique_ptr<QuicReceivedPacket> packet(
+        maker_.MakeMultipleDataFramesPacket(packet_number, stream_id_,
+                                            should_include_version, fin, offset,
+                                            data_writes));
+    DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+             << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
+    return packet;
+  }
 
   std::unique_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
       RequestPriority request_priority,
       size_t* spdy_headers_frame_length) {
     SpdyPriority priority =
         ConvertRequestPriorityToQuicPriority(request_priority);
     return maker_.MakeRequestHeadersPacket(
         packet_number, stream_id_, kIncludeVersion, fin, priority,
         request_headers_, spdy_headers_frame_length);
   }
 
+  std::unique_ptr<QuicReceivedPacket>
+  ConstructRequestHeadersAndMultipleDataFramesPacket(
+      QuicPacketNumber packet_number,
+      bool fin,
+      RequestPriority request_priority,
+      size_t* spdy_headers_frame_length,
+      const std::vector<std::string>& data) {
+    SpdyPriority priority =
+        ConvertRequestPriorityToQuicPriority(request_priority);
+    std::unique_ptr<QuicReceivedPacket> packet(
+        maker_.MakeRequestHeadersAndMultipleDataFramesPacket(
+            packet_number, stream_id_, kIncludeVersion, fin, priority,
+            request_headers_, spdy_headers_frame_length, data));
+    DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+             << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
+    return packet;
+  }
+
   std::unique_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
       const SpdyHeaderBlock& response_headers,
       size_t* spdy_headers_frame_length,
       QuicStreamOffset* offset) {
     return maker_.MakeResponseHeadersPacket(
         packet_number, stream_id_, !kIncludeVersion, fin, response_headers,
         spdy_headers_frame_length, offset);
   }
@@ skipping 107 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->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
@@ skipping 50 matching lines @@
   pos = ExpectLogContainsSomewhere(
       entries, /*min_offset=*/pos,
       NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
       entries, /*min_offset=*/pos,
       NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
       NetLog::PHASE_NONE);
 }
 
+TEST_P(BidirectionalStreamQuicImplTest, CoalesceSmallBuffers) {
+  SetRequest("POST", "/", DEFAULT_PRIORITY);
+  size_t spdy_request_headers_frame_length;
+
+  const char kBody1[] = "here are some data";
+  const char kBody2[] = "data keep coming";
+  std::vector<std::string> two_writes = {kBody1, kBody2};
+  AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
+      1, !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
+      two_writes));
+  // Ack server's data packet.
+  AddWrite(ConstructAckPacket(2, 3, 1));
+  const char kBody3[] = "hello there";
+  const char kBody4[] = "another piece of small data";
+  const char kBody5[] = "really small";
+  QuicStreamOffset data_offset = strlen(kBody1) + strlen(kBody2);
+  AddWrite(ConstructMultipleDataFramesPacket(
+      3, !kIncludeVersion, kFin, data_offset, {kBody3, kBody4, kBody5}));
+
+  Initialize();
+
+  BidirectionalStreamRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://www.google.com/");
+  request.end_stream_on_headers = false;
+  request.priority = DEFAULT_PRIORITY;
+
+  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
+  std::unique_ptr<TestDelegateBase> delegate(
+      new TestDelegateBase(read_buffer.get(), kReadBufferSize));
+  delegate->DisableAutoFlush();
+  delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
+  delegate->WaitUntilNextCallback();  // OnStreamReady
+
+  // Send a Data packet.
+  scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
+  scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
+
+  std::vector<IOBuffer*> buffers = {buf1.get(), buf2.get()};
+  std::vector<int> lengths = {buf1->size(), buf2->size()};
+  delegate->SendvData(buffers, lengths, !kFin);
+  delegate->WaitUntilNextCallback();  // OnDataSent
+
+  // Server acks the request.
+  ProcessPacket(ConstructAckPacket(1, 0, 0));
+
+  // Server sends the response headers.
+  SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
+  size_t spdy_response_headers_frame_length;
+  QuicStreamOffset offset = 0;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, !kFin, response_headers, &spdy_response_headers_frame_length,
+      &offset));
+
+  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  TestCompletionCallback cb;
+  int rv = delegate->ReadData(cb.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
+  const char kResponseBody[] = "Hello world!";
+  // Server sends data.
+  ProcessPacket(
+      ConstructDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
+
+  EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
+
+  // Send a second Data packet.
+  scoped_refptr<StringIOBuffer> buf3(new StringIOBuffer(kBody3));
+  scoped_refptr<StringIOBuffer> buf4(new StringIOBuffer(kBody4));
+  scoped_refptr<StringIOBuffer> buf5(new StringIOBuffer(kBody5));
+
+  delegate->SendvData({buf3.get(), buf4.get(), buf5.get()},
+                      {buf3->size(), buf4->size(), buf5->size()}, kFin);
+  delegate->WaitUntilNextCallback();  // OnDataSent
+
+  size_t spdy_trailers_frame_length;
+  SpdyHeaderBlock trailers;
+  trailers["foo"] = "bar";
+  trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
+  // Server sends trailers.
+  ProcessPacket(ConstructResponseTrailersPacket(
+      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+
+  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  trailers.erase(kFinalOffsetHeaderKey);
+  EXPECT_EQ(trailers, delegate->trailers());
+  EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
+
+  EXPECT_EQ(1, delegate->on_data_read_count());
+  EXPECT_EQ(2, delegate->on_data_sent_count());
+  EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
+  EXPECT_EQ(
+      static_cast<int64_t>(spdy_request_headers_frame_length + strlen(kBody1) +
+                           strlen(kBody2) + strlen(kBody3) + strlen(kBody4) +
+                           strlen(kBody5)),
+      delegate->GetTotalSentBytes());
+  EXPECT_EQ(
+      static_cast<int64_t>(spdy_response_headers_frame_length +
+                           strlen(kResponseBody) + spdy_trailers_frame_length),
+      delegate->GetTotalReceivedBytes());
+}
+
 TEST_P(BidirectionalStreamQuicImplTest, PostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY,
                                          &spdy_request_headers_frame_length));
   AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData));
   AddWrite(ConstructAckPacket(3, 3, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf.get(), buf->size(), true);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
@@ skipping 56 matching lines @@
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
 
@@ skipping 56 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->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server sends a Rst.
   ProcessPacket(ConstructRstStreamPacket(1));
 
   delegate->WaitUntilNextCallback();  // OnFailed
   TestCompletionCallback cb;
   EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, delegate->ReadData(cb.callback()));
 
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 18 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->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
@@ skipping 36 matching lines @@
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
 
@@ skipping 29 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->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
@@ skipping 33 matching lines @@
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
 
@@ skipping 29 matching lines @@
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize,
       DeleteStreamDelegate::ON_HEADERS_RECEIVED, true));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, response_headers, &spdy_response_headers_frame_length,
@@ skipping 22 matching lines @@
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<DeleteStreamDelegate> delegate(
       new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
                                DeleteStreamDelegate::ON_DATA_READ, true));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, response_headers, &spdy_response_headers_frame_length,
@@ skipping 31 matching lines @@
   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<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize,
       DeleteStreamDelegate::ON_TRAILERS_RECEIVED, true));
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  delegate->WaitUntilNextCallback();  // OnHeadersSent
+  delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   QuicStreamOffset offset = 0;
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
@@ skipping 29 matching lines @@
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net