net: rename BoundNetLog to NetLogWithSource

net/http/http_transaction_test_util.cc

 // Copyright 2014 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_transaction_test_util.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
@@ skipping 145 matching lines @@
     : state_(IDLE), error_(OK) {
   // Disregard the error code.
   factory->CreateTransaction(priority, &trans_);
   ++quit_counter_;
 }
 
 TestTransactionConsumer::~TestTransactionConsumer() {
 }
 
 void TestTransactionConsumer::Start(const HttpRequestInfo* request,
-                                    const BoundNetLog& net_log) {
+                                    const NetLogWithSource& net_log) {
   state_ = STARTING;
   int result = trans_->Start(
       request, base::Bind(&TestTransactionConsumer::OnIOComplete,
                           base::Unretained(this)), net_log);
   if (result != ERR_IO_PENDING)
     DidStart(result);
 }
 
 void TestTransactionConsumer::DidStart(int result) {
   if (result != OK) {
@@ skipping 55 matching lines @@
       received_bytes_(0),
       sent_bytes_(0),
       socket_log_id_(NetLog::Source::kInvalidId),
       done_reading_called_(false),
       weak_factory_(this) {}
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
                                   const CompletionCallback& callback,
-                                  const BoundNetLog& net_log) {
+                                  const NetLogWithSource& net_log) {
   if (request_)
     return ERR_FAILED;
 
   request_ = request;
   return StartInternal(request, callback, net_log);
 }
 
 int MockNetworkTransaction::RestartIgnoringLastError(
     const CompletionCallback& callback) {
   return ERR_FAILED;
@@ skipping 11 matching lines @@
     const CompletionCallback& callback) {
   if (!IsReadyToRestartForAuth())
     return ERR_FAILED;
 
   HttpRequestInfo auth_request_info = *request_;
   auth_request_info.extra_headers.SetHeader("Authorization", "Bar");
 
   // Let the MockTransactionHandler worry about this: the only way for this
   // test to succeed is by using an explicit handler for the transaction so
   // that server behavior can be simulated.
-  return StartInternal(&auth_request_info, callback, BoundNetLog());
+  return StartInternal(&auth_request_info, callback, NetLogWithSource());
 }
 
 void MockNetworkTransaction::PopulateNetErrorDetails(
     NetErrorDetails* /*details*/) const {
   NOTIMPLEMENTED();
 }
 
 bool MockNetworkTransaction::IsReadyToRestartForAuth() {
   if (!request_)
     return false;
@@ skipping 108 matching lines @@
 }
 
 // static
 const int64_t MockNetworkTransaction::kTotalReceivedBytes = 1000;
 
 // static
 const int64_t MockNetworkTransaction::kTotalSentBytes = 100;
 
 int MockNetworkTransaction::StartInternal(const HttpRequestInfo* request,
                                           const CompletionCallback& callback,
-                                          const BoundNetLog& net_log) {
+                                          const NetLogWithSource& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return ERR_FAILED;
 
   if (!before_network_start_callback_.is_null()) {
     bool defer = false;
     before_network_start_callback_.Run(&defer);
     if (defer)
       return net::ERR_IO_PENDING;
   }
@@ skipping 158 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net