net: rename BoundNetLog to NetLogWithSource

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 <memory>
@@ skipping 61 matching lines @@
  public:
   enum class FailureMode { SYNC, ASYNC };
 
   explicit ReadErrorUploadDataStream(FailureMode mode)
       : UploadDataStream(true, 0), async_(mode), weak_factory_(this) {}
 
  private:
   void CompleteRead() { UploadDataStream::OnReadCompleted(ERR_FAILED); }
 
   // UploadDataStream implementation:
-  int InitInternal(const BoundNetLog& net_log) override { return OK; }
+  int InitInternal(const NetLogWithSource& net_log) override { return OK; }
 
   int ReadInternal(IOBuffer* buf, int buf_len) override {
     if (async_ == FailureMode::ASYNC) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ReadErrorUploadDataStream::CompleteRead,
                                 weak_factory_.GetWeakPtr()));
       return ERR_IO_PENDING;
     }
     return ERR_FAILED;
   }
@@ skipping 19 matching lines @@
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::SYNC);
 
   // Test upload progress before init.
   UploadProgress progress = upload_data_stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback(),
-                                      BoundNetLog()),
+                                      NetLogWithSource()),
               IsOk());
 
   // Test upload progress after init.
   progress = upload_data_stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 
   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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Content-Length", "12");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   int result = parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                   callback.callback());
   EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
@@ skipping 10 matching lines @@
       MockWrite(ASYNC, 1, "Content-Length: 12\r\n\r\n"),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::ASYNC);
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback(),
-                                      BoundNetLog()),
+                                      NetLogWithSource()),
               IsOk());
 
   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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Content-Length", "12");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   int result = parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                   callback.callback());
   EXPECT_THAT(result, IsError(ERR_IO_PENDING));
 
   UploadProgress progress = upload_data_stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 
   EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
 }
 
 class InitAsyncUploadDataStream : public ChunkedUploadDataStream {
  public:
   explicit InitAsyncUploadDataStream(int64_t identifier)
       : ChunkedUploadDataStream(identifier), weak_factory_(this) {}
 
  private:
   void CompleteInit() { UploadDataStream::OnInitCompleted(OK); }
 
-  int InitInternal(const BoundNetLog& net_log) override {
+  int InitInternal(const NetLogWithSource& net_log) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&InitAsyncUploadDataStream::CompleteInit,
                               weak_factory_.GetWeakPtr()));
     return ERR_IO_PENDING;
   }
 
   base::WeakPtrFactory<InitAsyncUploadDataStream> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InitAsyncUploadDataStream);
 };
 
 TEST(HttpStreamParser, InitAsynchronousUploadDataStream) {
   InitAsyncUploadDataStream upload_data_stream(0);
 
   TestCompletionCallback callback;
-  int result = upload_data_stream.Init(callback.callback(), BoundNetLog());
+  int result = upload_data_stream.Init(callback.callback(), NetLogWithSource());
   ASSERT_THAT(result, IsError(ERR_IO_PENDING));
 
   // Should be empty progress while initialization is in progress.
   UploadProgress progress = upload_data_stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
   EXPECT_THAT(callback.GetResult(result), IsOk());
 
   // Initialization complete.
   progress = upload_data_stream.GetUploadProgress();
@@ skipping 11 matching lines @@
       MockWrite(ASYNC, 1, "Transfer-Encoding: chunked\r\n\r\n"),
       MockWrite(ASYNC, 2, "7\r\nChunk 1\r\n"),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request, read_buffer.get(),
-                          BoundNetLog());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response;
   TestCompletionCallback callback1;
   int result1 = parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                    callback1.callback());
   EXPECT_EQ(ERR_IO_PENDING, result1);
   base::RunLoop().RunUntilIdle();
@@ skipping 73 matching lines @@
   // Shouldn't be merged if upload data is non-existent.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", NULL));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   std::unique_ptr<UploadDataStream> body(
       base::MakeUnique<ElementsUploadDataStream>(std::move(element_readers),
                                                  0));
-  ASSERT_THAT(body->Init(CompletionCallback(), BoundNetLog()), IsOk());
+  ASSERT_THAT(body->Init(CompletionCallback(), NetLogWithSource()), IsOk());
   // Shouldn't be merged if upload data is empty.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
   const std::string payload = "123";
   std::unique_ptr<ChunkedUploadDataStream> body(new ChunkedUploadDataStream(0));
   body->AppendData(payload.data(), payload.size(), true);
-  ASSERT_THAT(body->Init(TestCompletionCallback().callback(), BoundNetLog()),
-              IsOk());
+  ASSERT_THAT(
+      body->Init(TestCompletionCallback().callback(), NetLogWithSource()),
+      IsOk());
   // Shouldn't be merged if upload data carries chunked data.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
   // Create an empty temporary file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath temp_file_path;
   ASSERT_TRUE(
       base::CreateTemporaryFileInDir(temp_dir.GetPath(), &temp_file_path));
 
   {
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
 
     element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
         base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, 0,
         base::Time()));
 
     std::unique_ptr<UploadDataStream> body(
         new ElementsUploadDataStream(std::move(element_readers), 0));
     TestCompletionCallback callback;
-    ASSERT_THAT(body->Init(callback.callback(), BoundNetLog()),
+    ASSERT_THAT(body->Init(callback.callback(), NetLogWithSource()),
                 IsError(ERR_IO_PENDING));
     ASSERT_THAT(callback.WaitForResult(), IsOk());
     // Shouldn't be merged if upload data carries a file, as it's not in-memory.
     ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
         "some header", body.get()));
   }
 
   // UploadFileElementReaders may post clean-up tasks on destruction.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   const std::string payload = "123";
   element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
       payload.data(), payload.size()));
 
   std::unique_ptr<UploadDataStream> body(
       new ElementsUploadDataStream(std::move(element_readers), 0));
-  ASSERT_THAT(body->Init(CompletionCallback(), BoundNetLog()), IsOk());
+  ASSERT_THAT(body->Init(CompletionCallback(), NetLogWithSource()), IsOk());
   // Yes, should be merged if the in-memory body is small here.
   ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_LargeBodyInMemory) {
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   const std::string payload(10000, 'a');  // 'a' x 10000.
   element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
       payload.data(), payload.size()));
 
   std::unique_ptr<UploadDataStream> body(
       new ElementsUploadDataStream(std::move(element_readers), 0));
-  ASSERT_THAT(body->Init(CompletionCallback(), BoundNetLog()), IsOk());
+  ASSERT_THAT(body->Init(CompletionCallback(), NetLogWithSource()), IsOk());
   // Shouldn't be merged if the in-memory body is large here.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, SentBytesNoHeaders) {
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_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());
+                          NetLogWithSource());
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", HttpRequestHeaders(),
                                    &response, callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(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));
   std::unique_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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Host", "localhost");
   headers.SetHeader("Connection", "Keep-Alive");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
                                    callback.callback()));
 
@@ skipping 10 matching lines @@
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Host", "localhost");
   headers.SetHeader("Connection", "Keep-Alive");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
 
   EXPECT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
                                    callback.callback()));
@@ skipping 11 matching lines @@
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Host", "localhost");
   headers.SetHeader("Connection", "Keep-Alive");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_CONNECTION_RESET,
             parser.SendRequest("GET / HTTP/1.1\r\n", headers, &response,
                                callback.callback()));
@@ skipping 10 matching lines @@
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::MakeUnique<UploadBytesElementReader>("hello world!", 12));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback(),
-                                      BoundNetLog()),
+                                      NetLogWithSource()),
               IsOk());
 
   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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Content-Length", "12");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, parser.SendRequest("POST / HTTP/1.1\r\n", headers, &response,
                                    callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
@@ skipping 12 matching lines @@
       MockWrite(ASYNC, 2, "7\r\nChunk 1\r\n"),
       MockWrite(SYNCHRONOUS, ERR_FAILED, 3),
   };
 
   SequencedSocketData data(nullptr, 0, writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   ChunkedUploadDataStream upload_data_stream(0);
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback(),
-                                      BoundNetLog()),
+                                      NetLogWithSource()),
               IsOk());
 
   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());
+                          NetLogWithSource());
 
   HttpRequestHeaders headers;
   headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, parser.SendRequest("POST / HTTP/1.1\r\n", headers,
                                                &response, callback.callback()));
 
   base::RunLoop().RunUntilIdle();
@@ skipping 30 matching lines @@
   static const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_THAT(
-      upload_stream.Init(TestCompletionCallback().callback(), BoundNetLog()),
-      IsOk());
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
+                                 NetLogWithSource()),
+              IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
-                          BoundNetLog());
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 42 matching lines @@
   static const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_THAT(
-      upload_stream.Init(TestCompletionCallback().callback(), BoundNetLog()),
-      IsOk());
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
+                                 NetLogWithSource()),
+              IsOk());
   // Append the only chunk.
   upload_stream.AppendData(kChunk, arraysize(kChunk) - 1, true);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
-                          BoundNetLog());
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 44 matching lines @@
 
   MockRead reads[] = {
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 6, "Content-Length: 8\r\n\r\n"),
     MockRead(ASYNC, 7, "one.html"),
     MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   upload_stream.AppendData(kChunk1, arraysize(kChunk1) - 1, false);
-  ASSERT_THAT(
-      upload_stream.Init(TestCompletionCallback().callback(), BoundNetLog()),
-      IsOk());
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
+                                 NetLogWithSource()),
+              IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-  HttpStreamParser parser(
-      socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
+  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 48 matching lines @@
   const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_THAT(
-      upload_stream.Init(TestCompletionCallback().callback(), BoundNetLog()),
-      IsOk());
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
+                                 NetLogWithSource()),
+              IsOk());
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
-                          BoundNetLog());
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 37 matching lines @@
   const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
-  ASSERT_THAT(
-      upload_stream.Init(TestCompletionCallback().callback(), BoundNetLog()),
-      IsOk());
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
+                                 NetLogWithSource()),
+              IsOk());
   // Append final empty chunk.
   upload_stream.AppendData(nullptr, 0, true);
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
-                          BoundNetLog());
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 80 matching lines @@
       HttpRequestInfo request_info;
       request_info.method = "GET";
       if (protocol == HTTP) {
         request_info.url = GURL("http://localhost");
       } else {
         request_info.url = GURL("https://localhost");
       }
       request_info.load_flags = LOAD_NORMAL;
 
       scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-      HttpStreamParser parser(
-          socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
+      HttpStreamParser parser(socket_handle.get(), &request_info,
+                              read_buffer.get(), NetLogWithSource());
 
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
       TestCompletionCallback callback;
       ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
                                        &response_info, callback.callback()));
 
       int rv = parser.ReadResponseHeaders(callback.callback());
       EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
                 parser.sent_bytes());
@@ skipping 35 matching lines @@
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.load_flags = LOAD_NORMAL;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-  HttpStreamParser parser(
-      socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
+  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
+                          NetLogWithSource());
 
   HttpRequestHeaders request_headers;
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
                                    &response_info, callback.callback()));
 
   EXPECT_THAT(parser.ReadResponseHeaders(callback.callback()), IsOk());
   ASSERT_TRUE(response_info.headers.get());
   EXPECT_EQ(101, response_info.headers->response_code());
@@ skipping 49 matching lines @@
     reads_.push_back(MockRead(SYNCHRONOUS, 0, sequence_number_++));  // EOF
 
     data_.reset(new SequencedSocketData(&reads_.front(), reads_.size(),
                                         &writes_.front(), writes_.size()));
     socket_handle_ = CreateConnectedSocketHandle(data_.get());
 
     request_info_.method = "GET";
     request_info_.url = url_;
     request_info_.load_flags = LOAD_NORMAL;
 
-    parser_.reset(new HttpStreamParser(
-        socket_handle_.get(), &request_info_, read_buffer(), BoundNetLog()));
+    parser_.reset(new HttpStreamParser(socket_handle_.get(), &request_info_,
+                                       read_buffer(), NetLogWithSource()));
 
     parser_->set_http_09_on_non_default_ports_enabled(
         http_09_on_non_default_ports_enabled_);
 
     TestCompletionCallback callback;
     ASSERT_EQ(OK, parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
                                        &response_info_, callback.callback()));
   }
 
   void ReadHeadersExpectingError(Error error) {
@@ skipping 351 matching lines @@
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   std::unique_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   std::unique_ptr<HttpRequestInfo> request_info(new HttpRequestInfo());
   request_info->method = "GET";
   request_info->url = GURL("http://somewhere/foo.html");
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), request_info.get(),
-                          read_buffer.get(), BoundNetLog());
+                          read_buffer.get(), NetLogWithSource());
 
   std::unique_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
   std::unique_ptr<HttpResponseInfo> response_info(new HttpResponseInfo());
   TestCompletionCallback callback;
   ASSERT_EQ(OK, parser.SendRequest("GET /foo.html HTTP/1.1\r\n",
             *request_headers, response_info.get(), callback.callback()));
   ASSERT_THAT(parser.ReadResponseHeaders(callback.callback()), IsOk());
 
   // If the object that owns the HttpStreamParser is deleted, it takes the
   // objects passed to the HttpStreamParser with it.
   request_info.reset();
   request_headers.reset();
   response_info.reset();
 
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
 }
 
 }  // namespace
 
 }  // namespace net