Use the ImageFile superclass for MetadataImage

Bug: b/472344572

Author: Databean

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

@@ -228,7 +228,7 @@ Result<std::set<std::string>> PreservingOnResume(
   preserving.insert(FactoryResetProtectedImage::FileName());
   preserving.insert(absl::StrCat(MiscImage::kName, ".img"));
   preserving.insert("vmmtruststore.img");
-  preserving.insert(MetadataImage::Name());
+  preserving.insert(absl::StrCat(MetadataImage::kName, ".img"));
   preserving.insert("persistent_vbmeta.img");
   preserving.insert("oemlock_secure");
   preserving.insert("oemlock_insecure");
@@ -338,14 +338,14 @@ Result<const CuttlefishConfig*> InitFilesystemAndCreateConfig(
     // if any device needs to rebuild its composite disk,
     // then don't preserve any files and delete everything.
     for (const auto& instance : config.Instances()) {
-      Result<MetadataImage> metadata = MetadataImage::Reuse(instance);
+      MetadataImage metadata(instance);
       MiscImage misc(instance);
       Result<std::optional<ChromeOsStateImage>> chrome_os_state =
           CF_EXPECT(ChromeOsStateImage::Reuse(instance));
-      if (chrome_os_state.ok() && metadata.ok()) {
+      if (chrome_os_state.ok()) {
         Result<DiskBuilder> os_builder =
-            OsCompositeDiskBuilder(config, instance, *chrome_os_state,
-                                   *metadata, misc, system_image_dir);
+            OsCompositeDiskBuilder(config, instance, *chrome_os_state, metadata,
+                                   misc, system_image_dir);
         if (!os_builder.ok()) {
           creating_os_disk = true;
         } else {

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

@@ -158,7 +158,8 @@ Result<void> CreateDynamicDiskFiles(
       }
     }
 
-    MetadataImage metadata = CF_EXPECT(MetadataImage::ReuseOrCreate(instance));
+    MetadataImage metadata(instance);
+    CF_EXPECT(metadata.Generate());
 
     MiscImage misc(instance);
     CF_EXPECT(misc.Generate());

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

@@ -248,9 +248,9 @@ cf_cc_library(
     hdrs = ["metadata_image.h"],
     deps = [
         "//cuttlefish/common/libs/utils:files",
+        "//cuttlefish/host/commands/assemble_cvd/disk:image_file",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:data_image",
-        "//cuttlefish/host/libs/image_aggregator",
         "//cuttlefish/result",
     ],
 )

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/android_composite_disk_config.cc

@@ -41,6 +41,7 @@ constexpr struct {
   std::string_view boot = "boot";
   std::string_view hibernation = "hibernation";
   std::string_view init_boot = "init_boot";
+  std::string_view metadata = "metadata";
   std::string_view misc = "misc";
   std::string_view super = "super";
   std::string_view userdata = "userdata";
@@ -91,6 +92,7 @@ Result<std::vector<ImagePartition>> AndroidCompositeDiskConfig(
   const std::map<std::string_view, std::string> primary_paths = {
       {kPartitions.boot, instance.new_boot_image()},
       {kPartitions.init_boot, instance.init_boot_image()},
+      {kPartitions.metadata, CF_EXPECT(metadata_image.Path())},
       {kPartitions.misc, CF_EXPECT(misc_image.Path())},
       {kPartitions.super, instance.new_super_image()},
       {kPartitions.userdata, instance.new_data_image()},
@@ -140,8 +142,6 @@ Result<std::vector<ImagePartition>> AndroidCompositeDiskConfig(
     }
   }
 
-  partitions.push_back(metadata_image.Partition());
-
   std::optional<ImagePartition> hibernation_partition =
       HibernationImage(system_image_dir, instance);
   if (hibernation_partition) {

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/metadata_image.cc

@@ -23,48 +23,35 @@
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/data_image.h"
-#include "cuttlefish/host/libs/image_aggregator/image_aggregator.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
 
 static constexpr size_t kMetadataImageMb = 64;
 static constexpr size_t kMetadataImageBytes = kMetadataImageMb << 20;
 
-Result<MetadataImage> MetadataImage::ReuseOrCreate(
-    const CuttlefishConfig::InstanceSpecific& instance) {
-  Result<MetadataImage> reused = Reuse(instance);
-  if (reused.ok()) {
-    return reused;
-  }
-
-  std::string path = instance.PerInstancePath(Name());
-
-  CF_EXPECTF(CreateBlankImage(path, kMetadataImageMb, "none"),
-             "Failed to create '{}' with size '{}' MB", path, kMetadataImageMb);
-
-  return MetadataImage(std::move(path));
+MetadataImage::MetadataImage(const CuttlefishConfig::InstanceSpecific& ins) {
+  path_ = ins.PerInstancePath(kName);
+  ready_ = FileExists(path_) && FileSize(path_) == kMetadataImageBytes;
 }
 
-Result<MetadataImage> MetadataImage::Reuse(
-    const CuttlefishConfig::InstanceSpecific& instance) {
-  std::string path = instance.PerInstancePath(Name());
+MetadataImage::MetadataImage(std::string path) : path_(std::move(path)) {}
 
-  CF_EXPECT(FileExists(path));
-  CF_EXPECT_EQ(FileSize(path), kMetadataImageBytes);
+std::string MetadataImage::Name() const { return std::string(kName); }
 
-  return MetadataImage(std::move(path));
+Result<std::string> MetadataImage::Path() const {
+  CF_EXPECT(!!ready_);
+  return path_;
 }
 
-MetadataImage::MetadataImage(std::string path) : path_(std::move(path)) {}
-
-std::string MetadataImage::Name() { return "metadata.img"; }
-
-ImagePartition MetadataImage::Partition() const {
-  return ImagePartition{
-      .label = "metadata",
-      .image_file_path = path_,
-  };
+Result<std::string> MetadataImage::Generate() {
+  if (!ready_) {
+    CF_EXPECTF(CreateBlankImage(path_, kMetadataImageMb, "none"),
+               "Failed to create '{}' with size '{}' MB", path_,
+               kMetadataImageMb);
+    ready_ = true;
+  }
+  return path_;
 }
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/metadata_image.h

@@ -17,26 +17,30 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 
+#include "cuttlefish/host/commands/assemble_cvd/disk/image_file.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
-#include "cuttlefish/host/libs/image_aggregator/image_aggregator.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
 
-class MetadataImage {
+class MetadataImage : public ImageFile {
  public:
-  static Result<MetadataImage> ReuseOrCreate(
-      const CuttlefishConfig::InstanceSpecific&);
-  static Result<MetadataImage> Reuse(const CuttlefishConfig::InstanceSpecific&);
+  static constexpr std::string_view kName = "metadata";
 
-  static std::string Name();
+  MetadataImage(const CuttlefishConfig::InstanceSpecific&);
 
-  ImagePartition Partition() const;
+  std::string Name() const override;
+
+  Result<std::string> Generate() override;
+
+  Result<std::string> Path() const override;
 
  private:
   MetadataImage(std::string);
 
+  bool ready_;
   std::string path_;
 };