Rename *MiscInfo methods to refer to behavior rather than the format.

Bug: b/438847412

Author: Databean

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value.cc

@@ -29,8 +29,9 @@
 
 namespace cuttlefish {
 
-Result<MiscInfo> ParseMiscInfo(const std::string& contents) {
-  MiscInfo misc_info;
+Result<std::map<std::string, std::string>> ParseKeyEqualsValue(
+    const std::string& contents) {
+  std::map<std::string, std::string> key_equals_value;
   for (std::string_view line : absl::StrSplit(contents, '\n')) {
     std::pair<std::string_view, std::string_view> key_value =
         absl::StrSplit(line, absl::MaxSplits('=', 1));
@@ -42,29 +43,32 @@ Result<MiscInfo> ParseMiscInfo(const std::string& contents) {
 
     key_value.second = absl::StripAsciiWhitespace(key_value.second);
 
-    auto [it, inserted] = misc_info.emplace(key_value);
+    auto [it, inserted] = key_equals_value.emplace(key_value);
     CF_EXPECTF(inserted || it->second == key_value.second,
                "Duplicate key with different value. key:\"{}\", previous "
                "value:\"{}\", this value:\"{}\"",
                key_value.first, it->second, key_value.second);
   }
-  return misc_info;
+  return key_equals_value;
 }
 
-std::string SerializeMiscInfo(const MiscInfo& misc_info) {
+std::string SerializeKeyEqualsValue(
+    const std::map<std::string, std::string>& key_equals_value) {
   std::stringstream file_content;
-  for (const auto& [key, value] : misc_info) {
+  for (const auto& [key, value] : key_equals_value) {
     file_content << key << "=" << value << "\n";
   }
   return file_content.str();
 }
 
-Result<void> WriteMiscInfo(const MiscInfo& misc_info, const std::string& path) {
+Result<void> WriteKeyEqualsValue(
+    const std::map<std::string, std::string>& key_equals_value,
+    const std::string& path) {
   SharedFD output = SharedFD::Creat(path, 0644);
   CF_EXPECTF(output->IsOpen(), "Failed to open '{}': '{}'", path,
              output->StrError());
 
-  std::string serialized = SerializeMiscInfo(misc_info);
+  std::string serialized = SerializeKeyEqualsValue(key_equals_value);
 
   CF_EXPECTF(WriteAll(output, serialized) == serialized.size(),
              "Failed to write to '{}': '{}'", path, output->StrError());

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value.h

@@ -22,12 +22,10 @@
 
 namespace cuttlefish {
 
-// TODO(chadreynolds): rename MiscInfo to more generic KeyValueFile since this
-// logic is processing multiple filetypes now
-using MiscInfo = std::map<std::string, std::string>;
-
-Result<MiscInfo> ParseMiscInfo(const std::string& misc_info_contents);
-std::string SerializeMiscInfo(const MiscInfo&);
-Result<void> WriteMiscInfo(const MiscInfo& misc_info, const std::string& path);
+Result<std::map<std::string, std::string>> ParseKeyEqualsValue(
+    const std::string&);
+std::string SerializeKeyEqualsValue(const std::map<std::string, std::string>&);
+Result<void> WriteKeyEqualsValue(const std::map<std::string, std::string>&,
+                                 const std::string& path);
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value_test.cc

@@ -29,42 +29,45 @@ namespace {
 TEST(KeyEqualsValue, Deserialize) {
   std::string serialized = "key1 = value1 \n key2 = value2";
 
-  MiscInfo expected = {{"key1", "value1"}, {"key2", "value2"}};
-  ASSERT_THAT(ParseMiscInfo(serialized), IsOkAndValue(expected));
+  std::map<std::string, std::string> expected = {{"key1", "value1"},
+                                                 {"key2", "value2"}};
+  ASSERT_THAT(ParseKeyEqualsValue(serialized), IsOkAndValue(expected));
 }
 
 TEST(KeyEqualsValue, Serialize) {
-  MiscInfo misc_info = {{"key1", "value1"}, {"key2", "value2"}};
+  std::map<std::string, std::string> misc_info = {{"key1", "value1"},
+                                                  {"key2", "value2"}};
 
-  EXPECT_EQ(SerializeMiscInfo(misc_info), "key1=value1\nkey2=value2\n");
+  EXPECT_EQ(SerializeKeyEqualsValue(misc_info), "key1=value1\nkey2=value2\n");
 }
 
 TEST(KeyEqualsValue, SerializeDeserialize) {
-  MiscInfo misc_info = {{"key1", "value1"}, {"key2", "value2"}};
+  std::map<std::string, std::string> misc_info = {{"key1", "value1"},
+                                                  {"key2", "value2"}};
 
-  std::string serialized = SerializeMiscInfo(misc_info);
+  std::string serialized = SerializeKeyEqualsValue(misc_info);
 
-  ASSERT_THAT(ParseMiscInfo(serialized), IsOkAndValue(misc_info));
+  ASSERT_THAT(ParseKeyEqualsValue(serialized), IsOkAndValue(misc_info));
 }
 
 TEST(KeyEqualsValue, DeserializeDuplicateKeySameValue) {
   std::string serialized = "key1=value1\nkey1=value1";
 
-  MiscInfo expected = {{"key1", "value1"}};
-  ASSERT_THAT(ParseMiscInfo(serialized), IsOkAndValue(expected));
+  std::map<std::string, std::string> expected = {{"key1", "value1"}};
+  ASSERT_THAT(ParseKeyEqualsValue(serialized), IsOkAndValue(expected));
 }
 
 TEST(KeyEqualsValue, DeserializeDuplicateKeyDifferentValue) {
   std::string serialized = "key1=value1\nkey1=value2";
 
-  Result<MiscInfo> parsed = ParseMiscInfo(serialized);
-  ASSERT_THAT(parsed, IsError());
+  ASSERT_THAT(ParseKeyEqualsValue(serialized), IsError());
 }
 
 TEST(KeyEqualsValue, EmptyLines) {
   std::string serialized = "\n\n\n\n\n\n";
 
-  ASSERT_THAT(ParseMiscInfo(serialized), IsOkAndValue(MiscInfo()));
+  ASSERT_THAT(ParseKeyEqualsValue(serialized),
+              IsOkAndValue(std::map<std::string, std::string>()));
 }
 
 }  // namespace

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

@@ -380,7 +380,6 @@ cf_cc_library(
     hdrs = ["misc_info.h"],
     deps = [
         "//cuttlefish/common/libs/fs",
-        "//cuttlefish/common/libs/key_equals_value",
         "//cuttlefish/common/libs/utils:contains",
         "//cuttlefish/common/libs/utils:result",
         "//cuttlefish/host/libs/avb",

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

@@ -46,7 +46,7 @@ Result<std::string> GetAndroidInfoConfig(
   CF_EXPECT(FileExists(android_info_file_path));
 
   std::string android_info_contents = ReadFile(android_info_file_path);
-  auto android_info_map = CF_EXPECT(ParseMiscInfo(android_info_contents));
+  auto android_info_map = CF_EXPECT(ParseKeyEqualsValue(android_info_contents));
   CF_EXPECT(android_info_map.find(key) != android_info_map.end());
   return android_info_map[key];
 }

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

@@ -28,7 +28,6 @@
 #include <android-base/strings.h>
 #include <fmt/format.h>
 
-#include "cuttlefish/common/libs/key_equals_value/key_equals_value.h"
 #include "cuttlefish/common/libs/utils/contains.h"
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/host/libs/avb/avb.h"

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

@@ -15,15 +15,17 @@
 
 #pragma once
 
+#include <map>
 #include <set>
 #include <string>
 
-#include "cuttlefish/common/libs/key_equals_value/key_equals_value.h"
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/host/libs/avb/avb.h"
 
 namespace cuttlefish {
 
+using MiscInfo = std::map<std::string, std::string>;
+
 struct VbmetaArgs {
   std::string algorithm;
   std::string key_path;

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

@@ -137,9 +137,9 @@ Result<MiscInfo> CombineDynamicPartitionsInfo(
              "System target files zip does not contain {}",
              kDynamicPartitionsPath);
 
-  const MiscInfo vendor_dp_info = CF_EXPECT(ParseMiscInfo(
+  const MiscInfo vendor_dp_info = CF_EXPECT(ParseKeyEqualsValue(
       ExtractArchiveToMemory(target_files.vendor_zip, kDynamicPartitionsPath)));
-  const MiscInfo system_dp_info = CF_EXPECT(ParseMiscInfo(
+  const MiscInfo system_dp_info = CF_EXPECT(ParseKeyEqualsValue(
       ExtractArchiveToMemory(target_files.system_zip, kDynamicPartitionsPath)));
 
   return CF_EXPECT(GetCombinedDynamicPartitions(vendor_dp_info, system_dp_info,
@@ -155,17 +155,17 @@ Result<MiscInfo> CombineMiscInfo(
   CF_EXPECTF(Contains(target_files.system_contents, kMiscInfoPath),
              "System target files zip does not contain {}", kMiscInfoPath);
 
-  const MiscInfo vendor_misc = CF_EXPECT(ParseMiscInfo(
+  const MiscInfo vendor_misc = CF_EXPECT(ParseKeyEqualsValue(
       ExtractArchiveToMemory(target_files.vendor_zip, kMiscInfoPath)));
-  const MiscInfo system_misc = CF_EXPECT(ParseMiscInfo(
+  const MiscInfo system_misc = CF_EXPECT(ParseKeyEqualsValue(
       ExtractArchiveToMemory(target_files.system_zip, kMiscInfoPath)));
 
   const auto combined_dp_info =
       CF_EXPECT(CombineDynamicPartitionsInfo(target_files, extracted_images));
   const auto output_misc = CF_EXPECT(MergeMiscInfos(
       vendor_misc, system_misc, combined_dp_info, system_partitions));
 
-  CF_EXPECT(WriteMiscInfo(output_misc, misc_output_path));
+  CF_EXPECT(WriteKeyEqualsValue(output_misc, misc_output_path));
   return std::move(output_misc);
 }