update_engine: Remove references to bluetooth and wimax
Shill does not support bluetooth (kTypeBluetooth is left over from the
flimflam API) and has stopped supporting Wimax.
BUG=chromium:954635
TEST=`FEATURES="test" emerge-$BOARD update_engine update_engine-client`
Change-Id: I3e7d4f0b0a7625067585b6f9fdeec196b87f7026
Reviewed-on: https://chromium-review.googlesource.com/c/aosp/platform/system/update_engine/+/1752329
Reviewed-by: Amin Hassani <ahassani@chromium.org>
Tested-by: Alex Khouderchah <akhouderchah@chromium.org>
Commit-Queue: Alex Khouderchah <akhouderchah@chromium.org>
diff --git a/connection_manager.cc b/connection_manager.cc
index 7263a74..ad7e5f6 100644
--- a/connection_manager.cc
+++ b/connection_manager.cc
@@ -54,66 +54,57 @@
bool ConnectionManager::IsUpdateAllowedOver(
ConnectionType type, ConnectionTethering tethering) const {
- switch (type) {
- case ConnectionType::kBluetooth:
- return false;
-
- case ConnectionType::kCellular: {
- set<string> allowed_types;
-
- const policy::DevicePolicy* device_policy =
- system_state_->device_policy();
-
- // The device_policy is loaded in a lazy way before an update check. Load
- // it now from the libbrillo cache if it wasn't already loaded.
- if (!device_policy) {
- UpdateAttempter* update_attempter = system_state_->update_attempter();
- if (update_attempter) {
- update_attempter->RefreshDevicePolicy();
- device_policy = system_state_->device_policy();
- }
- }
-
- if (!device_policy) {
- // Device policy fails to be loaded (possibly due to guest account). We
- // do not check the local user setting here, which should be checked by
- // |OmahaRequestAction| during checking for update.
- LOG(INFO) << "Allowing updates over cellular as device policy "
- "fails to be loaded.";
- return true;
- }
-
- if (device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
- // The update setting is enforced by the device policy.
-
- if (!base::ContainsKey(allowed_types, shill::kTypeCellular)) {
- LOG(INFO) << "Disabling updates over cellular connection as it's not "
- "allowed in the device policy.";
- return false;
- }
-
- LOG(INFO) << "Allowing updates over cellular per device policy.";
- return true;
- }
-
- // If there's no update setting in the device policy, we do not check
- // the local user setting here, which should be checked by
- // |OmahaRequestAction| during checking for update.
- LOG(INFO) << "Allowing updates over cellular as device policy does "
- "not include update setting.";
+ if (type != ConnectionType::kCellular) {
+ if (tethering != ConnectionTethering::kConfirmed) {
return true;
}
- default:
- if (tethering == ConnectionTethering::kConfirmed) {
- // Treat this connection as if it is a cellular connection.
- LOG(INFO) << "Current connection is confirmed tethered, using Cellular "
- "setting.";
- return IsUpdateAllowedOver(ConnectionType::kCellular,
- ConnectionTethering::kUnknown);
- }
- return true;
+ // Treat this connection as if it is a cellular connection.
+ LOG(INFO)
+ << "Current connection is confirmed tethered, using Cellular setting.";
}
+
+ const policy::DevicePolicy* device_policy = system_state_->device_policy();
+
+ // The device_policy is loaded in a lazy way before an update check. Load
+ // it now from the libbrillo cache if it wasn't already loaded.
+ if (!device_policy) {
+ UpdateAttempter* update_attempter = system_state_->update_attempter();
+ if (update_attempter) {
+ update_attempter->RefreshDevicePolicy();
+ device_policy = system_state_->device_policy();
+ }
+ }
+
+ if (!device_policy) {
+ // Device policy fails to be loaded (possibly due to guest account). We
+ // do not check the local user setting here, which should be checked by
+ // |OmahaRequestAction| during checking for update.
+ LOG(INFO) << "Allowing updates over cellular as device policy fails to be "
+ "loaded.";
+ return true;
+ }
+
+ set<string> allowed_types;
+ if (device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
+ // The update setting is enforced by the device policy.
+
+ if (!base::ContainsKey(allowed_types, shill::kTypeCellular)) {
+ LOG(INFO) << "Disabling updates over cellular connection as it's not "
+ "allowed in the device policy.";
+ return false;
+ }
+
+ LOG(INFO) << "Allowing updates over cellular per device policy.";
+ return true;
+ }
+
+ // If there's no update setting in the device policy, we do not check
+ // the local user setting here, which should be checked by
+ // |OmahaRequestAction| during checking for update.
+ LOG(INFO) << "Allowing updates over cellular as device policy does "
+ "not include update setting.";
+ return true;
}
bool ConnectionManager::IsAllowedConnectionTypesForUpdateSet() const {
diff --git a/connection_manager_unittest.cc b/connection_manager_unittest.cc
index 3cdaf4c..97436c9 100644
--- a/connection_manager_unittest.cc
+++ b/connection_manager_unittest.cc
@@ -184,9 +184,6 @@
TEST_F(ConnectionManagerTest, SimpleTest) {
TestWithServiceType(shill::kTypeEthernet, nullptr, ConnectionType::kEthernet);
TestWithServiceType(shill::kTypeWifi, nullptr, ConnectionType::kWifi);
- TestWithServiceType(shill::kTypeWimax, nullptr, ConnectionType::kWimax);
- TestWithServiceType(
- shill::kTypeBluetooth, nullptr, ConnectionType::kBluetooth);
TestWithServiceType(shill::kTypeCellular, nullptr, ConnectionType::kCellular);
}
@@ -195,8 +192,6 @@
TestWithServiceType(
shill::kTypeVPN, shill::kTypeVPN, ConnectionType::kUnknown);
TestWithServiceType(shill::kTypeVPN, shill::kTypeWifi, ConnectionType::kWifi);
- TestWithServiceType(
- shill::kTypeVPN, shill::kTypeWimax, ConnectionType::kWimax);
}
TEST_F(ConnectionManagerTest, TetheringTest) {
@@ -229,16 +224,6 @@
ConnectionTethering::kUnknown));
}
-TEST_F(ConnectionManagerTest, AllowUpdatesOverWimaxTest) {
- EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWimax,
- ConnectionTethering::kUnknown));
-}
-
-TEST_F(ConnectionManagerTest, BlockUpdatesOverBluetoothTest) {
- EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kBluetooth,
- ConnectionTethering::kUnknown));
-}
-
TEST_F(ConnectionManagerTest, AllowUpdatesOnlyOver3GPerPolicyTest) {
policy::MockDevicePolicy allow_3g_policy;
@@ -263,10 +248,9 @@
// This test tests multiple connection types being allowed, with
// 3G one among them. Only Cellular is currently enforced by the policy
- // setting, the others are ignored (see Bluetooth for example).
+ // setting.
set<string> allowed_set;
allowed_set.insert(StringForConnectionType(ConnectionType::kCellular));
- allowed_set.insert(StringForConnectionType(ConnectionType::kBluetooth));
EXPECT_CALL(allow_3g_policy, GetAllowedConnectionTypesForUpdate(_))
.Times(3)
@@ -280,10 +264,6 @@
ConnectionTethering::kUnknown));
EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWifi,
ConnectionTethering::kUnknown));
- EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWimax,
- ConnectionTethering::kUnknown));
- EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kBluetooth,
- ConnectionTethering::kUnknown));
// Tethered networks are treated in the same way as Cellular networks and
// thus allowed.
@@ -325,7 +305,6 @@
set<string> allowed_set;
allowed_set.insert(StringForConnectionType(ConnectionType::kEthernet));
allowed_set.insert(StringForConnectionType(ConnectionType::kWifi));
- allowed_set.insert(StringForConnectionType(ConnectionType::kWimax));
EXPECT_CALL(block_3g_policy, GetAllowedConnectionTypesForUpdate(_))
.Times(1)
@@ -363,10 +342,6 @@
StringForConnectionType(ConnectionType::kEthernet));
EXPECT_STREQ(shill::kTypeWifi,
StringForConnectionType(ConnectionType::kWifi));
- EXPECT_STREQ(shill::kTypeWimax,
- StringForConnectionType(ConnectionType::kWimax));
- EXPECT_STREQ(shill::kTypeBluetooth,
- StringForConnectionType(ConnectionType::kBluetooth));
EXPECT_STREQ(shill::kTypeCellular,
StringForConnectionType(ConnectionType::kCellular));
EXPECT_STREQ("Unknown", StringForConnectionType(ConnectionType::kUnknown));
diff --git a/connection_utils.cc b/connection_utils.cc
index aeb0163..5af7341 100644
--- a/connection_utils.cc
+++ b/connection_utils.cc
@@ -32,10 +32,6 @@
return ConnectionType::kEthernet;
} else if (type_str == shill::kTypeWifi) {
return ConnectionType::kWifi;
- } else if (type_str == shill::kTypeWimax) {
- return ConnectionType::kWimax;
- } else if (type_str == shill::kTypeBluetooth) {
- return ConnectionType::kBluetooth;
} else if (type_str == shill::kTypeCellular) {
return ConnectionType::kCellular;
} else if (type_str == kTypeDisconnected) {
@@ -61,10 +57,6 @@
return shill::kTypeEthernet;
case ConnectionType::kWifi:
return shill::kTypeWifi;
- case ConnectionType::kWimax:
- return shill::kTypeWimax;
- case ConnectionType::kBluetooth:
- return shill::kTypeBluetooth;
case ConnectionType::kCellular:
return shill::kTypeCellular;
case ConnectionType::kDisconnected:
diff --git a/connection_utils.h b/connection_utils.h
index d5133a1..4e71fcf 100644
--- a/connection_utils.h
+++ b/connection_utils.h
@@ -25,8 +25,6 @@
kDisconnected,
kEthernet,
kWifi,
- kWimax,
- kBluetooth,
kCellular,
kUnknown
};
diff --git a/metrics_constants.h b/metrics_constants.h
index 161d585..167e577 100644
--- a/metrics_constants.h
+++ b/metrics_constants.h
@@ -119,12 +119,12 @@
kUnknown = 0, // Unknown.
kEthernet = 1, // Ethernet.
kWifi = 2, // Wireless.
- kWimax = 3, // WiMax.
- kBluetooth = 4, // Bluetooth.
kCellular = 5, // Cellular.
kTetheredEthernet = 6, // Tethered (Ethernet).
kTetheredWifi = 7, // Tethered (Wifi).
kDisconnected = 8, // Disconnected.
+ // deprecated: kWimax = 3,
+ // deprecated: kBluetooth = 4,
kNumConstants,
kUnset = -1
diff --git a/metrics_utils.cc b/metrics_utils.cc
index 070626a..88c8d52 100644
--- a/metrics_utils.cc
+++ b/metrics_utils.cc
@@ -266,12 +266,6 @@
else
return metrics::ConnectionType::kWifi;
- case ConnectionType::kWimax:
- return metrics::ConnectionType::kWimax;
-
- case ConnectionType::kBluetooth:
- return metrics::ConnectionType::kBluetooth;
-
case ConnectionType::kCellular:
return metrics::ConnectionType::kCellular;
}
diff --git a/metrics_utils_unittest.cc b/metrics_utils_unittest.cc
index e7c4c26..6ea996f 100644
--- a/metrics_utils_unittest.cc
+++ b/metrics_utils_unittest.cc
@@ -41,12 +41,6 @@
EXPECT_EQ(
metrics::ConnectionType::kWifi,
GetConnectionType(ConnectionType::kWifi, ConnectionTethering::kUnknown));
- EXPECT_EQ(
- metrics::ConnectionType::kWimax,
- GetConnectionType(ConnectionType::kWimax, ConnectionTethering::kUnknown));
- EXPECT_EQ(metrics::ConnectionType::kBluetooth,
- GetConnectionType(ConnectionType::kBluetooth,
- ConnectionTethering::kUnknown));
EXPECT_EQ(metrics::ConnectionType::kCellular,
GetConnectionType(ConnectionType::kCellular,
ConnectionTethering::kUnknown));
diff --git a/update_manager/boxed_value_unittest.cc b/update_manager/boxed_value_unittest.cc
index f98b6b6..5b87a7b 100644
--- a/update_manager/boxed_value_unittest.cc
+++ b/update_manager/boxed_value_unittest.cc
@@ -168,11 +168,6 @@
BoxedValue(new ConnectionType(ConnectionType::kEthernet)).ToString());
EXPECT_EQ("wifi",
BoxedValue(new ConnectionType(ConnectionType::kWifi)).ToString());
- EXPECT_EQ("wimax",
- BoxedValue(new ConnectionType(ConnectionType::kWimax)).ToString());
- EXPECT_EQ(
- "bluetooth",
- BoxedValue(new ConnectionType(ConnectionType::kBluetooth)).ToString());
EXPECT_EQ(
"cellular",
BoxedValue(new ConnectionType(ConnectionType::kCellular)).ToString());
@@ -219,9 +214,9 @@
TEST(UmBoxedValueTest, SetConnectionTypeToString) {
set<ConnectionType>* set1 = new set<ConnectionType>;
- set1->insert(ConnectionType::kWimax);
+ set1->insert(ConnectionType::kCellular);
set1->insert(ConnectionType::kEthernet);
- EXPECT_EQ("ethernet,wimax", BoxedValue(set1).ToString());
+ EXPECT_EQ("ethernet,cellular", BoxedValue(set1).ToString());
set<ConnectionType>* set2 = new set<ConnectionType>;
set2->insert(ConnectionType::kWifi);
diff --git a/update_manager/chromeos_policy.cc b/update_manager/chromeos_policy.cc
index 08c355e..12d443d 100644
--- a/update_manager/chromeos_policy.cc
+++ b/update_manager/chromeos_policy.cc
@@ -457,7 +457,7 @@
// TODO(garnold) The current logic generally treats the list of allowed
// connections coming from the device policy as a whitelist, meaning that it
// can only be used for enabling connections, but not disable them. Further,
-// certain connection types (like Bluetooth) cannot be enabled even by policy.
+// certain connection types cannot be enabled even by policy.
// In effect, the only thing that device policy can change is to enable
// updates over a cellular network (disabled by default). We may want to
// revisit this semantics, allowing greater flexibility in defining specific
@@ -488,10 +488,6 @@
*result = true;
bool device_policy_can_override = false;
switch (conn_type) {
- case ConnectionType::kBluetooth:
- *result = false;
- break;
-
case ConnectionType::kCellular:
*result = false;
device_policy_can_override = true;
diff --git a/update_manager/chromeos_policy_unittest.cc b/update_manager/chromeos_policy_unittest.cc
index 25c91fa..414ac0d 100644
--- a/update_manager/chromeos_policy_unittest.cc
+++ b/update_manager/chromeos_policy_unittest.cc
@@ -1440,47 +1440,6 @@
EXPECT_TRUE(result);
}
-TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWimaxDefault) {
- // Wimax is always allowed.
-
- fake_state_.shill_provider()->var_conn_type()->reset(
- new ConnectionType(ConnectionType::kWifi));
-
- bool result;
- ExpectPolicyStatus(
- EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
- EXPECT_TRUE(result);
-}
-
-TEST_F(UmChromeOSPolicyTest,
- UpdateCurrentConnectionNotAllowedBluetoothDefault) {
- // Bluetooth is never allowed.
-
- fake_state_.shill_provider()->var_conn_type()->reset(
- new ConnectionType(ConnectionType::kBluetooth));
-
- bool result;
- ExpectPolicyStatus(
- EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
-}
-
-TEST_F(UmChromeOSPolicyTest,
- UpdateCurrentConnectionNotAllowedBluetoothPolicyCannotOverride) {
- // Bluetooth cannot be allowed even by policy.
-
- fake_state_.shill_provider()->var_conn_type()->reset(
- new ConnectionType(ConnectionType::kBluetooth));
- set<ConnectionType> allowed_connections;
- allowed_connections.insert(ConnectionType::kBluetooth);
- fake_state_.device_policy_provider()
- ->var_allowed_connection_types_for_update()
- ->reset(new set<ConnectionType>(allowed_connections));
-
- bool result;
- ExpectPolicyStatus(
- EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
-}
-
TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
// Cellular is not allowed by default.
diff --git a/update_manager/real_device_policy_provider_unittest.cc b/update_manager/real_device_policy_provider_unittest.cc
index 8f2c377..84debd1 100644
--- a/update_manager/real_device_policy_provider_unittest.cc
+++ b/update_manager/real_device_policy_provider_unittest.cc
@@ -344,14 +344,14 @@
#else
.Times(1)
#endif // USE_DBUS
- .WillRepeatedly(DoAll(
- SetArgPointee<0>(set<string>{"bluetooth", "wifi", "not-a-type"}),
- Return(true)));
+ .WillRepeatedly(
+ DoAll(SetArgPointee<0>(set<string>{"ethernet", "wifi", "not-a-type"}),
+ Return(true)));
EXPECT_TRUE(provider_->Init());
loop_.RunOnce(false);
UmTestUtils::ExpectVariableHasValue(
- set<ConnectionType>{ConnectionType::kWifi, ConnectionType::kBluetooth},
+ set<ConnectionType>{ConnectionType::kWifi, ConnectionType::kEthernet},
provider_->var_allowed_connection_types_for_update());
}
diff --git a/update_manager/real_shill_provider_unittest.cc b/update_manager/real_shill_provider_unittest.cc
index dcc729a..505f2f8 100644
--- a/update_manager/real_shill_provider_unittest.cc
+++ b/update_manager/real_shill_provider_unittest.cc
@@ -51,8 +51,6 @@
// Fake service paths.
const char* const kFakeEthernetServicePath = "/fake/ethernet/service";
const char* const kFakeWifiServicePath = "/fake/wifi/service";
-const char* const kFakeWimaxServicePath = "/fake/wimax/service";
-const char* const kFakeBluetoothServicePath = "/fake/bluetooth/service";
const char* const kFakeCellularServicePath = "/fake/cellular/service";
const char* const kFakeVpnServicePath = "/fake/vpn/service";
const char* const kFakeUnknownServicePath = "/fake/unknown/service";
@@ -317,21 +315,6 @@
kFakeWifiServicePath, shill::kTypeWifi, ConnectionType::kWifi);
}
-// Test that Wimax connection is identified correctly.
-TEST_F(UmRealShillProviderTest, ReadConnTypeWimax) {
- InitWithDefaultService("/");
- SetupConnectionAndTestType(
- kFakeWimaxServicePath, shill::kTypeWimax, ConnectionType::kWimax);
-}
-
-// Test that Bluetooth connection is identified correctly.
-TEST_F(UmRealShillProviderTest, ReadConnTypeBluetooth) {
- InitWithDefaultService("/");
- SetupConnectionAndTestType(kFakeBluetoothServicePath,
- shill::kTypeBluetooth,
- ConnectionType::kBluetooth);
-}
-
// Test that Cellular connection is identified correctly.
TEST_F(UmRealShillProviderTest, ReadConnTypeCellular) {
InitWithDefaultService("/");