net: rename BoundNetLog to NetLogWithSource

net/proxy/proxy_resolver_factory_mojo.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/proxy/proxy_resolver_factory_mojo.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
 
 // A mixin that forwards logging to (Bound)NetLog and ProxyResolverErrorObserver
 // and DNS requests to a MojoHostResolverImpl, which is implemented in terms of
 // a HostResolver.
 template <typename ClientInterface>
 class ClientMixin : public ClientInterface {
  public:
   ClientMixin(HostResolver* host_resolver,
               ProxyResolverErrorObserver* error_observer,
               NetLog* net_log,
-              const BoundNetLog& bound_net_log)
+              const NetLogWithSource& bound_net_log)
       : host_resolver_(host_resolver, bound_net_log),
         error_observer_(error_observer),
         net_log_(net_log),
         bound_net_log_(bound_net_log) {}
 
   // Overridden from ClientInterface:
   void Alert(const mojo::String& message) override {
     base::string16 message_str = message.To<base::string16>();
     auto callback = NetLog::StringCallback("message", &message_str);
     bound_net_log_.AddEvent(NetLogEventType::PAC_JAVASCRIPT_ALERT, callback);
@@ skipping 18 matching lines @@
 
  protected:
   bool dns_request_in_progress() {
     return host_resolver_.request_in_progress();
   }
 
  private:
   MojoHostResolverImpl host_resolver_;
   ProxyResolverErrorObserver* const error_observer_;
   NetLog* const net_log_;
-  const BoundNetLog bound_net_log_;
+  const NetLogWithSource bound_net_log_;
 };
 
 // Implementation of ProxyResolver that connects to a Mojo service to evaluate
 // PAC scripts. This implementation only knows about Mojo services, and
 // therefore that service may live in or out of process.
 //
 // This implementation reports disconnections from the Mojo service (i.e. if the
 // service is out-of-process and that process crashes) using the error code
 // ERR_PAC_SCRIPT_TERMINATED.
 class ProxyResolverMojo : public ProxyResolver {
  public:
   // Constructs a ProxyResolverMojo that connects to a mojo proxy resolver
   // implementation using |resolver_ptr|. The implementation uses
   // |host_resolver| as the DNS resolver, using |host_resolver_binding| to
   // communicate with it. When deleted, the closure contained within
   // |on_delete_callback_runner| will be run.
   ProxyResolverMojo(
       interfaces::ProxyResolverPtr resolver_ptr,
       HostResolver* host_resolver,
       std::unique_ptr<base::ScopedClosureRunner> on_delete_callback_runner,
       std::unique_ptr<ProxyResolverErrorObserver> error_observer,
       NetLog* net_log);
   ~ProxyResolverMojo() override;
 
   // ProxyResolver implementation:
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const net::CompletionCallback& callback,
                      RequestHandle* request,
-                     const BoundNetLog& net_log) override;
+                     const NetLogWithSource& net_log) override;
   void CancelRequest(RequestHandle request) override;
   LoadState GetLoadState(RequestHandle request) const override;
 
  private:
   class Job;
 
   // Mojo error handler.
   void OnConnectionError();
 
   void RemoveJob(Job* job);
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverMojo);
 };
 
 class ProxyResolverMojo::Job
     : public ClientMixin<interfaces::ProxyResolverRequestClient> {
  public:
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
       ProxyInfo* results,
       const CompletionCallback& callback,
-      const BoundNetLog& net_log);
+      const NetLogWithSource& net_log);
   ~Job() override;
 
   // Cancels the job and prevents the callback from being run.
   void Cancel();
 
   // Returns the LoadState of this job.
   LoadState GetLoadState();
 
  private:
   // Mojo error handler.
@@ skipping 10 matching lines @@
   CompletionCallback callback_;
 
   base::ThreadChecker thread_checker_;
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 };
 
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log)
+                            const NetLogWithSource& net_log)
     : ClientMixin<interfaces::ProxyResolverRequestClient>(
           resolver->host_resolver_,
           resolver->error_observer_.get(),
           resolver->net_log_,
           net_log),
       resolver_(resolver),
       url_(url),
       results_(results),
       callback_(callback),
       binding_(this) {
@@ skipping 76 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num_erased = pending_jobs_.erase(job);
   DCHECK(num_erased);
   delete job;
 }
 
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const CompletionCallback& callback,
                                       RequestHandle* request,
-                                      const BoundNetLog& net_log) {
+                                      const NetLogWithSource& net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!mojo_proxy_resolver_ptr_)
     return ERR_PAC_SCRIPT_TERMINATED;
 
   Job* job = new Job(this, url, results, callback, net_log);
   bool inserted = pending_jobs_.insert(job).second;
   DCHECK(inserted);
   *request = job;
 
@@ skipping 13 matching lines @@
   CHECK_EQ(1u, pending_jobs_.count(job));
   return job->GetLoadState();
 }
 
 }  // namespace
 
 // A Job to create a ProxyResolver instance.
 //
 // Note: a Job instance is not tied to a particular resolve request, and hence
 // there is no per-request logging to be done (any netlog events are only sent
-// globally) so this always uses an empty BoundNetLog.
+// globally) so this always uses an empty NetLogWithSource.
 class ProxyResolverFactoryMojo::Job
     : public ClientMixin<interfaces::ProxyResolverFactoryRequestClient>,
       public ProxyResolverFactory::Request {
  public:
   Job(ProxyResolverFactoryMojo* factory,
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
       std::unique_ptr<ProxyResolver>* resolver,
       const CompletionCallback& callback,
       std::unique_ptr<ProxyResolverErrorObserver> error_observer)
       : ClientMixin<interfaces::ProxyResolverFactoryRequestClient>(
             factory->host_resolver_,
             error_observer.get(),
             factory->net_log_,
-            BoundNetLog()),
+            NetLogWithSource()),
         factory_(factory),
         resolver_(resolver),
         callback_(callback),
         binding_(this),
         error_observer_(std::move(error_observer)) {
     on_delete_callback_runner_ = factory_->mojo_proxy_factory_->CreateResolver(
         mojo::String::From(pac_script->utf16()), mojo::GetProxy(&resolver_ptr_),
         binding_.CreateInterfacePtrAndBind());
     resolver_ptr_.set_connection_error_handler(
         base::Bind(&ProxyResolverFactoryMojo::Job::OnConnectionError,
@@ skipping 54 matching lines @@
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback,
                          error_observer_factory_.is_null()
                              ? nullptr
                              : error_observer_factory_.Run()));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net