Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

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"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/load_log.h"
+#include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/proxy/init_proxy_resolver.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #if defined(OS_WIN)
 #include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
 #elif defined(OS_MACOSX)
 #include "net/proxy/proxy_config_service_mac.h"
 #include "net/proxy/proxy_resolver_mac.h"
 #elif defined(OS_LINUX)
 #include "net/proxy/proxy_config_service_linux.h"
 #endif
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_v8.h"
 #include "net/proxy/single_threaded_proxy_resolver.h"
 #include "net/url_request/url_request_context.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
-static const size_t kMaxNumLoadLogEntries = 100;
+static const size_t kMaxNumNetLogEntries = 100;
 
 // Config getter that fails every time.
 class ProxyConfigServiceNull : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
   virtual int GetProxyConfig(ProxyConfig* config) {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() : ProxyResolver(false /*expects_pac_bytes*/) {}
 
   // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              CompletionCallback* callback,
                              RequestHandle* request,
-                             LoadLog* load_log) {
+                             const BoundNetLog& net_log) {
     return ERR_NOT_IMPLEMENTED;
   }
 
   virtual void CancelRequest(RequestHandle request) {
     NOTREACHED();
   }
 
  private:
   virtual int SetPacScript(const GURL& /*pac_url*/,
                            const std::string& /*pac_bytes*/,
                            CompletionCallback* /*callback*/) {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
              CompletionCallback* user_callback,
-             LoadLog* load_log)
+             const BoundNetLog& net_log)
       : service_(service),
         user_callback_(user_callback),
         ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
             this, &PacRequest::QueryComplete)),
         results_(results),
         url_(url),
         resolve_job_(NULL),
         config_id_(ProxyConfig::INVALID_ID),
-        load_log_(load_log) {
+        net_log_(net_log) {
     DCHECK(user_callback);
   }
 
   // Starts the resolve proxy request.
   int Start() {
     DCHECK(!was_cancelled());
     DCHECK(!is_started());
 
     config_id_ = service_->config_.id();
 
     return resolver()->GetProxyForURL(
-        url_, results_, &io_callback_, &resolve_job_, load_log_);
+        url_, results_, &io_callback_, &resolve_job_, net_log_);
   }
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
     return !!resolve_job_;
   }
 
   void StartAndCompleteCheckingForSynchronous() {
     int rv = service_->TryToCompleteSynchronously(url_, results_);
     if (rv == ERR_IO_PENDING)
       rv = Start();
     if (rv != ERR_IO_PENDING)
       QueryComplete(rv);
   }
 
   void CancelResolveJob() {
     DCHECK(is_started());
     // The request may already be running in the resolver.
     resolver()->CancelRequest(resolve_job_);
     resolve_job_ = NULL;
     DCHECK(!is_started());
   }
 
   void Cancel() {
-    LoadLog::AddEvent(load_log_, LoadLog::TYPE_CANCELLED);
+    net_log_.AddEvent(NetLog::TYPE_CANCELLED);
 
     if (is_started())
       CancelResolveJob();
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
     user_callback_ = NULL;
     results_ = NULL;
 
-    LoadLog::EndEvent(load_log_, LoadLog::TYPE_PROXY_SERVICE);
+    net_log_.EndEvent(NetLog::TYPE_PROXY_SERVICE);
   }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const { return user_callback_ == NULL; }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
     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;
 
-    return service_->DidFinishResolvingProxy(results_, result_code, load_log_);
+    return service_->DidFinishResolvingProxy(results_, result_code, net_log_);
   }
 
-  LoadLog* load_log() const { return load_log_; }
+  BoundNetLog* net_log() { return &net_log_; }
 
  private:
   friend class base::RefCounted<ProxyService::PacRequest>;
 
   ~PacRequest() {}
 
   // Callback for when the ProxyResolver request has completed.
   void QueryComplete(int result_code) {
     result_code = QueryDidComplete(result_code);
 
@@ skipping 10 matching lines @@
   // Note that we don't hold a reference to the ProxyService. Outstanding
   // requests are cancelled during ~ProxyService, so this is guaranteed
   // to be valid throughout our lifetime.
   ProxyService* service_;
   CompletionCallback* user_callback_;
   CompletionCallbackImpl<PacRequest> io_callback_;
   ProxyInfo* results_;
   GURL url_;
   ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
-  scoped_refptr<LoadLog> load_log_;
+  BoundNetLog net_log_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver,
                            NetworkChangeNotifier* network_change_notifier)
     : config_service_(config_service),
       resolver_(resolver),
       next_config_id_(1),
       should_use_proxy_resolver_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
           this, &ProxyService::OnInitProxyResolverComplete)),
+      init_proxy_resolver_log_(kMaxNumNetLogEntries),
       network_change_notifier_(network_change_notifier) {
   // Register to receive network change notifications.
   if (network_change_notifier_)
     network_change_notifier_->AddObserver(this);
 }
 
 // static
 ProxyService* ProxyService::Create(
     ProxyConfigService* proxy_config_service,
     bool use_v8_resolver,
@@ skipping 40 matching lines @@
   // Use a configuration fetcher and proxy resolver which always fail.
   return new ProxyService(new ProxyConfigServiceNull,
                           new ProxyResolverNull,
                           NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request,
-                               LoadLog* load_log) {
+                               const BoundNetLog& net_log) {
   DCHECK(callback);
 
-  LoadLog::BeginEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
+  net_log.BeginEvent(NetLog::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);
+  UpdateConfigIfOld(net_log);
   int rv = TryToCompleteSynchronously(url, result);
   if (rv != ERR_IO_PENDING)
-    return DidFinishResolvingProxy(result, rv, load_log);
+    return DidFinishResolvingProxy(result, rv, net_log);
 
   scoped_refptr<PacRequest> req =
-      new PacRequest(this, url, result, callback, load_log);
+      new PacRequest(this, url, result, callback, net_log);
 
   bool resolver_is_ready = !IsInitializingProxyResolver();
 
   if (resolver_is_ready) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
       return req->QueryDidComplete(rv);
   } else {
-    LoadLog::BeginEvent(req->load_log(),
-        LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
+    req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
   DCHECK(!ContainsPendingRequest(req));
   pending_requests_.push_back(req);
 
   // Completion will be notifed through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
@@ skipping 20 matching lines @@
   // Unregister to receive network change notifications.
   if (network_change_notifier_)
     network_change_notifier_->RemoveObserver(this);
 
   // Cancel any inprogress requests.
   for (PendingRequests::iterator it = pending_requests_.begin();
        it != pending_requests_.end();
        ++it) {
     (*it)->Cancel();
   }
+
+  // Make sure that InitProxyResolver gets destroyed BEFORE the
+  // CapturingNetLog it is using is deleted.
+  init_proxy_resolver_.reset();
 }
 
 void ProxyService::SuspendAllPendingRequests() {
   for (PendingRequests::iterator it = pending_requests_.begin();
        it != pending_requests_.end();
        ++it) {
     PacRequest* req = it->get();
     if (req->is_started()) {
       req->CancelResolveJob();
 
-      LoadLog::BeginEvent(req->load_log(),
-          LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
+      req->net_log()->BeginEvent(
+          NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
     }
   }
 }
 
 void ProxyService::ResumeAllPendingRequests() {
   DCHECK(!IsInitializingProxyResolver());
 
   // Make a copy in case |this| is deleted during the synchronous completion
   // of one of the requests. If |this| is deleted then all of the PacRequest
   // instances will be Cancel()-ed.
   PendingRequests pending_copy = pending_requests_;
 
   for (PendingRequests::iterator it = pending_copy.begin();
        it != pending_copy.end();
        ++it) {
     PacRequest* req = it->get();
     if (!req->is_started() && !req->was_cancelled()) {
-      LoadLog::EndEvent(req->load_log(),
-          LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
+      req->net_log()->EndEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
 
       // Note that we re-check for synchronous completion, in case we are
       // no longer using a ProxyResolver (can happen if we fell-back to manual).
       req->StartAndCompleteCheckingForSynchronous();
     }
   }
 }
 
 void ProxyService::OnInitProxyResolverComplete(int result) {
   DCHECK(init_proxy_resolver_.get());
@@ skipping 10 matching lines @@
 
   // Resume any requests which we had to defer until the PAC script was
   // downloaded.
   ResumeAllPendingRequests();
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             ProxyInfo* result,
                                             CompletionCallback* callback,
                                             PacRequest** pac_request,
-                                            LoadLog* load_log) {
+                                            const BoundNetLog& net_log) {
   // 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(load_log);
+    UpdateConfig(net_log);
     if (result->config_id_ != config_.id()) {
       // A new configuration!
       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, load_log);
+    return ResolveProxy(url, result, callback, pac_request, net_log);
   }
 
   // We don't have new proxy settings to try, try to fallback to the next proxy
   // in the list.
   bool did_fallback = result->Fallback(&proxy_retry_info_);
 
   // 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;
 }
@@ skipping 12 matching lines @@
 
 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) {
+                                          const BoundNetLog& net_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,
+    if (net_log.HasListener()) {
+      net_log.AddString(
           std::string("Resolved proxy list: ") + result->ToPacString());
     }
     result->DeprioritizeBadProxies(proxy_retry_info_);
   } else {
-    LoadLog::AddStringLiteral(
-        load_log,
+    net_log.AddStringLiteral(
         "Got an error from proxy resolver, falling-back to DIRECT.");
-    LoadLog::AddErrorCode(load_log, result_code);
+    net_log.AddErrorCode(result_code);
 
     // Fall-back to direct when the proxy resolver fails. This corresponds
     // with a javascript runtime error in the PAC script.
     //
     // This implicit fall-back to direct matches Firefox 3.5 and
     // Internet Explorer 8. For more information, see:
     //
     // http://www.chromium.org/developers/design-documents/proxy-settings-fallback
     result->UseDirect();
     result_code = OK;
   }
 
-  LoadLog::EndEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
+  net_log.EndEvent(NetLog::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());
@@ skipping 70 matching lines @@
   return new ProxyResolverWinHttp();
 #elif defined(OS_MACOSX)
   return new ProxyResolverMac();
 #else
   LOG(WARNING) << "PAC support disabled because there is no fallback "
                   "non-V8 implementation";
   return new ProxyResolverNull();
 #endif
 }
 
-void ProxyService::UpdateConfig(LoadLog* load_log) {
+void ProxyService::UpdateConfig(const BoundNetLog& net_log) {
   bool is_first_update = !config_has_been_initialized();
 
   ProxyConfig latest;
 
   // Fetch the proxy settings.
   TimeTicks start_time = TimeTicks::Now();
-  LoadLog::BeginEvent(load_log,
-      LoadLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
+  net_log.BeginEvent(
+      NetLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
   int rv = config_service_->GetProxyConfig(&latest);
-  LoadLog::EndEvent(load_log,
-      LoadLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
+  net_log.EndEvent(NetLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
   TimeTicks end_time = TimeTicks::Now();
 
   // Record how long the call to config_service_->GetConfig() above took.
   // On some setups of Windows, we have reports that querying the system
   // proxy settings can take multiple seconds (http://crbug.com/12189).
   UMA_HISTOGRAM_CUSTOM_TIMES("Net.ProxyPollConfigurationTime",
                              end_time - start_time,
                              TimeDelta::FromMilliseconds(1),
                              TimeDelta::FromSeconds(30),
                              50);
@@ skipping 40 matching lines @@
     StartInitProxyResolver();
   }
 }
 
 void ProxyService::StartInitProxyResolver() {
   DCHECK(!init_proxy_resolver_.get());
 
   init_proxy_resolver_.reset(
       new InitProxyResolver(resolver_.get(), proxy_script_fetcher_.get()));
 
-  init_proxy_resolver_log_ = new LoadLog(kMaxNumLoadLogEntries);
+  init_proxy_resolver_log_.Clear();
 
   int rv = init_proxy_resolver_->Init(
-      config_, &init_proxy_resolver_callback_, init_proxy_resolver_log_);
+      config_, &init_proxy_resolver_callback_,
+      init_proxy_resolver_log_.bound());
 
   if (rv != ERR_IO_PENDING)
     OnInitProxyResolverComplete(rv);
 }
 
-void ProxyService::UpdateConfigIfOld(LoadLog* load_log) {
+void ProxyService::UpdateConfigIfOld(const BoundNetLog& net_log) {
   // The overhead of calling ProxyConfigService::GetProxyConfig is very low.
   const TimeDelta kProxyConfigMaxAge = TimeDelta::FromSeconds(5);
 
   // Periodically check for a new config.
   if (!config_has_been_initialized() ||
       (TimeTicks::Now() - config_last_update_time_) > kProxyConfigMaxAge)
-    UpdateConfig(load_log);
+    UpdateConfig(net_log);
 }
 
 
 void ProxyService::OnIPAddressChanged() {
   DCHECK(network_change_notifier_);
 
   // Mark the current configuration as being un-initialized.
   //
   // This will force us to re-fetch the configuration (and re-run all of
   // the initialization steps) on the next ResolveProxy() request, as part
   // of UpdateConfigIfOld().
   config_.set_id(ProxyConfig::INVALID_ID);
 }
 
 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,
                                          ProxyInfo* proxy_info,
-                                         LoadLog* load_log) {
+                                         const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
   io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncResolve, url, load_log));
+      this, &SyncProxyServiceHelper::StartAsyncResolve, url, net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 int SyncProxyServiceHelper::ReconsiderProxyAfterError(
-    const GURL& url, ProxyInfo* proxy_info, LoadLog* load_log) {
+    const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
   io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncReconsider, url, load_log));
+      this, &SyncProxyServiceHelper::StartAsyncReconsider, url, net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url,
-                                               LoadLog* load_log) {
+                                               const BoundNetLog& net_log) {
   result_ = proxy_service_->ResolveProxy(
-      url, &proxy_info_, &callback_, NULL, load_log);
+      url, &proxy_info_, &callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url,
-                                                  LoadLog* load_log) {
+                                                  const BoundNetLog& net_log) {
   result_ = proxy_service_->ReconsiderProxyAfterError(
-      url, &proxy_info_, &callback_, NULL, load_log);
+      url, &proxy_info_, &callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net