net: rename BoundNetLog to NetLogWithSource

net/proxy/multi_threaded_proxy_resolver.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/proxy/multi_threaded_proxy_resolver.h"
 
 #include <deque>
 #include <utility>
 #include <vector>
 
@@ skipping 101 matching lines @@
       const scoped_refptr<ProxyResolverScriptData>& script_data,
       scoped_refptr<Executor> executor);
 
   ~MultiThreadedProxyResolver() override;
 
   // ProxyResolver implementation:
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const 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 GetProxyForURLJob;
   // FIFO queue of pending jobs waiting to be started.
   // TODO(eroman): Make this priority queue.
   typedef std::deque<scoped_refptr<Job>> PendingJobsQueue;
   typedef std::vector<scoped_refptr<Executor>> ExecutorList;
 
@@ skipping 142 matching lines @@
 
 // MultiThreadedProxyResolver::GetProxyForURLJob ------------------------------
 
 class MultiThreadedProxyResolver::GetProxyForURLJob : public Job {
  public:
   // |url|         -- the URL of the query.
   // |results|     -- the structure to fill with proxy resolve results.
   GetProxyForURLJob(const GURL& url,
                     ProxyInfo* results,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log)
+                    const NetLogWithSource& net_log)
       : Job(TYPE_GET_PROXY_FOR_URL, callback),
         results_(results),
         net_log_(net_log),
         url_(url),
         was_waiting_for_thread_(false) {
     DCHECK(!callback.is_null());
   }
 
-  BoundNetLog* net_log() { return &net_log_; }
+  NetLogWithSource* net_log() { return &net_log_; }
 
   void WaitingForThread() override {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(NetLogEventType::WAITING_FOR_PROXY_RESOLVER_THREAD);
   }
 
   void FinishedWaitingForThread() override {
     DCHECK(executor());
 
     if (was_waiting_for_thread_) {
@@ skipping 30 matching lines @@
       }
       RunUserCallback(result_code);
     }
     OnJobCompleted();
   }
 
   // Must only be used on the "origin" thread.
   ProxyInfo* results_;
 
   // Can be used on either "origin" or worker thread.
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   const GURL url_;
 
   // Usable from within DoQuery on the worker thread.
   ProxyInfo results_buf_;
 
   bool was_waiting_for_thread_;
 };
 
 // Executor ----------------------------------------
 
@@ skipping 80 matching lines @@
   DCHECK(CalledOnValidThread());
   // We will cancel all outstanding requests.
   pending_jobs_.clear();
 
   for (auto& executor : executors_) {
     executor->Destroy();
   }
 }
 
 int MultiThreadedProxyResolver::GetProxyForURL(
-    const GURL& url, ProxyInfo* results, const CompletionCallback& callback,
-    RequestHandle* request, const BoundNetLog& net_log) {
+    const GURL& url,
+    ProxyInfo* results,
+    const CompletionCallback& callback,
+    RequestHandle* request,
+    const NetLogWithSource& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   scoped_refptr<GetProxyForURLJob> job(
       new GetProxyForURLJob(url, results, callback, net_log));
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
   if (request)
     *request = reinterpret_cast<RequestHandle>(job.get());
@@ skipping 167 matching lines @@
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolverFactory::RemoveJob(
     MultiThreadedProxyResolverFactory::Job* job) {
   size_t erased = jobs_.erase(job);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace net