Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/proxy/proxy_service.cc

 // Copyright (c) 2006-2008 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 "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 228 matching lines @@
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
   return Create(&pc, false, NULL, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateNull() {
   // Use a configuration fetcher and proxy resolver which always fail.
   return new ProxyService(new ProxyConfigServiceNull, new ProxyResolverNull);
 }
 
-int ProxyService::ResolveProxy(const GURL& raw_url, ProxyInfo* result,
+int ProxyService::ResolveProxy(LoadLog* load_log,
+                               const GURL& raw_url,
+                               ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request) {
   DCHECK(callback);
 
   // Strip away any reference fragments and the username/password, as they
   // are not relevant to proxy resolution.
   GURL url = SimplifyUrlForRequest(raw_url);
 
   // Check if the request can be completed right away. This is the case when
   // using a direct connection, or when the config is bad.
@@ skipping 136 matching lines @@
   if (result != OK) {
     LOG(INFO) << "Failed configuring with PAC script, falling-back to manual "
                  "proxy servers.";
   }
 
   // Resume any requests which we had to defer until the PAC script was
   // downloaded.
   ResumeAllPendingRequests();
 }
 
-int ProxyService::ReconsiderProxyAfterError(const GURL& url,
+int ProxyService::ReconsiderProxyAfterError(LoadLog* load_log,
+                                            const GURL& url,
                                             ProxyInfo* result,
                                             CompletionCallback* callback,
                                             PacRequest** pac_request) {
   // 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.
 
   bool re_resolve = result->config_id_ != config_.id();
   if (!re_resolve) {
     UpdateConfig();
     if (result->config_id_ != config_.id()) {
       // A new configuration!
       re_resolve = true;
     } else if (!result->config_was_tried_) {
       // We never tried the proxy configuration since we thought it was bad,
       // but because we failed to establish a connection, let's try the proxy
       // configuration again to see if it will work now.
       config_is_bad_ = false;
       re_resolve = true;
     }
   }
   if (re_resolve) {
     // If we have a new config or the config was never tried, we delete the
     // list of bad proxies and we try again.
     proxy_retry_info_.clear();
-    return ResolveProxy(url, result, callback, pac_request);
+    return ResolveProxy(load_log, url, result, callback, pac_request);
   }
 
   // We don't have new proxy settings to try, fallback to the next proxy
   // in the list.
   bool was_direct = result->is_direct();
   if (!was_direct && result->Fallback(&proxy_retry_info_))
     return OK;
 
   // TODO(eroman): Hmm, this doesn't seem right. For starters just because
   // auto_detect is true doesn't mean we are actually using it.
@@ skipping 249 matching lines @@
 SyncProxyServiceHelper::SyncProxyServiceHelper(MessageLoop* io_message_loop,
                                                ProxyService* proxy_service)
     : io_message_loop_(io_message_loop),
       proxy_service_(proxy_service),
       event_(false, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
           this, &SyncProxyServiceHelper::OnCompletion)) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 }
 
-int SyncProxyServiceHelper::ResolveProxy(const GURL& url,
+int SyncProxyServiceHelper::ResolveProxy(LoadLog* load_log,
+                                         const GURL& url,
                                          ProxyInfo* proxy_info) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
   io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncResolve, url));
+      this, &SyncProxyServiceHelper::StartAsyncResolve, load_log, url));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
-int SyncProxyServiceHelper::ReconsiderProxyAfterError(const GURL& url,
-                                                      ProxyInfo* proxy_info) {
+int SyncProxyServiceHelper::ReconsiderProxyAfterError(
+    LoadLog* load_log, const GURL& url, ProxyInfo* proxy_info) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
   io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncReconsider, url));
+      this, &SyncProxyServiceHelper::StartAsyncReconsider, load_log, url));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
-void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url) {
-  result_ = proxy_service_->ResolveProxy(url, &proxy_info_, &callback_, NULL);
+void SyncProxyServiceHelper::StartAsyncResolve(LoadLog* load_log,
+                                               const GURL& url) {
+  result_ = proxy_service_->ResolveProxy(
+      load_log, url, &proxy_info_, &callback_, NULL);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
-void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url) {
+void SyncProxyServiceHelper::StartAsyncReconsider(LoadLog* load_log,
+                                                  const GURL& url) {
   result_ = proxy_service_->ReconsiderProxyAfterError(
-      url, &proxy_info_, &callback_, NULL);
+      load_log, url, &proxy_info_, &callback_, NULL);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net