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 "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
@@ skipping 41 matching lines @@
     // 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.
+    static const int kSourceDisabled = 0x1000;
+    enum SourceType {
+      SOURCE_TYPE_NONE = 1,  // No configuration.
+      SOURCE_TYPE_POLICY = 2,  // Configuration is from policy.
+      SOURCE_TYPE_EXTENSION = 3,  // Configuration is from extension.
+      SOURCE_TYPE_RECOMMENDED = 4,  // Configuration is recommended.
+      SOURCE_TYPE_NETWORK = 5,  // Configuration is from network.
+    };
     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;
+      // No configuration and writeable.
+      SOURCE_NONE = SOURCE_TYPE_NONE,
+      // No configuration and disabled.
+      SOURCE_NONE_DISABLED = SOURCE_TYPE_NONE | kSourceDisabled,
+      // Configuration is from policy and readonly.
+      SOURCE_POLICY = SOURCE_TYPE_POLICY | kSourceDisabled,
+      // Configuration is from extension and readonly.
+      SOURCE_EXTENSION = SOURCE_TYPE_EXTENSION | kSourceDisabled,
+      // Configuration is recommended and writeable.
+      SOURCE_RECOMMENDED  = SOURCE_TYPE_RECOMMENDED,
+      // Configuration is recommended but disabled.
+      SOURCE_RECOMMENDED_DISABLED = SOURCE_TYPE_RECOMMENDED | kSourceDisabled,
+      // Configuration is from network and writeable.
+      SOURCE_NETWORK = SOURCE_TYPE_NETWORK,
+      // Configuration is from network but disabled.
+      SOURCE_NETWORK_DISABLED = SOURCE_TYPE_NETWORK | kSourceDisabled,
     };

[stevenjb, 2011/10/05 00:22:57]

Do we need to Source and SourceType in the same variable? It seems like the code
would be simpler if we stored |source| and |source_disabled| separately and
eliminated the Source enum.

[kuan, 2011/10/07 00:30:41]

i use "source| and |user_modifiable|.

On 2011/10/05 00:22:57, Steven Bennetts wrote:
Done.

 
     // Proxy setting for mode = direct or auto-detect or using pac script.
-    struct AutomaticProxy : public Setting {
+    struct AutomaticProxy {
       GURL    pac_url;  // Set if proxy is using pac script.

[stevenjb, 2011/10/05 00:22:57]

nit: one space betwen GURL and pac

[kuan, 2011/10/07 00:30:41]

Done.

     };
 
     // Proxy setting for mode = single-proxy or proxy-per-scheme.
-    struct ManualProxy : public Setting {
+    struct ManualProxy {
       net::ProxyServer  server;

[Mattias Nissler (ping if slow), 2011/10/05 10:18:36]

same here: only one space.

[kuan, 2011/10/07 00:30:41]

Done.

     };
 
     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);
+
+    // Returns true if proxy config can be modified by user.
+    bool IsUserModifiable() const {
+      return !(static_cast<int>(source) & kSourceDisabled);

[Mattias Nissler (ping if slow), 2011/10/05 10:18:36]

Seems like Steven has a point in making an actual boolean flag instead of
packing the flag into source. If you want both bundled in one, you can always
make it a class or struct.

[kuan, 2011/10/07 00:30:41]

i removed it.

On 2011/10/05 10:18:36, Mattias Nissler wrote:
Done.

+    }
 
     // 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;
 
+    Source source;
+
     // 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.
     ManualProxy     ftp_proxy;
@@ skipping 29 matching lines @@
   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 retrieve proxy configuration in |config|.
   void UIGetProxyConfig(ProxyConfig* config);
 
   // 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.
-  bool UISetCurrentNetwork(const std::string& current_network);
+  // edited with the current user profile.  Subsequent UISet* methods will use
+  // this network, until UI calls it again with a different network.
+  void UISetCurrentNetworkWithProfile(const std::string& current_network,
+                                      Profile* profile);
 
   // 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
-  // UI calls it again when the active network has changed.
-  bool UIMakeActiveNetworkCurrent();
+  // displayed or edited, with current user profile. Subsequent UISet* methods
+  // will use this network until UI calls it again when the active network has
+  // changed.
+  void UIMakeActiveNetworkCurrentWithProfile(Profile* profile);
 
   // 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.
+  // Called from UI thread to set user preference use_shared_proxies.
   void UISetUseSharedProxies(bool use_shared);
-  bool use_shared_proxies() const {
-    return use_shared_proxies_;
-  }
 
   // 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).
+  // current network (set via UISetCurrentNetworkWithProfile or
+  // UIMakeActiveNetworkCurrentWithPRofile).
   // 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.
   bool UISetProxyConfigToDirect();
   bool UISetProxyConfigToAutoDetect();
   bool UISetProxyConfigToPACScript(const GURL& pac_url);
   bool UISetProxyConfigToSingleProxy(const net::ProxyServer& server);
@@ skipping 10 matching lines @@
   // NetworkLibrary::NetworkManagerObserver implementation.
   virtual void OnNetworkManagerChanged(NetworkLibrary* cros);
 
   // NetworkLibrary::NetworkObserver implementation.
   virtual void OnNetworkChanged(NetworkLibrary* cros, const Network* network);
 
 #if defined(UNIT_TEST)
   void SetTesting() {
     testing_ = true;
     active_network_ = "test";
-    UIMakeActiveNetworkCurrent();
+    UIMakeActiveNetworkCurrentWithProfile(NULL);
   }
 #endif  // defined(UNIT_TEST)
 
  private:
   friend class base::RefCountedThreadSafe<ProxyConfigServiceImpl>;
 
   // Called from UI thread from the various UISetProxyConfigTo*.
   void OnUISetProxyConfig();
 
   // Posted from UI thread to IO thread to carry the new config information.
@@ skipping 11 matching lines @@
   // 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 proxy config for ui based on |profile| and |network|.
+  void DetermineUIConfig(Profile* profile, const Network* network);
+
   // Set |current_ui_network_name_| with name of |network|.
   void SetCurrentNetworkName(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.
+  void ResetUICache();
+
   // 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.
@@ skipping 17 matching lines @@
   // 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_;
 
+  // True if user preference UseSharedProxies is true.
+  bool use_shared_proxies_;
+
   // 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
+  // UIMakeActiveNetworkCurrentWithProfile and UISetCurrentNetworkWithProfile.
   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_