net: rename BoundNetLog to NetLogWithSource

net/proxy/proxy_service.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/proxy_service.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 169 matching lines @@
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() {}
 
   // ProxyResolver implementation.
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
                      RequestHandle* request,
-                     const BoundNetLog& net_log) override {
+                     const NetLogWithSource& net_log) override {
     return ERR_NOT_IMPLEMENTED;
   }
 
   void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
   LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
 };
 
 // ProxyResolver that simulates a PAC script which returns
 // |pac_string| for every single URL.
 class ProxyResolverFromPacString : public ProxyResolver {
  public:
   explicit ProxyResolverFromPacString(const std::string& pac_string)
       : pac_string_(pac_string) {}
 
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
                      RequestHandle* request,
-                     const BoundNetLog& net_log) override {
+                     const NetLogWithSource& net_log) override {
     results->UsePacString(pac_string_);
     return OK;
   }
 
   void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
   LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
@@ skipping 560 matching lines @@
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              const std::string& method,
              ProxyDelegate* proxy_delegate,
              ProxyInfo* results,
              const CompletionCallback& user_callback,
-             const BoundNetLog& net_log)
+             const NetLogWithSource& net_log)
       : service_(service),
         user_callback_(user_callback),
         results_(results),
         url_(url),
         method_(method),
         proxy_delegate_(proxy_delegate),
         resolve_job_(NULL),
         config_id_(ProxyConfig::kInvalidConfigID),
         config_source_(PROXY_CONFIG_SOURCE_UNKNOWN),
         net_log_(net_log),
@@ skipping 83 matching lines @@
     results_->proxy_resolve_start_time_ = creation_time_;
     results_->proxy_resolve_end_time_ = TimeTicks::Now();
 
     // Reset the state associated with in-progress-resolve.
     config_id_ = ProxyConfig::kInvalidConfigID;
     config_source_ = PROXY_CONFIG_SOURCE_UNKNOWN;
 
     return rv;
   }
 
-  BoundNetLog* net_log() { return &net_log_; }
+  NetLogWithSource* net_log() { return &net_log_; }
 
   LoadState GetLoadState() const {
     if (is_started())
       return resolver()->GetLoadState(resolve_job_);
     return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
   }
 
  private:
   friend class base::RefCounted<ProxyService::PacRequest>;
 
@@ skipping 19 matching lines @@
   // to be valid throughout our lifetime.
   ProxyService* service_;
   CompletionCallback user_callback_;
   ProxyInfo* results_;
   GURL url_;
   std::string method_;
   ProxyDelegate* proxy_delegate_;
   ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   ProxyConfigSource config_source_;  // The source of proxy settings.
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   // Time when the request was created.  Stored here rather than in |results_|
   // because the time in |results_| will be cleared.
   TimeTicks creation_time_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(
     std::unique_ptr<ProxyConfigService> config_service,
     std::unique_ptr<ProxyResolverFactory> resolver_factory,
@@ skipping 82 matching lines @@
       std::move(proxy_config_service),
       base::MakeUnique<ProxyResolverFactoryForPacResult>(pac_string), NULL));
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                const std::string& method,
                                ProxyInfo* result,
                                const CompletionCallback& callback,
                                PacRequest** pac_request,
                                ProxyDelegate* proxy_delegate,
-                               const BoundNetLog& net_log) {
+                               const NetLogWithSource& net_log) {
   DCHECK(!callback.is_null());
   return ResolveProxyHelper(raw_url, method, result, callback, pac_request,
                             proxy_delegate, net_log);
 }
 
 int ProxyService::ResolveProxyHelper(const GURL& raw_url,
                                      const std::string& method,
                                      ProxyInfo* result,
                                      const CompletionCallback& callback,
                                      PacRequest** pac_request,
                                      ProxyDelegate* proxy_delegate,
-                                     const BoundNetLog& net_log) {
+                                     const NetLogWithSource& net_log) {
   DCHECK(CalledOnValidThread());
 
   net_log.BeginEvent(NetLogEventType::PROXY_SERVICE);
 
   // Notify our polling-based dependencies that a resolve is taking place.
   // This way they can schedule their polls in response to network activity.
   config_service_->OnLazyPoll();
   if (script_poller_.get())
      script_poller_->OnLazyPoll();
 
@@ skipping 36 matching lines @@
   DCHECK(!ContainsPendingRequest(req.get()));
   pending_requests_.insert(req);
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
   return rv;  // ERR_IO_PENDING
 }
 
-bool ProxyService::TryResolveProxySynchronously(const GURL& raw_url,
-                                                const std::string& method,
-                                                ProxyInfo* result,
-                                                ProxyDelegate* proxy_delegate,
-                                                const BoundNetLog& net_log) {
+bool ProxyService::TryResolveProxySynchronously(
+    const GURL& raw_url,
+    const std::string& method,
+    ProxyInfo* result,
+    ProxyDelegate* proxy_delegate,
+    const NetLogWithSource& net_log) {
   CompletionCallback null_callback;
   return ResolveProxyHelper(raw_url, method, result, null_callback,
                             nullptr /* pac_request*/, proxy_delegate,
                             net_log) == OK;
 }
 
 int ProxyService::TryToCompleteSynchronously(const GURL& url,
                                              ProxyDelegate* proxy_delegate,
                                              ProxyInfo* result) {
   DCHECK_NE(STATE_NONE, current_state_);
@@ skipping 147 matching lines @@
   SetReady();
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             const std::string& method,
                                             int net_error,
                                             ProxyInfo* result,
                                             const CompletionCallback& callback,
                                             PacRequest** pac_request,
                                             ProxyDelegate* proxy_delegate,
-                                            const BoundNetLog& net_log) {
+                                            const NetLogWithSource& net_log) {
   DCHECK(CalledOnValidThread());
 
   // Check to see if we have a new config since ResolveProxy was called.  We
   // want to re-run ResolveProxy in two cases: 1) we have a new config, or 2) a
   // direct connection failed and we never tried the current config.
 
   DCHECK(result);
   bool re_resolve = result->config_id_ != config_.id();
 
   if (re_resolve) {
@@ skipping 13 matching lines @@
 
   // Return synchronous failure if there is nothing left to fall-back to.
   // TODO(eroman): This is a yucky API, clean it up.
   return did_fallback ? OK : ERR_FAILED;
 }
 
 bool ProxyService::MarkProxiesAsBadUntil(
     const ProxyInfo& result,
     base::TimeDelta retry_delay,
     const std::vector<ProxyServer>& additional_bad_proxies,
-    const BoundNetLog& net_log) {
+    const NetLogWithSource& net_log) {
   result.proxy_list_.UpdateRetryInfoOnFallback(&proxy_retry_info_, retry_delay,
                                                false, additional_bad_proxies,
                                                OK, net_log);
   return result.proxy_list_.size() > (additional_bad_proxies.size() + 1);
 }
 
 void ProxyService::ReportSuccess(const ProxyInfo& result,
                                  ProxyDelegate* proxy_delegate) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 44 matching lines @@
 void ProxyService::RemovePendingRequest(PacRequest* req) {
   DCHECK(ContainsPendingRequest(req));
   pending_requests_.erase(req);
 }
 
 int ProxyService::DidFinishResolvingProxy(const GURL& url,
                                           const std::string& method,
                                           ProxyDelegate* proxy_delegate,
                                           ProxyInfo* result,
                                           int result_code,
-                                          const BoundNetLog& net_log,
+                                          const NetLogWithSource& net_log,
                                           base::TimeTicks start_time,
                                           bool script_executed) {
   // Don't track any metrics if start_time is 0, which will happen when the user
   // calls |TryResolveProxySynchronously|.
   if (!start_time.is_null()) {
     TimeDelta diff = TimeTicks::Now() - start_time;
     if (script_executed) {
       // This function "fixes" the result code, so make sure script terminated
       // errors are tracked. Only track result codes that were a result of
       // script execution.
@@ skipping 276 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net