Change BidirectionalStreamQuicImplTest to verify the correct callback

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 42 matching lines @@
 namespace test {
 
 namespace {
 
 const char kUploadData[] = "Really nifty data!";
 const char kDefaultServerHostName[] = "www.google.com";
 const uint16_t kDefaultServerPort = 80;
 // Size of the buffer to be allocated for each read.
 const size_t kReadBufferSize = 4096;
 
+enum DelegateMethod {
+  kOnStreamReady,
+  kOnHeadersReceived,
+  kOnTrailersReceived,
+  kOnDataRead,
+  kOnDataSent,
+  kOnFailed
+};
+
 class TestDelegateBase : public BidirectionalStreamImpl::Delegate {
  public:
   TestDelegateBase(IOBuffer* read_buf, int read_buf_len)
       : TestDelegateBase(read_buf,
                          read_buf_len,
                          base::MakeUnique<base::Timer>(false, false)) {}
 
   TestDelegateBase(IOBuffer* read_buf,
                    int read_buf_len,
                    std::unique_ptr<base::Timer> timer)
@@ skipping 98 matching lines @@
 
   void SendvData(const std::vector<scoped_refptr<IOBuffer>>& data,
                  const std::vector<int>& lengths,
                  bool end_of_stream) {
     not_expect_callback_ = true;
     stream_->SendvData(data, lengths, end_of_stream);
     not_expect_callback_ = false;
   }
 
   // Waits until next Delegate callback.
-  void WaitUntilNextCallback() {
+  void WaitUntilNextCallback(DelegateMethod method) {
+    ASSERT_FALSE(on_failed_called_);
+    bool is_ready = is_ready_;
+    bool headers_received = !response_headers_.empty();
+    bool trailers_received = trailers_received_;
+    int on_data_read_count = on_data_read_count_;
+    int on_data_sent_count = on_data_sent_count_;
+
     loop_->Run();
     loop_.reset(new base::RunLoop);
+
+    EXPECT_EQ(method == kOnFailed, on_failed_called_);
+    EXPECT_EQ(is_ready || (method == kOnStreamReady), is_ready_);
+    EXPECT_EQ(headers_received || (method == kOnHeadersReceived),
+              !response_headers_.empty());
+    EXPECT_EQ(trailers_received || (method == kOnTrailersReceived),
+              trailers_received_);
+    EXPECT_EQ(on_data_read_count + (method == kOnDataRead ? 1 : 0),
+              on_data_read_count_);
+    EXPECT_EQ(on_data_sent_count + (method == kOnDataSent ? 1 : 0),
+              on_data_sent_count_);
   }
 
   // Calls ReadData on the |stream_| and updates |data_received_|.
   int ReadData(const CompletionCallback& callback) {
     not_expect_callback_ = true;
     int rv = stream_->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)
@@ skipping 565 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<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->set_trailers_expected(true);
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
   ConfirmHandshake();
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
   ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
   EXPECT_EQ(12, cb.WaitForResult());
 
   EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
   TestCompletionCallback cb2;
   EXPECT_THAT(delegate->ReadData(cb2.callback()), IsError(ERR_IO_PENDING));
 
   SpdyHeaderBlock trailers;
   size_t spdy_trailers_frame_length;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
       4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   EXPECT_THAT(cb2.WaitForResult(), IsOk());
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
 
   EXPECT_THAT(delegate->ReadData(cb2.callback()), IsOk());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
@@ skipping 46 matching lines @@
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
 
   // Start second request.
   scoped_refptr<IOBuffer> read_buffer2(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate2(
       new TestDelegateBase(read_buffer2.get(), kReadBufferSize));
   delegate2->Start(&request, net_log().bound(), session()->CreateHandle());
 
-  delegate->WaitUntilNextCallback();   // OnStreamReady
-  delegate2->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
+  delegate2->WaitUntilNextCallback(kOnStreamReady);
 
   ConfirmHandshake();
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   offset = 0;
   ProcessPacket(ConstructResponseHeadersPacketInner(
       2, GetNthClientInitiatedStreamId(0), kFin,
       ConstructResponseHeaders("200"), nullptr, &offset));
 
   ProcessPacket(ConstructResponseHeadersPacketInner(
       3, GetNthClientInitiatedStreamId(1), kFin,
       ConstructResponseHeaders("200"), nullptr, &offset));
 
-  delegate->WaitUntilNextCallback();   // OnHeadersReceived
-  delegate2->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
+  delegate2->WaitUntilNextCallback(kOnHeadersReceived);
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
   LoadTimingInfo load_timing_info2;
   EXPECT_TRUE(delegate2->GetLoadTimingInfo(&load_timing_info2));
   ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
   ExpectLoadTimingValid(load_timing_info2, /*session_reused=*/true);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ("200", delegate2->response_headers().find(":status")->second);
   // No response body. ReadData() should return OK synchronously.
@@ skipping 34 matching lines @@
   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->DoNotSendRequestHeadersAutomatically();
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   EXPECT_FALSE(delegate->is_ready());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
   EXPECT_TRUE(delegate->is_ready());
 
   // Sends request headers separately, which causes them to be sent in a
   // separate packet.
   delegate->SendRequestHeaders();
   // Send a Data packet.
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
   scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
 
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(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, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
   EXPECT_EQ(
       static_cast<int64_t>(spdy_request_headers_frame_length + strlen(kBody1) +
                            strlen(kBody2) + strlen(kBody3) + strlen(kBody4) +
@@ skipping 31 matching lines @@
   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->DoNotSendRequestHeadersAutomatically();
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet.
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
 
   delegate->SendData(buf1, buf1->size(), false);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   // Send a second Data packet.
   scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
 
   delegate->SendData(buf2, buf2->size(), true);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
                                  strlen(kBody1) + strlen(kBody2)),
             delegate->GetTotalSentBytes());
@@ skipping 33 matching lines @@
   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->DoNotSendRequestHeadersAutomatically();
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet.
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
   scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
 
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(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, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
   EXPECT_EQ(
       static_cast<int64_t>(spdy_request_headers_frame_length + strlen(kBody1) +
                            strlen(kBody2) + strlen(kBody3) + strlen(kBody4) +
@@ skipping 23 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<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf, buf->size(), true);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
                                  strlen(kUploadData)),
             delegate->GetTotalSentBytes());
@@ skipping 17 matching lines @@
   BidirectionalStreamRequestInfo request;
   request.method = "PUT";
   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()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf, buf->size(), true);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
                                  strlen(kUploadData)),
             delegate->GetTotalSentBytes());
@@ 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<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   ProcessPacket(
       ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
                                      &spdy_response_headers_frame_length, 0));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Client sends a data packet.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf, buf->size(), false);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   const char kResponseBody[] = "Hello world!";
 
   // Server sends a data packet.
   ProcessPacket(ConstructAckAndDataPacket(3, !kIncludeVersion, 2, 1, 1, !kFin,
                                           0, kResponseBody, &server_maker_));
 
   EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
   EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
 
   // Client sends a data packet.
   delegate->SendData(buf, buf->size(), true);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   TestCompletionCallback cb2;
   rv = delegate->ReadData(cb2.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   ProcessPacket(ConstructAckAndDataPacket(4, !kIncludeVersion, 3, 1, 1, kFin,
                                           strlen(kResponseBody), kResponseBody,
                                           &server_maker_));
 
   EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb2.WaitForResult());
 
@@ skipping 26 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()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
   ConfirmHandshake();
 
   // Server sends a Rst.
   ProcessPacket(ConstructServerRstStreamPacket(1));
 
-  delegate->WaitUntilNextCallback();  // OnFailed
+  EXPECT_TRUE(delegate->on_failed_called());
+
   TestCompletionCallback cb;
   EXPECT_THAT(delegate->ReadData(cb.callback()),
               IsError(ERR_QUIC_PROTOCOL_ERROR));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
@@ skipping 17 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()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
   ConfirmHandshake();
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Server sends a Rst.
   ProcessPacket(ConstructServerRstStreamPacket(3));
 
-  delegate->WaitUntilNextCallback();  // OnFailed
+  EXPECT_TRUE(delegate->on_failed_called());
 
   EXPECT_THAT(delegate->ReadData(cb.callback()),
               IsError(ERR_QUIC_PROTOCOL_ERROR));
   EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
@@ skipping 13 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<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 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, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   session()->connection()->CloseConnection(
       QUIC_NO_ERROR, "test", ConnectionCloseBehavior::SILENT_CLOSE);
-  delegate->WaitUntilNextCallback();  // OnFailed
   EXPECT_TRUE(delegate->on_failed_called());
 
   // Try to send data after OnFailed(), should not get called back.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
   delegate->SendData(buf, buf->size(), false);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsError(ERR_UNEXPECTED));
   EXPECT_THAT(delegate->error(), IsError(ERR_UNEXPECTED));
   EXPECT_EQ(0, delegate->on_data_read_count());
@@ skipping 16 matching lines @@
   request.priority = DEFAULT_PRIORITY;
 
   ConfirmHandshake();
   session()->connection()->CloseConnection(
       QUIC_NO_ERROR, "test", ConnectionCloseBehavior::SILENT_CLOSE);
 
   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()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnFailed
+  delegate->WaitUntilNextCallback(kOnFailed);
   EXPECT_TRUE(delegate->on_failed_called());
   EXPECT_THAT(delegate->error(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeStartNotConfirmed) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   Initialize();
 
   session()->connection()->CloseConnection(
       QUIC_NO_ERROR, "test", ConnectionCloseBehavior::SILENT_CLOSE);
 
   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()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnFailed
+  delegate->WaitUntilNextCallback(kOnFailed);
   EXPECT_TRUE(delegate->on_failed_called());
   EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, SessionCloseDuringOnStreamReady) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
 
   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<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
       read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnFailed);
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnStreamReady) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
       2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientEarlyRstStreamPacket(3));
 
   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<DeleteStreamDelegate> delegate(
       new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
                                DeleteStreamDelegate::ON_STREAM_READY));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamAfterReadData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
       2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientAckAndRstStreamPacket(3, 2, 1, 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()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   ProcessPacket(
       ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
                                      &spdy_response_headers_frame_length, 0));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Cancel the stream after ReadData returns ERR_IO_PENDING.
   TestCompletionCallback cb;
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsError(ERR_IO_PENDING));
   delegate->DeleteStream();
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, delegate->on_data_read_count());
@@ skipping 22 matching lines @@
   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));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, std::move(response_headers),
       &spdy_response_headers_frame_length, nullptr));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnDataRead) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
@@ skipping 12 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));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, std::move(response_headers),
       &spdy_response_headers_frame_length, nullptr));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 25 matching lines @@
   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()->CreateHandle());
   ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Send a Data packet with fin set.
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody));
   delegate->SendData(buf1, buf1->size(), /*fin*/ true);
-  delegate->WaitUntilNextCallback();  // OnDataSent
+  delegate->WaitUntilNextCallback(kOnDataSent);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, std::move(response_headers),
       &spdy_response_headers_frame_length, nullptr));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Read the body, which will complete asynchronously.
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   const char kResponseBody[] = "Hello world!";
 
   // Server sends data with the fin set, which should result in the stream
@@ skipping 22 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));
   delegate->Start(&request, net_log().bound(), session()->CreateHandle());
-  delegate->WaitUntilNextCallback();  // OnStreamReady
+  delegate->WaitUntilNextCallback(kOnStreamReady);
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   QuicStreamOffset offset = 0;
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
       2, !kFin, std::move(response_headers),
       &spdy_response_headers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
+  delegate->WaitUntilNextCallback(kOnHeadersReceived);
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
   EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
 
   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.Clone(), &spdy_trailers_frame_length, &offset));
 
-  delegate->WaitUntilNextCallback();  // OnTrailersReceived
+  delegate->WaitUntilNextCallback(kOnTrailersReceived);
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net