redesign and reimplement proxy config service and tracker, revise proxy ui on cros

chrome/browser/chromeos/proxy_config_service_impl.h

 // Copyright (c) 2011 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_CHROMEOS_PROXY_CONFIG_SERVICE_IMPL_H_
 #define CHROME_BROWSER_CHROMEOS_PROXY_CONFIG_SERVICE_IMPL_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/login/signed_settings.h"
+#include "chrome/browser/net/pref_proxy_config_service.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_server.h"
 
+class Profile;
+
 namespace chromeos {
 
 // Implementation of proxy config service for chromeos that:
 // - is RefCountedThreadSafe
 // - is wrapped by chromeos::ProxyConfigService which implements
 //   net::ProxyConfigService interface by fowarding the methods to this class
 // - retrieves initial system proxy configuration from cros settings persisted
 //   on chromeos device from chromeos revisions before migration to flimflam,
 // - persists proxy setting per network in flimflim
 // - provides network stack with latest proxy configuration for currently
 //   active network for use on IO thread
 // - provides UI with methods to retrieve and modify proxy configuration for
 //   any network (either currently active or non-active) on UI thread
 class ProxyConfigServiceImpl
     : public base::RefCountedThreadSafe<ProxyConfigServiceImpl>,
       public SignedSettings::Delegate<std::string>,
       public NetworkLibrary::NetworkManagerObserver,
-      public NetworkLibrary::NetworkObserver {
+      public NetworkLibrary::NetworkObserver,
+      public ProxyConfigDecider {
  public:
   // ProxyConfigServiceImpl is created on the UI thread in
   // chrome/browser/net/proxy_service_factory.cc::CreateProxyConfigService
   // via BrowserProcess::chromeos_proxy_config_service_impl, and stored in
   // g_browser_process as a scoped_refptr (because it's RefCountedThreadSafe).
   //
   // Past that point, it can be accessed from the IO or UI threads.
   //
   // From the IO thread, it is accessed periodically through the wrapper class
   // chromeos::ProxyConfigService via net::ProxyConfigService interface
@@ skipping 22 matching lines @@
     // Specifies if proxy config is direct, auto-detect, using pac script,
     // single-proxy, or proxy-per-scheme.
     enum Mode {
       MODE_DIRECT,
       MODE_AUTO_DETECT,
       MODE_PAC_SCRIPT,
       MODE_SINGLE_PROXY,
       MODE_PROXY_PER_SCHEME,
     };
 
-    // Specifies where proxy configuration was picked up from.
-    enum Source {
-      SOURCE_NONE,    // No default configuration.
-      SOURCE_POLICY,  // Configuration is from policy.
-      SOURCE_OWNER,   // Configuration is from owner.
-    };
-
-    struct Setting {
-      Setting() : source(SOURCE_NONE) {}
-      bool CanBeWrittenByUser(bool user_is_owner);
-
-      Source source;
-    };
-
     // Proxy setting for mode = direct or auto-detect or using pac script.
-    struct AutomaticProxy : public Setting {
-      GURL    pac_url;  // Set if proxy is using pac script.
+    struct AutomaticProxy {
+      GURL pac_url;  // Set if proxy is using pac script.
     };
 
     // Proxy setting for mode = single-proxy or proxy-per-scheme.
-    struct ManualProxy : public Setting {
-      net::ProxyServer  server;
+    struct ManualProxy {
+      net::ProxyServer server;
     };
 
     ProxyConfig();
     ~ProxyConfig();
 
     // Converts |this| to net::ProxyConfig.
     void ToNetProxyConfig(net::ProxyConfig* net_config);
 
-    // Returns true if proxy config can be written by user.
-    // If mode is MODE_PROXY_PER_SCHEME, |scheme| is one of "http", "https",
-    // "ftp" or "socks"; otherwise, it should be empty or will be ignored.
-    bool CanBeWrittenByUser(bool user_is_owner, const std::string& scheme);
+    // Converts net::ProxyConfig to |this|.
+    bool FromNetProxyConfig(const net::ProxyConfig& net_config);
 
     // Map |scheme| (one of "http", "https", "ftp" or "socks") to the correct
     // ManualProxy.  Returns NULL if scheme is invalid.
     ManualProxy* MapSchemeToProxy(const std::string& scheme);
 
     // We've migrated device settings to flimflam, so we only need to
     // deserialize previously persisted device settings.
     // Deserializes from signed setting on device as std::string into a
     // protobuf and then into the config.
     bool DeserializeForDevice(const std::string& input);
 
     // Serializes config into a ProxyConfigDictionary and then std::string
     // persisted as string property in flimflam for a network.
     bool SerializeForNetwork(std::string* output);
 
     // Deserializes from string property in flimflam for a network into a
     // ProxyConfigDictionary and then into the config.
     // Opposite of SerializeForNetwork.
     bool DeserializeForNetwork(const std::string& input);
 
     // Returns true if the given config is equivalent to this config.
     bool Equals(const ProxyConfig& other) const;
 
-    // Creates a textual dump of the configuration.
-    std::string ToString() const;
+    Mode mode;
 
-    Mode mode;
+    PrefProxyConfigTracker::ConfigSource source;
+
+    bool user_modifiable;

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

It would be good to have a comment explaining in which situations the config is
modifiable and in which it isn't.

[kuan, 2011/10/18 16:25:35]

Done.

 
     // Set if mode is MODE_DIRECT or MODE_AUTO_DETECT or MODE_PAC_SCRIPT.
     AutomaticProxy  automatic_proxy;
     // Set if mode is MODE_SINGLE_PROXY.
     ManualProxy     single_proxy;
     // Set if mode is MODE_PROXY_PER_SCHEME and has http proxy.
     ManualProxy     http_proxy;
     // Set if mode is MODE_PROXY_PER_SCHEME and has https proxy.
     ManualProxy     https_proxy;
     // Set if mode is MODE_PROXY_PER_SCHEME and has ftp proxy.
@@ skipping 18 matching lines @@
     bool FromPrefProxyConfig(const DictionaryValue* proxy_dict);
   };
 
   // Usual constructor.
   ProxyConfigServiceImpl();
   // Constructor for testing.
   // |init_config| specifies the ProxyConfig to use for initialization.
   explicit ProxyConfigServiceImpl(const ProxyConfig& init_config);
   virtual ~ProxyConfigServiceImpl();
 
-  // Methods called on IO thread from wrapper class chromeos::ProxyConfigService
-  // as ProxyConfigService methods.
-  void AddObserver(net::ProxyConfigService::Observer* observer);
-  void RemoveObserver(net::ProxyConfigService::Observer* observer);
-  // Called from GetLatestProxyConfig.
-  net::ProxyConfigService::ConfigAvailability IOGetProxyConfig(
-      net::ProxyConfig* config);
+  // Called from UI thread to set user preference use_shared_proxies.
+  void UISetUseSharedProxies(bool use_shared);
 
-  // Called from UI thread to retrieve proxy configuration in |config|.
-  void UIGetProxyConfig(ProxyConfig* config);
+  // Called from UI thread to set user |profile| whose prefs proxy config will
+  // be to be displayed or edited. Subsequent UISet* methods will use this
+  // profile, until UI calls it again with a different profile.
+  void UISetCurrentUserProfile(Profile* profile);
 
-  // Called from UI thread to set service path of network to be displayed or
-  // edited.  Subsequent UISet* methods will use this network, until UI calls
+  // Called from UI thread to set service path of |network| to be displayed or
+  // edited. Subsequent UISet* methods will use this
+  // network, until UI calls
   // it again with a different network.

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

comment formatting.

[kuan, 2011/10/18 16:25:35]

Done.

-  bool UISetCurrentNetwork(const std::string& current_network);
+  void UISetCurrentNetwork(const std::string& current_network);
 
-  // Called from UI thread to make the currently active network the one to be
-  // displayed or edited. Subsequent UISet* methods will use this network. until
+  // Called from UI thread to make the currently active |etwork the one to be

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

revert

[kuan, 2011/10/18 16:25:35]

Done.

+  // displayed or edited. Subsequent UISet* methods will use this network until
   // UI calls it again when the active network has changed.
-  bool UIMakeActiveNetworkCurrent();
+  void UIMakeActiveNetworkCurrent();
 
   // Called from UI thread to get name of the current active network.
   const std::string& current_network_name() const {
     return current_ui_network_name_;
   }
 
-  // Called from UI thread to set/get user preference use_shared_proxies.
-  void UISetUseSharedProxies(bool use_shared);
-  bool use_shared_proxies() const {
-    return use_shared_proxies_;
-  }
+  // Called from UI thread to retrieve proxy configuration in |config|.
+  void UIGetProxyConfig(ProxyConfig* config);
 
   // Called from UI thread to update proxy configuration for different modes.
   // Returns true if config is set properly and persisted to flimflam for the
   // current network (set via UISetCurrentNetwork/UIMakeActiveNetworkCurrent).
   // If this network is also currently active, config service proceeds to start
   // activating it on network stack.
   // Returns false if config is not set properly, probably because information
   // is incomplete or invalid; while config service won't proceed to activate or
   // persist this config, the information is "cached" in the service, so that
   // the next UIGetProxyConfig call will return this latest information.
@@ skipping 10 matching lines @@
   // Implementation for SignedSettings::Delegate
   virtual void OnSettingsOpCompleted(SignedSettings::ReturnCode code,
                                      std::string value);
 
   // NetworkLibrary::NetworkManagerObserver implementation.
   virtual void OnNetworkManagerChanged(NetworkLibrary* cros);
 
   // NetworkLibrary::NetworkObserver implementation.
   virtual void OnNetworkChanged(NetworkLibrary* cros, const Network* network);
 
+  // Methods called on io thread from wrapper chromeos::ProxyConfigService as

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

s/io/IO/

[kuan, 2011/10/18 16:25:35]

function is removed.

+  // net::ProxyConfigService methods.
+  void AddObserver(net::ProxyConfigService::Observer* observer);
+  void RemoveObserver(net::ProxyConfigService::Observer* observer);
+  // Called from GetLatestProxyConfig.

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

maybe adjust to match the name then?

[kuan, 2011/10/18 16:25:35]

function is removed.

+  net::ProxyConfigService::ConfigAvailability IOGetProxyConfig(
+      net::ProxyConfig* config);
+
+  // Methods called on ui thread from wrapper chromeos::ProxyConfigService to

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

s/ui/UI/

[kuan, 2011/10/18 16:25:35]

function is removed.

+  // serve extra functionalities beyond net::ProxyCofigService methods.
+  // Implementation of PrefProxyConfigTracker::Observer.
+  void OnPrefProxyConfigChanged(PrefProxyConfigTracker* tracker);
+
 #if defined(UNIT_TEST)
   void SetTesting() {
     testing_ = true;
     active_network_ = "test";
     UIMakeActiveNetworkCurrent();
   }
 #endif  // defined(UNIT_TEST)
 
  private:
   friend class base::RefCountedThreadSafe<ProxyConfigServiceImpl>;
@@ skipping 12 matching lines @@
   // proxy setting of new network.
   void OnActiveNetworkChanged(NetworkLibrary* cros,
                               const Network* active_network);
 
   // Sets proxy config for |network_path| into flimflam and activates setting
   // if the network is currently active.
   void SetProxyConfigForNetwork(const std::string& network_path,
                                 const std::string& value,
                                 bool only_set_if_empty);
 
-  // Determines and activates proxy config of |network| based on if network is
-  // shared/private or user is using shared proxies, etc.
-  void DetermineConfigFromNetwork(const Network* network);
+  // Determines effective proxy config based on prefs from config tracker,
+  // |network| and if user is using shared proxies.
+  // If |activate| is true, effective config is stored in |active_config| and
+  // activated on IO thread, and hence, picked up by observers.
+  // if |activate| is false, effective config is stored in |current_ui_config|
+  // but not activated on io thread, and hence, not picked up by observers.
+  void DetermineEffectiveConfig(const Network* network, bool activate);
 
-  // Set |current_ui_network_name_| with name of |network|.
-  void SetCurrentNetworkName(const Network* network);
+  // Determine UI-related variables (|current_network_name_| and
+  // |current_ui_config_|) based on |network|, called from UISetCurrentNetwork
+  // and UIMakeActiveNetworkActive.
+  void OnUISetCurrentNetwork(const Network* network);
+
+  // Returns true if proxy is to be ignored for network, which happens if
+  // network is shared and use-shared-proxies is turned off.
+  bool IgnoreProxy(const Network* network) {
+    return network->profile_type() == PROFILE_SHARED && !use_shared_proxies_;
+  }
+
+  // Reset UI cache variables that keep track of ui changes.

[Mattias Nissler (ping if slow), 2011/10/07 13:32:10]

s/ui/UI/

[kuan, 2011/10/18 16:25:35]

Done.

+  void ResetUICache();
+
+  // Returns prefs proxy config tracker of |current_ui_profile_| if available,
+  // or default profile.
+  PrefProxyConfigTracker* GetProxyConfigTracker();
 
   // Checks that method is called on BrowserThread::IO thread.
   void CheckCurrentlyOnIOThread();
 
   // Checks that method is called on BrowserThread::UI thread.
   void CheckCurrentlyOnUIThread();
 
   // Data members.
 
   // True if running unit_tests, which will need to specifically exclude
   // flimflam logic.
   bool testing_;
 
   // True if tasks can be posted, which can only happen if constructor has
   // completed (NewRunnableMethod cannot be created for a RefCountedThreadBase's
   // method until the class's ref_count is at least one).
   bool can_post_task_;
 
-  // Availability status of the configuration, initialized on UI thread, but
-  // afterwards only accessed from IO thread.
-  net::ProxyConfigService::ConfigAvailability config_availability_;
-
   // Service path of currently active network (determined via flimflam
   // notifications) whose proxy config is taking effect.
   std::string active_network_;
-  // Proxy configuration of |active_network_|, only accessed from UI thread.
+
+  // Active proxy configuration, which could be from prefs or network, only
+  // accessed from UI thread.
   ProxyConfig active_config_;
 
   // Proxy config retreived from device, in format generated from
   // SerializeForNetwork, that can be directly set into flimflam.
   std::string device_config_;
 
-  // Cached proxy configuration, to be converted to net::ProxyConfig and
-  // returned by IOGetProxyConfig.
-  // Initially populated from UI thread, but afterwards only accessed from IO
-  // thread.
-  ProxyConfig cached_config_;
+  // Proxy configuration that is cache of |active_config_| and only accessible
+  // from IO thread (except for construction in UI thread), to be converted to
+  // net::ProxyConfig and returned by IOGetProxyConfig.
+  ProxyConfig io_config_;
+
+  // Availability status of |io_config_| accessible only from IO thread (except
+  // for construction in UI thread), returned by IOGetProxyConfig.
+  net::ProxyConfigService::ConfigAvailability io_config_availability_;
+
+  // True if user preference UseSharedProxies is true.
+  bool use_shared_proxies_;
+
+  // Current user profile, set in UISetCurrentUserProfile.
+  Profile* current_ui_profile_;  // Weak ptr.
 
   // Service path of network whose proxy configuration is being displayed or
   // edited via UI, separate from |active_network_| which may be same or
   // different.
   std::string current_ui_network_;
 
-  // Name of network with current_ui_network_, set in UIMakeActiveNetworkCurrent
-  // and UISetCurrentNetwork.
+  // Name of network with current_ui_network_, set in UISetCurrentNetwork and
+  // UIMakeActiveNetworkCurrent.
   std::string current_ui_network_name_;
 
   // Proxy configuration of |current_ui_network|.
   ProxyConfig current_ui_config_;
 
-  // True if user preference UseSharedProxies is true.
-  bool use_shared_proxies_;
-
   // List of observers for changes in proxy config.
   ObserverList<net::ProxyConfigService::Observer> observers_;
 
   // Operation to retrieve proxy setting from device.
   scoped_refptr<SignedSettings> retrieve_property_op_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyConfigServiceImpl);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PROXY_CONFIG_SERVICE_IMPL_H_