Land Recent QUIC changes.

net/quic/quic_reliable_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/quic_reliable_client_stream.h"
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/quic/quic_client_session.h"
 #include "net/quic/quic_utils.h"
@@ skipping 10 matching lines @@
 
 class MockDelegate : public QuicReliableClientStream::Delegate {
  public:
   MockDelegate() {}
 
   MOCK_METHOD0(OnSendData, int());
   MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
   MOCK_METHOD2(OnDataReceived, int(const char*, int));
   MOCK_METHOD1(OnClose, void(QuicErrorCode));
   MOCK_METHOD1(OnError, void(int));
+  MOCK_METHOD0(HasSendHeadersComplete, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 class QuicReliableClientStreamTest : public ::testing::Test {
  public:
   QuicReliableClientStreamTest()
       : session_(new MockConnection(1, IPEndPoint(), false), false),
         stream_(1, &session_, BoundNetLog()) {
@@ skipping 38 matching lines @@
   EXPECT_FALSE(stream_.GetDelegate());
 }
 
 TEST_F(QuicReliableClientStreamTest, WriteStreamData) {
   EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR));
 
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
 
   // All data written.
-  EXPECT_CALL(session_, WriteData(stream_.id(), _, _, _)).WillOnce(
+  EXPECT_CALL(session_, WritevData(stream_.id(), _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   TestCompletionCallback callback;
   EXPECT_EQ(OK, stream_.WriteStreamData(base::StringPiece(kData1, kDataLen),
                                         true, callback.callback()));
 }
 
 TEST_F(QuicReliableClientStreamTest, WriteStreamDataAsync) {
+  EXPECT_CALL(delegate_, HasSendHeadersComplete());
   EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR));
 
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
 
   // No data written.
-  EXPECT_CALL(session_, WriteData(stream_.id(), _, _, _)).WillOnce(
+  EXPECT_CALL(session_, WritevData(stream_.id(), _, _, _, _)).WillOnce(
       Return(QuicConsumedData(0, false)));
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             stream_.WriteStreamData(base::StringPiece(kData1, kDataLen),
                                     true, callback.callback()));
   ASSERT_FALSE(callback.have_result());
 
   // All data written.
-  EXPECT_CALL(session_, WriteData(stream_.id(), _, _, _)).WillOnce(
+  EXPECT_CALL(session_, WritevData(stream_.id(), _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   stream_.OnCanWrite();
   ASSERT_TRUE(callback.have_result());
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net