Cleanup: Remove the implicit constructor for BoundNetLog that allowed passing...

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 183 matching lines @@
   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,
-                           const BoundNetLog& init_proxy_resolver_log)
+                           NetLog* net_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_(init_proxy_resolver_log),
+      net_log_(net_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,
@@ skipping 22 matching lines @@
         new SingleThreadedProxyResolverUsingBridgedHostResolver(
             new ProxyResolverV8(js_bindings),
             sync_host_resolver);
   } else {
     proxy_resolver =
         new SingleThreadedProxyResolver(CreateNonV8ProxyResolver());
   }
 
   ProxyService* proxy_service = new ProxyService(
       proxy_config_service, proxy_resolver, network_change_notifier,
-      BoundNetLog::Make(net_log, NetLog::SOURCE_INIT_PROXY_RESOLVER));
+      net_log);
 
   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, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateNull() {
   // Use a configuration fetcher and proxy resolver which always fail.
   return new ProxyService(new ProxyConfigServiceNull,
                           new ProxyResolverNull,
                           NULL,
-                          BoundNetLog());
+                          NULL);
 }
 
 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, NULL);
@@ skipping 224 matching lines @@
   }
 }
 
 ProxyScriptFetcher* ProxyService::GetProxyScriptFetcher() const {
   return proxy_script_fetcher_.get();
 }
 
 void ProxyService::ResetConfigService(
     ProxyConfigService* new_proxy_config_service) {
   config_service_.reset(new_proxy_config_service);
-  UpdateConfig(NULL);
+  UpdateConfig(BoundNetLog());
 }
 
 void ProxyService::PurgeMemory() {
   if (resolver_.get())
     resolver_->PurgeMemory();
 }
 
 void ProxyService::ForceReloadProxyConfig() {
   // Mark the current configuration as being un-initialized, then force it to
   // start updating (normally this would happen lazily during the next
   // call to ResolveProxy()).
   config_.set_id(ProxyConfig::INVALID_ID);
-  UpdateConfig(NULL);
+  UpdateConfig(BoundNetLog());
 }
 
 // static
 ProxyConfigService* ProxyService::CreateSystemProxyConfigService(
     MessageLoop* io_loop, MessageLoop* file_loop) {
 #if defined(OS_WIN)
   return new ProxyConfigServiceWin();
 #elif defined(OS_MACOSX)
   return new ProxyConfigServiceMac();
 #elif defined(OS_LINUX)
@@ skipping 99 matching lines @@
 
     // Calls OnInitProxyResolverComplete() on completion.
     StartInitProxyResolver();
   }
 }
 
 void ProxyService::StartInitProxyResolver() {
   DCHECK(!init_proxy_resolver_.get());
 
   init_proxy_resolver_.reset(
-      new InitProxyResolver(resolver_.get(), proxy_script_fetcher_.get()));
+      new InitProxyResolver(resolver_.get(), proxy_script_fetcher_.get(),
+                            net_log_));
 
   int rv = init_proxy_resolver_->Init(
-      config_, &init_proxy_resolver_callback_,
-      init_proxy_resolver_log_);
+      config_, &init_proxy_resolver_callback_);
 
   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