Include HTTP header bytes in GetTotalSent/ReceivedBytes for QUIC.

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_chromium_client_session.h"
 #include "net/quic/quic_utils.h"
@@ skipping 14 matching lines @@
 namespace {
 
 const QuicStreamId kTestStreamId = 5u;
 
 class MockDelegate : public QuicReliableClientStream::Delegate {
  public:
   MockDelegate() {}
 
   MOCK_METHOD0(OnSendData, int());
   MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
-  MOCK_METHOD1(OnHeadersAvailable, void(const SpdyHeaderBlock&));
+  MOCK_METHOD2(OnHeadersAvailable, void(const SpdyHeaderBlock&, size_t));
   MOCK_METHOD2(OnDataReceived, int(const char*, int));
   MOCK_METHOD0(OnDataAvailable, void());
   MOCK_METHOD1(OnClose, void(QuicErrorCode));
   MOCK_METHOD1(OnError, void(int));
   MOCK_METHOD0(HasSendHeadersComplete, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
@@ skipping 58 matching lines @@
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicReliableClientStreamTest, OnFinRead) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam());
   QuicStreamOffset offset = 0;
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
-  EXPECT_CALL(delegate_, OnHeadersAvailable(headers_));
+  EXPECT_CALL(delegate_,
+              OnHeadersAvailable(headers_, uncompressed_headers.length()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   QuicStreamFrame frame2(kTestStreamId, true, offset, StringPiece());
   EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR));
   stream_->OnStreamFrame(frame2);
 }
 
 TEST_P(QuicReliableClientStreamTest, OnDataAvailableBeforeHeaders) {
   EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR));
 
   EXPECT_CALL(delegate_, OnDataAvailable()).Times(0);
   stream_->OnDataAvailable();
 }
 
 TEST_P(QuicReliableClientStreamTest, OnDataAvailable) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam());
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
-  EXPECT_CALL(delegate_, OnHeadersAvailable(headers_));
+  EXPECT_CALL(delegate_,
+              OnHeadersAvailable(headers_, uncompressed_headers.length()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicReliableClientStreamTest::ReadData,
@@ skipping 15 matching lines @@
   EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR));
 }
 
 TEST_P(QuicReliableClientStreamTest, OnDataAvailableWithError) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam());
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
-  EXPECT_CALL(delegate_, OnHeadersAvailable(headers_));
+  EXPECT_CALL(delegate_,
+              OnHeadersAvailable(headers_, uncompressed_headers.length()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(CreateFunctor(
           stream_, &QuicReliableClientStream::Reset, QUIC_STREAM_CANCELLED)));
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 42 matching lines @@
   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