Merge "Remove no-op config." into main
diff --git a/tools/aconfig/aconfig_storage_read_api/Android.bp b/tools/aconfig/aconfig_storage_read_api/Android.bp
index db36294..d1c282d 100644
--- a/tools/aconfig/aconfig_storage_read_api/Android.bp
+++ b/tools/aconfig/aconfig_storage_read_api/Android.bp
@@ -9,8 +9,6 @@
     srcs: ["src/lib.rs"],
     rustlibs: [
         "libanyhow",
-        "libonce_cell",
-        "libtempfile",
         "libmemmap2",
         "libcxx",
         "libthiserror",
@@ -34,6 +32,9 @@
     name: "aconfig_storage_read_api.test",
     test_suites: ["general-tests"],
     defaults: ["aconfig_storage_read_api.defaults"],
+    rustlibs: [
+        "librand",
+    ],
     data: [
         "tests/package.map",
         "tests/flag.map",
@@ -89,10 +90,6 @@
     host_supported: true,
     vendor_available: true,
     product_available: true,
-    static_libs: [
-        "libaconfig_storage_protos_cc",
-        "libprotobuf-cpp-lite",
-    ],
     shared_libs: [
         "liblog",
         "libbase",
diff --git a/tools/aconfig/aconfig_storage_read_api/Cargo.toml b/tools/aconfig/aconfig_storage_read_api/Cargo.toml
index 30a4298..2b27e4b 100644
--- a/tools/aconfig/aconfig_storage_read_api/Cargo.toml
+++ b/tools/aconfig/aconfig_storage_read_api/Cargo.toml
@@ -8,10 +8,9 @@
 cargo = []
 
 [dependencies]
+rand = "0.8.5"
 anyhow = "1.0.69"
 memmap2 = "0.8.0"
-once_cell = "1.19.0"
-tempfile = "3.9.0"
 cxx = "1.0"
 thiserror = "1.0.56"
 aconfig_storage_file = { path = "../aconfig_storage_file" }
diff --git a/tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp b/tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp
index 0aa936a..50076aa 100644
--- a/tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp
+++ b/tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp
@@ -1,6 +1,5 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <protos/aconfig_storage_metadata.pb.h>
 
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ -10,74 +9,45 @@
 #include "aconfig_storage/lib.rs.h"
 #include "aconfig_storage/aconfig_storage_read_api.hpp"
 
-using storage_records_pb = android::aconfig_storage_metadata::storage_files;
-using storage_record_pb = android::aconfig_storage_metadata::storage_file_info;
 using namespace android::base;
 
 namespace aconfig_storage {
 
 /// Storage location pb file
-static constexpr char kAvailableStorageRecordsPb[] =
-    "/metadata/aconfig/boot/available_storage_file_records.pb";
+static constexpr char kStorageDir[] = "/metadata/aconfig";
 
 /// destructor
 MappedStorageFile::~MappedStorageFile() {
   munmap(file_ptr, file_size);
 }
 
-/// Read aconfig storage records pb file
-static Result<storage_records_pb> read_storage_records_pb(std::string const& pb_file) {
-  auto records = storage_records_pb();
-  auto content = std::string();
-  if (!ReadFileToString(pb_file, &content)) {
-    return ErrnoError() << "ReadFileToString failed";
-  }
-
-  if (!records.ParseFromString(content)) {
-    return ErrnoError() << "Unable to parse persistent storage records protobuf";
-  }
-  return records;
-}
-
 /// Get storage file path
 static Result<std::string> find_storage_file(
-    std::string const& pb_file,
+    std::string const& storage_dir,
     std::string const& container,
     StorageFileType file_type) {
-  auto records_pb = read_storage_records_pb(pb_file);
-  if (!records_pb.ok()) {
-    return Error() << "Unable to read storage records from " << pb_file
-                   << " : " << records_pb.error();
+  switch(file_type) {
+    case StorageFileType::package_map:
+      return storage_dir + "/maps/" + container + ".package.map";
+    case StorageFileType::flag_map:
+      return storage_dir + "/maps/" + container + ".flag.map";
+    case StorageFileType::flag_val:
+      return storage_dir + "/boot/" + container + ".val";
+    case StorageFileType::flag_info:
+      return storage_dir + "/boot/" + container + ".info";
+    default:
+      return Error() << "Invalid file type " << file_type;
   }
-
-  for (auto& entry : records_pb->files()) {
-    if (entry.container() == container) {
-      switch(file_type) {
-        case StorageFileType::package_map:
-          return entry.package_map();
-        case StorageFileType::flag_map:
-          return entry.flag_map();
-        case StorageFileType::flag_val:
-          return entry.flag_val();
-        case StorageFileType::flag_info:
-          return entry.flag_info();
-        default:
-          return Error() << "Invalid file type " << file_type;
-      }
-    }
-  }
-
-  return Error() << "Unable to find storage files for container " << container;;
 }
 
 namespace private_internal_api {
 
 /// Get mapped file implementation.
 Result<MappedStorageFile*> get_mapped_file_impl(
-    std::string const& pb_file,
+    std::string const& storage_dir,
     std::string const& container,
     StorageFileType file_type) {
-  auto file_result = find_storage_file(pb_file, container, file_type);
+  auto file_result = find_storage_file(storage_dir, container, file_type);
   if (!file_result.ok()) {
     return Error() << file_result.error();
   }
@@ -129,7 +99,7 @@
     std::string const& container,
     StorageFileType file_type) {
   return private_internal_api::get_mapped_file_impl(
-      kAvailableStorageRecordsPb, container, file_type);
+      kStorageDir, container, file_type);
 }
 
 /// Get storage file version number
diff --git a/tools/aconfig/aconfig_storage_read_api/src/lib.rs b/tools/aconfig/aconfig_storage_read_api/src/lib.rs
index e419206..61f9e96 100644
--- a/tools/aconfig/aconfig_storage_read_api/src/lib.rs
+++ b/tools/aconfig/aconfig_storage_read_api/src/lib.rs
@@ -42,9 +42,6 @@
 pub mod mapped_file;
 pub mod package_table_query;
 
-#[cfg(test)]
-mod test_utils;
-
 pub use aconfig_storage_file::{AconfigStorageError, FlagValueType, StorageFileType};
 pub use flag_table_query::FlagReadContext;
 pub use package_table_query::PackageReadContext;
@@ -60,8 +57,8 @@
 use std::fs::File;
 use std::io::Read;
 
-/// Storage file location pb file
-pub const STORAGE_LOCATION_FILE: &str = "/metadata/aconfig/boot/available_storage_file_records.pb";
+/// Storage file location
+pub const STORAGE_LOCATION: &str = "/metadata/aconfig";
 
 /// Get read only mapped storage files.
 ///
@@ -78,7 +75,7 @@
     container: &str,
     file_type: StorageFileType,
 ) -> Result<Mmap, AconfigStorageError> {
-    unsafe { crate::mapped_file::get_mapped_file(STORAGE_LOCATION_FILE, container, file_type) }
+    unsafe { crate::mapped_file::get_mapped_file(STORAGE_LOCATION, container, file_type) }
 }
 
 /// Get package read context for a specific package.
@@ -394,45 +391,41 @@
 mod tests {
     use super::*;
     use crate::mapped_file::get_mapped_file;
-    use crate::test_utils::copy_to_temp_file;
-    use aconfig_storage_file::protos::storage_record_pb::write_proto_to_temp_file;
     use aconfig_storage_file::{FlagInfoBit, StoredFlagType};
-    use tempfile::NamedTempFile;
+    use rand::Rng;
+    use std::fs;
 
-    fn create_test_storage_files() -> [NamedTempFile; 5] {
-        let package_map = copy_to_temp_file("./tests/package.map").unwrap();
-        let flag_map = copy_to_temp_file("./tests/flag.map").unwrap();
-        let flag_val = copy_to_temp_file("./tests/flag.val").unwrap();
-        let flag_info = copy_to_temp_file("./tests/flag.info").unwrap();
+    fn create_test_storage_files() -> String {
+        let mut rng = rand::thread_rng();
+        let number: u32 = rng.gen();
+        let storage_dir = String::from("/tmp/") + &number.to_string();
+        if std::fs::metadata(&storage_dir).is_ok() {
+            fs::remove_dir_all(&storage_dir).unwrap();
+        }
+        let maps_dir = storage_dir.clone() + "/maps";
+        let boot_dir = storage_dir.clone() + "/boot";
+        fs::create_dir(&storage_dir).unwrap();
+        fs::create_dir(&maps_dir).unwrap();
+        fs::create_dir(&boot_dir).unwrap();
 
-        let text_proto = format!(
-            r#"
-files {{
-    version: 0
-    container: "mockup"
-    package_map: "{}"
-    flag_map: "{}"
-    flag_val: "{}"
-    flag_info: "{}"
-    timestamp: 12345
-}}
-"#,
-            package_map.path().display(),
-            flag_map.path().display(),
-            flag_val.path().display(),
-            flag_info.path().display()
-        );
-        let pb_file = write_proto_to_temp_file(&text_proto).unwrap();
-        [package_map, flag_map, flag_val, flag_info, pb_file]
+        let package_map = storage_dir.clone() + "/maps/mockup.package.map";
+        let flag_map = storage_dir.clone() + "/maps/mockup.flag.map";
+        let flag_val = storage_dir.clone() + "/boot/mockup.val";
+        let flag_info = storage_dir.clone() + "/boot/mockup.info";
+        fs::copy("./tests/package.map", &package_map).unwrap();
+        fs::copy("./tests/flag.map", &flag_map).unwrap();
+        fs::copy("./tests/flag.val", &flag_val).unwrap();
+        fs::copy("./tests/flag.info", &flag_info).unwrap();
+
+        return storage_dir;
     }
 
     #[test]
     // this test point locks down flag package read context query
     fn test_package_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         let package_mapped_file = unsafe {
-            get_mapped_file(&pb_file_path, "mockup", StorageFileType::PackageMap).unwrap()
+            get_mapped_file(&storage_dir, "mockup", StorageFileType::PackageMap).unwrap()
         };
 
         let package_context =
@@ -460,10 +453,9 @@
     #[test]
     // this test point locks down flag read context query
     fn test_flag_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         let flag_mapped_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagMap).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagMap).unwrap() };
 
         let baseline = vec![
             (0, "enabled_ro", StoredFlagType::ReadOnlyBoolean, 1u16),
@@ -486,10 +478,9 @@
     #[test]
     // this test point locks down flag value query
     fn test_flag_value_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         let flag_value_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagVal).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagVal).unwrap() };
         let baseline: Vec<bool> = vec![false, true, true, false, true, true, true, true];
         for (offset, expected_value) in baseline.into_iter().enumerate() {
             let flag_value = get_boolean_flag_value(&flag_value_file, offset as u32).unwrap();
@@ -500,10 +491,9 @@
     #[test]
     // this test point locks donw flag info query
     fn test_flag_info_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         let flag_info_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagInfo).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagInfo).unwrap() };
         let is_rw: Vec<bool> = vec![true, false, true, true, false, false, false, true];
         for (offset, expected_value) in is_rw.into_iter().enumerate() {
             let attribute =
diff --git a/tools/aconfig/aconfig_storage_read_api/src/mapped_file.rs b/tools/aconfig/aconfig_storage_read_api/src/mapped_file.rs
index 3786443..5a16645 100644
--- a/tools/aconfig/aconfig_storage_read_api/src/mapped_file.rs
+++ b/tools/aconfig/aconfig_storage_read_api/src/mapped_file.rs
@@ -14,47 +14,12 @@
  * limitations under the License.
  */
 
-use std::fs::File;
-use std::io::{BufReader, Read};
-
 use anyhow::anyhow;
 use memmap2::Mmap;
+use std::fs::File;
 
-use crate::AconfigStorageError::{
-    self, FileReadFail, MapFileFail, ProtobufParseFail, StorageFileNotFound,
-};
+use crate::AconfigStorageError::{self, FileReadFail, MapFileFail, StorageFileNotFound};
 use crate::StorageFileType;
-use aconfig_storage_file::protos::{
-    storage_record_pb::try_from_binary_proto, ProtoStorageFileInfo, ProtoStorageFiles,
-};
-
-/// Find where storage files are stored for a particular container
-pub fn find_container_storage_location(
-    location_pb_file: &str,
-    container: &str,
-) -> Result<ProtoStorageFileInfo, AconfigStorageError> {
-    let file = File::open(location_pb_file).map_err(|errmsg| {
-        FileReadFail(anyhow!("Failed to open file {}: {}", location_pb_file, errmsg))
-    })?;
-    let mut reader = BufReader::new(file);
-    let mut bytes = Vec::new();
-    reader.read_to_end(&mut bytes).map_err(|errmsg| {
-        FileReadFail(anyhow!("Failed to read file {}: {}", location_pb_file, errmsg))
-    })?;
-    let storage_locations: ProtoStorageFiles = try_from_binary_proto(&bytes).map_err(|errmsg| {
-        ProtobufParseFail(anyhow!(
-            "Failed to parse storage location pb file {}: {}",
-            location_pb_file,
-            errmsg
-        ))
-    })?;
-    for location_info in storage_locations.files.iter() {
-        if location_info.container() == container {
-            return Ok(location_info.clone());
-        }
-    }
-    Err(StorageFileNotFound(anyhow!("Storage file does not exist for {}", container)))
-}
 
 /// Get the read only memory mapping of a storage file
 ///
@@ -82,123 +47,70 @@
 /// file after being mapped. Ensure no writes can happen to this file while this
 /// mapping stays alive.
 pub unsafe fn get_mapped_file(
-    location_pb_file: &str,
+    storage_dir: &str,
     container: &str,
     file_type: StorageFileType,
 ) -> Result<Mmap, AconfigStorageError> {
-    let files_location = find_container_storage_location(location_pb_file, container)?;
-    match file_type {
-        StorageFileType::PackageMap => unsafe { map_file(files_location.package_map()) },
-        StorageFileType::FlagMap => unsafe { map_file(files_location.flag_map()) },
-        StorageFileType::FlagVal => unsafe { map_file(files_location.flag_val()) },
-        StorageFileType::FlagInfo => unsafe { map_file(files_location.flag_info()) },
+    let storage_file = match file_type {
+        StorageFileType::PackageMap => {
+            String::from(storage_dir) + "/maps/" + container + ".package.map"
+        }
+        StorageFileType::FlagMap => String::from(storage_dir) + "/maps/" + container + ".flag.map",
+        StorageFileType::FlagVal => String::from(storage_dir) + "/boot/" + container + ".val",
+        StorageFileType::FlagInfo => String::from(storage_dir) + "/boot/" + container + ".info",
+    };
+    if std::fs::metadata(&storage_file).is_err() {
+        return Err(StorageFileNotFound(anyhow!("storage file {} does not exist", storage_file)));
     }
+    unsafe { map_file(&storage_file) }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::copy_to_temp_file;
-    use aconfig_storage_file::protos::storage_record_pb::write_proto_to_temp_file;
-    use tempfile::NamedTempFile;
+    use rand::Rng;
+    use std::fs;
+    use std::io::Read;
 
-    #[test]
-    fn test_find_storage_file_location() {
-        let text_proto = r#"
-files {
-    version: 0
-    container: "system"
-    package_map: "/system/etc/package.map"
-    flag_map: "/system/etc/flag.map"
-    flag_val: "/metadata/aconfig/system.val"
-    timestamp: 12345
-}
-files {
-    version: 1
-    container: "product"
-    package_map: "/product/etc/package.map"
-    flag_map: "/product/etc/flag.map"
-    flag_val: "/metadata/aconfig/product.val"
-    timestamp: 54321
-}
-"#;
-        let file = write_proto_to_temp_file(&text_proto).unwrap();
-        let file_full_path = file.path().display().to_string();
-        let file_info = find_container_storage_location(&file_full_path, "system").unwrap();
-        assert_eq!(file_info.version(), 0);
-        assert_eq!(file_info.container(), "system");
-        assert_eq!(file_info.package_map(), "/system/etc/package.map");
-        assert_eq!(file_info.flag_map(), "/system/etc/flag.map");
-        assert_eq!(file_info.flag_val(), "/metadata/aconfig/system.val");
-        assert_eq!(file_info.timestamp(), 12345);
-
-        let file_info = find_container_storage_location(&file_full_path, "product").unwrap();
-        assert_eq!(file_info.version(), 1);
-        assert_eq!(file_info.container(), "product");
-        assert_eq!(file_info.package_map(), "/product/etc/package.map");
-        assert_eq!(file_info.flag_map(), "/product/etc/flag.map");
-        assert_eq!(file_info.flag_val(), "/metadata/aconfig/product.val");
-        assert_eq!(file_info.timestamp(), 54321);
-
-        let err = find_container_storage_location(&file_full_path, "vendor").unwrap_err();
-        assert_eq!(
-            format!("{:?}", err),
-            "StorageFileNotFound(Storage file does not exist for vendor)"
-        );
-    }
-
-    fn map_and_verify(location_pb_file: &str, file_type: StorageFileType, actual_file: &str) {
+    fn map_and_verify(storage_dir: &str, file_type: StorageFileType, actual_file: &str) {
         let mut opened_file = File::open(actual_file).unwrap();
         let mut content = Vec::new();
         opened_file.read_to_end(&mut content).unwrap();
-
-        let mmaped_file =
-            unsafe { get_mapped_file(location_pb_file, "system", file_type).unwrap() };
+        let mmaped_file = unsafe { get_mapped_file(storage_dir, "mockup", file_type).unwrap() };
         assert_eq!(mmaped_file[..], content[..]);
     }
 
-    fn create_test_storage_files() -> [NamedTempFile; 4] {
-        let package_map = copy_to_temp_file("./tests/package.map").unwrap();
-        let flag_map = copy_to_temp_file("./tests/flag.map").unwrap();
-        let flag_val = copy_to_temp_file("./tests/package.map").unwrap();
+    fn create_test_storage_files() -> String {
+        let mut rng = rand::thread_rng();
+        let number: u32 = rng.gen();
+        let storage_dir = String::from("/tmp/") + &number.to_string();
+        if std::fs::metadata(&storage_dir).is_ok() {
+            fs::remove_dir_all(&storage_dir).unwrap();
+        }
+        let maps_dir = storage_dir.clone() + "/maps";
+        let boot_dir = storage_dir.clone() + "/boot";
+        fs::create_dir(&storage_dir).unwrap();
+        fs::create_dir(&maps_dir).unwrap();
+        fs::create_dir(&boot_dir).unwrap();
 
-        let text_proto = format!(
-            r#"
-files {{
-    version: 0
-    container: "system"
-    package_map: "{}"
-    flag_map: "{}"
-    flag_val: "{}"
-    timestamp: 12345
-}}
-"#,
-            package_map.path().display(),
-            flag_map.path().display(),
-            flag_val.path().display()
-        );
-        let pb_file = write_proto_to_temp_file(&text_proto).unwrap();
-        [package_map, flag_map, flag_val, pb_file]
+        let package_map = storage_dir.clone() + "/maps/mockup.package.map";
+        let flag_map = storage_dir.clone() + "/maps/mockup.flag.map";
+        let flag_val = storage_dir.clone() + "/boot/mockup.val";
+        let flag_info = storage_dir.clone() + "/boot/mockup.info";
+        fs::copy("./tests/package.map", &package_map).unwrap();
+        fs::copy("./tests/flag.map", &flag_map).unwrap();
+        fs::copy("./tests/flag.val", &flag_val).unwrap();
+        fs::copy("./tests/flag.info", &flag_info).unwrap();
+
+        return storage_dir;
     }
 
     #[test]
     fn test_mapped_file_contents() {
-        let [package_map, flag_map, flag_val, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
-        map_and_verify(
-            &pb_file_path,
-            StorageFileType::PackageMap,
-            &package_map.path().display().to_string(),
-        );
-        map_and_verify(
-            &pb_file_path,
-            StorageFileType::FlagMap,
-            &flag_map.path().display().to_string(),
-        );
-        map_and_verify(
-            &pb_file_path,
-            StorageFileType::FlagVal,
-            &flag_val.path().display().to_string(),
-        );
+        let storage_dir = create_test_storage_files();
+        map_and_verify(&storage_dir, StorageFileType::PackageMap, "./tests/package.map");
+        map_and_verify(&storage_dir, StorageFileType::FlagMap, "./tests/flag.map");
+        map_and_verify(&storage_dir, StorageFileType::FlagVal, "./tests/flag.val");
+        map_and_verify(&storage_dir, StorageFileType::FlagInfo, "./tests/flag.info");
     }
 }
diff --git a/tools/aconfig/aconfig_storage_read_api/src/test_utils.rs b/tools/aconfig/aconfig_storage_read_api/src/test_utils.rs
deleted file mode 100644
index 84f31aa..0000000
--- a/tools/aconfig/aconfig_storage_read_api/src/test_utils.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2023 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.
- */
-
-use anyhow::Result;
-use std::fs;
-use tempfile::NamedTempFile;
-
-/// Create temp file copy
-pub(crate) fn copy_to_temp_file(source_file: &str) -> Result<NamedTempFile> {
-    let file = NamedTempFile::new()?;
-    fs::copy(source_file, file.path())?;
-    Ok(file)
-}
diff --git a/tools/aconfig/aconfig_storage_read_api/tests/Android.bp b/tools/aconfig/aconfig_storage_read_api/tests/Android.bp
index 6b05ca6..98944d6 100644
--- a/tools/aconfig/aconfig_storage_read_api/tests/Android.bp
+++ b/tools/aconfig/aconfig_storage_read_api/tests/Android.bp
@@ -7,8 +7,7 @@
         "libanyhow",
         "libaconfig_storage_file",
         "libaconfig_storage_read_api",
-        "libprotobuf",
-        "libtempfile",
+        "librand",
     ],
     data: [
         "package.map",
@@ -26,8 +25,6 @@
     ],
     static_libs: [
         "libgmock",
-        "libaconfig_storage_protos_cc",
-        "libprotobuf-cpp-lite",
         "libaconfig_storage_read_api_cc",
         "libbase",
         "liblog",
diff --git a/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.cpp b/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.cpp
index 5393c49..86a0541 100644
--- a/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.cpp
+++ b/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.cpp
@@ -22,11 +22,9 @@
 #include <sys/stat.h>
 #include "aconfig_storage/aconfig_storage_read_api.hpp"
 #include <gtest/gtest.h>
-#include <protos/aconfig_storage_metadata.pb.h>
 #include <android-base/file.h>
 #include <android-base/result.h>
 
-using android::aconfig_storage_metadata::storage_files;
 using namespace android::base;
 
 namespace api = aconfig_storage;
@@ -34,49 +32,33 @@
 
 class AconfigStorageTest : public ::testing::Test {
  protected:
-  Result<std::string> copy_to_temp_file(std::string const& source_file) {
-    auto temp_file = std::string(std::tmpnam(nullptr));
+  Result<void> copy_file(std::string const& src_file,
+                         std::string const& dst_file) {
     auto content = std::string();
-    if (!ReadFileToString(source_file, &content)) {
-      return Error() << "failed to read file: " << source_file;
+    if (!ReadFileToString(src_file, &content)) {
+      return Error() << "failed to read file: " << src_file;
     }
-    if (!WriteStringToFile(content, temp_file)) {
-      return Error() << "failed to copy file: " << source_file;
+    if (!WriteStringToFile(content, dst_file)) {
+      return Error() << "failed to copy file: " << dst_file;
     }
-    return temp_file;
-  }
-
-  Result<std::string> write_storage_location_pb_file(std::string const& package_map,
-                                                     std::string const& flag_map,
-                                                     std::string const& flag_val,
-                                                     std::string const& flag_info) {
-    auto temp_file = std::tmpnam(nullptr);
-    auto proto = storage_files();
-    auto* info = proto.add_files();
-    info->set_version(0);
-    info->set_container("mockup");
-    info->set_package_map(package_map);
-    info->set_flag_map(flag_map);
-    info->set_flag_val(flag_val);
-    info->set_flag_info(flag_info);
-    info->set_timestamp(12345);
-
-    auto content = std::string();
-    proto.SerializeToString(&content);
-    if (!WriteStringToFile(content, temp_file)) {
-      return Error() << "failed to write storage records pb file";
-    }
-    return temp_file;
+    return {};
   }
 
   void SetUp() override {
     auto const test_dir = android::base::GetExecutableDirectory();
-    package_map = *copy_to_temp_file(test_dir + "/package.map");
-    flag_map = *copy_to_temp_file(test_dir + "/flag.map");
-    flag_val = *copy_to_temp_file(test_dir + "/flag.val");
-    flag_info = *copy_to_temp_file(test_dir + "/flag.info");
-    storage_record_pb = *write_storage_location_pb_file(
-        package_map, flag_map, flag_val, flag_info);
+    storage_dir = std::string(root_dir.path);
+    auto maps_dir = storage_dir + "/maps";
+    auto boot_dir = storage_dir + "/boot";
+    mkdir(maps_dir.c_str(), 0775);
+    mkdir(boot_dir.c_str(), 0775);
+    package_map = std::string(maps_dir) + "/mockup.package.map";
+    flag_map = std::string(maps_dir) + "/mockup.flag.map";
+    flag_val = std::string(boot_dir) + "/mockup.val";
+    flag_info = std::string(boot_dir) + "/mockup.info";
+    copy_file(test_dir + "/package.map", package_map);
+    copy_file(test_dir + "/flag.map", flag_map);
+    copy_file(test_dir + "/flag.val", flag_val);
+    copy_file(test_dir + "/flag.info", flag_info);
   }
 
   void TearDown() override {
@@ -84,14 +66,14 @@
     std::remove(flag_map.c_str());
     std::remove(flag_val.c_str());
     std::remove(flag_info.c_str());
-    std::remove(storage_record_pb.c_str());
   }
 
+  TemporaryDir root_dir;
+  std::string storage_dir;
   std::string package_map;
   std::string flag_map;
   std::string flag_val;
   std::string flag_info;
-  std::string storage_record_pb;
 };
 
 /// Test to lock down storage file version query api
@@ -113,16 +95,17 @@
 /// Negative test to lock down the error when mapping none exist storage files
 TEST_F(AconfigStorageTest, test_none_exist_storage_file_mapping) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "vendor", api::StorageFileType::package_map);
+      storage_dir, "vendor", api::StorageFileType::package_map);
   ASSERT_FALSE(mapped_file_result.ok());
   ASSERT_EQ(mapped_file_result.error().message(),
-            "Unable to find storage files for container vendor");
+            std::string("failed to open ") + storage_dir
+            + "/maps/vendor.package.map: No such file or directory");
 }
 
 /// Test to lock down storage package context query api
 TEST_F(AconfigStorageTest, test_package_context_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::package_map);
+      storage_dir, "mockup", api::StorageFileType::package_map);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -151,7 +134,7 @@
 /// Test to lock down when querying none exist package
 TEST_F(AconfigStorageTest, test_none_existent_package_context_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::package_map);
+      storage_dir, "mockup", api::StorageFileType::package_map);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -164,7 +147,7 @@
 /// Test to lock down storage flag context query api
 TEST_F(AconfigStorageTest, test_flag_context_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_map);
+      storage_dir, "mockup", api::StorageFileType::flag_map);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -190,7 +173,7 @@
 /// Test to lock down when querying none exist flag
 TEST_F(AconfigStorageTest, test_none_existent_flag_context_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_map);
+      storage_dir, "mockup", api::StorageFileType::flag_map);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -206,7 +189,7 @@
 /// Test to lock down storage flag value query api
 TEST_F(AconfigStorageTest, test_boolean_flag_value_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_val);
+      storage_dir, "mockup", api::StorageFileType::flag_val);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -222,7 +205,7 @@
 /// Negative test to lock down the error when querying flag value out of range
 TEST_F(AconfigStorageTest, test_invalid_boolean_flag_value_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_val);
+      storage_dir, "mockup", api::StorageFileType::flag_val);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -235,7 +218,7 @@
 /// Test to lock down storage flag info query api
 TEST_F(AconfigStorageTest, test_boolean_flag_info_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_info);
+      storage_dir, "mockup", api::StorageFileType::flag_info);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
@@ -254,7 +237,7 @@
 /// Negative test to lock down the error when querying flag info out of range
 TEST_F(AconfigStorageTest, test_invalid_boolean_flag_info_query) {
   auto mapped_file_result = private_api::get_mapped_file_impl(
-      storage_record_pb, "mockup", api::StorageFileType::flag_info);
+      storage_dir, "mockup", api::StorageFileType::flag_info);
   ASSERT_TRUE(mapped_file_result.ok());
   auto mapped_file = std::unique_ptr<api::MappedStorageFile>(*mapped_file_result);
 
diff --git a/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.rs b/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.rs
index ecba573..afc44d4 100644
--- a/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.rs
+++ b/tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.rs
@@ -1,71 +1,63 @@
 #[cfg(not(feature = "cargo"))]
 mod aconfig_storage_rust_test {
-    use aconfig_storage_file::protos::storage_record_pb::write_proto_to_temp_file;
     use aconfig_storage_file::{FlagInfoBit, FlagValueType, StorageFileType, StoredFlagType};
     use aconfig_storage_read_api::{
         get_boolean_flag_value, get_flag_attribute, get_flag_read_context,
         get_package_read_context, get_storage_file_version, mapped_file::get_mapped_file,
         PackageReadContext,
     };
+    use rand::Rng;
     use std::fs;
-    use tempfile::NamedTempFile;
 
-    pub fn copy_to_temp_file(source_file: &str) -> NamedTempFile {
-        let file = NamedTempFile::new().unwrap();
-        fs::copy(source_file, file.path()).unwrap();
-        file
-    }
+    fn create_test_storage_files() -> String {
+        let mut rng = rand::thread_rng();
+        let number: u32 = rng.gen();
+        let storage_dir = String::from("/tmp/") + &number.to_string();
+        if std::fs::metadata(&storage_dir).is_ok() {
+            fs::remove_dir_all(&storage_dir).unwrap();
+        }
+        let maps_dir = storage_dir.clone() + "/maps";
+        let boot_dir = storage_dir.clone() + "/boot";
+        fs::create_dir(&storage_dir).unwrap();
+        fs::create_dir(maps_dir).unwrap();
+        fs::create_dir(boot_dir).unwrap();
 
-    fn create_test_storage_files() -> [NamedTempFile; 5] {
-        let package_map = copy_to_temp_file("./package.map");
-        let flag_map = copy_to_temp_file("./flag.map");
-        let flag_val = copy_to_temp_file("./flag.val");
-        let flag_info = copy_to_temp_file("./flag.info");
+        let package_map = storage_dir.clone() + "/maps/mockup.package.map";
+        let flag_map = storage_dir.clone() + "/maps/mockup.flag.map";
+        let flag_val = storage_dir.clone() + "/boot/mockup.val";
+        let flag_info = storage_dir.clone() + "/boot/mockup.info";
+        fs::copy("./package.map", package_map).unwrap();
+        fs::copy("./flag.map", flag_map).unwrap();
+        fs::copy("./flag.val", flag_val).unwrap();
+        fs::copy("./flag.info", flag_info).unwrap();
 
-        let text_proto = format!(
-            r#"
-files {{
-    version: 0
-    container: "mockup"
-    package_map: "{}"
-    flag_map: "{}"
-    flag_val: "{}"
-    flag_info: "{}"
-    timestamp: 12345
-}}
-"#,
-            package_map.path().display(),
-            flag_map.path().display(),
-            flag_val.path().display(),
-            flag_info.path().display()
-        );
-        let pb_file = write_proto_to_temp_file(&text_proto).unwrap();
-        [package_map, flag_map, flag_val, flag_info, pb_file]
+        storage_dir
     }
 
     #[test]
     fn test_unavailable_stoarge() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let err = unsafe {
-            get_mapped_file(&pb_file_path, "vendor", StorageFileType::PackageMap).unwrap_err()
+            get_mapped_file(&storage_dir, "vendor", StorageFileType::PackageMap).unwrap_err()
         };
         assert_eq!(
             format!("{:?}", err),
-            "StorageFileNotFound(Storage file does not exist for vendor)"
+            format!(
+                "StorageFileNotFound(storage file {}/maps/vendor.package.map does not exist)",
+                storage_dir
+            )
         );
     }
 
     #[test]
     fn test_package_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let package_mapped_file = unsafe {
-            get_mapped_file(&pb_file_path, "mockup", StorageFileType::PackageMap).unwrap()
+            get_mapped_file(&storage_dir, "mockup", StorageFileType::PackageMap).unwrap()
         };
 
         let package_context =
@@ -92,12 +84,11 @@
 
     #[test]
     fn test_none_exist_package_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let package_mapped_file = unsafe {
-            get_mapped_file(&pb_file_path, "mockup", StorageFileType::PackageMap).unwrap()
+            get_mapped_file(&storage_dir, "mockup", StorageFileType::PackageMap).unwrap()
         };
 
         let package_context_option =
@@ -108,12 +99,11 @@
 
     #[test]
     fn test_flag_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_mapped_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagMap).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagMap).unwrap() };
 
         let baseline = vec![
             (0, "enabled_ro", StoredFlagType::ReadOnlyBoolean, 1u16),
@@ -135,12 +125,11 @@
 
     #[test]
     fn test_none_exist_flag_context_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_mapped_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagMap).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagMap).unwrap() };
         let flag_context_option =
             get_flag_read_context(&flag_mapped_file, 0, "none_exist").unwrap();
         assert_eq!(flag_context_option, None);
@@ -152,12 +141,11 @@
 
     #[test]
     fn test_boolean_flag_value_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_value_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagVal).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagVal).unwrap() };
         let baseline: Vec<bool> = vec![false, true, true, false, true, true, true, true];
         for (offset, expected_value) in baseline.into_iter().enumerate() {
             let flag_value = get_boolean_flag_value(&flag_value_file, offset as u32).unwrap();
@@ -167,12 +155,11 @@
 
     #[test]
     fn test_invalid_boolean_flag_value_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_value_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagVal).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagVal).unwrap() };
         let err = get_boolean_flag_value(&flag_value_file, 8u32).unwrap_err();
         assert_eq!(
             format!("{:?}", err),
@@ -182,12 +169,11 @@
 
     #[test]
     fn test_flag_info_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_info_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagInfo).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagInfo).unwrap() };
         let is_rw: Vec<bool> = vec![true, false, true, true, false, false, false, true];
         for (offset, expected_value) in is_rw.into_iter().enumerate() {
             let attribute =
@@ -200,12 +186,11 @@
 
     #[test]
     fn test_invalid_boolean_flag_info_query() {
-        let [_package_map, _flag_map, _flag_val, _flag_info, pb_file] = create_test_storage_files();
-        let pb_file_path = pb_file.path().display().to_string();
+        let storage_dir = create_test_storage_files();
         // SAFETY:
         // The safety here is ensured as the test process will not write to temp storage file
         let flag_info_file =
-            unsafe { get_mapped_file(&pb_file_path, "mockup", StorageFileType::FlagInfo).unwrap() };
+            unsafe { get_mapped_file(&storage_dir, "mockup", StorageFileType::FlagInfo).unwrap() };
         let err = get_flag_attribute(&flag_info_file, FlagValueType::Boolean, 8u32).unwrap_err();
         assert_eq!(
             format!("{:?}", err),
diff --git a/tools/aconfig/aconfig_storage_write_api/Android.bp b/tools/aconfig/aconfig_storage_write_api/Android.bp
index 4dbdbbf..0f1962c 100644
--- a/tools/aconfig/aconfig_storage_write_api/Android.bp
+++ b/tools/aconfig/aconfig_storage_write_api/Android.bp
@@ -77,7 +77,6 @@
     export_include_dirs: ["include"],
     static_libs: [
         "libaconfig_storage_read_api_cc",
-        "libaconfig_storage_protos_cc",
         "libprotobuf-cpp-lite",
         "libbase",
     ],
diff --git a/tools/aconfig/aconfig_storage_write_api/Cargo.toml b/tools/aconfig/aconfig_storage_write_api/Cargo.toml
index eaa55f2..2ce6edf 100644
--- a/tools/aconfig/aconfig_storage_write_api/Cargo.toml
+++ b/tools/aconfig/aconfig_storage_write_api/Cargo.toml
@@ -13,7 +13,6 @@
 memmap2 = "0.8.0"
 tempfile = "3.9.0"
 thiserror = "1.0.56"
-protobuf = "3.2.0"
 aconfig_storage_file = { path = "../aconfig_storage_file" }
 aconfig_storage_read_api = { path = "../aconfig_storage_read_api" }
 
diff --git a/tools/aconfig/aconfig_storage_write_api/aconfig_storage_write_api.cpp b/tools/aconfig/aconfig_storage_write_api/aconfig_storage_write_api.cpp
index f529f79..b441e05 100644
--- a/tools/aconfig/aconfig_storage_write_api/aconfig_storage_write_api.cpp
+++ b/tools/aconfig/aconfig_storage_write_api/aconfig_storage_write_api.cpp
@@ -1,7 +1,6 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <protos/aconfig_storage_metadata.pb.h>
 
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ -11,8 +10,6 @@
 #include "aconfig_storage/lib.rs.h"
 #include "aconfig_storage/aconfig_storage_write_api.hpp"
 
-using storage_records_pb = android::aconfig_storage_metadata::storage_files;
-using storage_record_pb = android::aconfig_storage_metadata::storage_file_info;
 using namespace android::base;
 
 namespace aconfig_storage {
diff --git a/tools/aconfig/aconfig_storage_write_api/tests/Android.bp b/tools/aconfig/aconfig_storage_write_api/tests/Android.bp
index 85568e0..f6409b7 100644
--- a/tools/aconfig/aconfig_storage_write_api/tests/Android.bp
+++ b/tools/aconfig/aconfig_storage_write_api/tests/Android.bp
@@ -25,8 +25,6 @@
     ],
     static_libs: [
         "libgmock",
-        "libaconfig_storage_protos_cc",
-        "libprotobuf-cpp-lite",
         "libaconfig_storage_read_api_cc",
         "libaconfig_storage_write_api_cc",
         "libbase",
diff --git a/tools/aconfig/aconfig_storage_write_api/tests/storage_write_api_test.cpp b/tools/aconfig/aconfig_storage_write_api/tests/storage_write_api_test.cpp
index 5437379..31183fa 100644
--- a/tools/aconfig/aconfig_storage_write_api/tests/storage_write_api_test.cpp
+++ b/tools/aconfig/aconfig_storage_write_api/tests/storage_write_api_test.cpp
@@ -22,11 +22,9 @@
 #include "aconfig_storage/aconfig_storage_read_api.hpp"
 #include "aconfig_storage/aconfig_storage_write_api.hpp"
 #include <gtest/gtest.h>
-#include <protos/aconfig_storage_metadata.pb.h>
 #include <android-base/file.h>
 #include <android-base/result.h>
 
-using android::aconfig_storage_metadata::storage_files;
 using namespace android::base;
 
 namespace api = aconfig_storage;