Include HTTP header bytes in GetTotalSent/ReceivedBytes for QUIC.

net/quic/quic_http_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_http_stream.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 68 matching lines @@
 };
 
 // Subclass of QuicHttpStream that closes itself when the first piece of data
 // is received.
 class AutoClosingStream : public QuicHttpStream {
  public:
   explicit AutoClosingStream(
       const base::WeakPtr<QuicChromiumClientSession>& session)
       : QuicHttpStream(session) {}
 
-  void OnHeadersAvailable(const SpdyHeaderBlock& headers) override {
+  void OnHeadersAvailable(const SpdyHeaderBlock& headers,
+                          size_t frame_len) override {
     Close(false);
   }
 
   void OnDataAvailable() override { Close(false); }
 };
 
 class TestPacketWriterFactory : public QuicConnection::PacketWriterFactory {
  public:
   explicit TestPacketWriterFactory(DatagramClientSocket* socket)
       : socket_(socket) {}
@@ skipping 150 matching lines @@
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
     return maker_.MakeDataPacket(packet_number, stream_id_,
                                  should_include_version, fin, offset, data);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
-      RequestPriority request_priority) {
+      RequestPriority request_priority,
+      size_t* spdy_headers_frame_length) {
     QuicPriority priority =
         ConvertRequestPriorityToQuicPriority(request_priority);
-    return maker_.MakeRequestHeadersPacket(packet_number, stream_id_,
-                                           kIncludeVersion, fin, priority,
-                                           request_headers_);
+    return maker_.MakeRequestHeadersPacket(
+        packet_number, stream_id_, kIncludeVersion, fin, priority,
+        request_headers_, spdy_headers_frame_length);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
       QuicPacketNumber packet_number,
-      bool fin) {
+      bool fin,
+      size_t* spdy_headers_frame_length) {
     return maker_.MakeResponseHeadersPacket(
-        packet_number, stream_id_, !kIncludeVersion, fin, response_headers_);
+        packet_number, stream_id_, !kIncludeVersion, fin, response_headers_,
+        spdy_headers_frame_length);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
       QuicPacketNumber packet_number) {
     return maker_.MakeRstPacket(
         packet_number, true, stream_id_,
         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamCancelledPacket(
@@ skipping 60 matching lines @@
   EXPECT_EQ(nullptr, stream_->RenewStreamForAuth());
 }
 
 TEST_P(QuicHttpStreamTest, CanReuseConnection) {
   Initialize();
   EXPECT_FALSE(stream_->CanReuseConnection());
 }
 
 TEST_P(QuicHttpStreamTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
+  size_t spdy_request_header_frame_length;
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
+                                         &spdy_request_header_frame_length));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   SetResponse("404 Not Found", std::string());
-  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
+  size_t spdy_response_header_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, kFin, &spdy_response_header_frame_length));
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(404, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
   EXPECT_FALSE(response_.response_time.is_null());
   EXPECT_FALSE(response_.request_time.is_null());
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
-  EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_header_frame_length),
+            stream_->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_header_frame_length),
+            stream_->GetTotalReceivedBytes());
 }
 
 // Regression test for http://crbug.com/288128
 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
+  size_t spdy_request_headers_frame_length;
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
+                                         &spdy_request_headers_frame_length));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   SpdyHeaderBlock headers;
   headers[":status"] = "200 OK";
   headers[":version"] = "HTTP/1.1";
   headers["content-type"] = "text/plain";
   headers["big6"] = std::string(1000, 'x');  // Lots of x's.
 
   response_headers_ = headers;
-  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
+  size_t spdy_response_headers_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, kFin, &spdy_response_headers_frame_length));
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
-  EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
+            stream_->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
+            stream_->GetTotalReceivedBytes());
 }
 
 // Regression test for http://crbug.com/409101
 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
 
   session_->connection()->CloseConnection(QUIC_NO_ERROR, true);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED,
             stream_->SendRequest(headers_, &response_,
                                  callback_.callback()));
 
   EXPECT_EQ(0, stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 // Regression test for http://crbug.com/409871
 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
+  size_t spdy_request_headers_frame_length;
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
+                                         &spdy_request_headers_frame_length));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
 
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
 
   session_->connection()->CloseConnection(QUIC_NO_ERROR, true);
 
   EXPECT_NE(OK, stream_->ReadResponseHeaders(callback_.callback()));
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
+            stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, SendPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin, 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();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
 
   // Ack both packets in the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
+  size_t spdy_response_headers_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody));
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData)),
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
+                                 strlen(kUploadData)),
             stream_->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)),
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
+                                 strlen(kResponseBody)),
             stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin, 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(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size,
                                kUploadData));
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
   upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
       TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
   upload_data_stream.AppendData(kUploadData, chunk_size, true);
   EXPECT_EQ(OK, callback_.WaitForResult());
 
   // Ack both packets in the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
+  size_t spdy_response_headers_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
   EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
                                     kResponseBody));
 
   // Since the body has already arrived, this should return immediately.
   ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData) * 2),
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
+                                 strlen(kUploadData) * 2),
             stream_->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)),
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
+                                 strlen(kResponseBody)),
             stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin, 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(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, ""));
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
   upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
       TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
   upload_data_stream.AppendData(nullptr, 0, true);
   EXPECT_EQ(OK, callback_.WaitForResult());
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
+  size_t spdy_response_headers_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
   EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
                                     kResponseBody));
 
   // The body has arrived, but it is delivered asynchronously
   ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData)),
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
+                                 strlen(kUploadData)),
             stream_->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)),
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
+                                 strlen(kResponseBody)),
             stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin, 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, ""));
   AddWrite(ConstructAckPacket(3, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
       TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
   upload_data_stream.AppendData(nullptr, 0, true);
   EXPECT_EQ(OK, callback_.WaitForResult());
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
+  size_t spdy_response_headers_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, !kFin, &spdy_response_headers_frame_length));
 
   // The headers have arrived, but they are delivered asynchronously
   EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
                                     kResponseBody));
 
   // The body has arrived, but it is delivered asynchronously
   ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)),
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
+            stream_->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
+                                 strlen(kResponseBody)),
             stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, DestroyedEarly) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
+  size_t spdy_request_headers_frame_length;
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
+                                         &spdy_request_headers_frame_length));
   AddWrite(ConstructAckAndRstStreamPacket(2));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
   // In the course of processing this packet, the QuicHttpStream close itself.
-  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
+  ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
+            stream_->GetTotalSentBytes());
+  // Zero since the stream is closed before processing the headers.
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 TEST_P(QuicHttpStreamTest, Priority) {
   SetRequest("GET", "/", MEDIUM);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM));
+  size_t spdy_request_headers_frame_length;
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM,
+                                         &spdy_request_headers_frame_length));
   AddWrite(ConstructAckAndRstStreamPacket(2));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
                                           net_log_, callback_.callback()));
 
@@ skipping 12 matching lines @@
       reliable_stream->EffectivePriority()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
   // In the course of processing this packet, the QuicHttpStream close itself.
-  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
+  ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
-  EXPECT_EQ(0, stream_->GetTotalSentBytes());
+  // headers and payload.
+  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
+            stream_->GetTotalSentBytes());
+  // Zero since the stream is closed before processing the headers.
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 // Regression test for http://crbug.com/294870
 TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) {
   SetRequest("GET", "/", MEDIUM);
   use_closing_stream_ = true;
 
   AddWrite(ConstructRstStreamPacket(1));
 
@@ skipping 14 matching lines @@
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
 
   // Set Delegate to nullptr and make sure EffectivePriority returns highest
   // priority.
   reliable_stream->SetDelegate(nullptr);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
   reliable_stream->SetDelegate(delegate);
 
-  // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
-  // payload.
   EXPECT_EQ(0, stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 }  // namespace test
 }  // namespace net