Create a type to represent --blank_data_image_mb

To allow reuse of the parsing logic for metrics data gathering.

Bug: 442024462

Author: cjreynol

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

@@ -269,6 +269,7 @@ cf_cc_library(
         "//cuttlefish/host/commands/assemble_cvd:network_flags",
         "//cuttlefish/host/commands/assemble_cvd:touchpad",
         "//cuttlefish/host/commands/assemble_cvd/flags:android_efi_loader",
+        "//cuttlefish/host/commands/assemble_cvd/flags:blank_data_image_mb",
         "//cuttlefish/host/commands/assemble_cvd/flags:boot_image",
         "//cuttlefish/host/commands/assemble_cvd/flags:bootloader",
         "//cuttlefish/host/commands/assemble_cvd/flags:display_proto",

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

@@ -30,12 +30,9 @@
 DEFINE_vec(cpus, std::to_string(CF_DEFAULTS_CPUS),
               "Virtual CPU count.");
 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(blank_data_image_mb,
-              CF_DEFAULTS_BLANK_DATA_IMAGE_MB,
-             "The size of the blank data image to generate, MB.");
+           "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

@@ -22,7 +22,6 @@
 
 DECLARE_vec(cpus);
 DECLARE_vec(data_policy);
-DECLARE_vec(blank_data_image_mb);
 DECLARE_vec(gdb_port);
 
 // TODO(b/192495477): combine these into a single repeatable '--display' flag

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

@@ -49,6 +49,7 @@
 #include "cuttlefish/host/commands/assemble_cvd/disk_image_flags_vectorization.h"
 #include "cuttlefish/host/commands/assemble_cvd/display.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/android_efi_loader.h"
+#include "cuttlefish/host/commands/assemble_cvd/flags/blank_data_image_mb.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/boot_image.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/bootloader.h"
 #include "cuttlefish/host/commands/assemble_cvd/flags/display_proto.h"
@@ -227,56 +228,6 @@ Result<std::vector<int>> GetFlagIntValueForInstances(
   return value_vec;
 }
 
-Result<std::vector<int>> GetDataImageFlagOrGuestIntValueForInstances(
-    const std::string& flag_values,
-    const std::vector<GuestConfig>& guest_configs, int32_t instances_size,
-    std::map<std::string, std::string>& name_to_default_value) {
-  std::vector<std::string> flag_vec = android::base::Split(flag_values, ",");
-  std::vector<int> value_vec(instances_size);
-  std::string flag_name = "blank_data_image_mb";
-  bool flag_set =
-      !gflags::GetCommandLineFlagInfoOrDie(flag_name.c_str()).is_default;
-  CF_EXPECT(name_to_default_value.find(flag_name) !=
-            name_to_default_value.end());
-  std::string default_value = name_to_default_value[flag_name];
-  bool first_unset = false;
-
-  for (int instance_index = 0; instance_index < instances_size;
-       instance_index++) {
-    if (flag_set) {
-      if (instance_index < flag_vec.size()) {
-        if ((flag_vec[instance_index] == "unset" ||
-             flag_vec[instance_index] == "\"unset\"") &&
-            instance_index == 0) {
-          first_unset = true;
-        } else {
-          CF_EXPECT(android::base::ParseInt(default_value,
-                                            &value_vec[instance_index]),
-                    "Failed to parse value \"" << default_value << "\" for "
-                                               << flag_name);
-          continue;
-        }
-      } else {
-        if (!first_unset) {
-          value_vec[instance_index] = value_vec[0];
-          continue;
-        }
-      }
-    }
-
-    if (guest_configs[instance_index].blank_data_image_mb != 0) {
-      value_vec[instance_index] =
-          guest_configs[instance_index].blank_data_image_mb;
-    } else {
-      CF_EXPECT(
-          android::base::ParseInt(default_value, &value_vec[instance_index]),
-          "Failed to parse value \"" << default_value << "\" for "
-                                     << flag_name);
-    }
-  }
-  return value_vec;
-}
-
 Result<std::vector<std::string>> GetFlagStrValueForInstances(
     const std::string& flag_values, int32_t instances_size,
     const std::string& flag_name, std::map<std::string, std::string>& name_to_default_value) {
@@ -505,10 +456,8 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
   std::vector<std::string> vsock_guest_group_vec =
       CF_EXPECT(GET_FLAG_STR_VALUE(vsock_guest_group));
   std::vector<int> cpus_vec = CF_EXPECT(GET_FLAG_INT_VALUE(cpus));
-  std::vector<int> blank_data_image_mb_vec =
-      CF_EXPECT(GetDataImageFlagOrGuestIntValueForInstances(
-          FLAGS_blank_data_image_mb, guest_configs, instances_size,
-          name_to_default_value));
+  BlankDataImageMbFlag blank_data_image_mb_values =
+      CF_EXPECT(BlankDataImageMbFlag::FromGlobalGflags(guest_configs));
   std::vector<int> gdb_port_vec = CF_EXPECT(GET_FLAG_INT_VALUE(gdb_port));
   std::vector<std::string> setupwizard_mode_vec =
       CF_EXPECT(GET_FLAG_STR_VALUE(setupwizard_mode));
@@ -929,7 +878,8 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
         guest_configs[instance_index].android_version_number);
     instance.set_console(console_vec[instance_index]);
     instance.set_kgdb(console_vec[instance_index] && kgdb_vec[instance_index]);
-    instance.set_blank_data_image_mb(blank_data_image_mb_vec[instance_index]);
+    instance.set_blank_data_image_mb(
+        blank_data_image_mb_values.ForIndex(instance_index));
     instance.set_gdb_port(gdb_port_vec[instance_index]);
     instance.set_fail_fast(fail_fast_vec[instance_index]);
     if (vhost_user_block_vec[instance_index]) {

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

@@ -33,6 +33,19 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "blank_data_image_mb",
+    srcs = ["blank_data_image_mb.cc"],
+    hdrs = ["blank_data_image_mb.h"],
+    deps = [
+        "//cuttlefish/common/libs/utils:result",
+        "//cuttlefish/host/commands/assemble_cvd:flags_defaults",
+        "//cuttlefish/host/commands/assemble_cvd:guest_config",
+        "//libbase",
+        "@gflags",
+    ],
+)
+
 cf_cc_library(
     name = "boot_image",
     srcs = ["boot_image.cc"],

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

@@ -0,0 +1,81 @@
+/*
+ * 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/blank_data_image_mb.h"
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include <android-base/parseint.h>
+#include <android-base/strings.h>
+#include <gflags/gflags.h>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/commands/assemble_cvd/flags_defaults.h"
+#include "cuttlefish/host/commands/assemble_cvd/guest_config.h"
+
+DEFINE_string(blank_data_image_mb, CF_DEFAULTS_BLANK_DATA_IMAGE_MB,
+              "The size of the blank data image to generate, MB.");
+
+namespace cuttlefish {
+
+Result<BlankDataImageMbFlag> BlankDataImageMbFlag::FromGlobalGflags(
+    const std::vector<GuestConfig>& guest_configs) {
+  gflags::CommandLineFlagInfo flag_info =
+      gflags::GetCommandLineFlagInfoOrDie("blank_data_image_mb");
+  int default_value;
+  CF_EXPECTF(android::base::ParseInt(flag_info.default_value, &default_value),
+             "Failed to parse value as integer: \"{}\"",
+             flag_info.default_value);
+
+  std::vector<std::string> string_values =
+      android::base::Split(flag_info.current_value, ",");
+  const std::size_t size = guest_configs.size() > string_values.size()
+                               ? guest_configs.size()
+                               : string_values.size();
+  std::vector<int> values(size);
+
+  for (int i = 0; i < size; i++) {
+    if (i < string_values.size()) {
+      if (string_values[i] == "unset" || string_values[i] == "\"unset\"") {
+        values[i] = default_value;
+      } else {
+        CF_EXPECTF(android::base::ParseInt(string_values[i], &values[i]),
+                   "Failed to parse value as integer: \"{}\"",
+                   string_values[i]);
+      }
+    } else {
+      values[i] = guest_configs[i].blank_data_image_mb;
+    }
+  }
+  return BlankDataImageMbFlag(default_value, std::move(values));
+}
+
+int BlankDataImageMbFlag::ForIndex(std::size_t index) const {
+  if (index < blank_data_image_mb_values_.size()) {
+    return blank_data_image_mb_values_[index];
+  } else {
+    return default_value_;
+  }
+}
+
+BlankDataImageMbFlag::BlankDataImageMbFlag(
+    const int default_value, std::vector<int> blank_data_image_mb_values)
+    : default_value_(default_value),
+      blank_data_image_mb_values_(blank_data_image_mb_values) {}
+
+}  // namespace cuttlefish

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

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <cstdlib>
+#include <vector>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/commands/assemble_cvd/guest_config.h"
+
+namespace cuttlefish {
+
+class BlankDataImageMbFlag {
+ public:
+  static Result<BlankDataImageMbFlag> FromGlobalGflags(
+      const std::vector<GuestConfig>& guest_configs);
+
+  int ForIndex(std::size_t index) const;
+
+ private:
+  BlankDataImageMbFlag(const int, std::vector<int>);
+
+  int default_value_ = 0;
+  std::vector<int> blank_data_image_mb_values_;
+};
+
+}  // namespace cuttlefish