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

chrome/browser/chromeos/cros/network_library.cc

 // 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.
 
 #include "chrome/browser/chromeos/cros/network_library.h"
 
 #include <dbus/dbus-glib.h>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 270 matching lines @@
 
 // static
 Network* Network::CreateForTesting(ConnectionType type) {
   return new Network("fake_service_path", type);
 }
 
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
   if (state_ == STATE_CONNECT_REQUESTED && new_state == STATE_IDLE) {
-    // CONNECT_REQUESTED is set internally. Shill/flimflam do not update the
+    // CONNECT_REQUESTED is set internally. Shill does not update the
     // state immediately, so ignore any Idle state updates sent while a
     // connection attempt is in progress.
     VLOG(2) << "Ignoring idle state change after connection request.";
     return;
   }
   ConnectionState old_state = state_;
   VLOG(2) << "Entering new state: " << ConnectionStateString(new_state);
   state_ = new_state;
   if (!IsConnectingState(new_state))
     set_connection_started(false);
@@ skipping 303 matching lines @@
       break;
     case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       if (client_cert_id_.empty() &&
           client_cert_type() != CLIENT_CERT_TYPE_PATTERN)
         return true;
       break;
     case PROVIDER_TYPE_OPEN_VPN:
       if (client_cert_id_.empty())
         return true;
       // For now we always need additional info for OpenVPN.
-      // TODO(stevenjb): Check connectable() once flimflam sets that state
+      // TODO(stevenjb): Check connectable() once shill sets that state
       // properly, or define another mechanism to determine when additional
       // credentials are required.
       return true;
       break;
     case PROVIDER_TYPE_MAX:
       NOTREACHED();
       break;
   }
   return false;
 }
@@ skipping 202 matching lines @@
 }
 
 CellularNetwork::~CellularNetwork() {
 }
 
 bool CellularNetwork::StartActivation() {
   if (!EnsureCrosLoaded())
     return false;
   if (!CrosActivateCellularModem(service_path(), ""))
     return false;
-  // Don't wait for flimflam to tell us that we are really activating since
+  // Don't wait for shill to tell us that we are really activating since
   // other notifications in the message loop might cause us to think that
   // the process hasn't started yet.
   activation_state_ = ACTIVATION_STATE_ACTIVATING;
   return true;
 }
 
 void CellularNetwork::RefreshDataPlansIfNeeded() const {
   if (!EnsureCrosLoaded())
     return;
   if (connected() && activated())
@@ skipping 144 matching lines @@
       eap_phase_2_auth_(EAP_PHASE_2_AUTH_AUTO),
       eap_use_system_cas_(true),
       eap_save_credentials_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_pointer_factory_(this)) {
 }
 
 WifiNetwork::~WifiNetwork() {}
 
 void WifiNetwork::CalculateUniqueId() {
   ConnectionSecurity encryption = encryption_;
-  // Flimflam treats wpa and rsn as psk internally, so convert those types
+  // Shill treats wpa and rsn as psk internally, so convert those types
   // to psk for unique naming.
   if (encryption == SECURITY_WPA || encryption == SECURITY_RSN)
     encryption = SECURITY_PSK;
   std::string security = std::string(SecurityToString(encryption));
   set_unique_id(security + "|" + name());
 }
 
 bool WifiNetwork::SetSsid(const std::string& ssid) {
   // Detects encoding and convert to UTF-8.
   std::string ssid_utf8;
@@ skipping 26 matching lines @@
   return SetSsid(std::string(ssid_raw.begin(), ssid_raw.end()));
 }
 
 const std::string& WifiNetwork::GetPassphrase() const {
   if (!user_passphrase_.empty())
     return user_passphrase_;
   return passphrase_;
 }
 
 void WifiNetwork::SetPassphrase(const std::string& passphrase) {
-  // Set the user_passphrase_ only; passphrase_ stores the flimflam value.
+  // Set the user_passphrase_ only; passphrase_ stores the shill value.
   // If the user sets an empty passphrase, restore it to the passphrase
-  // remembered by flimflam.
+  // remembered by shill.
   if (!passphrase.empty()) {
     user_passphrase_ = passphrase;
     passphrase_ = passphrase;
   } else {
     user_passphrase_ = passphrase_;
   }
-  // Send the change to flimflam. If the format is valid, it will propagate to
+  // Send the change to shill. If the format is valid, it will propagate to
   // passphrase_ with a service update.
   SetOrClearStringProperty(flimflam::kPassphraseProperty, passphrase, NULL);
 }
 
-// See src/third_party/flimflam/doc/service-api.txt for properties that
-// flimflam will forget when SaveCredentials is false.
+// See src/third_party/shill/doc/service-api.txt for properties that
+// shill will forget when SaveCredentials is false.
 void WifiNetwork::EraseCredentials() {
   WipeString(&passphrase_);
   WipeString(&user_passphrase_);
   WipeString(&eap_client_cert_pkcs11_id_);
   WipeString(&eap_identity_);
   WipeString(&eap_anonymous_identity_);
   WipeString(&eap_passphrase_);
 }
 
 void WifiNetwork::SetIdentity(const std::string& identity) {
@@ skipping 67 matching lines @@
     const std::string& nss_nickname) {
   VLOG(1) << "SetEAPServerCaCertNssNickname " << nss_nickname;
   SetOrClearStringProperty(flimflam::kEapCaCertNssProperty,
                            nss_nickname, &eap_server_ca_cert_nss_nickname_);
 }
 
 void WifiNetwork::SetEAPClientCertPkcs11Id(const std::string& pkcs11_id) {
   VLOG(1) << "SetEAPClientCertPkcs11Id " << pkcs11_id;
   SetOrClearStringProperty(
       flimflam::kEapCertIdProperty, pkcs11_id, &eap_client_cert_pkcs11_id_);
-  // flimflam requires both CertID and KeyID for TLS connections, despite
+  // shill requires both CertID and KeyID for TLS connections, despite
   // the fact that by convention they are the same ID.
   SetOrClearStringProperty(flimflam::kEapKeyIdProperty, pkcs11_id, NULL);
 }
 
 void WifiNetwork::SetEAPUseSystemCAs(bool use_system_cas) {
   SetBooleanProperty(flimflam::kEapUseSystemCasProperty, use_system_cas,
                      &eap_use_system_cas_);
 }
 
 void WifiNetwork::SetEAPIdentity(const std::string& identity) {
@@ skipping 43 matching lines @@
       }
       return result;
     }
     case SECURITY_PSK:
       return "PSK";
   }
   return "Unknown";
 }
 
 bool WifiNetwork::IsPassphraseRequired() const {
-  // TODO(stevenjb): Remove error_ tests when fixed in flimflam
+  // TODO(stevenjb): Remove error_ tests when fixed.
   // (http://crosbug.com/10135).
   if (error() == ERROR_BAD_PASSPHRASE || error() == ERROR_BAD_WEPKEY)
     return true;
   // For 802.1x networks, configuration is required if connectable is false
   // unless we're using a certificate pattern.
   if (encryption_ == SECURITY_8021X) {
     if (eap_method_ != EAP_METHOD_TLS ||
         client_cert_type() != CLIENT_CERT_TYPE_PATTERN)
       return !connectable();
     return false;
@@ skipping 110 matching lines @@
   NetworkLibrary* impl;
   if (stub)
     impl = new NetworkLibraryImplStub();
   else
     impl = new NetworkLibraryImplCros();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos