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

chrome/browser/chromeos/cros/network_library_impl_base.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_impl_base.h"
 
 #include "base/bind.h"
 #include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/cros/onc_network_parser.h"
 #include "chrome/browser/chromeos/network_login_observer.h"
@@ skipping 303 matching lines @@
   return wimax_networks_;
 }
 const VirtualNetworkVector& NetworkLibraryImplBase::virtual_networks() const {
   return virtual_networks_;
 }
 const VirtualNetworkVector&
     NetworkLibraryImplBase::remembered_virtual_networks() const {
   return remembered_virtual_networks_;
 }
 
-// Use flimflam's ordering of the services to determine which type of
+// Use shill's ordering of the services to determine which type of
 // network to return (i.e. don't assume priority of network types).
 // Note: This does not include any virtual networks.
 namespace {
 Network* highest_priority(Network* a, Network*b) {
   if (!a)
     return b;
   if (!b)
     return a;
   if (b->priority_order() < a->priority_order())
     return b;
@@ skipping 486 matching lines @@
 
 // 2. Start the connection.
 void NetworkLibraryImplBase::NetworkConnectStartWifi(
     WifiNetwork* wifi, NetworkProfileType profile_type) {
   DCHECK(!wifi->connection_started());
   // This will happen if a network resets, gets out of range or is forgotten.
   if (wifi->user_passphrase_ != wifi->passphrase_ ||
       wifi->passphrase_required())
     wifi->SetPassphrase(wifi->user_passphrase_);
   // For enterprise 802.1X networks, always provide TPM PIN when available.
-  // flimflam uses the PIN if it needs to access certificates in the TPM and
+  // shill uses the PIN if it needs to access certificates in the TPM and
   // ignores it otherwise.
   if (wifi->encryption() == SECURITY_8021X) {
     // If the TPM initialization has not completed, GetTpmPin() will return
     // an empty value, in which case we do not want to clear the PIN since
-    // that will cause flimflam to flag the network as unconfigured.
+    // that will cause shill to flag the network as unconfigured.
     // TODO(stevenjb): We may want to delay attempting to connect, or fail
     // immediately, rather than let the network layer attempt a connection.
     std::string tpm_pin = GetTpmPin();
     if (!tpm_pin.empty())
       wifi->SetCertificatePin(tpm_pin);
   }
   NetworkConnectStart(wifi, profile_type);
 }
 
 void NetworkLibraryImplBase::NetworkConnectStartVPN(VirtualNetwork* vpn) {
-  // flimflam needs the TPM PIN for some VPN networks to access client
+  // shill needs the TPM PIN for some VPN networks to access client
   // certificates, and ignores the PIN if it doesn't need them. Only set this
   // if the TPM is ready (see comment in NetworkConnectStartWifi).
   std::string tpm_pin = GetTpmPin();
   if (!tpm_pin.empty()) {
     std::string tpm_slot = GetTpmSlot();
     vpn->SetCertificateSlotAndPin(tpm_slot, tpm_pin);
   }
   NetworkConnectStart(vpn, PROFILE_NONE);
 }
 
@@ skipping 55 matching lines @@
     NotifyNetworkChanged(network);
     VLOG(1) << "Error connecting to network: " << network->name()
             << " Status: " << status;
     return;
   }
 
   VLOG(1) << "Connected to network: " << network->name()
           << " State: " << network->state()
           << " Status: " << status;
 
-  // If the user asked not to save credentials, flimflam will have
+  // If the user asked not to save credentials, shill will have
   // forgotten them.  Wipe our cache as well.
   if (!network->save_credentials())
     network->EraseCredentials();
 
   ClearActiveNetwork(network->type());
   UpdateActiveNetwork(network);
 
   // Notify observers.
   NotifyNetworkManagerChanged(true);  // Forced update.
   NotifyUserConnectionInitiated(network);
@@ skipping 380 matching lines @@
     return true;
 
   // Set |network| to active.
   UpdateActiveNetwork(network);
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // Network list management functions.
 
-// Note: sometimes flimflam still returns networks when the device type is
+// Note: sometimes shill still returns networks when the device type is
 // disabled. Always check the appropriate enabled() state before adding
 // networks to a list or setting an active network so that we do not show them
 // in the UI.
 
-// This relies on services being requested from flimflam in priority order,
+// This relies on services being requested from shill in priority order,
 // and the updates getting processed and received in order.
 void NetworkLibraryImplBase::UpdateActiveNetwork(Network* network) {
   network->set_is_active(true);
   ConnectionType type(network->type());
   if (type == TYPE_ETHERNET) {
     if (ethernet_enabled()) {
       // Set ethernet_ to the first connected ethernet service, or the first
       // disconnected ethernet service if none are connected.
       if (ethernet_ == NULL || !ethernet_->connected()) {
         ethernet_ = static_cast<EthernetNetwork*>(network);
@@ skipping 129 matching lines @@
 
 bool NetworkLibraryImplBase::ValidateRememberedNetwork(Network* network) {
   std::pair<NetworkMap::iterator, bool> result =
       remembered_network_map_.insert(
           std::make_pair(network->service_path(), network));
   DCHECK(result.second);  // Should only get called with new network.
 
   // See if this is a policy-configured network that has meanwhile been removed.
   // This situation may arise when the full list of remembered networks is not
   // available to LoadOncNetworks(), which can happen due to the asynchronous
-  // communication between flimflam and NetworkLibrary. Just tell flimflam to
+  // communication between shill and NetworkLibrary. Just tell shill to
   // delete the network now.
   const NetworkUIData::ONCSource source = network->ui_data().onc_source();
   if (source == NetworkUIData::ONC_SOURCE_USER_POLICY ||
       source == NetworkUIData::ONC_SOURCE_DEVICE_POLICY) {
     NetworkSourceMap::const_iterator network_id_set(
         network_source_map_.find(source));
     if (network_id_set != network_source_map_.end() &&
         network_id_set->second.find(network->unique_id()) ==
             network_id_set->second.end()) {
       DeleteRememberedNetwork(network->service_path());
@@ skipping 10 matching lines @@
 
   if (network->type() == TYPE_WIFI) {
     remembered_wifi_networks_.push_back(
         static_cast<WifiNetwork*>(network));
   } else if (network->type() == TYPE_VPN) {
     remembered_virtual_networks_.push_back(
         static_cast<VirtualNetwork*>(network));
   } else {
     NOTREACHED();
   }
-  // Find service path in profiles. Flimflam does not set the Profile
+  // Find service path in profiles. Shill does not set the Profile
   // property for remembered networks, only active networks.
   for (NetworkProfileList::iterator iter = profile_list_.begin();
        iter != profile_list_.end(); ++iter) {
     NetworkProfile& profile = *iter;
     if (profile.services.find(network->service_path()) !=
         profile.services.end()) {
       network->set_profile_path(profile.path);
       network->set_profile_type(profile.type);
       VLOG(1) << "ValidateAndAddRememberedNetwork: " << network->service_path()
               << " profile: " << profile.path;
       break;
     }
   }
   DCHECK(!network->profile_path().empty())
       << "Service path not in any profile: " << network->service_path();
   return true;
 }
 
 void NetworkLibraryImplBase::DeleteRememberedNetwork(
     const std::string& service_path) {
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found == remembered_network_map_.end()) {
     LOG(WARNING) << "Attempt to delete non-existent remembered network: "
                  << service_path;
     return;
   }
   Network* remembered_network = found->second;
 
   // Update any associated network service before removing from profile
-  // so that flimflam doesn't recreate the service (e.g. when we disconenct it).
+  // so that shill doesn't recreate the service (e.g. when we disconenct it).
   Network* network = FindNetworkByUniqueId(remembered_network->unique_id());
   if (network) {
     // Clear the stored credentials for any forgotten networks.
     network->EraseCredentials();
     network->ClearUIData();
     SetProfileType(network, PROFILE_NONE);
     // Remove VPN from list of networks.
     if (network->type() == TYPE_VPN)
       CallRemoveNetwork(network);
   } else {
@@ skipping 289 matching lines @@
   GetTpmInfo();
   return tpm_slot_;
 }
 
 const std::string& NetworkLibraryImplBase::GetTpmPin() {
   GetTpmInfo();
   return tpm_pin_;
 }
 
 }  // namespace chromeos