Massively simplify the NetworkChangeNotifier infrastructure:...

net/proxy/proxy_service.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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"
@@ 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,
                            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)),
-      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);
+      net_log_(net_log) {
+  NetworkChangeNotifier::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 = NULL;
 
   if (use_v8_resolver) {
     // Use the IO thread's host resolver (but since it is not threadsafe,
     // bridge requests from the PAC thread over to the IO thread).
     SyncHostResolverBridge* sync_host_resolver =
         new SyncHostResolverBridge(url_request_context->host_resolver(),
                                    io_loop);
 
     // Send javascript errors and alerts to LOG(INFO).
     ProxyResolverJSBindings* js_bindings =
         ProxyResolverJSBindings::CreateDefault(sync_host_resolver);
 
     // Wrap the (synchronous) ProxyResolver implementation in a single-threaded
     // asynchronous resolver. This version of SingleThreadedProxyResolver
     // additionally aborts any synchronous host resolves to avoid deadlock
     // during shutdown.
     proxy_resolver =
         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,
-      net_log);
+  ProxyService* proxy_service =
+      new ProxyService(proxy_config_service, 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);
+  return Create(new ProxyConfigServiceFixed(pc), false, 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,
+  return new ProxyService(new ProxyConfigServiceNull, new ProxyResolverNull,
                           NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request,
                                const BoundNetLog& net_log) {
   DCHECK(callback);
 
@@ skipping 46 matching lines @@
     // May need to go through ProxyResolver for this.
     return ERR_IO_PENDING;
   }
 
   // Use the manual proxy settings.
   config_.proxy_rules().Apply(url, result);
   return OK;
 }
 
 ProxyService::~ProxyService() {
-  // Unregister to receive network change notifications.
-  if (network_change_notifier_)
-    network_change_notifier_->RemoveObserver(this);
+  NetworkChangeNotifier::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.
@@ skipping 311 matching lines @@
   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(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)
@@ skipping 53 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net