net: rename BoundNetLog to NetLogWithSource

net/dns/mojo_host_resolver_impl.cc

 // Copyright 2015 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/dns/mojo_host_resolver_impl.h"
 
 #include <utility>
 
 #include "base/stl_util.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mojo_host_type_converters.h"
 
 namespace net {
 
 // Handles host resolution for a single request and sends a response when done.
 // Also detects connection errors for HostResolverRequestClient and cancels the
 // outstanding resolve request. Owned by MojoHostResolverImpl.
 class MojoHostResolverImpl::Job {
  public:
   Job(MojoHostResolverImpl* resolver_service,
       net::HostResolver* resolver,
       const net::HostResolver::RequestInfo& request_info,
-      const BoundNetLog& net_log,
+      const NetLogWithSource& net_log,
       interfaces::HostResolverRequestClientPtr client);
   ~Job();
 
   void Start();
 
  private:
   // Completion callback for the HostResolver::Resolve request.
   void OnResolveDone(int result);
 
   // Mojo error handler.
   void OnConnectionError();
 
   MojoHostResolverImpl* resolver_service_;
   net::HostResolver* resolver_;
   net::HostResolver::RequestInfo request_info_;
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
   interfaces::HostResolverRequestClientPtr client_;
   std::unique_ptr<net::HostResolver::Request> request_;
   AddressList result_;
   base::ThreadChecker thread_checker_;
 };
 
 MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver,
-                                           const BoundNetLog& net_log)
-    : resolver_(resolver), net_log_(net_log) {
-}
+                                           const NetLogWithSource& net_log)
+    : resolver_(resolver), net_log_(net_log) {}
 
 MojoHostResolverImpl::~MojoHostResolverImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::STLDeleteElements(&pending_jobs_);
 }
 
 void MojoHostResolverImpl::Resolve(
     interfaces::HostResolverRequestInfoPtr request_info,
     interfaces::HostResolverRequestClientPtr client) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 15 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num_erased = pending_jobs_.erase(job);
   DCHECK(num_erased);
   delete job;
 }
 
 MojoHostResolverImpl::Job::Job(
     MojoHostResolverImpl* resolver_service,
     net::HostResolver* resolver,
     const net::HostResolver::RequestInfo& request_info,
-    const BoundNetLog& net_log,
+    const NetLogWithSource& net_log,
     interfaces::HostResolverRequestClientPtr client)
     : resolver_service_(resolver_service),
       resolver_(resolver),
       request_info_(request_info),
       net_log_(net_log),
       client_(std::move(client)) {
   client_.set_connection_error_handler(base::Bind(
       &MojoHostResolverImpl::Job::OnConnectionError, base::Unretained(this)));
 }
 
@@ skipping 32 matching lines @@
 void MojoHostResolverImpl::Job::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // |resolver_service_| should always outlive us.
   DCHECK(resolver_service_);
   DVLOG(1) << "Connection error on request for "
            << request_info_.host_port_pair().ToString();
   resolver_service_->DeleteJob(this);
 }
 
 }  // namespace net