net: rename BoundNetLog to NetLogWithSource

net/quic/chromium/quic_end_to_end_unittest.cc

 // Copyright 2013 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 <memory>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 201 matching lines @@
   void InitializePostRequest(size_t length) {
     GenerateBody(length);
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
     element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
         request_body_.data(), request_body_.length()));
     upload_data_stream_.reset(
         new ElementsUploadDataStream(std::move(element_readers), 0));
     request_.method = "POST";
     request_.url = GURL("https://test.example.com/");
     request_.upload_data_stream = upload_data_stream_.get();
-    ASSERT_THAT(
-        request_.upload_data_stream->Init(CompletionCallback(), BoundNetLog()),
-        IsOk());
+    ASSERT_THAT(request_.upload_data_stream->Init(CompletionCallback(),
+                                                  NetLogWithSource()),
+                IsOk());
   }
 
   // Checks that |consumer| completed and received |status_line| and |body|.
   void CheckResponse(const TestTransactionConsumer& consumer,
                      const std::string& status_line,
                      const std::string& body) {
     ASSERT_TRUE(consumer.is_done());
     ASSERT_THAT(consumer.error(), IsOk());
     EXPECT_EQ(status_line, consumer.response_info()->headers->GetStatusLine());
     EXPECT_EQ(body, consumer.content());
@@ skipping 28 matching lines @@
                         QuicEndToEndTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
   std::string response(10 * 1024, 'x');
 
   AddToCache(request_.url.PathForRequest(), 200, "OK", response);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
-  consumer.Start(&request_, BoundNetLog());
+  consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   CheckResponse(consumer, "HTTP/1.1 200", response);
 }
 
 TEST_P(QuicEndToEndTest, TokenBinding) {
   // Enable token binding and re-initialize the TestTransactionFactory.
   params_.enable_token_binding = true;
   transaction_factory_.reset(new TestTransactionFactory(params_));
 
   AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
-  consumer.Start(&request_, BoundNetLog());
+  consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   CheckResponse(consumer, "HTTP/1.1 200", kResponseBody);
   HttpRequestHeaders headers;
   ASSERT_TRUE(consumer.transaction()->GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 
 // crbug.com/559173
 #if defined(THREAD_SANITIZER)
 TEST_P(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
 #else
 TEST_P(QuicEndToEndTest, LargePostWithNoPacketLoss) {
 #endif
   InitializePostRequest(1024 * 1024);
 
   AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
-  consumer.Start(&request_, BoundNetLog());
+  consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   CheckResponse(consumer, "HTTP/1.1 200", kResponseBody);
 }
 
 // crbug.com/559173
 #if defined(THREAD_SANITIZER)
 TEST_P(QuicEndToEndTest, DISABLED_LargePostWithPacketLoss) {
 #else
 TEST_P(QuicEndToEndTest, LargePostWithPacketLoss) {
 #endif
   // FLAGS_fake_packet_loss_percentage = 30;
   InitializePostRequest(1024 * 1024);
 
   const char kResponseBody[] = "some really big response body";
   AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
-  consumer.Start(&request_, BoundNetLog());
+  consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   CheckResponse(consumer, "HTTP/1.1 200", kResponseBody);
 }
 
 // crbug.com/536845
 #if defined(THREAD_SANITIZER)
 TEST_P(QuicEndToEndTest, DISABLED_UberTest) {
 #else
 TEST_P(QuicEndToEndTest, UberTest) {
 #endif
   // FLAGS_fake_packet_loss_percentage = 30;
 
   const char kResponseBody[] = "some really big response body";
   AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   std::vector<TestTransactionConsumer*> consumers;
   size_t num_requests = 100;
   for (size_t i = 0; i < num_requests; ++i) {
     TestTransactionConsumer* consumer = new TestTransactionConsumer(
         DEFAULT_PRIORITY, transaction_factory_.get());
     consumers.push_back(consumer);
-    consumer->Start(&request_, BoundNetLog());
+    consumer->Start(&request_, NetLogWithSource());
   }
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   for (size_t i = 0; i < num_requests; ++i) {
     CheckResponse(*consumers[i], "HTTP/1.1 200", kResponseBody);
   }
   base::STLDeleteElements(&consumers);
 }
 
 }  // namespace test
 }  // namespace net