Make MiscImage implement ImageFile

Bug: b/471849677

Author: Databean

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

@@ -22,6 +22,7 @@
 #include <android-base/strings.h>
 #include <gflags/gflags.h>
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 
 #include "cuttlefish/common/libs/fs/shared_buf.h"
 #include "cuttlefish/common/libs/fs/shared_fd.h"
@@ -225,7 +226,7 @@ Result<std::set<std::string>> PreservingOnResume(
   preserving.insert("pflash.img");
   preserving.insert("uboot_env.img");
   preserving.insert(FactoryResetProtectedImage::FileName());
-  preserving.insert(MiscImage::Name());
+  preserving.insert(absl::StrCat(MiscImage::kName, ".img"));
   preserving.insert("vmmtruststore.img");
   preserving.insert(MetadataImage::Name());
   preserving.insert("persistent_vbmeta.img");
@@ -338,13 +339,13 @@ Result<const CuttlefishConfig*> InitFilesystemAndCreateConfig(
     // then don't preserve any files and delete everything.
     for (const auto& instance : config.Instances()) {
       Result<MetadataImage> metadata = MetadataImage::Reuse(instance);
-      Result<MiscImage> misc = MiscImage::Reuse(instance);
+      MiscImage misc(instance);
       Result<std::optional<ChromeOsStateImage>> chrome_os_state =
           CF_EXPECT(ChromeOsStateImage::Reuse(instance));
-      if (chrome_os_state.ok() && metadata.ok() && misc.ok()) {
+      if (chrome_os_state.ok() && metadata.ok()) {
         Result<DiskBuilder> os_builder =
             OsCompositeDiskBuilder(config, instance, *chrome_os_state,
-                                   *metadata, *misc, system_image_dir);
+                                   *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

@@ -159,7 +159,9 @@ Result<void> CreateDynamicDiskFiles(
     }
 
     MetadataImage metadata = CF_EXPECT(MetadataImage::ReuseOrCreate(instance));
-    MiscImage misc = CF_EXPECT(MiscImage::ReuseOrCreate(instance));
+
+    MiscImage misc(instance);
+    CF_EXPECT(misc.Generate());
 
     DiskBuilder os_disk_builder = CF_EXPECT(OsCompositeDiskBuilder(
         config, instance, chrome_os_state, metadata, misc, system_image_dirs));

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

@@ -261,9 +261,9 @@ cf_cc_library(
     hdrs = ["misc_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",
         "//libbase",
     ],

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

@@ -91,6 +91,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.misc, CF_EXPECT(misc_image.Path())},
       {kPartitions.super, instance.new_super_image()},
       {kPartitions.userdata, instance.new_data_image()},
       {kPartitions.vbmeta, instance.new_vbmeta_image()},
@@ -139,7 +140,6 @@ Result<std::vector<ImagePartition>> AndroidCompositeDiskConfig(
     }
   }
 
-  partitions.push_back(misc_image.Partition());
   partitions.push_back(metadata_image.Partition());
 
   std::optional<ImagePartition> hibernation_partition =

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

@@ -21,45 +21,30 @@
 #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 {
 
-Result<MiscImage> MiscImage::Reuse(
-    const CuttlefishConfig::InstanceSpecific& instance) {
-  std::string path = instance.PerInstancePath(Name());
-  CF_EXPECT(FileHasContent(path));
-
-  LOG(DEBUG) << "misc partition image already exists";
-
-  return MiscImage(path);
+MiscImage::MiscImage(const CuttlefishConfig::InstanceSpecific& instance) {
+  path_ = instance.PerInstancePath(kName);
+  ready_ = FileHasContent(path_);
 }
 
-Result<MiscImage> MiscImage::ReuseOrCreate(
-    const CuttlefishConfig::InstanceSpecific& instance) {
-  std::string path = instance.PerInstancePath(Name());
+std::string MiscImage::Name() const { return std::string(kName); }
 
-  Result<MiscImage> reuse_res = Reuse(instance);
-  if (reuse_res.ok()) {
-    return reuse_res.value();
+Result<std::string> MiscImage::Generate() {
+  if (!ready_) {
+    CF_EXPECT(CreateBlankImage(path_, 1 /* mb */, "none"),
+              "Failed to create misc image");
+    ready_ = true;
   }
-
-  LOG(DEBUG) << "misc partition image: creating empty at '" << path << "'";
-  CF_EXPECT(CreateBlankImage(path, 1 /* mb */, "none"),
-            "Failed to create misc image");
-  return MiscImage(path);
+  return path_;
 }
 
-MiscImage::MiscImage(std::string path) : path_(std::move(path)) {}
-
-std::string MiscImage::Name() { return "misc.img"; }
-
-ImagePartition MiscImage::Partition() const {
-  return ImagePartition{
-      .label = "misc",
-      .image_file_path = path_,
-  };
+Result<std::string> MiscImage::Path() const {
+  CF_EXPECT(!!ready_);
+  return path_;
 }
 
+
 }  // namespace cuttlefish

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

@@ -16,25 +16,28 @@
 
 #pragma once
 
+#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 MiscImage {
+class MiscImage : public ImageFile {
  public:
-  static Result<MiscImage> Reuse(const CuttlefishConfig::InstanceSpecific&);
-  static Result<MiscImage> ReuseOrCreate(
-      const CuttlefishConfig::InstanceSpecific&);
+  static constexpr std::string_view kName = "misc";
 
-  static std::string Name();
+  MiscImage(const CuttlefishConfig::InstanceSpecific&);
 
-  ImagePartition Partition() const;
+  std::string Name() const override;
+
+  Result<std::string> Generate() override;
+
+  Result<std::string> Path() const override;
 
  private:
   MiscImage(std::string);
 
+  bool ready_;
   std::string path_;
 };