Move over another legacy "LoadLog-style" event generator to routing its messa...

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 181 matching lines @@
   GURL url_;
   ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   BoundNetLog net_log_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver,
-                           NetworkChangeNotifier* network_change_notifier)
+                           NetworkChangeNotifier* network_change_notifier,
+                           const BoundNetLog& init_proxy_resolver_log)
     : 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),
+      init_proxy_resolver_log_(init_proxy_resolver_log),
       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,
     URLRequestContext* url_request_context,
     NetworkChangeNotifier* network_change_notifier,
+    NetLog* net_log,
     MessageLoop* io_loop) {
   ProxyResolver* proxy_resolver;
 
   if (use_v8_resolver) {
     // Send javascript errors and alerts to LOG(INFO).
     HostResolver* host_resolver = url_request_context->host_resolver();
     ProxyResolverJSBindings* js_bindings =
         ProxyResolverJSBindings::CreateDefault(host_resolver, io_loop);
 
     proxy_resolver = new ProxyResolverV8(js_bindings);
   } else {
     proxy_resolver = CreateNonV8ProxyResolver();
   }
 
   // Wrap the (synchronous) ProxyResolver implementation in a single-threaded
   // runner. This will dispatch requests to a threadpool of size 1.
   proxy_resolver = new SingleThreadedProxyResolver(proxy_resolver);
 
   ProxyService* proxy_service = new ProxyService(
-      proxy_config_service, proxy_resolver, network_change_notifier);
+      proxy_config_service, proxy_resolver, network_change_notifier,
+      BoundNetLog::Make(net_log, NetLog::SOURCE_INIT_PROXY_RESOLVER));
 
   if (proxy_resolver->expects_pac_bytes()) {
     // Configure PAC script downloads to be issued using |url_request_context|.
     DCHECK(url_request_context);
     proxy_service->SetProxyScriptFetcher(
         ProxyScriptFetcher::Create(url_request_context));
   }
 
   return proxy_service;
 }
 
 // static
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
-  return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL, NULL);
+  return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL,
+                NULL, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateNull() {
   // Use a configuration fetcher and proxy resolver which always fail.
   return new ProxyService(new ProxyConfigServiceNull,
                           new ProxyResolverNull,
-                          NULL);
+                          NULL,
+                          BoundNetLog());
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request,
                                const BoundNetLog& net_log) {
   DCHECK(callback);
 
   net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE);
@@ skipping 355 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_.Clear();
-
   int rv = init_proxy_resolver_->Init(
       config_, &init_proxy_resolver_callback_,
-      init_proxy_resolver_log_.bound());
+      init_proxy_resolver_log_);
 
   if (rv != ERR_IO_PENDING)
     OnInitProxyResolverComplete(rv);
 }
 
 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.
@@ skipping 72 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net