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

chrome/browser/chromeos/cros/onc_network_parser.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/onc_network_parser.h"
 
 #include <keyhi.h>
 #include <pk11pub.h>
 
 #include "base/base64.h"
@@ skipping 563 matching lines @@
                          static_cast<const base::Value&>(info),
                          network_configuration_signature,
                          ParseNetworkConfigurationValue)) {
     LOG(WARNING) << "Network " << network->name() << " failed to parse.";
     if (parse_error_.empty())
       parse_error_ = l10n_util::GetStringUTF8(
           IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
     return NULL;
   }
 
-  // Update the UI data property in flimflam.
+  // Update the UI data property in shill.
   std::string ui_data_json;
   base::DictionaryValue ui_data_dict;
   network->ui_data().FillDictionary(&ui_data_dict);
   base::JSONWriter::Write(&ui_data_dict, &ui_data_json);
   base::StringValue ui_data_string_value(ui_data_json);
   network->UpdatePropertyMap(PROPERTY_INDEX_UI_DATA, &ui_data_string_value);
 
   if (VLOG_IS_ON(2)) {
     VLOG(2) << "Created Network '" << network->name()
             << "' from info. Path:" << service_path
@@ skipping 189 matching lines @@
       std::string str =
           NativeNetworkParser::network_type_mapper()->GetKey(network->type());
       base::StringValue val(str);
       network->UpdatePropertyMap(PROPERTY_INDEX_TYPE, &val);
       return true;
     }
     case PROPERTY_INDEX_GUID:
       // Fall back to generic parser.
       return parser->ParseValue(index, value, network);
     case PROPERTY_INDEX_NAME:
-      // flimflam doesn't allow setting name for non-VPN networks.
+      // shill doesn't allow setting name for non-VPN networks.
       if (network->type() != TYPE_VPN) {
         network->UpdatePropertyMap(PROPERTY_INDEX_NAME, NULL);
         return true;
       }
 
       // Fall back to generic parser.
       return parser->ParseValue(index, value, network);
     default:
       break;
   }
@@ skipping 418 matching lines @@
     default:
       break;
   }
   if (!proxy_dict.get())
     return false;
 
   // Serialize ProxyConfigDictionary into a string.
   std::string proxy_dict_str = ConvertValueToString(*proxy_dict.get());
 
   // Add ProxyConfig property to property map so that it will be updated in
-  // flimflam in NetworkLibraryImplCros::CallConfigureService after all parsing
+  // shill in NetworkLibraryImplCros::CallConfigureService after all parsing
   // has completed.
   base::StringValue val(proxy_dict_str);
   network->UpdatePropertyMap(PROPERTY_INDEX_PROXY_CONFIG, &val);
 
   // If |network| is currently being connected to or it exists in memory,
-  // flimflam will fire PropertyChanged notification in ConfigureService,
+  // shill will fire PropertyChanged notification in ConfigureService,
   // chromeos::ProxyConfigServiceImpl will get OnNetworkChanged notification
   // and, if necessary, activate |proxy_dict_str| on network stack and reflect
   // it in UI via "Change proxy settings" button.
   network->set_proxy_config(proxy_dict_str);
   VLOG(1) << "Parsed ProxyConfig: " << network->proxy_config();
 
   return true;
 }
 
 // static
@@ skipping 480 matching lines @@
                                             PropertyIndex index,
                                             const base::Value& value,
                                             Network* network) {
   if (!CheckNetworkType(network, TYPE_VPN, onc::kVPN))
     return false;
   VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network);
   switch (index) {
     case PROPERTY_INDEX_PROVIDER_HOST: {
       base::StringValue empty_value("");
       virtual_network->set_server_hostname(GetStringValue(value));
-      // Flimflam requires a domain property which is unused.
+      // Shill requires a domain property which is unused.
       network->UpdatePropertyMap(PROPERTY_INDEX_VPN_DOMAIN, &empty_value);
       return true;
     }
     case PROPERTY_INDEX_ONC_IPSEC:
       if (virtual_network->provider_type() != PROVIDER_TYPE_L2TP_IPSEC_PSK &&
           virtual_network->provider_type() !=
           PROVIDER_TYPE_L2TP_IPSEC_USER_CERT) {
         VLOG(1) << "IPsec field not allowed with this VPN type";
         return false;
       }
@@ skipping 10 matching lines @@
       return parser->ParseNestedObject(network,
                                        onc::vpn::kL2TP,
                                        value,
                                        l2tp_signature,
                                        ParseL2TPValue);
     case PROPERTY_INDEX_ONC_OPENVPN: {
       if (virtual_network->provider_type() != PROVIDER_TYPE_OPEN_VPN) {
         VLOG(1) << "OpenVPN field not allowed with this VPN type";
         return false;
       }
-      // The following are needed by flimflam to set up the OpenVPN
+      // The following are needed by shill to set up the OpenVPN
       // management channel which every ONC OpenVPN configuration will
       // use.
       base::StringValue empty_value("");
       network->UpdatePropertyMap(PROPERTY_INDEX_OPEN_VPN_AUTHUSERPASS,
                                  &empty_value);
       network->UpdatePropertyMap(PROPERTY_INDEX_OPEN_VPN_MGMT_ENABLE,
                                  &empty_value);
       return parser->ParseNestedObject(network,
                                        onc::vpn::kOpenVPN,
                                        value,
@@ skipping 60 matching lines @@
                                        certificate_pattern_signature,
                                        ParseClientCertPattern);
     }
     case PROPERTY_INDEX_ONC_CLIENT_CERT_TYPE: {
       ClientCertType type = ParseClientCertType(GetStringValue(value));
       virtual_network->set_client_cert_type(type);
       return true;
     }
     case PROPERTY_INDEX_IPSEC_IKEVERSION: {
       if (!value.IsType(TYPE_STRING)) {
-        // Flimflam wants all provider properties to be strings.
+        // Shill wants all provider properties to be strings.
         base::StringValue string_value(ConvertValueToString(value));
         virtual_network->UpdatePropertyMap(index, &string_value);
       }
       return true;
     }
     default:
       break;
   }
   return false;
 }
@@ skipping 83 matching lines @@
       virtual_network->UpdatePropertyMap(index, &expanded_user_value);
       return true;
     }
     case PROPERTY_INDEX_SAVE_CREDENTIALS:
       virtual_network->set_save_credentials(GetBooleanValue(value));
       return true;
     case PROPERTY_INDEX_OPEN_VPN_CACERT:
       virtual_network->set_ca_cert_nss(GetStringValue(value));
       return true;
     case PROPERTY_INDEX_OPEN_VPN_REMOTECERTKU: {
-      // ONC supports a list of these, but we flimflam supports only one
+      // ONC supports a list of these, but we shill supports only one
       // today.  So extract the first.
       const base::ListValue* value_list = NULL;
       value.GetAsList(&value_list);
       const base::Value* first_item = NULL;
       if (!value_list->Get(0, &first_item) ||
           !first_item->IsType(base::Value::TYPE_STRING)) {
         VLOG(1) << "RemoteCertKU must be non-empty list of strings";
         return false;
       }
       virtual_network->UpdatePropertyMap(index, first_item);
@@ skipping 13 matching lines @@
     case PROPERTY_INDEX_OPEN_VPN_PUSHPEERINFO:
     case PROPERTY_INDEX_OPEN_VPN_REMOTECERTEKU:
     case PROPERTY_INDEX_OPEN_VPN_REMOTECERTTLS:
     case PROPERTY_INDEX_OPEN_VPN_RENEGSEC:
     case PROPERTY_INDEX_OPEN_VPN_SERVERPOLLTIMEOUT:
     case PROPERTY_INDEX_OPEN_VPN_SHAPER:
     case PROPERTY_INDEX_OPEN_VPN_STATICCHALLENGE:
     case PROPERTY_INDEX_OPEN_VPN_TLSAUTHCONTENTS:
     case PROPERTY_INDEX_OPEN_VPN_TLSREMOTE: {
       if (!value.IsType(TYPE_STRING)) {
-        // Flimflam wants all provider properties to be strings.
+        // Shill wants all provider properties to be strings.
         base::StringValue string_value(ConvertValueToString(value));
         virtual_network->UpdatePropertyMap(index, &string_value);
       }
       return true;
     }
     case PROPERTY_INDEX_ONC_CLIENT_CERT_REF: {
       std::string cert_id = GetPkcs11IdFromCertGuid(GetStringValue(value));
       if (cert_id.empty())
         return false;
       virtual_network->set_client_cert_id(cert_id);
@@ skipping 26 matching lines @@
     // on the value of AuthenticationType.
     { "L2TP-IPsec", PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { "OpenVPN", PROVIDER_TYPE_OPEN_VPN },
   };
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
       (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos