Adds a NetworkChangeNotifier dependency to ProxyService; when we observer a n...

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 180 matching lines @@
   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_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
-                           ProxyResolver* resolver)
+                           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)) {
+          this, &ProxyService::OnInitProxyResolverComplete)),
+      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,
     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);
+      proxy_config_service, proxy_resolver, network_change_notifier);
 
   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);
+  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);
+  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) {
   DCHECK(callback);
 
   LoadLog::BeginEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
@@ skipping 82 matching lines @@
       break;
     }
     default:
       result->UseDirect();
       NOTREACHED();
       break;
   }
 }
 
 ProxyService::~ProxyService() {
+  // 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();
   }
 }
 
 void ProxyService::SuspendAllPendingRequests() {
   for (PendingRequests::iterator it = pending_requests_.begin();
@@ skipping 362 matching lines @@
 // regardless of what they map to.
 //
 // static
 bool ProxyService::IsLocalName(const GURL& url) {
   const std::string& host = url.host();
   if (host == "127.0.0.1" || host == "[::1]")
     return true;
   return host.find('.') == std::string::npos;
 }
 
+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());
 }
 
@@ skipping 45 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net