Add data_policy to list of flags gathered for metrics

base/cvd/cuttlefish/host/commands/assemble_cvd/BUILD.bazel

@@ -301,6 +301,7 @@ cf_cc_library(
         "//cuttlefish/host/commands/assemble_cvd/flags:bootloader",
         "//cuttlefish/host/commands/assemble_cvd/flags:cpus",
         "//cuttlefish/host/commands/assemble_cvd/flags:daemon",
+        "//cuttlefish/host/commands/assemble_cvd/flags:data_policy",
         "//cuttlefish/host/commands/assemble_cvd/flags:display_proto",
         "//cuttlefish/host/commands/assemble_cvd/flags:initramfs_path",
         "//cuttlefish/host/commands/assemble_cvd/flags:kernel_path",

base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp

@@ -27,10 +27,6 @@
 
 #define DEFINE_vec DEFINE_string
 
-DEFINE_vec(data_policy, CF_DEFAULTS_DATA_POLICY,
-           "How to handle userdata partition."
-           " Either 'use_existing', 'create_if_missing', 'resize_up_to', or "
-           "'always_create'.");
 DEFINE_vec(gdb_port, std::to_string(CF_DEFAULTS_GDB_PORT),
              "Port number to spawn kernel gdb on e.g. -gdb_port=1234. The"
              "kernel must have been built with CONFIG_RANDOMIZE_BASE "

base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h

@@ -20,7 +20,6 @@
 
 #define DECLARE_vec DECLARE_string
 
-DECLARE_vec(data_policy);
 DECLARE_vec(gdb_port);
 
 // TODO(b/192495477): combine these into a single repeatable '--display' flag

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc

@@ -56,6 +56,7 @@
 #include "cuttlefish/host/commands/assemble_cvd/flags/bootloader.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/cpus.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/daemon.h"
+#include "cuttlefish/host/commands/assemble_cvd/flags/data_policy.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/display_proto.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/initramfs_path.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/kernel_path.h"
@@ -603,8 +604,8 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
       CF_EXPECT(GET_FLAG_STR_VALUE(gem5_binary_dir));
   std::vector<std::string> gem5_checkpoint_dir_vec =
       CF_EXPECT(GET_FLAG_STR_VALUE(gem5_checkpoint_dir));
-  std::vector<std::string> data_policy_vec =
-      CF_EXPECT(GET_FLAG_STR_VALUE(data_policy));
+  DataPolicyFlag data_policy_values =
+      CF_EXPECT(DataPolicyFlag::FromGlobalGflags());
 
   // multi-virtual-device multi-display proto input
   DisplaysProtoFlag instances_display_configs =
@@ -983,7 +984,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
     instance.set_camera_server_port(camera_server_port_vec[instance_index]);
     instance.set_gem5_binary_dir(gem5_binary_dir_vec[instance_index]);
     instance.set_gem5_checkpoint_dir(gem5_checkpoint_dir_vec[instance_index]);
-    instance.set_data_policy(data_policy_vec[instance_index]);
+    instance.set_data_policy(data_policy_values.ForIndex(instance_index));
 
     instance.set_has_wifi_card(enable_wifi_vec[instance_index]);
     instance.set_mobile_bridge_name(StrForInstance("cvd-mbr-", num));

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/BUILD.bazel

@@ -125,6 +125,20 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "data_policy",
+    srcs = ["data_policy.cc"],
+    hdrs = ["data_policy.h"],
+    deps = [
+        "//cuttlefish/host/commands/assemble_cvd:flags_defaults",
+        "//cuttlefish/host/commands/assemble_cvd/flags:flag_base",
+        "//cuttlefish/host/commands/assemble_cvd/flags:from_gflags",
+        "//cuttlefish/host/libs/config:data_image_policy",
+        "//cuttlefish/result",
+        "@gflags",
+    ],
+)
+
 cf_cc_library(
     name = "display_proto",
     srcs = ["display_proto.cc"],

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/data_policy.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2025 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 "cuttlefish/host/commands/assemble_cvd/flags/data_policy.h"
+
+#include <iterator>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gflags/gflags.h>
+
+#include "cuttlefish/host/commands/assemble_cvd/flags/flag_base.h"
+#include "cuttlefish/host/commands/assemble_cvd/flags/from_gflags.h"
+#include "cuttlefish/host/commands/assemble_cvd/flags_defaults.h"
+#include "cuttlefish/host/libs/config/data_image_policy.h"
+#include "cuttlefish/result/result.h"
+
+DEFINE_string(data_policy, CF_DEFAULTS_DATA_POLICY,
+              "How to handle userdata partition. Either 'use_existing', "
+              "'resize_up_to', or 'always_create'.");
+
+namespace cuttlefish {
+namespace {
+
+constexpr char kFlagName[] = "data_policy";
+
+}  // namespace
+
+Result<DataPolicyFlag> DataPolicyFlag::FromGlobalGflags() {
+  const auto flag_info = gflags::GetCommandLineFlagInfoOrDie(kFlagName);
+  std::vector<std::string> flag_string_values =
+      CF_EXPECT(StringFromGlobalGflags(flag_info, kFlagName));
+  std::vector<DataImagePolicy> flag_values;
+  std::transform(flag_string_values.cbegin(), flag_string_values.cend(),
+                 std::back_inserter(flag_values), DataImagePolicyFromString);
+  return DataPolicyFlag(std::move(flag_values));
+}
+
+DataPolicyFlag::DataPolicyFlag(std::vector<DataImagePolicy> flag_values)
+    : FlagBase<DataImagePolicy>(std::move(flag_values)) {}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/data_policy.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2026 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.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include "cuttlefish/host/commands/assemble_cvd/flags/flag_base.h"
+#include "cuttlefish/host/libs/config/data_image_policy.h"
+#include "cuttlefish/result/result.h"
+
+namespace cuttlefish {
+
+class DataPolicyFlag : public FlagBase<DataImagePolicy> {
+ public:
+  static Result<DataPolicyFlag> FromGlobalGflags();
+  ~DataPolicyFlag() override = default;
+
+ private:
+  DataPolicyFlag(std::vector<DataImagePolicy>);
+};
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/flag_base.cc

@@ -16,29 +16,10 @@
 
 #include "cuttlefish/host/commands/assemble_cvd/flags/flag_base.h"
 
-#include <cstdlib>
 #include <string>
-#include <utility>
-#include <vector>
 
 namespace cuttlefish {
 
-template <typename T>
-T FlagBase<T>::ForIndex(const std::size_t index) const {
-  if (index < values_.size()) {
-    return values_[index];
-  } else {
-    return values_[0];
-  }
-}
-
-template <typename T>
-FlagBase<T>::FlagBase(std::vector<T> flag_values)
-    : values_(std::move(flag_values)) {}
-
-template <typename T>
-FlagBase<T>::~FlagBase() {}
-
 template class FlagBase<bool>;
 template class FlagBase<int>;
 template class FlagBase<std::string>;

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/flag_base.h

@@ -17,21 +17,35 @@
 #pragma once
 
 #include <cstdlib>
+#include <utility>
 #include <vector>
 
 namespace cuttlefish {
 
 template <typename T>
 class FlagBase {
  public:
-  T ForIndex(const std::size_t index) const;
+  T ForIndex(const std::size_t index) const {
+    if (index < values_.size()) {
+      return values_[index];
+    } else {
+      return values_[0];
+    }
+  }
 
  protected:
-  FlagBase(std::vector<T> flag_values);
+  FlagBase(std::vector<T> flag_values) : values_(std::move(flag_values)) {}
   virtual ~FlagBase() = 0;
 
  private:
   std::vector<T> values_;
 };
 
+template <typename T>
+FlagBase<T>::~FlagBase() {}
+
+extern template class FlagBase<bool>;
+extern template class FlagBase<int>;
+extern template class FlagBase<std::string>;
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/config/BUILD.bazel

@@ -124,6 +124,7 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:config_constants",
         "//cuttlefish/host/libs/config:config_fragment",
         "//cuttlefish/host/libs/config:config_utils",
+        "//cuttlefish/host/libs/config:data_image_policy",
         "//cuttlefish/host/libs/config:external_network_mode",
         "//cuttlefish/host/libs/config:guest_hwui_renderer",
         "//cuttlefish/host/libs/config:guest_renderer_preload",
@@ -155,6 +156,7 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:boot_flow",
         "//cuttlefish/host/libs/config:config_utils",
         "//cuttlefish/host/libs/config:cuttlefish_config",
+        "//cuttlefish/host/libs/config:data_image_policy",
         "//cuttlefish/host/libs/config:esp",
         "//cuttlefish/host/libs/config:openwrt_args",
         "//cuttlefish/host/libs/image_aggregator:mbr",
@@ -164,6 +166,16 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "data_image_policy",
+    srcs = [
+        "data_image_policy.cc",
+    ],
+    hdrs = [
+        "data_image_policy.h",
+    ],
+)
+
 cf_cc_library(
     name = "display",
     srcs = ["display.cpp"],

base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h

@@ -34,6 +34,7 @@
 #include "cuttlefish/host/libs/config/config_constants.h"
 #include "cuttlefish/host/libs/config/config_fragment.h"
 #include "cuttlefish/host/libs/config/config_utils.h"
+#include "cuttlefish/host/libs/config/data_image_policy.h"
 #include "cuttlefish/host/libs/config/external_network_mode.h"
 #include "cuttlefish/host/libs/config/guest_hwui_renderer.h"
 #include "cuttlefish/host/libs/config/guest_renderer_preload.h"
@@ -470,7 +471,7 @@ class CuttlefishConfig {
 
     std::string vcpu_config_path() const;
 
-    std::string data_policy() const;
+    DataImagePolicy data_policy() const;
 
     int blank_data_image_mb() const;
 
@@ -707,7 +708,7 @@ class CuttlefishConfig {
     void set_target_arch(Arch target_arch);
     void set_cpus(int cpus);
     void set_vcpu_config_path(const std::string& vcpu_config_path);
-    void set_data_policy(const std::string& data_policy);
+    void set_data_policy(DataImagePolicy data_policy);
     void set_blank_data_image_mb(int blank_data_image_mb);
     void set_gdb_port(int gdb_port);
     void set_display_configs(const std::vector<DisplayConfig>& display_configs);

base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp

@@ -46,6 +46,7 @@
 #include "cuttlefish/host/libs/config/ap_boot_flow.h"
 #include "cuttlefish/host/libs/config/boot_flow.h"
 #include "cuttlefish/host/libs/config/config_constants.h"
+#include "cuttlefish/host/libs/config/data_image_policy.h"
 #include "cuttlefish/host/libs/config/external_network_mode.h"
 #include "cuttlefish/host/libs/config/guest_hwui_renderer.h"
 #include "cuttlefish/host/libs/config/guest_renderer_preload.h"
@@ -576,11 +577,11 @@ std::string CuttlefishConfig::InstanceSpecific::vcpu_config_path() const {
 
 static constexpr char kDataPolicy[] = "data_policy";
 void CuttlefishConfig::MutableInstanceSpecific::set_data_policy(
-    const std::string& data_policy) {
-  (*Dictionary())[kDataPolicy] = data_policy;
+    DataImagePolicy data_policy) {
+  (*Dictionary())[kDataPolicy] = DataImagePolicyString(data_policy);
 }
-std::string CuttlefishConfig::InstanceSpecific::data_policy() const {
-  return (*Dictionary())[kDataPolicy].asString();
+DataImagePolicy CuttlefishConfig::InstanceSpecific::data_policy() const {
+  return DataImagePolicyFromString((*Dictionary())[kDataPolicy].asString());
 }
 
 static constexpr char kBlankDataImageMb[] = "blank_data_image_mb";

base/cvd/cuttlefish/host/libs/config/data_image.cpp

@@ -36,6 +36,7 @@
 #include "cuttlefish/host/libs/config/boot_flow.h"
 #include "cuttlefish/host/libs/config/config_utils.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
+#include "cuttlefish/host/libs/config/data_image_policy.h"
 #include "cuttlefish/host/libs/config/esp.h"
 #include "cuttlefish/host/libs/config/openwrt_args.h"
 #include "cuttlefish/host/libs/image_aggregator/mbr.h"
@@ -48,10 +49,6 @@ namespace cuttlefish {
 
 namespace {
 
-static constexpr std::string_view kDataPolicyUseExisting = "use_existing";
-static constexpr std::string_view kDataPolicyAlwaysCreate = "always_create";
-static constexpr std::string_view kDataPolicyResizeUpTo = "resize_up_to";
-
 const int FSCK_ERROR_CORRECTED = 1;
 const int FSCK_ERROR_CORRECTED_REQUIRES_REBOOT = 2;
 
@@ -135,24 +132,25 @@ enum class DataImageAction { kNoAction, kResizeImage, kCreateBlankImage };
 
 static Result<DataImageAction> ChooseDataImageAction(
     const CuttlefishConfig::InstanceSpecific& instance) {
-  if (instance.data_policy() == kDataPolicyAlwaysCreate) {
+  if (instance.data_policy() == DataImagePolicy::AlwaysCreate) {
     return DataImageAction::kCreateBlankImage;
   }
   if (!FileHasContent(instance.data_image())) {
     return DataImageAction::kCreateBlankImage;
   }
-  if (instance.data_policy() == kDataPolicyUseExisting) {
+  if (instance.data_policy() == DataImagePolicy::UseExisting) {
     return DataImageAction::kNoAction;
   }
   auto current_fs_type = GetFsType(instance.data_image());
   if (current_fs_type != instance.userdata_format()) {
-    CF_EXPECT(instance.data_policy() != kDataPolicyResizeUpTo,
-              "Changing the fs format is incompatible with -data_policy="
-                  << kDataPolicyResizeUpTo << " (\"" << current_fs_type
-                  << "\" != \"" << instance.userdata_format() << "\")");
+    CF_EXPECT(instance.data_policy() != DataImagePolicy::ResizeUpTo,
+              "Changing the fs format is incompatible with --data_policy="
+                  << DataImagePolicyString(DataImagePolicy::ResizeUpTo)
+                  << " (\"" << current_fs_type << "\" != \""
+                  << instance.userdata_format() << "\")");
     return DataImageAction::kCreateBlankImage;
   }
-  if (instance.data_policy() == kDataPolicyResizeUpTo) {
+  if (instance.data_policy() == DataImagePolicy::ResizeUpTo) {
     return DataImageAction::kResizeImage;
   }
   return DataImageAction::kNoAction;