diff options
Diffstat (limited to 'chromeos')
41 files changed, 554 insertions, 580 deletions
diff --git a/chromeos/network/client_cert_resolver_unittest.cc b/chromeos/network/client_cert_resolver_unittest.cc index f275c82..b802bf3 100644 --- a/chromeos/network/client_cert_resolver_unittest.cc +++ b/chromeos/network/client_cert_resolver_unittest.cc @@ -145,12 +145,12 @@ class ClientCertResolverTest : public testing::Test { const bool add_to_watchlist = true; service_test_->AddService(kWifiStub, kWifiSSID, - flimflam::kTypeWifi, - flimflam::kStateOnline, + shill::kTypeWifi, + shill::kStateOnline, add_to_visible, add_to_watchlist); service_test_->SetServiceProperty( - kWifiStub, flimflam::kGuidProperty, base::StringValue(kWifiStub)); + kWifiStub, shill::kGuidProperty, base::StringValue(kWifiStub)); profile_test_->AddService(kUserProfilePath, kWifiStub); } @@ -196,7 +196,7 @@ class ClientCertResolverTest : public testing::Test { service_test_->GetServiceProperties(kWifiStub); if (!properties) return; - properties->GetStringWithoutPathExpansion(flimflam::kEapCertIdProperty, + properties->GetStringWithoutPathExpansion(shill::kEapCertIdProperty, pkcs11_id); } diff --git a/chromeos/network/client_cert_util.cc b/chromeos/network/client_cert_util.cc index 88ff649..a1ec8a4 100644 --- a/chromeos/network/client_cert_util.cc +++ b/chromeos/network/client_cert_util.cc @@ -208,33 +208,33 @@ void SetShillProperties(const client_cert::ConfigType cert_config_type, return; } case CONFIG_TYPE_OPENVPN: { - tpm_pin_property = flimflam::kOpenVPNPinProperty; + tpm_pin_property = shill::kOpenVPNPinProperty; if (pkcs11_id) { properties->SetStringWithoutPathExpansion( - flimflam::kOpenVPNClientCertIdProperty, *pkcs11_id); + shill::kOpenVPNClientCertIdProperty, *pkcs11_id); } break; } case CONFIG_TYPE_IPSEC: { - tpm_pin_property = flimflam::kL2tpIpsecPinProperty; + tpm_pin_property = shill::kL2tpIpsecPinProperty; if (!tpm_slot.empty()) { properties->SetStringWithoutPathExpansion( - flimflam::kL2tpIpsecClientCertSlotProperty, tpm_slot); + shill::kL2tpIpsecClientCertSlotProperty, tpm_slot); } if (pkcs11_id) { properties->SetStringWithoutPathExpansion( - flimflam::kL2tpIpsecClientCertIdProperty, *pkcs11_id); + shill::kL2tpIpsecClientCertIdProperty, *pkcs11_id); } break; } case CONFIG_TYPE_EAP: { - tpm_pin_property = flimflam::kEapPinProperty; + tpm_pin_property = shill::kEapPinProperty; if (pkcs11_id) { // Shill requires both CertID and KeyID for TLS connections, despite the // fact that by convention they are the same ID. - properties->SetStringWithoutPathExpansion(flimflam::kEapCertIdProperty, + properties->SetStringWithoutPathExpansion(shill::kEapCertIdProperty, *pkcs11_id); - properties->SetStringWithoutPathExpansion(flimflam::kEapKeyIdProperty, + properties->SetStringWithoutPathExpansion(shill::kEapKeyIdProperty, *pkcs11_id); } break; @@ -250,7 +250,7 @@ bool IsCertificateConfigured(const client_cert::ConfigType cert_config_type, // VPN certificate properties are read from the Provider dictionary. const base::DictionaryValue* provider_properties = NULL; service_properties.GetDictionaryWithoutPathExpansion( - flimflam::kProviderProperty, &provider_properties); + shill::kProviderProperty, &provider_properties); switch (cert_config_type) { case CONFIG_TYPE_NONE: return true; @@ -263,11 +263,11 @@ bool IsCertificateConfigured(const client_cert::ConfigType cert_config_type, return false; case CONFIG_TYPE_EAP: { std::string cert_id = GetStringFromDictionary( - service_properties, flimflam::kEapCertIdProperty); + service_properties, shill::kEapCertIdProperty); std::string key_id = GetStringFromDictionary( - service_properties, flimflam::kEapKeyIdProperty); + service_properties, shill::kEapKeyIdProperty); std::string identity = GetStringFromDictionary( - service_properties, flimflam::kEapIdentityProperty); + service_properties, shill::kEapIdentityProperty); return !cert_id.empty() && !key_id.empty() && !identity.empty(); } } diff --git a/chromeos/network/device_state.cc b/chromeos/network/device_state.cc index f71b978..d39fc14 100644 --- a/chromeos/network/device_state.cc +++ b/chromeos/network/device_state.cc @@ -31,23 +31,23 @@ bool DeviceState::PropertyChanged(const std::string& key, if (ManagedStatePropertyChanged(key, value)) return true; - if (key == flimflam::kAddressProperty) { + if (key == shill::kAddressProperty) { return GetStringValue(key, value, &mac_address_); - } else if (key == flimflam::kScanningProperty) { + } else if (key == shill::kScanningProperty) { return GetBooleanValue(key, value, &scanning_); - } else if (key == flimflam::kSupportNetworkScanProperty) { + } else if (key == shill::kSupportNetworkScanProperty) { return GetBooleanValue(key, value, &support_network_scan_); } else if (key == shill::kProviderRequiresRoamingProperty) { return GetBooleanValue(key, value, &provider_requires_roaming_); - } else if (key == flimflam::kHomeProviderProperty) { + } else if (key == shill::kHomeProviderProperty) { const base::DictionaryValue* dict = NULL; if (!value.GetAsDictionary(&dict)) return false; std::string home_provider_country; std::string home_provider_name; - dict->GetStringWithoutPathExpansion(flimflam::kOperatorCountryKey, + dict->GetStringWithoutPathExpansion(shill::kOperatorCountryKey, &home_provider_country); - dict->GetStringWithoutPathExpansion(flimflam::kOperatorNameKey, + dict->GetStringWithoutPathExpansion(shill::kOperatorNameKey, &home_provider_name); // Set home_provider_id_ if (!home_provider_name.empty() && !home_provider_country.empty()) { @@ -56,17 +56,17 @@ bool DeviceState::PropertyChanged(const std::string& key, home_provider_name.c_str(), home_provider_country.c_str()); } else { - dict->GetStringWithoutPathExpansion(flimflam::kOperatorCodeKey, + dict->GetStringWithoutPathExpansion(shill::kOperatorCodeKey, &home_provider_id_); LOG(WARNING) << "Carrier ID not defined, using code instead: " << home_provider_id_; } return true; - } else if (key == flimflam::kTechnologyFamilyProperty) { + } else if (key == shill::kTechnologyFamilyProperty) { return GetStringValue(key, value, &technology_family_); - } else if (key == flimflam::kCarrierProperty) { + } else if (key == shill::kCarrierProperty) { return GetStringValue(key, value, &carrier_); - } else if (key == flimflam::kFoundNetworksProperty) { + } else if (key == shill::kFoundNetworksProperty) { const base::ListValue* list = NULL; if (!value.GetAsList(&list)) return false; @@ -75,7 +75,7 @@ bool DeviceState::PropertyChanged(const std::string& key, return false; scan_results_.swap(parsed_results); return true; - } else if (key == flimflam::kSIMLockStatusProperty) { + } else if (key == shill::kSIMLockStatusProperty) { const base::DictionaryValue* dict = NULL; if (!value.GetAsDictionary(&dict)) return false; @@ -83,35 +83,35 @@ bool DeviceState::PropertyChanged(const std::string& key, // Return true if at least one of the property values changed. bool property_changed = false; const base::Value* out_value = NULL; - if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockRetriesLeftProperty, + if (!dict->GetWithoutPathExpansion(shill::kSIMLockRetriesLeftProperty, &out_value)) return false; - if (GetUInt32Value(flimflam::kSIMLockRetriesLeftProperty, + if (GetUInt32Value(shill::kSIMLockRetriesLeftProperty, *out_value, &sim_retries_left_)) property_changed = true; - if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockTypeProperty, + if (!dict->GetWithoutPathExpansion(shill::kSIMLockTypeProperty, &out_value)) return false; - if (GetStringValue(flimflam::kSIMLockTypeProperty, + if (GetStringValue(shill::kSIMLockTypeProperty, *out_value, &sim_lock_type_)) property_changed = true; - if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockEnabledProperty, + if (!dict->GetWithoutPathExpansion(shill::kSIMLockEnabledProperty, &out_value)) return false; - if (GetBooleanValue(flimflam::kSIMLockEnabledProperty, + if (GetBooleanValue(shill::kSIMLockEnabledProperty, *out_value, &sim_lock_enabled_)) property_changed = true; return property_changed; - } else if (key == flimflam::kMeidProperty) { + } else if (key == shill::kMeidProperty) { return GetStringValue(key, value, &meid_); - } else if (key == flimflam::kImeiProperty) { + } else if (key == shill::kImeiProperty) { return GetStringValue(key, value, &imei_); - } else if (key == flimflam::kIccidProperty) { + } else if (key == shill::kIccidProperty) { return GetStringValue(key, value, &iccid_); - } else if (key == flimflam::kMdnProperty) { + } else if (key == shill::kMdnProperty) { return GetStringValue(key, value, &mdn_); } else if (key == shill::kSIMPresentProperty) { return GetBooleanValue(key, value, &sim_present_); @@ -130,7 +130,7 @@ bool DeviceState::InitialPropertiesReceived( } bool DeviceState::IsSimAbsent() const { - return technology_family_ == flimflam::kTechnologyFamilyGsm && !sim_present_; + return technology_family_ == shill::kTechnologyFamilyGsm && !sim_present_; } } // namespace chromeos diff --git a/chromeos/network/favorite_state.cc b/chromeos/network/favorite_state.cc index 96fc74f..66efe55 100644 --- a/chromeos/network/favorite_state.cc +++ b/chromeos/network/favorite_state.cc @@ -26,9 +26,9 @@ bool FavoriteState::PropertyChanged(const std::string& key, const base::Value& value) { if (ManagedStatePropertyChanged(key, value)) return true; - if (key == flimflam::kProfileProperty) { + if (key == shill::kProfileProperty) { return GetStringValue(key, value, &profile_path_); - } else if (key == flimflam::kUIDataProperty) { + } else if (key == shill::kUIDataProperty) { scoped_ptr<NetworkUIData> new_ui_data = shill_property_util::GetUIDataFromValue(value); if (!new_ui_data) { @@ -37,7 +37,7 @@ bool FavoriteState::PropertyChanged(const std::string& key, } ui_data_ = *new_ui_data; return true; - } else if (key == flimflam::kGuidProperty) { + } else if (key == shill::kGuidProperty) { return GetStringValue(key, value, &guid_); } return false; diff --git a/chromeos/network/geolocation_handler.cc b/chromeos/network/geolocation_handler.cc index 468b2d0..d4adfb8 100644 --- a/chromeos/network/geolocation_handler.cc +++ b/chromeos/network/geolocation_handler.cc @@ -64,13 +64,13 @@ void GeolocationHandler::ManagerPropertiesCallback( DBusMethodCallStatus call_status, const base::DictionaryValue& properties) { const base::Value* value = NULL; - if (properties.Get(flimflam::kEnabledTechnologiesProperty, &value) && value) - HandlePropertyChanged(flimflam::kEnabledTechnologiesProperty, *value); + if (properties.Get(shill::kEnabledTechnologiesProperty, &value) && value) + HandlePropertyChanged(shill::kEnabledTechnologiesProperty, *value); } void GeolocationHandler::HandlePropertyChanged(const std::string& key, const base::Value& value) { - if (key != flimflam::kEnabledTechnologiesProperty) + if (key != shill::kEnabledTechnologiesProperty) return; const base::ListValue* technologies = NULL; if (!value.GetAsList(&technologies) || !technologies) @@ -81,7 +81,7 @@ void GeolocationHandler::HandlePropertyChanged(const std::string& key, iter != technologies->end(); ++iter) { std::string technology; (*iter)->GetAsString(&technology); - if (technology == flimflam::kTypeWifi) { + if (technology == shill::kTypeWifi) { wifi_enabled_ = true; break; } diff --git a/chromeos/network/geolocation_handler_unittest.cc b/chromeos/network/geolocation_handler_unittest.cc index 8657497..be0985d 100644 --- a/chromeos/network/geolocation_handler_unittest.cc +++ b/chromeos/network/geolocation_handler_unittest.cc @@ -57,7 +57,7 @@ class GeolocationHandlerTest : public testing::Test { shill::kGeoChannelProperty, channel); properties.SetStringWithoutPathExpansion( shill::kGeoSignalStrengthProperty, strength); - manager_test_->AddGeoNetwork(flimflam::kTypeWifi, properties); + manager_test_->AddGeoNetwork(shill::kTypeWifi, properties); message_loop_.RunUntilIdle(); } diff --git a/chromeos/network/managed_network_configuration_handler_impl.cc b/chromeos/network/managed_network_configuration_handler_impl.cc index f48efe0..f6c8414 100644 --- a/chromeos/network/managed_network_configuration_handler_impl.cc +++ b/chromeos/network/managed_network_configuration_handler_impl.cc @@ -144,7 +144,7 @@ void ManagedNetworkConfigurationHandlerImpl::GetManagedPropertiesCallback( const std::string& service_path, const base::DictionaryValue& shill_properties) { std::string profile_path; - shill_properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty, + shill_properties.GetStringWithoutPathExpansion(shill::kProfileProperty, &profile_path); const NetworkProfile* profile = network_profile_handler_->GetProfileForPath(profile_path); diff --git a/chromeos/network/managed_network_configuration_handler_unittest.cc b/chromeos/network/managed_network_configuration_handler_unittest.cc index dfeaebc..c2eca5e 100644 --- a/chromeos/network/managed_network_configuration_handler_unittest.cc +++ b/chromeos/network/managed_network_configuration_handler_unittest.cc @@ -79,7 +79,7 @@ class ShillProfileTestClient { ASSERT_TRUE(entries); base::DictionaryValue* new_entry = entry.DeepCopy(); - new_entry->SetStringWithoutPathExpansion(flimflam::kProfileProperty, + new_entry->SetStringWithoutPathExpansion(shill::kProfileProperty, profile_path); entries->SetWithoutPathExpansion(entry_path, new_entry); } @@ -94,8 +94,7 @@ class ShillProfileTestClient { scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue); base::ListValue* entry_paths = new base::ListValue; - result->SetWithoutPathExpansion(flimflam::kEntriesProperty, - entry_paths); + result->SetWithoutPathExpansion(shill::kEntriesProperty, entry_paths); for (base::DictionaryValue::Iterator it(*entries); !it.IsAtEnd(); it.Advance()) { entry_paths->AppendString(it.key()); @@ -412,7 +411,7 @@ TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUpdateManagedNewGUID) { // The passphrase isn't sent again, because it's configured by the user and // Shill doesn't sent it on GetProperties calls. expected_shill_properties->RemoveWithoutPathExpansion( - flimflam::kPassphraseProperty, NULL); + shill::kPassphraseProperty, NULL); EXPECT_CALL(mock_profile_client_, GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _)); @@ -448,7 +447,7 @@ TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyReapplyToManaged) { // The passphrase isn't sent again, because it's configured by the user and // Shill doesn't sent it on GetProperties calls. expected_shill_properties->RemoveWithoutPathExpansion( - flimflam::kPassphraseProperty, NULL); + shill::kPassphraseProperty, NULL); EXPECT_CALL(mock_profile_client_, GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _)); diff --git a/chromeos/network/managed_state.cc b/chromeos/network/managed_state.cc index cedddf3..b4f77fb 100644 --- a/chromeos/network/managed_state.cc +++ b/chromeos/network/managed_state.cc @@ -66,9 +66,9 @@ bool ManagedState::InitialPropertiesReceived( bool ManagedState::ManagedStatePropertyChanged(const std::string& key, const base::Value& value) { - if (key == flimflam::kNameProperty) { + if (key == shill::kNameProperty) { return GetStringValue(key, value, &name_); - } else if (key == flimflam::kTypeProperty) { + } else if (key == shill::kTypeProperty) { return GetStringValue(key, value, &type_); } return false; diff --git a/chromeos/network/managed_state.h b/chromeos/network/managed_state.h index 7f9875e..2cab509 100644 --- a/chromeos/network/managed_state.h +++ b/chromeos/network/managed_state.h @@ -110,8 +110,8 @@ class CHROMEOS_EXPORT ManagedState { std::string path_; // Common properties shared by all managed state objects. - std::string name_; // flimflam::kNameProperty - std::string type_; // flimflam::kTypeProperty + std::string name_; // shill::kNameProperty + std::string type_; // shill::kTypeProperty // Set to true when the an update has been received. bool update_received_; diff --git a/chromeos/network/network_cert_migrator.cc b/chromeos/network/network_cert_migrator.cc index 259f2a9..f32dc16 100644 --- a/chromeos/network/network_cert_migrator.cc +++ b/chromeos/network/network_cert_migrator.cc @@ -131,11 +131,11 @@ class NetworkCertMigrator::MigrationTask const char* pem_key; UMANetworkType uma_type; } const kNssPemMap[] = { - { NULL, flimflam::kEapCaCertNssProperty, shill::kEapCaCertPemProperty, + { NULL, shill::kEapCaCertNssProperty, shill::kEapCaCertPemProperty, UMA_NETWORK_TYPE_EAP }, - { flimflam::kProviderProperty, flimflam::kL2tpIpsecCaCertNssProperty, + { shill::kProviderProperty, shill::kL2tpIpsecCaCertNssProperty, shill::kL2tpIpsecCaCertPemProperty, UMA_NETWORK_TYPE_IPSEC }, - { flimflam::kProviderProperty, flimflam::kOpenVPNCaCertNSSProperty, + { shill::kProviderProperty, shill::kOpenVPNCaCertNSSProperty, shill::kOpenVPNCaCertPemProperty, UMA_NETWORK_TYPE_OPENVPN }, }; diff --git a/chromeos/network/network_cert_migrator_unittest.cc b/chromeos/network/network_cert_migrator_unittest.cc index ee2dcdf..f1f5fb2 100644 --- a/chromeos/network/network_cert_migrator_unittest.cc +++ b/chromeos/network/network_cert_migrator_unittest.cc @@ -104,12 +104,12 @@ class NetworkCertMigratorTest : public testing::Test { const bool add_to_watchlist = true; service_test_->AddService(kWifiStub, kWifiStub, - flimflam::kTypeWifi, - flimflam::kStateOnline, + shill::kTypeWifi, + shill::kStateOnline, add_to_visible, add_to_watchlist); service_test_->SetServiceProperty(kWifiStub, - flimflam::kEapCaCertNssProperty, + shill::kEapCaCertNssProperty, base::StringValue(kNSSNickname)); } @@ -118,7 +118,7 @@ class NetworkCertMigratorTest : public testing::Test { ca_pem->clear(); const base::DictionaryValue* properties = service_test_->GetServiceProperties(kWifiStub); - properties->GetStringWithoutPathExpansion(flimflam::kEapCaCertNssProperty, + properties->GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty, nss_nickname); const base::ListValue* ca_pems = NULL; properties->GetListWithoutPathExpansion(shill::kEapCaCertPemProperty, @@ -132,16 +132,16 @@ class NetworkCertMigratorTest : public testing::Test { const bool add_to_watchlist = true; service_test_->AddService(kVPNStub, kVPNStub, - flimflam::kTypeVPN, - flimflam::kStateIdle, + shill::kTypeVPN, + shill::kStateIdle, add_to_visible, add_to_watchlist); base::DictionaryValue provider; - const char* nss_property = open_vpn ? flimflam::kOpenVPNCaCertNSSProperty - : flimflam::kL2tpIpsecCaCertNssProperty; + const char* nss_property = open_vpn ? shill::kOpenVPNCaCertNSSProperty + : shill::kL2tpIpsecCaCertNssProperty; provider.SetStringWithoutPathExpansion(nss_property, kNSSNickname); service_test_->SetServiceProperty( - kVPNStub, flimflam::kProviderProperty, provider); + kVPNStub, shill::kProviderProperty, provider); } void GetVpnCACertProperties(bool open_vpn, @@ -152,12 +152,12 @@ class NetworkCertMigratorTest : public testing::Test { const base::DictionaryValue* properties = service_test_->GetServiceProperties(kVPNStub); const base::DictionaryValue* provider = NULL; - properties->GetDictionaryWithoutPathExpansion(flimflam::kProviderProperty, + properties->GetDictionaryWithoutPathExpansion(shill::kProviderProperty, &provider); if (!provider) return; - const char* nss_property = open_vpn ? flimflam::kOpenVPNCaCertNSSProperty - : flimflam::kL2tpIpsecCaCertNssProperty; + const char* nss_property = open_vpn ? shill::kOpenVPNCaCertNSSProperty + : shill::kL2tpIpsecCaCertNssProperty; provider->GetStringWithoutPathExpansion(nss_property, nss_nickname); const base::ListValue* ca_pems = NULL; const char* pem_property = open_vpn ? shill::kOpenVPNCaCertPemProperty diff --git a/chromeos/network/network_change_notifier_chromeos.cc b/chromeos/network/network_change_notifier_chromeos.cc index dd95cf6..d8d3d2c 100644 --- a/chromeos/network/network_change_notifier_chromeos.cc +++ b/chromeos/network/network_change_notifier_chromeos.cc @@ -199,23 +199,23 @@ NetworkChangeNotifierChromeos::ConnectionTypeFromShill( const std::string& type, const std::string& technology) { if (NetworkTypePattern::Ethernet().MatchesType(type)) return CONNECTION_ETHERNET; - else if (type == flimflam::kTypeWifi) + else if (type == shill::kTypeWifi) return CONNECTION_WIFI; - else if (type == flimflam::kTypeWimax) + else if (type == shill::kTypeWimax) return CONNECTION_4G; - if (type != flimflam::kTypeCellular) + if (type != shill::kTypeCellular) return CONNECTION_UNKNOWN; // For cellular types, mapping depends on the technology. - if (technology == flimflam::kNetworkTechnologyEvdo || - technology == flimflam::kNetworkTechnologyGsm || - technology == flimflam::kNetworkTechnologyUmts || - technology == flimflam::kNetworkTechnologyHspa) { + if (technology == shill::kNetworkTechnologyEvdo || + technology == shill::kNetworkTechnologyGsm || + technology == shill::kNetworkTechnologyUmts || + technology == shill::kNetworkTechnologyHspa) { return CONNECTION_3G; - } else if (technology == flimflam::kNetworkTechnologyHspaPlus || - technology == flimflam::kNetworkTechnologyLte || - technology == flimflam::kNetworkTechnologyLteAdvanced) { + } else if (technology == shill::kNetworkTechnologyHspaPlus || + technology == shill::kNetworkTechnologyLte || + technology == shill::kNetworkTechnologyLteAdvanced) { return CONNECTION_4G; } else { return CONNECTION_2G; // Default cellular type is 2G. diff --git a/chromeos/network/network_change_notifier_chromeos_unittest.cc b/chromeos/network/network_change_notifier_chromeos_unittest.cc index f8462d8..90e5162 100644 --- a/chromeos/network/network_change_notifier_chromeos_unittest.cc +++ b/chromeos/network/network_change_notifier_chromeos_unittest.cc @@ -63,32 +63,32 @@ TEST(NetworkChangeNotifierChromeosTest, ConnectionTypeFromShill) { NetworkChangeNotifier::ConnectionType connection_type; }; TypeMapping type_mappings[] = { - { flimflam::kTypeEthernet, "", NetworkChangeNotifier::CONNECTION_ETHERNET }, - { flimflam::kTypeWifi, "", NetworkChangeNotifier::CONNECTION_WIFI }, - { flimflam::kTypeWimax, "", NetworkChangeNotifier::CONNECTION_4G }, + { shill::kTypeEthernet, "", NetworkChangeNotifier::CONNECTION_ETHERNET }, + { shill::kTypeWifi, "", NetworkChangeNotifier::CONNECTION_WIFI }, + { shill::kTypeWimax, "", NetworkChangeNotifier::CONNECTION_4G }, { "unknown type", "unknown technology", NetworkChangeNotifier::CONNECTION_UNKNOWN }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnology1Xrtt, + { shill::kTypeCellular, shill::kNetworkTechnology1Xrtt, NetworkChangeNotifier::CONNECTION_2G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyGprs, + { shill::kTypeCellular, shill::kNetworkTechnologyGprs, NetworkChangeNotifier::CONNECTION_2G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyEdge, + { shill::kTypeCellular, shill::kNetworkTechnologyEdge, NetworkChangeNotifier::CONNECTION_2G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyEvdo, + { shill::kTypeCellular, shill::kNetworkTechnologyEvdo, NetworkChangeNotifier::CONNECTION_3G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyGsm, + { shill::kTypeCellular, shill::kNetworkTechnologyGsm, NetworkChangeNotifier::CONNECTION_3G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyUmts, + { shill::kTypeCellular, shill::kNetworkTechnologyUmts, NetworkChangeNotifier::CONNECTION_3G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyHspa, + { shill::kTypeCellular, shill::kNetworkTechnologyHspa, NetworkChangeNotifier::CONNECTION_3G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyHspaPlus, + { shill::kTypeCellular, shill::kNetworkTechnologyHspaPlus, NetworkChangeNotifier::CONNECTION_4G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyLte, + { shill::kTypeCellular, shill::kNetworkTechnologyLte, NetworkChangeNotifier::CONNECTION_4G }, - { flimflam::kTypeCellular, flimflam::kNetworkTechnologyLteAdvanced, + { shill::kTypeCellular, shill::kNetworkTechnologyLteAdvanced, NetworkChangeNotifier::CONNECTION_4G }, - { flimflam::kTypeCellular, "unknown technology", + { shill::kTypeCellular, "unknown technology", NetworkChangeNotifier::CONNECTION_2G } }; @@ -128,9 +128,9 @@ class NetworkChangeNotifierChromeosUpdateTest : public testing::Test { void SetDefaultNetworkState( const DefaultNetworkState& default_network_state) { if (default_network_state.is_connected) - default_network_.connection_state_ = flimflam::kStateOnline; + default_network_.connection_state_ = shill::kStateOnline; else - default_network_.connection_state_ = flimflam::kStateConfiguration; + default_network_.connection_state_ = shill::kStateConfiguration; default_network_.type_ = default_network_state.type; default_network_.network_technology_ = default_network_state.network_technology; @@ -158,20 +158,20 @@ NotifierUpdateTestCase test_cases[] = { { "Online -> Offline", { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1, kDnsServers1 }, - { false, flimflam::kTypeEthernet, "", kService1, "", "" }, + { false, shill::kTypeEthernet, "", kService1, "", "" }, { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" }, true, true, true }, { "Offline -> Offline", { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" }, - { false, flimflam::kTypeEthernet, "", kService1, kIpAddress1, + { false, shill::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" }, false, false, false }, { "Offline -> Online", { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" }, - { true, flimflam::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 }, + { true, shill::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1, kDnsServers1 }, true, true, true @@ -179,7 +179,7 @@ NotifierUpdateTestCase test_cases[] = { { "Online -> Online (new default service, different connection type)", { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1, kDnsServers1 }, - { true, flimflam::kTypeWifi, "", kService2, kIpAddress1, kDnsServers1 }, + { true, shill::kTypeWifi, "", kService2, kIpAddress1, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1, kDnsServers1 }, true, true, true @@ -187,14 +187,14 @@ NotifierUpdateTestCase test_cases[] = { { "Online -> Online (new default service, same connection type)", { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1, kDnsServers1 }, - { true, flimflam::kTypeWifi, "", kService3, kIpAddress1, kDnsServers1 }, + { true, shill::kTypeWifi, "", kService3, kIpAddress1, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1, kDnsServers1 }, false, true, true }, { "Online -> Online (same default service, first IP address update)", { NetworkChangeNotifier::CONNECTION_WIFI, kService3, "", kDnsServers1 }, - { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 }, + { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2, kDnsServers1 }, false, false, false @@ -202,7 +202,7 @@ NotifierUpdateTestCase test_cases[] = { { "Online -> Online (same default service, new IP address, same DNS)", { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1, kDnsServers1 }, - { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 }, + { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 }, { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2, kDnsServers1 }, false, true, false @@ -210,7 +210,7 @@ NotifierUpdateTestCase test_cases[] = { { "Online -> Online (same default service, same IP address, new DNS)", { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2, kDnsServers1 }, - { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers2 }, + { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers2 }, { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2, kDnsServers2 }, false, false, true diff --git a/chromeos/network/network_configuration_handler.cc b/chromeos/network/network_configuration_handler.cc index 7748623..f464dee 100644 --- a/chromeos/network/network_configuration_handler.cc +++ b/chromeos/network/network_configuration_handler.cc @@ -60,8 +60,7 @@ void GetPropertiesCallback( std::string name = shill_property_util::GetNameFromProperties(service_path, properties); if (!name.empty()) { - properties_copy->SetStringWithoutPathExpansion( - flimflam::kNameProperty, name); + properties_copy->SetStringWithoutPathExpansion(shill::kNameProperty, name); } if (call_status != DBUS_METHOD_CALL_SUCCESS) { // Because network services are added and removed frequently, we will see @@ -92,15 +91,15 @@ void SetNetworkProfileErrorCallback( } bool IsPassphrase(const std::string& key) { - return key == flimflam::kEapPrivateKeyPasswordProperty || - key == flimflam::kEapPasswordProperty || - key == flimflam::kL2tpIpsecPasswordProperty || - key == flimflam::kOpenVPNPasswordProperty || - key == flimflam::kPassphraseProperty || - key == flimflam::kOpenVPNOTPProperty || - key == flimflam::kEapPrivateKeyProperty || - key == flimflam::kEapPinProperty || - key == flimflam::kApnPasswordProperty; + return key == shill::kEapPrivateKeyPasswordProperty || + key == shill::kEapPasswordProperty || + key == shill::kL2tpIpsecPasswordProperty || + key == shill::kOpenVPNPasswordProperty || + key == shill::kPassphraseProperty || + key == shill::kOpenVPNOTPProperty || + key == shill::kEapPrivateKeyProperty || + key == shill::kEapPinProperty || + key == shill::kApnPasswordProperty; } void LogConfigProperties(const std::string& desc, @@ -285,13 +284,13 @@ void NetworkConfigurationHandler::CreateConfiguration( ShillManagerClient* manager = DBusThreadManager::Get()->GetShillManagerClient(); std::string type; - properties.GetStringWithoutPathExpansion(flimflam::kTypeProperty, &type); + properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type); NET_LOG_USER("CreateConfiguration", type); LogConfigProperties("Configure", type, properties); std::string profile; - properties.GetStringWithoutPathExpansion(flimflam::kProfileProperty, + properties.GetStringWithoutPathExpansion(shill::kProfileProperty, &profile); DCHECK(!profile.empty()); manager->ConfigureServiceForProfile( @@ -333,7 +332,7 @@ void NetworkConfigurationHandler::SetNetworkProfile( base::StringValue profile_path_value(profile_path); DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(service_path), - flimflam::kProfileProperty, + shill::kProfileProperty, profile_path_value, callback, base::Bind(&SetNetworkProfileErrorCallback, diff --git a/chromeos/network/network_configuration_handler_unittest.cc b/chromeos/network/network_configuration_handler_unittest.cc index b8b019c..e353543 100644 --- a/chromeos/network/network_configuration_handler_unittest.cc +++ b/chromeos/network/network_configuration_handler_unittest.cc @@ -1,4 +1,4 @@ - // Copyright (c) 2012 The Chromium Authors. All rights reserved. +// 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. @@ -336,9 +336,9 @@ TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) { scoped_ptr<base::StringValue> networkNameValue( base::Value::CreateStringValue(networkName)); base::DictionaryValue value; - value.SetWithoutPathExpansion(flimflam::kSSIDProperty, + value.SetWithoutPathExpansion(shill::kSSIDProperty, base::Value::CreateStringValue(networkName)); - value.SetWithoutPathExpansion(flimflam::kProfileProperty, + value.SetWithoutPathExpansion(shill::kProfileProperty, base::Value::CreateStringValue(profile)); EXPECT_CALL(*mock_manager_client_, @@ -499,9 +499,9 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubSetAndClearProperties) { // Set Properties base::DictionaryValue properties_to_set; properties_to_set.SetStringWithoutPathExpansion( - flimflam::kIdentityProperty, test_identity); + shill::kIdentityProperty, test_identity); properties_to_set.SetStringWithoutPathExpansion( - flimflam::kPassphraseProperty, test_passphrase); + shill::kPassphraseProperty, test_passphrase); network_configuration_handler_->SetProperties( service_path, properties_to_set, @@ -514,17 +514,17 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubSetAndClearProperties) { EXPECT_EQ("SetProperties", success_callback_name_); std::string identity, passphrase; EXPECT_TRUE(GetServiceStringProperty( - service_path, flimflam::kIdentityProperty, &identity)); + service_path, shill::kIdentityProperty, &identity)); EXPECT_TRUE(GetServiceStringProperty( - service_path, flimflam::kPassphraseProperty, &passphrase)); + service_path, shill::kPassphraseProperty, &passphrase)); EXPECT_EQ(test_identity, identity); EXPECT_EQ(test_passphrase, passphrase); EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(service_path)); // Clear Properties std::vector<std::string> properties_to_clear; - properties_to_clear.push_back(flimflam::kIdentityProperty); - properties_to_clear.push_back(flimflam::kPassphraseProperty); + properties_to_clear.push_back(shill::kIdentityProperty); + properties_to_clear.push_back(shill::kPassphraseProperty); network_configuration_handler_->ClearProperties( service_path, properties_to_clear, @@ -536,9 +536,9 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubSetAndClearProperties) { EXPECT_EQ("ClearProperties", success_callback_name_); EXPECT_FALSE(GetServiceStringProperty( - service_path, flimflam::kIdentityProperty, &identity)); + service_path, shill::kIdentityProperty, &identity)); EXPECT_FALSE(GetServiceStringProperty( - service_path, flimflam::kIdentityProperty, &passphrase)); + service_path, shill::kIdentityProperty, &passphrase)); EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(service_path)); } @@ -551,7 +551,7 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) { // Set Properties base::DictionaryValue properties_to_set; properties_to_set.SetStringWithoutPathExpansion( - flimflam::kWifiHexSsid, wifi_hex); + shill::kWifiHexSsid, wifi_hex); network_configuration_handler_->SetProperties( service_path, properties_to_set, @@ -560,7 +560,7 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) { message_loop_.RunUntilIdle(); std::string wifi_hex_result; EXPECT_TRUE(GetServiceStringProperty( - service_path, flimflam::kWifiHexSsid, &wifi_hex_result)); + service_path, shill::kWifiHexSsid, &wifi_hex_result)); EXPECT_EQ(wifi_hex, wifi_hex_result); // Get Properties @@ -574,25 +574,22 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) { EXPECT_EQ(service_path, get_properties_path_); std::string name_result; EXPECT_TRUE(GetReceivedStringProperty( - service_path, flimflam::kNameProperty, &name_result)); + service_path, shill::kNameProperty, &name_result)); EXPECT_EQ(expected_name, name_result); } TEST_F(NetworkConfigurationHandlerStubTest, StubCreateConfiguration) { const std::string service_path("test_wifi"); base::DictionaryValue properties; + properties.SetStringWithoutPathExpansion(shill::kSSIDProperty, service_path); + properties.SetStringWithoutPathExpansion(shill::kNameProperty, service_path); + properties.SetStringWithoutPathExpansion(shill::kGuidProperty, service_path); properties.SetStringWithoutPathExpansion( - flimflam::kSSIDProperty, service_path); + shill::kTypeProperty, shill::kTypeWifi); properties.SetStringWithoutPathExpansion( - flimflam::kNameProperty, service_path); + shill::kStateProperty, shill::kStateIdle); properties.SetStringWithoutPathExpansion( - flimflam::kGuidProperty, service_path); - properties.SetStringWithoutPathExpansion( - flimflam::kTypeProperty, flimflam::kTypeWifi); - properties.SetStringWithoutPathExpansion( - flimflam::kStateProperty, flimflam::kStateIdle); - properties.SetStringWithoutPathExpansion( - flimflam::kProfileProperty, shill_stub_helper::kSharedProfilePath); + shill::kProfileProperty, shill_stub_helper::kSharedProfilePath); network_configuration_handler_->CreateConfiguration( properties, @@ -606,12 +603,12 @@ TEST_F(NetworkConfigurationHandlerStubTest, StubCreateConfiguration) { std::string ssid; EXPECT_TRUE(GetServiceStringProperty( - create_service_path_, flimflam::kSSIDProperty, &ssid)); + create_service_path_, shill::kSSIDProperty, &ssid)); std::string actual_profile; EXPECT_EQ(service_path, ssid); EXPECT_TRUE(GetServiceStringProperty( - create_service_path_, flimflam::kProfileProperty, &actual_profile)); + create_service_path_, shill::kProfileProperty, &actual_profile)); EXPECT_EQ(shill_stub_helper::kSharedProfilePath, actual_profile); } diff --git a/chromeos/network/network_connection_handler.cc b/chromeos/network/network_connection_handler.cc index 00776aa..e6889f0 100644 --- a/chromeos/network/network_connection_handler.cc +++ b/chromeos/network/network_connection_handler.cc @@ -40,8 +40,8 @@ void InvokeErrorCallback(const std::string& service_path, } bool IsAuthenticationError(const std::string& error) { - return (error == flimflam::kErrorBadWEPKey || - error == flimflam::kErrorPppAuthFailed || + return (error == shill::kErrorBadWEPKey || + error == shill::kErrorPppAuthFailed || error == shill::kErrorEapLocalTlsFailed || error == shill::kErrorEapRemoteTlsFailed || error == shill::kErrorEapAuthenticationFailed); @@ -50,24 +50,24 @@ bool IsAuthenticationError(const std::string& error) { bool VPNIsConfigured(const std::string& service_path, const std::string& provider_type, const base::DictionaryValue& provider_properties) { - if (provider_type == flimflam::kProviderOpenVpn) { + if (provider_type == shill::kProviderOpenVpn) { std::string hostname; provider_properties.GetStringWithoutPathExpansion( - flimflam::kHostProperty, &hostname); + shill::kHostProperty, &hostname); if (hostname.empty()) { NET_LOG_EVENT("OpenVPN: No hostname", service_path); return false; } std::string username; provider_properties.GetStringWithoutPathExpansion( - flimflam::kOpenVPNUserProperty, &username); + shill::kOpenVPNUserProperty, &username); if (username.empty()) { NET_LOG_EVENT("OpenVPN: No username", service_path); return false; } bool passphrase_required = false; provider_properties.GetBooleanWithoutPathExpansion( - flimflam::kPassphraseRequiredProperty, &passphrase_required); + shill::kPassphraseRequiredProperty, &passphrase_required); if (passphrase_required) { NET_LOG_EVENT("OpenVPN: Passphrase Required", service_path); return false; @@ -77,7 +77,7 @@ bool VPNIsConfigured(const std::string& service_path, bool passphrase_required = false; std::string passphrase; provider_properties.GetBooleanWithoutPathExpansion( - flimflam::kL2tpIpsecPskRequiredProperty, &passphrase_required); + shill::kL2tpIpsecPskRequiredProperty, &passphrase_required); if (passphrase_required) { NET_LOG_EVENT("VPN: PSK Required", service_path); return false; @@ -232,7 +232,7 @@ void NetworkConnectionHandler::ConnectToNetwork( if (check_error_state) { const std::string& error = network->error(); - if (error == flimflam::kErrorBadPassphrase) { + if (error == shill::kErrorBadPassphrase) { InvokeErrorCallback(service_path, error_callback, error); return; } @@ -251,8 +251,7 @@ void NetworkConnectionHandler::ConnectToNetwork( // Connect immediately to 'connectable' networks. // TODO(stevenjb): Shill needs to properly set Connectable for VPN. - if (network && - network->connectable() && network->type() != flimflam::kTypeVPN) { + if (network && network->connectable() && network->type() != shill::kTypeVPN) { CallShillConnect(service_path); return; } @@ -324,24 +323,23 @@ void NetworkConnectionHandler::VerifyConfiguredAndConnect( // has not been set to a minimum length value. bool passphrase_required = false; service_properties.GetBooleanWithoutPathExpansion( - flimflam::kPassphraseRequiredProperty, &passphrase_required); + shill::kPassphraseRequiredProperty, &passphrase_required); if (passphrase_required) { ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired); return; } std::string type, security; + service_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type); service_properties.GetStringWithoutPathExpansion( - flimflam::kTypeProperty, &type); - service_properties.GetStringWithoutPathExpansion( - flimflam::kSecurityProperty, &security); + shill::kSecurityProperty, &security); bool connectable = false; service_properties.GetBooleanWithoutPathExpansion( - flimflam::kConnectableProperty, &connectable); + shill::kConnectableProperty, &connectable); // In case NetworkState was not available in ConnectToNetwork (e.g. it had // been recently configured), we need to check Connectable again. - if (connectable && type != flimflam::kTypeVPN) { + if (connectable && type != shill::kTypeVPN) { // TODO(stevenjb): Shill needs to properly set Connectable for VPN. CallShillConnect(service_path); return; @@ -350,16 +348,16 @@ void NetworkConnectionHandler::VerifyConfiguredAndConnect( // Get VPN provider type and host (required for configuration) and ensure // that required VPN non-cert properties are set. std::string vpn_provider_type, vpn_provider_host; - if (type == flimflam::kTypeVPN) { + if (type == shill::kTypeVPN) { // VPN Provider values are read from the "Provider" dictionary, not the // "Provider.Type", etc keys (which are used only to set the values). const base::DictionaryValue* provider_properties; if (service_properties.GetDictionaryWithoutPathExpansion( - flimflam::kProviderProperty, &provider_properties)) { + shill::kProviderProperty, &provider_properties)) { provider_properties->GetStringWithoutPathExpansion( - flimflam::kTypeProperty, &vpn_provider_type); + shill::kTypeProperty, &vpn_provider_type); provider_properties->GetStringWithoutPathExpansion( - flimflam::kHostProperty, &vpn_provider_host); + shill::kHostProperty, &vpn_provider_host); } if (vpn_provider_type.empty() || vpn_provider_host.empty()) { ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired); @@ -375,13 +373,12 @@ void NetworkConnectionHandler::VerifyConfiguredAndConnect( } client_cert::ConfigType client_cert_type = client_cert::CONFIG_TYPE_NONE; - if (type == flimflam::kTypeVPN) { - if (vpn_provider_type == flimflam::kProviderOpenVpn) + if (type == shill::kTypeVPN) { + if (vpn_provider_type == shill::kProviderOpenVpn) client_cert_type = client_cert::CONFIG_TYPE_OPENVPN; else client_cert_type = client_cert::CONFIG_TYPE_IPSEC; - } else if (type == flimflam::kTypeWifi && - security == flimflam::kSecurity8021x) { + } else if (type == shill::kTypeWifi && security == shill::kSecurity8021x) { client_cert_type = client_cert::CONFIG_TYPE_EAP; } @@ -525,7 +522,7 @@ void NetworkConnectionHandler::HandleShillConnectFailure( network_handler::ErrorCallback error_callback = request->error_callback; pending_requests_.erase(service_path); network_handler::ShillErrorCallbackFunction( - flimflam::kErrorConnectFailed, service_path, error_callback, + shill::kErrorConnectFailed, service_path, error_callback, dbus_error_name, dbus_error_message); } @@ -551,7 +548,7 @@ void NetworkConnectionHandler::CheckPendingRequest( pending_requests_.erase(service_path); return; } - if (network->connection_state() == flimflam::kStateIdle && + if (network->connection_state() == shill::kStateIdle && request->connect_state != ConnectRequest::CONNECT_CONNECTING) { // Connection hasn't started yet, keep waiting. return; @@ -559,17 +556,17 @@ void NetworkConnectionHandler::CheckPendingRequest( // Network is neither connecting or connected; an error occurred. std::string error_name, error_detail; - if (network->connection_state() == flimflam::kStateIdle && + if (network->connection_state() == shill::kStateIdle && pending_requests_.size() > 1) { // Another connect request canceled this one. error_name = kErrorConnectCanceled; error_detail = ""; } else { - error_name = flimflam::kErrorConnectFailed; + error_name = shill::kErrorConnectFailed; error_detail = network->error(); if (error_detail.empty()) { - if (network->connection_state() == flimflam::kStateFailure) - error_detail = flimflam::kUnknownString; + if (network->connection_state() == shill::kStateFailure) + error_detail = shill::kUnknownString; else error_detail = "Unexpected State: " + network->connection_state(); } diff --git a/chromeos/network/network_connection_handler.h b/chromeos/network/network_connection_handler.h index d67a41c..2bc40c4 100644 --- a/chromeos/network/network_connection_handler.h +++ b/chromeos/network/network_connection_handler.h @@ -91,8 +91,8 @@ class CHROMEOS_EXPORT NetworkConnectionHandler // ConnectToNetwork() will start an asynchronous connection attempt. // On success, |success_callback| will be called. // On failure, |error_callback| will be called with |error_name| one of the - // constants defined above, or flimflam::kErrorConnectFailed or - // flimflam::kErrorBadPassphrase if the Shill Error property (from a + // constants defined above, or shill::kErrorConnectFailed or + // shill::kErrorBadPassphrase if the Shill Error property (from a // previous connect attempt) was set to one of those. // |error_message| will contain an additional error string for debugging. // If |check_error_state| is true, the current state of the network is diff --git a/chromeos/network/network_connection_handler_unittest.cc b/chromeos/network/network_connection_handler_unittest.cc index 68c3a9b..0e991ef 100644 --- a/chromeos/network/network_connection_handler_unittest.cc +++ b/chromeos/network/network_connection_handler_unittest.cc @@ -160,8 +160,8 @@ TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectSuccess) { EXPECT_TRUE(Configure(kConfigConnectable)); Connect("wifi0"); EXPECT_EQ(kSuccessResult, GetResultAndReset()); - EXPECT_EQ(flimflam::kStateOnline, - GetServiceStringProperty("wifi0", flimflam::kStateProperty)); + EXPECT_EQ(shill::kStateOnline, + GetServiceStringProperty("wifi0", shill::kStateProperty)); } // Handles basic failure cases. diff --git a/chromeos/network/network_device_handler.cc b/chromeos/network/network_device_handler.cc index c480073..ab456eb 100644 --- a/chromeos/network/network_device_handler.cc +++ b/chromeos/network/network_device_handler.cc @@ -33,11 +33,11 @@ std::string GetErrorNameForShillError(const std::string& shill_error_name) { return NetworkDeviceHandler::kErrorFailure; if (shill_error_name == kShillErrorNotSupported) return NetworkDeviceHandler::kErrorNotSupported; - if (shill_error_name == flimflam::kErrorIncorrectPinMsg) + if (shill_error_name == shill::kErrorIncorrectPinMsg) return NetworkDeviceHandler::kErrorIncorrectPin; - if (shill_error_name == flimflam::kErrorPinBlockedMsg) + if (shill_error_name == shill::kErrorPinBlockedMsg) return NetworkDeviceHandler::kErrorPinBlocked; - if (shill_error_name == flimflam::kErrorPinRequiredMsg) + if (shill_error_name == shill::kErrorPinRequiredMsg) return NetworkDeviceHandler::kErrorPinRequired; return NetworkDeviceHandler::kErrorUnknown; } @@ -73,13 +73,13 @@ void RefreshIPConfigsCallback( const base::DictionaryValue& properties) { const ListValue* ip_configs; if (!properties.GetListWithoutPathExpansion( - flimflam::kIPConfigsProperty, &ip_configs)) { + shill::kIPConfigsProperty, &ip_configs)) { NET_LOG_ERROR("RequestRefreshIPConfigs Failed", device_path); network_handler::ShillErrorCallbackFunction( "RequestRefreshIPConfigs Failed", device_path, error_callback, - std::string("Missing ") + flimflam::kIPConfigsProperty, ""); + std::string("Missing ") + shill::kIPConfigsProperty, ""); return; } diff --git a/chromeos/network/network_device_handler_unittest.cc b/chromeos/network/network_device_handler_unittest.cc index ff58e6b..dd9667a 100644 --- a/chromeos/network/network_device_handler_unittest.cc +++ b/chromeos/network/network_device_handler_unittest.cc @@ -44,20 +44,19 @@ class NetworkDeviceHandlerTest : public testing::Test { DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface(); device_test->ClearDevices(); device_test->AddDevice( - kDefaultCellularDevicePath, flimflam::kTypeCellular, "cellular1"); - device_test->AddDevice( - kDefaultWifiDevicePath, flimflam::kTypeWifi, "wifi1"); + kDefaultCellularDevicePath, shill::kTypeCellular, "cellular1"); + device_test->AddDevice(kDefaultWifiDevicePath, shill::kTypeWifi, "wifi1"); base::FundamentalValue allow_roaming(false); device_test->SetDeviceProperty( kDefaultCellularDevicePath, - flimflam::kCellularAllowRoamingProperty, + shill::kCellularAllowRoamingProperty, allow_roaming); base::ListValue test_ip_configs; test_ip_configs.AppendString("ip_config1"); device_test->SetDeviceProperty( - kDefaultWifiDevicePath, flimflam::kIPConfigsProperty, test_ip_configs); + kDefaultWifiDevicePath, shill::kIPConfigsProperty, test_ip_configs); } virtual void TearDown() OVERRIDE { @@ -170,8 +169,8 @@ TEST_F(NetworkDeviceHandlerTest, GetDeviceProperties) { message_loop_.RunUntilIdle(); EXPECT_EQ(kResultSuccess, result_); std::string type; - properties_->GetString(flimflam::kTypeProperty, &type); - EXPECT_EQ(flimflam::kTypeWifi, type); + properties_->GetString(shill::kTypeProperty, &type); + EXPECT_EQ(shill::kTypeWifi, type); } TEST_F(NetworkDeviceHandlerTest, SetDeviceProperty) { @@ -184,15 +183,15 @@ TEST_F(NetworkDeviceHandlerTest, SetDeviceProperty) { EXPECT_EQ(kResultSuccess, result_); bool allow_roaming; EXPECT_TRUE(properties_->GetBooleanWithoutPathExpansion( - flimflam::kCellularAllowRoamingProperty, &allow_roaming)); + shill::kCellularAllowRoamingProperty, &allow_roaming)); EXPECT_FALSE(allow_roaming); - // Set the flimflam::kCellularAllowRoamingProperty to true. The call + // Set the shill::kCellularAllowRoamingProperty to true. The call // should succeed and the value should be set. base::FundamentalValue allow_roaming_value(true); network_device_handler_->SetDeviceProperty( kDefaultCellularDevicePath, - flimflam::kCellularAllowRoamingProperty, + shill::kCellularAllowRoamingProperty, allow_roaming_value, success_callback_, error_callback_); @@ -207,13 +206,13 @@ TEST_F(NetworkDeviceHandlerTest, SetDeviceProperty) { message_loop_.RunUntilIdle(); EXPECT_EQ(kResultSuccess, result_); EXPECT_TRUE(properties_->GetBooleanWithoutPathExpansion( - flimflam::kCellularAllowRoamingProperty, &allow_roaming)); + shill::kCellularAllowRoamingProperty, &allow_roaming)); EXPECT_TRUE(allow_roaming); // Set property on an invalid path. network_device_handler_->SetDeviceProperty( "/device/invalid_path", - flimflam::kCellularAllowRoamingProperty, + shill::kCellularAllowRoamingProperty, allow_roaming_value, success_callback_, error_callback_); diff --git a/chromeos/network/network_profile_handler.cc b/chromeos/network/network_profile_handler.cc index 26b1bef..19a47b6 100644 --- a/chromeos/network/network_profile_handler.cc +++ b/chromeos/network/network_profile_handler.cc @@ -75,18 +75,18 @@ void NetworkProfileHandler::GetManagerPropertiesCallback( } const base::Value* profiles = NULL; - properties.GetWithoutPathExpansion(flimflam::kProfilesProperty, &profiles); + properties.GetWithoutPathExpansion(shill::kProfilesProperty, &profiles); if (!profiles) { LOG(ERROR) << "Manager properties returned from Shill don't contain " - << "the field " << flimflam::kProfilesProperty; + << "the field " << shill::kProfilesProperty; return; } - OnPropertyChanged(flimflam::kProfilesProperty, *profiles); + OnPropertyChanged(shill::kProfilesProperty, *profiles); } void NetworkProfileHandler::OnPropertyChanged(const std::string& name, const base::Value& value) { - if (name != flimflam::kProfilesProperty) + if (name != shill::kProfilesProperty) return; const base::ListValue* profiles_value = NULL; @@ -141,8 +141,7 @@ void NetworkProfileHandler::GetProfilePropertiesCallback( const std::string& profile_path, const base::DictionaryValue& properties) { std::string userhash; - properties.GetStringWithoutPathExpansion(shill::kUserHashProperty, - &userhash); + properties.GetStringWithoutPathExpansion(shill::kUserHashProperty, &userhash); AddProfile(NetworkProfile(profile_path, userhash)); } diff --git a/chromeos/network/network_sms_handler.cc b/chromeos/network/network_sms_handler.cc index 986317d..ecbafe9 100644 --- a/chromeos/network/network_sms_handler.cc +++ b/chromeos/network/network_sms_handler.cc @@ -378,7 +378,7 @@ void NetworkSmsHandler::RemoveObserver(Observer* observer) { void NetworkSmsHandler::OnPropertyChanged(const std::string& name, const base::Value& value) { - if (name != flimflam::kDevicesProperty) + if (name != shill::kDevicesProperty) return; const base::ListValue* devices = NULL; if (!value.GetAsList(&devices) || !devices) @@ -414,10 +414,10 @@ void NetworkSmsHandler::ManagerPropertiesCallback( return; } const base::Value* value; - if (!properties.GetWithoutPathExpansion(flimflam::kDevicesProperty, &value) || + if (!properties.GetWithoutPathExpansion(shill::kDevicesProperty, &value) || value->GetType() != base::Value::TYPE_LIST) { LOG(ERROR) << "NetworkSmsHandler: No list value for: " - << flimflam::kDevicesProperty; + << shill::kDevicesProperty; return; } const base::ListValue* devices = static_cast<const base::ListValue*>(value); @@ -453,23 +453,23 @@ void NetworkSmsHandler::DevicePropertiesCallback( std::string device_type; if (!properties.GetStringWithoutPathExpansion( - flimflam::kTypeProperty, &device_type)) { + shill::kTypeProperty, &device_type)) { LOG(ERROR) << "NetworkSmsHandler: No type for: " << device_path; return; } - if (device_type != flimflam::kTypeCellular) + if (device_type != shill::kTypeCellular) return; std::string dbus_connection; if (!properties.GetStringWithoutPathExpansion( - flimflam::kDBusConnectionProperty, &dbus_connection)) { + shill::kDBusConnectionProperty, &dbus_connection)) { LOG(ERROR) << "Device has no DBusConnection Property: " << device_path; return; } std::string object_path_string; if (!properties.GetStringWithoutPathExpansion( - flimflam::kDBusObjectProperty, &object_path_string)) { + shill::kDBusObjectProperty, &object_path_string)) { LOG(ERROR) << "Device has no DBusObject Property: " << device_path; return; } diff --git a/chromeos/network/network_sms_handler_unittest.cc b/chromeos/network/network_sms_handler_unittest.cc index c7eaac2..c3d434b 100644 --- a/chromeos/network/network_sms_handler_unittest.cc +++ b/chromeos/network/network_sms_handler_unittest.cc @@ -69,7 +69,7 @@ class NetworkSmsHandlerTest : public testing::Test { ShillDeviceClient::TestInterface* device_test = DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface(); ASSERT_TRUE(device_test); - device_test->AddDevice("stub_cellular_device2", flimflam::kTypeCellular, + device_test->AddDevice("stub_cellular_device2", shill::kTypeCellular, "/org/freedesktop/ModemManager1/stub/0"); // This relies on the stub dbus implementations for ShillManagerClient, diff --git a/chromeos/network/network_state.cc b/chromeos/network/network_state.cc index 24d194a..3a0a1fb 100644 --- a/chromeos/network/network_state.cc +++ b/chromeos/network/network_state.cc @@ -29,24 +29,24 @@ bool ConvertListValueToStringVector(const base::ListValue& string_list, bool IsCaCertNssSet(const base::DictionaryValue& properties) { std::string ca_cert_nss; - if (properties.GetStringWithoutPathExpansion(flimflam::kEapCaCertNssProperty, + if (properties.GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty, &ca_cert_nss) && !ca_cert_nss.empty()) { return true; } const base::DictionaryValue* provider = NULL; - properties.GetDictionaryWithoutPathExpansion(flimflam::kProviderProperty, + properties.GetDictionaryWithoutPathExpansion(shill::kProviderProperty, &provider); if (!provider) return false; if (provider->GetStringWithoutPathExpansion( - flimflam::kL2tpIpsecCaCertNssProperty, &ca_cert_nss) && + shill::kL2tpIpsecCaCertNssProperty, &ca_cert_nss) && !ca_cert_nss.empty()) { return true; } if (provider->GetStringWithoutPathExpansion( - flimflam::kOpenVPNCaCertNSSProperty, &ca_cert_nss) && + shill::kOpenVPNCaCertNSSProperty, &ca_cert_nss) && !ca_cert_nss.empty()) { return true; } @@ -76,31 +76,31 @@ bool NetworkState::PropertyChanged(const std::string& key, // Keep care that these properties are the same as in |GetProperties|. if (ManagedStatePropertyChanged(key, value)) return true; - if (key == flimflam::kSignalStrengthProperty) { + if (key == shill::kSignalStrengthProperty) { return GetIntegerValue(key, value, &signal_strength_); - } else if (key == flimflam::kStateProperty) { + } else if (key == shill::kStateProperty) { return GetStringValue(key, value, &connection_state_); - } else if (key == flimflam::kConnectableProperty) { + } else if (key == shill::kConnectableProperty) { return GetBooleanValue(key, value, &connectable_); - } else if (key == flimflam::kErrorProperty) { + } else if (key == shill::kErrorProperty) { if (!GetStringValue(key, value, &error_)) return false; // Shill uses "Unknown" to indicate an unset error state. if (error_ == kErrorUnknown) error_.clear(); return true; - } else if (key == IPConfigProperty(flimflam::kAddressProperty)) { + } else if (key == IPConfigProperty(shill::kAddressProperty)) { return GetStringValue(key, value, &ip_address_); - } else if (key == IPConfigProperty(flimflam::kGatewayProperty)) { + } else if (key == IPConfigProperty(shill::kGatewayProperty)) { return GetStringValue(key, value, &gateway_); - } else if (key == IPConfigProperty(flimflam::kNameServersProperty)) { + } else if (key == IPConfigProperty(shill::kNameServersProperty)) { const base::ListValue* dns_servers; if (!value.GetAsList(&dns_servers)) return false; dns_servers_.clear(); ConvertListValueToStringVector(*dns_servers, &dns_servers_); return true; - } else if (key == IPConfigProperty(flimflam::kPrefixlenProperty)) { + } else if (key == IPConfigProperty(shill::kPrefixlenProperty)) { return GetIntegerValue(key, value, &prefix_length_); } else if (key == IPConfigProperty( shill::kWebProxyAutoDiscoveryUrlProperty)) { @@ -120,13 +120,13 @@ bool NetworkState::PropertyChanged(const std::string& key, } } return true; - } else if (key == flimflam::kActivationStateProperty) { + } else if (key == shill::kActivationStateProperty) { return GetStringValue(key, value, &activation_state_); - } else if (key == flimflam::kRoamingStateProperty) { + } else if (key == shill::kRoamingStateProperty) { return GetStringValue(key, value, &roaming_); - } else if (key == flimflam::kSecurityProperty) { + } else if (key == shill::kSecurityProperty) { return GetStringValue(key, value, &security_); - } else if (key == flimflam::kProxyConfigProperty) { + } else if (key == shill::kProxyConfigProperty) { std::string proxy_config_str; if (!value.GetAsString(&proxy_config_str)) { NET_LOG_ERROR("Failed to parse " + key, path()); @@ -149,7 +149,7 @@ bool NetworkState::PropertyChanged(const std::string& key, NET_LOG_ERROR("Failed to parse " + key, path()); } return true; - } else if (key == flimflam::kUIDataProperty) { + } else if (key == shill::kUIDataProperty) { scoped_ptr<NetworkUIData> new_ui_data = shill_property_util::GetUIDataFromValue(value); if (!new_ui_data) { @@ -158,13 +158,13 @@ bool NetworkState::PropertyChanged(const std::string& key, } ui_data_ = *new_ui_data; return true; - } else if (key == flimflam::kNetworkTechnologyProperty) { + } else if (key == shill::kNetworkTechnologyProperty) { return GetStringValue(key, value, &network_technology_); - } else if (key == flimflam::kDeviceProperty) { + } else if (key == shill::kDeviceProperty) { return GetStringValue(key, value, &device_path_); - } else if (key == flimflam::kGuidProperty) { + } else if (key == shill::kGuidProperty) { return GetStringValue(key, value, &guid_); - } else if (key == flimflam::kProfileProperty) { + } else if (key == shill::kProfileProperty) { return GetStringValue(key, value, &profile_path_); } else if (key == shill::kActivateOverNonCellularNetworkProperty) { return GetBooleanValue(key, value, &activate_over_non_cellular_networks_); @@ -186,27 +186,26 @@ bool NetworkState::InitialPropertiesReceived( void NetworkState::GetProperties(base::DictionaryValue* dictionary) const { // Keep care that these properties are the same as in |PropertyChanged|. - dictionary->SetStringWithoutPathExpansion(flimflam::kNameProperty, name()); - dictionary->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type()); - dictionary->SetIntegerWithoutPathExpansion(flimflam::kSignalStrengthProperty, + dictionary->SetStringWithoutPathExpansion(shill::kNameProperty, name()); + dictionary->SetStringWithoutPathExpansion(shill::kTypeProperty, type()); + dictionary->SetIntegerWithoutPathExpansion(shill::kSignalStrengthProperty, signal_strength_); - dictionary->SetStringWithoutPathExpansion(flimflam::kStateProperty, + dictionary->SetStringWithoutPathExpansion(shill::kStateProperty, connection_state_); - dictionary->SetBooleanWithoutPathExpansion(flimflam::kConnectableProperty, + dictionary->SetBooleanWithoutPathExpansion(shill::kConnectableProperty, connectable_); - dictionary->SetStringWithoutPathExpansion(flimflam::kErrorProperty, - error_); + dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error_); // IPConfig properties base::DictionaryValue* ipconfig_properties = new base::DictionaryValue; - ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kAddressProperty, + ipconfig_properties->SetStringWithoutPathExpansion(shill::kAddressProperty, ip_address_); - ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kGatewayProperty, + ipconfig_properties->SetStringWithoutPathExpansion(shill::kGatewayProperty, gateway_); base::ListValue* name_servers = new base::ListValue; name_servers->AppendStrings(dns_servers_); - ipconfig_properties->SetWithoutPathExpansion(flimflam::kNameServersProperty, + ipconfig_properties->SetWithoutPathExpansion(shill::kNameServersProperty, name_servers); ipconfig_properties->SetStringWithoutPathExpansion( shill::kWebProxyAutoDiscoveryUrlProperty, @@ -214,11 +213,11 @@ void NetworkState::GetProperties(base::DictionaryValue* dictionary) const { dictionary->SetWithoutPathExpansion(shill::kIPConfigProperty, ipconfig_properties); - dictionary->SetStringWithoutPathExpansion(flimflam::kActivationStateProperty, + dictionary->SetStringWithoutPathExpansion(shill::kActivationStateProperty, activation_state_); - dictionary->SetStringWithoutPathExpansion(flimflam::kRoamingStateProperty, + dictionary->SetStringWithoutPathExpansion(shill::kRoamingStateProperty, roaming_); - dictionary->SetStringWithoutPathExpansion(flimflam::kSecurityProperty, + dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty, security_); // Proxy config and ONC source are intentionally omitted: These properties are // placed in NetworkState to transition ProxyConfigServiceImpl from @@ -226,12 +225,12 @@ void NetworkState::GetProperties(base::DictionaryValue* dictionary) const { // shouldn't depend on this member. Once ManagedNetworkConfigurationHandler // is used instead of NetworkLibrary, we can remove them again. dictionary->SetStringWithoutPathExpansion( - flimflam::kNetworkTechnologyProperty, + shill::kNetworkTechnologyProperty, network_technology_); - dictionary->SetStringWithoutPathExpansion(flimflam::kDeviceProperty, + dictionary->SetStringWithoutPathExpansion(shill::kDeviceProperty, device_path_); - dictionary->SetStringWithoutPathExpansion(flimflam::kGuidProperty, guid_); - dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty, + dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid_); + dictionary->SetStringWithoutPathExpansion(shill::kProfileProperty, profile_path_); dictionary->SetBooleanWithoutPathExpansion( shill::kActivateOverNonCellularNetworkProperty, @@ -241,9 +240,9 @@ void NetworkState::GetProperties(base::DictionaryValue* dictionary) const { } bool NetworkState::RequiresActivation() const { - return (type() == flimflam::kTypeCellular && - activation_state() != flimflam::kActivationStateActivated && - activation_state() != flimflam::kActivationStateUnknown); + return (type() == shill::kTypeCellular && + activation_state() != shill::kActivationStateActivated && + activation_state() != shill::kActivationStateUnknown); } bool NetworkState::IsConnectedState() const { @@ -290,16 +289,16 @@ bool NetworkState::UpdateName(const base::DictionaryValue& properties) { // static bool NetworkState::StateIsConnected(const std::string& connection_state) { - return (connection_state == flimflam::kStateReady || - connection_state == flimflam::kStateOnline || - connection_state == flimflam::kStatePortal); + return (connection_state == shill::kStateReady || + connection_state == shill::kStateOnline || + connection_state == shill::kStatePortal); } // static bool NetworkState::StateIsConnecting(const std::string& connection_state) { - return (connection_state == flimflam::kStateAssociation || - connection_state == flimflam::kStateConfiguration || - connection_state == flimflam::kStateCarrier); + return (connection_state == shill::kStateAssociation || + connection_state == shill::kStateConfiguration || + connection_state == shill::kStateCarrier); } // static diff --git a/chromeos/network/network_state_handler.cc b/chromeos/network/network_state_handler.cc index c8516d6..64b96a9 100644 --- a/chromeos/network/network_state_handler.cc +++ b/chromeos/network/network_state_handler.cc @@ -29,7 +29,7 @@ namespace { bool ConnectionStateChanged(NetworkState* network, const std::string& prev_connection_state) { return (network->connection_state() != prev_connection_state) && - (network->connection_state() != flimflam::kStateIdle || + (network->connection_state() != shill::kStateIdle || !prev_connection_state.empty()); } @@ -330,7 +330,7 @@ void NetworkStateHandler::WaitForScan(const std::string& type, void NetworkStateHandler::ConnectToBestWifiNetwork() { NET_LOG_USER("ConnectToBestWifiNetwork", ""); - WaitForScan(flimflam::kTypeWifi, + WaitForScan(shill::kTypeWifi, base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices, shill_property_handler_->AsWeakPtr())); } @@ -507,7 +507,7 @@ void NetworkStateHandler::UpdateNetworkServiceProperty( if (!network->PropertyChanged(key, value)) return; - if (key == flimflam::kStateProperty) { + if (key == shill::kStateProperty) { if (ConnectionStateChanged(network, prev_connection_state)) { OnNetworkConnectionStateChanged(network); // If the connection state changes, other properties such as IPConfig @@ -516,7 +516,7 @@ void NetworkStateHandler::UpdateNetworkServiceProperty( } } else { bool noisy_property = - key == flimflam::kSignalStrengthProperty || + key == shill::kSignalStrengthProperty || key == shill::kWifiFrequencyListProperty; if (network->path() == default_network_path_ && !noisy_property) { // Wifi SignalStrength and WifiFrequencyList updates are too noisy, so @@ -532,8 +532,7 @@ void NetworkStateHandler::UpdateNetworkServiceProperty( std::string detail = network->name() + "." + key; detail += " = " + network_event_log::ValueAsString(value); network_event_log::LogLevel log_level; - if (key == flimflam::kErrorProperty || - key == shill::kErrorDetailsProperty) { + if (key == shill::kErrorProperty || key == shill::kErrorDetailsProperty) { log_level = network_event_log::LOG_LEVEL_ERROR; } else { log_level = network_event_log::LOG_LEVEL_EVENT; @@ -559,7 +558,7 @@ void NetworkStateHandler::UpdateDeviceProperty(const std::string& device_path, NotifyDeviceListChanged(); - if (key == flimflam::kScanningProperty && device->scanning() == false) + if (key == shill::kScanningProperty && device->scanning() == false) ScanCompleted(device->type()); } @@ -720,23 +719,23 @@ void NetworkStateHandler::ScanCompleted(const std::string& type) { std::string NetworkStateHandler::GetTechnologyForType( const NetworkTypePattern& type) const { - if (type.MatchesType(flimflam::kTypeEthernet)) - return flimflam::kTypeEthernet; + if (type.MatchesType(shill::kTypeEthernet)) + return shill::kTypeEthernet; - if (type.MatchesType(flimflam::kTypeWifi)) - return flimflam::kTypeWifi; + if (type.MatchesType(shill::kTypeWifi)) + return shill::kTypeWifi; if (type.Equals(NetworkTypePattern::Wimax())) - return flimflam::kTypeWimax; + return shill::kTypeWimax; // Prefer Wimax over Cellular only if it's available. - if (type.MatchesType(flimflam::kTypeWimax) && - shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax)) { - return flimflam::kTypeWimax; + if (type.MatchesType(shill::kTypeWimax) && + shill_property_handler_->IsTechnologyAvailable(shill::kTypeWimax)) { + return shill::kTypeWimax; } - if (type.MatchesType(flimflam::kTypeCellular)) - return flimflam::kTypeCellular; + if (type.MatchesType(shill::kTypeCellular)) + return shill::kTypeCellular; NOTREACHED(); return std::string(); diff --git a/chromeos/network/network_state_handler.h b/chromeos/network/network_state_handler.h index 14c12a4..3223b1e 100644 --- a/chromeos/network/network_state_handler.h +++ b/chromeos/network/network_state_handler.h @@ -51,7 +51,7 @@ class NetworkTypePattern; // // Most *ByType or *ForType methods will accept any of the following for |type|. // See individual methods for specific notes. -// * Any type defined in service_constants.h (e.g. flimflam::kTypeWifi) +// * Any type defined in service_constants.h (e.g. shill::kTypeWifi) // * kMatchTypeDefault returns the default (active) network // * kMatchTypeNonVirtual returns the primary non virtual network // * kMatchTypeWired returns the primary wired network diff --git a/chromeos/network/network_state_handler_unittest.cc b/chromeos/network/network_state_handler_unittest.cc index 7aa684f..76ccc49 100644 --- a/chromeos/network/network_state_handler_unittest.cc +++ b/chromeos/network/network_state_handler_unittest.cc @@ -164,9 +164,9 @@ class NetworkStateHandlerTest : public testing::Test { DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface(); device_test->ClearDevices(); device_test->AddDevice("/device/stub_wifi_device1", - flimflam::kTypeWifi, "stub_wifi_device1"); + shill::kTypeWifi, "stub_wifi_device1"); device_test->AddDevice("/device/stub_cellular_device1", - flimflam::kTypeCellular, "stub_cellular_device1"); + shill::kTypeCellular, "stub_cellular_device1"); ShillServiceClient::TestInterface* service_test = DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); @@ -175,19 +175,19 @@ class NetworkStateHandlerTest : public testing::Test { const bool add_to_watchlist = true; service_test->AddService(kShillManagerClientStubDefaultService, kShillManagerClientStubDefaultService, - flimflam::kTypeEthernet, flimflam::kStateOnline, + shill::kTypeEthernet, shill::kStateOnline, add_to_visible, add_to_watchlist); service_test->AddService(kShillManagerClientStubDefaultWireless, kShillManagerClientStubDefaultWireless, - flimflam::kTypeWifi, flimflam::kStateOnline, + shill::kTypeWifi, shill::kStateOnline, add_to_visible, add_to_watchlist); service_test->AddService(kShillManagerClientStubWireless2, kShillManagerClientStubWireless2, - flimflam::kTypeWifi, flimflam::kStateIdle, + shill::kTypeWifi, shill::kStateIdle, add_to_visible, add_to_watchlist); service_test->AddService(kShillManagerClientStubCellular, kShillManagerClientStubCellular, - flimflam::kTypeCellular, flimflam::kStateIdle, + shill::kTypeCellular, shill::kStateIdle, add_to_visible, add_to_watchlist); } @@ -223,7 +223,7 @@ TEST_F(NetworkStateHandlerTest, NetworkStateHandlerStub) { kShillManagerClientStubCellular, network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular()) ->path()); - EXPECT_EQ(flimflam::kStateOnline, + EXPECT_EQ(shill::kStateOnline, test_observer_->default_network_connection_state()); } @@ -261,25 +261,25 @@ TEST_F(NetworkStateHandlerTest, TechnologyChanged) { TEST_F(NetworkStateHandlerTest, TechnologyState) { ShillManagerClient::TestInterface* manager_test = DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface(); - manager_test->RemoveTechnology(flimflam::kTypeWimax); + manager_test->RemoveTechnology(shill::kTypeWimax); message_loop_.RunUntilIdle(); EXPECT_EQ( NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); - manager_test->AddTechnology(flimflam::kTypeWimax, false); + manager_test->AddTechnology(shill::kTypeWimax, false); message_loop_.RunUntilIdle(); EXPECT_EQ( NetworkStateHandler::TECHNOLOGY_AVAILABLE, network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); - manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, true); + manager_test->SetTechnologyInitializing(shill::kTypeWimax, true); message_loop_.RunUntilIdle(); EXPECT_EQ( NetworkStateHandler::TECHNOLOGY_UNINITIALIZED, network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); - manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, false); + manager_test->SetTechnologyInitializing(shill::kTypeWimax, false); network_state_handler_->SetTechnologyEnabled( NetworkTypePattern::Wimax(), true, network_handler::ErrorCallback()); message_loop_.RunUntilIdle(); @@ -287,7 +287,7 @@ TEST_F(NetworkStateHandlerTest, TechnologyState) { NetworkStateHandler::TECHNOLOGY_ENABLED, network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); - manager_test->RemoveTechnology(flimflam::kTypeWimax); + manager_test->RemoveTechnology(shill::kTypeWimax); message_loop_.RunUntilIdle(); EXPECT_EQ( NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, @@ -302,7 +302,7 @@ TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) { base::StringValue security_value("TestSecurity"); DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(eth1), - flimflam::kSecurityProperty, security_value, + shill::kSecurityProperty, security_value, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); EXPECT_EQ("TestSecurity", @@ -312,7 +312,7 @@ TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) { // Changing a service to the existing value should not trigger an update. DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(eth1), - flimflam::kSecurityProperty, security_value, + shill::kSecurityProperty, security_value, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1)); @@ -335,16 +335,16 @@ TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) { ShillServiceClient::TestInterface* service_test = DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); const std::string eth1 = kShillManagerClientStubDefaultService; - base::StringValue connection_state_idle_value(flimflam::kStateIdle); - service_test->SetServiceProperty(eth1, flimflam::kStateProperty, + base::StringValue connection_state_idle_value(shill::kStateIdle); + service_test->SetServiceProperty(eth1, shill::kStateProperty, connection_state_idle_value); message_loop_.RunUntilIdle(); - EXPECT_EQ(flimflam::kStateIdle, + EXPECT_EQ(shill::kStateIdle, test_observer_->NetworkConnectionStateForService(eth1)); EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1)); // Confirm that changing the connection state to the same value does *not* // signal the observer. - service_test->SetServiceProperty(eth1, flimflam::kStateProperty, + service_test->SetServiceProperty(eth1, shill::kStateProperty, connection_state_idle_value); message_loop_.RunUntilIdle(); EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1)); @@ -362,12 +362,12 @@ TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) { // should re-sort Manager.Services. const std::string eth1 = kShillManagerClientStubDefaultService; const std::string wifi1 = kShillManagerClientStubDefaultWireless; - base::StringValue connection_state_idle_value(flimflam::kStateIdle); - service_test->SetServiceProperty(eth1, flimflam::kStateProperty, + base::StringValue connection_state_idle_value(shill::kStateIdle); + service_test->SetServiceProperty(eth1, shill::kStateProperty, connection_state_idle_value); message_loop_.RunUntilIdle(); EXPECT_EQ(wifi1, test_observer_->default_network()); - EXPECT_EQ(flimflam::kStateOnline, + EXPECT_EQ(shill::kStateOnline, test_observer_->default_network_connection_state()); // We should have seen 2 default network updates - for the default // service change, and for the state change. @@ -377,7 +377,7 @@ TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) { // a default network change. DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(wifi1), - flimflam::kSecurityProperty, base::StringValue("TestSecurity"), + shill::kSecurityProperty, base::StringValue("TestSecurity"), base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); EXPECT_EQ(3u, test_observer_->default_network_change_count()); @@ -385,7 +385,7 @@ TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) { // No default network updates for signal strength changes. DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(wifi1), - flimflam::kSignalStrengthProperty, base::FundamentalValue(32), + shill::kSignalStrengthProperty, base::FundamentalValue(32), base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); EXPECT_EQ(3u, test_observer_->default_network_change_count()); diff --git a/chromeos/network/network_state_unittest.cc b/chromeos/network/network_state_unittest.cc index 4bb2fac..f652493 100644 --- a/chromeos/network/network_state_unittest.cc +++ b/chromeos/network/network_state_unittest.cc @@ -80,14 +80,14 @@ class NetworkStateTest : public testing::Test { TEST_F(NetworkStateTest, SsidAscii) { std::string wifi_setname = "SSID TEST"; std::string wifi_setname_result = "SSID TEST"; - EXPECT_TRUE(SetStringProperty(flimflam::kNameProperty, wifi_setname)); + EXPECT_TRUE(SetStringProperty(shill::kNameProperty, wifi_setname)); EXPECT_EQ(network_state_.name(), wifi_setname_result); } TEST_F(NetworkStateTest, SsidAsciiWithNull) { std::string wifi_setname = "SSID TEST\x00xxx"; std::string wifi_setname_result = "SSID TEST"; - EXPECT_TRUE(SetStringProperty(flimflam::kNameProperty, wifi_setname)); + EXPECT_TRUE(SetStringProperty(shill::kNameProperty, wifi_setname)); EXPECT_EQ(network_state_.name(), wifi_setname_result); } @@ -95,7 +95,7 @@ TEST_F(NetworkStateTest, SsidAsciiWithNull) { TEST_F(NetworkStateTest, SsidUtf8) { std::string wifi_utf8 = "UTF-8 \u3042\u3044\u3046"; std::string wifi_utf8_result = "UTF-8 \xE3\x81\x82\xE3\x81\x84\xE3\x81\x86"; - EXPECT_TRUE(SetStringProperty(flimflam::kNameProperty, wifi_utf8)); + EXPECT_TRUE(SetStringProperty(shill::kNameProperty, wifi_utf8)); EXPECT_EQ(network_state_.name(), wifi_utf8_result); } @@ -103,7 +103,7 @@ TEST_F(NetworkStateTest, SsidUtf8) { TEST_F(NetworkStateTest, SsidTruncateInvalid) { std::string wifi_setname2 = "SSID TEST \x01\xff!"; std::string wifi_setname2_result = "SSID TEST \xEF\xBF\xBD\xEF\xBF\xBD!"; - EXPECT_TRUE(SetStringProperty(flimflam::kNameProperty, wifi_setname2)); + EXPECT_TRUE(SetStringProperty(shill::kNameProperty, wifi_setname2)); EXPECT_TRUE(SignalInitialPropertiesReceived()); EXPECT_EQ(network_state_.name(), wifi_setname2_result); } @@ -114,7 +114,7 @@ TEST_F(NetworkStateTest, SsidLatin) { std::string wifi_latin1_hex = base::HexEncode(wifi_latin1.c_str(), wifi_latin1.length()); std::string wifi_latin1_result = "latin-1 \u00c0\u00cb\u00cc\u00d6\u00fb"; - EXPECT_FALSE(SetStringProperty(flimflam::kWifiHexSsid, wifi_latin1_hex)); + EXPECT_FALSE(SetStringProperty(shill::kWifiHexSsid, wifi_latin1_hex)); EXPECT_TRUE(SignalInitialPropertiesReceived()); EXPECT_EQ(network_state_.name(), wifi_latin1_result); } @@ -123,7 +123,7 @@ TEST_F(NetworkStateTest, SsidLatin) { TEST_F(NetworkStateTest, SsidHex) { std::string wifi_hex = "5468697320697320484558205353494421"; std::string wifi_hex_result = "This is HEX SSID!"; - EXPECT_FALSE(SetStringProperty(flimflam::kWifiHexSsid, wifi_hex)); + EXPECT_FALSE(SetStringProperty(shill::kWifiHexSsid, wifi_hex)); EXPECT_TRUE(SignalInitialPropertiesReceived()); EXPECT_EQ(network_state_.name(), wifi_hex_result); } diff --git a/chromeos/network/network_util.cc b/chromeos/network/network_util.cc index 4b13a15..8b1ff44 100644 --- a/chromeos/network/network_util.cc +++ b/chromeos/network/network_util.cc @@ -104,16 +104,16 @@ bool ParseCellularScanResults( const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); // If the network id property is not present then this network cannot be // connected to so don't include it in the results. - if (!dict->GetStringWithoutPathExpansion(flimflam::kNetworkIdProperty, + if (!dict->GetStringWithoutPathExpansion(shill::kNetworkIdProperty, &scan_result.network_id)) continue; - dict->GetStringWithoutPathExpansion(flimflam::kStatusProperty, + dict->GetStringWithoutPathExpansion(shill::kStatusProperty, &scan_result.status); - dict->GetStringWithoutPathExpansion(flimflam::kLongNameProperty, + dict->GetStringWithoutPathExpansion(shill::kLongNameProperty, &scan_result.long_name); - dict->GetStringWithoutPathExpansion(flimflam::kShortNameProperty, + dict->GetStringWithoutPathExpansion(shill::kShortNameProperty, &scan_result.short_name); - dict->GetStringWithoutPathExpansion(flimflam::kTechnologyProperty, + dict->GetStringWithoutPathExpansion(shill::kTechnologyProperty, &scan_result.technology); scan_results->push_back(scan_result); } diff --git a/chromeos/network/network_util_unittest.cc b/chromeos/network/network_util_unittest.cc index 17c09bb..f668cf3 100644 --- a/chromeos/network/network_util_unittest.cc +++ b/chromeos/network/network_util_unittest.cc @@ -117,22 +117,22 @@ TEST_F(NetworkUtilTest, ParseScanResults) { // Scan result has no network id. list.Clear(); DictionaryValue* dict_value = new DictionaryValue(); - dict_value->SetString(flimflam::kStatusProperty, "available"); + dict_value->SetString(shill::kStatusProperty, "available"); list.Append(dict_value); EXPECT_TRUE(ParseCellularScanResults(list, &scan_results)); EXPECT_TRUE(scan_results.empty()); // Mixed parse results. dict_value = new DictionaryValue(); - dict_value->SetString(flimflam::kNetworkIdProperty, "000001"); - dict_value->SetString(flimflam::kStatusProperty, "unknown"); - dict_value->SetString(flimflam::kTechnologyProperty, "GSM"); + dict_value->SetString(shill::kNetworkIdProperty, "000001"); + dict_value->SetString(shill::kStatusProperty, "unknown"); + dict_value->SetString(shill::kTechnologyProperty, "GSM"); list.Append(dict_value); dict_value = new DictionaryValue(); - dict_value->SetString(flimflam::kNetworkIdProperty, "000002"); - dict_value->SetString(flimflam::kStatusProperty, "available"); - dict_value->SetString(flimflam::kLongNameProperty, "Long Name"); + dict_value->SetString(shill::kNetworkIdProperty, "000002"); + dict_value->SetString(shill::kStatusProperty, "available"); + dict_value->SetString(shill::kLongNameProperty, "Long Name"); list.Append(dict_value); EXPECT_TRUE(ParseCellularScanResults(list, &scan_results)); diff --git a/chromeos/network/onc/onc_translation_tables.cc b/chromeos/network/onc/onc_translation_tables.cc index 0cc2b6b..690df0b 100644 --- a/chromeos/network/onc/onc_translation_tables.cc +++ b/chromeos/network/onc/onc_translation_tables.cc @@ -24,150 +24,150 @@ namespace onc { namespace { const FieldTranslationEntry eap_fields[] = { - { eap::kAnonymousIdentity, flimflam::kEapAnonymousIdentityProperty }, - { eap::kIdentity, flimflam::kEapIdentityProperty }, + { eap::kAnonymousIdentity, shill::kEapAnonymousIdentityProperty }, + { eap::kIdentity, shill::kEapIdentityProperty }, // This field is converted during translation, see onc_translator_*. - // { eap::kInner, flimflam::kEapPhase2AuthProperty }, + // { eap::kInner, shill::kEapPhase2AuthProperty }, // This field is converted during translation, see onc_translator_*. - // { eap::kOuter, flimflam::kEapMethodProperty }, - { eap::kPassword, flimflam::kEapPasswordProperty }, - { eap::kSaveCredentials, flimflam::kSaveCredentialsProperty }, + // { eap::kOuter, shill::kEapMethodProperty }, + { eap::kPassword, shill::kEapPasswordProperty }, + { eap::kSaveCredentials, shill::kSaveCredentialsProperty }, { eap::kServerCAPEMs, shill::kEapCaCertPemProperty }, - { eap::kUseSystemCAs, flimflam::kEapUseSystemCasProperty }, + { eap::kUseSystemCAs, shill::kEapUseSystemCasProperty }, { NULL } }; const FieldTranslationEntry ipsec_fields[] = { // Ignored by Shill, not necessary to synchronize. - // { ipsec::kAuthenticationType, flimflam::kL2tpIpsecAuthenticationType }, + // { ipsec::kAuthenticationType, shill::kL2tpIpsecAuthenticationType }, { ipsec::kGroup, shill::kL2tpIpsecTunnelGroupProperty }, // Ignored by Shill, not necessary to synchronize. - // { ipsec::kIKEVersion, flimflam::kL2tpIpsecIkeVersion }, - { ipsec::kPSK, flimflam::kL2tpIpsecPskProperty }, - { vpn::kSaveCredentials, flimflam::kSaveCredentialsProperty }, + // { ipsec::kIKEVersion, shill::kL2tpIpsecIkeVersion }, + { ipsec::kPSK, shill::kL2tpIpsecPskProperty }, + { vpn::kSaveCredentials, shill::kSaveCredentialsProperty }, { ipsec::kServerCAPEMs, shill::kL2tpIpsecCaCertPemProperty }, { NULL } }; const FieldTranslationEntry l2tp_fields[] = { - { vpn::kPassword, flimflam::kL2tpIpsecPasswordProperty }, + { vpn::kPassword, shill::kL2tpIpsecPasswordProperty }, // We don't synchronize l2tp's SaveCredentials field for now, as Shill doesn't // support separate settings for ipsec and l2tp. // { vpn::kSaveCredentials, &kBoolSignature }, - { vpn::kUsername, flimflam::kL2tpIpsecUserProperty }, + { vpn::kUsername, shill::kL2tpIpsecUserProperty }, { NULL } }; const FieldTranslationEntry openvpn_fields[] = { - { openvpn::kAuth, flimflam::kOpenVPNAuthProperty }, - { openvpn::kAuthNoCache, flimflam::kOpenVPNAuthNoCacheProperty }, - { openvpn::kAuthRetry, flimflam::kOpenVPNAuthRetryProperty }, - { openvpn::kCipher, flimflam::kOpenVPNCipherProperty }, - { openvpn::kCompLZO, flimflam::kOpenVPNCompLZOProperty }, - { openvpn::kCompNoAdapt, flimflam::kOpenVPNCompNoAdaptProperty }, - { openvpn::kKeyDirection, flimflam::kOpenVPNKeyDirectionProperty }, - { openvpn::kNsCertType, flimflam::kOpenVPNNsCertTypeProperty }, - { vpn::kPassword, flimflam::kOpenVPNPasswordProperty }, - { openvpn::kPort, flimflam::kOpenVPNPortProperty }, - { openvpn::kProto, flimflam::kOpenVPNProtoProperty }, - { openvpn::kPushPeerInfo, flimflam::kOpenVPNPushPeerInfoProperty }, - { openvpn::kRemoteCertEKU, flimflam::kOpenVPNRemoteCertEKUProperty }, + { openvpn::kAuth, shill::kOpenVPNAuthProperty }, + { openvpn::kAuthNoCache, shill::kOpenVPNAuthNoCacheProperty }, + { openvpn::kAuthRetry, shill::kOpenVPNAuthRetryProperty }, + { openvpn::kCipher, shill::kOpenVPNCipherProperty }, + { openvpn::kCompLZO, shill::kOpenVPNCompLZOProperty }, + { openvpn::kCompNoAdapt, shill::kOpenVPNCompNoAdaptProperty }, + { openvpn::kKeyDirection, shill::kOpenVPNKeyDirectionProperty }, + { openvpn::kNsCertType, shill::kOpenVPNNsCertTypeProperty }, + { vpn::kPassword, shill::kOpenVPNPasswordProperty }, + { openvpn::kPort, shill::kOpenVPNPortProperty }, + { openvpn::kProto, shill::kOpenVPNProtoProperty }, + { openvpn::kPushPeerInfo, shill::kOpenVPNPushPeerInfoProperty }, + { openvpn::kRemoteCertEKU, shill::kOpenVPNRemoteCertEKUProperty }, // This field is converted during translation, see onc_translator_*. - // { openvpn::kRemoteCertKU, flimflam::kOpenVPNRemoteCertKUProperty }, - { openvpn::kRemoteCertTLS, flimflam::kOpenVPNRemoteCertTLSProperty }, - { openvpn::kRenegSec, flimflam::kOpenVPNRenegSecProperty }, - { vpn::kSaveCredentials, flimflam::kSaveCredentialsProperty }, + // { openvpn::kRemoteCertKU, shill::kOpenVPNRemoteCertKUProperty }, + { openvpn::kRemoteCertTLS, shill::kOpenVPNRemoteCertTLSProperty }, + { openvpn::kRenegSec, shill::kOpenVPNRenegSecProperty }, + { vpn::kSaveCredentials, shill::kSaveCredentialsProperty }, { openvpn::kServerCAPEMs, shill::kOpenVPNCaCertPemProperty }, - { openvpn::kServerPollTimeout, flimflam::kOpenVPNServerPollTimeoutProperty }, - { openvpn::kShaper, flimflam::kOpenVPNShaperProperty }, - { openvpn::kStaticChallenge, flimflam::kOpenVPNStaticChallengeProperty }, - { openvpn::kTLSAuthContents, flimflam::kOpenVPNTLSAuthContentsProperty }, - { openvpn::kTLSRemote, flimflam::kOpenVPNTLSRemoteProperty }, - { vpn::kUsername, flimflam::kOpenVPNUserProperty }, + { openvpn::kServerPollTimeout, shill::kOpenVPNServerPollTimeoutProperty }, + { openvpn::kShaper, shill::kOpenVPNShaperProperty }, + { openvpn::kStaticChallenge, shill::kOpenVPNStaticChallengeProperty }, + { openvpn::kTLSAuthContents, shill::kOpenVPNTLSAuthContentsProperty }, + { openvpn::kTLSRemote, shill::kOpenVPNTLSRemoteProperty }, + { vpn::kUsername, shill::kOpenVPNUserProperty }, { NULL } }; const FieldTranslationEntry vpn_fields[] = { - { vpn::kAutoConnect, flimflam::kAutoConnectProperty }, - { vpn::kHost, flimflam::kProviderHostProperty }, + { vpn::kAutoConnect, shill::kAutoConnectProperty }, + { vpn::kHost, shill::kProviderHostProperty }, // This field is converted during translation, see onc_translator_*. - // { vpn::kType, flimflam::kProviderTypeProperty }, + // { vpn::kType, shill::kProviderTypeProperty }, { NULL } }; const FieldTranslationEntry wifi_fields[] = { - { wifi::kAutoConnect, flimflam::kAutoConnectProperty }, - { wifi::kBSSID, flimflam::kWifiBSsid }, - { wifi::kFrequency, flimflam::kWifiFrequency }, + { wifi::kAutoConnect, shill::kAutoConnectProperty }, + { wifi::kBSSID, shill::kWifiBSsid }, + { wifi::kFrequency, shill::kWifiFrequency }, { wifi::kFrequencyList, shill::kWifiFrequencyListProperty }, - { wifi::kHiddenSSID, flimflam::kWifiHiddenSsid }, - { wifi::kPassphrase, flimflam::kPassphraseProperty }, - { wifi::kSSID, flimflam::kSSIDProperty }, + { wifi::kHiddenSSID, shill::kWifiHiddenSsid }, + { wifi::kPassphrase, shill::kPassphraseProperty }, + { wifi::kSSID, shill::kSSIDProperty }, // This field is converted during translation, see onc_translator_*. - // { wifi::kSecurity, flimflam::kSecurityProperty }, - { wifi::kSignalStrength, flimflam::kSignalStrengthProperty }, + // { wifi::kSecurity, shill::kSecurityProperty }, + { wifi::kSignalStrength, shill::kSignalStrengthProperty }, { NULL } }; const FieldTranslationEntry cellular_apn_fields[] = { - { cellular_apn::kName, flimflam::kApnProperty }, - { cellular_apn::kUsername, flimflam::kApnUsernameProperty }, - { cellular_apn::kPassword, flimflam::kApnPasswordProperty }, + { cellular_apn::kName, shill::kApnProperty }, + { cellular_apn::kUsername, shill::kApnUsernameProperty }, + { cellular_apn::kPassword, shill::kApnPasswordProperty }, { NULL } }; const FieldTranslationEntry cellular_provider_fields[] = { - { cellular_provider::kCode, flimflam::kOperatorCodeKey }, - { cellular_provider::kCountry, flimflam::kOperatorCountryKey }, - { cellular_provider::kName, flimflam::kOperatorNameKey }, + { cellular_provider::kCode, shill::kOperatorCodeKey }, + { cellular_provider::kCountry, shill::kOperatorCountryKey }, + { cellular_provider::kName, shill::kOperatorNameKey }, { NULL } }; const FieldTranslationEntry cellular_fields[] = { { cellular::kActivateOverNonCellularNetwork, shill::kActivateOverNonCellularNetworkProperty }, - { cellular::kActivationState, flimflam::kActivationStateProperty }, - { cellular::kAllowRoaming, flimflam::kCellularAllowRoamingProperty }, - { cellular::kCarrier, flimflam::kCarrierProperty }, - { cellular::kESN, flimflam::kEsnProperty }, - { cellular::kFamily, flimflam::kTechnologyFamilyProperty }, - { cellular::kFirmwareRevision, flimflam::kFirmwareRevisionProperty }, - { cellular::kFoundNetworks, flimflam::kFoundNetworksProperty }, - { cellular::kHardwareRevision, flimflam::kHardwareRevisionProperty }, - { cellular::kICCID, flimflam::kIccidProperty }, - { cellular::kIMEI, flimflam::kImeiProperty }, - { cellular::kIMSI, flimflam::kImsiProperty }, - { cellular::kManufacturer, flimflam::kManufacturerProperty }, - { cellular::kMDN, flimflam::kMdnProperty }, - { cellular::kMEID, flimflam::kMeidProperty }, - { cellular::kMIN, flimflam::kMinProperty }, - { cellular::kModelID, flimflam::kModelIDProperty }, - { cellular::kNetworkTechnology, flimflam::kNetworkTechnologyProperty }, - { cellular::kPRLVersion, flimflam::kPRLVersionProperty }, + { cellular::kActivationState, shill::kActivationStateProperty }, + { cellular::kAllowRoaming, shill::kCellularAllowRoamingProperty }, + { cellular::kCarrier, shill::kCarrierProperty }, + { cellular::kESN, shill::kEsnProperty }, + { cellular::kFamily, shill::kTechnologyFamilyProperty }, + { cellular::kFirmwareRevision, shill::kFirmwareRevisionProperty }, + { cellular::kFoundNetworks, shill::kFoundNetworksProperty }, + { cellular::kHardwareRevision, shill::kHardwareRevisionProperty }, + { cellular::kICCID, shill::kIccidProperty }, + { cellular::kIMEI, shill::kImeiProperty }, + { cellular::kIMSI, shill::kImsiProperty }, + { cellular::kManufacturer, shill::kManufacturerProperty }, + { cellular::kMDN, shill::kMdnProperty }, + { cellular::kMEID, shill::kMeidProperty }, + { cellular::kMIN, shill::kMinProperty }, + { cellular::kModelID, shill::kModelIDProperty }, + { cellular::kNetworkTechnology, shill::kNetworkTechnologyProperty }, + { cellular::kPRLVersion, shill::kPRLVersionProperty }, { cellular::kProviderRequiresRoaming, shill::kProviderRequiresRoamingProperty }, - { cellular::kRoamingState, flimflam::kRoamingStateProperty }, - { cellular::kSelectedNetwork, flimflam::kSelectedNetworkProperty }, - { cellular::kSIMLockStatus, flimflam::kSIMLockStatusProperty }, + { cellular::kRoamingState, shill::kRoamingStateProperty }, + { cellular::kSelectedNetwork, shill::kSelectedNetworkProperty }, + { cellular::kSIMLockStatus, shill::kSIMLockStatusProperty }, { cellular::kSIMPresent, shill::kSIMPresentProperty }, { cellular::kSupportedCarriers, shill::kSupportedCarriersProperty }, - { cellular::kSupportNetworkScan, flimflam::kSupportNetworkScanProperty }, + { cellular::kSupportNetworkScan, shill::kSupportNetworkScanProperty }, { NULL } }; const FieldTranslationEntry network_fields[] = { // Shill doesn't allow setting the name for non-VPN networks. // This field is conditionally translated, see onc_translator_*. - // { network_config::kName, flimflam::kNameProperty }, - { network_config::kGUID, flimflam::kGuidProperty }, + // { network_config::kName, shill::kNameProperty }, + { network_config::kGUID, shill::kGuidProperty }, // This field is converted during translation, see onc_translator_*. - // { network_config::kType, flimflam::kTypeProperty }, + // { network_config::kType, shill::kTypeProperty }, // This field is converted during translation, see // onc_translator_shill_to_onc.cc. It is only converted when going from // Shill->ONC, and ignored otherwise. - // { network_config::kConnectionState, flimflam::kStateProperty }, + // { network_config::kConnectionState, shill::kStateProperty }, { NULL } }; @@ -200,7 +200,7 @@ struct NestedShillDictionaryEntry { }; const char* cellular_apn_property_path_entries[] = { - flimflam::kCellularApnProperty, + shill::kCellularApnProperty, NULL }; @@ -213,51 +213,51 @@ const NestedShillDictionaryEntry nested_shill_dictionaries[] = { const StringTranslationEntry kNetworkTypeTable[] = { // This mapping is ensured in the translation code. - // { network_type::kEthernet, flimflam::kTypeEthernet }, + // { network_type::kEthernet, shill::kTypeEthernet }, // { network_type::kEthernet, shill::kTypeEthernetEap }, - { network_type::kWiFi, flimflam::kTypeWifi }, - { network_type::kCellular, flimflam::kTypeCellular }, - { network_type::kVPN, flimflam::kTypeVPN }, + { network_type::kWiFi, shill::kTypeWifi }, + { network_type::kCellular, shill::kTypeCellular }, + { network_type::kVPN, shill::kTypeVPN }, { NULL } }; const StringTranslationEntry kVPNTypeTable[] = { - { vpn::kTypeL2TP_IPsec, flimflam::kProviderL2tpIpsec }, - { vpn::kOpenVPN, flimflam::kProviderOpenVpn }, + { vpn::kTypeL2TP_IPsec, shill::kProviderL2tpIpsec }, + { vpn::kOpenVPN, shill::kProviderOpenVpn }, { NULL } }; // The first matching line is chosen. const StringTranslationEntry kWiFiSecurityTable[] = { - { wifi::kNone, flimflam::kSecurityNone }, - { wifi::kWEP_PSK, flimflam::kSecurityWep }, - { wifi::kWPA_PSK, flimflam::kSecurityPsk }, - { wifi::kWPA_EAP, flimflam::kSecurity8021x }, - { wifi::kWPA_PSK, flimflam::kSecurityRsn }, - { wifi::kWPA_PSK, flimflam::kSecurityWpa }, + { wifi::kNone, shill::kSecurityNone }, + { wifi::kWEP_PSK, shill::kSecurityWep }, + { wifi::kWPA_PSK, shill::kSecurityPsk }, + { wifi::kWPA_EAP, shill::kSecurity8021x }, + { wifi::kWPA_PSK, shill::kSecurityRsn }, + { wifi::kWPA_PSK, shill::kSecurityWpa }, { NULL } }; const StringTranslationEntry kEAPOuterTable[] = { - { eap::kPEAP, flimflam::kEapMethodPEAP }, - { eap::kEAP_TLS, flimflam::kEapMethodTLS }, - { eap::kEAP_TTLS, flimflam::kEapMethodTTLS }, - { eap::kLEAP, flimflam::kEapMethodLEAP }, + { eap::kPEAP, shill::kEapMethodPEAP }, + { eap::kEAP_TLS, shill::kEapMethodTLS }, + { eap::kEAP_TTLS, shill::kEapMethodTTLS }, + { eap::kLEAP, shill::kEapMethodLEAP }, { NULL } }; // Translation of the EAP.Inner field in case of EAP.Outer == PEAP const StringTranslationEntry kEAP_PEAP_InnerTable[] = { - { eap::kMD5, flimflam::kEapPhase2AuthPEAPMD5 }, - { eap::kMSCHAPv2, flimflam::kEapPhase2AuthPEAPMSCHAPV2 }, + { eap::kMD5, shill::kEapPhase2AuthPEAPMD5 }, + { eap::kMSCHAPv2, shill::kEapPhase2AuthPEAPMSCHAPV2 }, { NULL } }; // Translation of the EAP.Inner field in case of EAP.Outer == TTLS const StringTranslationEntry kEAP_TTLS_InnerTable[] = { - { eap::kMD5, flimflam::kEapPhase2AuthTTLSMD5 }, - { eap::kMSCHAPv2, flimflam::kEapPhase2AuthTTLSMSCHAPV2 }, - { eap::kPAP, flimflam::kEapPhase2AuthTTLSPAP }, + { eap::kMD5, shill::kEapPhase2AuthTTLSMD5 }, + { eap::kMSCHAPv2, shill::kEapPhase2AuthTTLSMSCHAPV2 }, + { eap::kPAP, shill::kEapPhase2AuthTTLSPAP }, { NULL } }; diff --git a/chromeos/network/onc/onc_translator_onc_to_shill.cc b/chromeos/network/onc/onc_translator_onc_to_shill.cc index 8af78d5..f3ac1fc 100644 --- a/chromeos/network/onc/onc_translator_onc_to_shill.cc +++ b/chromeos/network/onc/onc_translator_onc_to_shill.cc @@ -106,10 +106,10 @@ void LocalTranslator::TranslateEthernet() { onc_object_->GetStringWithoutPathExpansion(ethernet::kAuthentication, &authentication); - const char* shill_type = flimflam::kTypeEthernet; + const char* shill_type = shill::kTypeEthernet; if (authentication == ethernet::k8021X) shill_type = shill::kTypeEthernetEap; - shill_dictionary_->SetStringWithoutPathExpansion(flimflam::kTypeProperty, + shill_dictionary_->SetStringWithoutPathExpansion(shill::kTypeProperty, shill_type); CopyFieldsAccordingToSignature(); @@ -124,7 +124,7 @@ void LocalTranslator::TranslateOpenVPN() { &certKUs) && certKUs->GetString(0, &certKU)) { shill_dictionary_->SetStringWithoutPathExpansion( - flimflam::kOpenVPNRemoteCertKUProperty, certKU); + shill::kOpenVPNRemoteCertKUProperty, certKU); } for (base::DictionaryValue::Iterator it(*onc_object_); !it.IsAtEnd(); @@ -145,8 +145,7 @@ void LocalTranslator::TranslateOpenVPN() { void LocalTranslator::TranslateVPN() { std::string type; onc_object_->GetStringWithoutPathExpansion(vpn::kType, &type); - TranslateWithTableAndSet(type, kVPNTypeTable, - flimflam::kProviderTypeProperty); + TranslateWithTableAndSet(type, kVPNTypeTable, shill::kProviderTypeProperty); CopyFieldsAccordingToSignature(); } @@ -155,18 +154,18 @@ void LocalTranslator::TranslateWiFi() { std::string security; onc_object_->GetStringWithoutPathExpansion(wifi::kSecurity, &security); TranslateWithTableAndSet(security, kWiFiSecurityTable, - flimflam::kSecurityProperty); + shill::kSecurityProperty); // We currently only support managed and no adhoc networks. - shill_dictionary_->SetStringWithoutPathExpansion(flimflam::kModeProperty, - flimflam::kModeManaged); + shill_dictionary_->SetStringWithoutPathExpansion(shill::kModeProperty, + shill::kModeManaged); CopyFieldsAccordingToSignature(); } void LocalTranslator::TranslateEAP() { std::string outer; onc_object_->GetStringWithoutPathExpansion(eap::kOuter, &outer); - TranslateWithTableAndSet(outer, kEAPOuterTable, flimflam::kEapMethodProperty); + TranslateWithTableAndSet(outer, kEAPOuterTable, shill::kEapMethodProperty); // Translate the inner protocol only for outer tunneling protocols. if (outer == eap::kPEAP || outer == eap::kEAP_TTLS) { @@ -178,7 +177,7 @@ void LocalTranslator::TranslateEAP() { if (inner != eap::kAutomatic) { const StringTranslationEntry* table = outer == eap::kPEAP ? kEAP_PEAP_InnerTable : kEAP_TTLS_InnerTable; - TranslateWithTableAndSet(inner, table, flimflam::kEapPhase2AuthProperty); + TranslateWithTableAndSet(inner, table, shill::kEapPhase2AuthProperty); } } @@ -191,13 +190,13 @@ void LocalTranslator::TranslateNetworkConfiguration() { // Set the type except for Ethernet which is set in TranslateEthernet. if (type != network_type::kEthernet) - TranslateWithTableAndSet(type, kNetworkTypeTable, flimflam::kTypeProperty); + TranslateWithTableAndSet(type, kNetworkTypeTable, shill::kTypeProperty); // Shill doesn't allow setting the name for non-VPN networks. if (type == network_type::kVPN) { std::string name; onc_object_->GetStringWithoutPathExpansion(network_config::kName, &name); - shill_dictionary_->SetStringWithoutPathExpansion(flimflam::kNameProperty, + shill_dictionary_->SetStringWithoutPathExpansion(shill::kNameProperty, name); } diff --git a/chromeos/network/onc/onc_translator_shill_to_onc.cc b/chromeos/network/onc/onc_translator_shill_to_onc.cc index 3835e6b..124db9f 100644 --- a/chromeos/network/onc/onc_translator_shill_to_onc.cc +++ b/chromeos/network/onc/onc_translator_shill_to_onc.cc @@ -128,7 +128,7 @@ ShillToONCTranslator::CreateTranslatedONCObject() { void ShillToONCTranslator::TranslateEthernet() { std::string shill_network_type; - shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty, + shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty, &shill_network_type); const char* onc_auth = ethernet::kNone; if (shill_network_type == shill::kTypeEthernetEap) @@ -142,7 +142,7 @@ void ShillToONCTranslator::TranslateOpenVPN() { // wraps the value into a list. std::string certKU; if (shill_dictionary_->GetStringWithoutPathExpansion( - flimflam::kOpenVPNRemoteCertKUProperty, &certKU)) { + shill::kOpenVPNRemoteCertKUProperty, &certKU)) { scoped_ptr<base::ListValue> certKUs(new base::ListValue); certKUs->AppendString(certKU); onc_object_->SetWithoutPathExpansion(openvpn::kRemoteCertKU, @@ -197,7 +197,7 @@ void ShillToONCTranslator::TranslateOpenVPN() { } void ShillToONCTranslator::TranslateVPN() { - TranslateWithTableAndSet(flimflam::kProviderTypeProperty, kVPNTypeTable, + TranslateWithTableAndSet(shill::kProviderTypeProperty, kVPNTypeTable, vpn::kType); CopyPropertiesAccordingToSignature(); @@ -214,7 +214,7 @@ void ShillToONCTranslator::TranslateVPN() { } void ShillToONCTranslator::TranslateWiFiWithState() { - TranslateWithTableAndSet(flimflam::kSecurityProperty, kWiFiSecurityTable, + TranslateWithTableAndSet(shill::kSecurityProperty, kWiFiSecurityTable, wifi::kSecurity); CopyPropertiesAccordingToSignature(); } @@ -223,11 +223,11 @@ void ShillToONCTranslator::TranslateCellularWithState() { CopyPropertiesAccordingToSignature(); const base::DictionaryValue* dictionary = NULL; if (shill_dictionary_->GetDictionaryWithoutPathExpansion( - flimflam::kServingOperatorProperty, &dictionary)) { + shill::kServingOperatorProperty, &dictionary)) { TranslateAndAddNestedObject(cellular::kServingOperator, *dictionary); } if (shill_dictionary_->GetDictionaryWithoutPathExpansion( - flimflam::kCellularApnProperty, &dictionary)) { + shill::kCellularApnProperty, &dictionary)) { TranslateAndAddNestedObject(cellular::kAPN, *dictionary); } } @@ -236,10 +236,10 @@ void ShillToONCTranslator::TranslateNetworkWithState() { CopyPropertiesAccordingToSignature(); std::string shill_network_type; - shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty, + shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty, &shill_network_type); std::string onc_network_type = network_type::kEthernet; - if (shill_network_type != flimflam::kTypeEthernet && + if (shill_network_type != shill::kTypeEthernet && shill_network_type != shill::kTypeEthernetEap) { TranslateStringToONC( kNetworkTypeTable, shill_network_type, &onc_network_type); @@ -253,12 +253,12 @@ void ShillToONCTranslator::TranslateNetworkWithState() { // Since Name is a read only field in Shill unless it's a VPN, it is copied // here, but not when going the other direction (if it's not a VPN). std::string name; - shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kNameProperty, + shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty, &name); onc_object_->SetStringWithoutPathExpansion(network_config::kName, name); std::string state; - if (shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kStateProperty, + if (shill_dictionary_->GetStringWithoutPathExpansion(shill::kStateProperty, &state)) { std::string onc_state = connection_state::kNotConnected; if (NetworkState::StateIsConnected(state)) { diff --git a/chromeos/network/policy_applicator.cc b/chromeos/network/policy_applicator.cc index 33fa703..bc2315d 100644 --- a/chromeos/network/policy_applicator.cc +++ b/chromeos/network/policy_applicator.cc @@ -73,10 +73,10 @@ void PolicyApplicator::GetProfilePropertiesCallback( VLOG(2) << "Received properties for profile " << profile_.ToDebugString(); const base::ListValue* entries = NULL; if (!profile_properties.GetListWithoutPathExpansion( - flimflam::kEntriesProperty, &entries)) { + shill::kEntriesProperty, &entries)) { LOG(ERROR) << "Profile " << profile_.ToDebugString() << " doesn't contain the property " - << flimflam::kEntriesProperty; + << shill::kEntriesProperty; return; } diff --git a/chromeos/network/policy_util.cc b/chromeos/network/policy_util.cc index c05d067..086a83a 100644 --- a/chromeos/network/policy_util.cc +++ b/chromeos/network/policy_util.cc @@ -154,7 +154,7 @@ scoped_ptr<base::DictionaryValue> CreateShillConfiguration( onc::TranslateONCObjectToShill(&onc::kNetworkConfigurationSignature, *effective)); - shill_dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty, + shill_dictionary->SetStringWithoutPathExpansion(shill::kProfileProperty, profile.path); scoped_ptr<NetworkUIData> ui_data; diff --git a/chromeos/network/shill_property_handler.cc b/chromeos/network/shill_property_handler.cc index bd47b20..4d2604e 100644 --- a/chromeos/network/shill_property_handler.cc +++ b/chromeos/network/shill_property_handler.cc @@ -173,7 +173,7 @@ void ShillPropertyHandler::SetCheckPortalList( const std::string& check_portal_list) { base::StringValue value(check_portal_list); shill_manager_->SetProperty( - flimflam::kCheckPortalListProperty, + shill::kCheckPortalListProperty, value, base::Bind(&base::DoNothing), base::Bind(&network_handler::ShillErrorCallbackFunction, @@ -245,7 +245,7 @@ void ShillPropertyHandler::ManagerPropertiesCallback( for (base::DictionaryValue::Iterator iter(properties); !iter.IsAtEnd(); iter.Advance()) { // Defer updating Services until all other properties have been updated. - if (iter.key() == flimflam::kServicesProperty) + if (iter.key() == shill::kServicesProperty) update_service_value = &iter.value(); else if (iter.key() == shill::kServiceCompleteListProperty) update_service_complete_value = &iter.value(); @@ -254,7 +254,7 @@ void ShillPropertyHandler::ManagerPropertiesCallback( } // Update Services which can safely assume other properties have been set. if (update_service_value) - ManagerPropertyChanged(flimflam::kServicesProperty, *update_service_value); + ManagerPropertyChanged(shill::kServicesProperty, *update_service_value); // Update ServiceCompleteList which skips entries that have already been // requested for Services. if (update_service_complete_value) { @@ -268,7 +268,7 @@ void ShillPropertyHandler::ManagerPropertiesCallback( void ShillPropertyHandler::CheckPendingStateListUpdates( const std::string& key) { // Once there are no pending updates, signal the state list changed callbacks. - if ((key.empty() || key == flimflam::kServicesProperty) && + if ((key.empty() || key == shill::kServicesProperty) && pending_updates_[ManagedState::MANAGED_TYPE_NETWORK].size() == 0) { listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_NETWORK); } @@ -279,7 +279,7 @@ void ShillPropertyHandler::CheckPendingStateListUpdates( pending_updates_[ManagedState::MANAGED_TYPE_FAVORITE].size() == 0) { listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_FAVORITE); } - if ((key.empty() || key == flimflam::kDevicesProperty) && + if ((key.empty() || key == shill::kDevicesProperty) && pending_updates_[ManagedState::MANAGED_TYPE_DEVICE].size() == 0) { listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_DEVICE); } @@ -287,7 +287,7 @@ void ShillPropertyHandler::CheckPendingStateListUpdates( void ShillPropertyHandler::ManagerPropertyChanged(const std::string& key, const base::Value& value) { - if (key == flimflam::kServicesProperty) { + if (key == shill::kServicesProperty) { const base::ListValue* vlist = GetListValue(key, value); if (vlist) { listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_NETWORK, *vlist); @@ -304,18 +304,18 @@ void ShillPropertyHandler::ManagerPropertyChanged(const std::string& key, listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_FAVORITE, *vlist); UpdateProperties(ManagedState::MANAGED_TYPE_FAVORITE, *vlist); } - } else if (key == flimflam::kDevicesProperty) { + } else if (key == shill::kDevicesProperty) { const base::ListValue* vlist = GetListValue(key, value); if (vlist) { listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_DEVICE, *vlist); UpdateProperties(ManagedState::MANAGED_TYPE_DEVICE, *vlist); UpdateObserved(ManagedState::MANAGED_TYPE_DEVICE, *vlist); } - } else if (key == flimflam::kAvailableTechnologiesProperty) { + } else if (key == shill::kAvailableTechnologiesProperty) { const base::ListValue* vlist = GetListValue(key, value); if (vlist) UpdateAvailableTechnologies(*vlist); - } else if (key == flimflam::kEnabledTechnologiesProperty) { + } else if (key == shill::kEnabledTechnologiesProperty) { const base::ListValue* vlist = GetListValue(key, value); if (vlist) UpdateEnabledTechnologies(*vlist); @@ -323,9 +323,9 @@ void ShillPropertyHandler::ManagerPropertyChanged(const std::string& key, const base::ListValue* vlist = GetListValue(key, value); if (vlist) UpdateUninitializedTechnologies(*vlist); - } else if (key == flimflam::kProfilesProperty) { + } else if (key == shill::kProfilesProperty) { listener_->ProfileListChanged(); - } else if (key == flimflam::kCheckPortalListProperty) { + } else if (key == shill::kCheckPortalListProperty) { std::string check_portal_list; if (value.GetAsString(&check_portal_list)) listener_->CheckPortalListChanged(check_portal_list); @@ -471,7 +471,7 @@ void ShillPropertyHandler::GetPropertiesCallback( // Only networks with a ProfilePath set are Favorites. std::string profile_path; properties.GetStringWithoutPathExpansion( - flimflam::kProfileProperty, &profile_path); + shill::kProfileProperty, &profile_path); if (!profile_path.empty()) { listener_->UpdateManagedStateProperties( ManagedState::MANAGED_TYPE_FAVORITE, path, properties); @@ -543,14 +543,10 @@ void ShillPropertyHandler::GetIPConfigCallback( service_path.c_str(), call_status)); return; } - UpdateIPConfigProperty(service_path, properties, - flimflam::kAddressProperty); - UpdateIPConfigProperty(service_path, properties, - flimflam::kNameServersProperty); - UpdateIPConfigProperty(service_path, properties, - flimflam::kPrefixlenProperty); - UpdateIPConfigProperty(service_path, properties, - flimflam::kGatewayProperty); + UpdateIPConfigProperty(service_path, properties, shill::kAddressProperty); + UpdateIPConfigProperty(service_path, properties, shill::kNameServersProperty); + UpdateIPConfigProperty(service_path, properties, shill::kPrefixlenProperty); + UpdateIPConfigProperty(service_path, properties, shill::kGatewayProperty); UpdateIPConfigProperty(service_path, properties, shill::kWebProxyAutoDiscoveryUrlProperty); } diff --git a/chromeos/network/shill_property_handler_unittest.cc b/chromeos/network/shill_property_handler_unittest.cc index 571230f..431cccf 100644 --- a/chromeos/network/shill_property_handler_unittest.cc +++ b/chromeos/network/shill_property_handler_unittest.cc @@ -59,14 +59,14 @@ class TestListener : public internal::ShillPropertyHandler::Listener { const std::string& service_path, const std::string& key, const base::Value& value) OVERRIDE { - AddPropertyUpdate(flimflam::kServicesProperty, service_path); + AddPropertyUpdate(shill::kServicesProperty, service_path); } virtual void UpdateDeviceProperty( const std::string& device_path, const std::string& key, const base::Value& value) OVERRIDE { - AddPropertyUpdate(flimflam::kDevicesProperty, device_path); + AddPropertyUpdate(shill::kDevicesProperty, device_path); } virtual void TechnologyListChanged() OVERRIDE { @@ -99,11 +99,11 @@ class TestListener : public internal::ShillPropertyHandler::Listener { private: std::string GetTypeString(ManagedState::ManagedType type) { if (type == ManagedState::MANAGED_TYPE_NETWORK) { - return flimflam::kServicesProperty; + return shill::kServicesProperty; } else if (type == ManagedState::MANAGED_TYPE_FAVORITE) { return shill::kServiceCompleteListProperty; } else if (type == ManagedState::MANAGED_TYPE_DEVICE) { - return flimflam::kDevicesProperty; + return shill::kDevicesProperty; } LOG(ERROR) << "UpdateManagedList called with unrecognized type: " << type; ++errors_; @@ -225,7 +225,7 @@ class ShillPropertyHandlerTest : public testing::Test { void AddServiceToProfile(const std::string& type, const std::string& id, bool visible) { - service_test_->AddService(id, id, type, flimflam::kStateIdle, + service_test_->AddService(id, id, type, shill::kStateIdle, visible, false /* watch */); std::vector<std::string> profiles; profile_test_->GetProfilePaths(&profiles); @@ -248,31 +248,31 @@ class ShillPropertyHandlerTest : public testing::Test { } bool IsValidType(const std::string& type) { - return (type == flimflam::kTypeEthernet || + return (type == shill::kTypeEthernet || type == shill::kTypeEthernetEap || - type == flimflam::kTypeWifi || - type == flimflam::kTypeWimax || - type == flimflam::kTypeBluetooth || - type == flimflam::kTypeCellular || - type == flimflam::kTypeVPN); + type == shill::kTypeWifi || + type == shill::kTypeWimax || + type == shill::kTypeBluetooth || + type == shill::kTypeCellular || + type == shill::kTypeVPN); } protected: void SetupDefaultShillState() { message_loop_.RunUntilIdle(); // Process any pending updates device_test_->ClearDevices(); - AddDevice(flimflam::kTypeWifi, "stub_wifi_device1"); - AddDevice(flimflam::kTypeCellular, "stub_cellular_device1"); + AddDevice(shill::kTypeWifi, "stub_wifi_device1"); + AddDevice(shill::kTypeCellular, "stub_cellular_device1"); service_test_->ClearServices(); const bool add_to_watchlist = true; - AddService(flimflam::kTypeEthernet, "stub_ethernet", - flimflam::kStateOnline, add_to_watchlist); - AddService(flimflam::kTypeWifi, "stub_wifi1", - flimflam::kStateOnline, add_to_watchlist); - AddService(flimflam::kTypeWifi, "stub_wifi2", - flimflam::kStateIdle, add_to_watchlist); - AddService(flimflam::kTypeCellular, "stub_cellular1", - flimflam::kStateIdle, add_to_watchlist); + AddService(shill::kTypeEthernet, "stub_ethernet", + shill::kStateOnline, add_to_watchlist); + AddService(shill::kTypeWifi, "stub_wifi1", + shill::kStateOnline, add_to_watchlist); + AddService(shill::kTypeWifi, "stub_wifi2", + shill::kStateIdle, add_to_watchlist); + AddService(shill::kTypeCellular, "stub_cellular1", + shill::kStateIdle, add_to_watchlist); } base::MessageLoopForUI message_loop_; @@ -288,16 +288,14 @@ class ShillPropertyHandlerTest : public testing::Test { }; TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerStub) { - EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable( - flimflam::kTypeWifi)); - EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled( - flimflam::kTypeWifi)); + EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable(shill::kTypeWifi)); + EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWifi)); const size_t kNumShillManagerClientStubImplDevices = 2; EXPECT_EQ(kNumShillManagerClientStubImplDevices, - listener_->entries(flimflam::kDevicesProperty).size()); + listener_->entries(shill::kDevicesProperty).size()); const size_t kNumShillManagerClientStubImplServices = 4; EXPECT_EQ(kNumShillManagerClientStubImplServices, - listener_->entries(flimflam::kServicesProperty).size()); + listener_->entries(shill::kServicesProperty).size()); EXPECT_EQ(0, listener_->errors()); } @@ -307,114 +305,110 @@ TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerTechnologyChanged) { EXPECT_EQ(initial_technology_updates, listener_->technology_list_updates()); // Remove a technology. Updates both the Available and Enabled lists. - manager_test_->RemoveTechnology(flimflam::kTypeWimax); + manager_test_->RemoveTechnology(shill::kTypeWimax); message_loop_.RunUntilIdle(); EXPECT_EQ(initial_technology_updates + 2, listener_->technology_list_updates()); // Add a disabled technology. - manager_test_->AddTechnology(flimflam::kTypeWimax, false); + manager_test_->AddTechnology(shill::kTypeWimax, false); message_loop_.RunUntilIdle(); EXPECT_EQ(initial_technology_updates + 3, listener_->technology_list_updates()); EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable( - flimflam::kTypeWimax)); - EXPECT_FALSE(shill_property_handler_->IsTechnologyEnabled( - flimflam::kTypeWimax)); + shill::kTypeWimax)); + EXPECT_FALSE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWimax)); // Enable the technology. DBusThreadManager::Get()->GetShillManagerClient()->EnableTechnology( - flimflam::kTypeWimax, + shill::kTypeWimax, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); EXPECT_EQ(initial_technology_updates + 4, listener_->technology_list_updates()); - EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled( - flimflam::kTypeWimax)); + EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWimax)); EXPECT_EQ(0, listener_->errors()); } TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerDevicePropertyChanged) { - EXPECT_EQ(1, listener_->list_updates(flimflam::kDevicesProperty)); + EXPECT_EQ(1, listener_->list_updates(shill::kDevicesProperty)); const size_t kNumShillManagerClientStubImplDevices = 2; EXPECT_EQ(kNumShillManagerClientStubImplDevices, - listener_->entries(flimflam::kDevicesProperty).size()); + listener_->entries(shill::kDevicesProperty).size()); // Add a device. const std::string kTestDevicePath("test_wifi_device1"); - AddDevice(flimflam::kTypeWifi, kTestDevicePath); + AddDevice(shill::kTypeWifi, kTestDevicePath); message_loop_.RunUntilIdle(); - EXPECT_EQ(2, listener_->list_updates(flimflam::kDevicesProperty)); + EXPECT_EQ(2, listener_->list_updates(shill::kDevicesProperty)); EXPECT_EQ(kNumShillManagerClientStubImplDevices + 1, - listener_->entries(flimflam::kDevicesProperty).size()); + listener_->entries(shill::kDevicesProperty).size()); // Device changes are not observed. // Remove a device RemoveDevice(kTestDevicePath); message_loop_.RunUntilIdle(); - EXPECT_EQ(3, listener_->list_updates(flimflam::kDevicesProperty)); + EXPECT_EQ(3, listener_->list_updates(shill::kDevicesProperty)); EXPECT_EQ(kNumShillManagerClientStubImplDevices, - listener_->entries(flimflam::kDevicesProperty).size()); + listener_->entries(shill::kDevicesProperty).size()); EXPECT_EQ(0, listener_->errors()); } TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServicePropertyChanged) { - EXPECT_EQ(1, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty)); const size_t kNumShillManagerClientStubImplServices = 4; EXPECT_EQ(kNumShillManagerClientStubImplServices, - listener_->entries(flimflam::kServicesProperty).size()); + listener_->entries(shill::kServicesProperty).size()); // Add an unwatched service. const std::string kTestServicePath("test_wifi_service1"); - AddService(flimflam::kTypeWifi, kTestServicePath, - flimflam::kStateIdle, false); + AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle, false); message_loop_.RunUntilIdle(); // Watched and unwatched services trigger a service list update. - EXPECT_EQ(2, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty)); EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, - listener_->entries(flimflam::kServicesProperty).size()); + listener_->entries(shill::kServicesProperty).size()); // Service receives an initial property update. EXPECT_EQ(1, listener_->initial_property_updates( - flimflam::kServicesProperty)[kTestServicePath]); + shill::kServicesProperty)[kTestServicePath]); // Change a property. base::FundamentalValue scan_interval(3); DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(kTestServicePath), - flimflam::kScanIntervalProperty, + shill::kScanIntervalProperty, scan_interval, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); // Property change triggers an update. EXPECT_EQ(1, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath]); + shill::kServicesProperty)[kTestServicePath]); // Add the existing service to the watch list. - AddService(flimflam::kTypeWifi, kTestServicePath, - flimflam::kStateIdle, true); + AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle, true); message_loop_.RunUntilIdle(); // Service list update should be received when watch list changes. - EXPECT_EQ(2, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty)); // Number of services shouldn't change. EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, - listener_->entries(flimflam::kServicesProperty).size()); + listener_->entries(shill::kServicesProperty).size()); // Change a property. DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(kTestServicePath), - flimflam::kScanIntervalProperty, + shill::kScanIntervalProperty, scan_interval, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); // Property change should trigger another update. EXPECT_EQ(2, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath]); + shill::kServicesProperty)[kTestServicePath]); // Remove a service RemoveService(kTestServicePath); message_loop_.RunUntilIdle(); - EXPECT_EQ(3, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(3, listener_->list_updates(shill::kServicesProperty)); EXPECT_EQ(kNumShillManagerClientStubImplServices, - listener_->entries(flimflam::kServicesProperty).size()); + listener_->entries(shill::kServicesProperty).size()); EXPECT_EQ(0, listener_->errors()); } @@ -426,36 +420,35 @@ TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) { base::StringValue ip_address("192.168.1.1"); DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty( dbus::ObjectPath(kTestIPConfigPath), - flimflam::kAddressProperty, ip_address, + shill::kAddressProperty, ip_address, base::Bind(&DoNothingWithCallStatus)); base::ListValue dns_servers; dns_servers.Append(base::Value::CreateStringValue("192.168.1.100")); dns_servers.Append(base::Value::CreateStringValue("192.168.1.101")); DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty( dbus::ObjectPath(kTestIPConfigPath), - flimflam::kNameServersProperty, dns_servers, + shill::kNameServersProperty, dns_servers, base::Bind(&DoNothingWithCallStatus)); base::FundamentalValue prefixlen(8); DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty( dbus::ObjectPath(kTestIPConfigPath), - flimflam::kPrefixlenProperty, prefixlen, + shill::kPrefixlenProperty, prefixlen, base::Bind(&DoNothingWithCallStatus)); base::StringValue gateway("192.0.0.1"); DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty( dbus::ObjectPath(kTestIPConfigPath), - flimflam::kGatewayProperty, gateway, + shill::kGatewayProperty, gateway, base::Bind(&DoNothingWithCallStatus)); message_loop_.RunUntilIdle(); // Add a service with an empty ipconfig and then update // its ipconfig property. const std::string kTestServicePath1("test_wifi_service1"); - AddService(flimflam::kTypeWifi, kTestServicePath1, - flimflam::kStateIdle, true); + AddService(shill::kTypeWifi, kTestServicePath1, shill::kStateIdle, true); message_loop_.RunUntilIdle(); // This is the initial property update. EXPECT_EQ(1, listener_->initial_property_updates( - flimflam::kServicesProperty)[kTestServicePath1]); + shill::kServicesProperty)[kTestServicePath1]); DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(kTestServicePath1), shill::kIPConfigProperty, @@ -465,39 +458,39 @@ TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) { // IPConfig property change on the service should trigger property updates for // IP Address, DNS, prefixlen, and gateway. EXPECT_EQ(4, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath1]); + shill::kServicesProperty)[kTestServicePath1]); // Now, Add a new watched service with the IPConfig already set. const std::string kTestServicePath2("test_wifi_service2"); - AddServiceWithIPConfig(flimflam::kTypeWifi, kTestServicePath2, - flimflam::kStateIdle, kTestIPConfigPath, true); + AddServiceWithIPConfig(shill::kTypeWifi, kTestServicePath2, + shill::kStateIdle, kTestIPConfigPath, true); message_loop_.RunUntilIdle(); // A watched service with the IPConfig property already set must trigger // property updates for IP Address, DNS, prefixlen, and gateway when added. EXPECT_EQ(4, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath2]); + shill::kServicesProperty)[kTestServicePath2]); } TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceCompleteList) { // Initial list updates. - EXPECT_EQ(1, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty)); EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty)); // Add a new entry to the profile only; should trigger a single list update // for both Services and ServiceCompleteList, and a single property update // for ServiceCompleteList. const std::string kTestServicePath1("stub_wifi_profile_only1"); - AddServiceToProfile(flimflam::kTypeWifi, kTestServicePath1, false); + AddServiceToProfile(shill::kTypeWifi, kTestServicePath1, false); shill_property_handler_->UpdateManagerProperties(); message_loop_.RunUntilIdle(); - EXPECT_EQ(2, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty)); EXPECT_EQ(2, listener_->list_updates(shill::kServiceCompleteListProperty)); EXPECT_EQ(0, listener_->initial_property_updates( - flimflam::kServicesProperty)[kTestServicePath1]); + shill::kServicesProperty)[kTestServicePath1]); EXPECT_EQ(1, listener_->initial_property_updates( shill::kServiceCompleteListProperty)[kTestServicePath1]); EXPECT_EQ(0, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath1]); + shill::kServicesProperty)[kTestServicePath1]); EXPECT_EQ(0, listener_->property_updates( shill::kServiceCompleteListProperty)[kTestServicePath1]); @@ -507,18 +500,18 @@ TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceCompleteList) { // changes, and one for the Request) and one ServiceCompleteList change for // the Request. const std::string kTestServicePath2("stub_wifi_profile_only2"); - AddServiceToProfile(flimflam::kTypeWifi, kTestServicePath2, true); + AddServiceToProfile(shill::kTypeWifi, kTestServicePath2, true); shill_property_handler_->UpdateManagerProperties(); message_loop_.RunUntilIdle(); - EXPECT_EQ(3, listener_->list_updates(flimflam::kServicesProperty)); + EXPECT_EQ(3, listener_->list_updates(shill::kServicesProperty)); EXPECT_EQ(3, listener_->list_updates(shill::kServiceCompleteListProperty)); EXPECT_EQ(1, listener_->initial_property_updates( - flimflam::kServicesProperty)[kTestServicePath2]); + shill::kServicesProperty)[kTestServicePath2]); EXPECT_EQ(1, listener_->initial_property_updates( shill::kServiceCompleteListProperty)[kTestServicePath2]); // Expect one property update for the Profile property of the Network. EXPECT_EQ(1, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath2]); + shill::kServicesProperty)[kTestServicePath2]); EXPECT_EQ(0, listener_->property_updates( shill::kServiceCompleteListProperty)[kTestServicePath2]); @@ -526,14 +519,14 @@ TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceCompleteList) { base::FundamentalValue scan_interval(3); DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( dbus::ObjectPath(kTestServicePath2), - flimflam::kScanIntervalProperty, + shill::kScanIntervalProperty, scan_interval, base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); message_loop_.RunUntilIdle(); // Property change should trigger an update for the Network only; no // property updates pushed by Shill affect Favorites. EXPECT_EQ(2, listener_->property_updates( - flimflam::kServicesProperty)[kTestServicePath2]); + shill::kServicesProperty)[kTestServicePath2]); EXPECT_EQ(0, listener_->property_updates( shill::kServiceCompleteListProperty)[kTestServicePath2]); } diff --git a/chromeos/network/shill_property_util.cc b/chromeos/network/shill_property_util.cc index c97c152..0f736d8 100644 --- a/chromeos/network/shill_property_util.cc +++ b/chromeos/network/shill_property_util.cc @@ -61,8 +61,8 @@ bool CopyStringFromDictionary(const base::DictionaryValue& source, std::string GetNameFromProperties(const std::string& service_path, const base::DictionaryValue& properties) { std::string name, hex_ssid; - properties.GetStringWithoutPathExpansion(flimflam::kNameProperty, &name); - properties.GetStringWithoutPathExpansion(flimflam::kWifiHexSsid, &hex_ssid); + properties.GetStringWithoutPathExpansion(shill::kNameProperty, &name); + properties.GetStringWithoutPathExpansion(shill::kWifiHexSsid, &hex_ssid); if (hex_ssid.empty()) { if (name.empty()) @@ -106,7 +106,7 @@ std::string GetNameFromProperties(const std::string& service_path, // Detect encoding and convert to UTF-8. std::string country_code; - properties.GetStringWithoutPathExpansion(flimflam::kCountryProperty, + properties.GetStringWithoutPathExpansion(shill::kCountryProperty, &country_code); std::string encoding; if (!base::DetectEncoding(ssid, &encoding)) { @@ -156,7 +156,7 @@ scoped_ptr<NetworkUIData> GetUIDataFromValue(const base::Value& ui_data_value) { scoped_ptr<NetworkUIData> GetUIDataFromProperties( const base::DictionaryValue& shill_dictionary) { const base::Value* ui_data_value = NULL; - shill_dictionary.GetWithoutPathExpansion(flimflam::kUIDataProperty, + shill_dictionary.GetWithoutPathExpansion(shill::kUIDataProperty, &ui_data_value); if (!ui_data_value) { VLOG(2) << "Dictionary has no UIData entry."; @@ -174,7 +174,7 @@ void SetUIData(const NetworkUIData& ui_data, ui_data.FillDictionary(&ui_data_dict); std::string ui_data_blob; base::JSONWriter::Write(&ui_data_dict, &ui_data_blob); - shill_dictionary->SetStringWithoutPathExpansion(flimflam::kUIDataProperty, + shill_dictionary->SetStringWithoutPathExpansion(shill::kUIDataProperty, ui_data_blob); } @@ -183,46 +183,44 @@ bool CopyIdentifyingProperties(const base::DictionaryValue& service_properties, bool success = true; // GUID is optional. - CopyStringFromDictionary(service_properties, flimflam::kGuidProperty, dest); + CopyStringFromDictionary(service_properties, shill::kGuidProperty, dest); std::string type; - service_properties.GetStringWithoutPathExpansion(flimflam::kTypeProperty, - &type); + service_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type); success &= !type.empty(); - dest->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type); - if (type == flimflam::kTypeWifi) { + dest->SetStringWithoutPathExpansion(shill::kTypeProperty, type); + if (type == shill::kTypeWifi) { success &= CopyStringFromDictionary( - service_properties, flimflam::kSecurityProperty, dest); + service_properties, shill::kSecurityProperty, dest); success &= CopyStringFromDictionary( - service_properties, flimflam::kSSIDProperty, dest); + service_properties, shill::kSSIDProperty, dest); success &= CopyStringFromDictionary( - service_properties, flimflam::kModeProperty, dest); - } else if (type == flimflam::kTypeVPN) { + service_properties, shill::kModeProperty, dest); + } else if (type == shill::kTypeVPN) { success &= CopyStringFromDictionary( - service_properties, flimflam::kNameProperty, dest); + service_properties, shill::kNameProperty, dest); // VPN Provider values are read from the "Provider" dictionary, but written // with the keys "Provider.Type" and "Provider.Host". const base::DictionaryValue* provider_properties = NULL; if (!service_properties.GetDictionaryWithoutPathExpansion( - flimflam::kProviderProperty, &provider_properties)) { + shill::kProviderProperty, &provider_properties)) { NET_LOG_ERROR("CopyIdentifyingProperties", "Missing VPN provider dict"); return false; } std::string vpn_provider_type; - provider_properties->GetStringWithoutPathExpansion(flimflam::kTypeProperty, + provider_properties->GetStringWithoutPathExpansion(shill::kTypeProperty, &vpn_provider_type); success &= !vpn_provider_type.empty(); - dest->SetStringWithoutPathExpansion(flimflam::kProviderTypeProperty, + dest->SetStringWithoutPathExpansion(shill::kProviderTypeProperty, vpn_provider_type); std::string vpn_provider_host; - provider_properties->GetStringWithoutPathExpansion(flimflam::kHostProperty, + provider_properties->GetStringWithoutPathExpansion(shill::kHostProperty, &vpn_provider_host); success &= !vpn_provider_host.empty(); - dest->SetStringWithoutPathExpansion(flimflam::kProviderHostProperty, + dest->SetStringWithoutPathExpansion(shill::kProviderHostProperty, vpn_provider_host); - } else if (type == flimflam::kTypeEthernet || - type == shill::kTypeEthernetEap) { + } else if (type == shill::kTypeEthernet || type == shill::kTypeEthernetEap) { // Ethernet and EthernetEAP don't have any additional identifying // properties. } else { @@ -258,12 +256,12 @@ struct ShillToBitFlagEntry { const char* shill_network_type; NetworkTypeBitFlag bit_flag; } shill_type_to_flag[] = { - { flimflam::kTypeEthernet, kNetworkTypeEthernet }, + { shill::kTypeEthernet, kNetworkTypeEthernet }, { shill::kTypeEthernetEap, kNetworkTypeEthernetEap }, - { flimflam::kTypeWifi, kNetworkTypeWifi }, - { flimflam::kTypeWimax, kNetworkTypeWimax }, - { flimflam::kTypeCellular, kNetworkTypeCellular }, - { flimflam::kTypeVPN, kNetworkTypeVPN } + { shill::kTypeWifi, kNetworkTypeWifi }, + { shill::kTypeWimax, kNetworkTypeWimax }, + { shill::kTypeCellular, kNetworkTypeCellular }, + { shill::kTypeVPN, kNetworkTypeVPN } }; NetworkTypeBitFlag ShillNetworkTypeToFlag(const std::string& shill_type) { diff --git a/chromeos/network/shill_property_util.h b/chromeos/network/shill_property_util.h index e8485ba..9072a28 100644 --- a/chromeos/network/shill_property_util.h +++ b/chromeos/network/shill_property_util.h @@ -75,7 +75,7 @@ class CHROMEOS_EXPORT NetworkTypePattern { // Matches only networks of exactly the type |shill_network_type|, which must // be one of the types defined in service_constants.h (e.g. - // flimflam::kTypeWifi). + // shill::kTypeWifi). // Note: Shill distinguishes Ethernet without EAP from Ethernet with EAP. If // unsure, better use one of the matchers above. static NetworkTypePattern Primitive(const std::string& shill_network_type); diff --git a/chromeos/network/shill_property_util_unittest.cc b/chromeos/network/shill_property_util_unittest.cc index ffbefe3..2d8b764 100644 --- a/chromeos/network/shill_property_util_unittest.cc +++ b/chromeos/network/shill_property_util_unittest.cc @@ -42,14 +42,14 @@ class NetworkTypePatternTest : public testing::Test { } // namespace TEST_F(NetworkTypePatternTest, MatchesType) { - EXPECT_TRUE(mobile_.MatchesType(flimflam::kTypeCellular)); - EXPECT_TRUE(mobile_.MatchesType(flimflam::kTypeWimax)); - EXPECT_FALSE(mobile_.MatchesType(flimflam::kTypeWifi)); - - EXPECT_TRUE(wireless_.MatchesType(flimflam::kTypeWifi)); - EXPECT_TRUE(wireless_.MatchesType(flimflam::kTypeCellular)); - EXPECT_TRUE(wireless_.MatchesType(flimflam::kTypeWimax)); - EXPECT_FALSE(wireless_.MatchesType(flimflam::kTypeEthernet)); + EXPECT_TRUE(mobile_.MatchesType(shill::kTypeCellular)); + EXPECT_TRUE(mobile_.MatchesType(shill::kTypeWimax)); + EXPECT_FALSE(mobile_.MatchesType(shill::kTypeWifi)); + + EXPECT_TRUE(wireless_.MatchesType(shill::kTypeWifi)); + EXPECT_TRUE(wireless_.MatchesType(shill::kTypeCellular)); + EXPECT_TRUE(wireless_.MatchesType(shill::kTypeWimax)); + EXPECT_FALSE(wireless_.MatchesType(shill::kTypeEthernet)); } TEST_F(NetworkTypePatternTest, MatchesPattern) { @@ -83,12 +83,12 @@ TEST_F(NetworkTypePatternTest, Equals) { TEST_F(NetworkTypePatternTest, Primitive) { const NetworkTypePattern primitive_cellular = - NetworkTypePattern::Primitive(flimflam::kTypeCellular); + NetworkTypePattern::Primitive(shill::kTypeCellular); EXPECT_TRUE(cellular_.Equals(primitive_cellular)); EXPECT_TRUE(primitive_cellular.Equals(cellular_)); const NetworkTypePattern primitive_wimax = - NetworkTypePattern::Primitive(flimflam::kTypeWimax); + NetworkTypePattern::Primitive(shill::kTypeWimax); EXPECT_TRUE(wimax_.Equals(primitive_wimax)); EXPECT_TRUE(primitive_wimax.Equals(wimax_)); } |