[DeviceSync v2] Consolidate CryptAuth feature type files

- Merge redundant cryptauth_better_together_feature_types.cc/h into
  cryptauth_feature_type.cc/h.
- Change the strings from camelcase to uppercase-underscore format--the
  format the CryptAuth server uses.
- Add function to convert from multidevice::SoftwareFeature to a
  feature type string. This will be needed to build
  BatchSetFeatureStatuses requests.

Bug: 951969
Change-Id: I4e516b2790edbb5ca2c08261fec3f59f35ab4994
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1834062
Commit-Queue: Josh Nohle <nohle@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#701714}

chromeos/services/device_sync/BUILD.gn

@@ -10,8 +10,6 @@ static_library("device_sync") {
     "async_execution_time_metrics_logger.h",
     "cryptauth_api_call_flow.cc",
     "cryptauth_api_call_flow.h",
-    "cryptauth_better_together_feature_types.cc",
-    "cryptauth_better_together_feature_types.h",
     "cryptauth_client.h",
     "cryptauth_client_impl.cc",
     "cryptauth_client_impl.h",

chromeos/services/device_sync/cryptauth_better_together_feature_types.cc

-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chromeos/services/device_sync/cryptauth_better_together_feature_types.h"
-
-#include "base/logging.h"
-#include "base/no_destructor.h"
-
-namespace chromeos {
-
-namespace device_sync {
-
-const char kCryptAuthFeatureTypeBetterTogetherHostSupported[] =
-    "BETTER_TOGETHER_HOST_SUPPORTED";
-const char kCryptAuthFeatureTypeBetterTogetherClientSupported[] =
-    "BETTER_TOGETHER_CLIENT_SUPPORTED";
-const char kCryptAuthFeatureTypeEasyUnlockHostSupported[] =
-    "EASY_UNLOCK_HOST_SUPPORTED";
-const char kCryptAuthFeatureTypeEasyUnlockClientSupported[] =
-    "EASY_UNLOCK_CLIENT_SUPPORTED";
-const char kCryptAuthFeatureTypeMagicTetherHostSupported[] =
-    "MAGIC_TETHER_HOST_SUPPORTED";
-const char kCryptAuthFeatureTypeMagicTetherClientSupported[] =
-    "MAGIC_TETHER_CLIENT_SUPPORTED";
-const char kCryptAuthFeatureTypeSmsConnectHostSupported[] =
-    "SMS_CONNECT_HOST_SUPPORTED";
-const char kCryptAuthFeatureTypeSmsConnectClientSupported[] =
-    "SMS_CONNECT_CLIENT_SUPPORTED";
-
-const char kCryptAuthFeatureTypeBetterTogetherHostEnabled[] =
-    "BETTER_TOGETHER_HOST";
-const char kCryptAuthFeatureTypeBetterTogetherClientEnabled[] =
-    "BETTER_TOGETHER_CLIENT";
-const char kCryptAuthFeatureTypeEasyUnlockHostEnabled[] = "EASY_UNLOCK_HOST";
-const char kCryptAuthFeatureTypeEasyUnlockClientEnabled[] =
-    "EASY_UNLOCK_CLIENT";
-const char kCryptAuthFeatureTypeMagicTetherHostEnabled[] = "MAGIC_TETHER_HOST";
-const char kCryptAuthFeatureTypeMagicTetherClientEnabled[] =
-    "MAGIC_TETHER_CLIENT";
-const char kCryptAuthFeatureTypeSmsConnectHostEnabled[] = "SMS_CONNECT_HOST";
-const char kCryptAuthFeatureTypeSmsConnectClientEnabled[] =
-    "SMS_CONNECT_CLIENT";
-
-const base::flat_set<std::string>& GetBetterTogetherFeatureTypes() {
-  static const base::NoDestructor<base::flat_set<std::string>> feature_set([] {
-    return base::flat_set<std::string>{
-        kCryptAuthFeatureTypeBetterTogetherHostSupported,
-        kCryptAuthFeatureTypeBetterTogetherClientSupported,
-        kCryptAuthFeatureTypeEasyUnlockHostSupported,
-        kCryptAuthFeatureTypeEasyUnlockClientSupported,
-        kCryptAuthFeatureTypeMagicTetherHostSupported,
-        kCryptAuthFeatureTypeMagicTetherClientSupported,
-        kCryptAuthFeatureTypeSmsConnectHostSupported,
-        kCryptAuthFeatureTypeSmsConnectClientSupported,
-        kCryptAuthFeatureTypeBetterTogetherHostEnabled,
-        kCryptAuthFeatureTypeBetterTogetherClientEnabled,
-        kCryptAuthFeatureTypeEasyUnlockHostEnabled,
-        kCryptAuthFeatureTypeEasyUnlockClientEnabled,
-        kCryptAuthFeatureTypeMagicTetherHostEnabled,
-        kCryptAuthFeatureTypeMagicTetherClientEnabled,
-        kCryptAuthFeatureTypeSmsConnectHostEnabled,
-        kCryptAuthFeatureTypeSmsConnectClientEnabled};
-  }());
-  return *feature_set;
-}
-
-const base::flat_set<std::string>& GetSupportedBetterTogetherFeatureTypes() {
-  static const base::NoDestructor<base::flat_set<std::string>> supported_set(
-      [] {
-        return base::flat_set<std::string>{
-            kCryptAuthFeatureTypeBetterTogetherHostSupported,
-            kCryptAuthFeatureTypeBetterTogetherClientSupported,
-            kCryptAuthFeatureTypeEasyUnlockHostSupported,
-            kCryptAuthFeatureTypeEasyUnlockClientSupported,
-            kCryptAuthFeatureTypeMagicTetherHostSupported,
-            kCryptAuthFeatureTypeMagicTetherClientSupported,
-            kCryptAuthFeatureTypeSmsConnectHostSupported,
-            kCryptAuthFeatureTypeSmsConnectClientSupported};
-      }());
-  return *supported_set;
-}
-
-const base::flat_set<std::string>& GetEnabledBetterTogetherFeatureTypes() {
-  static const base::NoDestructor<base::flat_set<std::string>> enabled_set([] {
-    return base::flat_set<std::string>{
-        kCryptAuthFeatureTypeBetterTogetherHostEnabled,
-        kCryptAuthFeatureTypeBetterTogetherClientEnabled,
-        kCryptAuthFeatureTypeEasyUnlockHostEnabled,
-        kCryptAuthFeatureTypeEasyUnlockClientEnabled,
-        kCryptAuthFeatureTypeMagicTetherHostEnabled,
-        kCryptAuthFeatureTypeMagicTetherClientEnabled,
-        kCryptAuthFeatureTypeSmsConnectHostEnabled,
-        kCryptAuthFeatureTypeSmsConnectClientEnabled};
-  }());
-  return *enabled_set;
-}
-
-multidevice::SoftwareFeature BetterTogetherFeatureTypeStringToSoftwareFeature(
-    const std::string& feature_type_string) {
-  if (feature_type_string == kCryptAuthFeatureTypeBetterTogetherHostSupported ||
-      feature_type_string == kCryptAuthFeatureTypeBetterTogetherHostEnabled) {
-    return multidevice::SoftwareFeature::kBetterTogetherHost;
-  }
-
-  if (feature_type_string ==
-          kCryptAuthFeatureTypeBetterTogetherClientSupported ||
-      feature_type_string == kCryptAuthFeatureTypeBetterTogetherClientEnabled) {
-    return multidevice::SoftwareFeature::kBetterTogetherClient;
-  }
-
-  if (feature_type_string == kCryptAuthFeatureTypeEasyUnlockHostSupported ||
-      feature_type_string == kCryptAuthFeatureTypeEasyUnlockHostEnabled) {
-    return multidevice::SoftwareFeature::kSmartLockHost;
-  }
-
-  if (feature_type_string == kCryptAuthFeatureTypeEasyUnlockClientSupported ||
-      feature_type_string == kCryptAuthFeatureTypeEasyUnlockClientEnabled) {
-    return multidevice::SoftwareFeature::kSmartLockClient;
-  }
-
-  if (feature_type_string == kCryptAuthFeatureTypeMagicTetherHostSupported ||
-      feature_type_string == kCryptAuthFeatureTypeMagicTetherHostEnabled) {
-    return multidevice::SoftwareFeature::kInstantTetheringHost;
-  }
-
-  if (feature_type_string == kCryptAuthFeatureTypeMagicTetherClientSupported ||
-      feature_type_string == kCryptAuthFeatureTypeMagicTetherClientEnabled) {
-    return multidevice::SoftwareFeature::kInstantTetheringClient;
-  }
-
-  if (feature_type_string == kCryptAuthFeatureTypeSmsConnectHostSupported ||
-      feature_type_string == kCryptAuthFeatureTypeSmsConnectHostEnabled) {
-    return multidevice::SoftwareFeature::kMessagesForWebHost;
-  }
-
-  DCHECK(feature_type_string ==
-             kCryptAuthFeatureTypeSmsConnectClientSupported ||
-         feature_type_string == kCryptAuthFeatureTypeSmsConnectClientEnabled);
-  return multidevice::SoftwareFeature::kMessagesForWebClient;
-}
-
-}  // namespace device_sync
-
-}  // namespace chromeos

chromeos/services/device_sync/cryptauth_better_together_feature_types.h

-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CHROMEOS_SERVICES_DEVICE_SYNC_CRYPTAUTH_BETTER_TOGETHER_FEATURE_TYPES_H_
-#define CHROMEOS_SERVICES_DEVICE_SYNC_CRYPTAUTH_BETTER_TOGETHER_FEATURE_TYPES_H_
-
-#include <string>
-
-#include "base/containers/flat_set.h"
-#include "chromeos/components/multidevice/software_feature.h"
-
-namespace chromeos {
-
-namespace device_sync {
-
-// Strings used by CryptAuth to identify the supported and enabled states of
-// BetterTogether features. They are used in the "feature_type(s)" fields of the
-// DeviceSync v2 RPCs BatchNotifyGroupDevices, BatchGetFeatureStatuses, and
-// BatchSetFeatureStatuses.
-extern const char kCryptAuthFeatureTypeBetterTogetherHostSupported[];
-extern const char kCryptAuthFeatureTypeBetterTogetherClientSupported[];
-extern const char kCryptAuthFeatureTypeEasyUnlockHostSupported[];
-extern const char kCryptAuthFeatureTypeEasyUnlockClientSupported[];
-extern const char kCryptAuthFeatureTypeMagicTetherHostSupported[];
-extern const char kCryptAuthFeatureTypeMagicTetherClientSupported[];
-extern const char kCryptAuthFeatureTypeSmsConnectHostSupported[];
-extern const char kCryptAuthFeatureTypeSmsConnectClientSupported[];
-extern const char kCryptAuthFeatureTypeBetterTogetherHostEnabled[];
-extern const char kCryptAuthFeatureTypeBetterTogetherClientEnabled[];
-extern const char kCryptAuthFeatureTypeEasyUnlockHostEnabled[];
-extern const char kCryptAuthFeatureTypeEasyUnlockClientEnabled[];
-extern const char kCryptAuthFeatureTypeMagicTetherHostEnabled[];
-extern const char kCryptAuthFeatureTypeMagicTetherClientEnabled[];
-extern const char kCryptAuthFeatureTypeSmsConnectHostEnabled[];
-extern const char kCryptAuthFeatureTypeSmsConnectClientEnabled[];
-
-const base::flat_set<std::string>& GetBetterTogetherFeatureTypes();
-const base::flat_set<std::string>& GetSupportedBetterTogetherFeatureTypes();
-const base::flat_set<std::string>& GetEnabledBetterTogetherFeatureTypes();
-
-multidevice::SoftwareFeature BetterTogetherFeatureTypeStringToSoftwareFeature(
-    const std::string& feature_type_string);
-
-}  // namespace device_sync
-
-}  // namespace chromeos
-
-#endif  // CHROMEOS_SERVICES_DEVICE_SYNC_CRYPTAUTH_BETTER_TOGETHER_FEATURE_TYPES_H_

chromeos/services/device_sync/cryptauth_device_activity_getter_impl.cc

@@ -15,7 +15,6 @@
 #include "chromeos/components/multidevice/logging/logging.h"
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/components/multidevice/software_feature_state.h"
-#include "chromeos/services/device_sync/cryptauth_better_together_feature_types.h"
 #include "chromeos/services/device_sync/cryptauth_client.h"
 #include "chromeos/services/device_sync/cryptauth_key_bundle.h"
 #include "chromeos/services/device_sync/device_sync_type_converters.h"

chromeos/services/device_sync/cryptauth_feature_status_getter_impl.cc

@@ -15,8 +15,8 @@
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/components/multidevice/software_feature_state.h"
 #include "chromeos/services/device_sync/async_execution_time_metrics_logger.h"
-#include "chromeos/services/device_sync/cryptauth_better_together_feature_types.h"
 #include "chromeos/services/device_sync/cryptauth_client.h"
+#include "chromeos/services/device_sync/cryptauth_feature_type.h"
 
 namespace chromeos {
 
@@ -80,7 +80,7 @@ ConvertFeatureStatusesToSoftwareFeatureMap(
        feature_statuses) {
     // TODO(https://crbug.com/936273): Add metrics to track unknown feature type
     // occurrences.
-    if (!base::Contains(GetBetterTogetherFeatureTypes(),
+    if (!base::Contains(GetCryptAuthFeatureTypeStrings(),
                         status.feature_type())) {
       PA_LOG(ERROR) << "Unknown feature type: " << status.feature_type();
       *did_non_fatal_error_occur = true;
@@ -88,16 +88,16 @@ ConvertFeatureStatusesToSoftwareFeatureMap(
     }
 
     multidevice::SoftwareFeature feature =
-        BetterTogetherFeatureTypeStringToSoftwareFeature(status.feature_type());
+        CryptAuthFeatureTypeStringToSoftwareFeature(status.feature_type());
 
-    if (base::Contains(GetSupportedBetterTogetherFeatureTypes(),
+    if (base::Contains(GetSupportedCryptAuthFeatureTypeStrings(),
                        status.feature_type()) &&
         status.enabled()) {
       marked_supported.insert(feature);
       continue;
     }
 
-    if (base::Contains(GetEnabledBetterTogetherFeatureTypes(),
+    if (base::Contains(GetEnabledCryptAuthFeatureTypeStrings(),
                        status.feature_type()) &&
         status.enabled()) {
       marked_enabled.insert(feature);
@@ -184,8 +184,8 @@ void CryptAuthFeatureStatusGetterImpl::OnAttemptStarted(
   cryptauthv2::BatchGetFeatureStatusesRequest request;
   request.mutable_context()->CopyFrom(request_context);
   *request.mutable_device_ids() = {device_ids.begin(), device_ids.end()};
-  *request.mutable_feature_types() = {GetBetterTogetherFeatureTypes().begin(),
-                                      GetBetterTogetherFeatureTypes().end()};
+  *request.mutable_feature_types() = {GetCryptAuthFeatureTypeStrings().begin(),
+                                      GetCryptAuthFeatureTypeStrings().end()};
 
   start_get_feature_statuses_timestamp_ = base::TimeTicks::Now();
 

chromeos/services/device_sync/cryptauth_feature_status_getter_impl_unittest.cc

@@ -15,10 +15,10 @@
 #include "base/timer/mock_timer.h"
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/components/multidevice/software_feature_state.h"
-#include "chromeos/services/device_sync/cryptauth_better_together_feature_types.h"
 #include "chromeos/services/device_sync/cryptauth_client.h"
 #include "chromeos/services/device_sync/cryptauth_device.h"
 #include "chromeos/services/device_sync/cryptauth_device_sync_result.h"
+#include "chromeos/services/device_sync/cryptauth_feature_type.h"
 #include "chromeos/services/device_sync/cryptauth_key_bundle.h"
 #include "chromeos/services/device_sync/cryptauth_v2_device_sync_test_devices.h"
 #include "chromeos/services/device_sync/mock_cryptauth_client.h"
@@ -64,10 +64,10 @@ cryptauthv2::DeviceFeatureStatus ConvertDeviceToDeviceFeatureStatus(
   device_feature_status.set_device_id(device.instance_id());
   for (const std::string& feature_type : feature_types) {
     bool is_supported_feature_type =
-        base::Contains(GetSupportedBetterTogetherFeatureTypes(), feature_type);
+        base::Contains(GetSupportedCryptAuthFeatureTypeStrings(), feature_type);
 
     const auto it = device.feature_states.find(
-        BetterTogetherFeatureTypeStringToSoftwareFeature(feature_type));
+        CryptAuthFeatureTypeStringToSoftwareFeature(feature_type));
     bool is_supported =
         it != device.feature_states.end() &&
         it->second != multidevice::SoftwareFeatureState::kNotSupported;
@@ -80,8 +80,8 @@ cryptauthv2::DeviceFeatureStatus ConvertDeviceToDeviceFeatureStatus(
     if (is_supported_feature_type) {
       feature_status->set_enabled(is_supported);
     } else {
-      EXPECT_TRUE(
-          base::Contains(GetEnabledBetterTogetherFeatureTypes(), feature_type));
+      EXPECT_TRUE(base::Contains(GetEnabledCryptAuthFeatureTypeStrings(),
+                                 feature_type));
       feature_status->set_enabled(is_enabled);
     }
   }
@@ -148,7 +148,7 @@ class DeviceSyncCryptAuthFeatureStatusGetterImplTest
               base::flat_set<std::string>(
                   batch_get_feature_statuses_request_->device_ids().begin(),
                   batch_get_feature_statuses_request_->device_ids().end()));
-    EXPECT_EQ(GetBetterTogetherFeatureTypes(),
+    EXPECT_EQ(GetCryptAuthFeatureTypeStrings(),
               base::flat_set<std::string>(
                   batch_get_feature_statuses_request_->feature_types().begin(),
                   batch_get_feature_statuses_request_->feature_types().end()));
@@ -245,7 +245,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest, Success) {
   VerifyBatchGetFeatureStatusesRequest(GetAllTestDeviceIds());
 
   SendCorrectBatchGetFeatureStatusesResponse(GetAllTestDeviceIds(),
-                                             GetBetterTogetherFeatureTypes());
+                                             GetCryptAuthFeatureTypeStrings());
 
   VerifyGetFeatureStatuesResult(
       GetAllTestDeviceIds(), CryptAuthDeviceSyncResult::ResultCode::kSuccess);
@@ -262,7 +262,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
   // Include an unknown feature type string in the response. The unknown feature
   // type should be ignored.
   cryptauthv2::DeviceFeatureStatus status = ConvertDeviceToDeviceFeatureStatus(
-      GetLocalDeviceForTest(), GetBetterTogetherFeatureTypes());
+      GetLocalDeviceForTest(), GetCryptAuthFeatureTypeStrings());
   status.add_feature_statuses()->set_feature_type("Unknown_feature_type");
 
   cryptauthv2::BatchGetFeatureStatusesResponse response;
@@ -283,7 +283,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
   VerifyBatchGetFeatureStatusesRequest(device_ids);
 
   cryptauthv2::DeviceFeatureStatus status = ConvertDeviceToDeviceFeatureStatus(
-      GetLocalDeviceForTest(), GetBetterTogetherFeatureTypes());
+      GetLocalDeviceForTest(), GetCryptAuthFeatureTypeStrings());
 
   // The BetterTogether host feature is not supported for the local device.
   EXPECT_EQ(multidevice::SoftwareFeatureState::kNotSupported,
@@ -293,25 +293,27 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
                 ->second);
 
   // Ensure that BetterTogether host is marked as not supported in the response.
-  auto beto_host_supported_it =
-      std::find_if(status.mutable_feature_statuses()->begin(),
+  auto beto_host_supported_it = std::find_if(
+      status.mutable_feature_statuses()->begin(),
       status.mutable_feature_statuses()->end(),
       [](const cryptauthv2::DeviceFeatureStatus::FeatureStatus&
              feature_status) {
         return feature_status.feature_type() ==
-                            kCryptAuthFeatureTypeBetterTogetherHostSupported;
+               CryptAuthFeatureTypeToString(
+                   CryptAuthFeatureType::kBetterTogetherHostSupported);
       });
   EXPECT_FALSE(beto_host_supported_it->enabled());
 
   // Erroneously mark the BetterTogether host feature state as enabled in the
   // response though it is not supported.
-  auto beto_host_enabled_it =
-      std::find_if(status.mutable_feature_statuses()->begin(),
+  auto beto_host_enabled_it = std::find_if(
+      status.mutable_feature_statuses()->begin(),
       status.mutable_feature_statuses()->end(),
       [](const cryptauthv2::DeviceFeatureStatus::FeatureStatus&
              feature_status) {
         return feature_status.feature_type() ==
-                            kCryptAuthFeatureTypeBetterTogetherHostEnabled;
+               CryptAuthFeatureTypeToString(
+                   CryptAuthFeatureType::kBetterTogetherHostEnabled);
       });
   beto_host_enabled_it->set_enabled(true);
 
@@ -337,7 +339,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
   // Include features statuses for unrequested devices. These extra devices
   // should be ignored.
   SendCorrectBatchGetFeatureStatusesResponse(GetAllTestDeviceIds(),
-                                             GetBetterTogetherFeatureTypes());
+                                             GetCryptAuthFeatureTypeStrings());
 
   VerifyGetFeatureStatuesResult(
       requested_device_ids,
@@ -355,7 +357,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
   // Send duplicate local device entries in the response. These duplicate
   // entries should be ignored.
   cryptauthv2::DeviceFeatureStatus status = ConvertDeviceToDeviceFeatureStatus(
-      GetLocalDeviceForTest(), GetBetterTogetherFeatureTypes());
+      GetLocalDeviceForTest(), GetCryptAuthFeatureTypeStrings());
   cryptauthv2::BatchGetFeatureStatusesResponse response;
   response.add_device_feature_statuses()->CopyFrom(status);
   response.add_device_feature_statuses()->CopyFrom(status);
@@ -376,7 +378,7 @@ TEST_F(DeviceSyncCryptAuthFeatureStatusGetterImplTest,
   base::flat_set<std::string> returned_device_ids = {
       GetLocalDeviceMetadataPacketForTest().device_id()};
   SendCorrectBatchGetFeatureStatusesResponse(returned_device_ids,
-                                             GetBetterTogetherFeatureTypes());
+                                             GetCryptAuthFeatureTypeStrings());
 
   VerifyGetFeatureStatuesResult(
       returned_device_ids,

chromeos/services/device_sync/cryptauth_feature_type.cc

@@ -4,88 +4,226 @@
 
 #include "chromeos/services/device_sync/cryptauth_feature_type.h"
 
+#include "base/no_destructor.h"
+
 namespace chromeos {
 
 namespace device_sync {
 
-std::string CryptAuthFeatureTypeToString(
-    const CryptAuthFeatureType& feature_type) {
+namespace {
+
+const char kBetterTogetherHostSupportedString[] =
+    "BETTER_TOGETHER_HOST_SUPPORTED";
+const char kBetterTogetherClientSupportedString[] =
+    "BETTER_TOGETHER_CLIENT_SUPPORTED";
+const char kEasyUnlockHostSupportedString[] = "EASY_UNLOCK_HOST_SUPPORTED";
+const char kEasyUnlockClientSupportedString[] = "EASY_UNLOCK_CLIENT_SUPPORTED";
+const char kMagicTetherHostSupportedString[] = "MAGIC_TETHER_HOST_SUPPORTED";
+const char kMagicTetherClientSupportedString[] =
+    "MAGIC_TETHER_CLIENT_SUPPORTED";
+const char kSmsConnectHostSupportedString[] = "SMS_CONNECT_HOST_SUPPORTED";
+const char kSmsConnectClientSupportedString[] = "SMS_CONNECT_CLIENT_SUPPORTED";
+
+const char kBetterTogetherHostEnabledString[] = "BETTER_TOGETHER_HOST";
+const char kBetterTogetherClientEnabledString[] = "BETTER_TOGETHER_CLIENT";
+const char kEasyUnlockHostEnabledString[] = "EASY_UNLOCK_HOST";
+const char kEasyUnlockClientEnabledString[] = "EASY_UNLOCK_CLIENT";
+const char kMagicTetherHostEnabledString[] = "MAGIC_TETHER_HOST";
+const char kMagicTetherClientEnabledString[] = "MAGIC_TETHER_CLIENT";
+const char kSmsConnectHostEnabledString[] = "SMS_CONNECT_HOST";
+const char kSmsConnectClientEnabledString[] = "SMS_CONNECT_CLIENT";
+
+}  // namespace
+
+const char* CryptAuthFeatureTypeToString(CryptAuthFeatureType feature_type) {
   switch (feature_type) {
     case CryptAuthFeatureType::kBetterTogetherHostSupported:
-      return "BetterTogetherHostSupported";
+      return kBetterTogetherHostSupportedString;
     case CryptAuthFeatureType::kBetterTogetherHostEnabled:
-      return "BetterTogetherHostEnabled";
+      return kBetterTogetherHostEnabledString;
     case CryptAuthFeatureType::kBetterTogetherClientSupported:
-      return "BetterTogetherClientSupported";
+      return kBetterTogetherClientSupportedString;
     case CryptAuthFeatureType::kBetterTogetherClientEnabled:
-      return "BetterTogetherClientEnabled";
+      return kBetterTogetherClientEnabledString;
     case CryptAuthFeatureType::kEasyUnlockHostSupported:
-      return "EasyUnlockHostSupported";
+      return kEasyUnlockHostSupportedString;
     case CryptAuthFeatureType::kEasyUnlockHostEnabled:
-      return "EasyUnlockHostEnabled";
+      return kEasyUnlockHostEnabledString;
     case CryptAuthFeatureType::kEasyUnlockClientSupported:
-      return "EasyUnlockClientSupported";
+      return kEasyUnlockClientSupportedString;
     case CryptAuthFeatureType::kEasyUnlockClientEnabled:
-      return "EasyUnlockClientEnabled";
+      return kEasyUnlockClientEnabledString;
     case CryptAuthFeatureType::kMagicTetherHostSupported:
-      return "MagicTetherHostSupported";
+      return kMagicTetherHostSupportedString;
     case CryptAuthFeatureType::kMagicTetherHostEnabled:
-      return "MagicTetherHostEnabled";
+      return kMagicTetherHostEnabledString;
     case CryptAuthFeatureType::kMagicTetherClientSupported:
-      return "MagicTetherClientSupported";
+      return kMagicTetherClientSupportedString;
     case CryptAuthFeatureType::kMagicTetherClientEnabled:
-      return "MagicTetherClientEnabled";
+      return kMagicTetherClientEnabledString;
     case CryptAuthFeatureType::kSmsConnectHostSupported:
-      return "SmsConnectHostSupported";
+      return kSmsConnectHostSupportedString;
     case CryptAuthFeatureType::kSmsConnectHostEnabled:
-      return "SmsConnectHostEnabled";
+      return kSmsConnectHostEnabledString;
     case CryptAuthFeatureType::kSmsConnectClientSupported:
-      return "SmsConnectClientSupported";
+      return kSmsConnectClientSupportedString;
     case CryptAuthFeatureType::kSmsConnectClientEnabled:
-      return "SmsConnectClientEnabled";
+      return kSmsConnectClientEnabledString;
+  }
+}
+
+const char* SoftwareFeatureToEnabledCryptAuthFeatureTypeString(
+    multidevice::SoftwareFeature software_feature) {
+  switch (software_feature) {
+    case multidevice::SoftwareFeature::kBetterTogetherHost:
+      return kBetterTogetherHostEnabledString;
+    case multidevice::SoftwareFeature::kBetterTogetherClient:
+      return kBetterTogetherClientEnabledString;
+    case multidevice::SoftwareFeature::kSmartLockHost:
+      return kEasyUnlockHostEnabledString;
+    case multidevice::SoftwareFeature::kSmartLockClient:
+      return kEasyUnlockClientEnabledString;
+    case multidevice::SoftwareFeature::kInstantTetheringHost:
+      return kMagicTetherHostEnabledString;
+    case multidevice::SoftwareFeature::kInstantTetheringClient:
+      return kMagicTetherClientEnabledString;
+    case multidevice::SoftwareFeature::kMessagesForWebHost:
+      return kSmsConnectHostEnabledString;
+    case multidevice::SoftwareFeature::kMessagesForWebClient:
+      return kSmsConnectClientEnabledString;
   }
 }
 
 base::Optional<CryptAuthFeatureType> CryptAuthFeatureTypeFromString(
     const std::string& feature_type_string) {
-  if (feature_type_string == "BetterTogetherHostSupported")
+  if (feature_type_string == kBetterTogetherHostSupportedString)
     return CryptAuthFeatureType::kBetterTogetherHostSupported;
-  if (feature_type_string == "BetterTogetherHostEnabled")
+  if (feature_type_string == kBetterTogetherHostEnabledString)
     return CryptAuthFeatureType::kBetterTogetherHostEnabled;
-  if (feature_type_string == "BetterTogetherClientSupported")
+  if (feature_type_string == kBetterTogetherClientSupportedString)
     return CryptAuthFeatureType::kBetterTogetherClientSupported;
-  if (feature_type_string == "BetterTogetherClientEnabled")
+  if (feature_type_string == kBetterTogetherClientEnabledString)
     return CryptAuthFeatureType::kBetterTogetherClientEnabled;
-  if (feature_type_string == "EasyUnlockHostSupported")
+  if (feature_type_string == kEasyUnlockHostSupportedString)
     return CryptAuthFeatureType::kEasyUnlockHostSupported;
-  if (feature_type_string == "EasyUnlockHostEnabled")
+  if (feature_type_string == kEasyUnlockHostEnabledString)
     return CryptAuthFeatureType::kEasyUnlockHostEnabled;
-  if (feature_type_string == "EasyUnlockClientSupported")
+  if (feature_type_string == kEasyUnlockClientSupportedString)
     return CryptAuthFeatureType::kEasyUnlockClientSupported;
-  if (feature_type_string == "EasyUnlockClientEnabled")
+  if (feature_type_string == kEasyUnlockClientEnabledString)
     return CryptAuthFeatureType::kEasyUnlockClientEnabled;
-  if (feature_type_string == "MagicTetherHostSupported")
+  if (feature_type_string == kMagicTetherHostSupportedString)
     return CryptAuthFeatureType::kMagicTetherHostSupported;
-  if (feature_type_string == "MagicTetherHostEnabled")
+  if (feature_type_string == kMagicTetherHostEnabledString)
     return CryptAuthFeatureType::kMagicTetherHostEnabled;
-  if (feature_type_string == "MagicTetherClientSupported")
+  if (feature_type_string == kMagicTetherClientSupportedString)
     return CryptAuthFeatureType::kMagicTetherClientSupported;
-  if (feature_type_string == "MagicTetherClientEnabled")
+  if (feature_type_string == kMagicTetherClientEnabledString)
     return CryptAuthFeatureType::kMagicTetherClientEnabled;
-  if (feature_type_string == "SmsConnectHostSupported")
+  if (feature_type_string == kSmsConnectHostSupportedString)
     return CryptAuthFeatureType::kSmsConnectHostSupported;
-  if (feature_type_string == "SmsConnectHostEnabled")
+  if (feature_type_string == kSmsConnectHostEnabledString)
     return CryptAuthFeatureType::kSmsConnectHostEnabled;
-  if (feature_type_string == "SmsConnectClientSupported")
+  if (feature_type_string == kSmsConnectClientSupportedString)
     return CryptAuthFeatureType::kSmsConnectClientSupported;
-  if (feature_type_string == "SmsConnectClientEnabled")
+  if (feature_type_string == kSmsConnectClientEnabledString)
     return CryptAuthFeatureType::kSmsConnectClientEnabled;
 
   return base::nullopt;
 }
 
+const base::flat_set<std::string>& GetCryptAuthFeatureTypeStrings() {
+  static const base::NoDestructor<base::flat_set<std::string>> feature_set([] {
+    return base::flat_set<std::string>{kBetterTogetherHostSupportedString,
+                                       kBetterTogetherClientSupportedString,
+                                       kEasyUnlockHostSupportedString,
+                                       kEasyUnlockClientSupportedString,
+                                       kMagicTetherHostSupportedString,
+                                       kMagicTetherClientSupportedString,
+                                       kSmsConnectHostSupportedString,
+                                       kSmsConnectClientSupportedString,
+                                       kBetterTogetherHostEnabledString,
+                                       kBetterTogetherClientEnabledString,
+                                       kEasyUnlockHostEnabledString,
+                                       kEasyUnlockClientEnabledString,
+                                       kMagicTetherHostEnabledString,
+                                       kMagicTetherClientEnabledString,
+                                       kSmsConnectHostEnabledString,
+                                       kSmsConnectClientEnabledString};
+  }());
+  return *feature_set;
+}
+
+const base::flat_set<std::string>& GetSupportedCryptAuthFeatureTypeStrings() {
+  static const base::NoDestructor<base::flat_set<std::string>> supported_set(
+      [] {
+        return base::flat_set<std::string>{kBetterTogetherHostSupportedString,
+                                           kBetterTogetherClientSupportedString,
+                                           kEasyUnlockHostSupportedString,
+                                           kEasyUnlockClientSupportedString,
+                                           kMagicTetherHostSupportedString,
+                                           kMagicTetherClientSupportedString,
+                                           kSmsConnectHostSupportedString,
+                                           kSmsConnectClientSupportedString};
+      }());
+  return *supported_set;
+}
+
+const base::flat_set<std::string>& GetEnabledCryptAuthFeatureTypeStrings() {
+  static const base::NoDestructor<base::flat_set<std::string>> enabled_set([] {
+    return base::flat_set<std::string>{
+        kBetterTogetherHostEnabledString, kBetterTogetherClientEnabledString,
+        kEasyUnlockHostEnabledString,     kEasyUnlockClientEnabledString,
+        kMagicTetherHostEnabledString,    kMagicTetherClientEnabledString,
+        kSmsConnectHostEnabledString,     kSmsConnectClientEnabledString};
+  }());
+  return *enabled_set;
+}
+
+multidevice::SoftwareFeature CryptAuthFeatureTypeStringToSoftwareFeature(
+    const std::string& feature_type_string) {
+  if (feature_type_string == kBetterTogetherHostSupportedString ||
+      feature_type_string == kBetterTogetherHostEnabledString) {
+    return multidevice::SoftwareFeature::kBetterTogetherHost;
+  }
+
+  if (feature_type_string == kBetterTogetherClientSupportedString ||
+      feature_type_string == kBetterTogetherClientEnabledString) {
+    return multidevice::SoftwareFeature::kBetterTogetherClient;
+  }
+
+  if (feature_type_string == kEasyUnlockHostSupportedString ||
+      feature_type_string == kEasyUnlockHostEnabledString) {
+    return multidevice::SoftwareFeature::kSmartLockHost;
+  }
+
+  if (feature_type_string == kEasyUnlockClientSupportedString ||
+      feature_type_string == kEasyUnlockClientEnabledString) {
+    return multidevice::SoftwareFeature::kSmartLockClient;
+  }
+
+  if (feature_type_string == kMagicTetherHostSupportedString ||
+      feature_type_string == kMagicTetherHostEnabledString) {
+    return multidevice::SoftwareFeature::kInstantTetheringHost;
+  }
+
+  if (feature_type_string == kMagicTetherClientSupportedString ||
+      feature_type_string == kMagicTetherClientEnabledString) {
+    return multidevice::SoftwareFeature::kInstantTetheringClient;
+  }
+
+  if (feature_type_string == kSmsConnectHostSupportedString ||
+      feature_type_string == kSmsConnectHostEnabledString) {
+    return multidevice::SoftwareFeature::kMessagesForWebHost;
+  }
+
+  DCHECK(feature_type_string == kSmsConnectClientSupportedString ||
+         feature_type_string == kSmsConnectClientEnabledString);
+  return multidevice::SoftwareFeature::kMessagesForWebClient;
+}
+
 std::ostream& operator<<(std::ostream& stream,
-                         const CryptAuthFeatureType& feature_type) {
+                         CryptAuthFeatureType feature_type) {
   stream << CryptAuthFeatureTypeToString(feature_type);
   return stream;
 }

chromeos/services/device_sync/cryptauth_feature_type.h

@@ -8,7 +8,9 @@
 #include <ostream>
 #include <string>
 
+#include "base/containers/flat_set.h"
 #include "base/optional.h"
+#include "chromeos/components/multidevice/software_feature.h"
 
 namespace chromeos {
 
@@ -23,11 +25,11 @@ namespace device_sync {
 // supported but not enabled:
 //   [
 //     message FeatureStatus {
-//       string feature_type = "BetterTogetherHostSupported";
+//       string feature_type = "BETTER_TOGETHER_HOST_SUPPORTED";
 //       bool enabled = true;
 //     },
 //     message FeatureStatus {
-//       string feature_type = "BetterTogetherHostEnabled";
+//       string feature_type = "BETTER_TOGETHER_HOST";
 //       bool enabled = false;
 //     }
 //   ]
@@ -60,18 +62,29 @@ enum class CryptAuthFeatureType {
   kSmsConnectClientEnabled,
 };
 
-// Uniquely maps each enum value to a string used in the protos and understood
-// by CryptAuth.
-std::string CryptAuthFeatureTypeToString(
-    const CryptAuthFeatureType& feature_type);
+// Uniquely maps each CryptAuthFeatureType enum value to a string used in the
+// protos and understood by CryptAuth.
+const char* CryptAuthFeatureTypeToString(CryptAuthFeatureType feature_type);
+
+// Uniquely maps each SoftwareFeature enum value to a string used in the protos
+// and understood by CryptAuth.
+const char* SoftwareFeatureToEnabledCryptAuthFeatureTypeString(
+    multidevice::SoftwareFeature software_feature);
 
 // Returns null if |feature_type_string| does not map to a known
 // CryptAuthFeatureType.
 base::Optional<CryptAuthFeatureType> CryptAuthFeatureTypeFromString(
     const std::string& feature_type_string);
 
+multidevice::SoftwareFeature CryptAuthFeatureTypeStringToSoftwareFeature(
+    const std::string& feature_type_string);
+
+const base::flat_set<std::string>& GetCryptAuthFeatureTypeStrings();
+const base::flat_set<std::string>& GetSupportedCryptAuthFeatureTypeStrings();
+const base::flat_set<std::string>& GetEnabledCryptAuthFeatureTypeStrings();
+
 std::ostream& operator<<(std::ostream& stream,
-                         const CryptAuthFeatureType& feature_type);
+                         CryptAuthFeatureType feature_type);
 
 }  // namespace device_sync