diff --git a/connection_manager.cc b/connection_manager.cc
index f6c0217..62bb11e 100644
--- a/connection_manager.cc
+++ b/connection_manager.cc
@@ -100,17 +100,17 @@
 
 NetworkConnectionType ParseConnectionType(const char* type_str) {
   if (!strcmp(type_str, shill::kTypeEthernet)) {
-    return kNetEthernet;
+    return NetworkConnectionType::kEthernet;
   } else if (!strcmp(type_str, shill::kTypeWifi)) {
-    return kNetWifi;
+    return NetworkConnectionType::kWifi;
   } else if (!strcmp(type_str, shill::kTypeWimax)) {
-    return kNetWimax;
+    return NetworkConnectionType::kWimax;
   } else if (!strcmp(type_str, shill::kTypeBluetooth)) {
-    return kNetBluetooth;
+    return NetworkConnectionType::kBluetooth;
   } else if (!strcmp(type_str, shill::kTypeCellular)) {
-    return kNetCellular;
+    return NetworkConnectionType::kCellular;
   }
-  return kNetUnknown;
+  return NetworkConnectionType::kUnknown;
 }
 
 NetworkTethering ParseTethering(const char* tethering_str) {
@@ -167,8 +167,8 @@
       } else {
         LOG(ERROR) << "No PhysicalTechnology property found for a VPN"
                    << " connection (service: " << path << "). Returning default"
-                   << " kNetUnknown value.";
-        *out_type = kNetUnknown;
+                   << " NetworkConnectionType::kUnknown value.";
+        *out_type = NetworkConnectionType::kUnknown;
       }
     } else {
       *out_type = ParseConnectionType(type_str);
@@ -186,10 +186,10 @@
 bool ConnectionManager::IsUpdateAllowedOver(NetworkConnectionType type,
                                             NetworkTethering tethering) const {
   switch (type) {
-    case kNetBluetooth:
+    case NetworkConnectionType::kBluetooth:
       return false;
 
-    case kNetCellular: {
+    case NetworkConnectionType::kCellular: {
       set<string> allowed_types;
       const policy::DevicePolicy* device_policy =
           system_state_->device_policy();
@@ -246,7 +246,8 @@
         // Treat this connection as if it is a cellular connection.
         LOG(INFO) << "Current connection is confirmed tethered, using Cellular "
                      "setting.";
-        return IsUpdateAllowedOver(kNetCellular, NetworkTethering::kUnknown);
+        return IsUpdateAllowedOver(NetworkConnectionType::kCellular,
+                                   NetworkTethering::kUnknown);
       }
       return true;
   }
@@ -254,15 +255,21 @@
 
 const char* ConnectionManager::StringForConnectionType(
     NetworkConnectionType type) const {
-  static const char* const kValues[] = {shill::kTypeEthernet,
-                                        shill::kTypeWifi,
-                                        shill::kTypeWimax,
-                                        shill::kTypeBluetooth,
-                                        shill::kTypeCellular};
-  if (type < 0 || type >= static_cast<int>(arraysize(kValues))) {
-    return "Unknown";
+  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 kValues[type];
+  return "Unknown";
 }
 
 const char* ConnectionManager::StringForTethering(
diff --git a/connection_manager.h b/connection_manager.h
index f9973a3..687759e 100644
--- a/connection_manager.h
+++ b/connection_manager.h
@@ -11,13 +11,13 @@
 
 namespace chromeos_update_engine {
 
-enum NetworkConnectionType {
-  kNetEthernet = 0,
-  kNetWifi,
-  kNetWimax,
-  kNetBluetooth,
-  kNetCellular,
-  kNetUnknown
+enum class NetworkConnectionType {
+  kEthernet = 0,
+  kWifi,
+  kWimax,
+  kBluetooth,
+  kCellular,
+  kUnknown
 };
 
 enum class NetworkTethering {
diff --git a/connection_manager_unittest.cc b/connection_manager_unittest.cc
index 8ca1a00..0c96272 100644
--- a/connection_manager_unittest.cc
+++ b/connection_manager_unittest.cc
@@ -208,18 +208,27 @@
 }
 
 TEST_F(ConnectionManagerTest, SimpleTest) {
-  TestWithServiceType(shill::kTypeEthernet, nullptr, kNetEthernet);
-  TestWithServiceType(shill::kTypeWifi, nullptr, kNetWifi);
-  TestWithServiceType(shill::kTypeWimax, nullptr, kNetWimax);
-  TestWithServiceType(shill::kTypeBluetooth, nullptr, kNetBluetooth);
-  TestWithServiceType(shill::kTypeCellular, nullptr, kNetCellular);
+  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);
 }
 
 TEST_F(ConnectionManagerTest, PhysicalTechnologyTest) {
-  TestWithServiceType(shill::kTypeVPN, nullptr, kNetUnknown);
-  TestWithServiceType(shill::kTypeVPN, shill::kTypeVPN, kNetUnknown);
-  TestWithServiceType(shill::kTypeVPN, shill::kTypeWifi, kNetWifi);
-  TestWithServiceType(shill::kTypeVPN, shill::kTypeWimax, kNetWimax);
+  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);
 }
 
 TEST_F(ConnectionManagerTest, TetheringTest) {
@@ -234,26 +243,27 @@
 }
 
 TEST_F(ConnectionManagerTest, UnknownTest) {
-  TestWithServiceType("foo", nullptr, kNetUnknown);
+  TestWithServiceType("foo", nullptr, NetworkConnectionType::kUnknown);
 }
 
 TEST_F(ConnectionManagerTest, AllowUpdatesOverEthernetTest) {
   // Updates over Ethernet are allowed even if there's no policy.
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetEthernet,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet,
                                         NetworkTethering::kUnknown));
 }
 
 TEST_F(ConnectionManagerTest, AllowUpdatesOverWifiTest) {
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWifi, NetworkTethering::kUnknown));
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi,
+                                        NetworkTethering::kUnknown));
 }
 
 TEST_F(ConnectionManagerTest, AllowUpdatesOverWimaxTest) {
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWimax,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWimax,
                                         NetworkTethering::kUnknown));
 }
 
 TEST_F(ConnectionManagerTest, BlockUpdatesOverBluetoothTest) {
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetBluetooth,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kBluetooth,
                                          NetworkTethering::kUnknown));
 }
 
@@ -264,13 +274,14 @@
 
   // This test tests cellular (3G) being the only connection type being allowed.
   set<string> allowed_set;
-  allowed_set.insert(cmut_.StringForConnectionType(kNetCellular));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kCellular));
 
   EXPECT_CALL(allow_3g_policy, GetAllowedConnectionTypesForUpdate(_))
       .Times(1)
       .WillOnce(DoAll(SetArgumentPointee<0>(allowed_set), Return(true)));
 
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                         NetworkTethering::kUnknown));
 }
 
@@ -283,43 +294,47 @@
   // 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(kNetCellular));
-  allowed_set.insert(cmut_.StringForConnectionType(kNetBluetooth));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kCellular));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kBluetooth));
 
   EXPECT_CALL(allow_3g_policy, GetAllowedConnectionTypesForUpdate(_))
       .Times(3)
       .WillRepeatedly(DoAll(SetArgumentPointee<0>(allowed_set), Return(true)));
 
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetEthernet,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet,
                                         NetworkTethering::kUnknown));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetEthernet,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet,
                                         NetworkTethering::kNotDetected));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                         NetworkTethering::kUnknown));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWifi, NetworkTethering::kUnknown));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWimax, NetworkTethering::kUnknown));
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetBluetooth,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi,
+                                        NetworkTethering::kUnknown));
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWimax,
+                                        NetworkTethering::kUnknown));
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kBluetooth,
                                          NetworkTethering::kUnknown));
 
   // Tethered networks are treated in the same way as Cellular networks and
   // thus allowed.
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetEthernet,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet,
                                         NetworkTethering::kConfirmed));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWifi,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi,
                                         NetworkTethering::kConfirmed));
 }
 
 TEST_F(ConnectionManagerTest, BlockUpdatesOverCellularByDefaultTest) {
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                          NetworkTethering::kUnknown));
 }
 
 TEST_F(ConnectionManagerTest, BlockUpdatesOverTetheredNetworkByDefaultTest) {
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetWifi,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi,
                                          NetworkTethering::kConfirmed));
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetEthernet,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kEthernet,
                                          NetworkTethering::kConfirmed));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetWifi,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kWifi,
                                         NetworkTethering::kSuspected));
 }
 
@@ -331,15 +346,18 @@
   // Test that updates for 3G are blocked while updates are allowed
   // over several other types.
   set<string> allowed_set;
-  allowed_set.insert(cmut_.StringForConnectionType(kNetEthernet));
-  allowed_set.insert(cmut_.StringForConnectionType(kNetWifi));
-  allowed_set.insert(cmut_.StringForConnectionType(kNetWimax));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kEthernet));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kWifi));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kWimax));
 
   EXPECT_CALL(block_3g_policy, GetAllowedConnectionTypesForUpdate(_))
       .Times(1)
       .WillOnce(DoAll(SetArgumentPointee<0>(allowed_set), Return(true)));
 
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                          NetworkTethering::kUnknown));
 }
 
@@ -349,7 +367,8 @@
   fake_system_state_.set_device_policy(&allow_3g_policy);
 
   set<string> allowed_set;
-  allowed_set.insert(cmut_.StringForConnectionType(kNetCellular));
+  allowed_set.insert(
+      cmut_.StringForConnectionType(NetworkConnectionType::kCellular));
 
   // Return false for GetAllowedConnectionTypesForUpdate and see
   // that updates are still blocked for 3G despite the value being in
@@ -358,7 +377,7 @@
       .Times(1)
       .WillOnce(DoAll(SetArgumentPointee<0>(allowed_set), Return(false)));
 
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                          NetworkTethering::kUnknown));
 }
 
@@ -377,7 +396,7 @@
   EXPECT_CALL(*prefs, Exists(kPrefsUpdateOverCellularPermission))
       .Times(1)
       .WillOnce(Return(false));
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                          NetworkTethering::kUnknown));
 
   // Allow per user pref.
@@ -387,7 +406,7 @@
   EXPECT_CALL(*prefs, GetBoolean(kPrefsUpdateOverCellularPermission, _))
       .Times(1)
       .WillOnce(DoAll(SetArgumentPointee<1>(true), Return(true)));
-  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_TRUE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                         NetworkTethering::kUnknown));
 
   // Block per user pref.
@@ -397,23 +416,24 @@
   EXPECT_CALL(*prefs, GetBoolean(kPrefsUpdateOverCellularPermission, _))
       .Times(1)
       .WillOnce(DoAll(SetArgumentPointee<1>(false), Return(true)));
-  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(kNetCellular,
+  EXPECT_FALSE(cmut_.IsUpdateAllowedOver(NetworkConnectionType::kCellular,
                                          NetworkTethering::kUnknown));
 }
 
 TEST_F(ConnectionManagerTest, StringForConnectionTypeTest) {
   EXPECT_STREQ(shill::kTypeEthernet,
-               cmut_.StringForConnectionType(kNetEthernet));
+               cmut_.StringForConnectionType(NetworkConnectionType::kEthernet));
   EXPECT_STREQ(shill::kTypeWifi,
-               cmut_.StringForConnectionType(kNetWifi));
+               cmut_.StringForConnectionType(NetworkConnectionType::kWifi));
   EXPECT_STREQ(shill::kTypeWimax,
-               cmut_.StringForConnectionType(kNetWimax));
+               cmut_.StringForConnectionType(NetworkConnectionType::kWimax));
   EXPECT_STREQ(shill::kTypeBluetooth,
-               cmut_.StringForConnectionType(kNetBluetooth));
+               cmut_.StringForConnectionType(
+                   NetworkConnectionType::kBluetooth));
   EXPECT_STREQ(shill::kTypeCellular,
-               cmut_.StringForConnectionType(kNetCellular));
+               cmut_.StringForConnectionType(NetworkConnectionType::kCellular));
   EXPECT_STREQ("Unknown",
-               cmut_.StringForConnectionType(kNetUnknown));
+               cmut_.StringForConnectionType(NetworkConnectionType::kUnknown));
   EXPECT_STREQ("Unknown",
                cmut_.StringForConnectionType(
                    static_cast<NetworkConnectionType>(999999)));
diff --git a/dbus_service.cc b/dbus_service.cc
index a7ec259..0dbff6b 100644
--- a/dbus_service.cc
+++ b/dbus_service.cc
@@ -425,7 +425,7 @@
   // updates. A log message could be printed as the result of this test.
   LOG(INFO) << "Checking if updates over cellular networks are allowed:";
   *allowed = cm->IsUpdateAllowedOver(
-      chromeos_update_engine::kNetCellular,
+      chromeos_update_engine::NetworkConnectionType::kCellular,
       chromeos_update_engine::NetworkTethering::kUnknown);
 
   return TRUE;
diff --git a/omaha_request_action_unittest.cc b/omaha_request_action_unittest.cc
index 1131c9c..8f4dc87 100644
--- a/omaha_request_action_unittest.cc
+++ b/omaha_request_action_unittest.cc
@@ -448,13 +448,14 @@
   MockConnectionManager mock_cm(nullptr);
   fake_system_state_.set_connection_manager(&mock_cm);
 
-  EXPECT_CALL(mock_cm, GetConnectionProperties(_, _, _))
-    .WillRepeatedly(DoAll(SetArgumentPointee<1>(kNetEthernet),
-                          SetArgumentPointee<2>(NetworkTethering::kUnknown),
-                          Return(true)));
-  EXPECT_CALL(mock_cm, IsUpdateAllowedOver(kNetEthernet, _))
+  EXPECT_CALL(mock_cm, GetConnectionProperties(_, _, _)).WillRepeatedly(
+    DoAll(SetArgumentPointee<1>(NetworkConnectionType::kEthernet),
+          SetArgumentPointee<2>(NetworkTethering::kUnknown),
+          Return(true)));
+  EXPECT_CALL(mock_cm, IsUpdateAllowedOver(NetworkConnectionType::kEthernet, _))
     .WillRepeatedly(Return(false));
-  EXPECT_CALL(mock_cm, StringForConnectionType(kNetEthernet))
+  EXPECT_CALL(mock_cm,
+              StringForConnectionType(NetworkConnectionType::kEthernet))
     .WillRepeatedly(Return(shill::kTypeEthernet));
 
   ASSERT_FALSE(
diff --git a/utils.cc b/utils.cc
index 97ce712..7777fca 100644
--- a/utils.cc
+++ b/utils.cc
@@ -1240,32 +1240,33 @@
     NetworkConnectionType type,
     NetworkTethering tethering) {
   switch (type) {
-    case kNetUnknown:
+    case NetworkConnectionType::kUnknown:
       return metrics::ConnectionType::kUnknown;
 
-    case kNetEthernet:
+    case NetworkConnectionType::kEthernet:
       if (tethering == NetworkTethering::kConfirmed)
         return metrics::ConnectionType::kTetheredEthernet;
       else
         return metrics::ConnectionType::kEthernet;
 
-    case kNetWifi:
+    case NetworkConnectionType::kWifi:
       if (tethering == NetworkTethering::kConfirmed)
         return metrics::ConnectionType::kTetheredWifi;
       else
         return metrics::ConnectionType::kWifi;
 
-    case kNetWimax:
+    case NetworkConnectionType::kWimax:
       return metrics::ConnectionType::kWimax;
 
-    case kNetBluetooth:
+    case NetworkConnectionType::kBluetooth:
       return metrics::ConnectionType::kBluetooth;
 
-    case kNetCellular:
+    case NetworkConnectionType::kCellular:
       return metrics::ConnectionType::kCellular;
   }
 
-  LOG(ERROR) << "Unexpected network connection type: type=" << type
+  LOG(ERROR) << "Unexpected network connection type: type="
+             << static_cast<int>(type)
              << ", tethering=" << static_cast<int>(tethering);
 
   return metrics::ConnectionType::kUnknown;
diff --git a/utils_unittest.cc b/utils_unittest.cc
index 4787e84..83ef485 100644
--- a/utils_unittest.cc
+++ b/utils_unittest.cc
@@ -682,50 +682,50 @@
 TEST(UtilsTest, GetConnectionType) {
   // Check that expected combinations map to the right value.
   EXPECT_EQ(metrics::ConnectionType::kUnknown,
-            utils::GetConnectionType(kNetUnknown,
+            utils::GetConnectionType(NetworkConnectionType::kUnknown,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kEthernet,
-            utils::GetConnectionType(kNetEthernet,
+            utils::GetConnectionType(NetworkConnectionType::kEthernet,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kWifi,
-            utils::GetConnectionType(kNetWifi,
+            utils::GetConnectionType(NetworkConnectionType::kWifi,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kWimax,
-            utils::GetConnectionType(kNetWimax,
+            utils::GetConnectionType(NetworkConnectionType::kWimax,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kBluetooth,
-            utils::GetConnectionType(kNetBluetooth,
+            utils::GetConnectionType(NetworkConnectionType::kBluetooth,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kCellular,
-            utils::GetConnectionType(kNetCellular,
+            utils::GetConnectionType(NetworkConnectionType::kCellular,
                                      NetworkTethering::kUnknown));
   EXPECT_EQ(metrics::ConnectionType::kTetheredEthernet,
-            utils::GetConnectionType(kNetEthernet,
+            utils::GetConnectionType(NetworkConnectionType::kEthernet,
                                      NetworkTethering::kConfirmed));
   EXPECT_EQ(metrics::ConnectionType::kTetheredWifi,
-            utils::GetConnectionType(kNetWifi,
+            utils::GetConnectionType(NetworkConnectionType::kWifi,
                                      NetworkTethering::kConfirmed));
 
   // Ensure that we don't report tethered ethernet unless it's confirmed.
   EXPECT_EQ(metrics::ConnectionType::kEthernet,
-            utils::GetConnectionType(kNetEthernet,
+            utils::GetConnectionType(NetworkConnectionType::kEthernet,
                                      NetworkTethering::kNotDetected));
   EXPECT_EQ(metrics::ConnectionType::kEthernet,
-            utils::GetConnectionType(kNetEthernet,
+            utils::GetConnectionType(NetworkConnectionType::kEthernet,
                                      NetworkTethering::kSuspected));
   EXPECT_EQ(metrics::ConnectionType::kEthernet,
-            utils::GetConnectionType(kNetEthernet,
+            utils::GetConnectionType(NetworkConnectionType::kEthernet,
                                      NetworkTethering::kUnknown));
 
   // Ditto for tethered wifi.
   EXPECT_EQ(metrics::ConnectionType::kWifi,
-            utils::GetConnectionType(kNetWifi,
+            utils::GetConnectionType(NetworkConnectionType::kWifi,
                                      NetworkTethering::kNotDetected));
   EXPECT_EQ(metrics::ConnectionType::kWifi,
-            utils::GetConnectionType(kNetWifi,
+            utils::GetConnectionType(NetworkConnectionType::kWifi,
                                      NetworkTethering::kSuspected));
   EXPECT_EQ(metrics::ConnectionType::kWifi,
-            utils::GetConnectionType(kNetWifi,
+            utils::GetConnectionType(NetworkConnectionType::kWifi,
                                      NetworkTethering::kUnknown));
 }