Added and implemented HttpStream::GetTotalSentBytes for basic streams.

net/http/http_stream_parser_unittest.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/http/http_stream_parser.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
@@ skipping 35 matching lines @@
   data->set_socket(socket.get());
 
   TestCompletionCallback callback;
   EXPECT_EQ(OK, socket->Connect(callback.callback()));
 
   scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
   socket_handle->SetSocket(socket.Pass());
   return socket_handle.Pass();
 }
 
+// Helper method to get the total data size of the MockWrites in |writes|.
+int64_t WritesSize(const MockWrite writes[], size_t length) {

[mmenke, 2015/08/31 22:23:13]

Suggest calling this CountWriteBytes.

WriteBytes matches the HttpStreamParser accessor's name.  "Count" indicates how
it's getting them.

[mmenke, 2015/08/31 22:23:13]

Maybe make this part of SequencedSocketData instead?  Or do your other tests not
need something similar?  If you do this, should add a similar read method, even
though you aren't currently using it.

[sclittle, 2015/09/01 01:21:48]

OK, I've created CountReadBytes and CountWriteBytes helper functions in
socket_test_util.

I don't want to make it part of the SequencedSocketData or the
SocketDataProvider, since the data provider shouldn't be responsible for
determining how many of the MockWrites/Reads *should* have been used.

[mmenke, 2015/09/01 17:39:43]

I actually disagree here - seems like a utility function to query what was
passed to it...  My main reason to prefer it is I don't really like passing
length around.

[sclittle, 2015/09/01 20:03:00]

Often the length is necessary - a single SocketDataProvider can satisfy multiple
requests if the socket is reused. At that point, it's useless to get the total
data_len of all the MockWrites from the SocketDataProvider, since only a subset
of the MockWrites apply to a single request.

None of the tests in this file reuse sockets like that, but many of the tests in
http_network_transaction_unittest do. I'm planning to make the
http_network_transaction tests switch over to using these helper functions in
the later CL when I plumb the GetTotalSentBytes through the HttpTransaction up
to the URLRequest.

+  int64_t total = 0;
+  for (const MockWrite* write = writes; write != writes + length; ++write) {
+    total += write->data_len;
+  }
+  return total;
+}
+
 // The empty payload is how the last chunk is encoded.
 TEST(HttpStreamParser, EncodeChunk_EmptyPayload) {
   char output[kOutputSize];
 
   const base::StringPiece kPayload = "";
   const base::StringPiece kExpected = "0\r\n\r\n";
   const int num_bytes_written =
       HttpStreamParser::EncodeChunk(kPayload, output, sizeof(output));
   ASSERT_EQ(kExpected.size(), static_cast<size_t>(num_bytes_written));
   EXPECT_EQ(kExpected, base::StringPiece(output, num_bytes_written));
@@ skipping 926 matching lines @@
   get_runner.ReadHeaders();
   EXPECT_EQ(200, get_runner.response_info()->headers->response_code());
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int64 response_size = headers_size + body.size();
   int body_size = body.size();
   int read_lengths[] = {body_size, 0};
   get_runner.ReadBody(body_size, read_lengths);
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
 }
 
+TEST(HttpStreamParser, SentBytesNoHeaders) {
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://localhost");
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", HttpRequestHeaders(),

[mmenke, 2015/08/31 22:23:13]

These should probably just be EXPECTs - at least the tendency in net/ is to only
use ASSERT if the later lines will crash if the ASSERT fails, which I don't
believe is the case here.

[sclittle, 2015/09/01 01:21:48]

Done.

+                                   &response, callback.callback()));
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesWithHeaders) {
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, 0,
+                "GET / HTTP/1.1\r\n"
+                "Host: localhost\r\n"
+                "Connection: Keep-Alive\r\n\r\n"),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://localhost");
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Host", "localhost");
+  headers.SetHeader("Connection", "Keep-Alive");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
+                                   callback.callback()));
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesWithHeadersMultiWrite) {
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: localhost\r\n"),
+      MockWrite(SYNCHRONOUS, 2, "Connection: Keep-Alive\r\n\r\n"),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://localhost");
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Host", "localhost");
+  headers.SetHeader("Connection", "Keep-Alive");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+
+  int rv = parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
+                              callback.callback());
+  ASSERT_EQ(OK, rv);
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesWithErrorWritingHeaders) {
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: localhost\r\n"),
+      MockWrite(SYNCHRONOUS, ERR_CONNECTION_RESET, 2),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://localhost");
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Host", "localhost");
+  headers.SetHeader("Connection", "Keep-Alive");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(ERR_CONNECTION_RESET,
+            parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
+                               callback.callback()));
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesPost) {
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, 0, "POST / HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Content-Length: 12\r\n\r\n"),
+      MockWrite(SYNCHRONOUS, 2, "hello world!"),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("hello world!", 12));
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://localhost");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Content-Length", "12");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(OK, parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
+                                   callback.callback()));
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesChunkedPost) {

[mmenke, 2015/08/31 22:23:13]

Rather than duplicate some of these larger tests, suggest just adding the new
check to the old tests.  I don't think we get a whole lot by separating them
out.  I feel that more basic tests should go earlier, so if you go with this,
should move the your earlier tests earlier in the file, too.

[sclittle, 2015/09/01 01:21:47]

Done.

+  static const char kChunk1[] = "Chunk 1";
+  static const char kChunk2[] = "Chunky 2";
+  static const char kChunk3[] = "Test 3";
+
+  MockWrite writes[] = {
+      MockWrite(ASYNC, 0, "POST / HTTP/1.1\r\n"),
+      MockWrite(ASYNC, 1, "Transfer-Encoding: chunked\r\n\r\n"),
+      MockWrite(ASYNC, 2, "7\r\nChunk 1\r\n"),
+      MockWrite(ASYNC, 3, "8\r\nChunky 2\r\n"),
+      MockWrite(ASYNC, 4, "6\r\nTest 3\r\n"),
+      MockWrite(ASYNC, 5, "0\r\n\r\n"),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  ChunkedUploadDataStream upload_data_stream(0);
+  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://localhost");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Transfer-Encoding", "chunked");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(ERR_IO_PENDING, parser.SendRequest("POST / HTTP/1.1\r\n", headers,
+                                               &response, callback.callback()));
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData(kChunk1, arraysize(kChunk1) - 1, false);
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData(kChunk2, arraysize(kChunk2) - 1, false);
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData(kChunk3, arraysize(kChunk3) - 1, true);
+
+  ASSERT_EQ(OK, callback.WaitForResult());
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
+TEST(HttpStreamParser, SentBytesChunkedPostError) {
+  static const char kChunk[] = "Chunk 1";
+
+  MockWrite writes[] = {
+      MockWrite(ASYNC, 0, "POST / HTTP/1.1\r\n"),
+      MockWrite(ASYNC, 1, "Transfer-Encoding: chunked\r\n\r\n"),
+      MockWrite(ASYNC, 2, "7\r\nChunk 1\r\n"),
+      MockWrite(SYNCHRONOUS, ERR_FAILED, 3),
+  };
+
+  SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
+
+  ChunkedUploadDataStream upload_data_stream(0);
+  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://localhost");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
+  HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
+                          BoundNetLog());
+
+  HttpRequestHeaders headers;
+  headers.SetHeader("Transfer-Encoding", "chunked");
+
+  HttpResponseInfo response;
+  TestCompletionCallback callback;
+  ASSERT_EQ(ERR_IO_PENDING, parser.SendRequest("POST / HTTP/1.1\r\n", headers,
+                                               &response, callback.callback()));
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData(kChunk, arraysize(kChunk) - 1, false);
+
+  base::RunLoop().RunUntilIdle();
+  // This write should fail.
+  upload_data_stream.AppendData(kChunk, arraysize(kChunk) - 1, false);
+  ASSERT_EQ(ERR_FAILED, callback.WaitForResult());
+
+  EXPECT_EQ(WritesSize(writes, arraysize(writes)), parser.sent_bytes());
+}
+
 // Test that an HttpStreamParser can be read from after it's received headers
 // and data structures owned by its owner have been deleted.  This happens
 // when a ResponseBodyDrainer is used.
 TEST(HttpStreamParser, ReadAfterUnownedObjectsDestroyed) {
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0,
               "GET /foo.html HTTP/1.1\r\n\r\n"),
   };
 
   const int kBodySize = 1;
@@ skipping 31 matching lines @@
   response_info.reset();
 
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 }
 
 }  // namespace
 
 }  // namespace net