Reduce usage of c_str() in assemble_cvd

Either removes it entirely when the callee doesn't need a `const char*`,
or moves the `c_str()` call closer to the libc function that requires
it.

Bug: b/470444522

Author: Databean

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

@@ -104,7 +104,7 @@ Result<void> CreateLegacySymlinks(
                              "crosvm_openwrt.log",
                              "crosvm_openwrt_boot.log"};
   for (const auto& log_file : log_files) {
-    auto symlink_location = instance.PerInstancePath(log_file.c_str());
+    auto symlink_location = instance.PerInstancePath(log_file);
     auto log_target = "logs/" + log_file;  // Relative path
     if (FileExists(symlink_location, /* follow_symlinks */ false)) {
       CF_EXPECT(RemoveFile(symlink_location),

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

@@ -120,7 +120,7 @@ size_t WriteEnvironment(const CuttlefishConfig::InstanceSpecific& instance,
   }
 
   std::string env_str = env.str();
-  std::ofstream file_out(env_path.c_str(), std::ios::binary);
+  std::ofstream file_out(env_path, std::ios::binary);
   file_out << env_str;
 
   if (!file_out.good()) {

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

@@ -68,7 +68,7 @@ Result<void> CleanPriorFiles(const std::string& path,
       continue;
     }
     std::string entity_path = path + "/" + entity_name;
-    CF_EXPECT(CleanPriorFiles(entity_path.c_str(), preserving),
+    CF_EXPECT(CleanPriorFiles(entity_path, preserving),
               "CleanPriorFiles for \""
                   << path << "\" failed on recursing into \"" << entity_path
                   << "\"");

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

@@ -217,7 +217,7 @@ Result<void> DiskImageFlagsVectorization(
       const std::string new_boot_image_path =
           const_instance.PerInstancePath("boot_repacked.img");
       // change the new flag value to corresponding instance
-      instance.set_new_boot_image(new_boot_image_path.c_str());
+      instance.set_new_boot_image(new_boot_image_path);
     }
 
     instance.set_data_image(system_image_dir.ForIndex(instance_index) +
@@ -233,7 +233,7 @@ Result<void> DiskImageFlagsVectorization(
       // Repack the vendor boot images if kernels and/or ramdisks are passed in.
       if (has_initramfs) {
         // change the new flag value to corresponding instance
-        instance.set_new_vendor_boot_image(new_vendor_boot_image_path.c_str());
+        instance.set_new_vendor_boot_image(new_vendor_boot_image_path);
       }
     }
 

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

@@ -221,13 +221,14 @@ Result<std::vector<int>> GetFlagIntValueForInstances(
         if (instance_index < default_value_vec.size()) {
           default_value = default_value_vec[instance_index];
         }
-        CF_EXPECT(android::base::ParseInt(default_value,
-        &value_vec[instance_index]),
-        "Failed to parse value \"" << default_value << "\" for " << flag_name);
+        CF_EXPECTF(
+            android::base::ParseInt(default_value, &value_vec[instance_index]),
+            "Failed to parse value '{}' for '{}'", default_value, flag_name);
       } else {
-        CF_EXPECT(android::base::ParseInt(flag_vec[instance_index].c_str(),
-        &value_vec[instance_index]),
-        "Failed to parse value \"" << flag_vec[instance_index] << "\" for " << flag_name);
+        CF_EXPECTF(android::base::ParseInt(flag_vec[instance_index],
+                                           &value_vec[instance_index]),
+                   "Failed to parse value '{}' for '{}'",
+                   flag_vec[instance_index], flag_name);
       }
     }
   }

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

@@ -77,7 +77,7 @@ Result<Json::Value> McuConfigPathFlag::JsonForIndex(
   CF_EXPECT(FileExists(mcu_cfg_path), "MCU config file does not exist");
 
   std::string content;
-  CF_EXPECTF(ReadFileToString(mcu_cfg_path.c_str(), &content,
+  CF_EXPECTF(ReadFileToString(mcu_cfg_path, &content,
                               /* follow_symlinks */ true),
              "Failed to read mcu config file '{}'", mcu_cfg_path);
 

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

@@ -209,7 +209,7 @@ Result<void> ParseGuestConfigTxt(const std::string& guest_config_path,
   if (res_output_audio_streams_count.ok()) {
     std::string output_audio_streams_count_str =
         res_output_audio_streams_count.value();
-    CF_EXPECT(android::base::ParseInt(output_audio_streams_count_str.c_str(),
+    CF_EXPECT(android::base::ParseInt(output_audio_streams_count_str,
                                       &guest_config.output_audio_streams_count),
               "Failed to parse value \"" << output_audio_streams_count_str
                                          << "\" for output audio stream count");
@@ -229,7 +229,7 @@ Result<void> ParseGuestConfigTxt(const std::string& guest_config_path,
       GetAndroidInfoConfig(guest_config_path, "blank_data_image_mb");
   if (res_blank_data_image_mb.ok()) {
     std::string res_blank_data_image_mb_str = res_blank_data_image_mb.value();
-    CF_EXPECT(android::base::ParseInt(res_blank_data_image_mb_str.c_str(),
+    CF_EXPECT(android::base::ParseInt(res_blank_data_image_mb_str,
                                       &guest_config.blank_data_image_mb),
               "Failed to parse value \"" << res_blank_data_image_mb_str
                                          << "\" for blank data image size");

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

@@ -56,9 +56,9 @@ constexpr size_t RoundUp(size_t a, size_t divisor) {
 }
 
 template <typename Container>
-bool WriteLinesToFile(const Container& lines, const char* path) {
+bool WriteLinesToFile(const Container& lines, const std::string& path) {
   android::base::unique_fd fd(
-      open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640));
+      open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640));
   if (!fd.ok()) {
     PLOG(ERROR) << "Failed to open " << path;
     return false;
@@ -78,10 +78,11 @@ bool WriteLinesToFile(const Container& lines, const char* path) {
 }
 
 // Generate a filesystem_config.txt for all files in |fs_root|
-Result<bool> WriteFsConfig(const char* output_path, const std::string& fs_root,
+Result<bool> WriteFsConfig(const std::string& output_path,
+                           const std::string& fs_root,
                            const std::string& mount_point) {
-  android::base::unique_fd fd(
-      open(output_path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644));
+  android::base::unique_fd fd(open(
+      output_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644));
   if (!fd.ok()) {
     PLOG(ERROR) << "Failed to open " << output_path;
     return false;
@@ -347,15 +348,15 @@ Result<void> BuildDlkmImage(const std::string& src_dir, const bool is_erofs,
 
   const std::string mount_point = "/" + partition_name;
   const std::string fs_config = output_image + ".fs_config";
-  CF_EXPECT(WriteFsConfig(fs_config.c_str(), src_dir, mount_point));
+  CF_EXPECT(WriteFsConfig(fs_config, src_dir, mount_point));
 
   const std::string file_contexts_bin = output_image + ".file_contexts";
   if (partition_name == "system_dlkm") {
-    CF_EXPECT(GenerateFileContexts(file_contexts_bin.c_str(), mount_point,
+    CF_EXPECT(GenerateFileContexts(file_contexts_bin, mount_point,
                                    "system_dlkm_file"));
   } else {
-    CF_EXPECT(GenerateFileContexts(file_contexts_bin.c_str(), mount_point,
-                                   "vendor_file"));
+    CF_EXPECT(
+        GenerateFileContexts(file_contexts_bin, mount_point, "vendor_file"));
   }
 
   // We are using directory size as an estimate of final image size. To avoid
@@ -513,19 +514,19 @@ Result<void> SplitRamdiskModules(const std::string& ramdisk_path,
   // Write updated modules.dep and modules.load files
   CF_EXPECT(WriteDepsToFile(FilterDependencies(deps, ramdisk_modules),
                             module_base_dir + "/modules.dep"));
-  CF_EXPECT(WriteLinesToFile(ramdisk_modules, module_load_file.c_str()));
+  CF_EXPECT(WriteLinesToFile(ramdisk_modules, module_load_file));
 
   CF_EXPECT(WriteDepsToFile(
       UpdateGKIModulePaths(FilterOutDependencies(deps, ramdisk_modules),
                            system_dlkm_modules),
       vendor_modules_dir + "/modules.dep"));
   CF_EXPECT(WriteLinesToFile(vendor_dlkm_modules,
-                             (vendor_modules_dir + "/modules.load").c_str()));
+                             vendor_modules_dir + "/modules.load"));
 
   CF_EXPECT(WriteDepsToFile(FilterDependencies(deps, system_dlkm_modules),
                             system_modules_dir + "/modules.dep"));
   CF_EXPECT(WriteLinesToFile(system_dlkm_modules,
-                             (system_modules_dir + "/modules.load").c_str()));
+                             system_modules_dir + "/modules.load"));
   PackRamdisk(ramdisk_stage_dir, ramdisk_path);
   return {};
 }