Log the results of proxy resolution to LoadLog when "full logging mode" is en...

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 140 matching lines @@
     DCHECK(!was_cancelled());
 
     // Make a note in the results which configuration was in use at the
     // time of the resolve.
     results_->config_id_ = config_id_;
 
     // Reset the state associated with in-progress-resolve.
     resolve_job_ = NULL;
     config_id_ = ProxyConfig::INVALID_ID;
 
-    // Clean up the results list.
-    if (result_code == OK)
-      results_->RemoveBadProxies(service_->proxy_retry_info_);
-
-    LoadLog::EndEvent(load_log_, LoadLog::TYPE_PROXY_SERVICE);
-
-    return result_code;
+    return service_->DidFinishResolvingProxy(results_, result_code, load_log_);
   }
 
   LoadLog* load_log() const { return load_log_; }
 
  private:
   friend class base::RefCounted<ProxyService::PacRequest>;
 
   ~PacRequest() {}
 
   // Callback for when the ProxyResolver request has completed.
@@ skipping 92 matching lines @@
   LoadLog::BeginEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
 
   // 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.
   UpdateConfigIfOld(load_log);
   int rv = TryToCompleteSynchronously(url, result);
-  if (rv != ERR_IO_PENDING) {
-    LoadLog::EndEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
-    return rv;
-  }
+  if (rv != ERR_IO_PENDING)
+    return DidFinishResolvingProxy(result, rv, load_log);
 
   scoped_refptr<PacRequest> req =
       new PacRequest(this, url, result, callback, load_log);
 
   bool resolver_is_ready = !IsInitializingProxyResolver();
 
   if (resolver_is_ready) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
@@ skipping 176 matching lines @@
   return pending_requests_.end() != it;
 }
 
 void ProxyService::RemovePendingRequest(PacRequest* req) {
   DCHECK(ContainsPendingRequest(req));
   PendingRequests::iterator it = std::find(
       pending_requests_.begin(), pending_requests_.end(), req);
   pending_requests_.erase(it);
 }
 
+int ProxyService::DidFinishResolvingProxy(ProxyInfo* result,
+                                          int result_code,
+                                          LoadLog* load_log) {
+  // Log the result of the proxy resolution.
+  if (result_code == OK) {
+    // When full logging is enabled, dump the proxy list.
+    if (LoadLog::IsUnbounded(load_log)) {
+      LoadLog::AddString(
+          load_log,
+          std::string("Resolved proxy list: ") + result->ToPacString());
+    }
+  } else {
+    LoadLog::AddErrorCode(load_log, result_code);
+  }
+
+  // Clean up the results list.
+  if (result_code == OK)
+    result->RemoveBadProxies(proxy_retry_info_);
+
+  LoadLog::EndEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
+  return result_code;
+}
+
 void ProxyService::SetProxyScriptFetcher(
     ProxyScriptFetcher* proxy_script_fetcher) {
   if (init_proxy_resolver_.get()) {
     // We need to be careful to first cancel |init_proxy_resolver_|, since it
     // holds a pointer to the old proxy script fetcher we are about to delete.
 
     DCHECK(IsInitializingProxyResolver());
     init_proxy_resolver_.reset();
     proxy_script_fetcher_.reset(proxy_script_fetcher);
 
@@ skipping 289 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net