shill: cellular: Deprecate flimflam namespace.
CL:170123 moves all DBus service constants from the flimflam namespace
to the shill namespace. This CL removes the use of the flimflam
namespace in cellular code.
BUG=chromium:295425
CQ-DEPEND=CL:170123
TEST=Unit tests and trybot runs on release builders.
Change-Id: I751c66c9d1d727007b8cd5510a8f76b094b6352b
Reviewed-on: https://chromium-review.googlesource.com/170223
Reviewed-by: Ben Chan <benchan@chromium.org>
Tested-by: Ben Chan <benchan@chromium.org>
Commit-Queue: Ben Chan <benchan@chromium.org>
diff --git a/cellular.cc b/cellular.cc
index 5abb71d..fb2d649 100644
--- a/cellular.cc
+++ b/cellular.cc
@@ -66,27 +66,27 @@
}
const string &Cellular::Operator::GetName() const {
- return dict_.find(flimflam::kOperatorNameKey)->second;
+ return dict_.find(kOperatorNameKey)->second;
}
void Cellular::Operator::SetName(const string &name) {
- dict_[flimflam::kOperatorNameKey] = name;
+ dict_[kOperatorNameKey] = name;
}
const string &Cellular::Operator::GetCode() const {
- return dict_.find(flimflam::kOperatorCodeKey)->second;
+ return dict_.find(kOperatorCodeKey)->second;
}
void Cellular::Operator::SetCode(const string &code) {
- dict_[flimflam::kOperatorCodeKey] = code;
+ dict_[kOperatorCodeKey] = code;
}
const string &Cellular::Operator::GetCountry() const {
- return dict_.find(flimflam::kOperatorCountryKey)->second;
+ return dict_.find(kOperatorCountryKey)->second;
}
void Cellular::Operator::SetCountry(const string &country) {
- dict_[flimflam::kOperatorCountryKey] = country;
+ dict_[kOperatorCountryKey] = country;
}
const Stringmap &Cellular::Operator::ToDict() const {
@@ -124,15 +124,15 @@
is_ppp_authenticating_(false) {
PropertyStore *store = this->mutable_store();
// TODO(jglasgow): kDBusConnectionProperty is deprecated.
- store->RegisterConstString(flimflam::kDBusConnectionProperty, &dbus_owner_);
- store->RegisterConstString(flimflam::kDBusServiceProperty, &dbus_service_);
- store->RegisterConstString(flimflam::kDBusObjectProperty, &dbus_path_);
- HelpRegisterConstDerivedString(flimflam::kTechnologyFamilyProperty,
+ store->RegisterConstString(kDBusConnectionProperty, &dbus_owner_);
+ store->RegisterConstString(kDBusServiceProperty, &dbus_service_);
+ store->RegisterConstString(kDBusObjectProperty, &dbus_path_);
+ HelpRegisterConstDerivedString(kTechnologyFamilyProperty,
&Cellular::GetTechnologyFamily);
- HelpRegisterDerivedBool(flimflam::kCellularAllowRoamingProperty,
+ HelpRegisterDerivedBool(kCellularAllowRoamingProperty,
&Cellular::GetAllowRoaming,
&Cellular::SetAllowRoaming);
- store->RegisterConstStringmap(flimflam::kHomeProviderProperty,
+ store->RegisterConstStringmap(kHomeProviderProperty,
&home_provider_.ToDict());
// For now, only a single capability is supported.
@@ -545,7 +545,7 @@
}
if (!capability_->AllowRoaming() &&
- service_->roaming_state() == flimflam::kRoamingStateRoaming) {
+ service_->roaming_state() == kRoamingStateRoaming) {
Error::PopulateAndLog(error, Error::kNotOnHomeNetwork,
"Roaming disallowed; connection request ignored.");
return;
@@ -596,7 +596,7 @@
LOG(INFO) << "Disconnecting due to no cellular service.";
Disconnect(NULL);
} else if (!capability_->AllowRoaming() &&
- service_->roaming_state() == flimflam::kRoamingStateRoaming) {
+ service_->roaming_state() == kRoamingStateRoaming) {
LOG(INFO) << "Disconnecting due to roaming.";
Disconnect(NULL);
} else {
@@ -790,11 +790,11 @@
// incorporate provider preferences when evaluating if a disconnect
// is required.
if (!capability_->AllowRoaming() &&
- capability_->GetRoamingStateString() == flimflam::kRoamingStateRoaming) {
+ capability_->GetRoamingStateString() == kRoamingStateRoaming) {
Error error;
Disconnect(&error);
}
- adaptor()->EmitBoolChanged(flimflam::kCellularAllowRoamingProperty, value);
+ adaptor()->EmitBoolChanged(kCellularAllowRoamingProperty, value);
return true;
}
diff --git a/cellular_capability.h b/cellular_capability.h
index c4ec812..219c6df 100644
--- a/cellular_capability.h
+++ b/cellular_capability.h
@@ -156,7 +156,7 @@
//
// Subclasses should implement this by fetching scan results
// asynchronously. When the results are ready, update the
- // flimflam::kFoundNetworksProperty and send a property change
+ // kFoundNetworksProperty and send a property change
// notification. Finally, callback must be invoked to inform the
// caller that the scan has completed.
//
diff --git a/cellular_capability_cdma.cc b/cellular_capability_cdma.cc
index 0040465..585b92c 100644
--- a/cellular_capability_cdma.cc
+++ b/cellular_capability_cdma.cc
@@ -40,7 +40,7 @@
prl_version_(0) {
SLOG(Cellular, 2) << "Cellular capability constructed: CDMA";
PropertyStore *store = cellular->mutable_store();
- store->RegisterConstUint16(flimflam::kPRLVersionProperty, &prl_version_);
+ store->RegisterConstUint16(kPRLVersionProperty, &prl_version_);
}
void CellularCapabilityCDMA::InitProxies() {
@@ -199,15 +199,15 @@
string CellularCapabilityCDMA::GetActivationStateString(uint32 state) {
switch (state) {
case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED:
- return flimflam::kActivationStateActivated;
+ return kActivationStateActivated;
case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING:
- return flimflam::kActivationStateActivating;
+ return kActivationStateActivating;
case MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED:
- return flimflam::kActivationStateNotActivated;
+ return kActivationStateNotActivated;
case MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED:
- return flimflam::kActivationStatePartiallyActivated;
+ return kActivationStatePartiallyActivated;
default:
- return flimflam::kActivationStateUnknown;
+ return kActivationStateUnknown;
}
}
@@ -215,18 +215,18 @@
string CellularCapabilityCDMA::GetActivationErrorString(uint32 error) {
switch (error) {
case MM_MODEM_CDMA_ACTIVATION_ERROR_WRONG_RADIO_INTERFACE:
- return flimflam::kErrorNeedEvdo;
+ return kErrorNeedEvdo;
case MM_MODEM_CDMA_ACTIVATION_ERROR_ROAMING:
- return flimflam::kErrorNeedHomeNetwork;
+ return kErrorNeedHomeNetwork;
case MM_MODEM_CDMA_ACTIVATION_ERROR_COULD_NOT_CONNECT:
case MM_MODEM_CDMA_ACTIVATION_ERROR_SECURITY_AUTHENTICATION_FAILED:
case MM_MODEM_CDMA_ACTIVATION_ERROR_PROVISIONING_FAILED:
- return flimflam::kErrorOtaspFailed;
+ return kErrorOtaspFailed;
case MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR:
return "";
case MM_MODEM_CDMA_ACTIVATION_ERROR_NO_SIGNAL:
default:
- return flimflam::kErrorActivationFailed;
+ return kErrorActivationFailed;
}
}
@@ -263,10 +263,10 @@
string CellularCapabilityCDMA::GetNetworkTechnologyString() const {
if (registration_state_evdo_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) {
- return flimflam::kNetworkTechnologyEvdo;
+ return kNetworkTechnologyEvdo;
}
if (registration_state_1x_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) {
- return flimflam::kNetworkTechnology1Xrtt;
+ return kNetworkTechnology1Xrtt;
}
return "";
}
@@ -281,13 +281,13 @@
case MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED:
break;
case MM_MODEM_CDMA_REGISTRATION_STATE_HOME:
- return flimflam::kRoamingStateHome;
+ return kRoamingStateHome;
case MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING:
- return flimflam::kRoamingStateRoaming;
+ return kRoamingStateRoaming;
default:
NOTREACHED();
}
- return flimflam::kRoamingStateUnknown;
+ return kRoamingStateUnknown;
}
void CellularCapabilityCDMA::GetSignalQuality() {
diff --git a/cellular_capability_cdma.h b/cellular_capability_cdma.h
index 8495a76..81b8998 100644
--- a/cellular_capability_cdma.h
+++ b/cellular_capability_cdma.h
@@ -43,7 +43,7 @@
virtual std::string GetRoamingStateString() const;
virtual void GetSignalQuality();
virtual std::string GetTypeString() const {
- return flimflam::kTechnologyFamilyCdma;
+ return kTechnologyFamilyCdma;
}
virtual bool AllowRoaming();
virtual void GetRegistrationState();
diff --git a/cellular_capability_cdma_unittest.cc b/cellular_capability_cdma_unittest.cc
index fe9193e..d32dda5 100644
--- a/cellular_capability_cdma_unittest.cc
+++ b/cellular_capability_cdma_unittest.cc
@@ -140,7 +140,7 @@
const unsigned int CellularCapabilityCDMATest::kStrength = 90;
TEST_F(CellularCapabilityCDMATest, PropertyStore) {
- EXPECT_TRUE(cellular_->store().Contains(flimflam::kPRLVersionProperty));
+ EXPECT_TRUE(cellular_->store().Contains(kPRLVersionProperty));
}
TEST_F(CellularCapabilityCDMATest, Activate) {
@@ -156,7 +156,7 @@
Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING,
capability_->activation_state());
- EXPECT_EQ(flimflam::kActivationStateActivating,
+ EXPECT_EQ(kActivationStateActivating,
cellular_->service()->activation_state());
EXPECT_EQ("", cellular_->service()->error());
}
@@ -189,7 +189,7 @@
// Now the modem is actually activating.
EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING,
capability_->activation_state());
- EXPECT_EQ(flimflam::kActivationStateActivating,
+ EXPECT_EQ(kActivationStateActivating,
cellular_->service()->activation_state());
EXPECT_EQ("", cellular_->service()->error());
EXPECT_FALSE(IsActivationStarting());
@@ -220,10 +220,9 @@
capability_->DisconnectCleanup();
EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
capability_->activation_state());
- EXPECT_EQ(flimflam::kActivationStateNotActivated,
+ EXPECT_EQ(kActivationStateNotActivated,
cellular_->service()->activation_state());
- EXPECT_EQ(flimflam::kErrorActivationFailed,
- cellular_->service()->error());
+ EXPECT_EQ(kErrorActivationFailed, cellular_->service()->error());
EXPECT_FALSE(IsActivationStarting());
EXPECT_FALSE(capability_->IsActivating());
}
@@ -241,52 +240,52 @@
Bind(&CellularCapabilityCDMATest::TestCallback, Unretained(this)));
EXPECT_EQ(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED,
capability_->activation_state());
- EXPECT_EQ(flimflam::kActivationStateNotActivated,
+ EXPECT_EQ(kActivationStateNotActivated,
cellular_->service()->activation_state());
- EXPECT_EQ(flimflam::kErrorActivationFailed,
+ EXPECT_EQ(kErrorActivationFailed,
cellular_->service()->error());
}
TEST_F(CellularCapabilityCDMATest, GetActivationStateString) {
- EXPECT_EQ(flimflam::kActivationStateActivated,
+ EXPECT_EQ(kActivationStateActivated,
CellularCapabilityCDMA::GetActivationStateString(
MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED));
- EXPECT_EQ(flimflam::kActivationStateActivating,
+ EXPECT_EQ(kActivationStateActivating,
CellularCapabilityCDMA::GetActivationStateString(
MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING));
- EXPECT_EQ(flimflam::kActivationStateNotActivated,
+ EXPECT_EQ(kActivationStateNotActivated,
CellularCapabilityCDMA::GetActivationStateString(
MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED));
- EXPECT_EQ(flimflam::kActivationStatePartiallyActivated,
+ EXPECT_EQ(kActivationStatePartiallyActivated,
CellularCapabilityCDMA::GetActivationStateString(
MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED));
- EXPECT_EQ(flimflam::kActivationStateUnknown,
+ EXPECT_EQ(kActivationStateUnknown,
CellularCapabilityCDMA::GetActivationStateString(123));
}
TEST_F(CellularCapabilityCDMATest, GetActivationErrorString) {
- EXPECT_EQ(flimflam::kErrorNeedEvdo,
+ EXPECT_EQ(kErrorNeedEvdo,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_WRONG_RADIO_INTERFACE));
- EXPECT_EQ(flimflam::kErrorNeedHomeNetwork,
+ EXPECT_EQ(kErrorNeedHomeNetwork,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_ROAMING));
- EXPECT_EQ(flimflam::kErrorOtaspFailed,
+ EXPECT_EQ(kErrorOtaspFailed,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_COULD_NOT_CONNECT));
- EXPECT_EQ(flimflam::kErrorOtaspFailed,
+ EXPECT_EQ(kErrorOtaspFailed,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_SECURITY_AUTHENTICATION_FAILED));
- EXPECT_EQ(flimflam::kErrorOtaspFailed,
+ EXPECT_EQ(kErrorOtaspFailed,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_PROVISIONING_FAILED));
EXPECT_EQ("",
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR));
- EXPECT_EQ(flimflam::kErrorActivationFailed,
+ EXPECT_EQ(kErrorActivationFailed,
CellularCapabilityCDMA::GetActivationErrorString(
MM_MODEM_CDMA_ACTIVATION_ERROR_NO_SIGNAL));
- EXPECT_EQ(flimflam::kErrorActivationFailed,
+ EXPECT_EQ(kErrorActivationFailed,
CellularCapabilityCDMA::GetActivationErrorString(1234));
}
@@ -317,33 +316,33 @@
TEST_F(CellularCapabilityCDMATest, GetNetworkTechnologyString) {
EXPECT_EQ("", capability_->GetNetworkTechnologyString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
- EXPECT_EQ(flimflam::kNetworkTechnologyEvdo,
+ EXPECT_EQ(kNetworkTechnologyEvdo,
capability_->GetNetworkTechnologyString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
- EXPECT_EQ(flimflam::kNetworkTechnology1Xrtt,
+ EXPECT_EQ(kNetworkTechnology1Xrtt,
capability_->GetNetworkTechnologyString());
}
TEST_F(CellularCapabilityCDMATest, GetRoamingStateString) {
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
+ EXPECT_EQ(kRoamingStateUnknown,
capability_->GetRoamingStateString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
+ EXPECT_EQ(kRoamingStateUnknown,
capability_->GetRoamingStateString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
- EXPECT_EQ(flimflam::kRoamingStateHome, capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateHome, capability_->GetRoamingStateString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
- EXPECT_EQ(flimflam::kRoamingStateRoaming,
+ EXPECT_EQ(kRoamingStateRoaming,
capability_->GetRoamingStateString());
SetRegistrationStateEVDO(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN);
SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED);
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
+ EXPECT_EQ(kRoamingStateUnknown,
capability_->GetRoamingStateString());
SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_HOME);
- EXPECT_EQ(flimflam::kRoamingStateHome, capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateHome, capability_->GetRoamingStateString());
SetRegistrationState1x(MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING);
- EXPECT_EQ(flimflam::kRoamingStateRoaming,
+ EXPECT_EQ(kRoamingStateRoaming,
capability_->GetRoamingStateString());
}
diff --git a/cellular_capability_classic.cc b/cellular_capability_classic.cc
index bf40872..6883a07 100644
--- a/cellular_capability_classic.cc
+++ b/cellular_capability_classic.cc
@@ -68,21 +68,18 @@
scanning_supported_(false),
weak_ptr_factory_(this) {
PropertyStore *store = cellular->mutable_store();
- store->RegisterConstString(flimflam::kCarrierProperty, &carrier_);
- store->RegisterConstBool(flimflam::kSupportNetworkScanProperty,
- &scanning_supported_);
- store->RegisterConstString(flimflam::kEsnProperty, &esn_);
- store->RegisterConstString(flimflam::kFirmwareRevisionProperty,
- &firmware_revision_);
- store->RegisterConstString(flimflam::kHardwareRevisionProperty,
- &hardware_revision_);
- store->RegisterConstString(flimflam::kImeiProperty, &imei_);
- store->RegisterConstString(flimflam::kImsiProperty, &imsi_);
- store->RegisterConstString(flimflam::kManufacturerProperty, &manufacturer_);
- store->RegisterConstString(flimflam::kMdnProperty, &mdn_);
- store->RegisterConstString(flimflam::kMeidProperty, &meid_);
- store->RegisterConstString(flimflam::kMinProperty, &min_);
- store->RegisterConstString(flimflam::kModelIDProperty, &model_id_);
+ store->RegisterConstString(kCarrierProperty, &carrier_);
+ store->RegisterConstBool(kSupportNetworkScanProperty, &scanning_supported_);
+ store->RegisterConstString(kEsnProperty, &esn_);
+ store->RegisterConstString(kFirmwareRevisionProperty, &firmware_revision_);
+ store->RegisterConstString(kHardwareRevisionProperty, &hardware_revision_);
+ store->RegisterConstString(kImeiProperty, &imei_);
+ store->RegisterConstString(kImsiProperty, &imsi_);
+ store->RegisterConstString(kManufacturerProperty, &manufacturer_);
+ store->RegisterConstString(kMdnProperty, &mdn_);
+ store->RegisterConstString(kMeidProperty, &meid_);
+ store->RegisterConstString(kMinProperty, &min_);
+ store->RegisterConstString(kModelIDProperty, &model_id_);
// This class is currently instantiated only for Gobi modems so setup the
// supported carriers list appropriately and expose it over RPC.
diff --git a/cellular_capability_classic_unittest.cc b/cellular_capability_classic_unittest.cc
index b6115c0..1692726 100644
--- a/cellular_capability_classic_unittest.cc
+++ b/cellular_capability_classic_unittest.cc
@@ -322,10 +322,10 @@
{
InSequence seq;
- EXPECT_CALL(*device_adaptor_, EmitBoolChanged(
- flimflam::kCellularAllowRoamingProperty, true));
- EXPECT_CALL(*device_adaptor_, EmitBoolChanged(
- flimflam::kCellularAllowRoamingProperty, false));
+ EXPECT_CALL(*device_adaptor_,
+ EmitBoolChanged(kCellularAllowRoamingProperty, true));
+ EXPECT_CALL(*device_adaptor_,
+ EmitBoolChanged(kCellularAllowRoamingProperty, false));
}
cellular_->state_ = Cellular::kStateConnected;
@@ -360,12 +360,12 @@
}
MATCHER_P(HasApn, apn, "") {
- DBusPropertiesMap::const_iterator it = arg.find(flimflam::kApnProperty);
+ DBusPropertiesMap::const_iterator it = arg.find(kApnProperty);
return it != arg.end() && apn == it->second.reader().get_string();
}
MATCHER(HasNoApn, "") {
- return arg.find(flimflam::kApnProperty) == arg.end();
+ return arg.find(kApnProperty) == arg.end();
}
TEST_F(CellularCapabilityTest, TryApns) {
@@ -400,11 +400,11 @@
Error error;
Stringmap apn_info;
DBusPropertiesMap props;
- apn_info[flimflam::kApnProperty] = kSuppliedApn;
+ apn_info[kApnProperty] = kSuppliedApn;
cellular_->service()->SetApn(apn_info, &error);
apn_info.clear();
- apn_info[flimflam::kApnProperty] = kLastGoodApn;
+ apn_info[kApnProperty] = kLastGoodApn;
cellular_->service()->SetLastGoodApn(apn_info);
capability_->SetupConnectProperties(&props);
@@ -412,8 +412,8 @@
// the user-supplied APN, plus the 4 APNs from the mobile
// provider info database.
EXPECT_EQ(6, gsm_capability->apn_try_list_.size());
- EXPECT_FALSE(props.find(flimflam::kApnProperty) == props.end());
- EXPECT_EQ(kLastGoodApn, props[flimflam::kApnProperty].reader().get_string());
+ EXPECT_FALSE(props.find(kApnProperty) == props.end());
+ EXPECT_EQ(kLastGoodApn, props[kApnProperty].reader().get_string());
SetSimpleProxy();
capability_->Connect(props, &error, ResultCallback());
diff --git a/cellular_capability_gsm.cc b/cellular_capability_gsm.cc
index 4fe8f0e..6844ef1 100644
--- a/cellular_capability_gsm.cc
+++ b/cellular_capability_gsm.cc
@@ -66,20 +66,16 @@
sim_present_(false) {
SLOG(Cellular, 2) << "Cellular capability constructed: GSM";
PropertyStore *store = cellular->mutable_store();
- store->RegisterConstString(flimflam::kSelectedNetworkProperty,
- &selected_network_);
- store->RegisterConstStringmaps(flimflam::kFoundNetworksProperty,
- &found_networks_);
+ store->RegisterConstString(kSelectedNetworkProperty, &selected_network_);
+ store->RegisterConstStringmaps(kFoundNetworksProperty, &found_networks_);
store->RegisterConstBool(shill::kProviderRequiresRoamingProperty,
&provider_requires_roaming_);
- store->RegisterConstBool(flimflam::kScanningProperty, &scanning_);
- store->RegisterUint16(flimflam::kScanIntervalProperty, &scan_interval_);
+ store->RegisterConstBool(kScanningProperty, &scanning_);
+ store->RegisterUint16(kScanIntervalProperty, &scan_interval_);
store->RegisterConstBool(shill::kSIMPresentProperty, &sim_present_);
HelpRegisterConstDerivedKeyValueStore(
- flimflam::kSIMLockStatusProperty,
- &CellularCapabilityGSM::SimLockStatusToProperty);
- store->RegisterConstStringmaps(flimflam::kCellularApnListProperty,
- &apn_list_);
+ kSIMLockStatusProperty, &CellularCapabilityGSM::SimLockStatusToProperty);
+ store->RegisterConstStringmaps(kCellularApnListProperty, &apn_list_);
scanning_supported_ = true;
// TODO(benchan): This is a hack to initialize the GSM card proxy for GetIMSI
@@ -101,10 +97,9 @@
KeyValueStore CellularCapabilityGSM::SimLockStatusToProperty(Error */*error*/) {
KeyValueStore status;
- status.SetBool(flimflam::kSIMLockEnabledProperty, sim_lock_status_.enabled);
- status.SetString(flimflam::kSIMLockTypeProperty, sim_lock_status_.lock_type);
- status.SetUint(flimflam::kSIMLockRetriesLeftProperty,
- sim_lock_status_.retries_left);
+ status.SetBool(kSIMLockEnabledProperty, sim_lock_status_.enabled);
+ status.SetString(kSIMLockTypeProperty, sim_lock_status_.lock_type);
+ status.SetUint(kSIMLockRetriesLeftProperty, sim_lock_status_.retries_left);
return status;
}
@@ -224,11 +219,9 @@
// If IMSI is available, base the service's storage identifier on it.
if (!imsi_.empty()) {
cellular()->service()->SetStorageIdentifier(
- string(flimflam::kTypeCellular) + "_" +
- cellular()->address() + "_" + imsi_);
+ string(kTypeCellular) + "_" + cellular()->address() + "_" + imsi_);
}
- cellular()->service()->SetActivationState(
- flimflam::kActivationStateActivated);
+ cellular()->service()->SetActivationState(kActivationStateActivated);
UpdateServingOperator();
}
@@ -278,16 +271,15 @@
// Leave the APN at the front of the list, so that it can be recorded
// if the connect attempt succeeds.
Stringmap apn_info = apn_try_list_.front();
- SLOG(Cellular, 2) << __func__ << ": Using APN "
- << apn_info[flimflam::kApnProperty];
+ SLOG(Cellular, 2) << __func__ << ": Using APN " << apn_info[kApnProperty];
(*properties)[kConnectPropertyApn].writer().append_string(
- apn_info[flimflam::kApnProperty].c_str());
- if (ContainsKey(apn_info, flimflam::kApnUsernameProperty))
+ apn_info[kApnProperty].c_str());
+ if (ContainsKey(apn_info, kApnUsernameProperty))
(*properties)[kConnectPropertyApnUsername].writer().append_string(
- apn_info[flimflam::kApnUsernameProperty].c_str());
- if (ContainsKey(apn_info, flimflam::kApnPasswordProperty))
+ apn_info[kApnUsernameProperty].c_str());
+ if (ContainsKey(apn_info, kApnPasswordProperty))
(*properties)[kConnectPropertyApnPassword].writer().append_string(
- apn_info[flimflam::kApnPasswordProperty].c_str());
+ apn_info[kApnPasswordProperty].c_str());
}
}
@@ -549,13 +541,13 @@
Stringmap props;
mobile_apn *apn = home_provider_->apns[i];
if (apn->value) {
- props[flimflam::kApnProperty] = apn->value;
+ props[kApnProperty] = apn->value;
}
if (apn->username) {
- props[flimflam::kApnUsernameProperty] = apn->username;
+ props[kApnUsernameProperty] = apn->username;
}
if (apn->password) {
- props[flimflam::kApnPasswordProperty] = apn->password;
+ props[kApnPasswordProperty] = apn->password;
}
// Find the first localized and non-localized name, if any.
const localized_name *lname = NULL;
@@ -570,17 +562,17 @@
}
}
if (name) {
- props[flimflam::kApnNameProperty] = name->name;
+ props[kApnNameProperty] = name->name;
}
if (lname) {
- props[flimflam::kApnLocalizedNameProperty] = lname->name;
- props[flimflam::kApnLanguageProperty] = lname->lang;
+ props[kApnLocalizedNameProperty] = lname->name;
+ props[kApnLanguageProperty] = lname->lang;
}
apn_list_.push_back(props);
}
if (cellular()->adaptor()) {
cellular()->adaptor()->EmitStringmapsChanged(
- flimflam::kCellularApnListProperty, apn_list_);
+ kCellularApnListProperty, apn_list_);
} else {
LOG(ERROR) << "Null RPC service adaptor.";
}
@@ -688,8 +680,7 @@
network_proxy_->Scan(error, cb, kTimeoutScan);
if (!error->IsFailure()) {
scanning_ = true;
- cellular()->adaptor()->EmitBoolChanged(flimflam::kScanningProperty,
- scanning_);
+ cellular()->adaptor()->EmitBoolChanged(kScanningProperty, scanning_);
}
}
@@ -704,8 +695,7 @@
//
// TODO(jglasgow): fix error handling
scanning_ = false;
- cellular()->adaptor()->EmitBoolChanged(flimflam::kScanningProperty,
- scanning_);
+ cellular()->adaptor()->EmitBoolChanged(kScanningProperty, scanning_);
found_networks_.clear();
if (!error.IsFailure()) {
for (GSMScanResults::const_iterator it = results.begin();
@@ -713,7 +703,7 @@
found_networks_.push_back(ParseScanResult(*it));
}
}
- cellular()->adaptor()->EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
+ cellular()->adaptor()->EmitStringmapsChanged(kFoundNetworksProperty,
found_networks_);
if (!callback.is_null())
callback.Run(error);
@@ -732,13 +722,13 @@
"forbidden",
};
static const char * const kTechnologyString[] = {
- flimflam::kNetworkTechnologyGsm,
+ kNetworkTechnologyGsm,
"GSM Compact",
- flimflam::kNetworkTechnologyUmts,
- flimflam::kNetworkTechnologyEdge,
+ kNetworkTechnologyUmts,
+ kNetworkTechnologyEdge,
"HSDPA",
"HSUPA",
- flimflam::kNetworkTechnologyHspa,
+ kNetworkTechnologyHspa,
};
SLOG(Cellular, 2) << "Network property: " << it->first << " = "
<< it->second;
@@ -747,22 +737,22 @@
if (base::StringToInt(it->second, &status) &&
status >= 0 &&
status < static_cast<int>(arraysize(kStatusString))) {
- parsed[flimflam::kStatusProperty] = kStatusString[status];
+ parsed[kStatusProperty] = kStatusString[status];
} else {
LOG(ERROR) << "Unexpected status value: " << it->second;
}
} else if (it->first == kNetworkPropertyID) {
- parsed[flimflam::kNetworkIdProperty] = it->second;
+ parsed[kNetworkIdProperty] = it->second;
} else if (it->first == kNetworkPropertyLongName) {
- parsed[flimflam::kLongNameProperty] = it->second;
+ parsed[kLongNameProperty] = it->second;
} else if (it->first == kNetworkPropertyShortName) {
- parsed[flimflam::kShortNameProperty] = it->second;
+ parsed[kShortNameProperty] = it->second;
} else if (it->first == kNetworkPropertyAccessTechnology) {
int tech = 0;
if (base::StringToInt(it->second, &tech) &&
tech >= 0 &&
tech < static_cast<int>(arraysize(kTechnologyString))) {
- parsed[flimflam::kTechnologyProperty] = kTechnologyString[tech];
+ parsed[kTechnologyProperty] = kTechnologyString[tech];
} else {
LOG(ERROR) << "Unexpected technology value: " << it->second;
}
@@ -772,17 +762,17 @@
}
// If the long name is not available but the network ID is, look up the long
// name in the mobile provider database.
- if ((!ContainsKey(parsed, flimflam::kLongNameProperty) ||
- parsed[flimflam::kLongNameProperty].empty()) &&
- ContainsKey(parsed, flimflam::kNetworkIdProperty)) {
+ if ((!ContainsKey(parsed, kLongNameProperty) ||
+ parsed[kLongNameProperty].empty()) &&
+ ContainsKey(parsed, kNetworkIdProperty)) {
mobile_provider *provider =
mobile_provider_lookup_by_network(
modem_info()->provider_db(),
- parsed[flimflam::kNetworkIdProperty].c_str());
+ parsed[kNetworkIdProperty].c_str());
if (provider) {
const char *long_name = mobile_provider_get_name(provider);
if (long_name && *long_name) {
- parsed[flimflam::kLongNameProperty] = long_name;
+ parsed[kLongNameProperty] = long_name;
}
}
}
@@ -800,19 +790,19 @@
switch (access_technology_) {
case MM_MODEM_GSM_ACCESS_TECH_GSM:
case MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT:
- return flimflam::kNetworkTechnologyGsm;
+ return kNetworkTechnologyGsm;
case MM_MODEM_GSM_ACCESS_TECH_GPRS:
- return flimflam::kNetworkTechnologyGprs;
+ return kNetworkTechnologyGprs;
case MM_MODEM_GSM_ACCESS_TECH_EDGE:
- return flimflam::kNetworkTechnologyEdge;
+ return kNetworkTechnologyEdge;
case MM_MODEM_GSM_ACCESS_TECH_UMTS:
- return flimflam::kNetworkTechnologyUmts;
+ return kNetworkTechnologyUmts;
case MM_MODEM_GSM_ACCESS_TECH_HSDPA:
case MM_MODEM_GSM_ACCESS_TECH_HSUPA:
case MM_MODEM_GSM_ACCESS_TECH_HSPA:
- return flimflam::kNetworkTechnologyHspa;
+ return kNetworkTechnologyHspa;
case MM_MODEM_GSM_ACCESS_TECH_HSPA_PLUS:
- return flimflam::kNetworkTechnologyHspaPlus;
+ return kNetworkTechnologyHspaPlus;
default:
break;
}
@@ -822,13 +812,13 @@
string CellularCapabilityGSM::GetRoamingStateString() const {
switch (registration_state_) {
case MM_MODEM_GSM_NETWORK_REG_STATUS_HOME:
- return flimflam::kRoamingStateHome;
+ return kRoamingStateHome;
case MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING:
- return flimflam::kRoamingStateRoaming;
+ return kRoamingStateRoaming;
default:
break;
}
- return flimflam::kRoamingStateUnknown;
+ return kRoamingStateUnknown;
}
void CellularCapabilityGSM::OnDBusPropertiesChanged(
@@ -871,7 +861,7 @@
shill::kSIMPresentProperty, sim_present_);
}
cellular()->adaptor()->EmitKeyValueStoreChanged(
- flimflam::kSIMLockStatusProperty, SimLockStatusToProperty(NULL));
+ kSIMLockStatusProperty, SimLockStatusToProperty(NULL));
}
}
}
diff --git a/cellular_capability_gsm.h b/cellular_capability_gsm.h
index 6e92d52..0ea702c 100644
--- a/cellular_capability_gsm.h
+++ b/cellular_capability_gsm.h
@@ -74,7 +74,7 @@
virtual std::string GetNetworkTechnologyString() const;
virtual std::string GetRoamingStateString() const;
virtual std::string GetTypeString() const {
- return flimflam::kTechnologyFamilyGsm;
+ return kTechnologyFamilyGsm;
}
virtual void OnDBusPropertiesChanged(
const std::string &interface,
diff --git a/cellular_capability_gsm_unittest.cc b/cellular_capability_gsm_unittest.cc
index e3b0fb4..111e8dc 100644
--- a/cellular_capability_gsm_unittest.cc
+++ b/cellular_capability_gsm_unittest.cc
@@ -332,7 +332,7 @@
const int CellularCapabilityGSMTest::kStrength = 80;
TEST_F(CellularCapabilityGSMTest, PropertyStore) {
- EXPECT_TRUE(cellular_->store().Contains(flimflam::kSIMLockStatusProperty));
+ EXPECT_TRUE(cellular_->store().Contains(kSIMLockStatusProperty));
}
TEST_F(CellularCapabilityGSMTest, GetIMEI) {
@@ -556,10 +556,8 @@
EXPECT_CALL(*this, TestCallback(IsSuccess()));
capability_->found_networks_.resize(3, Stringmap());
EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
- SizeIs2()));
- EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, true));
+ EmitStringmapsChanged(kFoundNetworksProperty, SizeIs2()));
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, true));
EXPECT_FALSE(capability_->scanning_);
SetNetworkProxy();
@@ -569,15 +567,12 @@
EXPECT_TRUE(capability_->scanning_);
// Simulate the completion of the scan...
- EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, false));
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, false));
InvokeScanReply();
EXPECT_FALSE(capability_->scanning_);
EXPECT_EQ(2, capability_->found_networks_.size());
- EXPECT_EQ(kScanID0,
- capability_->found_networks_[0][flimflam::kNetworkIdProperty]);
- EXPECT_EQ(kScanID1,
- capability_->found_networks_[1][flimflam::kNetworkIdProperty]);
+ EXPECT_EQ(kScanID0, capability_->found_networks_[0][kNetworkIdProperty]);
+ EXPECT_EQ(kScanID1, capability_->found_networks_[1][kNetworkIdProperty]);
}
TEST_F(CellularCapabilityGSMTest, ParseScanResult) {
@@ -593,12 +588,11 @@
result["unknown property"] = "random value";
Stringmap parsed = capability_->ParseScanResult(result);
EXPECT_EQ(5, parsed.size());
- EXPECT_EQ("available", parsed[flimflam::kStatusProperty]);
- EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
- EXPECT_EQ(kLongName, parsed[flimflam::kLongNameProperty]);
- EXPECT_EQ(kShortName, parsed[flimflam::kShortNameProperty]);
- EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
- parsed[flimflam::kTechnologyProperty]);
+ EXPECT_EQ("available", parsed[kStatusProperty]);
+ EXPECT_EQ(kID, parsed[kNetworkIdProperty]);
+ EXPECT_EQ(kLongName, parsed[kLongNameProperty]);
+ EXPECT_EQ(kShortName, parsed[kShortNameProperty]);
+ EXPECT_EQ(kNetworkTechnologyEdge, parsed[kTechnologyProperty]);
}
TEST_F(CellularCapabilityGSMTest, ParseScanResultProviderLookup) {
@@ -608,8 +602,8 @@
result[CellularCapabilityGSM::kNetworkPropertyID] = kID;
Stringmap parsed = capability_->ParseScanResult(result);
EXPECT_EQ(2, parsed.size());
- EXPECT_EQ(kID, parsed[flimflam::kNetworkIdProperty]);
- EXPECT_EQ("T-Mobile", parsed[flimflam::kLongNameProperty]);
+ EXPECT_EQ(kID, parsed[kNetworkIdProperty]);
+ EXPECT_EQ("T-Mobile", parsed[kLongNameProperty]);
}
TEST_F(CellularCapabilityGSMTest, SetAccessTechnology) {
@@ -619,8 +613,7 @@
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
capability_->SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GPRS);
EXPECT_EQ(MM_MODEM_GSM_ACCESS_TECH_GPRS, capability_->access_technology_);
- EXPECT_EQ(flimflam::kNetworkTechnologyGprs,
- cellular_->service()->network_technology());
+ EXPECT_EQ(kNetworkTechnologyGprs, cellular_->service()->network_technology());
}
TEST_F(CellularCapabilityGSMTest, UpdateOperatorInfo) {
@@ -727,65 +720,50 @@
ASSERT_TRUE(capability_->home_provider_);
EXPECT_EQ(0, capability_->apn_list_.size());
EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kCellularApnListProperty,
- SizeIs4()));
+ EmitStringmapsChanged(kCellularApnListProperty, SizeIs4()));
capability_->InitAPNList();
EXPECT_EQ(4, capability_->apn_list_.size());
EXPECT_EQ("wap.voicestream.com",
- capability_->apn_list_[1][flimflam::kApnProperty]);
+ capability_->apn_list_[1][kApnProperty]);
EXPECT_EQ("Web2Go/t-zones",
- capability_->apn_list_[1][flimflam::kApnNameProperty]);
+ capability_->apn_list_[1][kApnNameProperty]);
}
TEST_F(CellularCapabilityGSMTest, GetNetworkTechnologyString) {
EXPECT_EQ("", capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM);
- EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyGsm, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GSM_COMPACT);
- EXPECT_EQ(flimflam::kNetworkTechnologyGsm,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyGsm, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_GPRS);
- EXPECT_EQ(flimflam::kNetworkTechnologyGprs,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyGprs, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_EDGE);
- EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyEdge, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_UMTS);
- EXPECT_EQ(flimflam::kNetworkTechnologyUmts,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyUmts, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSDPA);
- EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyHspa, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSUPA);
- EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyHspa, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA);
- EXPECT_EQ(flimflam::kNetworkTechnologyHspa,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyHspa, capability_->GetNetworkTechnologyString());
SetAccessTechnology(MM_MODEM_GSM_ACCESS_TECH_HSPA_PLUS);
- EXPECT_EQ(flimflam::kNetworkTechnologyHspaPlus,
+ EXPECT_EQ(kNetworkTechnologyHspaPlus,
capability_->GetNetworkTechnologyString());
}
TEST_F(CellularCapabilityGSMTest, GetRoamingStateString) {
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateUnknown, capability_->GetRoamingStateString());
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_HOME);
- EXPECT_EQ(flimflam::kRoamingStateHome,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateHome, capability_->GetRoamingStateString());
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_ROAMING);
- EXPECT_EQ(flimflam::kRoamingStateRoaming,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateRoaming, capability_->GetRoamingStateString());
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_SEARCHING);
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateUnknown, capability_->GetRoamingStateString());
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_DENIED);
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateUnknown, capability_->GetRoamingStateString());
SetRegistrationState(MM_MODEM_GSM_NETWORK_REG_STATUS_IDLE);
- EXPECT_EQ(flimflam::kRoamingStateUnknown,
- capability_->GetRoamingStateString());
+ EXPECT_EQ(kRoamingStateUnknown, capability_->GetRoamingStateString());
}
TEST_F(CellularCapabilityGSMTest, CreateFriendlyServiceName) {
@@ -818,12 +796,12 @@
TEST_F(CellularCapabilityGSMTest, SetStorageIdentifier) {
SetService();
capability_->OnServiceCreated();
- EXPECT_EQ(string(flimflam::kTypeCellular) + "_" + kAddress + "_" +
+ EXPECT_EQ(string(kTypeCellular) + "_" + kAddress + "_" +
cellular_->service()->friendly_name(),
cellular_->service()->GetStorageIdentifier());
capability_->imsi_ = kIMSI;
capability_->OnServiceCreated();
- EXPECT_EQ(string(flimflam::kTypeCellular) + "_" + kAddress + "_" + kIMSI,
+ EXPECT_EQ(string(kTypeCellular) + "_" + kAddress + "_" + kIMSI,
cellular_->service()->GetStorageIdentifier());
}
@@ -882,12 +860,12 @@
// Call with the MM_MODEM_GSM_NETWORK_INTERFACE interface and expect a change
// to the enabled state of the SIM lock.
KeyValueStore lock_status;
- lock_status.SetBool(flimflam::kSIMLockEnabledProperty, true);
- lock_status.SetString(flimflam::kSIMLockTypeProperty, "");
- lock_status.SetUint(flimflam::kSIMLockRetriesLeftProperty, 0);
+ lock_status.SetBool(kSIMLockEnabledProperty, true);
+ lock_status.SetString(kSIMLockTypeProperty, "");
+ lock_status.SetUint(kSIMLockRetriesLeftProperty, 0);
EXPECT_CALL(*device_adaptor_, EmitKeyValueStoreChanged(
- flimflam::kSIMLockStatusProperty,
+ kSIMLockStatusProperty,
KeyValueStoreEq(lock_status)));
capability_->OnDBusPropertiesChanged(MM_MODEM_GSM_NETWORK_INTERFACE, props,
@@ -904,11 +882,11 @@
capability_->sim_lock_status_.lock_type = "";
capability_->sim_lock_status_.retries_left = 0;
KeyValueStore lock_status2;
- lock_status2.SetBool(flimflam::kSIMLockEnabledProperty, false);
- lock_status2.SetString(flimflam::kSIMLockTypeProperty, kLockType);
- lock_status2.SetUint(flimflam::kSIMLockRetriesLeftProperty, kRetries);
+ lock_status2.SetBool(kSIMLockEnabledProperty, false);
+ lock_status2.SetString(kSIMLockTypeProperty, kLockType);
+ lock_status2.SetUint(kSIMLockRetriesLeftProperty, kRetries);
EXPECT_CALL(*device_adaptor_,
- EmitKeyValueStoreChanged(flimflam::kSIMLockStatusProperty,
+ EmitKeyValueStoreChanged(kSIMLockStatusProperty,
KeyValueStoreEq(lock_status2)));
capability_->OnDBusPropertiesChanged(MM_MODEM_INTERFACE, props,
vector<string>());
@@ -929,60 +907,60 @@
capability_->SetHomeProvider();
DBusPropertiesMap props;
capability_->SetupConnectProperties(&props);
- EXPECT_FALSE(props.find(flimflam::kApnProperty) == props.end());
- EXPECT_EQ(kTmobileApn, props[flimflam::kApnProperty].reader().get_string());
+ EXPECT_FALSE(props.find(kApnProperty) == props.end());
+ EXPECT_EQ(kTmobileApn, props[kApnProperty].reader().get_string());
ProfileRefPtr profile(new NiceMock<MockProfile>(
modem_info_.control_interface(), modem_info_.metrics(),
modem_info_.manager()));
cellular_->service()->set_profile(profile);
Stringmap apn_info;
- apn_info[flimflam::kApnProperty] = kLastGoodApn;
- apn_info[flimflam::kApnUsernameProperty] = kLastGoodUsername;
+ apn_info[kApnProperty] = kLastGoodApn;
+ apn_info[kApnUsernameProperty] = kLastGoodUsername;
cellular_->service()->SetLastGoodApn(apn_info);
props.clear();
- EXPECT_TRUE(props.find(flimflam::kApnProperty) == props.end());
+ EXPECT_TRUE(props.find(kApnProperty) == props.end());
capability_->SetupConnectProperties(&props);
// We expect the list to contain the last good APN, plus
// the 4 APNs from the mobile provider info database.
EXPECT_EQ(5, capability_->apn_try_list_.size());
- EXPECT_FALSE(props.find(flimflam::kApnProperty) == props.end());
- EXPECT_EQ(kLastGoodApn, props[flimflam::kApnProperty].reader().get_string());
- EXPECT_FALSE(props.find(flimflam::kApnUsernameProperty) == props.end());
+ EXPECT_FALSE(props.find(kApnProperty) == props.end());
+ EXPECT_EQ(kLastGoodApn, props[kApnProperty].reader().get_string());
+ EXPECT_FALSE(props.find(kApnUsernameProperty) == props.end());
EXPECT_EQ(kLastGoodUsername,
- props[flimflam::kApnUsernameProperty].reader().get_string());
+ props[kApnUsernameProperty].reader().get_string());
Error error;
apn_info.clear();
props.clear();
- apn_info[flimflam::kApnProperty] = kSuppliedApn;
+ apn_info[kApnProperty] = kSuppliedApn;
// Setting the APN has the side effect of clearing the LastGoodApn,
// so the try list will have 5 elements, with the first one being
// the supplied APN.
cellular_->service()->SetApn(apn_info, &error);
- EXPECT_TRUE(props.find(flimflam::kApnProperty) == props.end());
+ EXPECT_TRUE(props.find(kApnProperty) == props.end());
capability_->SetupConnectProperties(&props);
EXPECT_EQ(5, capability_->apn_try_list_.size());
- EXPECT_FALSE(props.find(flimflam::kApnProperty) == props.end());
- EXPECT_EQ(kSuppliedApn, props[flimflam::kApnProperty].reader().get_string());
+ EXPECT_FALSE(props.find(kApnProperty) == props.end());
+ EXPECT_EQ(kSuppliedApn, props[kApnProperty].reader().get_string());
apn_info.clear();
props.clear();
- apn_info[flimflam::kApnProperty] = kLastGoodApn;
- apn_info[flimflam::kApnUsernameProperty] = kLastGoodUsername;
+ apn_info[kApnProperty] = kLastGoodApn;
+ apn_info[kApnUsernameProperty] = kLastGoodUsername;
// Now when LastGoodAPN is set, it will be the one selected.
cellular_->service()->SetLastGoodApn(apn_info);
- EXPECT_TRUE(props.find(flimflam::kApnProperty) == props.end());
+ EXPECT_TRUE(props.find(kApnProperty) == props.end());
capability_->SetupConnectProperties(&props);
// We expect the list to contain the last good APN, plus
// the user-supplied APN, plus the 4 APNs from the mobile
// provider info database.
EXPECT_EQ(6, capability_->apn_try_list_.size());
- EXPECT_FALSE(props.find(flimflam::kApnProperty) == props.end());
- EXPECT_EQ(kLastGoodApn, props[flimflam::kApnProperty].reader().get_string());
- EXPECT_FALSE(props.find(flimflam::kApnUsernameProperty) == props.end());
+ EXPECT_FALSE(props.find(kApnProperty) == props.end());
+ EXPECT_EQ(kLastGoodApn, props[kApnProperty].reader().get_string());
+ EXPECT_FALSE(props.find(kApnUsernameProperty) == props.end());
EXPECT_EQ(kLastGoodUsername,
- props[flimflam::kApnUsernameProperty].reader().get_string());
+ props[kApnUsernameProperty].reader().get_string());
}
TEST_F(CellularCapabilityGSMTest, StartModemSuccess) {
diff --git a/cellular_capability_universal.cc b/cellular_capability_universal.cc
index ed644c8..aeb8958 100644
--- a/cellular_capability_universal.cc
+++ b/cellular_capability_universal.cc
@@ -85,28 +85,28 @@
string AccessTechnologyToString(uint32 access_technologies) {
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_LTE)
- return flimflam::kNetworkTechnologyLte;
+ return kNetworkTechnologyLte;
if (access_technologies & (MM_MODEM_ACCESS_TECHNOLOGY_EVDO0 |
MM_MODEM_ACCESS_TECHNOLOGY_EVDOA |
MM_MODEM_ACCESS_TECHNOLOGY_EVDOB))
- return flimflam::kNetworkTechnologyEvdo;
+ return kNetworkTechnologyEvdo;
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_1XRTT)
- return flimflam::kNetworkTechnology1Xrtt;
+ return kNetworkTechnology1Xrtt;
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS)
- return flimflam::kNetworkTechnologyHspaPlus;
+ return kNetworkTechnologyHspaPlus;
if (access_technologies & (MM_MODEM_ACCESS_TECHNOLOGY_HSPA |
MM_MODEM_ACCESS_TECHNOLOGY_HSUPA |
MM_MODEM_ACCESS_TECHNOLOGY_HSDPA))
- return flimflam::kNetworkTechnologyHspa;
+ return kNetworkTechnologyHspa;
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_UMTS)
- return flimflam::kNetworkTechnologyUmts;
+ return kNetworkTechnologyUmts;
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_EDGE)
- return flimflam::kNetworkTechnologyEdge;
+ return kNetworkTechnologyEdge;
if (access_technologies & MM_MODEM_ACCESS_TECHNOLOGY_GPRS)
- return flimflam::kNetworkTechnologyGprs;
+ return kNetworkTechnologyGprs;
if (access_technologies & (MM_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT |
MM_MODEM_ACCESS_TECHNOLOGY_GSM))
- return flimflam::kNetworkTechnologyGsm;
+ return kNetworkTechnologyGsm;
return "";
}
@@ -121,12 +121,12 @@
MM_MODEM_ACCESS_TECHNOLOGY_GPRS |
MM_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT |
MM_MODEM_ACCESS_TECHNOLOGY_GSM))
- return flimflam::kTechnologyFamilyGsm;
+ return kTechnologyFamilyGsm;
if (access_technologies & (MM_MODEM_ACCESS_TECHNOLOGY_EVDO0 |
MM_MODEM_ACCESS_TECHNOLOGY_EVDOA |
MM_MODEM_ACCESS_TECHNOLOGY_EVDOB |
MM_MODEM_ACCESS_TECHNOLOGY_1XRTT))
- return flimflam::kTechnologyFamilyCdma;
+ return kTechnologyFamilyCdma;
return "";
}
@@ -159,38 +159,31 @@
SLOG(Cellular, 2) << "Cellular capability constructed: Universal";
PropertyStore *store = cellular->mutable_store();
- store->RegisterConstString(flimflam::kCarrierProperty, &carrier_);
- store->RegisterConstBool(flimflam::kSupportNetworkScanProperty,
- &scanning_supported_);
- store->RegisterConstString(flimflam::kEsnProperty, &esn_);
- store->RegisterConstString(flimflam::kFirmwareRevisionProperty,
- &firmware_revision_);
- store->RegisterConstString(flimflam::kHardwareRevisionProperty,
- &hardware_revision_);
- store->RegisterConstString(flimflam::kImeiProperty, &imei_);
- store->RegisterConstString(flimflam::kImsiProperty, &imsi_);
- store->RegisterConstString(flimflam::kIccidProperty, &sim_identifier_);
- store->RegisterConstString(flimflam::kManufacturerProperty, &manufacturer_);
- store->RegisterConstString(flimflam::kMdnProperty, &mdn_);
- store->RegisterConstString(flimflam::kMeidProperty, &meid_);
- store->RegisterConstString(flimflam::kMinProperty, &min_);
- store->RegisterConstString(flimflam::kModelIDProperty, &model_id_);
- store->RegisterConstString(flimflam::kSelectedNetworkProperty,
- &selected_network_);
- store->RegisterConstStringmaps(flimflam::kFoundNetworksProperty,
- &found_networks_);
+ store->RegisterConstString(kCarrierProperty, &carrier_);
+ store->RegisterConstBool(kSupportNetworkScanProperty, &scanning_supported_);
+ store->RegisterConstString(kEsnProperty, &esn_);
+ store->RegisterConstString(kFirmwareRevisionProperty, &firmware_revision_);
+ store->RegisterConstString(kHardwareRevisionProperty, &hardware_revision_);
+ store->RegisterConstString(kImeiProperty, &imei_);
+ store->RegisterConstString(kImsiProperty, &imsi_);
+ store->RegisterConstString(kIccidProperty, &sim_identifier_);
+ store->RegisterConstString(kManufacturerProperty, &manufacturer_);
+ store->RegisterConstString(kMdnProperty, &mdn_);
+ store->RegisterConstString(kMeidProperty, &meid_);
+ store->RegisterConstString(kMinProperty, &min_);
+ store->RegisterConstString(kModelIDProperty, &model_id_);
+ store->RegisterConstString(kSelectedNetworkProperty, &selected_network_);
+ store->RegisterConstStringmaps(kFoundNetworksProperty, &found_networks_);
store->RegisterConstBool(shill::kProviderRequiresRoamingProperty,
&provider_requires_roaming_);
- store->RegisterConstBool(flimflam::kScanningProperty,
- &scanning_or_searching_);
- store->RegisterUint16(flimflam::kScanIntervalProperty, &scan_interval_);
+ store->RegisterConstBool(kScanningProperty, &scanning_or_searching_);
+ store->RegisterUint16(kScanIntervalProperty, &scan_interval_);
HelpRegisterConstDerivedKeyValueStore(
- flimflam::kSIMLockStatusProperty,
+ kSIMLockStatusProperty,
&CellularCapabilityUniversal::SimLockStatusToProperty);
store->RegisterConstString(shill::kSIMOperatorIdProperty, &operator_id_);
store->RegisterConstBool(shill::kSIMPresentProperty, &sim_present_);
- store->RegisterConstStringmaps(flimflam::kCellularApnListProperty,
- &apn_list_);
+ store->RegisterConstStringmaps(kCellularApnListProperty, &apn_list_);
}
KeyValueStore CellularCapabilityUniversal::SimLockStatusToProperty(
@@ -208,10 +201,9 @@
lock_type = "";
break;
}
- status.SetBool(flimflam::kSIMLockEnabledProperty, sim_lock_status_.enabled);
- status.SetString(flimflam::kSIMLockTypeProperty, lock_type);
- status.SetUint(flimflam::kSIMLockRetriesLeftProperty,
- sim_lock_status_.retries_left);
+ status.SetBool(kSIMLockEnabledProperty, sim_lock_status_.enabled);
+ status.SetString(kSIMLockTypeProperty, lock_type);
+ status.SetUint(kSIMLockRetriesLeftProperty, sim_lock_status_.retries_left);
return status;
}
@@ -491,8 +483,7 @@
// There should be a cellular service at this point.
if (cellular()->service().get())
- cellular()->service()->SetActivationState(
- flimflam::kActivationStateActivating);
+ cellular()->service()->SetActivationState(kActivationStateActivating);
modem_info()->pending_activation_store()->SetActivationState(
PendingActivationStore::kIdentifierICCID,
sim_identifier_,
@@ -551,7 +542,7 @@
if (!service.get())
return;
- if (service->activation_state() == flimflam::kActivationStateActivated)
+ if (service->activation_state() == kActivationStateActivated)
// Either no service or already activated. Nothing to do.
return;
@@ -560,7 +551,7 @@
if (got_mdn || cellular()->state() == Cellular::kStateConnected ||
cellular()->state() == Cellular::kStateLinked) {
SLOG(Cellular, 2) << "Marking service as activated.";
- service->SetActivationState(flimflam::kActivationStateActivated);
+ service->SetActivationState(kActivationStateActivated);
return;
}
@@ -577,7 +568,7 @@
case PendingActivationStore::kStatePending:
// Always mark the service as activating here, as the ICCID could have
// been unavailable earlier.
- service->SetActivationState(flimflam::kActivationStateActivating);
+ service->SetActivationState(kActivationStateActivating);
if (reset_done_) {
SLOG(Cellular, 2) << "Post-payment activation reset complete.";
modem_info()->pending_activation_store()->SetActivationState(
@@ -607,7 +598,7 @@
PendingActivationStore::kIdentifierICCID,
sim_identifier_,
PendingActivationStore::kStateActivated);
- service->SetActivationState(flimflam::kActivationStateActivated);
+ service->SetActivationState(kActivationStateActivated);
}
break;
case PendingActivationStore::kStateUnknown:
@@ -678,11 +669,11 @@
if (!sim_identifier_.empty() &&
(state == PendingActivationStore::kStatePending ||
state == PendingActivationStore::kStatePendingTimeout))
- activation_state = flimflam::kActivationStateActivating;
+ activation_state = kActivationStateActivating;
else if (activation_required)
- activation_state = flimflam::kActivationStateNotActivated;
+ activation_state = kActivationStateNotActivated;
else {
- activation_state = flimflam::kActivationStateActivated;
+ activation_state = kActivationStateActivated;
// Mark an activated service for auto-connect by default. Since data from
// the user profile will be loaded after the call to OnServiceCreated, this
@@ -761,16 +752,15 @@
// Leave the APN at the front of the list, so that it can be recorded
// if the connect attempt succeeds.
Stringmap apn_info = apn_try_list_.front();
- SLOG(Cellular, 2) << __func__ << ": Using APN "
- << apn_info[flimflam::kApnProperty];
+ SLOG(Cellular, 2) << __func__ << ": Using APN " << apn_info[kApnProperty];
(*properties)[kConnectApn].writer().append_string(
- apn_info[flimflam::kApnProperty].c_str());
- if (ContainsKey(apn_info, flimflam::kApnUsernameProperty))
+ apn_info[kApnProperty].c_str());
+ if (ContainsKey(apn_info, kApnUsernameProperty))
(*properties)[kConnectUser].writer().append_string(
- apn_info[flimflam::kApnUsernameProperty].c_str());
- if (ContainsKey(apn_info, flimflam::kApnPasswordProperty))
+ apn_info[kApnUsernameProperty].c_str());
+ if (ContainsKey(apn_info, kApnPasswordProperty))
(*properties)[kConnectPassword].writer().append_string(
- apn_info[flimflam::kApnPasswordProperty].c_str());
+ apn_info[kApnPasswordProperty].c_str());
}
}
@@ -944,7 +934,7 @@
scanning_;
if (new_scanning_or_searching != scanning_or_searching_) {
scanning_or_searching_ = new_scanning_or_searching;
- cellular()->adaptor()->EmitBoolChanged(flimflam::kScanningProperty,
+ cellular()->adaptor()->EmitBoolChanged(kScanningProperty,
new_scanning_or_searching);
if (!scanning_or_searching_) {
@@ -964,9 +954,9 @@
void CellularCapabilityUniversal::OnScanningOrSearchingTimeout() {
SLOG(Cellular, 2) << "Initial network scan timed out. Changing "
- << "flimflam::kScanningProperty to |false|.";
+ << "kScanningProperty to |false|.";
scanning_or_searching_ = false;
- cellular()->adaptor()->EmitBoolChanged(flimflam::kScanningProperty, false);
+ cellular()->adaptor()->EmitBoolChanged(kScanningProperty, false);
}
void CellularCapabilityUniversal::UpdateOLP() {
@@ -1159,13 +1149,13 @@
Stringmap props;
mobile_apn *apn = home_provider_->apns[i];
if (apn->value) {
- props[flimflam::kApnProperty] = apn->value;
+ props[kApnProperty] = apn->value;
}
if (apn->username) {
- props[flimflam::kApnUsernameProperty] = apn->username;
+ props[kApnUsernameProperty] = apn->username;
}
if (apn->password) {
- props[flimflam::kApnPasswordProperty] = apn->password;
+ props[kApnPasswordProperty] = apn->password;
}
// Find the first localized and non-localized name, if any.
const localized_name *lname = NULL;
@@ -1180,17 +1170,17 @@
}
}
if (name) {
- props[flimflam::kApnNameProperty] = name->name;
+ props[kApnNameProperty] = name->name;
}
if (lname) {
- props[flimflam::kApnLocalizedNameProperty] = lname->name;
- props[flimflam::kApnLanguageProperty] = lname->lang;
+ props[kApnLocalizedNameProperty] = lname->name;
+ props[kApnLanguageProperty] = lname->lang;
}
apn_list_.push_back(props);
}
if (cellular()->adaptor()) {
cellular()->adaptor()->EmitStringmapsChanged(
- flimflam::kCellularApnListProperty, apn_list_);
+ kCellularApnListProperty, apn_list_);
} else {
LOG(ERROR) << "Null RPC service adaptor.";
}
@@ -1384,7 +1374,7 @@
found_networks_.push_back(ParseScanResult(*it));
}
}
- cellular()->adaptor()->EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
+ cellular()->adaptor()->EmitStringmapsChanged(kFoundNetworksProperty,
found_networks_);
// TODO(gmorain): This check for is_null() is a work-around because
@@ -1437,37 +1427,37 @@
"current", // MM_MODEM_3GPP_NETWORK_AVAILABILITY_CURRENT
"forbidden", // MM_MODEM_3GPP_NETWORK_AVAILABILITY_FORBIDDEN
};
- parsed[flimflam::kStatusProperty] = kStatusString[status];
+ parsed[kStatusProperty] = kStatusString[status];
}
uint32 tech; // MMModemAccessTechnology
if (DBusProperties::GetUint32(result, kOperatorAccessTechnologyProperty,
&tech)) {
- parsed[flimflam::kTechnologyProperty] = AccessTechnologyToString(tech);
+ parsed[kTechnologyProperty] = AccessTechnologyToString(tech);
}
string operator_long, operator_short, operator_code;
if (DBusProperties::GetString(result, kOperatorLongProperty, &operator_long))
- parsed[flimflam::kLongNameProperty] = operator_long;
+ parsed[kLongNameProperty] = operator_long;
if (DBusProperties::GetString(result, kOperatorShortProperty,
&operator_short))
- parsed[flimflam::kShortNameProperty] = operator_short;
+ parsed[kShortNameProperty] = operator_short;
if (DBusProperties::GetString(result, kOperatorCodeProperty, &operator_code))
- parsed[flimflam::kNetworkIdProperty] = operator_code;
+ parsed[kNetworkIdProperty] = operator_code;
// If the long name is not available but the network ID is, look up the long
// name in the mobile provider database.
- if ((!ContainsKey(parsed, flimflam::kLongNameProperty) ||
- parsed[flimflam::kLongNameProperty].empty()) &&
- ContainsKey(parsed, flimflam::kNetworkIdProperty)) {
+ if ((!ContainsKey(parsed, kLongNameProperty) ||
+ parsed[kLongNameProperty].empty()) &&
+ ContainsKey(parsed, kNetworkIdProperty)) {
mobile_provider *provider =
mobile_provider_lookup_by_network(
modem_info()->provider_db(),
- parsed[flimflam::kNetworkIdProperty].c_str());
+ parsed[kNetworkIdProperty].c_str());
if (provider) {
const char *long_name = mobile_provider_get_name(provider);
if (long_name && *long_name) {
- parsed[flimflam::kLongNameProperty] = long_name;
+ parsed[kLongNameProperty] = long_name;
}
}
}
@@ -1483,7 +1473,7 @@
// ever want to support switching between access technologies (e.g. falling
// back to 3G when LTE is not available).
if (model_id_ == kE362ModelId)
- return flimflam::kNetworkTechnologyLte;
+ return kNetworkTechnologyLte;
// Order is important. Return the highest speed technology
// TODO(jglasgow): change shill interfaces to a capability model
@@ -1493,13 +1483,13 @@
string CellularCapabilityUniversal::GetRoamingStateString() const {
switch (registration_state_) {
case MM_MODEM_3GPP_REGISTRATION_STATE_HOME:
- return flimflam::kRoamingStateHome;
+ return kRoamingStateHome;
case MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING:
- return flimflam::kRoamingStateRoaming;
+ return kRoamingStateRoaming;
default:
break;
}
- return flimflam::kRoamingStateUnknown;
+ return kRoamingStateUnknown;
}
// TODO(armansito): Remove this method once cromo is deprecated.
@@ -1729,7 +1719,7 @@
(current_capabilities & MM_MODEM_CAPABILITY_GSM_UMTS) != 0;
if (cellular()->adaptor()) {
cellular()->adaptor()->EmitBoolChanged(
- flimflam::kSupportNetworkScanProperty, scanning_supported_);
+ kSupportNetworkScanProperty, scanning_supported_);
}
}
@@ -1788,7 +1778,7 @@
// TODO(jglasgow): address layering violation of emitting change
// signal here for a property owned by Cellular.
cellular()->adaptor()->EmitStringChanged(
- flimflam::kTechnologyFamilyProperty, new_type_string);
+ kTechnologyFamilyProperty, new_type_string);
}
if (cellular()->service().get()) {
cellular()->service()->SetNetworkTechnology(GetNetworkTechnologyString());
@@ -1842,7 +1832,7 @@
void CellularCapabilityUniversal::OnSimLockStatusChanged() {
SLOG(Cellular, 2) << __func__;
cellular()->adaptor()->EmitKeyValueStoreChanged(
- flimflam::kSIMLockStatusProperty, SimLockStatusToProperty(NULL));
+ kSIMLockStatusProperty, SimLockStatusToProperty(NULL));
// If the SIM is currently unlocked, assume that we need to refresh
// carrier information, since a locked SIM prevents shill from obtaining
diff --git a/cellular_capability_universal_cdma.cc b/cellular_capability_universal_cdma.cc
index 6dbe183..cdb93d9 100644
--- a/cellular_capability_universal_cdma.cc
+++ b/cellular_capability_universal_cdma.cc
@@ -204,11 +204,11 @@
cellular()->service()->SetActivateOverNonCellularNetwork(activation_required);
string activation_state;
if (IsActivating())
- activation_state = flimflam::kActivationStateActivating;
+ activation_state = kActivationStateActivating;
else if (activation_required)
- activation_state = flimflam::kActivationStateNotActivated;
+ activation_state = kActivationStateNotActivated;
else
- activation_state = flimflam::kActivationStateActivated;
+ activation_state = kActivationStateActivated;
cellular()->service()->SetActivationState(activation_state);
}
@@ -392,15 +392,15 @@
uint32 state) {
switch (state) {
case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED:
- return flimflam::kActivationStateActivated;
+ return kActivationStateActivated;
case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING:
- return flimflam::kActivationStateActivating;
+ return kActivationStateActivating;
case MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED:
- return flimflam::kActivationStateNotActivated;
+ return kActivationStateNotActivated;
case MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED:
- return flimflam::kActivationStatePartiallyActivated;
+ return kActivationStatePartiallyActivated;
default:
- return flimflam::kActivationStateUnknown;
+ return kActivationStateUnknown;
}
}
@@ -409,18 +409,18 @@
uint32 error) {
switch (error) {
case MM_CDMA_ACTIVATION_ERROR_WRONG_RADIO_INTERFACE:
- return flimflam::kErrorNeedEvdo;
+ return kErrorNeedEvdo;
case MM_CDMA_ACTIVATION_ERROR_ROAMING:
- return flimflam::kErrorNeedHomeNetwork;
+ return kErrorNeedHomeNetwork;
case MM_CDMA_ACTIVATION_ERROR_COULD_NOT_CONNECT:
case MM_CDMA_ACTIVATION_ERROR_SECURITY_AUTHENTICATION_FAILED:
case MM_CDMA_ACTIVATION_ERROR_PROVISIONING_FAILED:
- return flimflam::kErrorOtaspFailed;
+ return kErrorOtaspFailed;
case MM_CDMA_ACTIVATION_ERROR_NONE:
return "";
case MM_CDMA_ACTIVATION_ERROR_NO_SIGNAL:
default:
- return flimflam::kErrorActivationFailed;
+ return kErrorActivationFailed;
}
}
@@ -513,13 +513,13 @@
case MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED:
break;
case MM_MODEM_CDMA_REGISTRATION_STATE_HOME:
- return flimflam::kRoamingStateHome;
+ return kRoamingStateHome;
case MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING:
- return flimflam::kRoamingStateRoaming;
+ return kRoamingStateRoaming;
default:
NOTREACHED();
}
- return flimflam::kRoamingStateUnknown;
+ return kRoamingStateUnknown;
}
void CellularCapabilityUniversalCDMA::OnDBusPropertiesChanged(
diff --git a/cellular_capability_universal_cdma_unittest.cc b/cellular_capability_universal_cdma_unittest.cc
index 49d15a6..891f42b 100644
--- a/cellular_capability_universal_cdma_unittest.cc
+++ b/cellular_capability_universal_cdma_unittest.cc
@@ -468,42 +468,34 @@
EXPECT_CALL(*modem_info_.mock_cellular_operator_info(), GetOLPBySID(_))
.WillRepeatedly(Return(&olp));
EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
- GetActivationState(_,_))
+ GetActivationState(_, _))
.WillOnce(Return(PendingActivationStore::kStatePending))
.WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
- capability_->activation_state_ =
- MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(1);
capability_->UpdateServiceActivationStateProperty();
Mock::VerifyAndClearExpectations(service_);
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateNotActivated))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateNotActivated))
.Times(1);
capability_->UpdateServiceActivationStateProperty();
Mock::VerifyAndClearExpectations(service_);
- capability_->activation_state_ =
- MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(1);
capability_->UpdateServiceActivationStateProperty();
Mock::VerifyAndClearExpectations(service_);
- capability_->activation_state_ =
- MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivated))
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
.Times(1);
capability_->UpdateServiceActivationStateProperty();
Mock::VerifyAndClearExpectations(service_);
Mock::VerifyAndClearExpectations(modem_info_.mock_cellular_operator_info());
- Mock::VerifyAndClearExpectations(
- modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
}
TEST_F(CellularCapabilityUniversalCDMAMainTest, IsActivating) {
diff --git a/cellular_capability_universal_unittest.cc b/cellular_capability_universal_unittest.cc
index d22e362..421c08a 100644
--- a/cellular_capability_universal_unittest.cc
+++ b/cellular_capability_universal_unittest.cc
@@ -688,7 +688,7 @@
capability_->access_technologies_);
EXPECT_FALSE(capability_->sim_proxy_.get());
EXPECT_CALL(*device_adaptor_, EmitStringChanged(
- flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyGsm));
+ kTechnologyFamilyProperty, kTechnologyFamilyGsm));
capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
modem_properties, vector<string>());
EXPECT_EQ(kAccessTechnologies, capability_->access_technologies_);
@@ -714,7 +714,7 @@
modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
writer().append_uint32(MM_MODEM_ACCESS_TECHNOLOGY_1XRTT);
EXPECT_CALL(*device_adaptor_, EmitStringChanged(
- flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyCdma)).
+ kTechnologyFamilyProperty, kTechnologyFamilyCdma)).
Times(1);
capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
modem_properties,
@@ -726,7 +726,7 @@
modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
writer().append_uint32(MM_MODEM_ACCESS_TECHNOLOGY_LTE);
EXPECT_CALL(*device_adaptor_, EmitStringChanged(
- flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyGsm)).
+ kTechnologyFamilyProperty, kTechnologyFamilyGsm)).
Times(1);
capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
modem_properties,
@@ -1158,8 +1158,7 @@
EXPECT_CALL(*modem_3gpp_proxy_, Scan(_, _, CellularCapability::kTimeoutScan))
.WillOnce(Invoke(this, &CellularCapabilityUniversalTest::InvokeScan));
EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
- SizeIs(0)));
+ EmitStringmapsChanged(kFoundNetworksProperty, SizeIs(0)));
Set3gppProxy();
capability_->Scan(&error, ResultCallback());
EXPECT_TRUE(error.IsSuccess());
@@ -1171,19 +1170,16 @@
EXPECT_CALL(*modem_3gpp_proxy_, Scan(_, _, CellularCapability::kTimeoutScan))
.WillRepeatedly(SaveArg<1>(&scan_callback_));
- EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, true));
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, true));
Set3gppProxy();
capability_->Scan(&error, ResultCallback());
EXPECT_TRUE(capability_->scanning_);
Mock::VerifyAndClearExpectations(device_adaptor_);
// Simulate the completion of the scan with 2 networks in the results.
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, false));
EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, false));
- EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
- SizeIs(2)));
+ EmitStringmapsChanged(kFoundNetworksProperty, SizeIs(2)));
vector<DBusPropertiesMap> results;
const char kScanID0[] = "testID0";
const char kScanID1[] = "testID1";
@@ -1198,17 +1194,14 @@
Mock::VerifyAndClearExpectations(device_adaptor_);
// Simulate the completion of the scan with no networks in the results.
- EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, true));
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, true));
capability_->Scan(&error, ResultCallback());
EXPECT_TRUE(capability_->scanning_);
Mock::VerifyAndClearExpectations(device_adaptor_);
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, false));
EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, false));
- EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
- SizeIs(0)));
+ EmitStringmapsChanged(kFoundNetworksProperty, SizeIs(0)));
scan_callback_.Run(vector<DBusPropertiesMap>(), Error());
EXPECT_FALSE(capability_->scanning_);
}
@@ -1234,8 +1227,7 @@
// Initiate a scan
error.Populate(Error::kSuccess);
- EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, true));
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, true));
capability_->Scan(&error, ResultCallback());
EXPECT_TRUE(capability_->scanning_);
EXPECT_TRUE(error.IsSuccess());
@@ -1249,11 +1241,9 @@
// Validate that signals are emitted even if an error is reported.
capability_->found_networks_.clear();
capability_->found_networks_.push_back(Stringmap());
+ EXPECT_CALL(*device_adaptor_, EmitBoolChanged(kScanningProperty, false));
EXPECT_CALL(*device_adaptor_,
- EmitBoolChanged(flimflam::kScanningProperty, false));
- EXPECT_CALL(*device_adaptor_,
- EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
- SizeIs(0)));
+ EmitStringmapsChanged(kFoundNetworksProperty, SizeIs(0)));
vector<DBusPropertiesMap> results;
scan_callback_.Run(results, Error(Error::kOperationFailed));
EXPECT_FALSE(capability_->scanning_);
@@ -1383,10 +1373,10 @@
EXPECT_CALL(*modem_simple_proxy, Connect(HasApn(apn_name_foo), _, _, _))
.WillOnce(SaveArg<2>(&connect_callback_));
Stringmap apn1;
- apn1[flimflam::kApnProperty] = apn_name_foo;
+ apn1[kApnProperty] = apn_name_foo;
capability_->apn_try_list_.push_back(apn1);
Stringmap apn2;
- apn2[flimflam::kApnProperty] = apn_name_bar;
+ apn2[kApnProperty] = apn_name_bar;
capability_->apn_try_list_.push_back(apn2);
capability_->FillConnectPropertyMap(&properties);
capability_->Connect(properties, &error, callback);
@@ -1426,7 +1416,7 @@
};
for (size_t i = 0; i < arraysize(gsm_technologies); ++i) {
capability_->access_technologies_ = gsm_technologies[i];
- ASSERT_EQ(capability_->GetTypeString(), flimflam::kTechnologyFamilyGsm);
+ ASSERT_EQ(capability_->GetTypeString(), kTechnologyFamilyGsm);
}
const int cdma_technologies[] = {
MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
@@ -1438,7 +1428,7 @@
};
for (size_t i = 0; i < arraysize(cdma_technologies); ++i) {
capability_->access_technologies_ = cdma_technologies[i];
- ASSERT_EQ(capability_->GetTypeString(), flimflam::kTechnologyFamilyCdma);
+ ASSERT_EQ(capability_->GetTypeString(), kTechnologyFamilyCdma);
}
capability_->access_technologies_ = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
ASSERT_EQ(capability_->GetTypeString(), "");
@@ -1782,8 +1772,7 @@
capability_->mdn_.clear();
capability_->sim_identifier_.clear();
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(0);
EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
SetActivationState(
@@ -1804,8 +1793,7 @@
kIccid,
PendingActivationStore::kStatePending))
.Times(1);
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(1);
EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(1);
capability_->CompleteActivation(&error);
@@ -1820,8 +1808,7 @@
kIccid,
PendingActivationStore::kStatePending))
.Times(0);
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(0);
EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(0);
capability_->mdn_ = "1231231212";
@@ -1837,16 +1824,14 @@
.WillRepeatedly(Return(&olp));
service_->SetAutoConnect(false);
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateNotActivated))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateNotActivated))
.Times(1);
capability_->UpdateServiceActivationState();
Mock::VerifyAndClearExpectations(service_);
EXPECT_FALSE(service_->auto_connect());
capability_->mdn_ = "1231231122";
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivated))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
.Times(1);
capability_->UpdateServiceActivationState();
Mock::VerifyAndClearExpectations(service_);
@@ -1861,8 +1846,7 @@
.Times(2)
.WillOnce(Return(PendingActivationStore::kStatePending))
.WillOnce(Return(PendingActivationStore::kStatePendingTimeout));
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
.Times(1);
capability_->UpdateServiceActivationState();
Mock::VerifyAndClearExpectations(service_);
@@ -1874,8 +1858,7 @@
kIccid))
.Times(2)
.WillRepeatedly(Return(PendingActivationStore::kStateActivated));
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivated))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
.Times(1);
capability_->UpdateServiceActivationState();
Mock::VerifyAndClearExpectations(service_);
@@ -1973,9 +1956,8 @@
GetActivationState(PendingActivationStore::kIdentifierICCID,
kIccid))
.Times(2).WillRepeatedly(Return(PendingActivationStore::kStatePending));
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivating))
- .Times(2);
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivating))
+ .Times(2);
EXPECT_CALL(*modem_proxy, Reset(_, _, _)).Times(0);
capability_->UpdatePendingActivationState();
Mock::VerifyAndClearExpectations(modem_proxy);
@@ -2004,15 +1986,13 @@
EXPECT_CALL(*service_, AutoConnect()).Times(1);
capability_->UpdatePendingActivationState();
- cellular_->service_->activation_state_ =
- flimflam::kActivationStateNotActivated;
+ cellular_->service_->activation_state_ = kActivationStateNotActivated;
Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
// Device is connected.
cellular_->state_ = Cellular::kStateConnected;
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivated))
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
.Times(3);
capability_->UpdatePendingActivationState();
@@ -2061,9 +2041,8 @@
kIccid,
PendingActivationStore::kStateActivated))
.Times(1);
- EXPECT_CALL(*service_,
- SetActivationState(flimflam::kActivationStateActivated))
- .Times(1);
+ EXPECT_CALL(*service_, SetActivationState(kActivationStateActivated))
+ .Times(1);
capability_->UpdatePendingActivationState();
Mock::VerifyAndClearExpectations(service_);
Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
@@ -2187,16 +2166,13 @@
EXPECT_TRUE(capability_->GetNetworkTechnologyString().empty());
capability_->model_id_ = CellularCapabilityUniversal::kE362ModelId;
- EXPECT_EQ(flimflam::kNetworkTechnologyLte,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyLte, capability_->GetNetworkTechnologyString());
capability_->access_technologies_ = MM_MODEM_ACCESS_TECHNOLOGY_GPRS;
- EXPECT_EQ(flimflam::kNetworkTechnologyLte,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyLte, capability_->GetNetworkTechnologyString());
capability_->model_id_.clear();
- EXPECT_EQ(flimflam::kNetworkTechnologyGprs,
- capability_->GetNetworkTechnologyString());
+ EXPECT_EQ(kNetworkTechnologyGprs, capability_->GetNetworkTechnologyString());
}
TEST_F(CellularCapabilityUniversalMainTest, ShouldDetectOutOfCredit) {
@@ -2211,29 +2187,29 @@
TEST_F(CellularCapabilityUniversalMainTest, SimLockStatusToProperty) {
Error error;
KeyValueStore store = capability_->SimLockStatusToProperty(&error);
- EXPECT_FALSE(store.GetBool(flimflam::kSIMLockEnabledProperty));
- EXPECT_TRUE(store.GetString(flimflam::kSIMLockTypeProperty).empty());
- EXPECT_EQ(0, store.GetUint(flimflam::kSIMLockRetriesLeftProperty));
+ EXPECT_FALSE(store.GetBool(kSIMLockEnabledProperty));
+ EXPECT_TRUE(store.GetString(kSIMLockTypeProperty).empty());
+ EXPECT_EQ(0, store.GetUint(kSIMLockRetriesLeftProperty));
capability_->sim_lock_status_.enabled = true;
capability_->sim_lock_status_.retries_left = 3;
capability_->sim_lock_status_.lock_type = MM_MODEM_LOCK_SIM_PIN;
store = capability_->SimLockStatusToProperty(&error);
- EXPECT_TRUE(store.GetBool(flimflam::kSIMLockEnabledProperty));
- EXPECT_EQ("sim-pin", store.GetString(flimflam::kSIMLockTypeProperty));
- EXPECT_EQ(3, store.GetUint(flimflam::kSIMLockRetriesLeftProperty));
+ EXPECT_TRUE(store.GetBool(kSIMLockEnabledProperty));
+ EXPECT_EQ("sim-pin", store.GetString(kSIMLockTypeProperty));
+ EXPECT_EQ(3, store.GetUint(kSIMLockRetriesLeftProperty));
capability_->sim_lock_status_.lock_type = MM_MODEM_LOCK_SIM_PUK;
store = capability_->SimLockStatusToProperty(&error);
- EXPECT_EQ("sim-puk", store.GetString(flimflam::kSIMLockTypeProperty));
+ EXPECT_EQ("sim-puk", store.GetString(kSIMLockTypeProperty));
capability_->sim_lock_status_.lock_type = MM_MODEM_LOCK_SIM_PIN2;
store = capability_->SimLockStatusToProperty(&error);
- EXPECT_TRUE(store.GetString(flimflam::kSIMLockTypeProperty).empty());
+ EXPECT_TRUE(store.GetString(kSIMLockTypeProperty).empty());
capability_->sim_lock_status_.lock_type = MM_MODEM_LOCK_SIM_PUK2;
store = capability_->SimLockStatusToProperty(&error);
- EXPECT_TRUE(store.GetString(flimflam::kSIMLockTypeProperty).empty());
+ EXPECT_TRUE(store.GetString(kSIMLockTypeProperty).empty());
}
TEST_F(CellularCapabilityUniversalMainTest, OnLockRetriesChanged) {
diff --git a/cellular_service.cc b/cellular_service.cc
index 0cfa7cf..390cd28 100644
--- a/cellular_service.cc
+++ b/cellular_service.cc
@@ -118,28 +118,25 @@
PropertyStore *store = this->mutable_store();
store->RegisterConstBool(kActivateOverNonCellularNetworkProperty,
&activate_over_non_cellular_network_);
- store->RegisterConstString(flimflam::kActivationStateProperty,
- &activation_state_);
- HelpRegisterDerivedStringmap(flimflam::kCellularApnProperty,
+ store->RegisterConstString(kActivationStateProperty, &activation_state_);
+ HelpRegisterDerivedStringmap(kCellularApnProperty,
&CellularService::GetApn,
&CellularService::SetApn);
- store->RegisterConstStringmap(flimflam::kCellularLastGoodApnProperty,
+ store->RegisterConstStringmap(kCellularLastGoodApnProperty,
&last_good_apn_info_);
- store->RegisterConstString(flimflam::kNetworkTechnologyProperty,
- &network_technology_);
+ store->RegisterConstString(kNetworkTechnologyProperty, &network_technology_);
store->RegisterConstBool(kOutOfCreditsProperty, &out_of_credits_);
- store->RegisterConstStringmap(flimflam::kPaymentPortalProperty,
- &olp_.ToDict());
- store->RegisterConstString(flimflam::kRoamingStateProperty, &roaming_state_);
- store->RegisterConstStringmap(flimflam::kServingOperatorProperty,
+ store->RegisterConstStringmap(kPaymentPortalProperty, &olp_.ToDict());
+ store->RegisterConstString(kRoamingStateProperty, &roaming_state_);
+ store->RegisterConstStringmap(kServingOperatorProperty,
&serving_operator_.ToDict());
- store->RegisterConstString(flimflam::kUsageURLProperty, &usage_url_);
+ store->RegisterConstString(kUsageURLProperty, &usage_url_);
store->RegisterString(kCellularPPPUsernameProperty, &ppp_username_);
store->RegisterWriteOnlyString(kCellularPPPPasswordProperty, &ppp_password_);
string name = device->CreateFriendlyServiceName();
set_friendly_name(name);
- SetStorageIdentifier(string(flimflam::kTypeCellular) + "_" +
+ SetStorageIdentifier(string(kTypeCellular) + "_" +
device->address() + "_" + name);
}
@@ -181,7 +178,7 @@
}
Stringmap *CellularService::GetUserSpecifiedApn() {
- Stringmap::iterator it = apn_info_.find(flimflam::kApnProperty);
+ Stringmap::iterator it = apn_info_.find(kApnProperty);
if (it == apn_info_.end() || it->second.empty())
return NULL;
return &apn_info_;
@@ -189,7 +186,7 @@
Stringmap *CellularService::GetLastGoodApn() {
Stringmap::iterator it =
- last_good_apn_info_.find(flimflam::kApnProperty);
+ last_good_apn_info_.find(kApnProperty);
if (it == last_good_apn_info_.end() || it->second.empty())
return NULL;
return &last_good_apn_info_;
@@ -204,18 +201,18 @@
// If the "apn" field is missing or empty, the APN is cleared.
string str;
Stringmap new_apn_info;
- if (GetNonEmptyField(value, flimflam::kApnProperty, &str)) {
- new_apn_info[flimflam::kApnProperty] = str;
- if (GetNonEmptyField(value, flimflam::kApnUsernameProperty, &str))
- new_apn_info[flimflam::kApnUsernameProperty] = str;
- if (GetNonEmptyField(value, flimflam::kApnPasswordProperty, &str))
- new_apn_info[flimflam::kApnPasswordProperty] = str;
+ if (GetNonEmptyField(value, kApnProperty, &str)) {
+ new_apn_info[kApnProperty] = str;
+ if (GetNonEmptyField(value, kApnUsernameProperty, &str))
+ new_apn_info[kApnUsernameProperty] = str;
+ if (GetNonEmptyField(value, kApnPasswordProperty, &str))
+ new_apn_info[kApnPasswordProperty] = str;
}
if (apn_info_ == new_apn_info) {
return false;
}
apn_info_ = new_apn_info;
- if (ContainsKey(apn_info_, flimflam::kApnProperty)) {
+ if (ContainsKey(apn_info_, kApnProperty)) {
// Clear the last good APN, otherwise the one the user just
// set won't be used, since LastGoodApn comes first in the
// search order when trying to connect. Only do this if a
@@ -223,21 +220,21 @@
// being cleared, leave LastGoodApn alone.
ClearLastGoodApn();
}
- adaptor()->EmitStringmapChanged(flimflam::kCellularApnProperty, apn_info_);
+ adaptor()->EmitStringmapChanged(kCellularApnProperty, apn_info_);
SaveToCurrentProfile();
return true;
}
void CellularService::SetLastGoodApn(const Stringmap &apn_info) {
last_good_apn_info_ = apn_info;
- adaptor()->EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ adaptor()->EmitStringmapChanged(kCellularLastGoodApnProperty,
last_good_apn_info_);
SaveToCurrentProfile();
}
void CellularService::ClearLastGoodApn() {
last_good_apn_info_.clear();
- adaptor()->EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ adaptor()->EmitStringmapChanged(kCellularLastGoodApnProperty,
last_good_apn_info_);
SaveToCurrentProfile();
}
@@ -271,13 +268,10 @@
const string &storage_group,
const string &keytag,
Stringmap *apn_info) {
- if (!LoadApnField(storage, storage_group, keytag,
- flimflam::kApnProperty, apn_info))
+ if (!LoadApnField(storage, storage_group, keytag, kApnProperty, apn_info))
return;
- LoadApnField(storage, storage_group, keytag,
- flimflam::kApnUsernameProperty, apn_info);
- LoadApnField(storage, storage_group, keytag,
- flimflam::kApnPasswordProperty, apn_info);
+ LoadApnField(storage, storage_group, keytag, kApnUsernameProperty, apn_info);
+ LoadApnField(storage, storage_group, keytag, kApnPasswordProperty, apn_info);
}
bool CellularService::LoadApnField(StoreInterface *storage,
@@ -353,7 +347,7 @@
return;
if (explicitly_disconnected())
return;
- if (roaming_state_ == flimflam::kRoamingStateRoaming &&
+ if (roaming_state_ == kRoamingStateRoaming &&
!cellular_->allow_roaming_property())
return;
if (time_since_connect.InSeconds() <= kOutOfCreditsConnectionDropSeconds) {
@@ -404,12 +398,9 @@
const string &storage_group,
const Stringmap *apn_info,
const string &keytag) {
- SaveApnField(storage, storage_group, apn_info, keytag,
- flimflam::kApnProperty);
- SaveApnField(storage, storage_group, apn_info, keytag,
- flimflam::kApnUsernameProperty);
- SaveApnField(storage, storage_group, apn_info, keytag,
- flimflam::kApnPasswordProperty);
+ SaveApnField(storage, storage_group, apn_info, keytag, kApnProperty);
+ SaveApnField(storage, storage_group, apn_info, keytag, kApnUsernameProperty);
+ SaveApnField(storage, storage_group, apn_info, keytag, kApnPasswordProperty);
}
void CellularService::SaveApnField(StoreInterface *storage,
@@ -491,8 +482,8 @@
return;
}
activation_state_ = state;
- adaptor()->EmitStringChanged(flimflam::kActivationStateProperty, state);
- SetConnectableFull(state != flimflam::kActivationStateNotActivated);
+ adaptor()->EmitStringChanged(kActivationStateProperty, state);
+ SetConnectableFull(state != kActivationStateNotActivated);
}
void CellularService::SetOLP(const OLP &olp) {
@@ -500,7 +491,7 @@
return;
}
olp_.CopyFrom(olp);
- adaptor()->EmitStringmapChanged(flimflam::kPaymentPortalProperty,
+ adaptor()->EmitStringmapChanged(kPaymentPortalProperty,
olp.ToDict());
}
@@ -509,7 +500,7 @@
return;
}
usage_url_ = url;
- adaptor()->EmitStringChanged(flimflam::kUsageURLProperty, url);
+ adaptor()->EmitStringChanged(kUsageURLProperty, url);
}
void CellularService::SetNetworkTechnology(const string &technology) {
@@ -517,7 +508,7 @@
return;
}
network_technology_ = technology;
- adaptor()->EmitStringChanged(flimflam::kNetworkTechnologyProperty,
+ adaptor()->EmitStringChanged(kNetworkTechnologyProperty,
technology);
}
@@ -526,7 +517,7 @@
return;
}
roaming_state_ = state;
- adaptor()->EmitStringChanged(flimflam::kRoamingStateProperty, state);
+ adaptor()->EmitStringChanged(kRoamingStateProperty, state);
}
void CellularService::SetOutOfCredits(bool state) {
@@ -546,8 +537,7 @@
return;
}
serving_operator_.CopyFrom(oper);
- adaptor()->EmitStringmapChanged(flimflam::kServingOperatorProperty,
- oper.ToDict());
+ adaptor()->EmitStringmapChanged(kServingOperatorProperty, oper.ToDict());
}
} // namespace shill
diff --git a/cellular_service_unittest.cc b/cellular_service_unittest.cc
index 092d3ed..d46ea3a 100644
--- a/cellular_service_unittest.cc
+++ b/cellular_service_unittest.cc
@@ -82,26 +82,26 @@
{
InSequence call_sequence;
EXPECT_CALL(*adaptor_, EmitStringChanged(
- flimflam::kActivationStateProperty,
- flimflam::kActivationStateNotActivated));
+ kActivationStateProperty,
+ kActivationStateNotActivated));
EXPECT_CALL(*adaptor_, EmitBoolChanged(
- flimflam::kConnectableProperty, false));
+ kConnectableProperty, false));
EXPECT_CALL(*adaptor_, EmitStringChanged(
- flimflam::kActivationStateProperty,
- flimflam::kActivationStateActivating));
+ kActivationStateProperty,
+ kActivationStateActivating));
EXPECT_CALL(*adaptor_, EmitBoolChanged(
- flimflam::kConnectableProperty, true));
+ kConnectableProperty, true));
EXPECT_CALL(*adaptor_, EmitStringChanged(
- flimflam::kActivationStateProperty,
- flimflam::kActivationStatePartiallyActivated));
+ kActivationStateProperty,
+ kActivationStatePartiallyActivated));
EXPECT_CALL(*adaptor_, EmitStringChanged(
- flimflam::kActivationStateProperty,
- flimflam::kActivationStateActivated));
+ kActivationStateProperty,
+ kActivationStateActivated));
EXPECT_CALL(*adaptor_, EmitStringChanged(
- flimflam::kActivationStateProperty,
- flimflam::kActivationStateNotActivated));
+ kActivationStateProperty,
+ kActivationStateNotActivated));
EXPECT_CALL(*adaptor_, EmitBoolChanged(
- flimflam::kConnectableProperty, false));
+ kConnectableProperty, false));
}
EXPECT_CALL(*modem_info_.mock_manager(), HasService(_))
.WillRepeatedly(Return(false));
@@ -109,46 +109,43 @@
EXPECT_TRUE(service_->activation_state().empty());
EXPECT_TRUE(service_->connectable());
- service_->SetActivationState(flimflam::kActivationStateNotActivated);
- EXPECT_EQ(flimflam::kActivationStateNotActivated,
- service_->activation_state());
+ service_->SetActivationState(kActivationStateNotActivated);
+ EXPECT_EQ(kActivationStateNotActivated, service_->activation_state());
EXPECT_FALSE(service_->connectable());
- service_->SetActivationState(flimflam::kActivationStateActivating);
- EXPECT_EQ(flimflam::kActivationStateActivating, service_->activation_state());
+ service_->SetActivationState(kActivationStateActivating);
+ EXPECT_EQ(kActivationStateActivating, service_->activation_state());
EXPECT_TRUE(service_->connectable());
- service_->SetActivationState(flimflam::kActivationStatePartiallyActivated);
- EXPECT_EQ(flimflam::kActivationStatePartiallyActivated,
- service_->activation_state());
+ service_->SetActivationState(kActivationStatePartiallyActivated);
+ EXPECT_EQ(kActivationStatePartiallyActivated, service_->activation_state());
EXPECT_TRUE(service_->connectable());
- service_->SetActivationState(flimflam::kActivationStateActivated);
- EXPECT_EQ(flimflam::kActivationStateActivated, service_->activation_state());
+ service_->SetActivationState(kActivationStateActivated);
+ EXPECT_EQ(kActivationStateActivated, service_->activation_state());
EXPECT_TRUE(service_->connectable());
- service_->SetActivationState(flimflam::kActivationStateNotActivated);
- EXPECT_EQ(flimflam::kActivationStateNotActivated,
- service_->activation_state());
+ service_->SetActivationState(kActivationStateNotActivated);
+ EXPECT_EQ(kActivationStateNotActivated, service_->activation_state());
EXPECT_FALSE(service_->connectable());
}
TEST_F(CellularServiceTest, SetNetworkTechnology) {
- EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kNetworkTechnologyProperty,
- flimflam::kNetworkTechnologyUmts));
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kNetworkTechnologyProperty,
+ kNetworkTechnologyUmts));
EXPECT_TRUE(service_->network_technology().empty());
- service_->SetNetworkTechnology(flimflam::kNetworkTechnologyUmts);
- EXPECT_EQ(flimflam::kNetworkTechnologyUmts, service_->network_technology());
- service_->SetNetworkTechnology(flimflam::kNetworkTechnologyUmts);
+ service_->SetNetworkTechnology(kNetworkTechnologyUmts);
+ EXPECT_EQ(kNetworkTechnologyUmts, service_->network_technology());
+ service_->SetNetworkTechnology(kNetworkTechnologyUmts);
}
TEST_F(CellularServiceTest, SetRoamingState) {
- EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kRoamingStateProperty,
- flimflam::kRoamingStateHome));
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kRoamingStateProperty,
+ kRoamingStateHome));
EXPECT_TRUE(service_->roaming_state().empty());
- service_->SetRoamingState(flimflam::kRoamingStateHome);
- EXPECT_EQ(flimflam::kRoamingStateHome, service_->roaming_state());
- service_->SetRoamingState(flimflam::kRoamingStateHome);
+ service_->SetRoamingState(kRoamingStateHome);
+ EXPECT_EQ(kRoamingStateHome, service_->roaming_state());
+ service_->SetRoamingState(kRoamingStateHome);
}
TEST_F(CellularServiceTest, FriendlyName) {
@@ -159,7 +156,7 @@
}
TEST_F(CellularServiceTest, SetStorageIdentifier) {
- EXPECT_EQ(string(flimflam::kTypeCellular) + "_" +
+ EXPECT_EQ(string(kTypeCellular) + "_" +
kAddress + "_" + GetFriendlyName(),
service_->GetStorageIdentifier());
service_->SetStorageIdentifier("a b c");
@@ -168,7 +165,7 @@
TEST_F(CellularServiceTest, SetServingOperator) {
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kServingOperatorProperty, _));
+ EmitStringmapChanged(kServingOperatorProperty, _));
static const char kCode[] = "123456";
static const char kName[] = "Some Cellular Operator";
Cellular::Operator oper;
@@ -183,7 +180,7 @@
TEST_F(CellularServiceTest, SetOLP) {
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kPaymentPortalProperty, _));
+ EmitStringmapChanged(kPaymentPortalProperty, _));
static const char kURL[] = "payment.url";
static const char kMethod[] = "GET";
CellularService::OLP olp;
@@ -198,7 +195,7 @@
TEST_F(CellularServiceTest, SetUsageURL) {
static const char kUsageURL[] = "usage.url";
- EXPECT_CALL(*adaptor_, EmitStringChanged(flimflam::kUsageURLProperty,
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kUsageURLProperty,
kUsageURL));
EXPECT_TRUE(service_->usage_url().empty());
service_->SetUsageURL(kUsageURL);
@@ -215,24 +212,24 @@
service_->set_profile(profile);
Error error;
Stringmap testapn;
- testapn[flimflam::kApnProperty] = kApn;
- testapn[flimflam::kApnUsernameProperty] = kUsername;
+ testapn[kApnProperty] = kApn;
+ testapn[kApnUsernameProperty] = kUsername;
{
InSequence seq;
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ EmitStringmapChanged(kCellularLastGoodApnProperty,
_));
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularApnProperty, _));
+ EmitStringmapChanged(kCellularApnProperty, _));
}
service_->SetApn(testapn, &error);
EXPECT_TRUE(error.IsSuccess());
Stringmap resultapn = service_->GetApn(&error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(2, resultapn.size());
- Stringmap::const_iterator it = resultapn.find(flimflam::kApnProperty);
+ Stringmap::const_iterator it = resultapn.find(kApnProperty);
EXPECT_TRUE(it != resultapn.end() && it->second == kApn);
- it = resultapn.find(flimflam::kApnUsernameProperty);
+ it = resultapn.find(kApnUsernameProperty);
EXPECT_TRUE(it != resultapn.end() && it->second == kUsername);
EXPECT_FALSE(service_->GetUserSpecifiedApn() == NULL);
}
@@ -247,15 +244,15 @@
Error error;
// Set up an APN to make sure that it later gets cleared.
Stringmap testapn;
- testapn[flimflam::kApnProperty] = kApn;
- testapn[flimflam::kApnUsernameProperty] = kUsername;
+ testapn[kApnProperty] = kApn;
+ testapn[kApnUsernameProperty] = kUsername;
{
InSequence seq;
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ EmitStringmapChanged(kCellularLastGoodApnProperty,
_));
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularApnProperty, _));
+ EmitStringmapChanged(kCellularApnProperty, _));
}
service_->SetApn(testapn, &error);
Stringmap resultapn = service_->GetApn(&error);
@@ -264,10 +261,10 @@
Stringmap emptyapn;
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ EmitStringmapChanged(kCellularLastGoodApnProperty,
_)).Times(0);
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularApnProperty, _)).Times(1);
+ EmitStringmapChanged(kCellularApnProperty, _)).Times(1);
service_->SetApn(emptyapn, &error);
EXPECT_TRUE(error.IsSuccess());
resultapn = service_->GetApn(&error);
@@ -283,30 +280,30 @@
modem_info_.manager()));
service_->set_profile(profile);
Stringmap testapn;
- testapn[flimflam::kApnProperty] = kApn;
- testapn[flimflam::kApnUsernameProperty] = kUsername;
+ testapn[kApnProperty] = kApn;
+ testapn[kApnUsernameProperty] = kUsername;
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty, _));
+ EmitStringmapChanged(kCellularLastGoodApnProperty, _));
service_->SetLastGoodApn(testapn);
Stringmap *resultapn = service_->GetLastGoodApn();
EXPECT_FALSE(resultapn == NULL);
EXPECT_EQ(2, resultapn->size());
- Stringmap::const_iterator it = resultapn->find(flimflam::kApnProperty);
+ Stringmap::const_iterator it = resultapn->find(kApnProperty);
EXPECT_TRUE(it != resultapn->end() && it->second == kApn);
- it = resultapn->find(flimflam::kApnUsernameProperty);
+ it = resultapn->find(kApnUsernameProperty);
EXPECT_TRUE(it != resultapn->end() && it->second == kUsername);
// Now set the user-specified APN, and check that LastGoodApn got
// cleared.
Stringmap userapn;
- userapn[flimflam::kApnProperty] = kApn;
- userapn[flimflam::kApnUsernameProperty] = kUsername;
+ userapn[kApnProperty] = kApn;
+ userapn[kApnUsernameProperty] = kUsername;
{
InSequence seq;
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularLastGoodApnProperty,
+ EmitStringmapChanged(kCellularLastGoodApnProperty,
_));
EXPECT_CALL(*adaptor_,
- EmitStringmapChanged(flimflam::kCellularApnProperty, _));
+ EmitStringmapChanged(kCellularApnProperty, _));
}
Error error;
service_->SetApn(userapn, &error);
@@ -594,16 +591,13 @@
service_->SetActivateOverNonCellularNetwork(!activate_over_non_cellular);
Mock::VerifyAndClearExpectations(adaptor_);
- EXPECT_NE(flimflam::kActivationStateNotActivated,
- service_->activation_state());
- EXPECT_CALL(*adaptor_,
- EmitStringChanged(flimflam::kActivationStateProperty, _));
- service_->SetActivationState(flimflam::kActivationStateNotActivated);
+ EXPECT_NE(kActivationStateNotActivated, service_->activation_state());
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kActivationStateProperty, _));
+ service_->SetActivationState(kActivationStateNotActivated);
Mock::VerifyAndClearExpectations(adaptor_);
string network_technology = service_->network_technology();
- EXPECT_CALL(*adaptor_,
- EmitStringChanged(flimflam::kNetworkTechnologyProperty, _));
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kNetworkTechnologyProperty, _));
service_->SetNetworkTechnology(network_technology + "and some new stuff");
Mock::VerifyAndClearExpectations(adaptor_);
@@ -613,8 +607,7 @@
Mock::VerifyAndClearExpectations(adaptor_);
string roaming_state = service_->roaming_state();
- EXPECT_CALL(*adaptor_,
- EmitStringChanged(flimflam::kRoamingStateProperty, _));
+ EXPECT_CALL(*adaptor_, EmitStringChanged(kRoamingStateProperty, _));
service_->SetRoamingState(roaming_state + "and some new stuff");
Mock::VerifyAndClearExpectations(adaptor_);
}
@@ -633,8 +626,8 @@
Stringmap testapn;
ProfileRefPtr profile(new NiceMock<MockProfile>(nullptr, nullptr, nullptr));
service_->set_profile(profile);
- testapn[flimflam::kApnProperty] = kApn;
- testapn[flimflam::kApnUsernameProperty] = kUsername;
+ testapn[kApnProperty] = kApn;
+ testapn[kApnUsernameProperty] = kUsername;
// ... then set to a known value ...
EXPECT_TRUE(service_->SetApn(testapn, &error));
EXPECT_TRUE(error.IsSuccess());
diff --git a/cellular_unittest.cc b/cellular_unittest.cc
index 3f95ebd..2849466 100644
--- a/cellular_unittest.cc
+++ b/cellular_unittest.cc
@@ -91,7 +91,7 @@
};
TEST_F(CellularPropertyTest, Contains) {
- EXPECT_TRUE(device_->store().Contains(flimflam::kNameProperty));
+ EXPECT_TRUE(device_->store().Contains(kNameProperty));
EXPECT_FALSE(device_->store().Contains(""));
}
@@ -102,7 +102,7 @@
allow_roaming.writer().append_bool(true);
EXPECT_TRUE(DBusAdaptor::SetProperty(
device_->mutable_store(),
- flimflam::kCellularAllowRoamingProperty,
+ kCellularAllowRoamingProperty,
allow_roaming,
&error));
}
@@ -110,7 +110,7 @@
{
::DBus::Error error;
EXPECT_FALSE(DBusAdaptor::SetProperty(device_->mutable_store(),
- flimflam::kAddressProperty,
+ kAddressProperty,
PropertyStoreTest::kStringV,
&error));
ASSERT_TRUE(error.is_set()); // name() may be invalid otherwise
@@ -119,7 +119,7 @@
{
::DBus::Error error;
EXPECT_FALSE(DBusAdaptor::SetProperty(device_->mutable_store(),
- flimflam::kCarrierProperty,
+ kCarrierProperty,
PropertyStoreTest::kStringV,
&error));
ASSERT_TRUE(error.is_set()); // name() may be invalid otherwise
@@ -307,7 +307,7 @@
EXPECT_CALL(*proxy_,
GetModemInfo(_, _, CellularCapability::kTimeoutDefault))
.WillOnce(Invoke(this, &CellularTest::InvokeGetModemInfo));
- if (network_technology == flimflam::kNetworkTechnology1Xrtt)
+ if (network_technology == kNetworkTechnology1Xrtt)
EXPECT_CALL(*cdma_proxy_, GetRegistrationState(NULL, _, _))
.WillOnce(Invoke(this, &CellularTest::InvokeGetRegistrationState1X));
else
@@ -495,7 +495,7 @@
TEST_F(CellularTest, StartCDMARegister) {
SetCellularType(Cellular::kTypeCDMA);
- ExpectCdmaStartModem(flimflam::kNetworkTechnology1Xrtt);
+ ExpectCdmaStartModem(kNetworkTechnology1Xrtt);
EXPECT_CALL(*cdma_proxy_, MEID()).WillOnce(Return(kMEID));
Error error;
device_->Start(&error, Bind(&CellularTest::TestCallback, Unretained(this)));
@@ -504,10 +504,9 @@
EXPECT_EQ(kTestCarrier, GetCapabilityClassic()->carrier_);
EXPECT_EQ(Cellular::kStateRegistered, device_->state_);
ASSERT_TRUE(device_->service_.get());
- EXPECT_EQ(flimflam::kNetworkTechnology1Xrtt,
- device_->service_->network_technology());
+ EXPECT_EQ(kNetworkTechnology1Xrtt, device_->service_->network_technology());
EXPECT_EQ(kStrength, device_->service_->strength());
- EXPECT_EQ(flimflam::kRoamingStateHome, device_->service_->roaming_state());
+ EXPECT_EQ(kRoamingStateHome, device_->service_->roaming_state());
}
TEST_F(CellularTest, StartGSMRegister) {
@@ -554,11 +553,10 @@
EXPECT_EQ(kMSISDN, GetCapabilityGSM()->mdn_);
EXPECT_EQ(Cellular::kStateRegistered, device_->state_);
ASSERT_TRUE(device_->service_.get());
- EXPECT_EQ(flimflam::kNetworkTechnologyEdge,
- device_->service_->network_technology());
+ EXPECT_EQ(kNetworkTechnologyEdge, device_->service_->network_technology());
EXPECT_TRUE(GetCapabilityGSM()->sim_lock_status_.enabled);
EXPECT_EQ(kStrength, device_->service_->strength());
- EXPECT_EQ(flimflam::kRoamingStateRoaming, device_->service_->roaming_state());
+ EXPECT_EQ(kRoamingStateRoaming, device_->service_->roaming_state());
EXPECT_EQ(kNetworkID, device_->service_->serving_operator().GetCode());
EXPECT_EQ(kTestCarrier, device_->service_->serving_operator().GetName());
EXPECT_EQ("ch", device_->service_->serving_operator().GetCountry());
@@ -570,7 +568,7 @@
SetCellularType(Cellular::kTypeCDMA);
device_->set_modem_state(Cellular::kModemStateConnected);
GetCapabilityClassic()->meid_ = kMEID;
- ExpectCdmaStartModem(flimflam::kNetworkTechnologyEvdo);
+ ExpectCdmaStartModem(kNetworkTechnologyEvdo);
Error error;
device_->Start(&error, Bind(&CellularTest::TestCallback, Unretained(this)));
EXPECT_TRUE(error.IsSuccess());
@@ -584,7 +582,7 @@
SetCellularType(Cellular::kTypeCDMA);
device_->set_modem_state(Cellular::kModemStateConnected);
GetCapabilityClassic()->meid_ = kMEID;
- ExpectCdmaStartModem(flimflam::kNetworkTechnologyEvdo);
+ ExpectCdmaStartModem(kNetworkTechnologyEvdo);
EXPECT_CALL(dhcp_provider_, CreateConfig(kTestDeviceName, _, _, _))
.WillOnce(Return(dhcp_config_));
EXPECT_CALL(*dhcp_config_, RequestIP()).WillOnce(Return(true));
@@ -649,7 +647,7 @@
SetService();
device_->allow_roaming_ = false;
- device_->service_->roaming_state_ = flimflam::kRoamingStateRoaming;
+ device_->service_->roaming_state_ = kRoamingStateRoaming;
device_->Connect(&error);
EXPECT_EQ(Error::kNotOnHomeNetwork, error.type());
@@ -660,7 +658,7 @@
.Times(2)
.WillRepeatedly(Invoke(this, &CellularTest::InvokeConnect));
GetCapabilityClassic()->simple_proxy_.reset(simple_proxy_.release());
- device_->service_->roaming_state_ = flimflam::kRoamingStateHome;
+ device_->service_->roaming_state_ = kRoamingStateHome;
device_->state_ = Cellular::kStateRegistered;
device_->Connect(&error);
EXPECT_TRUE(error.IsSuccess());
@@ -668,7 +666,7 @@
EXPECT_EQ(Cellular::kStateConnected, device_->state_);
device_->allow_roaming_ = true;
- device_->service_->roaming_state_ = flimflam::kRoamingStateRoaming;
+ device_->service_->roaming_state_ = kRoamingStateRoaming;
device_->state_ = Cellular::kStateRegistered;
device_->Connect(&error);
EXPECT_TRUE(error.IsSuccess());