Dynamically refresh pref-configured proxies.

chrome/browser/net/pref_proxy_config_service.h

+// 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 CHROME_BROWSER_NET_PREF_PROXY_CONFIG_SERVICE_H_
+#define CHROME_BROWSER_NET_PREF_PROXY_CONFIG_SERVICE_H_
+#pragma once
+
+#include "base/basictypes.h"
+#include "base/observer_list.h"
+#include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
+#include "chrome/common/notification_observer.h"
+#include "net/proxy/proxy_config.h"
+#include "net/proxy/proxy_config_service.h"
+
+class PrefService;
+class PrefSetObserver;
+
+// A helper class that tracks proxy preferences. It translates the configuration
+// to net::ProxyConfig and proxies the result over to the IO thread for
+// PrefProxyConfigService to use.
+class PrefProxyConfigTracker
+    : public base::RefCountedThreadSafe<PrefProxyConfigTracker>,
+      public NotificationObserver {
+ public:
+  // Observer interface used to send out notifications on the IO thread about
+  // changes to the proxy configuration.
+  class ObserverInterface {

[eroman, 2010/11/30 02:58:54]

nit: why not call this "Observer", which is more typical naming in Chrome.

[battre (please use the other), 2010/12/02 18:06:12]

Done.

+   public:
+    virtual ~ObserverInterface() {}
+    virtual void OnPrefProxyConfigChanged() = 0;
+  };
+
+  explicit PrefProxyConfigTracker(PrefService* pref_service);
+  virtual ~PrefProxyConfigTracker();
+
+  // Observer manipulation is only valid on the IO thread.
+  void AddObserver(ObserverInterface* observer);
+  void RemoveObserver(ObserverInterface* observer);
+
+  // Get the proxy configuration currently defined by preferences. Writes the
+  // configuration to |config| and returns true on success. |config| is not
+  // touched and false is returned if there is no configuration defined. This
+  // must be called on the IO thread.
+  bool GetProxyConfig(net::ProxyConfig* config);
+
+  // Notifies the tracker that the pref service passed upon construction is
+  // about to go away. This must be called from the UI thread.
+  void DetachFromPrefService();
+
+ private:
+  // NotificationObserver implementation:
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+  // Install a new configuration. This is invoked on the IO thread to update
+  // the internal state after handling a pref change on the UI thread. |valid|
+  // indicates whether there is a preference proxy configuration defined, in
+  // which case this configuration is given by |config|. |config| is ignored if
+  // |valid| is false.
+  void InstallProxyConfig(const net::ProxyConfig& config, bool valid);
+
+  // Creates a proxy configuration from proxy-related preferences. Configuration
+  // is stored in |config| and the return value indicates whether the
+  // configuration is valid.
+  bool ReadPrefConfig(net::ProxyConfig* config);
+
+  // Configuration as defined by prefs. Only to be accessed from the IO thread
+  // (expect for construction).

[eroman, 2010/11/30 02:58:54]

typo: "expect" --> "except".

[battre (please use the other), 2010/12/02 18:06:12]

Done.

+  net::ProxyConfig pref_config_;
+
+  // Whether |pref_config_| is valid. Only accessed from the IO thread.
+  bool valid_;
+
+  // List of observers, accessed exclusively from the IO thread.
+  ObserverList<ObserverInterface, true> observers_;
+
+  // Pref-related members that should only be accessed from the UI thread.
+  PrefService* pref_service_;
+  scoped_ptr<PrefSetObserver> proxy_prefs_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrefProxyConfigTracker);
+};
+
+// A net::ProxyConfigService implementation that applies preference proxy
+// settings as overrides to the proxy configuration determined by a baseline
+// delegate ProxyConfigService.
+class PrefProxyConfigService
+    : public net::ProxyConfigService,
+      public net::ProxyConfigService::Observer,
+      public PrefProxyConfigTracker::ObserverInterface {
+ public:
+  // Takes ownership of the passed |base_service|.
+  PrefProxyConfigService(PrefProxyConfigTracker* tracker,
+                         net::ProxyConfigService* base_service);
+  virtual ~PrefProxyConfigService();
+
+  // ProxyConfigService implementation:
+  virtual void AddObserver(net::ProxyConfigService::Observer* observer);
+  virtual void RemoveObserver(net::ProxyConfigService::Observer* observer);
+  virtual bool GetLatestProxyConfig(net::ProxyConfig* config);
+  virtual void OnLazyPoll();
+
+ private:
+  // ProxyConfigService::Observer implementation:
+  virtual void OnProxyConfigChanged(const net::ProxyConfig& config);
+
+  // PrefProxyConfigTracker::Observer implementation:
+  virtual void OnPrefProxyConfigChanged();
+
+  // Makes sure that the observer registrations with the base service and the
+  // tracker object are set up.
+  void RegisterObservers();
+
+  scoped_ptr<net::ProxyConfigService> base_service_;
+  ObserverList<net::ProxyConfigService::Observer, true> observers_;
+  scoped_refptr<PrefProxyConfigTracker> pref_config_tracker_;
+
+  // Indicates whether the base service and tracker registrations are done.
+  bool registered_observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrefProxyConfigService);
+};
+
+#endif  // CHROME_BROWSER_NET_PREF_PROXY_CONFIG_SERVICE_H_