Remove QuicChromiumClientStream::Delegate in favor of async methods.

net/quic/chromium/quic_chromium_client_stream_test.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 <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 20 matching lines @@
 using testing::Return;
 using testing::StrEq;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 const QuicStreamId kTestStreamId = 5u;
 
-class MockDelegate : public QuicChromiumClientStream::Delegate {
- public:
-  MockDelegate() {}
-
-  MOCK_METHOD0(OnSendData, int());
-  MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
-  MOCK_METHOD0(OnClose, void());
-  MOCK_METHOD1(OnError, void(int));
-  MOCK_METHOD0(HasSendHeadersComplete, bool());
-
-  SpdyHeaderBlock headers_;
-  SpdyHeaderBlock trailers_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockDelegate);
-};
-
 class MockQuicClientSessionBase : public QuicClientSessionBase {
  public:
   explicit MockQuicClientSessionBase(QuicConnection* connection,
                                      QuicClientPushPromiseIndex* index);
   ~MockQuicClientSessionBase() override;
 
   const QuicCryptoStream* GetCryptoStream() const override {
     return crypto_stream_.get();
   }
 
@@ skipping 108 matching lines @@
   QuicChromiumClientStreamTest()
       : crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
         session_(new MockQuicConnection(&helper_,
                                         &alarm_factory_,
                                         Perspective::IS_CLIENT,
                                         SupportedVersions(GetParam())),
                  &push_promise_index_) {
     stream_ = new QuicChromiumClientStream(kTestStreamId, &session_,
                                            NetLogWithSource());
     session_.ActivateStream(base::WrapUnique(stream_));
-    handle_ = stream_->CreateHandle(&delegate_);
+    handle_ = stream_->CreateHandle();
   }
 
   void InitializeHeaders() {
     headers_[":host"] = "www.google.com";
     headers_[":path"] = "/index.hml";
     headers_[":scheme"] = "https";
     headers_["cookie"] =
         "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; "
         "__utmc=160408618; "
         "GX=DQAAAOEAAACWJYdewdE9rIrW6qw3PtVi2-d729qaa-74KqOsM1NVQblK4VhX"
@@ skipping 35 matching lines @@
 
   QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) {
     QuicHeaderList h = AsHeaderList(headers);
     stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h);
     return h;
   }
 
   QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) {
     QuicHeaderList h = ProcessHeaders(headers);
     TestCompletionCallback callback;
-    EXPECT_EQ(
-        static_cast<int>(h.uncompressed_header_bytes()),
-        handle_->ReadInitialHeaders(&delegate_.headers_, callback.callback()));
-    EXPECT_EQ(headers, delegate_.headers_);
+    EXPECT_EQ(static_cast<int>(h.uncompressed_header_bytes()),
+              handle_->ReadInitialHeaders(&headers_, callback.callback()));
+    EXPECT_EQ(headers, headers_);
     EXPECT_TRUE(stream_->header_list().empty());
     return h;
   }
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
   QuicStreamId GetNthServerInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(session_, n);
   }
 
   void ResetStreamCallback(QuicChromiumClientStream* stream, int /*rv*/) {
     stream->Reset(QUIC_STREAM_CANCELLED);
   }
 
   QuicCryptoClientConfig crypto_config_;
   std::unique_ptr<QuicChromiumClientStream::Handle> handle_;
-  testing::StrictMock<MockDelegate> delegate_;
   std::unique_ptr<QuicChromiumClientStream::Handle> handle2_;
-  testing::StrictMock<MockDelegate> delegate2_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicClientSessionBase session_;
   QuicChromiumClientStream* stream_;
   SpdyHeaderBlock headers_;
+  SpdyHeaderBlock trailers_;
   QuicClientPushPromiseIndex push_promise_index_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         QuicChromiumClientStreamTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 TEST_P(QuicChromiumClientStreamTest, Handle) {
   EXPECT_TRUE(handle_->IsOpen());
   EXPECT_EQ(kTestStreamId, handle_->id());
   EXPECT_EQ(QUIC_NO_ERROR, handle_->connection_error());
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, handle_->stream_error());
   EXPECT_TRUE(handle_->IsFirstStream());
   EXPECT_FALSE(handle_->IsDoneReading());
   EXPECT_FALSE(handle_->fin_sent());
   EXPECT_FALSE(handle_->fin_received());
   EXPECT_EQ(0u, handle_->stream_bytes_read());
   EXPECT_EQ(0u, handle_->stream_bytes_written());
   EXPECT_EQ(0u, handle_->NumBytesConsumed());
 
   InitializeHeaders();
   QuicStreamOffset offset = 0;
   ProcessHeadersFull(headers_);
   QuicStreamFrame frame2(kTestStreamId, true, offset, QuicStringPiece());
-  EXPECT_CALL(delegate_, OnClose());
   stream_->OnStreamFrame(frame2);
   EXPECT_TRUE(handle_->fin_received());
   handle_->OnFinRead();
 
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
@@ skipping 18 matching lines @@
                                      callback.callback()));
 
   std::vector<scoped_refptr<IOBuffer>> buffers = {
       scoped_refptr<IOBuffer>(new IOBuffer(10))};
   std::vector<int> lengths = {10};
   EXPECT_EQ(
       ERR_CONNECTION_CLOSED,
       handle_->WritevStreamData(buffers, lengths, true, callback.callback()));
 
   SpdyHeaderBlock headers;
-  EXPECT_EQ(0u, handle_->WriteHeaders(std::move(headers), true, nullptr));
+  EXPECT_EQ(0, handle_->WriteHeaders(std::move(headers), true, nullptr));
 }
 
 TEST_P(QuicChromiumClientStreamTest, HandleAfterConnectionClose) {
-  // Verify that the delegate's OnClose is called after closing the connection.
-  EXPECT_CALL(delegate_, OnClose());
   EXPECT_CALL(session_,
               SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
   stream_->OnConnectionClosed(QUIC_INVALID_FRAME_DATA,
                               ConnectionCloseSource::FROM_PEER);
 
   EXPECT_FALSE(handle_->IsOpen());
   EXPECT_EQ(QUIC_INVALID_FRAME_DATA, handle_->connection_error());
 }
 
 TEST_P(QuicChromiumClientStreamTest, HandleAfterStreamReset) {
-  // Verify that the delegate's OnClose is called after the stream is reset,
-  // but that the Handle still behaves correctly.
-  EXPECT_CALL(delegate_, OnClose());
+  // Verify that the Handle still behaves correctly after the stream is reset.
   QuicRstStreamFrame rst(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
   EXPECT_CALL(session_,
               SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
-  stream_->OnStreamReset(rst);
-
-  EXPECT_FALSE(handle_->IsOpen());
-  EXPECT_EQ(QUIC_STREAM_CANCELLED, handle_->stream_error());
-}
-
-TEST_P(QuicChromiumClientStreamTest, HandleAfterClearDelegate) {
-  EXPECT_TRUE(handle_->IsOpen());
-  handle_->ClearDelegate();
-
-  // Verify that the delegate's OnClose is not called after ClearDelegate.
-  EXPECT_CALL(delegate_, OnClose()).Times(0);
-  QuicRstStreamFrame rst(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
-  EXPECT_CALL(session_,
-              SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
   stream_->OnStreamReset(rst);
 
   EXPECT_FALSE(handle_->IsOpen());
   EXPECT_EQ(QUIC_STREAM_CANCELLED, handle_->stream_error());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnFinRead) {
   InitializeHeaders();
   QuicStreamOffset offset = 0;
   ProcessHeadersFull(headers_);
   QuicStreamFrame frame2(kTestStreamId, true, offset, QuicStringPiece());
-  EXPECT_CALL(delegate_, OnClose());
   stream_->OnStreamFrame(frame2);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailable) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   int data_len = strlen(data);
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
-
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableAfterReadBody) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   int data_len = strlen(data);
 
   // Start to read the body.
   TestCompletionCallback callback;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
 
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   EXPECT_EQ(data_len, callback.WaitForResult());
   EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
   base::RunLoop().RunUntilIdle();
-
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, ProcessHeadersWithError) {
   SpdyHeaderBlock bad_headers;
   bad_headers["NAME"] = "...";
   EXPECT_CALL(session_,
               SendRstStream(kTestStreamId, QUIC_BAD_APPLICATION_PAYLOAD, 0));
 
   auto headers = AsHeaderList(bad_headers);
   stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
                               headers);
 
   base::RunLoop().RunUntilIdle();
-
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableWithError) {
   InitializeHeaders();
   auto headers = AsHeaderList(headers_);
   ProcessHeadersFull(headers_);
   EXPECT_CALL(session_, SendRstStream(kTestStreamId, QUIC_STREAM_CANCELLED, 0));
 
   const char data[] = "hello world!";
   int data_len = strlen(data);
 
   // Start to read the body.
   TestCompletionCallback callback;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->ReadBody(
                 buffer.get(), 2 * data_len,
                 base::Bind(&QuicChromiumClientStreamTest::ResetStreamCallback,
                            base::Unretained(this), stream_)));
 
   // Receive the data and close the stream during the callback.
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   base::RunLoop().RunUntilIdle();
-
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnError) {
-  EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED)).Times(1);
+  //  EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED)).Times(1);
 
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   int data_len = strlen(data);
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   // Read the body and verify that it arrives correctly.
   TestCompletionCallback callback;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
   EXPECT_EQ(data_len,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
   EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
 
   auto t = ProcessTrailers(trailers);
 
   TestCompletionCallback trailers_callback;
-  EXPECT_EQ(static_cast<int>(t.uncompressed_header_bytes()),
-            handle_->ReadTrailingHeaders(&delegate_.trailers_,
-                                         trailers_callback.callback()));
+  EXPECT_EQ(
+      static_cast<int>(t.uncompressed_header_bytes()),
+      handle_->ReadTrailingHeaders(&trailers_, trailers_callback.callback()));
 
   // Read the body and verify that it arrives correctly.
   EXPECT_EQ(0,
             handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
 
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, delegate_.trailers_);
+  EXPECT_EQ(trailers, trailers_);
   base::RunLoop().RunUntilIdle();
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 // Tests that trailers are marked as consumed only before delegate is to be
 // immediately notified about trailers.
 TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   int data_len = strlen(data);
@@ skipping 11 matching lines @@
   EXPECT_THAT(
       handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()),
       IsError(ERR_IO_PENDING));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
   QuicHeaderList t = ProcessTrailers(trailers);
   EXPECT_FALSE(stream_->IsDoneReading());
 
-  EXPECT_EQ(
-      static_cast<int>(t.uncompressed_header_bytes()),
-      handle_->ReadTrailingHeaders(&delegate_.trailers_, callback.callback()));
+  EXPECT_EQ(static_cast<int>(t.uncompressed_header_bytes()),
+            handle_->ReadTrailingHeaders(&trailers_, callback.callback()));
 
   // Read the body and verify that it arrives correctly.
   EXPECT_EQ(0, callback.WaitForResult());
 
   // Make sure the stream is properly closed since trailers and data are all
   // consumed.
   EXPECT_TRUE(stream_->IsDoneReading());
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, delegate_.trailers_);
+  EXPECT_EQ(trailers, trailers_);
 
   base::RunLoop().RunUntilIdle();
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 // Test that if Read() is called after response body is read and after trailers
 // are received but not yet delivered, Read() will return ERR_IO_PENDING instead
 // of 0 (EOF).
 TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
@@ skipping 18 matching lines @@
   EXPECT_FALSE(stream_->IsDoneReading());
   // Read again, it return ERR_IO_PENDING.
   EXPECT_THAT(
       handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()),
       IsError(ERR_IO_PENDING));
 
   // Trailers are not delivered
   EXPECT_FALSE(stream_->IsDoneReading());
 
   TestCompletionCallback callback2;
-  EXPECT_EQ(
-      static_cast<int>(t.uncompressed_header_bytes()),
-      handle_->ReadTrailingHeaders(&delegate_.trailers_, callback2.callback()));
+  EXPECT_EQ(static_cast<int>(t.uncompressed_header_bytes()),
+            handle_->ReadTrailingHeaders(&trailers_, callback2.callback()));
 
   // Read the body and verify that it arrives correctly.
   // OnDataAvailable() should follow right after and Read() will return 0.
   EXPECT_EQ(0, callback.WaitForResult());
 
   // Make sure the stream is properly closed since trailers and data are all
   // consumed.
   EXPECT_TRUE(stream_->IsDoneReading());
 
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, delegate_.trailers_);
+  EXPECT_EQ(trailers, trailers_);
 
   base::RunLoop().RunUntilIdle();
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, WriteStreamData) {
-  EXPECT_CALL(delegate_, OnClose());
-
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   TestCompletionCallback callback;
   EXPECT_EQ(OK, handle_->WriteStreamData(QuicStringPiece(kData1, kDataLen),
                                          true, callback.callback()));
 }
 
 TEST_P(QuicChromiumClientStreamTest, WriteStreamDataAsync) {
-  EXPECT_CALL(delegate_, HasSendHeadersComplete()).Times(AnyNumber());
-  EXPECT_CALL(delegate_, OnClose());
-
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
 
   // No data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, false)));
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->WriteStreamData(QuicStringPiece(kData1, kDataLen), true,
                                      callback.callback()));
   ASSERT_FALSE(callback.have_result());
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 TEST_P(QuicChromiumClientStreamTest, WritevStreamData) {
-  EXPECT_CALL(delegate_, OnClose());
-
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer("hello world!"));
   scoped_refptr<StringIOBuffer> buf2(
       new StringIOBuffer("Just a small payload"));
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(buf1->size(), false)))
       .WillOnce(Return(QuicConsumedData(buf2->size(), true)));
   TestCompletionCallback callback;
   EXPECT_EQ(
       OK, handle_->WritevStreamData({buf1, buf2}, {buf1->size(), buf2->size()},
                                     true, callback.callback()));
 }
 
 TEST_P(QuicChromiumClientStreamTest, WritevStreamDataAsync) {
-  EXPECT_CALL(delegate_, HasSendHeadersComplete()).Times(AnyNumber());
-  EXPECT_CALL(delegate_, OnClose());
-
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer("hello world!"));
   scoped_refptr<StringIOBuffer> buf2(
       new StringIOBuffer("Just a small payload"));
 
   // Only a part of the data is written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       // First piece of data is written.
       .WillOnce(Return(QuicConsumedData(buf1->size(), false)))
       // Second piece of data is queued.
       .WillOnce(Return(QuicConsumedData(0, false)));
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle_->WritevStreamData({buf1.get(), buf2.get()},
                                       {buf1->size(), buf2->size()}, true,
                                       callback.callback()));
   ASSERT_FALSE(callback.have_result());
 
   // The second piece of data is written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(buf2->size(), true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
-TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
+TEST_P(QuicChromiumClientStreamTest, HeadersBeforeHandle) {
   // We don't use stream_ because we want an incoming server push
   // stream.
   QuicStreamId stream_id = GetNthServerInitiatedStreamId(0);
   QuicChromiumClientStream* stream2 =
       new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource());
   session_.ActivateStream(base::WrapUnique(stream2));
 
   InitializeHeaders();
 
   // Receive the headers before the delegate is set.
   QuicHeaderList header_list = AsHeaderList(headers_);
   stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(),
                               header_list);
-  EXPECT_TRUE(delegate2_.headers_.empty());
 
   // Now set the delegate and verify that the headers are delivered.
-  handle2_ = stream2->CreateHandle(&delegate2_);
+  handle2_ = stream2->CreateHandle();
   TestCompletionCallback callback;
-  EXPECT_EQ(
-      static_cast<int>(header_list.uncompressed_header_bytes()),
-      handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback()));
-  EXPECT_EQ(headers_, delegate2_.headers_);
-
-  // Both delegates should be notified that theirs streams are closed.
-  EXPECT_CALL(delegate2_, OnClose());
-  EXPECT_CALL(delegate_, OnClose());
+  EXPECT_EQ(static_cast<int>(header_list.uncompressed_header_bytes()),
+            handle2_->ReadInitialHeaders(&headers_, callback.callback()));
+  EXPECT_EQ(headers_, headers_);
 }
 
-TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) {
+TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeHandle) {
   // We don't use stream_ because we want an incoming server push
   // stream.
   QuicStreamId stream_id = GetNthServerInitiatedStreamId(0);
   QuicChromiumClientStream* stream2 =
       new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource());
   session_.ActivateStream(base::WrapUnique(stream2));
 
   InitializeHeaders();
 
   // Receive the headers and data before the delegate is set.
   QuicHeaderList header_list = AsHeaderList(headers_);
   stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(),
                               header_list);
-  EXPECT_TRUE(delegate2_.headers_.empty());
   const char data[] = "hello world!";
   stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false,
                                          /*offset=*/0, data));
 
   // Now set the delegate and verify that the headers are delivered, but
   // not the data, which needs to be read explicitly.
-  handle2_ = stream2->CreateHandle(&delegate2_);
+  handle2_ = stream2->CreateHandle();
   TestCompletionCallback callback;
-  EXPECT_EQ(
-      static_cast<int>(header_list.uncompressed_header_bytes()),
-      handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback()));
-  EXPECT_EQ(headers_, delegate2_.headers_);
+  EXPECT_EQ(static_cast<int>(header_list.uncompressed_header_bytes()),
+            handle2_->ReadInitialHeaders(&headers_, callback.callback()));
+  EXPECT_EQ(headers_, headers_);
   base::RunLoop().RunUntilIdle();
 
   // Now explicitly read the data.
   int data_len = arraysize(data) - 1;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1));
   ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1));
   EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
-
-  // Both delegates should be notified that theirs streams are closed.
-  EXPECT_CALL(delegate2_, OnClose());
-  EXPECT_CALL(delegate_, OnClose());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net