Massively simplify the NetworkChangeNotifier infrastructure:...

net/proxy/proxy_service.h

-// Copyright (c) 2009 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.
 
 #ifndef NET_PROXY_PROXY_SERVICE_H_
 #define NET_PROXY_PROXY_SERVICE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/ref_counted.h"
@@ skipping 17 matching lines @@
 class ProxyResolver;
 class ProxyScriptFetcher;
 
 // This class can be used to resolve the proxy server to use when loading a
 // HTTP(S) URL.  It uses the given ProxyResolver to handle the actual proxy
 // resolution.  See ProxyResolverV8 for example.
 class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
                      public NetworkChangeNotifier::Observer {
  public:
   // The instance takes ownership of |config_service| and |resolver|.
-  // If |network_change_notifier| is non-NULL, the proxy service will register
-  // with it to detect when the network setup has changed. This is used to
-  // decide when to re-configure the proxy discovery.
   // |net_log| is a possibly NULL destination to send log events to. It must
   // remain alive for the lifetime of this ProxyService.
-  ProxyService(ProxyConfigService* config_service, ProxyResolver* resolver,
-               NetworkChangeNotifier* network_change_notifier,
+  ProxyService(ProxyConfigService* config_service,
+               ProxyResolver* resolver,
                NetLog* net_log);
 
   // Used internally to handle PAC queries.
   // TODO(eroman): consider naming this simply "Request".
   class PacRequest;
 
   // Returns ERR_IO_PENDING if the proxy information could not be provided
   // synchronously, to indicate that the result will be available when the
   // callback is run.  The callback is run on the thread that calls
   // ResolveProxy.
@@ skipping 80 matching lines @@
   // to downloading and testing the PAC files.
   void ForceReloadProxyConfig();
 
   // Creates a proxy service that polls |proxy_config_service| to notice when
   // the proxy settings change. We take ownership of |proxy_config_service|.
   // Iff |use_v8_resolver| is true, then the V8 implementation is
   // used.
   // |url_request_context| is only used when use_v8_resolver is true:
   // it specifies the URL request context that will be used if a PAC
   // script needs to be fetched.
-  // |network_change_notifier| may be NULL. Otherwise it will be used to
-  // signal the ProxyService when the network setup has changed.
   // |io_loop| points to the IO thread's message loop. It is only used
   // when pc is NULL.
   // ##########################################################################
   // # See the warnings in net/proxy/proxy_resolver_v8.h describing the
   // # multi-threading model. In order for this to be safe to use, *ALL* the
   // # other V8's running in the process must use v8::Locker.
   // ##########################################################################
   static ProxyService* Create(
       ProxyConfigService* proxy_config_service,
       bool use_v8_resolver,
       URLRequestContext* url_request_context,
-      NetworkChangeNotifier* network_change_notifier,
       NetLog* net_log,
       MessageLoop* io_loop);
 
   // Convenience method that creates a proxy service using the
   // specified fixed settings. |pc| must not be NULL.
   static ProxyService* CreateFixed(const ProxyConfig& pc);
 
   // Creates a proxy service that always fails to fetch the proxy configuration,
   // so it falls back to direct connect.
   static ProxyService* CreateNull();
@@ skipping 67 matching lines @@
   // Removes |req| from the list of pending requests.
   void RemovePendingRequest(PacRequest* req);
 
   // Called when proxy resolution has completed (either synchronously or
   // asynchronously). Handles logging the result, and cleaning out
   // bad entries from the results list.
   int DidFinishResolvingProxy(ProxyInfo* result,
                               int result_code,
                               const BoundNetLog& net_log);
 
-  // NetworkChangeNotifier::Observer methods:
+  // NetworkChangeNotifier::Observer
+  // When this is called, we re-fetch PAC scripts and re-run WPAD.
   virtual void OnIPAddressChanged();
 
   scoped_ptr<ProxyConfigService> config_service_;
   scoped_ptr<ProxyResolver> resolver_;
 
   // We store the proxy config and a counter (ID) that is incremented each time
   // the config changes.
   ProxyConfig config_;
 
   // Increasing ID to give to the next ProxyConfig that we set.
@@ skipping 22 matching lines @@
   // Helper to download the PAC script (wpad + custom) and apply fallback rules.
   //
   // Note that the declaration is important here: |proxy_script_fetcher_| and
   // |proxy_resolver_| must outlive |init_proxy_resolver_|.
   scoped_ptr<InitProxyResolver> init_proxy_resolver_;
 
   // This is the log where any events generated by |init_proxy_resolver_| are
   // sent to.
   NetLog* net_log_;
 
-  // The (possibly NULL) network change notifier that we use to decide when
-  // to refetch PAC scripts or re-run WPAD.
-  NetworkChangeNotifier* const network_change_notifier_;
-
   DISALLOW_COPY_AND_ASSIGN(ProxyService);
 };
 
 // Wrapper for invoking methods on a ProxyService synchronously.
 class SyncProxyServiceHelper
     : public base::RefCountedThreadSafe<SyncProxyServiceHelper> {
  public:
   SyncProxyServiceHelper(MessageLoop* io_message_loop,
                          ProxyService* proxy_service);
 
-  int ResolveProxy(const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log);
+  int ResolveProxy(const GURL& url,
+                   ProxyInfo* proxy_info,
+                   const BoundNetLog& net_log);
   int ReconsiderProxyAfterError(const GURL& url,
-                                ProxyInfo* proxy_info, const BoundNetLog& net_log);
+                                ProxyInfo* proxy_info,
+                                const BoundNetLog& net_log);
 
  private:
   friend class base::RefCountedThreadSafe<SyncProxyServiceHelper>;
 
   ~SyncProxyServiceHelper() {}
 
   void StartAsyncResolve(const GURL& url, const BoundNetLog& net_log);
   void StartAsyncReconsider(const GURL& url, const BoundNetLog& net_log);
 
   void OnCompletion(int result);
 
   MessageLoop* io_message_loop_;
   ProxyService* proxy_service_;
 
   base::WaitableEvent event_;
   CompletionCallbackImpl<SyncProxyServiceHelper> callback_;
   ProxyInfo proxy_info_;
   int result_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVICE_H_