Add enum values for Wifi Sync V2 host/client

This includes:
(1) Adding Proto values for Wifi Sync.
(2) Adding Mojo values in multidevice_types.mojom.
(3) Integrating these types with existing DeviceSync code.
(4) Enrolling with WIFI_SYNC_CLIENT when the flag is enabled.
(5) Add IsWifiSyncAndroidEnabled() function as a simple way
to verify whether WifiSyncAndroid flag is enabled.

Bug: 1117619
Change-Id: I842bcb028d1e311905d60a111cd8bf9524fc72f2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2366660Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Jon Mann <jonmann@chromium.org>
Commit-Queue: Claude van der Merwe <cvandermerwe@google.com>
Cr-Commit-Position: refs/heads/master@{#801522}

chrome/browser/chromeos/cryptauth/client_app_metadata_provider_service.cc

@@ -73,6 +73,14 @@ const cryptauthv2::FeatureMetadata& GenerateFeatureMetadata() {
                   BetterTogetherFeatureMetadata_FeatureName_PHONE_HUB_CLIENT);
         }
 
+        // Wifi Sync Android is only supported if the associated flag is
+        // enabled.
+        if (features::IsWifiSyncAndroidEnabled()) {
+          inner_metadata.add_supported_features(
+              cryptauthv2::
+                  BetterTogetherFeatureMetadata_FeatureName_WIFI_SYNC_CLIENT);
+        }
+
         // Note: |inner_metadata|'s enabled_features field is deprecated and
         // left unset here (the server ignores this value when processing the
         // received proto).

chrome/browser/chromeos/cryptauth/gcm_device_info_provider_impl.cc

@@ -95,6 +95,12 @@ const cryptauth::GcmDeviceInfo& GcmDeviceInfoProviderImpl::GetGcmDeviceInfo()
           cryptauth::SoftwareFeature::PHONE_HUB_CLIENT);
     }
 
+    // Wifi Sync Android is only supported if the associated flag is enabled.
+    if (features::IsWifiSyncAndroidEnabled()) {
+      gcm_device_info.add_supported_software_features(
+          cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT);
+    }
+
     return gcm_device_info;
   }());
 

chromeos/components/multidevice/mojom/multidevice_mojom_traits.cc

@@ -194,6 +194,10 @@ EnumTraits<chromeos::multidevice::mojom::SoftwareFeature,
       return chromeos::multidevice::mojom::SoftwareFeature::PHONE_HUB_HOST;
     case chromeos::multidevice::SoftwareFeature::kPhoneHubClient:
       return chromeos::multidevice::mojom::SoftwareFeature::PHONE_HUB_CLIENT;
+    case chromeos::multidevice::SoftwareFeature::kWifiSyncHost:
+      return chromeos::multidevice::mojom::SoftwareFeature::WIFI_SYNC_HOST;
+    case chromeos::multidevice::SoftwareFeature::kWifiSyncClient:
+      return chromeos::multidevice::mojom::SoftwareFeature::WIFI_SYNC_CLIENT;
   }
 
   NOTREACHED();
@@ -235,6 +239,12 @@ bool EnumTraits<chromeos::multidevice::mojom::SoftwareFeature,
     case chromeos::multidevice::mojom::SoftwareFeature::PHONE_HUB_CLIENT:
       *out = chromeos::multidevice::SoftwareFeature::kPhoneHubClient;
       return true;
+    case chromeos::multidevice::mojom::SoftwareFeature::WIFI_SYNC_HOST:
+      *out = chromeos::multidevice::SoftwareFeature::kWifiSyncHost;
+      return true;
+    case chromeos::multidevice::mojom::SoftwareFeature::WIFI_SYNC_CLIENT:
+      *out = chromeos::multidevice::SoftwareFeature::kWifiSyncClient;
+      return true;
   }
 
   NOTREACHED();

chromeos/components/multidevice/mojom/multidevice_mojom_traits_unittest.cc

@@ -97,7 +97,9 @@ TEST(DeviceSyncMojomEnumTraitsTest, SoftwareFeature) {
           chromeos::multidevice::SoftwareFeature::kMessagesForWebHost,
           chromeos::multidevice::SoftwareFeature::kMessagesForWebClient,
           chromeos::multidevice::SoftwareFeature::kPhoneHubHost,
-          chromeos::multidevice::SoftwareFeature::kPhoneHubClient};
+          chromeos::multidevice::SoftwareFeature::kPhoneHubClient,
+          chromeos::multidevice::SoftwareFeature::kWifiSyncHost,
+          chromeos::multidevice::SoftwareFeature::kWifiSyncClient};
 
   for (auto feature_in : kTestSoftwareFeatures) {
     chromeos::multidevice::SoftwareFeature feature_out;

chromeos/components/multidevice/mojom/multidevice_types.mojom

@@ -37,7 +37,12 @@ enum SoftwareFeature {
   // Phone Hub allows users to view phone metadata and send commands to their
   // phone directly from the Chrome OS UI.
   PHONE_HUB_HOST = 9,
-  PHONE_HUB_CLIENT = 10
+  PHONE_HUB_CLIENT = 10,
+
+  // Wifi Sync with Android allows users to sync wifi network configurations
+  // between Chrome OS devices and a connected Android phone
+  WIFI_SYNC_HOST = 11,
+  WIFI_SYNC_CLIENT = 12
 };
 
 // Enumeration of what value a SoftwareFeature can be.

chromeos/components/multidevice/software_feature.cc

@@ -33,6 +33,10 @@ SoftwareFeature FromCryptAuthFeature(
       return SoftwareFeature::kPhoneHubHost;
     case cryptauth::SoftwareFeature::PHONE_HUB_CLIENT:
       return SoftwareFeature::kPhoneHubClient;
+    case cryptauth::SoftwareFeature::WIFI_SYNC_HOST:
+      return SoftwareFeature::kWifiSyncHost;
+    case cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT:
+      return SoftwareFeature::kWifiSyncClient;
     case cryptauth::SoftwareFeature::UNKNOWN_FEATURE:
       NOTREACHED();
   }
@@ -65,6 +69,10 @@ cryptauth::SoftwareFeature ToCryptAuthFeature(
       return cryptauth::SoftwareFeature::PHONE_HUB_HOST;
     case SoftwareFeature::kPhoneHubClient:
       return cryptauth::SoftwareFeature::PHONE_HUB_CLIENT;
+    case SoftwareFeature::kWifiSyncHost:
+      return cryptauth::SoftwareFeature::WIFI_SYNC_HOST;
+    case SoftwareFeature::kWifiSyncClient:
+      return cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT;
   }
 
   NOTREACHED();
@@ -103,6 +111,12 @@ std::ostream& operator<<(std::ostream& stream, const SoftwareFeature& feature) {
     case SoftwareFeature::kPhoneHubClient:
       stream << "[Phone Hub client]";
       break;
+    case SoftwareFeature::kWifiSyncHost:
+      stream << "[Wifi Sync host]";
+      break;
+    case SoftwareFeature::kWifiSyncClient:
+      stream << "[Wifi Sync client]";
+      break;
   }
   return stream;
 }

chromeos/components/multidevice/software_feature.h

@@ -47,7 +47,12 @@ enum class SoftwareFeature {
   // Phone Hub, which allows users to view phone metadata and send commands to
   // their phone directly from the Chrome OS UI.
   kPhoneHubHost = 9,
-  kPhoneHubClient = 10
+  kPhoneHubClient = 10,
+
+  // Wifi Sync with Android, which allows users to sync wifi network
+  // configurations between Chrome OS devices and a connected Android phone
+  kWifiSyncHost = 11,
+  kWifiSyncClient = 12
 };
 
 SoftwareFeature FromCryptAuthFeature(

chromeos/constants/chromeos_features.cc

@@ -636,6 +636,10 @@ bool IsViewBasedMultiprofileLoginEnabled() {
   return base::FeatureList::IsEnabled(kViewBasedMultiprofileLogin);
 }
 
+bool IsWifiSyncAndroidEnabled() {
+  return base::FeatureList::IsEnabled(kWifiSyncAndroid);
+}
+
 bool ShouldShowPlayStoreInDemoMode() {
   return base::FeatureList::IsEnabled(kShowPlayInDemoMode);
 }

chromeos/constants/chromeos_features.h

@@ -263,6 +263,7 @@ bool IsQuickAnswersTextAnnotatorEnabled();
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool IsQuickAnswersTranslationEnabled();
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool IsSplitSettingsSyncEnabled();
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool IsViewBasedMultiprofileLoginEnabled();
+COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool IsWifiSyncAndroidEnabled();
 // TODO(michaelpg): Remove after M71 branch to re-enable Play Store by default.
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool ShouldShowPlayStoreInDemoMode();
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS) bool ShouldUseBrowserSyncConsent();

chromeos/services/device_sync/cryptauth_feature_status_getter_impl.cc

@@ -32,7 +32,7 @@ namespace {
 constexpr base::TimeDelta kWaitingForBatchGetFeatureStatusesResponseTimeout =
     kMaxAsyncExecutionTime;
 
-constexpr std::array<multidevice::SoftwareFeature, 10> kAllSoftwareFeatures = {
+constexpr std::array<multidevice::SoftwareFeature, 12> kAllSoftwareFeatures = {
     multidevice::SoftwareFeature::kBetterTogetherHost,
     multidevice::SoftwareFeature::kBetterTogetherClient,
     multidevice::SoftwareFeature::kSmartLockHost,
@@ -42,7 +42,9 @@ constexpr std::array<multidevice::SoftwareFeature, 10> kAllSoftwareFeatures = {
     multidevice::SoftwareFeature::kMessagesForWebHost,
     multidevice::SoftwareFeature::kMessagesForWebClient,
     multidevice::SoftwareFeature::kPhoneHubHost,
-    multidevice::SoftwareFeature::kPhoneHubClient};
+    multidevice::SoftwareFeature::kPhoneHubClient,
+    multidevice::SoftwareFeature::kWifiSyncHost,
+    multidevice::SoftwareFeature::kWifiSyncClient};
 
 CryptAuthDeviceSyncResult::ResultCode
 BatchGetFeatureStatusesNetworkRequestErrorToResultCode(

chromeos/services/device_sync/cryptauth_feature_type.cc

@@ -30,6 +30,8 @@ const char kSmsConnectHostSupportedString[] = "SMS_CONNECT_HOST_SUPPORTED";
 const char kSmsConnectClientSupportedString[] = "SMS_CONNECT_CLIENT_SUPPORTED";
 const char kPhoneHubHostSupportedString[] = "PHONE_HUB_HOST_SUPPORTED";
 const char kPhoneHubClientSupportedString[] = "PHONE_HUB_CLIENT_SUPPORTED";
+const char kWifiSyncHostSupportedString[] = "WIFI_SYNC_HOST_SUPPORTED";
+const char kWifiSyncClientSupportedString[] = "WIFI_SYNC_CLIENT_SUPPORTED";
 
 const char kBetterTogetherHostEnabledString[] = "BETTER_TOGETHER_HOST";
 const char kBetterTogetherClientEnabledString[] = "BETTER_TOGETHER_CLIENT";
@@ -41,6 +43,8 @@ const char kSmsConnectHostEnabledString[] = "SMS_CONNECT_HOST";
 const char kSmsConnectClientEnabledString[] = "SMS_CONNECT_CLIENT";
 const char kPhoneHubHostEnabledString[] = "PHONE_HUB_HOST";
 const char kPhoneHubClientEnabledString[] = "PHONE_HUB_CLIENT";
+const char kWifiSyncHostEnabledString[] = "WIFI_SYNC_HOST";
+const char kWifiSyncClientEnabledString[] = "WIFI_SYNC_CLIENT";
 
 }  // namespace
 
@@ -70,6 +74,12 @@ const base::flat_set<CryptAuthFeatureType>& GetAllCryptAuthFeatureTypes() {
           feature_set.insert(CryptAuthFeatureType::kPhoneHubHostSupported);
           feature_set.insert(CryptAuthFeatureType::kPhoneHubHostEnabled);
         }
+        if (features::IsWifiSyncAndroidEnabled()) {
+          feature_set.insert(CryptAuthFeatureType::kWifiSyncClientSupported);
+          feature_set.insert(CryptAuthFeatureType::kWifiSyncClientEnabled);
+          feature_set.insert(CryptAuthFeatureType::kWifiSyncHostSupported);
+          feature_set.insert(CryptAuthFeatureType::kWifiSyncHostEnabled);
+        }
         return feature_set;
       }());
 
@@ -93,6 +103,10 @@ GetSupportedCryptAuthFeatureTypes() {
           supported_set.insert(CryptAuthFeatureType::kPhoneHubHostSupported);
           supported_set.insert(CryptAuthFeatureType::kPhoneHubClientSupported);
         }
+        if (features::IsWifiSyncAndroidEnabled()) {
+          supported_set.insert(CryptAuthFeatureType::kWifiSyncHostSupported);
+          supported_set.insert(CryptAuthFeatureType::kWifiSyncClientSupported);
+        }
         return supported_set;
       }());
 
@@ -115,6 +129,10 @@ const base::flat_set<CryptAuthFeatureType>& GetEnabledCryptAuthFeatureTypes() {
           enabled_set.insert(CryptAuthFeatureType::kPhoneHubHostEnabled);
           enabled_set.insert(CryptAuthFeatureType::kPhoneHubClientEnabled);
         }
+        if (features::IsWifiSyncAndroidEnabled()) {
+          enabled_set.insert(CryptAuthFeatureType::kWifiSyncHostEnabled);
+          enabled_set.insert(CryptAuthFeatureType::kWifiSyncClientEnabled);
+        }
         return enabled_set;
       }());
 
@@ -175,6 +193,14 @@ const char* CryptAuthFeatureTypeToString(CryptAuthFeatureType feature_type) {
       return kPhoneHubClientSupportedString;
     case CryptAuthFeatureType::kPhoneHubClientEnabled:
       return kPhoneHubClientEnabledString;
+    case CryptAuthFeatureType::kWifiSyncHostSupported:
+      return kWifiSyncHostSupportedString;
+    case CryptAuthFeatureType::kWifiSyncHostEnabled:
+      return kWifiSyncHostEnabledString;
+    case CryptAuthFeatureType::kWifiSyncClientSupported:
+      return kWifiSyncClientSupportedString;
+    case CryptAuthFeatureType::kWifiSyncClientEnabled:
+      return kWifiSyncClientEnabledString;
   }
 }
 
@@ -220,6 +246,14 @@ base::Optional<CryptAuthFeatureType> CryptAuthFeatureTypeFromString(
     return CryptAuthFeatureType::kPhoneHubClientSupported;
   if (feature_type_string == kPhoneHubClientEnabledString)
     return CryptAuthFeatureType::kPhoneHubClientEnabled;
+  if (feature_type_string == kWifiSyncHostSupportedString)
+    return CryptAuthFeatureType::kWifiSyncHostSupported;
+  if (feature_type_string == kWifiSyncHostEnabledString)
+    return CryptAuthFeatureType::kWifiSyncHostEnabled;
+  if (feature_type_string == kWifiSyncClientSupportedString)
+    return CryptAuthFeatureType::kWifiSyncClientSupported;
+  if (feature_type_string == kWifiSyncClientEnabledString)
+    return CryptAuthFeatureType::kWifiSyncClientEnabled;
 
   return base::nullopt;
 }
@@ -315,6 +349,16 @@ multidevice::SoftwareFeature CryptAuthFeatureTypeToSoftwareFeature(
       FALLTHROUGH;
     case CryptAuthFeatureType::kPhoneHubClientEnabled:
       return multidevice::SoftwareFeature::kPhoneHubClient;
+
+    case CryptAuthFeatureType::kWifiSyncHostSupported:
+      FALLTHROUGH;
+    case CryptAuthFeatureType::kWifiSyncHostEnabled:
+      return multidevice::SoftwareFeature::kWifiSyncHost;
+
+    case CryptAuthFeatureType::kWifiSyncClientSupported:
+      FALLTHROUGH;
+    case CryptAuthFeatureType::kWifiSyncClientEnabled:
+      return multidevice::SoftwareFeature::kWifiSyncClient;
   }
 }
 
@@ -341,6 +385,10 @@ CryptAuthFeatureType CryptAuthFeatureTypeFromSoftwareFeature(
       return CryptAuthFeatureType::kPhoneHubHostEnabled;
     case multidevice::SoftwareFeature::kPhoneHubClient:
       return CryptAuthFeatureType::kPhoneHubClientEnabled;
+    case multidevice::SoftwareFeature::kWifiSyncHost:
+      return CryptAuthFeatureType::kWifiSyncHostEnabled;
+    case multidevice::SoftwareFeature::kWifiSyncClient:
+      return CryptAuthFeatureType::kWifiSyncClientEnabled;
   }
 }
 

chromeos/services/device_sync/cryptauth_feature_type.h

@@ -74,8 +74,15 @@ enum class CryptAuthFeatureType {
   kPhoneHubClientSupported = 18,
   kPhoneHubClientEnabled = 19,
 
+  // Wifi Sync with Android, which allows users to sync wifi network
+  // configurations between Chrome OS devices and a connected  Android phone
+  kWifiSyncHostSupported = 20,
+  kWifiSyncHostEnabled = 21,
+  kWifiSyncClientSupported = 22,
+  kWifiSyncClientEnabled = 23,
+
   // Used for UMA logs.
-  kMaxValue = kPhoneHubClientEnabled
+  kMaxValue = kWifiSyncClientEnabled
 };
 
 const base::flat_set<CryptAuthFeatureType>& GetAllCryptAuthFeatureTypes();

chromeos/services/device_sync/cryptauth_v2_device_sync_test_devices.cc

@@ -63,6 +63,10 @@ const CryptAuthDevice& GetLocalDeviceForTest() {
              multidevice::SoftwareFeatureState::kNotSupported},
             {multidevice::SoftwareFeature::kPhoneHubClient,
              multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncHost,
+             multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncClient,
+             multidevice::SoftwareFeatureState::kNotSupported},
         });
   }());
   return *device;
@@ -113,6 +117,10 @@ const CryptAuthDevice& GetRemoteDeviceNeedsGroupPrivateKeyForTest() {
              multidevice::SoftwareFeatureState::kNotSupported},
             {multidevice::SoftwareFeature::kPhoneHubClient,
              multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncHost,
+             multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncClient,
+             multidevice::SoftwareFeatureState::kNotSupported},
         });
   }());
   return *device;
@@ -163,6 +171,10 @@ const CryptAuthDevice& GetRemoteDeviceHasGroupPrivateKeyForTest() {
              multidevice::SoftwareFeatureState::kNotSupported},
             {multidevice::SoftwareFeature::kPhoneHubClient,
              multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncHost,
+             multidevice::SoftwareFeatureState::kNotSupported},
+            {multidevice::SoftwareFeature::kWifiSyncClient,
+             multidevice::SoftwareFeatureState::kNotSupported},
         });
   }());
   return *device;

chromeos/services/device_sync/proto/cryptauth_api.proto

@@ -55,6 +55,8 @@ enum SoftwareFeature {
   SMS_CONNECT_CLIENT = 8;
   PHONE_HUB_HOST = 9;
   PHONE_HUB_CLIENT = 10;
+  WIFI_SYNC_HOST = 11;
+  WIFI_SYNC_CLIENT = 12;
 }
 
 // A seed used to feed an EID BLE advertisement for some time period. This

chromeos/services/device_sync/proto/cryptauth_better_together_feature_metadata.proto

@@ -24,6 +24,8 @@ message BetterTogetherFeatureMetadata {
     SMS_CONNECT_CLIENT = 8;
     PHONE_HUB_HOST = 9;
     PHONE_HUB_CLIENT = 10;
+    WIFI_SYNC_HOST = 11;
+    WIFI_SYNC_CLIENT = 12;
   }
 
   repeated FeatureName supported_features = 1;

chromeos/services/device_sync/proto/enum_util.cc

@@ -91,6 +91,12 @@ std::ostream& operator<<(std::ostream& stream,
     case cryptauth::SoftwareFeature::PHONE_HUB_CLIENT:
       stream << "[Phone Hub client]";
       break;
+    case cryptauth::SoftwareFeature::WIFI_SYNC_HOST:
+      stream << "[Wifi Sync host]";
+      break;
+    case cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT:
+      stream << "[Wifi Sync client]";
+      break;
     default:
       stream << "[unknown software feature]";
       break;
@@ -120,6 +126,10 @@ cryptauth::SoftwareFeature SoftwareFeatureStringToEnum(
     return cryptauth::SoftwareFeature::PHONE_HUB_HOST;
   if (software_feature_as_string == "phoneHubClient")
     return cryptauth::SoftwareFeature::PHONE_HUB_CLIENT;
+  if (software_feature_as_string == "wifiSyncHost")
+    return cryptauth::SoftwareFeature::WIFI_SYNC_HOST;
+  if (software_feature_as_string == "wifiSyncClient")
+    return cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT;
 
   return cryptauth::SoftwareFeature::UNKNOWN_FEATURE;
 }
@@ -147,6 +157,10 @@ std::string SoftwareFeatureEnumToString(
       return "phoneHubHost";
     case cryptauth::SoftwareFeature::PHONE_HUB_CLIENT:
       return "phoneHubClient";
+    case cryptauth::SoftwareFeature::WIFI_SYNC_HOST:
+      return "wifiSyncHost";
+    case cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT:
+      return "wifiSyncClient";
     default:
       return "unknownFeature";
   }
@@ -175,6 +189,10 @@ std::string SoftwareFeatureEnumToStringAllCaps(
       return "PHONE_HUB_HOST";
     case cryptauth::SoftwareFeature::PHONE_HUB_CLIENT:
       return "PHONE_HUB_CLIENT";
+    case cryptauth::SoftwareFeature::WIFI_SYNC_HOST:
+      return "WIFI_SYNC_HOST";
+    case cryptauth::SoftwareFeature::WIFI_SYNC_CLIENT:
+      return "WIFI_SYNC_CLIENT";
     default:
       return "UNKNOWN_FEATURE";
   }