Renaming instances of "flimflam" with "shill", now that we're only

chrome/browser/chromeos/proxy_config_service_impl.h

 // Copyright (c) 2012 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_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/values.h"
 #include "chrome/browser/api/prefs/pref_member.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/net/pref_proxy_config_tracker_impl.h"
 
 namespace chromeos {
 
 // Implementation of proxy config service for chromeos that:
 // - extends PrefProxyConfigTrackerImpl (and so lives and runs entirely on UI
 //   thread) to handle proxy from prefs (via PrefProxyConfigTrackerImpl) and
-//   system i.e. network (via flimflam notifications)
+//   system i.e. network (via shill notifications)
 // - exists one per profile and one per local state
 // - retrieves initial system proxy configuration from cros settings persisted
-//   on chromeos device from chromeos revisions before migration to flimflam,
+//   on chromeos device from chromeos revisions before migration to shill,
 // - persists proxy setting per network in flimflim
 // - provides network stack with latest effective proxy configuration for
 //   currently active network via PrefProxyConfigTrackerImpl's mechanism of
 //   pushing config to ChromeProxyConfigService
 // - provides UI with methods to retrieve and modify proxy configuration for
 //   any remembered network (either currently active or non-active) of current
 //   user profile
 class ProxyConfigServiceImpl
     : public PrefProxyConfigTrackerImpl,
       public NetworkLibrary::NetworkManagerObserver,
@@ skipping 52 matching lines @@
     bool FromNetProxyConfig(const net::ProxyConfig& net_config);
 
     // Converts |this| to Dictionary of ProxyConfigDictionary format (which
     // is the same format used by prefs).
     DictionaryValue* ToPrefProxyConfig();
 
     // 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
+    // We've migrated device settings to shill, 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.
+    // persisted as string property in shill for a network.
     bool SerializeForNetwork(std::string* output);
 
     // Encodes the proxy server as "<url-scheme>=<proxy-scheme>://<proxy>"
     static void EncodeAndAppendProxyServer(const std::string& scheme,
                                            const net::ProxyServer& server,
                                            std::string* spec);
 
     Mode mode;
 
     ProxyPrefs::ConfigState state;
@@ skipping 36 matching lines @@
   void UIMakeActiveNetworkCurrent();
 
   // Called from UI to get name of the current network set via
   // UISetCurrentNetwork or UIMakeActiveNetworkCurrent.
   void UIGetCurrentNetworkName(std::string* network_name);
 
   // Called from UI to retrieve proxy configuration in |current_ui_config_|.
   void UIGetProxyConfig(ProxyConfig* config);
 
   // Called from UI to update proxy configuration for different modes.
-  // Returns true if config is set properly and persisted to flimflam for the
+  // Returns true if config is set properly and persisted to shill 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.
   bool UISetProxyConfigToDirect();
   bool UISetProxyConfigToAutoDetect();
   bool UISetProxyConfigToPACScript(const GURL& pac_url);
@@ skipping 38 matching lines @@
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Called from the various UISetProxyConfigTo*.
   void OnUISetProxyConfig();
 
   // Called from OnNetworkManagerChanged and OnNetworkChanged for currently
   // active network, to handle previously active network, new active network,
-  // and if necessary, migrates device settings to flimflam and/or activates
+  // and if necessary, migrates device settings to shill and/or activates
   // proxy setting of new network.
   void OnActiveNetworkChanged(NetworkLibrary* cros,
                               const Network* active_network);
 
-  // Sets proxy config for |network_path| into flimflam and activates setting
+  // Sets proxy config for |network_path| into shill and activates setting
   // if the network is currently active.  If |only_set_if_empty| is true,
   // proxy will be set and saved only if network has no proxy.
   void SetProxyConfigForNetwork(const std::string& network_path,
                                 const std::string& value,
                                 bool only_set_if_empty);
 
   // Returns value of UseSharedProxies preference if it's not default, else
   // returns false if user is logged in and true otherwise.
   bool GetUseSharedProxies();
 
@@ skipping 15 matching lines @@
     return network->profile_type() == PROFILE_SHARED && !GetUseSharedProxies();
   }
 
   // Reset UI cache variables that keep track of UI activities.
   void ResetUICache();
 
   void FetchProxyPolicy();
 
   // Data members.
 
-  // Service path of currently active network (determined via flimflam
+  // Service path of currently active network (determined via shill
   // notifications); if effective proxy config is from system, proxy of this
   // network will be the one taking effect.
   std::string active_network_;
 
   // State of |active_config_|.  |active_config_| is only valid if
   // |active_config_state_| is not ProxyPrefs::CONFIG_UNSET.
   ProxyPrefs::ConfigState active_config_state_;
 
   // Active proxy configuration, which could be from prefs or network.
   net::ProxyConfig active_config_;
 
   // Proxy config retreived from device, in format generated from
-  // SerializeForNetwork, that can be directly set into flimflam.
+  // SerializeForNetwork, that can be directly set into shill.
   std::string device_config_;
 
   // 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_;
 
   // Proxy configuration of |current_ui_network_|.
   ProxyConfig current_ui_config_;
 
   // Track changes in UseSharedProxies user preference.
   BooleanPrefMember use_shared_proxies_;
 
   // Callbacks for notification when network to be viewed has been changed from
   // the UI.
   std::vector<base::Closure> callbacks_;
 
   base::WeakPtrFactory<ProxyConfigServiceImpl> pointer_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyConfigServiceImpl);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PROXY_CONFIG_SERVICE_IMPL_H_