diff options
30 files changed, 343 insertions, 346 deletions
@@ -307,6 +307,7 @@ LOCAL_SRC_FILES := \ boot_control_android.cc \ common_service.cc \ connection_manager.cc \ + connection_utils.cc \ daemon.cc \ dbus_service.cc \ hardware_android.cc \ diff --git a/common_service.cc b/common_service.cc index ade5349e..e284a934 100644 --- a/common_service.cc +++ b/common_service.cc @@ -273,9 +273,8 @@ bool UpdateEngineService::GetUpdateOverCellularPermission(ErrorPtr* /* error */, // Return the current setting based on the same logic used while checking for // updates. A log message could be printed as the result of this test. LOG(INFO) << "Checking if updates over cellular networks are allowed:"; - *out_allowed = cm->IsUpdateAllowedOver( - chromeos_update_engine::NetworkConnectionType::kCellular, - chromeos_update_engine::NetworkTethering::kUnknown); + *out_allowed = cm->IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown); return true; } diff --git a/connection_manager.cc b/connection_manager.cc index 778cba56..13503d9c 100644 --- a/connection_manager.cc +++ b/connection_manager.cc @@ -27,6 +27,7 @@ #include "update_engine/common/prefs.h" #include "update_engine/common/utils.h" +#include "update_engine/connection_utils.h" #include "update_engine/system_state.h" using org::chromium::flimflam::ManagerProxyInterface; @@ -36,48 +37,17 @@ using std::string; namespace chromeos_update_engine { -namespace { - -NetworkConnectionType ParseConnectionType(const string& type_str) { - if (type_str == shill::kTypeEthernet) { - return NetworkConnectionType::kEthernet; - } else if (type_str == shill::kTypeWifi) { - return NetworkConnectionType::kWifi; - } else if (type_str == shill::kTypeWimax) { - return NetworkConnectionType::kWimax; - } else if (type_str == shill::kTypeBluetooth) { - return NetworkConnectionType::kBluetooth; - } else if (type_str == shill::kTypeCellular) { - return NetworkConnectionType::kCellular; - } - return NetworkConnectionType::kUnknown; -} - -NetworkTethering ParseTethering(const string& tethering_str) { - if (tethering_str == shill::kTetheringNotDetectedState) { - return NetworkTethering::kNotDetected; - } else if (tethering_str == shill::kTetheringSuspectedState) { - return NetworkTethering::kSuspected; - } else if (tethering_str == shill::kTetheringConfirmedState) { - return NetworkTethering::kConfirmed; - } - LOG(WARNING) << "Unknown Tethering value: " << tethering_str; - return NetworkTethering::kUnknown; -} - -} // namespace - ConnectionManager::ConnectionManager(ShillProxyInterface* shill_proxy, SystemState* system_state) : shill_proxy_(shill_proxy), system_state_(system_state) {} -bool ConnectionManager::IsUpdateAllowedOver(NetworkConnectionType type, - NetworkTethering tethering) const { +bool ConnectionManager::IsUpdateAllowedOver( + ConnectionType type, ConnectionTethering tethering) const { switch (type) { - case NetworkConnectionType::kBluetooth: + case ConnectionType::kBluetooth: return false; - case NetworkConnectionType::kCellular: { + case ConnectionType::kCellular: { set<string> allowed_types; const policy::DevicePolicy* device_policy = system_state_->device_policy(); @@ -130,40 +100,19 @@ bool ConnectionManager::IsUpdateAllowedOver(NetworkConnectionType type, } default: - if (tethering == NetworkTethering::kConfirmed) { + 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(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown); + return IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown); } return true; } } -// static -const char* ConnectionManager::StringForConnectionType( - NetworkConnectionType type) { - switch (type) { - case NetworkConnectionType::kEthernet: - return shill::kTypeEthernet; - case NetworkConnectionType::kWifi: - return shill::kTypeWifi; - case NetworkConnectionType::kWimax: - return shill::kTypeWimax; - case NetworkConnectionType::kBluetooth: - return shill::kTypeBluetooth; - case NetworkConnectionType::kCellular: - return shill::kTypeCellular; - case NetworkConnectionType::kUnknown: - return "Unknown"; - } - return "Unknown"; -} - bool ConnectionManager::GetConnectionProperties( - NetworkConnectionType* out_type, - NetworkTethering* out_tethering) { + ConnectionType* out_type, ConnectionTethering* out_tethering) { dbus::ObjectPath default_service_path; TEST_AND_RETURN_FALSE(GetDefaultServicePath(&default_service_path)); if (!default_service_path.IsValid()) @@ -195,8 +144,8 @@ bool ConnectionManager::GetDefaultServicePath(dbus::ObjectPath* out_path) { bool ConnectionManager::GetServicePathProperties( const dbus::ObjectPath& path, - NetworkConnectionType* out_type, - NetworkTethering* out_tethering) { + ConnectionType* out_type, + ConnectionTethering* out_tethering) { // We create and dispose the ServiceProxyInterface on every request. std::unique_ptr<ServiceProxyInterface> service = shill_proxy_->GetServiceForPath(path); @@ -209,18 +158,19 @@ bool ConnectionManager::GetServicePathProperties( const auto& prop_tethering = properties.find(shill::kTetheringProperty); if (prop_tethering == properties.end()) { // Set to Unknown if not present. - *out_tethering = NetworkTethering::kUnknown; + *out_tethering = ConnectionTethering::kUnknown; } else { // If the property doesn't contain a string value, the empty string will // become kUnknown. - *out_tethering = ParseTethering(prop_tethering->second.TryGet<string>()); + *out_tethering = connection_utils::ParseConnectionTethering( + prop_tethering->second.TryGet<string>()); } // Populate the out_type property. const auto& prop_type = properties.find(shill::kTypeProperty); if (prop_type == properties.end()) { // Set to Unknown if not present. - *out_type = NetworkConnectionType::kUnknown; + *out_type = ConnectionType::kUnknown; return false; } @@ -232,12 +182,13 @@ bool ConnectionManager::GetServicePathProperties( LOG(ERROR) << "No PhysicalTechnology property found for a VPN" " connection (service: " << path.value() << "). Returning default kUnknown value."; - *out_type = NetworkConnectionType::kUnknown; + *out_type = ConnectionType::kUnknown; } else { - *out_type = ParseConnectionType(prop_physical->second.TryGet<string>()); + *out_type = connection_utils::ParseConnectionType( + prop_physical->second.TryGet<string>()); } } else { - *out_type = ParseConnectionType(type_str); + *out_type = connection_utils::ParseConnectionType(type_str); } return true; } diff --git a/connection_manager.h b/connection_manager.h index 2057f3b1..1143f83a 100644 --- a/connection_manager.h +++ b/connection_manager.h @@ -34,10 +34,6 @@ class SystemState; // TODO(deymo): Remove this class and use ShillProvider from the UpdateManager. class ConnectionManager : public ConnectionManagerInterface { public: - // Returns the string representation corresponding to the given - // connection type. - static const char* StringForConnectionType(NetworkConnectionType type); - // Constructs a new ConnectionManager object initialized with the // given system state. ConnectionManager(ShillProxyInterface* shill_proxy, @@ -45,10 +41,10 @@ class ConnectionManager : public ConnectionManagerInterface { ~ConnectionManager() override = default; // ConnectionManagerInterface overrides. - bool GetConnectionProperties(NetworkConnectionType* out_type, - NetworkTethering* out_tethering) override; - bool IsUpdateAllowedOver(NetworkConnectionType type, - NetworkTethering tethering) const override; + bool GetConnectionProperties(ConnectionType* out_type, + ConnectionTethering* out_tethering) override; + bool IsUpdateAllowedOver(ConnectionType type, + ConnectionTethering tethering) const override; private: // Returns (via out_path) the default network path, or empty string if @@ -56,8 +52,8 @@ class ConnectionManager : public ConnectionManagerInterface { bool GetDefaultServicePath(dbus::ObjectPath* out_path); bool GetServicePathProperties(const dbus::ObjectPath& path, - NetworkConnectionType* out_type, - NetworkTethering* out_tethering); + ConnectionType* out_type, + ConnectionTethering* out_tethering); // The mockable interface to access the shill DBus proxies. ShillProxyInterface* shill_proxy_; diff --git a/connection_manager_interface.h b/connection_manager_interface.h index cb60a3cb..d36ef761 100644 --- a/connection_manager_interface.h +++ b/connection_manager_interface.h @@ -19,23 +19,9 @@ #include <base/macros.h> -namespace chromeos_update_engine { - -enum class NetworkConnectionType { - kEthernet, - kWifi, - kWimax, - kBluetooth, - kCellular, - kUnknown -}; +#include "update_engine/connection_utils.h" -enum class NetworkTethering { - kNotDetected, - kSuspected, - kConfirmed, - kUnknown -}; +namespace chromeos_update_engine { // This class exposes a generic interface to the connection manager // (e.g FlimFlam, Shill, etc.) to consolidate all connection-related @@ -47,14 +33,14 @@ class ConnectionManagerInterface { // Populates |out_type| with the type of the network connection // that we are currently connected and |out_tethering| with the estimate of // whether that network is being tethered. - virtual bool GetConnectionProperties(NetworkConnectionType* out_type, - NetworkTethering* out_tethering) = 0; + virtual bool GetConnectionProperties(ConnectionType* out_type, + ConnectionTethering* out_tethering) = 0; // Returns true if we're allowed to update the system when we're // connected to the internet through the given network connection type and the // given tethering state. - virtual bool IsUpdateAllowedOver(NetworkConnectionType type, - NetworkTethering tethering) const = 0; + virtual bool IsUpdateAllowedOver(ConnectionType type, + ConnectionTethering tethering) const = 0; protected: ConnectionManagerInterface() = default; diff --git a/connection_manager_unittest.cc b/connection_manager_unittest.cc index 612929b6..48f61951 100644 --- a/connection_manager_unittest.cc +++ b/connection_manager_unittest.cc @@ -34,6 +34,7 @@ #include "update_engine/fake_shill_proxy.h" #include "update_engine/fake_system_state.h" +using chromeos_update_engine::connection_utils::StringForConnectionType; using org::chromium::flimflam::ManagerProxyMock; using org::chromium::flimflam::ServiceProxyMock; using std::set; @@ -70,10 +71,10 @@ class ConnectionManagerTest : public ::testing::Test { void TestWithServiceType( const char* service_type, const char* physical_technology, - NetworkConnectionType expected_type); + ConnectionType expected_type); void TestWithServiceTethering( const char* service_tethering, - NetworkTethering expected_tethering); + ConnectionTethering expected_tethering); brillo::FakeMessageLoop loop_{nullptr}; FakeSystemState fake_system_state_; @@ -136,15 +137,15 @@ void ConnectionManagerTest::SetServiceReply(const string& service_path, void ConnectionManagerTest::TestWithServiceType( const char* service_type, const char* physical_technology, - NetworkConnectionType expected_type) { + ConnectionType expected_type) { SetManagerReply("/service/guest/network", true); SetServiceReply("/service/guest/network", service_type, physical_technology, shill::kTetheringNotDetectedState); - NetworkConnectionType type; - NetworkTethering tethering; + ConnectionType type; + ConnectionTethering tethering; EXPECT_TRUE(cmut_.GetConnectionProperties(&type, &tethering)); EXPECT_EQ(expected_type, type); testing::Mock::VerifyAndClearExpectations( @@ -153,13 +154,13 @@ void ConnectionManagerTest::TestWithServiceType( void ConnectionManagerTest::TestWithServiceTethering( const char* service_tethering, - NetworkTethering expected_tethering) { + ConnectionTethering expected_tethering) { SetManagerReply("/service/guest/network", true); SetServiceReply( "/service/guest/network", shill::kTypeWifi, nullptr, service_tethering); - NetworkConnectionType type; - NetworkTethering tethering; + ConnectionType type; + ConnectionTethering tethering; EXPECT_TRUE(cmut_.GetConnectionProperties(&type, &tethering)); EXPECT_EQ(expected_tethering, tethering); testing::Mock::VerifyAndClearExpectations( @@ -167,63 +168,57 @@ void ConnectionManagerTest::TestWithServiceTethering( } TEST_F(ConnectionManagerTest, SimpleTest) { - TestWithServiceType(shill::kTypeEthernet, nullptr, - NetworkConnectionType::kEthernet); - TestWithServiceType(shill::kTypeWifi, nullptr, - NetworkConnectionType::kWifi); - TestWithServiceType(shill::kTypeWimax, nullptr, - NetworkConnectionType::kWimax); - TestWithServiceType(shill::kTypeBluetooth, nullptr, - NetworkConnectionType::kBluetooth); - TestWithServiceType(shill::kTypeCellular, nullptr, - NetworkConnectionType::kCellular); + 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); } TEST_F(ConnectionManagerTest, PhysicalTechnologyTest) { - TestWithServiceType(shill::kTypeVPN, nullptr, - NetworkConnectionType::kUnknown); - TestWithServiceType(shill::kTypeVPN, shill::kTypeVPN, - NetworkConnectionType::kUnknown); - TestWithServiceType(shill::kTypeVPN, shill::kTypeWifi, - NetworkConnectionType::kWifi); - TestWithServiceType(shill::kTypeVPN, shill::kTypeWimax, - NetworkConnectionType::kWimax); + TestWithServiceType(shill::kTypeVPN, nullptr, ConnectionType::kUnknown); + 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) { TestWithServiceTethering(shill::kTetheringConfirmedState, - NetworkTethering::kConfirmed); + ConnectionTethering::kConfirmed); TestWithServiceTethering(shill::kTetheringNotDetectedState, - NetworkTethering::kNotDetected); + ConnectionTethering::kNotDetected); TestWithServiceTethering(shill::kTetheringSuspectedState, - NetworkTethering::kSuspected); + ConnectionTethering::kSuspected); TestWithServiceTethering("I'm not a valid property value =)", - NetworkTethering::kUnknown); + ConnectionTethering::kUnknown); } TEST_F(ConnectionManagerTest, UnknownTest) { - TestWithServiceType("foo", nullptr, NetworkConnectionType::kUnknown); + TestWithServiceType("foo", nullptr, ConnectionType::kUnknown); } TEST_F(ConnectionManagerTest, AllowUpdatesOverEthernetTest) { // Updates over Ethernet are allowed even if there's no policy. - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kEthernet, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, AllowUpdatesOverWifiTest) { - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWifi, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, AllowUpdatesOverWimaxTest) { - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWimax, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWimax, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, BlockUpdatesOverBluetoothTest) { - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kBluetooth, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kBluetooth, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, AllowUpdatesOnlyOver3GPerPolicyTest) { @@ -233,15 +228,14 @@ TEST_F(ConnectionManagerTest, AllowUpdatesOnlyOver3GPerPolicyTest) { // This test tests cellular (3G) being the only connection type being allowed. set<string> allowed_set; - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kCellular)); + allowed_set.insert(StringForConnectionType(ConnectionType::kCellular)); EXPECT_CALL(allow_3g_policy, GetAllowedConnectionTypesForUpdate(_)) .Times(1) .WillOnce(DoAll(SetArgPointee<0>(allowed_set), Return(true))); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, AllowUpdatesOver3GAndOtherTypesPerPolicyTest) { @@ -253,48 +247,46 @@ TEST_F(ConnectionManagerTest, AllowUpdatesOver3GAndOtherTypesPerPolicyTest) { // 3G one among them. Only Cellular is currently enforced by the policy // setting, the others are ignored (see Bluetooth for example). set<string> allowed_set; - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kCellular)); - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kBluetooth)); + allowed_set.insert(StringForConnectionType(ConnectionType::kCellular)); + allowed_set.insert(StringForConnectionType(ConnectionType::kBluetooth)); EXPECT_CALL(allow_3g_policy, GetAllowedConnectionTypesForUpdate(_)) .Times(3) .WillRepeatedly(DoAll(SetArgPointee<0>(allowed_set), Return(true))); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet, - NetworkTethering::kUnknown)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet, - NetworkTethering::kNotDetected)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi, - NetworkTethering::kUnknown)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWimax, - NetworkTethering::kUnknown)); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kBluetooth, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kEthernet, + ConnectionTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kEthernet, + ConnectionTethering::kNotDetected)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + 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. - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet, - NetworkTethering::kConfirmed)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi, - NetworkTethering::kConfirmed)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kEthernet, + ConnectionTethering::kConfirmed)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWifi, + ConnectionTethering::kConfirmed)); } TEST_F(ConnectionManagerTest, BlockUpdatesOverCellularByDefaultTest) { - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, BlockUpdatesOverTetheredNetworkByDefaultTest) { - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi, - NetworkTethering::kConfirmed)); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet, - NetworkTethering::kConfirmed)); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi, - NetworkTethering::kSuspected)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kWifi, + ConnectionTethering::kConfirmed)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kEthernet, + ConnectionTethering::kConfirmed)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kWifi, + ConnectionTethering::kSuspected)); } TEST_F(ConnectionManagerTest, BlockUpdatesOver3GPerPolicyTest) { @@ -305,19 +297,16 @@ TEST_F(ConnectionManagerTest, BlockUpdatesOver3GPerPolicyTest) { // Test that updates for 3G are blocked while updates are allowed // over several other types. set<string> allowed_set; - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kEthernet)); - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kWifi)); - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kWimax)); + 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) .WillOnce(DoAll(SetArgPointee<0>(allowed_set), Return(true))); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, BlockUpdatesOver3GIfErrorInPolicyFetchTest) { @@ -326,8 +315,7 @@ TEST_F(ConnectionManagerTest, BlockUpdatesOver3GIfErrorInPolicyFetchTest) { fake_system_state_.set_device_policy(&allow_3g_policy); set<string> allowed_set; - allowed_set.insert( - cmut_.StringForConnectionType(NetworkConnectionType::kCellular)); + allowed_set.insert(StringForConnectionType(ConnectionType::kCellular)); // Return false for GetAllowedConnectionTypesForUpdate and see // that updates are still blocked for 3G despite the value being in @@ -336,8 +324,8 @@ TEST_F(ConnectionManagerTest, BlockUpdatesOver3GIfErrorInPolicyFetchTest) { .Times(1) .WillOnce(DoAll(SetArgPointee<0>(allowed_set), Return(false))); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, UseUserPrefForUpdatesOverCellularIfNoPolicyTest) { @@ -355,8 +343,8 @@ TEST_F(ConnectionManagerTest, UseUserPrefForUpdatesOverCellularIfNoPolicyTest) { EXPECT_CALL(*prefs, Exists(kPrefsUpdateOverCellularPermission)) .Times(1) .WillOnce(Return(false)); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); // Allow per user pref. EXPECT_CALL(*prefs, Exists(kPrefsUpdateOverCellularPermission)) @@ -365,8 +353,8 @@ TEST_F(ConnectionManagerTest, UseUserPrefForUpdatesOverCellularIfNoPolicyTest) { EXPECT_CALL(*prefs, GetBoolean(kPrefsUpdateOverCellularPermission, _)) .Times(1) .WillOnce(DoAll(SetArgPointee<1>(true), Return(true))); - EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_TRUE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); // Block per user pref. EXPECT_CALL(*prefs, Exists(kPrefsUpdateOverCellularPermission)) @@ -375,34 +363,31 @@ TEST_F(ConnectionManagerTest, UseUserPrefForUpdatesOverCellularIfNoPolicyTest) { EXPECT_CALL(*prefs, GetBoolean(kPrefsUpdateOverCellularPermission, _)) .Times(1) .WillOnce(DoAll(SetArgPointee<1>(false), Return(true))); - EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + EXPECT_FALSE(cmut_.IsUpdateAllowedOver(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); } TEST_F(ConnectionManagerTest, StringForConnectionTypeTest) { EXPECT_STREQ(shill::kTypeEthernet, - cmut_.StringForConnectionType(NetworkConnectionType::kEthernet)); + StringForConnectionType(ConnectionType::kEthernet)); EXPECT_STREQ(shill::kTypeWifi, - cmut_.StringForConnectionType(NetworkConnectionType::kWifi)); + StringForConnectionType(ConnectionType::kWifi)); EXPECT_STREQ(shill::kTypeWimax, - cmut_.StringForConnectionType(NetworkConnectionType::kWimax)); + StringForConnectionType(ConnectionType::kWimax)); EXPECT_STREQ(shill::kTypeBluetooth, - cmut_.StringForConnectionType( - NetworkConnectionType::kBluetooth)); + StringForConnectionType(ConnectionType::kBluetooth)); EXPECT_STREQ(shill::kTypeCellular, - cmut_.StringForConnectionType(NetworkConnectionType::kCellular)); + StringForConnectionType(ConnectionType::kCellular)); + EXPECT_STREQ("Unknown", StringForConnectionType(ConnectionType::kUnknown)); EXPECT_STREQ("Unknown", - cmut_.StringForConnectionType(NetworkConnectionType::kUnknown)); - EXPECT_STREQ("Unknown", - cmut_.StringForConnectionType( - static_cast<NetworkConnectionType>(999999))); + StringForConnectionType(static_cast<ConnectionType>(999999))); } TEST_F(ConnectionManagerTest, MalformedServiceList) { SetManagerReply("/service/guest/network", false); - NetworkConnectionType type; - NetworkTethering tethering; + ConnectionType type; + ConnectionTethering tethering; EXPECT_FALSE(cmut_.GetConnectionProperties(&type, &tethering)); } diff --git a/connection_utils.cc b/connection_utils.cc new file mode 100644 index 00000000..9b6b526c --- /dev/null +++ b/connection_utils.cc @@ -0,0 +1,70 @@ +// +// Copyright (C) 2016 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include "update_engine/connection_utils.h" + +#include <shill/dbus-constants.h> + +namespace chromeos_update_engine { +namespace connection_utils { + +ConnectionType ParseConnectionType(const std::string& type_str) { + if (type_str == shill::kTypeEthernet) { + 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; + } + return ConnectionType::kUnknown; +} + +ConnectionTethering ParseConnectionTethering(const std::string& tethering_str) { + if (tethering_str == shill::kTetheringNotDetectedState) { + return ConnectionTethering::kNotDetected; + } else if (tethering_str == shill::kTetheringSuspectedState) { + return ConnectionTethering::kSuspected; + } else if (tethering_str == shill::kTetheringConfirmedState) { + return ConnectionTethering::kConfirmed; + } + return ConnectionTethering::kUnknown; +} + +const char* StringForConnectionType(ConnectionType type) { + switch (type) { + case ConnectionType::kEthernet: + 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::kUnknown: + return "Unknown"; + } + return "Unknown"; +} + +} // namespace connection_utils + +} // namespace chromeos_update_engine diff --git a/connection_utils.h b/connection_utils.h new file mode 100644 index 00000000..e385517b --- /dev/null +++ b/connection_utils.h @@ -0,0 +1,51 @@ +// +// Copyright (C) 2016 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef UPDATE_ENGINE_CONNECTION_UTILS_H_ +#define UPDATE_ENGINE_CONNECTION_UTILS_H_ + +#include <string> + +namespace chromeos_update_engine { + +enum class ConnectionType { + kEthernet, + kWifi, + kWimax, + kBluetooth, + kCellular, + kUnknown +}; + +enum class ConnectionTethering { + kNotDetected, + kSuspected, + kConfirmed, + kUnknown, +}; + +namespace connection_utils { +// Helper methods for converting shill strings into symbolic values. +ConnectionType ParseConnectionType(const std::string& type_str); +ConnectionTethering ParseConnectionTethering(const std::string& tethering_str); + +// Returns the string representation corresponding to the given connection type. +const char* StringForConnectionType(ConnectionType type); +} // namespace connection_utils + +} // namespace chromeos_update_engine + +#endif // UPDATE_ENGINE_CONNECTION_UTILS_H_ diff --git a/metrics_utils.cc b/metrics_utils.cc index e165e897..263bacd2 100644 --- a/metrics_utils.cc +++ b/metrics_utils.cc @@ -228,31 +228,31 @@ metrics::DownloadErrorCode GetDownloadErrorCode(ErrorCode code) { return metrics::DownloadErrorCode::kInputMalformed; } -metrics::ConnectionType GetConnectionType(NetworkConnectionType type, - NetworkTethering tethering) { +metrics::ConnectionType GetConnectionType(ConnectionType type, + ConnectionTethering tethering) { switch (type) { - case NetworkConnectionType::kUnknown: + case ConnectionType::kUnknown: return metrics::ConnectionType::kUnknown; - case NetworkConnectionType::kEthernet: - if (tethering == NetworkTethering::kConfirmed) + case ConnectionType::kEthernet: + if (tethering == ConnectionTethering::kConfirmed) return metrics::ConnectionType::kTetheredEthernet; else return metrics::ConnectionType::kEthernet; - case NetworkConnectionType::kWifi: - if (tethering == NetworkTethering::kConfirmed) + case ConnectionType::kWifi: + if (tethering == ConnectionTethering::kConfirmed) return metrics::ConnectionType::kTetheredWifi; else return metrics::ConnectionType::kWifi; - case NetworkConnectionType::kWimax: + case ConnectionType::kWimax: return metrics::ConnectionType::kWimax; - case NetworkConnectionType::kBluetooth: + case ConnectionType::kBluetooth: return metrics::ConnectionType::kBluetooth; - case NetworkConnectionType::kCellular: + case ConnectionType::kCellular: return metrics::ConnectionType::kCellular; } diff --git a/metrics_utils.h b/metrics_utils.h index 7c3b02d8..d9826c14 100644 --- a/metrics_utils.h +++ b/metrics_utils.h @@ -17,7 +17,7 @@ #ifndef UPDATE_ENGINE_METRICS_UTILS_H_ #define UPDATE_ENGINE_METRICS_UTILS_H_ -#include "update_engine/connection_manager.h" +#include "update_engine/connection_utils.h" #include "update_engine/metrics.h" namespace chromeos_update_engine { @@ -39,8 +39,8 @@ metrics::DownloadErrorCode GetDownloadErrorCode(ErrorCode code); metrics::AttemptResult GetAttemptResult(ErrorCode code); // Calculates the internet connection type given |type| and |tethering|. -metrics::ConnectionType GetConnectionType(NetworkConnectionType type, - NetworkTethering tethering); +metrics::ConnectionType GetConnectionType(ConnectionType type, + ConnectionTethering tethering); // This function returns the duration on the wallclock since the last // time it was called for the same |state_variable_key| value. diff --git a/metrics_utils_unittest.cc b/metrics_utils_unittest.cc index e702c17a..edf6bc3d 100644 --- a/metrics_utils_unittest.cc +++ b/metrics_utils_unittest.cc @@ -30,51 +30,51 @@ class MetricsUtilsTest : public ::testing::Test {}; TEST(MetricsUtilsTest, GetConnectionType) { // Check that expected combinations map to the right value. EXPECT_EQ(metrics::ConnectionType::kUnknown, - GetConnectionType(NetworkConnectionType::kUnknown, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kUnknown, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kEthernet, - GetConnectionType(NetworkConnectionType::kEthernet, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kEthernet, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(NetworkConnectionType::kWifi, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kWifi, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kWimax, - GetConnectionType(NetworkConnectionType::kWimax, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kWimax, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kBluetooth, - GetConnectionType(NetworkConnectionType::kBluetooth, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kBluetooth, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kCellular, - GetConnectionType(NetworkConnectionType::kCellular, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kCellular, + ConnectionTethering::kUnknown)); EXPECT_EQ(metrics::ConnectionType::kTetheredEthernet, - GetConnectionType(NetworkConnectionType::kEthernet, - NetworkTethering::kConfirmed)); + GetConnectionType(ConnectionType::kEthernet, + ConnectionTethering::kConfirmed)); EXPECT_EQ(metrics::ConnectionType::kTetheredWifi, - GetConnectionType(NetworkConnectionType::kWifi, - NetworkTethering::kConfirmed)); + GetConnectionType(ConnectionType::kWifi, + ConnectionTethering::kConfirmed)); // Ensure that we don't report tethered ethernet unless it's confirmed. EXPECT_EQ(metrics::ConnectionType::kEthernet, - GetConnectionType(NetworkConnectionType::kEthernet, - NetworkTethering::kNotDetected)); + GetConnectionType(ConnectionType::kEthernet, + ConnectionTethering::kNotDetected)); EXPECT_EQ(metrics::ConnectionType::kEthernet, - GetConnectionType(NetworkConnectionType::kEthernet, - NetworkTethering::kSuspected)); + GetConnectionType(ConnectionType::kEthernet, + ConnectionTethering::kSuspected)); EXPECT_EQ(metrics::ConnectionType::kEthernet, - GetConnectionType(NetworkConnectionType::kEthernet, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kEthernet, + ConnectionTethering::kUnknown)); // Ditto for tethered wifi. EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(NetworkConnectionType::kWifi, - NetworkTethering::kNotDetected)); + GetConnectionType(ConnectionType::kWifi, + ConnectionTethering::kNotDetected)); EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(NetworkConnectionType::kWifi, - NetworkTethering::kSuspected)); + GetConnectionType(ConnectionType::kWifi, + ConnectionTethering::kSuspected)); EXPECT_EQ(metrics::ConnectionType::kWifi, - GetConnectionType(NetworkConnectionType::kWifi, - NetworkTethering::kUnknown)); + GetConnectionType(ConnectionType::kWifi, + ConnectionTethering::kUnknown)); } TEST(MetricsUtilsTest, WallclockDurationHelper) { diff --git a/mock_connection_manager.h b/mock_connection_manager.h index 109c529c..e37460b2 100644 --- a/mock_connection_manager.h +++ b/mock_connection_manager.h @@ -31,11 +31,11 @@ class MockConnectionManager : public ConnectionManagerInterface { MockConnectionManager() = default; MOCK_METHOD2(GetConnectionProperties, - bool(NetworkConnectionType* out_type, - NetworkTethering* out_tethering)); + bool(ConnectionType* out_type, + ConnectionTethering* out_tethering)); - MOCK_CONST_METHOD2(IsUpdateAllowedOver, bool(NetworkConnectionType type, - NetworkTethering tethering)); + MOCK_CONST_METHOD2(IsUpdateAllowedOver, + bool(ConnectionType type, ConnectionTethering tethering)); }; } // namespace chromeos_update_engine diff --git a/omaha_request_action.cc b/omaha_request_action.cc index 173d3876..7f18cc4a 100644 --- a/omaha_request_action.cc +++ b/omaha_request_action.cc @@ -40,7 +40,7 @@ #include "update_engine/common/platform_constants.h" #include "update_engine/common/prefs_interface.h" #include "update_engine/common/utils.h" -#include "update_engine/connection_manager.h" +#include "update_engine/connection_manager_interface.h" #include "update_engine/metrics.h" #include "update_engine/metrics_utils.h" #include "update_engine/omaha_request_params.h" @@ -1501,8 +1501,8 @@ bool OmahaRequestAction::ShouldIgnoreUpdate( } bool OmahaRequestAction::IsUpdateAllowedOverCurrentConnection() const { - NetworkConnectionType type; - NetworkTethering tethering; + ConnectionType type; + ConnectionTethering tethering; ConnectionManagerInterface* connection_manager = system_state_->connection_manager(); if (!connection_manager->GetConnectionProperties(&type, &tethering)) { @@ -1512,7 +1512,7 @@ bool OmahaRequestAction::IsUpdateAllowedOverCurrentConnection() const { } bool is_allowed = connection_manager->IsUpdateAllowedOver(type, tethering); LOG(INFO) << "We are connected via " - << ConnectionManager::StringForConnectionType(type) + << connection_utils::StringForConnectionType(type) << ", Updates allowed: " << (is_allowed ? "Yes" : "No"); return is_allowed; } diff --git a/omaha_request_action_unittest.cc b/omaha_request_action_unittest.cc index d4b166fd..82f9ae86 100644 --- a/omaha_request_action_unittest.cc +++ b/omaha_request_action_unittest.cc @@ -467,11 +467,11 @@ TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByConnection) { EXPECT_CALL(mock_cm, GetConnectionProperties(_, _)) .WillRepeatedly( - DoAll(SetArgumentPointee<0>(NetworkConnectionType::kEthernet), - SetArgumentPointee<1>(NetworkTethering::kUnknown), + DoAll(SetArgumentPointee<0>(ConnectionType::kEthernet), + SetArgumentPointee<1>(ConnectionTethering::kUnknown), Return(true))); - EXPECT_CALL(mock_cm, IsUpdateAllowedOver(NetworkConnectionType::kEthernet, _)) - .WillRepeatedly(Return(false)); + EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kEthernet, _)) + .WillRepeatedly(Return(false)); ASSERT_FALSE( TestUpdateCheck(nullptr, // request_params diff --git a/payload_state.cc b/payload_state.cc index af1ad055..1da472f4 100644 --- a/payload_state.cc +++ b/payload_state.cc @@ -31,6 +31,7 @@ #include "update_engine/common/hardware_interface.h" #include "update_engine/common/prefs.h" #include "update_engine/common/utils.h" +#include "update_engine/connection_manager_interface.h" #include "update_engine/metrics_utils.h" #include "update_engine/omaha_request_params.h" #include "update_engine/payload_consumer/install_plan.h" @@ -186,8 +187,8 @@ void PayloadState::AttemptStarted(AttemptType attempt_type) { attempt_num_bytes_downloaded_ = 0; metrics::ConnectionType type; - NetworkConnectionType network_connection_type; - NetworkTethering tethering; + ConnectionType network_connection_type; + ConnectionTethering tethering; ConnectionManagerInterface* connection_manager = system_state_->connection_manager(); if (!connection_manager->GetConnectionProperties(&network_connection_type, diff --git a/update_engine.gyp b/update_engine.gyp index 7a3be60c..880a03af 100644 --- a/update_engine.gyp +++ b/update_engine.gyp @@ -252,6 +252,7 @@ 'boot_control_chromeos.cc', 'common_service.cc', 'connection_manager.cc', + 'connection_utils.cc', 'daemon.cc', 'dbus_service.cc', 'hardware_chromeos.cc', diff --git a/update_manager/boxed_value.cc b/update_manager/boxed_value.cc index a4aeedea..9758d33b 100644 --- a/update_manager/boxed_value.cc +++ b/update_manager/boxed_value.cc @@ -25,9 +25,13 @@ #include <base/time/time.h> #include "update_engine/common/utils.h" +#include "update_engine/connection_utils.h" #include "update_engine/update_manager/shill_provider.h" #include "update_engine/update_manager/updater_provider.h" +using chromeos_update_engine::ConnectionTethering; +using chromeos_update_engine::ConnectionType; +using chromeos_update_engine::connection_utils::StringForConnectionType; using std::set; using std::string; @@ -91,29 +95,10 @@ string BoxedValue::ValuePrinter<base::TimeDelta>(const void* value) { return chromeos_update_engine::utils::FormatTimeDelta(*val); } -static string ConnectionTypeToString(ConnectionType type) { - switch (type) { - case ConnectionType::kEthernet: - return "Ethernet"; - case ConnectionType::kWifi: - return "Wifi"; - case ConnectionType::kWimax: - return "Wimax"; - case ConnectionType::kBluetooth: - return "Bluetooth"; - case ConnectionType::kCellular: - return "Cellular"; - case ConnectionType::kUnknown: - return "Unknown"; - } - NOTREACHED(); - return "Unknown"; -} - template<> string BoxedValue::ValuePrinter<ConnectionType>(const void* value) { const ConnectionType* val = reinterpret_cast<const ConnectionType*>(value); - return ConnectionTypeToString(*val); + return StringForConnectionType(*val); } template<> @@ -125,7 +110,7 @@ string BoxedValue::ValuePrinter<set<ConnectionType>>(const void* value) { ConnectionType type = it; if (ret.size() > 0) ret += ","; - ret += ConnectionTypeToString(type); + ret += StringForConnectionType(type); } return ret; } diff --git a/update_manager/boxed_value_unittest.cc b/update_manager/boxed_value_unittest.cc index 47bfd8f7..3d0c72ee 100644 --- a/update_manager/boxed_value_unittest.cc +++ b/update_manager/boxed_value_unittest.cc @@ -31,6 +31,8 @@ using base::Time; using base::TimeDelta; +using chromeos_update_engine::ConnectionTethering; +using chromeos_update_engine::ConnectionType; using std::list; using std::map; using std::set; diff --git a/update_manager/chromeos_policy.cc b/update_manager/chromeos_policy.cc index 900a845c..ec2b9f0c 100644 --- a/update_manager/chromeos_policy.cc +++ b/update_manager/chromeos_policy.cc @@ -33,6 +33,8 @@ using base::Time; using base::TimeDelta; +using chromeos_update_engine::ConnectionTethering; +using chromeos_update_engine::ConnectionType; using chromeos_update_engine::ErrorCode; using std::get; using std::max; diff --git a/update_manager/chromeos_policy_unittest.cc b/update_manager/chromeos_policy_unittest.cc index 8a1796fe..0c387000 100644 --- a/update_manager/chromeos_policy_unittest.cc +++ b/update_manager/chromeos_policy_unittest.cc @@ -32,6 +32,8 @@ using base::Time; using base::TimeDelta; +using chromeos_update_engine::ConnectionTethering; +using chromeos_update_engine::ConnectionType; using chromeos_update_engine::ErrorCode; using chromeos_update_engine::FakeClock; using std::set; diff --git a/update_manager/device_policy_provider.h b/update_manager/device_policy_provider.h index 0eb04c17..3537d130 100644 --- a/update_manager/device_policy_provider.h +++ b/update_manager/device_policy_provider.h @@ -52,7 +52,7 @@ class DevicePolicyProvider : public Provider { // Variable returning the set of connection types allowed for updates. The // identifiers returned are consistent with the ones returned by the // ShillProvider. - virtual Variable<std::set<ConnectionType>>* + virtual Variable<std::set<chromeos_update_engine::ConnectionType>>* var_allowed_connection_types_for_update() = 0; // Variable stating the name of the device owner. For enterprise enrolled diff --git a/update_manager/fake_device_policy_provider.h b/update_manager/fake_device_policy_provider.h index 0ab2d3cf..9e4f5b76 100644 --- a/update_manager/fake_device_policy_provider.h +++ b/update_manager/fake_device_policy_provider.h @@ -54,7 +54,7 @@ class FakeDevicePolicyProvider : public DevicePolicyProvider { return &var_scatter_factor_; } - FakeVariable<std::set<ConnectionType>>* + FakeVariable<std::set<chromeos_update_engine::ConnectionType>>* var_allowed_connection_types_for_update() override { return &var_allowed_connection_types_for_update_; } @@ -88,7 +88,7 @@ class FakeDevicePolicyProvider : public DevicePolicyProvider { "target_version_prefix", kVariableModePoll}; FakeVariable<base::TimeDelta> var_scatter_factor_{ "scatter_factor", kVariableModePoll}; - FakeVariable<std::set<ConnectionType>> + FakeVariable<std::set<chromeos_update_engine::ConnectionType>> var_allowed_connection_types_for_update_{ "allowed_connection_types_for_update", kVariableModePoll}; FakeVariable<std::string> var_owner_{"owner", kVariableModePoll}; diff --git a/update_manager/fake_shill_provider.h b/update_manager/fake_shill_provider.h index b68e858e..7f1c8f51 100644 --- a/update_manager/fake_shill_provider.h +++ b/update_manager/fake_shill_provider.h @@ -31,11 +31,12 @@ class FakeShillProvider : public ShillProvider { return &var_is_connected_; } - FakeVariable<ConnectionType>* var_conn_type() override { + FakeVariable<chromeos_update_engine::ConnectionType>* var_conn_type() + override { return &var_conn_type_; } - FakeVariable<ConnectionTethering>* + FakeVariable<chromeos_update_engine::ConnectionTethering>* var_conn_tethering() override { return &var_conn_tethering_; } @@ -46,8 +47,9 @@ class FakeShillProvider : public ShillProvider { private: FakeVariable<bool> var_is_connected_{"is_connected", kVariableModePoll}; - FakeVariable<ConnectionType> var_conn_type_{"conn_type", kVariableModePoll}; - FakeVariable<ConnectionTethering> var_conn_tethering_{ + FakeVariable<chromeos_update_engine::ConnectionType> var_conn_type_{ + "conn_type", kVariableModePoll}; + FakeVariable<chromeos_update_engine::ConnectionTethering> var_conn_tethering_{ "conn_tethering", kVariableModePoll}; FakeVariable<base::Time> var_conn_last_changed_{ "conn_last_changed", kVariableModePoll}; diff --git a/update_manager/real_device_policy_provider.cc b/update_manager/real_device_policy_provider.cc index 0e76518b..e3e0659c 100644 --- a/update_manager/real_device_policy_provider.cc +++ b/update_manager/real_device_policy_provider.cc @@ -24,11 +24,12 @@ #include <policy/device_policy.h> #include "update_engine/common/utils.h" +#include "update_engine/connection_utils.h" #include "update_engine/update_manager/generic_variables.h" -#include "update_engine/update_manager/real_shill_provider.h" using base::TimeDelta; using brillo::MessageLoop; +using chromeos_update_engine::ConnectionType; using policy::DevicePolicy; using std::set; using std::string; @@ -133,7 +134,7 @@ bool RealDevicePolicyProvider::ConvertAllowedConnectionTypesForUpdate( allowed_types->clear(); for (auto& type_str : allowed_types_str) { ConnectionType type = - RealShillProvider::ParseConnectionType(type_str.c_str()); + chromeos_update_engine::connection_utils::ParseConnectionType(type_str); if (type != ConnectionType::kUnknown) { allowed_types->insert(type); } else { diff --git a/update_manager/real_device_policy_provider.h b/update_manager/real_device_policy_provider.h index 6e798ca2..1ccf45b9 100644 --- a/update_manager/real_device_policy_provider.h +++ b/update_manager/real_device_policy_provider.h @@ -67,7 +67,7 @@ class RealDevicePolicyProvider : public DevicePolicyProvider { return &var_scatter_factor_; } - Variable<std::set<ConnectionType>>* + Variable<std::set<chromeos_update_engine::ConnectionType>>* var_allowed_connection_types_for_update() override { return &var_allowed_connection_types_for_update_; } @@ -130,7 +130,7 @@ class RealDevicePolicyProvider : public DevicePolicyProvider { // Wrapper for DevicePolicy::GetAllowedConnectionTypesForUpdate() that // converts the result to a set of ConnectionType elements instead of strings. bool ConvertAllowedConnectionTypesForUpdate( - std::set<ConnectionType>* allowed_types) const; + std::set<chromeos_update_engine::ConnectionType>* allowed_types) const; // Used for fetching information about the device policy. policy::PolicyProvider* policy_provider_; @@ -155,7 +155,7 @@ class RealDevicePolicyProvider : public DevicePolicyProvider { AsyncCopyVariable<std::string> var_target_version_prefix_{ "target_version_prefix"}; AsyncCopyVariable<base::TimeDelta> var_scatter_factor_{"scatter_factor"}; - AsyncCopyVariable<std::set<ConnectionType>> + AsyncCopyVariable<std::set<chromeos_update_engine::ConnectionType>> var_allowed_connection_types_for_update_{ "allowed_connection_types_for_update"}; AsyncCopyVariable<std::string> var_owner_{"owner"}; diff --git a/update_manager/real_device_policy_provider_unittest.cc b/update_manager/real_device_policy_provider_unittest.cc index 09c90958..45aca56c 100644 --- a/update_manager/real_device_policy_provider_unittest.cc +++ b/update_manager/real_device_policy_provider_unittest.cc @@ -34,6 +34,7 @@ using base::TimeDelta; using brillo::MessageLoop; +using chromeos_update_engine::ConnectionType; using chromeos_update_engine::dbus_test_utils::MockSignalHandler; using std::set; using std::string; diff --git a/update_manager/real_shill_provider.cc b/update_manager/real_shill_provider.cc index 79381800..2c58a7ee 100644 --- a/update_manager/real_shill_provider.cc +++ b/update_manager/real_shill_provider.cc @@ -24,39 +24,13 @@ #include <shill/dbus-constants.h> #include <shill/dbus-proxies.h> +using chromeos_update_engine::connection_utils::ParseConnectionType; using org::chromium::flimflam::ManagerProxyInterface; using org::chromium::flimflam::ServiceProxyInterface; using std::string; namespace chromeos_update_manager { -ConnectionType RealShillProvider::ParseConnectionType(const string& type_str) { - if (type_str == shill::kTypeEthernet) { - 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; - } - return ConnectionType::kUnknown; -} - -ConnectionTethering RealShillProvider::ParseConnectionTethering( - const string& tethering_str) { - if (tethering_str == shill::kTetheringNotDetectedState) { - return ConnectionTethering::kNotDetected; - } else if (tethering_str == shill::kTetheringSuspectedState) { - return ConnectionTethering::kSuspected; - } else if (tethering_str == shill::kTetheringConfirmedState) { - return ConnectionTethering::kConfirmed; - } - return ConnectionTethering::kUnknown; -} - bool RealShillProvider::Init() { ManagerProxyInterface* manager_proxy = shill_proxy_->GetManagerProxy(); if (!manager_proxy) @@ -157,7 +131,8 @@ bool RealShillProvider::ProcessDefaultService( // If the property doesn't contain a string value, the empty string will // become kUnknown. var_conn_tethering_.SetValue( - ParseConnectionTethering(prop_tethering->second.TryGet<string>())); + chromeos_update_engine::connection_utils::ParseConnectionTethering( + prop_tethering->second.TryGet<string>())); } // Get the connection type. @@ -175,7 +150,8 @@ bool RealShillProvider::ProcessDefaultService( LOG(ERROR) << "No PhysicalTechnology property found for a VPN" << " connection (service: " << default_service_path_.value() << "). Using default kUnknown value."; - var_conn_type_.SetValue(ConnectionType::kUnknown); + var_conn_type_.SetValue( + chromeos_update_engine::ConnectionType::kUnknown); } else { var_conn_type_.SetValue( ParseConnectionType(prop_physical->second.TryGet<string>())); diff --git a/update_manager/real_shill_provider.h b/update_manager/real_shill_provider.h index dbd6fc5f..815bbfcb 100644 --- a/update_manager/real_shill_provider.h +++ b/update_manager/real_shill_provider.h @@ -49,11 +49,11 @@ class RealShillProvider : public ShillProvider { return &var_is_connected_; } - Variable<ConnectionType>* var_conn_type() override { + Variable<chromeos_update_engine::ConnectionType>* var_conn_type() override { return &var_conn_type_; } - Variable<ConnectionTethering>* var_conn_tethering() override { + Variable<chromeos_update_engine::ConnectionTethering>* var_conn_tethering() override { return &var_conn_tethering_; } @@ -61,11 +61,6 @@ class RealShillProvider : public ShillProvider { return &var_conn_last_changed_; } - // Helper methods for converting shill strings into symbolic values. - static ConnectionType ParseConnectionType(const std::string& type_str); - static ConnectionTethering ParseConnectionTethering( - const std::string& tethering_str); - private: // A handler for ManagerProxy.PropertyChanged signal. void OnManagerPropertyChanged(const std::string& name, @@ -92,8 +87,10 @@ class RealShillProvider : public ShillProvider { // The provider's variables. AsyncCopyVariable<bool> var_is_connected_{"is_connected"}; - AsyncCopyVariable<ConnectionType> var_conn_type_{"conn_type"}; - AsyncCopyVariable<ConnectionTethering> var_conn_tethering_{"conn_tethering"}; + AsyncCopyVariable<chromeos_update_engine::ConnectionType> var_conn_type_{ + "conn_type"}; + AsyncCopyVariable<chromeos_update_engine::ConnectionTethering> + var_conn_tethering_{"conn_tethering"}; AsyncCopyVariable<base::Time> var_conn_last_changed_{"conn_last_changed"}; DISALLOW_COPY_AND_ASSIGN(RealShillProvider); diff --git a/update_manager/real_shill_provider_unittest.cc b/update_manager/real_shill_provider_unittest.cc index 2fa0628b..59e70f67 100644 --- a/update_manager/real_shill_provider_unittest.cc +++ b/update_manager/real_shill_provider_unittest.cc @@ -35,6 +35,8 @@ using base::Time; using base::TimeDelta; +using chromeos_update_engine::ConnectionTethering; +using chromeos_update_engine::ConnectionType; using chromeos_update_engine::FakeClock; using org::chromium::flimflam::ManagerProxyMock; using org::chromium::flimflam::ServiceProxyMock; diff --git a/update_manager/shill_provider.h b/update_manager/shill_provider.h index b40f2552..e6f4628d 100644 --- a/update_manager/shill_provider.h +++ b/update_manager/shill_provider.h @@ -19,27 +19,12 @@ #include <base/time/time.h> +#include "update_engine/connection_utils.h" #include "update_engine/update_manager/provider.h" #include "update_engine/update_manager/variable.h" namespace chromeos_update_manager { -enum class ConnectionType { - kEthernet, - kWifi, - kWimax, - kBluetooth, - kCellular, - kUnknown -}; - -enum class ConnectionTethering { - kNotDetected, - kSuspected, - kConfirmed, - kUnknown, -}; - // Provider for networking related information. class ShillProvider : public Provider { public: @@ -50,11 +35,12 @@ class ShillProvider : public Provider { // A variable returning the current network connection type. Unknown if not // connected. - virtual Variable<ConnectionType>* var_conn_type() = 0; + virtual Variable<chromeos_update_engine::ConnectionType>* var_conn_type() = 0; // A variable returning the tethering mode of a network connection. Unknown if // not connected. - virtual Variable<ConnectionTethering>* var_conn_tethering() = 0; + virtual Variable<chromeos_update_engine::ConnectionTethering>* + var_conn_tethering() = 0; // A variable returning the time when network connection last changed. // Initialized to current time. |