diff --git a/apexd/aidl/android/apex/IApexService.aidl b/apexd/aidl/android/apex/IApexService.aidl
index 4d9b5f7..57adcf8 100644
--- a/apexd/aidl/android/apex/IApexService.aidl
+++ b/apexd/aidl/android/apex/IApexService.aidl
@@ -36,9 +36,9 @@
 
    /**
     * Copies the CE apex data directory for the given user to the backup
-    * location, and returns the inode of the snapshot directory.
+    * location.
     */
-   long snapshotCeData(int user_id, int rollback_id, in @utf8InCpp String apex_name);
+   void snapshotCeData(int user_id, int rollback_id, in @utf8InCpp String apex_name);
 
    /**
     * Restores the snapshot of the CE apex data directory for the given user and
@@ -52,6 +52,11 @@
    void destroyDeSnapshots(int rollback_id);
 
    /**
+    * Deletes credential-encrypted snapshots for the given user, for the given rollback id.
+    */
+   void destroyCeSnapshots(int user_id, int rollback_id);
+
+   /**
     * Deletes all credential-encrypted snapshots for the given user, except for
     * those listed in retain_rollback_ids.
     */
diff --git a/apexd/apex_database.cpp b/apexd/apex_database.cpp
index 13a5472..0f9502c 100644
--- a/apexd/apex_database.cpp
+++ b/apexd/apex_database.cpp
@@ -77,12 +77,12 @@
   fs::path DevPath() const { return kDevBlock / name; }
 
   Result<std::string> GetProperty(const std::string& property) const {
-    auto propertyFile = SysPath() / property;
-    std::string propertyValue;
-    if (!ReadFileToString(propertyFile, &propertyValue)) {
+    auto property_file = SysPath() / property;
+    std::string property_value;
+    if (!ReadFileToString(property_file, &property_value)) {
       return ErrnoError() << "Fail to read";
     }
-    return Trim(propertyValue);
+    return Trim(property_value);
   }
 
   std::vector<BlockDevice> GetSlaves() const {
@@ -101,17 +101,17 @@
   }
 };
 
-std::pair<fs::path, fs::path> parseMountInfo(const std::string& mountInfo) {
-  const auto& tokens = Split(mountInfo, " ");
+std::pair<fs::path, fs::path> ParseMountInfo(const std::string& mount_info) {
+  const auto& tokens = Split(mount_info, " ");
   if (tokens.size() < 2) {
     return std::make_pair("", "");
   }
   return std::make_pair(tokens[0], tokens[1]);
 }
 
-std::pair<std::string, int> parseMountPoint(const std::string& mountPoint) {
-  auto packageId = fs::path(mountPoint).filename();
-  auto split = Split(packageId, "@");
+std::pair<std::string, int> ParseMountPoint(const std::string& mount_point) {
+  auto package_id = fs::path(mount_point).filename();
+  auto split = Split(package_id, "@");
   if (split.size() == 2) {
     int version;
     if (!ParseInt(split[1], &version)) {
@@ -119,11 +119,11 @@
     }
     return std::make_pair(split[0], version);
   }
-  return std::make_pair(packageId, -1);
+  return std::make_pair(package_id, -1);
 }
 
-bool isActiveMountPoint(const std::string& mountPoint) {
-  return (mountPoint.find('@') == std::string::npos);
+bool IsActiveMountPoint(const std::string& mount_point) {
+  return (mount_point.find('@') == std::string::npos);
 }
 
 Result<void> PopulateLoopInfo(const BlockDevice& top_device,
@@ -189,17 +189,17 @@
   apex_data->full_path = full_path;
 }
 
-Result<MountedApexData> resolveMountInfo(const BlockDevice& block,
-                                         const std::string& mountPoint) {
-  bool temp_mount = EndsWith(mountPoint, ".tmp");
+Result<MountedApexData> ResolveMountInfo(const BlockDevice& block,
+                                         const std::string& mount_point) {
+  bool temp_mount = EndsWith(mount_point, ".tmp");
   // Now, see if it is dm-verity or loop mounted
   switch (block.GetType()) {
     case LoopDevice: {
-      auto backingFile = block.GetProperty("loop/backing_file");
-      if (!backingFile.ok()) {
-        return backingFile.error();
+      auto backing_file = block.GetProperty("loop/backing_file");
+      if (!backing_file.ok()) {
+        return backing_file.error();
       }
-      auto result = MountedApexData(block.DevPath(), *backingFile, mountPoint,
+      auto result = MountedApexData(block.DevPath(), *backing_file, mount_point,
                                     /* device_name= */ "",
                                     /* hashtree_loop_name= */ "",
                                     /* is_temp_mount */ temp_mount);
@@ -212,7 +212,7 @@
         return name.error();
       }
       MountedApexData result;
-      result.mount_point = mountPoint;
+      result.mount_point = mount_point;
       result.device_name = *name;
       result.is_temp_mount = temp_mount;
       if (auto status = PopulateLoopInfo(block, &result); !status.ok()) {
@@ -253,37 +253,37 @@
 void MountedApexDatabase::PopulateFromMounts() {
   LOG(INFO) << "Populating APEX database from mounts...";
 
-  std::unordered_map<std::string, int> activeVersions;
+  std::unordered_map<std::string, int> active_versions;
 
   std::ifstream mounts("/proc/mounts");
   std::string line;
   while (std::getline(mounts, line)) {
-    auto [block, mountPoint] = parseMountInfo(line);
+    auto [block, mount_point] = ParseMountInfo(line);
     // TODO(b/158469914): distinguish between temp and non-temp mounts
-    if (fs::path(mountPoint).parent_path() != kApexRoot) {
+    if (fs::path(mount_point).parent_path() != kApexRoot) {
       continue;
     }
-    if (isActiveMountPoint(mountPoint)) {
+    if (IsActiveMountPoint(mount_point)) {
       continue;
     }
 
-    auto mountData = resolveMountInfo(BlockDevice(block), mountPoint);
-    if (!mountData.ok()) {
-      LOG(WARNING) << "Can't resolve mount info " << mountData.error();
+    auto mount_data = ResolveMountInfo(BlockDevice(block), mount_point);
+    if (!mount_data.ok()) {
+      LOG(WARNING) << "Can't resolve mount info " << mount_data.error();
       continue;
     }
 
-    auto [package, version] = parseMountPoint(mountPoint);
-    AddMountedApex(package, false, *mountData);
+    auto [package, version] = ParseMountPoint(mount_point);
+    AddMountedApex(package, false, *mount_data);
 
-    auto active = activeVersions[package] < version;
+    auto active = active_versions[package] < version;
     if (active) {
-      activeVersions[package] = version;
-      SetLatest(package, mountData->full_path);
+      active_versions[package] = version;
+      SetLatest(package, mount_data->full_path);
     }
-    LOG(INFO) << "Found " << mountPoint << " backed by"
-              << (mountData->deleted ? " deleted " : " ") << "file "
-              << mountData->full_path;
+    LOG(INFO) << "Found " << mount_point << " backed by"
+              << (mount_data->deleted ? " deleted " : " ") << "file "
+              << mount_data->full_path;
   }
 
   LOG(INFO) << mounted_apexes_.size() << " packages restored.";
diff --git a/apexd/apex_file.cpp b/apexd/apex_file.cpp
index 83264d3..2049ff9 100644
--- a/apexd/apex_file.cpp
+++ b/apexd/apex_file.cpp
@@ -153,7 +153,7 @@
 
 static constexpr int kVbMetaMaxSize = 64 * 1024;
 
-std::string bytes_to_hex(const uint8_t* bytes, size_t bytes_len) {
+std::string BytesToHex(const uint8_t* bytes, size_t bytes_len) {
   std::ostringstream s;
 
   s << std::hex << std::setfill('0');
@@ -163,22 +163,22 @@
   return s.str();
 }
 
-std::string getSalt(const AvbHashtreeDescriptor& desc,
-                    const uint8_t* trailingData) {
-  const uint8_t* desc_salt = trailingData + desc.partition_name_len;
+std::string GetSalt(const AvbHashtreeDescriptor& desc,
+                    const uint8_t* trailing_data) {
+  const uint8_t* desc_salt = trailing_data + desc.partition_name_len;
 
-  return bytes_to_hex(desc_salt, desc.salt_len);
+  return BytesToHex(desc_salt, desc.salt_len);
 }
 
-std::string getDigest(const AvbHashtreeDescriptor& desc,
-                      const uint8_t* trailingData) {
+std::string GetDigest(const AvbHashtreeDescriptor& desc,
+                      const uint8_t* trailing_data) {
   const uint8_t* desc_digest =
-      trailingData + desc.partition_name_len + desc.salt_len;
+      trailing_data + desc.partition_name_len + desc.salt_len;
 
-  return bytes_to_hex(desc_digest, desc.root_digest_len);
+  return BytesToHex(desc_digest, desc.root_digest_len);
 }
 
-Result<std::unique_ptr<AvbFooter>> getAvbFooter(const ApexFile& apex,
+Result<std::unique_ptr<AvbFooter>> GetAvbFooter(const ApexFile& apex,
                                                 const unique_fd& fd) {
   std::array<uint8_t, AVB_FOOTER_SIZE> footer_data;
   auto footer = std::make_unique<AvbFooter>();
@@ -211,7 +211,7 @@
 }
 
 // Verifies correctness of vbmeta and returns public key it was signed with.
-Result<std::span<const uint8_t>> verifyVbMetaSignature(const ApexFile& apex,
+Result<std::span<const uint8_t>> VerifyVbMetaSignature(const ApexFile& apex,
                                                        const uint8_t* data,
                                                        size_t length) {
   const uint8_t* pk;
@@ -240,7 +240,7 @@
   return std::span<const uint8_t>(pk, pk_len);
 }
 
-Result<std::unique_ptr<uint8_t[]>> verifyVbMeta(const ApexFile& apex,
+Result<std::unique_ptr<uint8_t[]>> VerifyVbMeta(const ApexFile& apex,
                                                 const unique_fd& fd,
                                                 const AvbFooter& footer,
                                                 const std::string& public_key) {
@@ -256,7 +256,7 @@
   }
 
   Result<std::span<const uint8_t>> st =
-      verifyVbMetaSignature(apex, vbmeta_buf.get(), footer.vbmeta_size);
+      VerifyVbMetaSignature(apex, vbmeta_buf.get(), footer.vbmeta_size);
   if (!st.ok()) {
     return st.error();
   }
@@ -269,7 +269,7 @@
   return vbmeta_buf;
 }
 
-Result<const AvbHashtreeDescriptor*> findDescriptor(uint8_t* vbmeta_data,
+Result<const AvbHashtreeDescriptor*> FindDescriptor(uint8_t* vbmeta_data,
                                                     size_t vbmeta_size) {
   const AvbDescriptor** descriptors;
   size_t num_descriptors;
@@ -303,62 +303,62 @@
   return Errorf("Couldn't find any AVB hashtree descriptors.");
 }
 
-Result<std::unique_ptr<AvbHashtreeDescriptor>> verifyDescriptor(
+Result<std::unique_ptr<AvbHashtreeDescriptor>> VerifyDescriptor(
     const AvbHashtreeDescriptor* desc) {
-  auto verifiedDesc = std::make_unique<AvbHashtreeDescriptor>();
+  auto verified_desc = std::make_unique<AvbHashtreeDescriptor>();
 
   if (!avb_hashtree_descriptor_validate_and_byteswap(desc,
-                                                     verifiedDesc.get())) {
+                                                     verified_desc.get())) {
     return Errorf("Couldn't validate AvbDescriptor.");
   }
 
-  return verifiedDesc;
+  return verified_desc;
 }
 
 }  // namespace
 
 Result<ApexVerityData> ApexFile::VerifyApexVerity(
     const std::string& public_key) const {
-  ApexVerityData verityData;
+  ApexVerityData verity_data;
 
   unique_fd fd(open(GetPath().c_str(), O_RDONLY | O_CLOEXEC));
   if (fd.get() == -1) {
     return ErrnoError() << "Failed to open " << GetPath();
   }
 
-  Result<std::unique_ptr<AvbFooter>> footer = getAvbFooter(*this, fd);
+  Result<std::unique_ptr<AvbFooter>> footer = GetAvbFooter(*this, fd);
   if (!footer.ok()) {
     return footer.error();
   }
 
   Result<std::unique_ptr<uint8_t[]>> vbmeta_data =
-      verifyVbMeta(*this, fd, **footer, public_key);
+      VerifyVbMeta(*this, fd, **footer, public_key);
   if (!vbmeta_data.ok()) {
     return vbmeta_data.error();
   }
 
   Result<const AvbHashtreeDescriptor*> descriptor =
-      findDescriptor(vbmeta_data->get(), (*footer)->vbmeta_size);
+      FindDescriptor(vbmeta_data->get(), (*footer)->vbmeta_size);
   if (!descriptor.ok()) {
     return descriptor.error();
   }
 
-  Result<std::unique_ptr<AvbHashtreeDescriptor>> verifiedDescriptor =
-      verifyDescriptor(*descriptor);
-  if (!verifiedDescriptor.ok()) {
-    return verifiedDescriptor.error();
+  Result<std::unique_ptr<AvbHashtreeDescriptor>> verified_descriptor =
+      VerifyDescriptor(*descriptor);
+  if (!verified_descriptor.ok()) {
+    return verified_descriptor.error();
   }
-  verityData.desc = std::move(*verifiedDescriptor);
+  verity_data.desc = std::move(*verified_descriptor);
 
   // This area is now safe to access, because we just verified it
-  const uint8_t* trailingData =
+  const uint8_t* trailing_data =
       (const uint8_t*)*descriptor + sizeof(AvbHashtreeDescriptor);
-  verityData.hash_algorithm =
+  verity_data.hash_algorithm =
       reinterpret_cast<const char*>((*descriptor)->hash_algorithm);
-  verityData.salt = getSalt(*verityData.desc, trailingData);
-  verityData.root_digest = getDigest(*verityData.desc, trailingData);
+  verity_data.salt = GetSalt(*verity_data.desc, trailing_data);
+  verity_data.root_digest = GetDigest(*verity_data.desc, trailing_data);
 
-  return verityData;
+  return verity_data;
 }
 
 }  // namespace apex
diff --git a/apexd/apex_file_test.cpp b/apexd/apex_file_test.cpp
index 2cf7d5d..f575434 100644
--- a/apexd/apex_file_test.cpp
+++ b/apexd/apex_file_test.cpp
@@ -27,9 +27,10 @@
 
 #include "apex_file.h"
 
+using android::base::GetExecutableDirectory;
 using android::base::Result;
 
-static std::string testDataDir = android::base::GetExecutableDirectory() + "/";
+static const std::string kTestDataDir = GetExecutableDirectory() + "/";
 
 namespace android {
 namespace apex {
@@ -48,15 +49,15 @@
 INSTANTIATE_TEST_SUITE_P(Apex, ApexFileTest, testing::ValuesIn(kParameters));
 
 TEST_P(ApexFileTest, GetOffsetOfSimplePackage) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_TRUE(apexFile.ok());
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_TRUE(apex_file.ok());
 
   int32_t zip_image_offset;
   size_t zip_image_size;
   {
     ZipArchiveHandle handle;
-    int32_t rc = OpenArchive(filePath.c_str(), &handle);
+    int32_t rc = OpenArchive(file_path.c_str(), &handle);
     ASSERT_EQ(0, rc);
     auto close_guard =
         android::base::make_scope_guard([&handle]() { CloseArchive(handle); });
@@ -71,32 +72,33 @@
     EXPECT_EQ(zip_image_size, entry.compressed_length);
   }
 
-  EXPECT_EQ(zip_image_offset, apexFile->GetImageOffset());
-  EXPECT_EQ(zip_image_size, apexFile->GetImageSize());
+  EXPECT_EQ(zip_image_offset, apex_file->GetImageOffset());
+  EXPECT_EQ(zip_image_size, apex_file->GetImageSize());
 }
 
 TEST(ApexFileTest, GetOffsetMissingFile) {
-  const std::string filePath = testDataDir + "missing.apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_FALSE(apexFile.ok());
-  ASSERT_THAT(apexFile.error().message(),
+  const std::string file_path = kTestDataDir + "missing.apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_FALSE(apex_file.ok());
+  ASSERT_THAT(apex_file.error().message(),
               testing::HasSubstr("Failed to open package"));
 }
 
 TEST_P(ApexFileTest, GetApexManifest) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_RESULT_OK(apexFile);
-  EXPECT_EQ("com.android.apex.test_package", apexFile->GetManifest().name());
-  EXPECT_EQ(1u, apexFile->GetManifest().version());
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_RESULT_OK(apex_file);
+  EXPECT_EQ("com.android.apex.test_package", apex_file->GetManifest().name());
+  EXPECT_EQ(1u, apex_file->GetManifest().version());
 }
 
 TEST_P(ApexFileTest, VerifyApexVerity) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_RESULT_OK(apexFile);
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_RESULT_OK(apex_file);
 
-  auto verity_or = apexFile->VerifyApexVerity(apexFile->GetBundledPublicKey());
+  auto verity_or =
+      apex_file->VerifyApexVerity(apex_file->GetBundledPublicKey());
   ASSERT_RESULT_OK(verity_or);
 
   const ApexVerityData& data = *verity_or;
@@ -105,60 +107,60 @@
                         "50ca7ec8071f49dfa47a243c"),
             data.salt);
 
-  const std::string digestPath =
-      testDataDir + GetParam().prefix + "_digest.txt";
-  std::string rootDigest;
-  ASSERT_TRUE(android::base::ReadFileToString(digestPath, &rootDigest))
-      << "Failed to read " << digestPath;
-  rootDigest = android::base::Trim(rootDigest);
+  const std::string digest_path =
+      kTestDataDir + GetParam().prefix + "_digest.txt";
+  std::string root_digest;
+  ASSERT_TRUE(android::base::ReadFileToString(digest_path, &root_digest))
+      << "Failed to read " << digest_path;
+  root_digest = android::base::Trim(root_digest);
 
-  EXPECT_EQ(std::string(rootDigest), data.root_digest);
+  EXPECT_EQ(std::string(root_digest), data.root_digest);
 }
 
 TEST_P(ApexFileTest, VerifyApexVerityWrongKey) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_RESULT_OK(apexFile);
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_RESULT_OK(apex_file);
 
-  auto verity_or = apexFile->VerifyApexVerity("wrong-key");
+  auto verity_or = apex_file->VerifyApexVerity("wrong-key");
   ASSERT_FALSE(verity_or.ok());
 }
 
 TEST_P(ApexFileTest, GetBundledPublicKey) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_RESULT_OK(apexFile);
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_RESULT_OK(apex_file);
 
-  const std::string keyPath =
-      testDataDir + "apexd_testdata/com.android.apex.test_package.avbpubkey";
-  std::string keyContent;
-  ASSERT_TRUE(android::base::ReadFileToString(keyPath, &keyContent))
-      << "Failed to read " << keyPath;
+  const std::string key_path =
+      kTestDataDir + "apexd_testdata/com.android.apex.test_package.avbpubkey";
+  std::string key_content;
+  ASSERT_TRUE(android::base::ReadFileToString(key_path, &key_content))
+      << "Failed to read " << key_path;
 
-  EXPECT_EQ(keyContent, apexFile->GetBundledPublicKey());
+  EXPECT_EQ(key_content, apex_file->GetBundledPublicKey());
 }
 
 TEST(ApexFileTest, CorrutedApexB146895998) {
-  const std::string apex_path = testDataDir + "corrupted_b146895998.apex";
+  const std::string apex_path = kTestDataDir + "corrupted_b146895998.apex";
   Result<ApexFile> apex = ApexFile::Open(apex_path);
   ASSERT_RESULT_OK(apex);
-  ASSERT_FALSE(apex->VerifyApexVerity("ignored"));
+  ASSERT_FALSE(apex->VerifyApexVerity("ignored").ok());
 }
 
 TEST_P(ApexFileTest, RetrieveFsType) {
-  const std::string filePath = testDataDir + GetParam().prefix + ".apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_TRUE(apexFile.ok());
+  const std::string file_path = kTestDataDir + GetParam().prefix + ".apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_TRUE(apex_file.ok());
 
-  EXPECT_EQ(std::string(GetParam().type), apexFile->GetFsType());
+  EXPECT_EQ(std::string(GetParam().type), apex_file->GetFsType());
 }
 
 TEST(ApexFileTest, OpenInvalidFilesystem) {
-  const std::string filePath =
-      testDataDir + "apex.apexd_test_corrupt_superblock_apex.apex";
-  Result<ApexFile> apexFile = ApexFile::Open(filePath);
-  ASSERT_FALSE(apexFile.ok());
-  ASSERT_THAT(apexFile.error().message(),
+  const std::string file_path =
+      kTestDataDir + "apex.apexd_test_corrupt_superblock_apex.apex";
+  Result<ApexFile> apex_file = ApexFile::Open(file_path);
+  ASSERT_FALSE(apex_file.ok());
+  ASSERT_THAT(apex_file.error().message(),
               testing::HasSubstr("Failed to retrieve filesystem type"));
 }
 
diff --git a/apexd/apex_manifest.cpp b/apexd/apex_manifest.cpp
index 1994633..7bd5913 100644
--- a/apexd/apex_manifest.cpp
+++ b/apexd/apex_manifest.cpp
@@ -46,8 +46,8 @@
   return apex_manifest;
 }
 
-std::string GetPackageId(const ApexManifest& apexManifest) {
-  return apexManifest.name() + "@" + std::to_string(apexManifest.version());
+std::string GetPackageId(const ApexManifest& apex_manifest) {
+  return apex_manifest.name() + "@" + std::to_string(apex_manifest.version());
 }
 
 Result<ApexManifest> ReadManifest(const std::string& path) {
diff --git a/apexd/apex_preinstalled_data.cpp b/apexd/apex_preinstalled_data.cpp
index a7b9f49..4ca8373 100644
--- a/apexd/apex_preinstalled_data.cpp
+++ b/apexd/apex_preinstalled_data.cpp
@@ -21,6 +21,7 @@
 #include <unordered_map>
 
 #include <android-base/file.h>
+#include <android-base/properties.h>
 #include <android-base/result.h>
 #include <android-base/strings.h>
 
@@ -29,6 +30,7 @@
 #include "apexd_utils.h"
 
 using android::base::Error;
+using android::base::GetProperty;
 using android::base::Result;
 
 namespace android {
@@ -60,10 +62,21 @@
     auto it = data_.find(name);
     if (it == data_.end()) {
       data_[name] = apex_data;
+    } else if (it->second.path != apex_data.path) {
+      // Currently, on some -eng builds there are two art apexes on /system
+      // partition. While this issue is not fixed, exempt art apex from the
+      // duplicate check on -eng builds.
+      // TODO(b/176497601): remove this exemption once issue with duplicate art
+      // apex is resolved.
+      std::string build_type = GetProperty("ro.build.type", "");
+      auto level = build_type == "eng" && name == "com.android.art"
+                       ? base::ERROR
+                       : base::FATAL;
+      LOG(level) << "Found two apex packages " << it->second.path << " and "
+                 << apex_data.path << " with the same module name " << name;
     } else if (it->second.public_key != apex_data.public_key) {
-      return Error() << "Key for package " << apex_data.path << " ( " << name
-                     << ") does not match with previously scanned key from "
-                     << it->second.path;
+      LOG(FATAL) << "Public key of apex package " << it->second.path << " ("
+                 << name << ") has unexpectedly changed";
     }
   }
   return {};
diff --git a/apexd/apex_preinstalled_data_test.cpp b/apexd/apex_preinstalled_data_test.cpp
index 8efe68a..a961ed2 100644
--- a/apexd/apex_preinstalled_data_test.cpp
+++ b/apexd/apex_preinstalled_data_test.cpp
@@ -41,7 +41,6 @@
 using android::apex::testing::IsOk;
 using android::base::GetExecutableDirectory;
 using android::base::StringPrintf;
-using ::testing::HasSubstr;
 
 static std::string GetTestDataDir() { return GetExecutableDirectory(); }
 static std::string GetTestFile(const std::string& name) {
@@ -79,6 +78,12 @@
 
   test_fn("apex.apexd_test.apex");
   test_fn("apex.apexd_test_different_app.apex");
+
+  // Check that second call will succeed as well.
+  ASSERT_TRUE(IsOk(instance.Initialize({td.path})));
+
+  test_fn("apex.apexd_test.apex");
+  test_fn("apex.apexd_test_different_app.apex");
 }
 
 TEST(ApexPreinstalledDataTest, InitializeFailureCorruptApex) {
@@ -92,18 +97,52 @@
   ASSERT_FALSE(IsOk(instance.Initialize({td.path})));
 }
 
-TEST(ApexPreinstalledData, InitializeFailureSameNameDifferentKeys) {
+TEST(ApexPreinstalledData, InitializeSameNameDifferentPathAborts) {
   // Prepare test data.
   TemporaryDir td;
   fs::copy(GetTestFile("apex.apexd_test.apex"), td.path);
-  fs::copy(GetTestFile("apex.apexd_test_different_key.apex"), td.path);
+  fs::copy(GetTestFile("apex.apexd_test.apex"),
+           StringPrintf("%s/other.apex", td.path));
+
+  ASSERT_DEATH(
+      {
+        ApexPreinstalledData instance;
+        instance.Initialize({td.path});
+      },
+      "");
+}
+
+TEST(ApexPreinstalledData, InitializePublicKeyUnexpectdlyChangedAborts) {
+  // Prepare test data.
+  TemporaryDir td;
+  fs::copy(GetTestFile("apex.apexd_test.apex"), td.path);
 
   ApexPreinstalledData instance;
-  auto result = instance.Initialize({td.path});
+  ASSERT_TRUE(IsOk(instance.Initialize({td.path})));
 
-  ASSERT_FALSE(IsOk(result));
-  ASSERT_THAT(result.error().message(),
-              HasSubstr("does not match with previously scanned key"));
+  // Check that apex was loaded.
+  auto path = instance.GetPreinstalledPath("com.android.apex.test_package");
+  ASSERT_TRUE(IsOk(path));
+  ASSERT_EQ(StringPrintf("%s/apex.apexd_test.apex", td.path), *path);
+
+  auto public_key = instance.GetPublicKey("com.android.apex.test_package");
+  ASSERT_TRUE(IsOk(public_key));
+
+  // Substitute it with another apex with the same name, but different public
+  // key.
+  fs::copy(GetTestFile("apex.apexd_test_different_key.apex"), *path,
+           fs::copy_options::overwrite_existing);
+
+  {
+    auto apex = ApexFile::Open(*path);
+    ASSERT_TRUE(IsOk(apex));
+    // Check module name hasn't changed.
+    ASSERT_EQ("com.android.apex.test_package", apex->GetManifest().name());
+    // Check public key has changed.
+    ASSERT_NE(*public_key, apex->GetBundledPublicKey());
+  }
+
+  ASSERT_DEATH({ instance.Initialize({td.path}); }, "");
 }
 
 TEST(ApexPreinstalledData, IsPreInstalledApex) {
diff --git a/apexd/apexd.cpp b/apexd/apexd.cpp
index c2439af..98a0d07 100644
--- a/apexd/apexd.cpp
+++ b/apexd/apexd.cpp
@@ -137,14 +137,14 @@
 
 static constexpr const int kNumRetriesWhenCheckpointingEnabled = 1;
 
-bool isBootstrapApex(const ApexFile& apex) {
+bool IsBootstrapApex(const ApexFile& apex) {
   return std::find(kBootstrapApexes.begin(), kBootstrapApexes.end(),
                    apex.GetManifest().name()) != kBootstrapApexes.end();
 }
 
 // Pre-allocate loop devices so that we don't have to wait for them
 // later when actually activating APEXes.
-Result<void> preAllocateLoopDevices() {
+Result<void> PreAllocateLoopDevices() {
   auto scan = FindApexes(kApexPackageBuiltinDirs);
   if (!scan.ok()) {
     return scan.error();
@@ -158,22 +158,22 @@
     }
     size++;
     // bootstrap Apexes may be activated on separate namespaces.
-    if (isBootstrapApex(*apexFile)) {
+    if (IsBootstrapApex(*apexFile)) {
       size++;
     }
   }
 
-  // note: do not call preAllocateLoopDevices() if size == 0.
+  // note: do not call PreAllocateLoopDevices() if size == 0.
   // For devices (e.g. ARC) which doesn't support loop-control
-  // preAllocateLoopDevices() can cause problem when it tries
+  // PreAllocateLoopDevices() can cause problem when it tries
   // to access /dev/loop-control.
   if (size == 0) {
     return {};
   }
-  return loop::preAllocateLoopDevices(size);
+  return loop::PreAllocateLoopDevices(size);
 }
 
-std::unique_ptr<DmTable> createVerityTable(const ApexVerityData& verity_data,
+std::unique_ptr<DmTable> CreateVerityTable(const ApexVerityData& verity_data,
                                            const std::string& block_device,
                                            const std::string& hash_device,
                                            bool restart_on_corruption) {
@@ -257,7 +257,7 @@
   bool cleared_;
 };
 
-Result<DmVerityDevice> createVerityDevice(const std::string& name,
+Result<DmVerityDevice> CreateVerityDevice(const std::string& name,
                                           const DmTable& table) {
   DeviceMapper& dm = DeviceMapper::Instance();
 
@@ -315,7 +315,7 @@
 }
 
 // Reads the entire device to verify the image is authenticatic
-Result<void> readVerityDevice(const std::string& verity_device,
+Result<void> ReadVerityDevice(const std::string& verity_device,
                               uint64_t device_size) {
   static constexpr int kBlockSize = 4096;
   static constexpr size_t kBufSize = 1024 * kBlockSize;
@@ -359,12 +359,12 @@
 }
 
 Result<MountedApexData> MountPackageImpl(const ApexFile& apex,
-                                         const std::string& mountPoint,
+                                         const std::string& mount_point,
                                          const std::string& device_name,
                                          const std::string& hashtree_file,
-                                         bool verifyImage,
-                                         bool tempMount = false) {
-  LOG(VERBOSE) << "Creating mount point: " << mountPoint;
+                                         bool verify_image,
+                                         bool temp_mount = false) {
+  LOG(VERBOSE) << "Creating mount point: " << mount_point;
   // Note: the mount point could exist in case when the APEX was activated
   // during the bootstrap phase (e.g., the runtime or tzdata APEX).
   // Although we have separate mount namespaces to separate the early activated
@@ -373,31 +373,31 @@
   // mounted at / which is (and has to be) a shared mount. Therefore, if apexd
   // finds an empty directory under /apex, it's not a problem and apexd can use
   // it.
-  auto exists = PathExists(mountPoint);
+  auto exists = PathExists(mount_point);
   if (!exists.ok()) {
     return exists.error();
   }
-  if (!*exists && mkdir(mountPoint.c_str(), kMkdirMode) != 0) {
-    return ErrnoError() << "Could not create mount point " << mountPoint;
+  if (!*exists && mkdir(mount_point.c_str(), kMkdirMode) != 0) {
+    return ErrnoError() << "Could not create mount point " << mount_point;
   }
-  auto deleter = [&mountPoint]() {
-    if (rmdir(mountPoint.c_str()) != 0) {
-      PLOG(WARNING) << "Could not rmdir " << mountPoint;
+  auto deleter = [&mount_point]() {
+    if (rmdir(mount_point.c_str()) != 0) {
+      PLOG(WARNING) << "Could not rmdir " << mount_point;
     }
   };
   auto scope_guard = android::base::make_scope_guard(deleter);
-  if (!IsEmptyDirectory(mountPoint)) {
-    return ErrnoError() << mountPoint << " is not empty";
+  if (!IsEmptyDirectory(mount_point)) {
+    return ErrnoError() << mount_point << " is not empty";
   }
 
   const std::string& full_path = apex.GetPath();
 
-  loop::LoopbackDeviceUniqueFd loopbackDevice;
+  loop::LoopbackDeviceUniqueFd loopback_device;
   for (size_t attempts = 1;; ++attempts) {
-    Result<loop::LoopbackDeviceUniqueFd> ret = loop::createLoopDevice(
+    Result<loop::LoopbackDeviceUniqueFd> ret = loop::CreateLoopDevice(
         full_path, apex.GetImageOffset(), apex.GetImageSize());
     if (ret.ok()) {
-      loopbackDevice = std::move(*ret);
+      loopback_device = std::move(*ret);
       break;
     }
     if (attempts >= kLoopDeviceSetupAttempts) {
@@ -405,7 +405,7 @@
                      << ret.error();
     }
   }
-  LOG(VERBOSE) << "Loopback device created: " << loopbackDevice.name;
+  LOG(VERBOSE) << "Loopback device created: " << loopback_device.name;
 
   auto& instance = ApexPreinstalledData::GetInstance();
 
@@ -414,32 +414,32 @@
     return public_key.error();
   }
 
-  auto verityData = apex.VerifyApexVerity(*public_key);
-  if (!verityData.ok()) {
+  auto verity_data = apex.VerifyApexVerity(*public_key);
+  if (!verity_data.ok()) {
     return Error() << "Failed to verify Apex Verity data for " << full_path
-                   << ": " << verityData.error();
+                   << ": " << verity_data.error();
   }
-  std::string blockDevice = loopbackDevice.name;
-  MountedApexData apex_data(loopbackDevice.name, apex.GetPath(), mountPoint,
+  std::string block_device = loopback_device.name;
+  MountedApexData apex_data(loopback_device.name, apex.GetPath(), mount_point,
                             /* device_name = */ "",
                             /* hashtree_loop_name = */ "",
-                            /* is_temp_mount */ tempMount);
+                            /* is_temp_mount */ temp_mount);
 
   // for APEXes in immutable partitions, we don't need to mount them on
   // dm-verity because they are already in the dm-verity protected partition;
   // system. However, note that we don't skip verification to ensure that APEXes
   // are correctly signed.
-  const bool mountOnVerity = !instance.IsPreInstalledApex(apex);
-  DmVerityDevice verityDev;
+  const bool mount_on_verity = !instance.IsPreInstalledApex(apex);
+  DmVerityDevice verity_dev;
   loop::LoopbackDeviceUniqueFd loop_for_hash;
-  if (mountOnVerity) {
-    std::string hash_device = loopbackDevice.name;
-    if (verityData->desc->tree_size == 0) {
-      if (auto st = PrepareHashTree(apex, *verityData, hashtree_file);
+  if (mount_on_verity) {
+    std::string hash_device = loopback_device.name;
+    if (verity_data->desc->tree_size == 0) {
+      if (auto st = PrepareHashTree(apex, *verity_data, hashtree_file);
           !st.ok()) {
         return st.error();
       }
-      auto create_loop_status = loop::createLoopDevice(hashtree_file, 0, 0);
+      auto create_loop_status = loop::CreateLoopDevice(hashtree_file, 0, 0);
       if (!create_loop_status.ok()) {
         return create_loop_status.error();
       }
@@ -447,54 +447,54 @@
       hash_device = loop_for_hash.name;
       apex_data.hashtree_loop_name = hash_device;
     }
-    auto verityTable =
-        createVerityTable(*verityData, loopbackDevice.name, hash_device,
-                          /* restart_on_corruption = */ !verifyImage);
-    Result<DmVerityDevice> verityDevRes =
-        createVerityDevice(device_name, *verityTable);
-    if (!verityDevRes.ok()) {
+    auto verity_table =
+        CreateVerityTable(*verity_data, loopback_device.name, hash_device,
+                          /* restart_on_corruption = */ !verify_image);
+    Result<DmVerityDevice> verity_dev_res =
+        CreateVerityDevice(device_name, *verity_table);
+    if (!verity_dev_res.ok()) {
       return Error() << "Failed to create Apex Verity device " << full_path
-                     << ": " << verityDevRes.error();
+                     << ": " << verity_dev_res.error();
     }
-    verityDev = std::move(*verityDevRes);
+    verity_dev = std::move(*verity_dev_res);
     apex_data.device_name = device_name;
-    blockDevice = verityDev.GetDevPath();
+    block_device = verity_dev.GetDevPath();
 
-    Result<void> readAheadStatus =
-        loop::configureReadAhead(verityDev.GetDevPath());
-    if (!readAheadStatus.ok()) {
-      return readAheadStatus.error();
+    Result<void> read_ahead_status =
+        loop::ConfigureReadAhead(verity_dev.GetDevPath());
+    if (!read_ahead_status.ok()) {
+      return read_ahead_status.error();
     }
   }
   // TODO(b/158467418): consider moving this inside RunVerifyFnInsideTempMount.
-  if (mountOnVerity && verifyImage) {
-    Result<void> verityStatus =
-        readVerityDevice(blockDevice, (*verityData).desc->image_size);
-    if (!verityStatus.ok()) {
-      return verityStatus.error();
+  if (mount_on_verity && verify_image) {
+    Result<void> verity_status =
+        ReadVerityDevice(block_device, (*verity_data).desc->image_size);
+    if (!verity_status.ok()) {
+      return verity_status.error();
     }
   }
 
-  uint32_t mountFlags = MS_NOATIME | MS_NODEV | MS_DIRSYNC | MS_RDONLY;
+  uint32_t mount_flags = MS_NOATIME | MS_NODEV | MS_DIRSYNC | MS_RDONLY;
   if (apex.GetManifest().nocode()) {
-    mountFlags |= MS_NOEXEC;
+    mount_flags |= MS_NOEXEC;
   }
 
-  if (mount(blockDevice.c_str(), mountPoint.c_str(), apex.GetFsType().c_str(),
-            mountFlags, nullptr) == 0) {
+  if (mount(block_device.c_str(), mount_point.c_str(), apex.GetFsType().c_str(),
+            mount_flags, nullptr) == 0) {
     LOG(INFO) << "Successfully mounted package " << full_path << " on "
-              << mountPoint;
-    auto status = VerifyMountedImage(apex, mountPoint);
+              << mount_point;
+    auto status = VerifyMountedImage(apex, mount_point);
     if (!status.ok()) {
-      if (umount2(mountPoint.c_str(), UMOUNT_NOFOLLOW) != 0) {
-        PLOG(ERROR) << "Failed to umount " << mountPoint;
+      if (umount2(mount_point.c_str(), UMOUNT_NOFOLLOW) != 0) {
+        PLOG(ERROR) << "Failed to umount " << mount_point;
       }
       return Error() << "Failed to verify " << full_path << ": "
                      << status.error();
     }
     // Time to accept the temporaries as good.
-    verityDev.Release();
-    loopbackDevice.CloseGood();
+    verity_dev.Release();
+    loopback_device.CloseGood();
     loop_for_hash.CloseGood();
 
     scope_guard.Disable();  // Accept the mount.
@@ -524,7 +524,7 @@
   }
   auto ret =
       MountPackageImpl(apex, mount_point, temp_device_name, hashtree_file,
-                       /* verifyImage = */ true, /* tempMount = */ true);
+                       /* verify_image = */ true, /* temp_mount = */ true);
   if (!ret.ok()) {
     LOG(DEBUG) << "Cleaning up " << hashtree_file;
     if (TEMP_FAILURE_RETRY(unlink(hashtree_file.c_str())) != 0) {
@@ -635,7 +635,7 @@
       std::string mount_point =
           apexd_private::GetPackageTempMountPoint(apex.GetManifest());
       Result<MountedApexData> mount_data =
-          apexd_private::getTempMountedApexData(apex.GetManifest().name());
+          apexd_private::GetTempMountedApexData(apex.GetManifest().name());
       if (!mount_data.ok()) {
         mount_data = VerifyAndTempMountPackage(apex, mount_point);
         if (!mount_data.ok()) {
@@ -723,7 +723,7 @@
   return {};
 }
 
-// A version of apex verification that happens on submitStagedSession.
+// A version of apex verification that happens on SubmitStagedSession.
 // This function contains checks that might be expensive to perform, e.g. temp
 // mounting a package and reading entire dm-verity device, and shouldn't be run
 // during boot.
@@ -740,14 +740,14 @@
 }
 
 template <typename VerifyApexFn>
-Result<std::vector<ApexFile>> verifyPackages(
+Result<std::vector<ApexFile>> VerifyPackages(
     const std::vector<std::string>& paths, const VerifyApexFn& verify_apex_fn) {
   Result<std::vector<ApexFile>> apex_files = OpenApexFiles(paths);
   if (!apex_files.ok()) {
     return apex_files.error();
   }
 
-  LOG(DEBUG) << "verifyPackages() for " << Join(paths, ',');
+  LOG(DEBUG) << "VerifyPackages() for " << Join(paths, ',');
 
   for (const ApexFile& apex_file : *apex_files) {
     Result<void> result = verify_apex_fn(apex_file);
@@ -758,12 +758,12 @@
   return std::move(*apex_files);
 }
 
-Result<ApexFile> verifySessionDir(const int session_id) {
-  std::string sessionDirPath = std::string(kStagedSessionsDir) + "/session_" +
-                               std::to_string(session_id);
-  LOG(INFO) << "Scanning " << sessionDirPath
+Result<ApexFile> VerifySessionDir(const int session_id) {
+  std::string session_dir_path = std::string(kStagedSessionsDir) + "/session_" +
+                                 std::to_string(session_id);
+  LOG(INFO) << "Scanning " << session_dir_path
             << " looking for packages to be validated";
-  Result<std::vector<std::string>> scan = FindApexFilesByName(sessionDirPath);
+  Result<std::vector<std::string>> scan = FindApexFilesByName(session_dir_path);
   if (!scan.ok()) {
     LOG(WARNING) << scan.error();
     return scan.error();
@@ -774,7 +774,7 @@
         "More than one APEX package found in the same session directory.");
   }
 
-  auto verified = verifyPackages(*scan, VerifyPackageInstall);
+  auto verified = VerifyPackages(*scan, VerifyPackageInstall);
   if (!verified.ok()) {
     return verified.error();
   }
@@ -798,7 +798,7 @@
   LOG(DEBUG) << "Initializing  backup of " << kActiveApexPackagesDataDir;
 
   // Previous restore might've delete backups folder.
-  auto create_status = createDirIfNeeded(kApexBackupDir, 0700);
+  auto create_status = CreateDirIfNeeded(kApexBackupDir, 0700);
   if (!create_status.ok()) {
     return Error() << "Backup failed : " << create_status.error();
   }
@@ -935,11 +935,12 @@
 
 }  // namespace
 
-Result<void> MountPackage(const ApexFile& apex, const std::string& mountPoint) {
+Result<void> MountPackage(const ApexFile& apex,
+                          const std::string& mount_point) {
   auto ret =
-      MountPackageImpl(apex, mountPoint, GetPackageId(apex.GetManifest()),
+      MountPackageImpl(apex, mount_point, GetPackageId(apex.GetManifest()),
                        GetHashTreeFileName(apex, /* is_new = */ false),
-                       /* verifyImage = */ false);
+                       /* verify_image = */ false);
   if (!ret.ok()) {
     return ret.error();
   }
@@ -958,7 +959,7 @@
   // If multiple temp mounts exist, ensure that all are unmounted.
   while (!finished_unmounting) {
     Result<MountedApexData> data =
-        apexd_private::getTempMountedApexData(manifest.name());
+        apexd_private::GetTempMountedApexData(manifest.name());
     if (!data.ok()) {
       finished_unmounting = true;
     } else {
@@ -969,7 +970,7 @@
   return {};
 }
 
-Result<MountedApexData> getTempMountedApexData(const std::string& package) {
+Result<MountedApexData> GetTempMountedApexData(const std::string& package) {
   bool found = false;
   Result<MountedApexData> mount_data;
   gMountedApexes.ForallMountedApexes(
@@ -1013,24 +1014,24 @@
 
 }  // namespace apexd_private
 
-Result<void> resumeRevertIfNeeded() {
+Result<void> ResumeRevertIfNeeded() {
   auto sessions =
       ApexSession::GetSessionsInState(SessionState::REVERT_IN_PROGRESS);
   if (sessions.empty()) {
     return {};
   }
-  return revertActiveSessions("");
+  return RevertActiveSessions("");
 }
 
-Result<void> activateSharedLibsPackage(const std::string& mountPoint) {
-  for (const auto& libPath : {"lib", "lib64"}) {
-    std::string apexLibPath = mountPoint + "/" + libPath;
-    auto lib_dir = PathExists(apexLibPath);
+Result<void> ActivateSharedLibsPackage(const std::string& mount_point) {
+  for (const auto& lib_path : {"lib", "lib64"}) {
+    std::string apex_lib_path = mount_point + "/" + lib_path;
+    auto lib_dir = PathExists(apex_lib_path);
     if (!lib_dir.ok() || !*lib_dir) {
       continue;
     }
 
-    auto iter = std::filesystem::directory_iterator(apexLibPath);
+    auto iter = std::filesystem::directory_iterator(apex_lib_path);
     std::error_code ec;
 
     while (iter != std::filesystem::end(iter)) {
@@ -1038,7 +1039,7 @@
       if (!lib_entry.is_directory()) {
         iter = iter.increment(ec);
         if (ec) {
-          return Error() << "Failed to scan " << apexLibPath << " : "
+          return Error() << "Failed to scan " << apex_lib_path << " : "
                          << ec.message();
         }
         continue;
@@ -1046,8 +1047,8 @@
 
       const auto library_name = lib_entry.path().filename();
       const std::string library_symlink_dir =
-          StringPrintf("%s/%s/%s/%s", kApexRoot, kApexSharedLibsSubDir, libPath,
-                       library_name.c_str());
+          StringPrintf("%s/%s/%s/%s", kApexRoot, kApexSharedLibsSubDir,
+                       lib_path, library_name.c_str());
 
       auto symlink_dir = PathExists(library_symlink_dir);
       if (!symlink_dir.ok() || !*symlink_dir) {
@@ -1069,8 +1070,28 @@
 
         auto hash_dir = PathExists(library_symlink_hash);
         if (hash_dir.ok() && *hash_dir) {
-          // TODO(b/161542925) : Handle symlink from different sharedlibs APEX
-          // with same hash value
+          // Compare file size for two library files with same name and hash
+          // value
+          auto existing_file_path =
+              library_symlink_hash + "/" + library_name.string();
+          auto existing_file_size = GetFileSize(existing_file_path);
+          if (!existing_file_size.ok()) {
+            return existing_file_size.error();
+          }
+
+          auto new_file_path =
+              lib_items.path().string() + "/" + library_name.string();
+          auto new_file_size = GetFileSize(new_file_path);
+          if (!new_file_size.ok()) {
+            return new_file_size.error();
+          }
+
+          if (*existing_file_size != *new_file_size) {
+            return Error() << "There are two libraries with same hash and "
+                              "different file size : "
+                           << existing_file_path << " and " << new_file_path;
+          }
+
           inner_iter = inner_iter.increment(ec);
           if (ec) {
             return Error() << "Failed to scan " << lib_entry.path().string()
@@ -1094,7 +1115,7 @@
 
       iter = iter.increment(ec);
       if (ec) {
-        return Error() << "Failed to scan " << apexLibPath << " : "
+        return Error() << "Failed to scan " << apex_lib_path << " : "
                        << ec.message();
       }
     }
@@ -1103,14 +1124,14 @@
   return {};
 }
 
-bool isValidPackageName(const std::string& package_name) {
+bool IsValidPackageName(const std::string& package_name) {
   return kBannedApexName.count(package_name) == 0;
 }
 
-Result<void> activatePackageImpl(const ApexFile& apex_file) {
+Result<void> ActivatePackageImpl(const ApexFile& apex_file) {
   const ApexManifest& manifest = apex_file.GetManifest();
 
-  if (!isValidPackageName(manifest.name())) {
+  if (!IsValidPackageName(manifest.name())) {
     return Errorf("Package name {} is not allowed.", manifest.name());
   }
 
@@ -1124,16 +1145,16 @@
     bool version_found_active = false;
     gMountedApexes.ForallMountedApexes(
         manifest.name(), [&](const MountedApexData& data, bool latest) {
-          Result<ApexFile> otherApex = ApexFile::Open(data.full_path);
-          if (!otherApex.ok()) {
+          Result<ApexFile> other_apex = ApexFile::Open(data.full_path);
+          if (!other_apex.ok()) {
             return;
           }
-          if (static_cast<uint64_t>(otherApex->GetManifest().version()) ==
+          if (static_cast<uint64_t>(other_apex->GetManifest().version()) ==
               new_version) {
             version_found_mounted = true;
             version_found_active = latest;
           }
-          if (static_cast<uint64_t>(otherApex->GetManifest().version()) >
+          if (static_cast<uint64_t>(other_apex->GetManifest().version()) >
               new_version) {
             is_newest_version = false;
           }
@@ -1150,12 +1171,13 @@
     }
   }
 
-  const std::string& mountPoint = apexd_private::GetPackageMountPoint(manifest);
+  const std::string& mount_point =
+      apexd_private::GetPackageMountPoint(manifest);
 
   if (!version_found_mounted) {
-    auto mountStatus = MountPackage(apex_file, mountPoint);
-    if (!mountStatus.ok()) {
-      return mountStatus;
+    auto mount_status = MountPackage(apex_file, mount_point);
+    if (!mount_status.ok()) {
+      return mount_status;
     }
   }
 
@@ -1173,7 +1195,7 @@
     // package provides shared libraries to other APEXs.
     if (is_newest_version) {
       const Result<void>& update_st = apexd_private::BindMount(
-          apexd_private::GetActiveMountPoint(manifest), mountPoint);
+          apexd_private::GetActiveMountPoint(manifest), mount_point);
       mounted_latest = update_st.has_value();
       if (!update_st.ok()) {
         return Error() << "Failed to update package " << manifest.name()
@@ -1187,9 +1209,10 @@
   }
 
   if (manifest.providesharedapexlibs()) {
-    const auto& handleSharedLibsApex = activateSharedLibsPackage(mountPoint);
-    if (!handleSharedLibsApex.ok()) {
-      return handleSharedLibsApex;
+    const auto& handle_shared_libs_apex =
+        ActivateSharedLibsPackage(mount_point);
+    if (!handle_shared_libs_apex.ok()) {
+      return handle_shared_libs_apex;
     }
   }
 
@@ -1199,28 +1222,28 @@
   return {};
 }
 
-Result<void> activatePackage(const std::string& full_path) {
+Result<void> ActivatePackage(const std::string& full_path) {
   LOG(INFO) << "Trying to activate " << full_path;
 
   Result<ApexFile> apex_file = ApexFile::Open(full_path);
   if (!apex_file.ok()) {
     return apex_file.error();
   }
-  return activatePackageImpl(*apex_file);
+  return ActivatePackageImpl(*apex_file);
 }
 
-Result<void> deactivatePackage(const std::string& full_path) {
+Result<void> DeactivatePackage(const std::string& full_path) {
   LOG(INFO) << "Trying to deactivate " << full_path;
 
-  Result<ApexFile> apexFile = ApexFile::Open(full_path);
-  if (!apexFile.ok()) {
-    return apexFile.error();
+  Result<ApexFile> apex_file = ApexFile::Open(full_path);
+  if (!apex_file.ok()) {
+    return apex_file.error();
   }
 
-  return UnmountPackage(*apexFile, /* allow_latest= */ true);
+  return UnmountPackage(*apex_file, /* allow_latest= */ true);
 }
 
-std::vector<ApexFile> getActivePackages() {
+std::vector<ApexFile> GetActivePackages() {
   std::vector<ApexFile> ret;
   gMountedApexes.ForallMountedApexes(
       [&](const std::string&, const MountedApexData& data, bool latest) {
@@ -1228,97 +1251,99 @@
           return;
         }
 
-        Result<ApexFile> apexFile = ApexFile::Open(data.full_path);
-        if (!apexFile.ok()) {
+        Result<ApexFile> apex_file = ApexFile::Open(data.full_path);
+        if (!apex_file.ok()) {
           return;
         }
-        ret.emplace_back(std::move(*apexFile));
+        ret.emplace_back(std::move(*apex_file));
       });
 
   return ret;
 }
 
-Result<void> emitApexInfoList(bool is_bootstrap) {
+Result<void> EmitApexInfoList(bool is_bootstrap) {
   // on a non-updatable device, we don't have APEX database to emit
   if (!android::sysprop::ApexProperties::updatable().value_or(false)) {
     return {};
   }
 
-  std::vector<com::android::apex::ApexInfo> apexInfos;
+  std::vector<com::android::apex::ApexInfo> apex_infos;
 
-  auto convertToAutogen = [&apexInfos](const ApexFile& apex, bool isActive) {
+  auto convert_to_autogen = [&apex_infos](const ApexFile& apex,
+                                          bool is_active) {
     auto& instance = ApexPreinstalledData::GetInstance();
 
-    auto preinstalledPath =
+    auto preinstalled_path =
         instance.GetPreinstalledPath(apex.GetManifest().name());
-    std::optional<std::string> preinstalledModulePath;
-    if (preinstalledPath.ok()) {
-      preinstalledModulePath = *preinstalledPath;
+    std::optional<std::string> preinstalled_module_path;
+    if (preinstalled_path.ok()) {
+      preinstalled_module_path = *preinstalled_path;
     }
-    com::android::apex::ApexInfo apexInfo(
-        apex.GetManifest().name(), apex.GetPath(), preinstalledModulePath,
+    com::android::apex::ApexInfo apex_info(
+        apex.GetManifest().name(), apex.GetPath(), preinstalled_module_path,
         apex.GetManifest().version(), apex.GetManifest().versionname(),
-        instance.IsPreInstalledApex(apex), isActive);
-    apexInfos.emplace_back(apexInfo);
+        instance.IsPreInstalledApex(apex), is_active);
+    apex_infos.emplace_back(apex_info);
   };
 
   // Apexd runs both in "bootstrap" and "default" mount namespace.
   // To expose /apex/apex-info-list.xml separately in each mount namespaces,
   // we write /apex/.<namespace>-apex-info-list .xml file first and then
   // bind mount it to the canonical file (/apex/apex-info-list.xml).
-  const std::string fileName =
+  const std::string file_name =
       fmt::format("{}/.{}-{}", kApexRoot,
                   is_bootstrap ? "bootstrap" : "default", kApexInfoList);
 
   unique_fd fd(TEMP_FAILURE_RETRY(
-      open(fileName.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644)));
+      open(file_name.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644)));
   if (fd.get() == -1) {
-    return ErrnoErrorf("Can't open {}", fileName);
+    return ErrnoErrorf("Can't open {}", file_name);
   }
 
-  const auto& active = getActivePackages();
+  const auto& active = GetActivePackages();
   for (const auto& apex : active) {
-    convertToAutogen(apex, true /* isActive */);
+    convert_to_autogen(apex, true /* is_active */);
   }
   // we skip for non-activated built-in apexes in bootstrap mode
   // in order to avoid boottime increase
   if (!is_bootstrap) {
-    for (const auto& apex : getFactoryPackages()) {
+    for (const auto& apex : GetFactoryPackages()) {
       const auto& same_path = [&apex](const auto& o) {
         return o.GetPath() == apex.GetPath();
       };
       if (std::find_if(active.begin(), active.end(), same_path) ==
           active.end()) {
-        convertToAutogen(apex, false /* isActive */);
+        convert_to_autogen(apex, false /* is_active */);
       }
     }
   }
 
   std::stringstream xml;
-  com::android::apex::ApexInfoList apexInfoList(apexInfos);
-  com::android::apex::write(xml, apexInfoList);
+  com::android::apex::ApexInfoList apex_info_list(apex_infos);
+  com::android::apex::write(xml, apex_info_list);
 
   if (!android::base::WriteStringToFd(xml.str(), fd)) {
-    return ErrnoErrorf("Can't write to {}", fileName);
+    return ErrnoErrorf("Can't write to {}", file_name);
   }
 
   fd.reset();
 
-  const std::string mountPoint = fmt::format("{}/{}", kApexRoot, kApexInfoList);
-  if (access(mountPoint.c_str(), F_OK) != 0) {
-    close(open(mountPoint.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC,
+  const std::string mount_point =
+      fmt::format("{}/{}", kApexRoot, kApexInfoList);
+  if (access(mount_point.c_str(), F_OK) != 0) {
+    close(open(mount_point.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC,
                0644));
   }
-  if (mount(fileName.c_str(), mountPoint.c_str(), nullptr, MS_BIND, nullptr) ==
-      -1) {
-    return ErrnoErrorf("Can't bind mount {} to {}", fileName, mountPoint);
+  if (mount(file_name.c_str(), mount_point.c_str(), nullptr, MS_BIND,
+            nullptr) == -1) {
+    return ErrnoErrorf("Can't bind mount {} to {}", file_name, mount_point);
   }
-  return RestoreconPath(fileName);
+  return RestoreconPath(file_name);
 }
 
 namespace {
 std::unordered_map<std::string, uint64_t> GetActivePackagesMap() {
-  std::vector<ApexFile> active_packages = getActivePackages();
+  std::vector<ApexFile> active_packages = GetActivePackages();
   std::unordered_map<std::string, uint64_t> ret;
   for (const auto& package : active_packages) {
     const ApexManifest& manifest = package.GetManifest();
@@ -1329,7 +1354,7 @@
 
 }  // namespace
 
-std::vector<ApexFile> getFactoryPackages() {
+std::vector<ApexFile> GetFactoryPackages() {
   std::vector<ApexFile> ret;
   for (const auto& dir : kApexPackageBuiltinDirs) {
     auto apex_files = FindApexFilesByName(dir);
@@ -1349,8 +1374,8 @@
   return ret;
 }
 
-Result<ApexFile> getActivePackage(const std::string& packageName) {
-  std::vector<ApexFile> packages = getActivePackages();
+Result<ApexFile> GetActivePackage(const std::string& packageName) {
+  std::vector<ApexFile> packages = GetActivePackages();
   for (ApexFile& apex : packages) {
     if (apex.GetManifest().name() == packageName) {
       return std::move(apex);
@@ -1365,7 +1390,7 @@
  *
  * Returns without error only if session was successfully aborted.
  **/
-Result<void> abortStagedSession(int session_id) {
+Result<void> AbortStagedSession(int session_id) {
   auto session = ApexSession::GetSession(session_id);
   if (!session.ok()) {
     return Error() << "No session found with id " << session_id;
@@ -1426,7 +1451,7 @@
       }
     }
 
-    if (auto res = activatePackageImpl(apex); !res.ok()) {
+    if (auto res = ActivatePackageImpl(apex); !res.ok()) {
       LOG(ERROR) << "Failed to activate " << apex.GetPath() << " : "
                  << res.error();
       failed_cnt++;
@@ -1449,7 +1474,7 @@
 
 }  // namespace
 
-Result<void> scanPackagesDirAndActivate(const char* apex_package_dir) {
+Result<void> ScanPackagesDirAndActivate(const char* apex_package_dir) {
   auto apexes = ScanApexFiles(apex_package_dir);
   if (!apexes.ok()) {
     return apexes.error();
@@ -1461,14 +1486,14 @@
  * Snapshots data from base_dir/apexdata/<apex name> to
  * base_dir/apexrollback/<rollback id>/<apex name>.
  */
-Result<void> snapshotDataDirectory(const std::string& base_dir,
+Result<void> SnapshotDataDirectory(const std::string& base_dir,
                                    const int rollback_id,
                                    const std::string& apex_name,
                                    bool pre_restore = false) {
   auto rollback_path =
       StringPrintf("%s/%s/%d%s", base_dir.c_str(), kApexSnapshotSubDir,
                    rollback_id, pre_restore ? kPreRestoreSuffix : "");
-  const Result<void> result = createDirIfNeeded(rollback_path, 0700);
+  const Result<void> result = CreateDirIfNeeded(rollback_path, 0700);
   if (!result.ok()) {
     return Error() << "Failed to create snapshot directory for rollback "
                    << rollback_id << " : " << result.error();
@@ -1486,7 +1511,7 @@
  * to base_dir/apexdata/<apex name>.
  * Note the snapshot will be deleted after restoration succeeded.
  */
-Result<void> restoreDataDirectory(const std::string& base_dir,
+Result<void> RestoreDataDirectory(const std::string& base_dir,
                                   const int rollback_id,
                                   const std::string& apex_name,
                                   bool pre_restore = false) {
@@ -1510,12 +1535,12 @@
   return {};
 }
 
-void snapshotOrRestoreDeIfNeeded(const std::string& base_dir,
+void SnapshotOrRestoreDeIfNeeded(const std::string& base_dir,
                                  const ApexSession& session) {
   if (session.HasRollbackEnabled()) {
     for (const auto& apex_name : session.GetApexNames()) {
       Result<void> result =
-          snapshotDataDirectory(base_dir, session.GetRollbackId(), apex_name);
+          SnapshotDataDirectory(base_dir, session.GetRollbackId(), apex_name);
       if (!result.ok()) {
         LOG(ERROR) << "Snapshot failed for " << apex_name << ": "
                    << result.error();
@@ -1525,11 +1550,11 @@
     for (const auto& apex_name : session.GetApexNames()) {
       if (!gInFsCheckpointMode) {
         // Snapshot before restore so this rollback can be reverted.
-        snapshotDataDirectory(base_dir, session.GetRollbackId(), apex_name,
+        SnapshotDataDirectory(base_dir, session.GetRollbackId(), apex_name,
                               true /* pre_restore */);
       }
       Result<void> result =
-          restoreDataDirectory(base_dir, session.GetRollbackId(), apex_name);
+          RestoreDataDirectory(base_dir, session.GetRollbackId(), apex_name);
       if (!result.ok()) {
         LOG(ERROR) << "Restore of data failed for " << apex_name << ": "
                    << result.error();
@@ -1538,15 +1563,15 @@
   }
 }
 
-void snapshotOrRestoreDeSysData() {
+void SnapshotOrRestoreDeSysData() {
   auto sessions = ApexSession::GetSessionsInState(SessionState::ACTIVATED);
 
   for (const ApexSession& session : sessions) {
-    snapshotOrRestoreDeIfNeeded(kDeSysDataDir, session);
+    SnapshotOrRestoreDeIfNeeded(kDeSysDataDir, session);
   }
 }
 
-int snapshotOrRestoreDeUserData() {
+int SnapshotOrRestoreDeUserData() {
   auto user_dirs = GetDeUserDirs();
 
   if (!user_dirs.ok()) {
@@ -1558,47 +1583,40 @@
 
   for (const ApexSession& session : sessions) {
     for (const auto& user_dir : *user_dirs) {
-      snapshotOrRestoreDeIfNeeded(user_dir, session);
+      SnapshotOrRestoreDeIfNeeded(user_dir, session);
     }
   }
 
   return 0;
 }
 
-Result<ino_t> snapshotCeData(const int user_id, const int rollback_id,
-                             const std::string& apex_name) {
+Result<void> SnapshotCeData(const int user_id, const int rollback_id,
+                            const std::string& apex_name) {
   auto base_dir = StringPrintf("%s/%d", kCeDataDir, user_id);
-  Result<void> result = snapshotDataDirectory(base_dir, rollback_id, apex_name);
-  if (!result.ok()) {
-    return result.error();
-  }
-  auto ce_snapshot_path =
-      StringPrintf("%s/%s/%d/%s", base_dir.c_str(), kApexSnapshotSubDir,
-                   rollback_id, apex_name.c_str());
-  return get_path_inode(ce_snapshot_path);
+  return SnapshotDataDirectory(base_dir, rollback_id, apex_name);
 }
 
-Result<void> restoreCeData(const int user_id, const int rollback_id,
+Result<void> RestoreCeData(const int user_id, const int rollback_id,
                            const std::string& apex_name) {
   auto base_dir = StringPrintf("%s/%d", kCeDataDir, user_id);
-  return restoreDataDirectory(base_dir, rollback_id, apex_name);
+  return RestoreDataDirectory(base_dir, rollback_id, apex_name);
 }
 
 //  Migrates sessions directory from /data/apex/sessions to
 //  /metadata/apex/sessions, if necessary.
-Result<void> migrateSessionsDirIfNeeded() {
+Result<void> MigrateSessionsDirIfNeeded() {
   return ApexSession::MigrateToMetadataSessionsDir();
 }
 
-Result<void> destroySnapshots(const std::string& base_dir,
+Result<void> DestroySnapshots(const std::string& base_dir,
                               const int rollback_id) {
   auto path = StringPrintf("%s/%s/%d", base_dir.c_str(), kApexSnapshotSubDir,
                            rollback_id);
   return DeleteDir(path);
 }
 
-Result<void> destroyDeSnapshots(const int rollback_id) {
-  destroySnapshots(kDeSysDataDir, rollback_id);
+Result<void> DestroyDeSnapshots(const int rollback_id) {
+  DestroySnapshots(kDeSysDataDir, rollback_id);
 
   auto user_dirs = GetDeUserDirs();
   if (!user_dirs.ok()) {
@@ -1606,22 +1624,28 @@
   }
 
   for (const auto& user_dir : *user_dirs) {
-    destroySnapshots(user_dir, rollback_id);
+    DestroySnapshots(user_dir, rollback_id);
   }
 
   return {};
 }
 
+Result<void> DestroyCeSnapshots(const int user_id, const int rollback_id) {
+  auto path = StringPrintf("%s/%d/%s/%d", kCeDataDir, user_id,
+                           kApexSnapshotSubDir, rollback_id);
+  return DeleteDir(path);
+}
+
 /**
  * Deletes all credential-encrypted snapshots for the given user, except for
  * those listed in retain_rollback_ids.
  */
-Result<void> destroyCeSnapshotsNotSpecified(
+Result<void> DestroyCeSnapshotsNotSpecified(
     int user_id, const std::vector<int>& retain_rollback_ids) {
   auto snapshot_root =
       StringPrintf("%s/%d/%s", kCeDataDir, user_id, kApexSnapshotSubDir);
   auto snapshot_dirs = GetSubdirs(snapshot_root);
-  if (!snapshot_dirs) {
+  if (!snapshot_dirs.ok()) {
     return Error() << "Error reading snapshot dirs " << snapshot_dirs.error();
   }
 
@@ -1633,7 +1657,7 @@
         std::find(retain_rollback_ids.begin(), retain_rollback_ids.end(),
                   snapshot_id) == retain_rollback_ids.end()) {
       Result<void> result = DeleteDir(snapshot_dir);
-      if (!result) {
+      if (!result.ok()) {
         return Error() << "Destroy CE snapshot failed for " << snapshot_dir
                        << " : " << result.error();
       }
@@ -1642,14 +1666,14 @@
   return {};
 }
 
-void restorePreRestoreSnapshotsIfPresent(const std::string& base_dir,
+void RestorePreRestoreSnapshotsIfPresent(const std::string& base_dir,
                                          const ApexSession& session) {
   auto pre_restore_snapshot_path =
       StringPrintf("%s/%s/%d%s", base_dir.c_str(), kApexSnapshotSubDir,
                    session.GetRollbackId(), kPreRestoreSuffix);
   if (PathExists(pre_restore_snapshot_path).ok()) {
     for (const auto& apex_name : session.GetApexNames()) {
-      Result<void> result = restoreDataDirectory(
+      Result<void> result = RestoreDataDirectory(
           base_dir, session.GetRollbackId(), apex_name, true /* pre_restore */);
       if (!result.ok()) {
         LOG(ERROR) << "Restore of pre-restore snapshot failed for " << apex_name
@@ -1665,8 +1689,8 @@
   }
 }
 
-void restoreDePreRestoreSnapshotsIfPresent(const ApexSession& session) {
-  restorePreRestoreSnapshotsIfPresent(kDeSysDataDir, session);
+void RestoreDePreRestoreSnapshotsIfPresent(const ApexSession& session) {
+  RestorePreRestoreSnapshotsIfPresent(kDeSysDataDir, session);
 
   auto user_dirs = GetDeUserDirs();
   if (!user_dirs.ok()) {
@@ -1675,11 +1699,11 @@
   }
 
   for (const auto& user_dir : *user_dirs) {
-    restorePreRestoreSnapshotsIfPresent(user_dir, session);
+    RestorePreRestoreSnapshotsIfPresent(user_dir, session);
   }
 }
 
-void deleteDePreRestoreSnapshots(const std::string& base_dir,
+void DeleteDePreRestoreSnapshots(const std::string& base_dir,
                                  const ApexSession& session) {
   auto pre_restore_snapshot_path =
       StringPrintf("%s/%s/%d%s", base_dir.c_str(), kApexSnapshotSubDir,
@@ -1690,8 +1714,8 @@
   }
 }
 
-void deleteDePreRestoreSnapshots(const ApexSession& session) {
-  deleteDePreRestoreSnapshots(kDeSysDataDir, session);
+void DeleteDePreRestoreSnapshots(const ApexSession& session) {
+  DeleteDePreRestoreSnapshots(kDeSysDataDir, session);
 
   auto user_dirs = GetDeUserDirs();
   if (!user_dirs.ok()) {
@@ -1700,41 +1724,41 @@
   }
 
   for (const auto& user_dir : *user_dirs) {
-    deleteDePreRestoreSnapshots(user_dir, session);
+    DeleteDePreRestoreSnapshots(user_dir, session);
   }
 }
 
-void onBootCompleted() {
-  ApexdLifecycle::getInstance().markBootCompleted();
-  bootCompletedCleanup();
+void OnBootCompleted() {
+  ApexdLifecycle::GetInstance().MarkBootCompleted();
+  BootCompletedCleanup();
 }
 
-void scanStagedSessionsDirAndStage() {
+void ScanStagedSessionsDirAndStage() {
   LOG(INFO) << "Scanning " << ApexSession::GetSessionsDir()
             << " looking for sessions to be activated.";
 
-  auto sessionsToActivate =
+  auto sessions_to_activate =
       ApexSession::GetSessionsInState(SessionState::STAGED);
   if (gSupportsFsCheckpoints) {
     // A session that is in the ACTIVATED state should still be re-activated if
     // fs checkpointing is supported. In this case, a session may be in the
     // ACTIVATED state yet the data/apex/active directory may have been
     // reverted. The session should be reverted in this scenario.
-    auto activatedSessions =
+    auto activated_sessions =
         ApexSession::GetSessionsInState(SessionState::ACTIVATED);
-    sessionsToActivate.insert(sessionsToActivate.end(),
-                              activatedSessions.begin(),
-                              activatedSessions.end());
+    sessions_to_activate.insert(sessions_to_activate.end(),
+                                activated_sessions.begin(),
+                                activated_sessions.end());
   }
 
-  for (auto& session : sessionsToActivate) {
-    auto sessionId = session.GetId();
+  for (auto& session : sessions_to_activate) {
+    auto session_id = session.GetId();
 
     auto session_failed_fn = [&]() {
-      LOG(WARNING) << "Marking session " << sessionId << " as failed.";
+      LOG(WARNING) << "Marking session " << session_id << " as failed.";
       auto st = session.UpdateStateAndCommit(SessionState::ACTIVATION_FAILED);
       if (!st.ok()) {
-        LOG(WARNING) << "Failed to mark session " << sessionId
+        LOG(WARNING) << "Failed to mark session " << session_id
                      << " as failed : " << st.error();
       }
     };
@@ -1746,52 +1770,52 @@
       continue;
     }
 
-    std::vector<std::string> dirsToScan;
+    std::vector<std::string> dirs_to_scan;
     if (session.GetChildSessionIds().empty()) {
-      dirsToScan.push_back(std::string(kStagedSessionsDir) + "/session_" +
-                           std::to_string(sessionId));
+      dirs_to_scan.push_back(std::string(kStagedSessionsDir) + "/session_" +
+                             std::to_string(session_id));
     } else {
-      for (auto childSessionId : session.GetChildSessionIds()) {
-        dirsToScan.push_back(std::string(kStagedSessionsDir) + "/session_" +
-                             std::to_string(childSessionId));
+      for (auto child_session_id : session.GetChildSessionIds()) {
+        dirs_to_scan.push_back(std::string(kStagedSessionsDir) + "/session_" +
+                               std::to_string(child_session_id));
       }
     }
 
     std::vector<std::string> apexes;
-    bool scanSuccessful = true;
-    for (const auto& dirToScan : dirsToScan) {
-      Result<std::vector<std::string>> scan = FindApexFilesByName(dirToScan);
+    bool scan_successful = true;
+    for (const auto& dir_to_scan : dirs_to_scan) {
+      Result<std::vector<std::string>> scan = FindApexFilesByName(dir_to_scan);
       if (!scan.ok()) {
         LOG(WARNING) << scan.error();
-        scanSuccessful = false;
+        scan_successful = false;
         break;
       }
 
       if (scan->size() > 1) {
         LOG(WARNING) << "More than one APEX package found in the same session "
-                     << "directory " << dirToScan << ", skipping activation.";
-        scanSuccessful = false;
+                     << "directory " << dir_to_scan << ", skipping activation.";
+        scan_successful = false;
         break;
       }
 
       if (scan->empty()) {
-        LOG(WARNING) << "No APEX packages found while scanning " << dirToScan
-                     << " session id: " << sessionId << ".";
-        scanSuccessful = false;
+        LOG(WARNING) << "No APEX packages found while scanning " << dir_to_scan
+                     << " session id: " << session_id << ".";
+        scan_successful = false;
         break;
       }
       apexes.push_back(std::move((*scan)[0]));
     }
 
-    if (!scanSuccessful) {
+    if (!scan_successful) {
       continue;
     }
 
     // Run postinstall, if necessary.
-    Result<void> postinstall_status = postinstallPackages(apexes);
+    Result<void> postinstall_status = PostinstallPackages(apexes);
     if (!postinstall_status.ok()) {
       LOG(ERROR) << "Postinstall failed for session "
-                 << std::to_string(sessionId) << ": "
+                 << std::to_string(session_id) << ": "
                  << postinstall_status.error();
       continue;
     }
@@ -1806,7 +1830,7 @@
       session.AddApexName(apex_file->GetManifest().name());
     }
 
-    const Result<void> result = stagePackages(apexes);
+    const Result<void> result = StagePackages(apexes);
     if (!result.ok()) {
       LOG(ERROR) << "Activation failed for packages " << Join(apexes, ',')
                  << ": " << result.error();
@@ -1824,21 +1848,21 @@
   }
 }
 
-Result<void> preinstallPackages(const std::vector<std::string>& paths) {
+Result<void> PreinstallPackages(const std::vector<std::string>& paths) {
   Result<std::vector<ApexFile>> apex_files = OpenApexFiles(paths);
   if (!apex_files.ok()) {
     return apex_files.error();
   }
-  LOG(DEBUG) << "preinstallPackages() for " << Join(paths, ',');
+  LOG(DEBUG) << "PreinstallPackages() for " << Join(paths, ',');
   return PreinstallPackages(*apex_files);
 }
 
-Result<void> postinstallPackages(const std::vector<std::string>& paths) {
+Result<void> PostinstallPackages(const std::vector<std::string>& paths) {
   Result<std::vector<ApexFile>> apex_files = OpenApexFiles(paths);
   if (!apex_files.ok()) {
     return apex_files.error();
   }
-  LOG(DEBUG) << "postinstallPackages() for " << Join(paths, ',');
+  LOG(DEBUG) << "PostinstallPackages() for " << Join(paths, ',');
   return PostinstallPackages(*apex_files);
 }
 
@@ -1851,24 +1875,24 @@
 
 }  // namespace
 
-Result<void> stagePackages(const std::vector<std::string>& tmpPaths) {
-  if (tmpPaths.empty()) {
+Result<void> StagePackages(const std::vector<std::string>& tmp_paths) {
+  if (tmp_paths.empty()) {
     return Errorf("Empty set of inputs");
   }
-  LOG(DEBUG) << "stagePackages() for " << Join(tmpPaths, ',');
+  LOG(DEBUG) << "StagePackages() for " << Join(tmp_paths, ',');
 
   // Note: this function is temporary. As such the code is not optimized, e.g.,
   //       it will open ApexFiles multiple times.
 
   // 1) Verify all packages.
-  auto verify_status = verifyPackages(tmpPaths, VerifyPackageBoot);
+  auto verify_status = VerifyPackages(tmp_paths, VerifyPackageBoot);
   if (!verify_status.ok()) {
     return verify_status.error();
   }
 
   // Make sure that kActiveApexPackagesDataDir exists.
   auto create_dir_status =
-      createDirIfNeeded(std::string(kActiveApexPackagesDataDir), 0755);
+      CreateDirIfNeeded(std::string(kActiveApexPackagesDataDir), 0755);
   if (!create_dir_status.ok()) {
     return create_dir_status.error();
   }
@@ -1893,7 +1917,7 @@
   auto scope_guard = android::base::make_scope_guard(deleter);
 
   std::unordered_set<std::string> staged_packages;
-  for (const std::string& path : tmpPaths) {
+  for (const std::string& path : tmp_paths) {
     Result<ApexFile> apex_file = ApexFile::Open(path);
     if (!apex_file.ok()) {
       return apex_file.error();
@@ -1937,11 +1961,11 @@
   return RemovePreviouslyActiveApexFiles(staged_packages, staged_files);
 }
 
-Result<void> unstagePackages(const std::vector<std::string>& paths) {
+Result<void> UnstagePackages(const std::vector<std::string>& paths) {
   if (paths.empty()) {
     return Errorf("Empty set of inputs");
   }
-  LOG(DEBUG) << "unstagePackages() for " << Join(paths, ',');
+  LOG(DEBUG) << "UnstagePackages() for " << Join(paths, ',');
 
   for (const std::string& path : paths) {
     auto apex = ApexFile::Open(path);
@@ -1971,16 +1995,16 @@
  * Also, we need to put staged sessions in /data/apex/sessions in REVERTED state
  * so that they do not get activated on next reboot.
  */
-Result<void> revertActiveSessions(const std::string& crashing_native_process) {
+Result<void> RevertActiveSessions(const std::string& crashing_native_process) {
   // First check whenever there is anything to revert. If there is none, then
   // fail. This prevents apexd from boot looping a device in case a native
   // process is crashing and there are no apex updates.
-  auto activeSessions = ApexSession::GetActiveSessions();
-  if (activeSessions.empty()) {
+  auto active_sessions = ApexSession::GetActiveSessions();
+  if (active_sessions.empty()) {
     return Error() << "Revert requested, when there are no active sessions.";
   }
 
-  for (auto& session : activeSessions) {
+  for (auto& session : active_sessions) {
     if (!crashing_native_process.empty()) {
       session.SetCrashingNativeProcess(crashing_native_process);
     }
@@ -1993,9 +2017,9 @@
   }
 
   if (!gInFsCheckpointMode) {
-    auto restoreStatus = RestoreActivePackages();
-    if (!restoreStatus.ok()) {
-      for (auto& session : activeSessions) {
+    auto restore_status = RestoreActivePackages();
+    if (!restore_status.ok()) {
+      for (auto& session : active_sessions) {
         auto st = session.UpdateStateAndCommit(SessionState::REVERT_FAILED);
         LOG(DEBUG) << "Marking " << session << " as failed to revert";
         if (!st.ok()) {
@@ -2003,17 +2027,17 @@
                        << " as failed to revert : " << st.error();
         }
       }
-      return restoreStatus;
+      return restore_status;
     }
   } else {
     LOG(INFO) << "Not restoring active packages in checkpoint mode.";
   }
 
-  for (auto& session : activeSessions) {
+  for (auto& session : active_sessions) {
     if (!gInFsCheckpointMode && session.IsRollback()) {
       // If snapshots have already been restored, undo that by restoring the
       // pre-restore snapshot.
-      restoreDePreRestoreSnapshotsIfPresent(session);
+      RestoreDePreRestoreSnapshotsIfPresent(session);
     }
 
     auto status = session.UpdateStateAndCommit(SessionState::REVERTED);
@@ -2026,9 +2050,9 @@
   return {};
 }
 
-Result<void> revertActiveSessionsAndReboot(
+Result<void> RevertActiveSessionsAndReboot(
     const std::string& crashing_native_process) {
-  auto status = revertActiveSessions(crashing_native_process);
+  auto status = RevertActiveSessions(crashing_native_process);
   if (!status.ok()) {
     return status;
   }
@@ -2044,28 +2068,28 @@
   return {};
 }
 
-Result<void> createSharedLibsApexDir() {
+Result<void> CreateSharedLibsApexDir() {
   // Creates /apex/sharedlibs/lib{,64} for SharedLibs APEXes.
-  std::string sharedLibsSubDir =
+  std::string shared_libs_sub_dir =
       StringPrintf("%s/%s", kApexRoot, kApexSharedLibsSubDir);
-  auto dir_exists = PathExists(sharedLibsSubDir);
+  auto dir_exists = PathExists(shared_libs_sub_dir);
   if (!dir_exists.ok() || !*dir_exists) {
     std::error_code error_code;
-    std::filesystem::create_directory(sharedLibsSubDir, error_code);
+    std::filesystem::create_directory(shared_libs_sub_dir, error_code);
     if (error_code) {
-      return Error() << "Failed to create directory " << sharedLibsSubDir
+      return Error() << "Failed to create directory " << shared_libs_sub_dir
                      << ": " << error_code.message();
     }
   }
-  for (const auto& libPath : {"lib", "lib64"}) {
-    std::string apexLibPath =
-        StringPrintf("%s/%s", sharedLibsSubDir.c_str(), libPath);
-    auto lib_dir_exists = PathExists(apexLibPath);
+  for (const auto& lib_path : {"lib", "lib64"}) {
+    std::string apex_lib_path =
+        StringPrintf("%s/%s", shared_libs_sub_dir.c_str(), lib_path);
+    auto lib_dir_exists = PathExists(apex_lib_path);
     if (!lib_dir_exists.ok() || !*lib_dir_exists) {
       std::error_code error_code;
-      std::filesystem::create_directory(apexLibPath, error_code);
+      std::filesystem::create_directory(apex_lib_path, error_code);
       if (error_code) {
-        return Error() << "Failed to create directory " << apexLibPath << ": "
+        return Error() << "Failed to create directory " << apex_lib_path << ": "
                        << error_code.message();
       }
     }
@@ -2074,11 +2098,11 @@
   return {};
 }
 
-int onBootstrap() {
-  Result<void> preAllocate = preAllocateLoopDevices();
-  if (!preAllocate.ok()) {
+int OnBootstrap() {
+  Result<void> pre_allocate = PreAllocateLoopDevices();
+  if (!pre_allocate.ok()) {
     LOG(ERROR) << "Failed to pre-allocate loop devices : "
-               << preAllocate.error();
+               << pre_allocate.error();
   }
 
   ApexPreinstalledData& instance = ApexPreinstalledData::GetInstance();
@@ -2091,7 +2115,7 @@
   }
 
   // Create directories for APEX shared libraries.
-  auto sharedlibs_apex_dir = createSharedLibsApexDir();
+  auto sharedlibs_apex_dir = CreateSharedLibsApexDir();
   if (!sharedlibs_apex_dir.ok()) {
     LOG(ERROR) << sharedlibs_apex_dir.error();
     return 1;
@@ -2108,7 +2132,7 @@
     }
     std::copy_if(std::make_move_iterator(scan->begin()),
                  std::make_move_iterator(scan->end()),
-                 std::back_inserter(bootstrap_apexes), isBootstrapApex);
+                 std::back_inserter(bootstrap_apexes), IsBootstrapApex);
   }
 
   // Now activate bootstrap apexes.
@@ -2117,19 +2141,19 @@
     return 1;
   }
 
-  onAllPackagesActivated(/*is_bootstrap=*/true);
+  OnAllPackagesActivated(/*is_bootstrap=*/true);
   LOG(INFO) << "Bootstrapping done";
   return 0;
 }
 
-Result<void> remountApexFile(const std::string& path) {
-  if (auto ret = deactivatePackage(path); !ret.ok()) {
+Result<void> RemountApexFile(const std::string& path) {
+  if (auto ret = DeactivatePackage(path); !ret.ok()) {
     return ret;
   }
-  return activatePackage(path);
+  return ActivatePackage(path);
 }
 
-void initializeVold(CheckpointInterface* checkpoint_service) {
+void InitializeVold(CheckpointInterface* checkpoint_service) {
   if (checkpoint_service != nullptr) {
     gVoldService = checkpoint_service;
     Result<bool> supports_fs_checkpoints =
@@ -2152,8 +2176,8 @@
   }
 }
 
-void initialize(CheckpointInterface* checkpoint_service) {
-  initializeVold(checkpoint_service);
+void Initialize(CheckpointInterface* checkpoint_service) {
+  InitializeVold(checkpoint_service);
   ApexPreinstalledData& instance = ApexPreinstalledData::GetInstance();
   Result<void> status = instance.Initialize(kApexPackageBuiltinDirs);
   if (!status.ok()) {
@@ -2164,7 +2188,7 @@
   gMountedApexes.PopulateFromMounts();
 }
 
-void onStart() {
+void OnStart() {
   LOG(INFO) << "Marking APEXd as starting";
   if (!android::base::SetProperty(kApexStatusSysprop, kApexStatusStarting)) {
     PLOG(ERROR) << "Failed to set " << kApexStatusSysprop << " to "
@@ -2183,20 +2207,20 @@
       LOG(INFO) << "Exceeded number of session retries ("
                 << kNumRetriesWhenCheckpointingEnabled
                 << "). Starting a revert";
-      revertActiveSessions("");
+      RevertActiveSessions("");
     }
   }
 
   // Create directories for APEX shared libraries.
-  auto sharedlibs_apex_dir = createSharedLibsApexDir();
+  auto sharedlibs_apex_dir = CreateSharedLibsApexDir();
   if (!sharedlibs_apex_dir.ok()) {
     LOG(ERROR) << sharedlibs_apex_dir.error();
   }
 
   // Activate APEXes from /data/apex. If one in the directory is newer than the
   // system one, the new one will eclipse the old one.
-  scanStagedSessionsDirAndStage();
-  auto status = resumeRevertIfNeeded();
+  ScanStagedSessionsDirAndStage();
+  auto status = ResumeRevertIfNeeded();
   if (!status.ok()) {
     LOG(ERROR) << "Failed to resume revert : " << status.error();
   }
@@ -2205,7 +2229,7 @@
   if (auto scan = ScanApexFiles(kActiveApexPackagesDataDir); !scan.ok()) {
     LOG(ERROR) << "Failed to scan packages from " << kActiveApexPackagesDataDir
                << " : " << scan.error();
-    if (auto revert = revertActiveSessionsAndReboot(""); !revert.ok()) {
+    if (auto revert = RevertActiveSessionsAndReboot(""); !revert.ok()) {
       LOG(ERROR) << "Failed to revert : " << revert.error();
     }
   } else {
@@ -2221,10 +2245,18 @@
                  std::back_inserter(data_apex), filter_fn);
   }
 
+  if (data_apex.size() > 0) {
+    Result<void> pre_allocate = loop::PreAllocateLoopDevices(data_apex.size());
+    if (!pre_allocate.ok()) {
+      LOG(ERROR) << "Failed to pre-allocate loop devices : "
+                 << pre_allocate.error();
+    }
+  }
+
   if (auto ret = ActivateApexPackages(data_apex); !ret.ok()) {
     LOG(ERROR) << "Failed to activate packages from "
-               << kActiveApexPackagesDataDir << " : " << status.error();
-    Result<void> revert_status = revertActiveSessionsAndReboot("");
+               << kActiveApexPackagesDataDir << " : " << ret.error();
+    Result<void> revert_status = RevertActiveSessionsAndReboot("");
     if (!revert_status.ok()) {
       LOG(ERROR) << "Failed to revert : " << revert_status.error()
                  << kActiveApexPackagesDataDir << " : " << ret.error();
@@ -2237,7 +2269,7 @@
     if (!scan_status.ok()) {
       LOG(ERROR) << "Failed to scan APEX packages from " << dir << " : "
                  << scan_status.error();
-      if (auto revert = revertActiveSessionsAndReboot(""); !revert.ok()) {
+      if (auto revert = RevertActiveSessionsAndReboot(""); !revert.ok()) {
         LOG(ERROR) << "Failed to revert : " << revert.error();
       }
     }
@@ -2249,11 +2281,11 @@
   }
 
   // Now that APEXes are mounted, snapshot or restore DE_sys data.
-  snapshotOrRestoreDeSysData();
+  SnapshotOrRestoreDeSysData();
 }
 
-void onAllPackagesActivated(bool is_bootstrap) {
-  auto result = emitApexInfoList(is_bootstrap);
+void OnAllPackagesActivated(bool is_bootstrap) {
+  auto result = EmitApexInfoList(is_bootstrap);
   if (!result.ok()) {
     LOG(ERROR) << "cannot emit apex info list: " << result.error();
   }
@@ -2276,7 +2308,7 @@
   }
 }
 
-void onAllPackagesReady() {
+void OnAllPackagesReady() {
   // Set a system property to let other components know that APEXs are
   // correctly mounted and ready to be used. Before using any file from APEXs,
   // they can query this system property to ensure that they are okay to
@@ -2289,7 +2321,7 @@
   }
 }
 
-Result<std::vector<ApexFile>> submitStagedSession(
+Result<std::vector<ApexFile>> SubmitStagedSession(
     const int session_id, const std::vector<int>& child_session_ids,
     const bool has_rollback_enabled, const bool is_rollback,
     const int rollback_id) {
@@ -2314,7 +2346,7 @@
 
   std::vector<ApexFile> ret;
   for (int id_to_scan : ids_to_scan) {
-    auto verified = verifySessionDir(id_to_scan);
+    auto verified = VerifySessionDir(id_to_scan);
     if (!verified.ok()) {
       return verified.error();
     }
@@ -2351,7 +2383,7 @@
   return ret;
 }
 
-Result<void> markStagedSessionReady(const int session_id) {
+Result<void> MarkStagedSessionReady(const int session_id) {
   auto session = ApexSession::GetSession(session_id);
   if (!session.ok()) {
     return session.error();
@@ -2370,7 +2402,7 @@
                  << ". Cannot mark it as ready.";
 }
 
-Result<void> markStagedSessionSuccessful(const int session_id) {
+Result<void> MarkStagedSessionSuccessful(const int session_id) {
   auto session = ApexSession::GetSession(session_id);
   if (!session.ok()) {
     return session.error();
@@ -2386,7 +2418,7 @@
                      << " as successful : " << cleanup_status.error();
     }
     if (session->IsRollback() && !gInFsCheckpointMode) {
-      deleteDePreRestoreSnapshots(*session);
+      DeleteDePreRestoreSnapshots(*session);
     }
     return session->UpdateStateAndCommit(SessionState::SUCCESS);
   } else {
@@ -2467,13 +2499,13 @@
 
 }  // namespace
 
-void bootCompletedCleanup() {
+void BootCompletedCleanup() {
   UnmountDanglingMounts();
   RemoveOrphanedApexes();
   ApexSession::DeleteFinalizedSessions();
 }
 
-int unmountAll() {
+int UnmountAll() {
   gMountedApexes.PopulateFromMounts();
   int ret = 0;
   gMountedApexes.ForallMountedApexes([&](const std::string& /*package*/,
@@ -2499,7 +2531,7 @@
   return ret;
 }
 
-Result<void> remountPackages() {
+Result<void> RemountPackages() {
   std::vector<std::string> apexes;
   gMountedApexes.ForallMountedApexes([&apexes](const std::string& /*package*/,
                                                const MountedApexData& data,
@@ -2513,7 +2545,7 @@
   for (const std::string& apex : apexes) {
     // Since this is only used during development workflow, we are trying to
     // remount as many apexes as possible instead of failing fast.
-    if (auto ret = remountApexFile(apex); !ret) {
+    if (auto ret = RemountApexFile(apex); !ret.ok()) {
       LOG(WARNING) << "Failed to remount " << apex << " : " << ret.error();
       failed.emplace_back(apex);
     }
diff --git a/apexd/apexd.h b/apexd/apexd.h
index dca3efb..bf44e4b 100644
--- a/apexd/apexd.h
+++ b/apexd/apexd.h
@@ -32,96 +32,99 @@
 
 class CheckpointInterface;
 
-android::base::Result<void> resumeRevertIfNeeded();
+android::base::Result<void> ResumeRevertIfNeeded();
 
 // Keep it for now to make otapreopt_chroot keep happy.
 // TODO(b/137086602): remove this function.
-android::base::Result<void> scanPackagesDirAndActivate(
+android::base::Result<void> ScanPackagesDirAndActivate(
     const char* apex_package_dir);
-void scanStagedSessionsDirAndStage();
-android::base::Result<void> preinstallPackages(
+void ScanStagedSessionsDirAndStage();
+android::base::Result<void> PreinstallPackages(
     const std::vector<std::string>& paths) WARN_UNUSED;
-android::base::Result<void> postinstallPackages(
+android::base::Result<void> PostinstallPackages(
     const std::vector<std::string>& paths) WARN_UNUSED;
 
-android::base::Result<void> stagePackages(
+android::base::Result<void> StagePackages(
     const std::vector<std::string>& tmpPaths) WARN_UNUSED;
-android::base::Result<void> unstagePackages(
+android::base::Result<void> UnstagePackages(
     const std::vector<std::string>& paths) WARN_UNUSED;
 
-android::base::Result<std::vector<ApexFile>> submitStagedSession(
+android::base::Result<std::vector<ApexFile>> SubmitStagedSession(
     const int session_id, const std::vector<int>& child_session_ids,
     const bool has_rollback_enabled, const bool is_rollback,
     const int rollback_id) WARN_UNUSED;
-android::base::Result<void> markStagedSessionReady(const int session_id)
+android::base::Result<void> MarkStagedSessionReady(const int session_id)
     WARN_UNUSED;
-android::base::Result<void> markStagedSessionSuccessful(const int session_id)
+android::base::Result<void> MarkStagedSessionSuccessful(const int session_id)
     WARN_UNUSED;
-android::base::Result<void> revertActiveSessions(
+android::base::Result<void> RevertActiveSessions(
     const std::string& crashing_native_process);
-android::base::Result<void> revertActiveSessionsAndReboot(
+android::base::Result<void> RevertActiveSessionsAndReboot(
     const std::string& crashing_native_process);
 
-android::base::Result<void> activatePackage(const std::string& full_path)
+android::base::Result<void> ActivatePackage(const std::string& full_path)
     WARN_UNUSED;
-android::base::Result<void> deactivatePackage(const std::string& full_path)
+android::base::Result<void> DeactivatePackage(const std::string& full_path)
     WARN_UNUSED;
 
-std::vector<ApexFile> getActivePackages();
-android::base::Result<ApexFile> getActivePackage(
+std::vector<ApexFile> GetActivePackages();
+android::base::Result<ApexFile> GetActivePackage(
     const std::string& package_name);
 
-std::vector<ApexFile> getFactoryPackages();
+std::vector<ApexFile> GetFactoryPackages();
 
-android::base::Result<void> abortStagedSession(const int session_id);
-android::base::Result<void> abortActiveSession();
+android::base::Result<void> AbortStagedSession(const int session_id);
+android::base::Result<void> AbortActiveSession();
 
-android::base::Result<ino_t> snapshotCeData(const int user_id,
-                                            const int rollback_id,
-                                            const std::string& apex_name);
-android::base::Result<void> restoreCeData(const int user_id,
+android::base::Result<void> SnapshotCeData(const int user_id,
+                                           const int rollback_id,
+                                           const std::string& apex_name);
+android::base::Result<void> RestoreCeData(const int user_id,
                                           const int rollback_id,
                                           const std::string& apex_name);
-android::base::Result<void> destroyDeSnapshots(const int rollback_id);
-android::base::Result<void> destroyCeSnapshotsNotSpecified(
+
+android::base::Result<void> DestroyDeSnapshots(const int rollback_id);
+android::base::Result<void> DestroyCeSnapshots(const int user_id,
+                                               const int rollback_id);
+android::base::Result<void> DestroyCeSnapshotsNotSpecified(
     int user_id, const std::vector<int>& retain_rollback_ids);
 
-int onBootstrap();
+int OnBootstrap();
 // Sets the values of gVoldService and gInFsCheckpointMode.
-void initializeVold(CheckpointInterface* checkpoint_service);
+void InitializeVold(CheckpointInterface* checkpoint_service);
 // Initializes in-memory state (e.g. pre-installed data, activated apexes).
 // Must be called first before calling any other boot sequence related function.
-void initialize(CheckpointInterface* checkpoint_service);
+void Initialize(CheckpointInterface* checkpoint_service);
 // Migrates sessions from /data/apex/session to /metadata/session.i
 // Must only be called during boot (i.e apexd.status is not "ready" or
 // "activated").
-android::base::Result<void> migrateSessionsDirIfNeeded();
+android::base::Result<void> MigrateSessionsDirIfNeeded();
 // Apex activation logic. Scans staged apex sessions and activates apexes.
 // Must only be called during boot (i.e apexd.status is not "ready" or
 // "activated").
-void onStart();
+void OnStart();
 // Notifies system that apexes are activated by setting apexd.status property to
 // "activated".
 // Must only be called during boot (i.e. apexd.status is not "ready" or
 // "activated").
-void onAllPackagesActivated(bool is_bootstrap);
+void OnAllPackagesActivated(bool is_bootstrap);
 // Notifies system that apexes are ready by setting apexd.status property to
 // "ready".
 // Must only be called during boot (i.e. apexd.status is not "ready" or
 // "activated").
-void onAllPackagesReady();
-void onBootCompleted();
-void bootCompletedCleanup();
-int snapshotOrRestoreDeUserData();
+void OnAllPackagesReady();
+void OnBootCompleted();
+void BootCompletedCleanup();
+int SnapshotOrRestoreDeUserData();
 
-int unmountAll();
+int UnmountAll();
 
 android::base::Result<MountedApexDatabase::MountedApexData>
-getTempMountedApexData(const std::string& package);
+GetTempMountedApexData(const std::string& package);
 
 // Optimistically tries to remount as many APEX packages as possible.
 // For more documentation see corresponding binder call in IApexService.aidl.
-android::base::Result<void> remountPackages();
+android::base::Result<void> RemountPackages();
 
 }  // namespace apex
 }  // namespace android
diff --git a/apexd/apexd_checkpoint.h b/apexd/apexd_checkpoint.h
index 7177c04..2b4c3a1 100644
--- a/apexd/apexd_checkpoint.h
+++ b/apexd/apexd_checkpoint.h
@@ -32,7 +32,7 @@
 
   virtual android::base::Result<bool> NeedsCheckpoint() = 0;
   virtual android::base::Result<bool> NeedsRollback() = 0;
-  virtual android::base::Result<void> StartCheckpoint(int32_t numRetries) = 0;
+  virtual android::base::Result<void> StartCheckpoint(int32_t num_retries) = 0;
 
   virtual android::base::Result<void> AbortChanges(const std::string& msg,
                                                    bool retry) = 0;
diff --git a/apexd/apexd_checkpoint_vold.cpp b/apexd/apexd_checkpoint_vold.cpp
index ca29209..8a8d0ff 100644
--- a/apexd/apexd_checkpoint_vold.cpp
+++ b/apexd/apexd_checkpoint_vold.cpp
@@ -31,11 +31,11 @@
 namespace apex {
 
 Result<VoldCheckpointInterface> VoldCheckpointInterface::Create() {
-  auto voldService =
+  auto vold_service =
       defaultServiceManager()->getService(android::String16("vold"));
-  if (voldService != nullptr) {
+  if (vold_service != nullptr) {
     return VoldCheckpointInterface(
-        android::interface_cast<android::os::IVold>(voldService));
+        android::interface_cast<android::os::IVold>(vold_service));
   }
   return Errorf("Failed to retrieve vold service.");
 }
@@ -91,9 +91,10 @@
   return false;
 }
 
-Result<void> VoldCheckpointInterface::StartCheckpoint(int32_t numRetries) {
+Result<void> VoldCheckpointInterface::StartCheckpoint(int32_t num_retries) {
   if (supports_fs_checkpoints_) {
-    android::binder::Status status = vold_service_->startCheckpoint(numRetries);
+    android::binder::Status status =
+        vold_service_->startCheckpoint(num_retries);
     if (!status.isOk()) {
       return Error() << status.toString8().c_str();
     }
diff --git a/apexd/apexd_checkpoint_vold.h b/apexd/apexd_checkpoint_vold.h
index dbd190d..f547532 100644
--- a/apexd/apexd_checkpoint_vold.h
+++ b/apexd/apexd_checkpoint_vold.h
@@ -44,7 +44,7 @@
   android::base::Result<void> StartCheckpoint(int32_t retry) override;
 
   android::base::Result<void> AbortChanges(const std::string& msg,
-                                           bool numRetries) override;
+                                           bool num_retries) override;
 
   static android::base::Result<VoldCheckpointInterface> Create();
 
diff --git a/apexd/apexd_lifecycle.cpp b/apexd/apexd_lifecycle.cpp
index c44ca5a..84918f9 100644
--- a/apexd/apexd_lifecycle.cpp
+++ b/apexd/apexd_lifecycle.cpp
@@ -30,12 +30,12 @@
 namespace android {
 namespace apex {
 
-bool ApexdLifecycle::isBooting() {
+bool ApexdLifecycle::IsBooting() {
   auto status = GetProperty(kApexStatusSysprop, "");
   return status != kApexStatusReady && status != kApexStatusActivated;
 }
 
-void ApexdLifecycle::waitForBootStatus(
+void ApexdLifecycle::WaitForBootStatus(
     Result<void> (&revert_fn)(const std::string&)) {
   while (!boot_completed_) {
     // Check for change in either crashing property or sys.boot_completed
@@ -66,7 +66,7 @@
   }
 }
 
-void ApexdLifecycle::markBootCompleted() { boot_completed_ = true; }
+void ApexdLifecycle::MarkBootCompleted() { boot_completed_ = true; }
 
 }  // namespace apex
 }  // namespace android
diff --git a/apexd/apexd_lifecycle.h b/apexd/apexd_lifecycle.h
index bab0a05..5a2224f 100644
--- a/apexd/apexd_lifecycle.h
+++ b/apexd/apexd_lifecycle.h
@@ -33,13 +33,13 @@
   ApexdLifecycle& operator=(ApexdLifecycle&&) = delete;
 
  public:
-  static ApexdLifecycle& getInstance() {
+  static ApexdLifecycle& GetInstance() {
     static ApexdLifecycle instance;
     return instance;
   }
-  bool isBooting();
-  void markBootCompleted();
-  void waitForBootStatus(
+  bool IsBooting();
+  void MarkBootCompleted();
+  void WaitForBootStatus(
       android::base::Result<void> (&rollback_fn)(const std::string&));
 };
 }  // namespace apex
diff --git a/apexd/apexd_loop.cpp b/apexd/apexd_loop.cpp
index 4ab4016..8a23fbf 100644
--- a/apexd/apexd_loop.cpp
+++ b/apexd/apexd_loop.cpp
@@ -32,6 +32,7 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
@@ -42,6 +43,7 @@
 using android::base::Basename;
 using android::base::Error;
 using android::base::GetBoolProperty;
+using android::base::ParseUint;
 using android::base::Result;
 using android::base::StartsWith;
 using android::base::StringPrintf;
@@ -83,7 +85,7 @@
   }
 }
 
-Result<void> configureReadAhead(const std::string& device_path) {
+Result<void> ConfigureReadAhead(const std::string& device_path) {
   CHECK(StartsWith(device_path, "/dev/"));
   std::string device_name = Basename(device_path);
 
@@ -103,10 +105,10 @@
   return {};
 }
 
-Result<void> preAllocateLoopDevices(size_t num) {
-  Result<void> loopReady = WaitForFile("/dev/loop-control", 20s);
-  if (!loopReady.ok()) {
-    return loopReady;
+Result<void> PreAllocateLoopDevices(size_t num) {
+  Result<void> loop_ready = WaitForFile("/dev/loop-control", 20s);
+  if (!loop_ready.ok()) {
+    return loop_ready;
   }
   unique_fd ctl_fd(
       TEMP_FAILURE_RETRY(open("/dev/loop-control", O_RDWR | O_CLOEXEC)));
@@ -114,13 +116,30 @@
     return ErrnoError() << "Failed to open loop-control";
   }
 
+  bool found = false;
+  size_t start_id = 0;
+  constexpr const char* kLoopPrefix = "loop";
+  WalkDir("/dev/block", [&](const std::filesystem::directory_entry& entry) {
+    std::string devname = entry.path().filename().string();
+    if (StartsWith(devname, kLoopPrefix)) {
+      size_t id;
+      auto parse_ok = ParseUint(
+          devname.substr(std::char_traits<char>::length(kLoopPrefix)), &id);
+      if (parse_ok && id > start_id) {
+        start_id = id;
+        found = true;
+      }
+    }
+  });
+  if (found) ++start_id;
+
   // Assumption: loop device ID [0..num) is valid.
   // This is because pre-allocation happens during bootstrap.
   // Anyway Kernel pre-allocated loop devices
   // as many as CONFIG_BLK_DEV_LOOP_MIN_COUNT,
   // Within the amount of kernel-pre-allocation,
   // LOOP_CTL_ADD will fail with EEXIST
-  for (size_t id = 0ul; id < num; ++id) {
+  for (size_t id = start_id; id < num + start_id; ++id) {
     int ret = ioctl(ctl_fd.get(), LOOP_CTL_ADD, id);
     if (ret < 0 && errno != EEXIST) {
       return ErrnoError() << "Failed LOOP_CTL_ADD";
@@ -133,17 +152,17 @@
   // just optimistally hope that they are all created when we actually
   // access them for activating APEXes. If the dev nodes are not ready
   // even then, we wait 50ms and warning message will be printed (see below
-  // createLoopDevice()).
+  // CreateLoopDevice()).
   LOG(INFO) << "Pre-allocated " << num << " loopback devices";
   return {};
 }
 
-Result<void> configureLoopDevice(const int device_fd, const std::string& target,
-                                 const int32_t imageOffset,
-                                 const size_t imageSize) {
-  static bool useLoopConfigure;
-  static std::once_flag onceFlag;
-  std::call_once(onceFlag, [&]() {
+Result<void> ConfigureLoopDevice(const int device_fd, const std::string& target,
+                                 const int32_t image_offset,
+                                 const size_t image_size) {
+  static bool use_loop_configure;
+  static std::once_flag once_flag;
+  std::call_once(once_flag, [&]() {
     // LOOP_CONFIGURE is a new ioctl in Linux 5.8 (and backported in Android
     // common) that allows atomically configuring a loop device. It is a lot
     // faster than the traditional LOOP_SET_FD/LOOP_SET_STATUS64 combo, but
@@ -154,7 +173,7 @@
     config.fd = -1;
     if (ioctl(device_fd, LOOP_CONFIGURE, &config) == -1 && errno == EBADF) {
       // If the IOCTL exists, it will fail with EBADF for the -1 fd
-      useLoopConfigure = true;
+      use_loop_configure = true;
     }
   });
 
@@ -188,10 +207,10 @@
   struct loop_info64 li;
   memset(&li, 0, sizeof(li));
   strlcpy((char*)li.lo_crypt_name, kApexLoopIdPrefix, LO_NAME_SIZE);
-  li.lo_offset = imageOffset;
-  li.lo_sizelimit = imageSize;
+  li.lo_offset = image_offset;
+  li.lo_sizelimit = image_size;
 
-  if (useLoopConfigure) {
+  if (use_loop_configure) {
     struct loop_config config;
     memset(&config, 0, sizeof(config));
     li.lo_flags |= LO_FLAGS_DIRECT_IO;
@@ -279,9 +298,9 @@
   return Error() << "Faled to open loopback device " << num;
 }
 
-Result<LoopbackDeviceUniqueFd> createLoopDevice(const std::string& target,
-                                                const int32_t imageOffset,
-                                                const size_t imageSize) {
+Result<LoopbackDeviceUniqueFd> CreateLoopDevice(const std::string& target,
+                                                const int32_t image_offset,
+                                                const size_t image_size) {
   unique_fd ctl_fd(open("/dev/loop-control", O_RDWR | O_CLOEXEC));
   if (ctl_fd.get() == -1) {
     return ErrnoError() << "Failed to open loop-control";
@@ -298,15 +317,15 @@
   }
   CHECK_NE(loop_device->device_fd.get(), -1);
 
-  Result<void> configureStatus = configureLoopDevice(
-      loop_device->device_fd.get(), target, imageOffset, imageSize);
+  Result<void> configureStatus = ConfigureLoopDevice(
+      loop_device->device_fd.get(), target, image_offset, image_size);
   if (!configureStatus.ok()) {
     return configureStatus.error();
   }
 
-  Result<void> readAheadStatus = configureReadAhead(loop_device->name);
-  if (!readAheadStatus.ok()) {
-    return readAheadStatus.error();
+  Result<void> read_ahead_status = ConfigureReadAhead(loop_device->name);
+  if (!read_ahead_status.ok()) {
+    return read_ahead_status.error();
   }
 
   return loop_device;
diff --git a/apexd/apexd_loop.h b/apexd/apexd_loop.h
index 8341675..1dbab21 100644
--- a/apexd/apexd_loop.h
+++ b/apexd/apexd_loop.h
@@ -52,16 +52,16 @@
 
   void CloseGood() { device_fd.reset(-1); }
 
-  int get() { return device_fd.get(); }
+  int Get() { return device_fd.get(); }
 };
 
-android::base::Result<void> configureReadAhead(const std::string& device_path);
+android::base::Result<void> ConfigureReadAhead(const std::string& device_path);
 
-android::base::Result<void> preAllocateLoopDevices(size_t num);
+android::base::Result<void> PreAllocateLoopDevices(size_t num);
 
-android::base::Result<LoopbackDeviceUniqueFd> createLoopDevice(
-    const std::string& target, const int32_t imageOffset,
-    const size_t imageSize);
+android::base::Result<LoopbackDeviceUniqueFd> CreateLoopDevice(
+    const std::string& target, const int32_t image_offset,
+    const size_t image_size);
 
 using DestroyLoopFn =
     std::function<void(const std::string&, const std::string&)>;
diff --git a/apexd/apexd_main.cpp b/apexd/apexd_main.cpp
index 93d0a6f..0f13db1 100644
--- a/apexd/apexd_main.cpp
+++ b/apexd/apexd_main.cpp
@@ -32,7 +32,7 @@
 
 namespace {
 android::apex::ApexdLifecycle& lifecycle =
-    android::apex::ApexdLifecycle::getInstance();
+    android::apex::ApexdLifecycle::GetInstance();
 
 int HandleSubcommand(char** argv) {
   if (strcmp("--pre-install", argv[1]) == 0) {
@@ -47,12 +47,12 @@
 
   if (strcmp("--bootstrap", argv[1]) == 0) {
     LOG(INFO) << "Bootstrap subcommand detected";
-    return android::apex::onBootstrap();
+    return android::apex::OnBootstrap();
   }
 
   if (strcmp("--unmount-all", argv[1]) == 0) {
     LOG(INFO) << "Unmount all subcommand detected";
-    return android::apex::unmountAll();
+    return android::apex::UnmountAll();
   }
 
   if (strcmp("--snapshotde", argv[1]) == 0) {
@@ -65,16 +65,16 @@
       LOG(ERROR) << "Could not retrieve vold service: "
                  << vold_service_st.error();
     } else {
-      android::apex::initializeVold(&*vold_service_st);
+      android::apex::InitializeVold(&*vold_service_st);
     }
 
-    int result = android::apex::snapshotOrRestoreDeUserData();
+    int result = android::apex::SnapshotOrRestoreDeUserData();
 
     if (result == 0) {
       // Notify other components (e.g. init) that all APEXs are ready to be used
       // Note that it's important that the binder service is registered at this
       // point, since other system services might depend on it.
-      android::apex::onAllPackagesReady();
+      android::apex::OnAllPackagesReady();
     }
     return result;
   }
@@ -116,10 +116,10 @@
     LOG(INFO) << "This device does not support updatable APEX. Exiting";
     if (!has_subcommand) {
       // mark apexd as activated so that init can proceed
-      android::apex::onAllPackagesActivated(/*is_bootstrap=*/false);
+      android::apex::OnAllPackagesActivated(/*is_bootstrap=*/false);
     } else if (strcmp("--snapshotde", argv[1]) == 0) {
       // mark apexd as ready
-      android::apex::onAllPackagesReady();
+      android::apex::OnAllPackagesReady();
     }
     return 0;
   }
@@ -137,15 +137,15 @@
   } else {
     vold_service = &*vold_service_st;
   }
-  android::apex::initialize(vold_service);
+  android::apex::Initialize(vold_service);
 
-  bool booting = lifecycle.isBooting();
+  bool booting = lifecycle.IsBooting();
   if (booting) {
-    if (auto res = android::apex::migrateSessionsDirIfNeeded(); !res.ok()) {
+    if (auto res = android::apex::MigrateSessionsDirIfNeeded(); !res.ok()) {
       LOG(ERROR) << "Failed to migrate sessions to /metadata partition : "
                  << res.error();
     }
-    android::apex::onStart();
+    android::apex::OnStart();
   }
   android::apex::binder::CreateAndRegisterService();
   android::apex::binder::StartThreadPool();
@@ -157,8 +157,8 @@
     // themselves should wait for the ready status instead, which is set when
     // the "--snapshotde" subcommand is received and snapshot/restore is
     // complete.
-    android::apex::onAllPackagesActivated(/*is_bootstrap=*/false);
-    lifecycle.waitForBootStatus(android::apex::revertActiveSessionsAndReboot);
+    android::apex::OnAllPackagesActivated(/*is_bootstrap=*/false);
+    lifecycle.WaitForBootStatus(android::apex::RevertActiveSessionsAndReboot);
   }
 
   android::apex::binder::AllowServiceShutdown();
diff --git a/apexd/apexd_private.h b/apexd/apexd_private.h
index 2c11327..23c6267 100644
--- a/apexd/apexd_private.h
+++ b/apexd/apexd_private.h
@@ -40,7 +40,7 @@
 android::base::Result<void> BindMount(const std::string& target,
                                       const std::string& source);
 android::base::Result<MountedApexDatabase::MountedApexData>
-getTempMountedApexData(const std::string& package);
+GetTempMountedApexData(const std::string& package);
 android::base::Result<void> UnmountTempMount(const ApexFile& apex);
 
 }  // namespace apexd_private
diff --git a/apexd/apexd_rollback_utils.h b/apexd/apexd_rollback_utils.h
index 9990be2..afb6275 100644
--- a/apexd/apexd_rollback_utils.h
+++ b/apexd/apexd_rollback_utils.h
@@ -40,7 +40,7 @@
  * path. Note that this will fail if run before APEXes are mounted, due to a
  * dependency on runtime.
  */
-int32_t copy_directory_recursive(const char* from, const char* to) {
+int32_t CopyDirectoryRecursive(const char* from, const char* to) {
   const char* const argv[] = {
       kCpPath,
       "-F", /* delete any existing destination file first
@@ -83,7 +83,7 @@
   };
   auto scope_guard = android::base::make_scope_guard(deleter);
 
-  int rc = copy_directory_recursive(from_path.c_str(), to_path.c_str());
+  int rc = CopyDirectoryRecursive(from_path.c_str(), to_path.c_str());
   if (rc != 0) {
     return Error() << "Failed to copy from [" << from_path << "] to ["
                    << to_path << "]";
diff --git a/apexd/apexd_session.cpp b/apexd/apexd_session.cpp
index 145cd5a..185b0ed 100644
--- a/apexd/apexd_session.cpp
+++ b/apexd/apexd_session.cpp
@@ -76,7 +76,7 @@
   SessionState state;
   // Create session directory
   std::string session_dir = GetSessionsDir() + "/" + std::to_string(session_id);
-  if (auto status = createDirIfNeeded(session_dir, 0700); !status.ok()) {
+  if (auto status = CreateDirIfNeeded(session_dir, 0700); !status.ok()) {
     return status.error();
   }
   state.set_id(session_id);
@@ -86,12 +86,12 @@
 
 Result<ApexSession> ApexSession::GetSessionFromFile(const std::string& path) {
   SessionState state;
-  std::fstream stateFile(path, std::ios::in | std::ios::binary);
-  if (!stateFile) {
+  std::fstream state_file(path, std::ios::in | std::ios::binary);
+  if (!state_file) {
     return Error() << "Failed to open " << path;
   }
 
-  if (!state.ParseFromIstream(&stateFile)) {
+  if (!state.ParseFromIstream(&state_file)) {
     return Error() << "Failed to parse " << path;
   }
 
@@ -108,19 +108,19 @@
 std::vector<ApexSession> ApexSession::GetSessions() {
   std::vector<ApexSession> sessions;
 
-  Result<std::vector<std::string>> sessionPaths = ReadDir(
+  Result<std::vector<std::string>> session_paths = ReadDir(
       GetSessionsDir(), [](const std::filesystem::directory_entry& entry) {
         std::error_code ec;
         return entry.is_directory(ec);
       });
 
-  if (!sessionPaths.ok()) {
+  if (!session_paths.ok()) {
     return sessions;
   }
 
-  for (const std::string& sessionDirPath : *sessionPaths) {
+  for (const std::string& session_dir_path : *session_paths) {
     // Try to read session state
-    auto session = GetSessionFromFile(sessionDirPath + "/" + kStateFileName);
+    auto session = GetSessionFromFile(session_dir_path + "/" + kStateFileName);
     if (!session.ok()) {
       LOG(WARNING) << session.error();
       continue;
@@ -144,13 +144,13 @@
 
 std::vector<ApexSession> ApexSession::GetActiveSessions() {
   auto sessions = GetSessions();
-  std::vector<ApexSession> activeSessions;
+  std::vector<ApexSession> active_sessions;
   for (const ApexSession& session : sessions) {
     if (!session.IsFinalized() && session.GetState() != SessionState::UNKNOWN) {
-      activeSessions.push_back(session);
+      active_sessions.push_back(session);
     }
   }
-  return activeSessions;
+  return active_sessions;
 }
 
 SessionState::State ApexSession::GetState() const { return state_.state(); }
diff --git a/apexd/apexd_session_test.cpp b/apexd/apexd_session_test.cpp
index bec0561..573b4d5 100644
--- a/apexd/apexd_session_test.cpp
+++ b/apexd/apexd_session_test.cpp
@@ -71,7 +71,7 @@
    public:
     TestApexSession(int id, const SessionState::State& state) {
       path_ = "/data/apex/sessions/" + std::to_string(id);
-      if (auto status = createDirIfNeeded(path_, 0700); !status.ok()) {
+      if (auto status = CreateDirIfNeeded(path_, 0700); !status.ok()) {
         ADD_FAILURE() << "Failed to create " << path_ << " : "
                       << status.error();
       }
diff --git a/apexd/apexd_utils.h b/apexd/apexd_utils.h
index e970404..e268f59 100644
--- a/apexd/apexd_utils.h
+++ b/apexd/apexd_utils.h
@@ -18,6 +18,7 @@
 #define ANDROID_APEXD_APEXD_UTILS_H_
 
 #include <chrono>
+#include <cstdint>
 #include <filesystem>
 #include <string>
 #include <thread>
@@ -126,7 +127,7 @@
   return res.ok() && res->empty();
 }
 
-inline Result<void> createDirIfNeeded(const std::string& path, mode_t mode) {
+inline Result<void> CreateDirIfNeeded(const std::string& path, mode_t mode) {
   struct stat stat_data;
 
   if (stat(path.c_str(), &stat_data) != 0) {
@@ -175,16 +176,6 @@
   return {};
 }
 
-inline Result<ino_t> get_path_inode(const std::string& path) {
-  struct stat buf;
-  memset(&buf, 0, sizeof(buf));
-  if (stat(path.c_str(), &buf) != 0) {
-    return ErrnoError() << "Failed to stat " << path;
-  } else {
-    return buf.st_ino;
-  }
-}
-
 inline Result<bool> PathExists(const std::string& path) {
   namespace fs = std::filesystem;
 
@@ -345,6 +336,17 @@
   return {};
 }
 
+inline Result<uintmax_t> GetFileSize(const std::string& file_path) {
+  std::error_code ec;
+  auto value = std::filesystem::file_size(file_path, ec);
+  if (ec) {
+    return Error() << "Failed to get file size of " << file_path << " : "
+                   << ec.message();
+  }
+
+  return value;
+}
+
 }  // namespace apex
 }  // namespace android
 
diff --git a/apexd/apexd_verity.cpp b/apexd/apexd_verity.cpp
index 052550c..e0975e0 100644
--- a/apexd/apexd_verity.cpp
+++ b/apexd/apexd_verity.cpp
@@ -151,7 +151,7 @@
 Result<PrepareHashTreeResult> PrepareHashTree(
     const ApexFile& apex, const ApexVerityData& verity_data,
     const std::string& hashtree_file) {
-  if (auto st = createDirIfNeeded(kApexHashTreeDir, 0700); !st.ok()) {
+  if (auto st = CreateDirIfNeeded(kApexHashTreeDir, 0700); !st.ok()) {
     return st.error();
   }
   bool should_regenerate_hashtree = false;
diff --git a/apexd/apexservice.cpp b/apexd/apexservice.cpp
index 1729bff..c0cb2ff 100644
--- a/apexd/apexservice.cpp
+++ b/apexd/apexservice.cpp
@@ -79,10 +79,10 @@
   BinderStatus getSessions(std::vector<ApexSessionInfo>* aidl_return) override;
   BinderStatus getStagedSessionInfo(
       int session_id, ApexSessionInfo* apex_session_info) override;
-  BinderStatus activatePackage(const std::string& packagePath) override;
-  BinderStatus deactivatePackage(const std::string& packagePath) override;
+  BinderStatus activatePackage(const std::string& package_path) override;
+  BinderStatus deactivatePackage(const std::string& package_path) override;
   BinderStatus getActivePackages(std::vector<ApexInfo>* aidl_return) override;
-  BinderStatus getActivePackage(const std::string& packageName,
+  BinderStatus getActivePackage(const std::string& package_name,
                                 ApexInfo* aidl_return) override;
   BinderStatus getAllPackages(std::vector<ApexInfo>* aidl_return) override;
   BinderStatus preinstallPackages(
@@ -93,11 +93,11 @@
   BinderStatus revertActiveSessions() override;
   BinderStatus resumeRevertIfNeeded() override;
   BinderStatus snapshotCeData(int user_id, int rollback_id,
-                              const std::string& apex_name,
-                              int64_t* _aidl_return) override;
+                              const std::string& apex_name) override;
   BinderStatus restoreCeData(int user_id, int rollback_id,
                              const std::string& apex_name) override;
   BinderStatus destroyDeSnapshots(int rollback_id) override;
+  BinderStatus destroyCeSnapshots(int user_id, int rollback_id) override;
   BinderStatus destroyCeSnapshotsNotSpecified(
       int user_id, const std::vector<int>& retain_rollback_ids) override;
   BinderStatus remountPackages() override;
@@ -124,14 +124,14 @@
 }
 
 BinderStatus ApexService::stagePackages(const std::vector<std::string>& paths) {
-  BinderStatus debugCheck = CheckDebuggable("stagePackages");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+  BinderStatus debug_check = CheckDebuggable("stagePackages");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
   LOG(DEBUG) << "stagePackages() received by ApexService, paths "
              << android::base::Join(paths, ',');
 
-  Result<void> res = ::android::apex::stagePackages(paths);
+  Result<void> res = ::android::apex::StagePackages(paths);
 
   if (res.ok()) {
     return BinderStatus::ok();
@@ -146,7 +146,7 @@
 
 BinderStatus ApexService::unstagePackages(
     const std::vector<std::string>& paths) {
-  Result<void> res = ::android::apex::unstagePackages(paths);
+  Result<void> res = ::android::apex::UnstagePackages(paths);
   if (res.ok()) {
     return BinderStatus::ok();
   }
@@ -164,7 +164,7 @@
              << params.sessionId << " child sessions: ["
              << android::base::Join(params.childSessionIds, ',') << "]";
 
-  Result<std::vector<ApexFile>> packages = ::android::apex::submitStagedSession(
+  Result<std::vector<ApexFile>> packages = ::android::apex::SubmitStagedSession(
       params.sessionId, params.childSessionIds, params.hasRollbackEnabled,
       params.isRollback, params.rollbackId);
   if (!packages.ok()) {
@@ -188,7 +188,7 @@
 BinderStatus ApexService::markStagedSessionReady(int session_id) {
   LOG(DEBUG) << "markStagedSessionReady() received by ApexService, session id "
              << session_id;
-  Result<void> success = ::android::apex::markStagedSessionReady(session_id);
+  Result<void> success = ::android::apex::MarkStagedSessionReady(session_id);
   if (!success.ok()) {
     LOG(ERROR) << "Failed to mark session id " << session_id
                << " as ready: " << success.error();
@@ -203,7 +203,7 @@
   LOG(DEBUG)
       << "markStagedSessionSuccessful() received by ApexService, session id "
       << session_id;
-  Result<void> ret = ::android::apex::markStagedSessionSuccessful(session_id);
+  Result<void> ret = ::android::apex::MarkStagedSessionSuccessful(session_id);
   if (!ret.ok()) {
     LOG(ERROR) << "Failed to mark session " << session_id
                << " as SUCCESS: " << ret.error();
@@ -215,7 +215,7 @@
 }
 
 BinderStatus ApexService::markBootCompleted() {
-  ::android::apex::onBootCompleted();
+  ::android::apex::OnBootCompleted();
   return BinderStatus::ok();
 }
 
@@ -232,7 +232,7 @@
   session_info->isRevertFailed = false;
 }
 
-void convertToApexSessionInfo(const ApexSession& session,
+void ConvertToApexSessionInfo(const ApexSession& session,
                               ApexSessionInfo* session_info) {
   using SessionState = ::apex::proto::SessionState;
 
@@ -272,7 +272,7 @@
   }
 }
 
-static ApexInfo getApexInfo(const ApexFile& package) {
+static ApexInfo GetApexInfo(const ApexFile& package) {
   auto& instance = ApexPreinstalledData::GetInstance();
   ApexInfo out;
   out.moduleName = package.GetManifest().name();
@@ -281,15 +281,15 @@
   out.versionName = package.GetManifest().versionname();
   out.isFactory = instance.IsPreInstalledApex(package);
   out.isActive = false;
-  Result<std::string> preinstalledPath =
+  Result<std::string> preinstalled_path =
       instance.GetPreinstalledPath(package.GetManifest().name());
-  if (preinstalledPath.ok()) {
-    out.preinstalledModulePath = *preinstalledPath;
+  if (preinstalled_path.ok()) {
+    out.preinstalledModulePath = *preinstalled_path;
   }
   return out;
 }
 
-static std::string toString(const ApexInfo& package) {
+static std::string ToString(const ApexInfo& package) {
   std::string msg = StringLog()
                     << "Module: " << package.moduleName
                     << " Version: " << package.versionCode
@@ -305,9 +305,9 @@
     std::vector<ApexSessionInfo>* aidl_return) {
   auto sessions = ApexSession::GetSessions();
   for (const auto& session : sessions) {
-    ApexSessionInfo sessionInfo;
-    convertToApexSessionInfo(session, &sessionInfo);
-    aidl_return->push_back(sessionInfo);
+    ApexSessionInfo session_info;
+    ConvertToApexSessionInfo(session, &session_info);
+    aidl_return->push_back(session_info);
   }
 
   return BinderStatus::ok();
@@ -325,48 +325,48 @@
     return BinderStatus::ok();
   }
 
-  convertToApexSessionInfo(*session, apex_session_info);
+  ConvertToApexSessionInfo(*session, apex_session_info);
 
   return BinderStatus::ok();
 }
 
-BinderStatus ApexService::activatePackage(const std::string& packagePath) {
-  BinderStatus debugCheck = CheckDebuggable("activatePackage");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+BinderStatus ApexService::activatePackage(const std::string& package_path) {
+  BinderStatus debug_check = CheckDebuggable("activatePackage");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
 
   LOG(DEBUG) << "activatePackage() received by ApexService, path "
-             << packagePath;
+             << package_path;
 
-  Result<void> res = ::android::apex::activatePackage(packagePath);
+  Result<void> res = ::android::apex::ActivatePackage(package_path);
 
   if (res.ok()) {
     return BinderStatus::ok();
   }
 
-  LOG(ERROR) << "Failed to activate " << packagePath << ": " << res.error();
+  LOG(ERROR) << "Failed to activate " << package_path << ": " << res.error();
   return BinderStatus::fromExceptionCode(
       BinderStatus::EX_SERVICE_SPECIFIC,
       String8(res.error().message().c_str()));
 }
 
-BinderStatus ApexService::deactivatePackage(const std::string& packagePath) {
-  BinderStatus debugCheck = CheckDebuggable("deactivatePackage");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+BinderStatus ApexService::deactivatePackage(const std::string& package_path) {
+  BinderStatus debug_check = CheckDebuggable("deactivatePackage");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
 
   LOG(DEBUG) << "deactivatePackage() received by ApexService, path "
-             << packagePath;
+             << package_path;
 
-  Result<void> res = ::android::apex::deactivatePackage(packagePath);
+  Result<void> res = ::android::apex::DeactivatePackage(package_path);
 
   if (res.ok()) {
     return BinderStatus::ok();
   }
 
-  LOG(ERROR) << "Failed to deactivate " << packagePath << ": " << res.error();
+  LOG(ERROR) << "Failed to deactivate " << package_path << ": " << res.error();
   return BinderStatus::fromExceptionCode(
       BinderStatus::EX_SERVICE_SPECIFIC,
       String8(res.error().message().c_str()));
@@ -374,31 +374,31 @@
 
 BinderStatus ApexService::getActivePackages(
     std::vector<ApexInfo>* aidl_return) {
-  auto packages = ::android::apex::getActivePackages();
+  auto packages = ::android::apex::GetActivePackages();
   for (const auto& package : packages) {
-    ApexInfo apexInfo = getApexInfo(package);
-    apexInfo.isActive = true;
-    aidl_return->push_back(std::move(apexInfo));
+    ApexInfo apex_info = GetApexInfo(package);
+    apex_info.isActive = true;
+    aidl_return->push_back(std::move(apex_info));
   }
 
   return BinderStatus::ok();
 }
 
-BinderStatus ApexService::getActivePackage(const std::string& packageName,
+BinderStatus ApexService::getActivePackage(const std::string& package_name,
                                            ApexInfo* aidl_return) {
-  Result<ApexFile> apex = ::android::apex::getActivePackage(packageName);
+  Result<ApexFile> apex = ::android::apex::GetActivePackage(package_name);
   if (apex.ok()) {
-    *aidl_return = getApexInfo(*apex);
+    *aidl_return = GetApexInfo(*apex);
     aidl_return->isActive = true;
   }
   return BinderStatus::ok();
 }
 
 BinderStatus ApexService::getAllPackages(std::vector<ApexInfo>* aidl_return) {
-  const auto& active = ::android::apex::getActivePackages();
-  const auto& factory = ::android::apex::getFactoryPackages();
+  const auto& active = ::android::apex::GetActivePackages();
+  const auto& factory = ::android::apex::GetFactoryPackages();
   for (const ApexFile& pkg : active) {
-    ApexInfo apex_info = getApexInfo(pkg);
+    ApexInfo apex_info = GetApexInfo(pkg);
     apex_info.isActive = true;
     aidl_return->push_back(std::move(apex_info));
   }
@@ -407,7 +407,7 @@
       return o.GetPath() == pkg.GetPath();
     };
     if (std::find_if(active.begin(), active.end(), same_path) == active.end()) {
-      aidl_return->push_back(getApexInfo(pkg));
+      aidl_return->push_back(GetApexInfo(pkg));
     }
   }
   return BinderStatus::ok();
@@ -415,12 +415,12 @@
 
 BinderStatus ApexService::preinstallPackages(
     const std::vector<std::string>& paths) {
-  BinderStatus debugCheck = CheckDebuggable("preinstallPackages");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+  BinderStatus debug_check = CheckDebuggable("preinstallPackages");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
 
-  Result<void> res = ::android::apex::preinstallPackages(paths);
+  Result<void> res = ::android::apex::PreinstallPackages(paths);
   if (res.ok()) {
     return BinderStatus::ok();
   }
@@ -434,12 +434,12 @@
 
 BinderStatus ApexService::postinstallPackages(
     const std::vector<std::string>& paths) {
-  BinderStatus debugCheck = CheckDebuggable("postinstallPackages");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+  BinderStatus debug_check = CheckDebuggable("postinstallPackages");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
 
-  Result<void> res = ::android::apex::postinstallPackages(paths);
+  Result<void> res = ::android::apex::PostinstallPackages(paths);
   if (res.ok()) {
     return BinderStatus::ok();
   }
@@ -453,7 +453,7 @@
 
 BinderStatus ApexService::abortStagedSession(int session_id) {
   LOG(DEBUG) << "abortStagedSession() received by ApexService.";
-  Result<void> res = ::android::apex::abortStagedSession(session_id);
+  Result<void> res = ::android::apex::AbortStagedSession(session_id);
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_ILLEGAL_ARGUMENT,
@@ -464,7 +464,7 @@
 
 BinderStatus ApexService::revertActiveSessions() {
   LOG(DEBUG) << "revertActiveSessions() received by ApexService.";
-  Result<void> res = ::android::apex::revertActiveSessions("");
+  Result<void> res = ::android::apex::RevertActiveSessions("");
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_ILLEGAL_ARGUMENT,
@@ -474,13 +474,13 @@
 }
 
 BinderStatus ApexService::resumeRevertIfNeeded() {
-  BinderStatus debugCheck = CheckDebuggable("resumeRevertIfNeeded");
-  if (!debugCheck.isOk()) {
-    return debugCheck;
+  BinderStatus debug_check = CheckDebuggable("resumeRevertIfNeeded");
+  if (!debug_check.isOk()) {
+    return debug_check;
   }
 
   LOG(DEBUG) << "resumeRevertIfNeeded() received by ApexService.";
-  Result<void> res = ::android::apex::resumeRevertIfNeeded();
+  Result<void> res = ::android::apex::ResumeRevertIfNeeded();
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_ILLEGAL_ARGUMENT,
@@ -490,17 +490,15 @@
 }
 
 BinderStatus ApexService::snapshotCeData(int user_id, int rollback_id,
-                                         const std::string& apex_name,
-                                         int64_t* _aidl_return) {
+                                         const std::string& apex_name) {
   LOG(DEBUG) << "snapshotCeData() received by ApexService.";
-  Result<ino_t> res =
-      ::android::apex::snapshotCeData(user_id, rollback_id, apex_name);
+  Result<void> res =
+      ::android::apex::SnapshotCeData(user_id, rollback_id, apex_name);
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_SERVICE_SPECIFIC,
         String8(res.error().message().c_str()));
   }
-  *_aidl_return = static_cast<uint64_t>(*res);
   return BinderStatus::ok();
 }
 
@@ -508,7 +506,7 @@
                                         const std::string& apex_name) {
   LOG(DEBUG) << "restoreCeData() received by ApexService.";
   Result<void> res =
-      ::android::apex::restoreCeData(user_id, rollback_id, apex_name);
+      ::android::apex::RestoreCeData(user_id, rollback_id, apex_name);
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_SERVICE_SPECIFIC,
@@ -519,7 +517,18 @@
 
 BinderStatus ApexService::destroyDeSnapshots(int rollback_id) {
   LOG(DEBUG) << "destroyDeSnapshots() received by ApexService.";
-  Result<void> res = ::android::apex::destroyDeSnapshots(rollback_id);
+  Result<void> res = ::android::apex::DestroyDeSnapshots(rollback_id);
+  if (!res.ok()) {
+    return BinderStatus::fromExceptionCode(
+        BinderStatus::EX_SERVICE_SPECIFIC,
+        String8(res.error().message().c_str()));
+  }
+  return BinderStatus::ok();
+}
+
+BinderStatus ApexService::destroyCeSnapshots(int user_id, int rollback_id) {
+  LOG(DEBUG) << "destroyCeSnapshots() received by ApexService.";
+  Result<void> res = ::android::apex::DestroyCeSnapshots(user_id, rollback_id);
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_SERVICE_SPECIFIC,
@@ -531,7 +540,7 @@
 BinderStatus ApexService::destroyCeSnapshotsNotSpecified(
     int user_id, const std::vector<int>& retain_rollback_ids) {
   LOG(DEBUG) << "destroyCeSnapshotsNotSpecified() received by ApexService.";
-  Result<void> res = ::android::apex::destroyCeSnapshotsNotSpecified(
+  Result<void> res = ::android::apex::DestroyCeSnapshotsNotSpecified(
       user_id, retain_rollback_ids);
   if (!res.ok()) {
     return BinderStatus::fromExceptionCode(
@@ -549,7 +558,7 @@
   if (auto root = CheckCallerIsRoot("remountPackages"); !root.isOk()) {
     return root;
   }
-  if (auto res = ::android::apex::remountPackages(); !res.ok()) {
+  if (auto res = ::android::apex::RemountPackages(); !res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_SERVICE_SPECIFIC,
         String8(res.error().message().c_str()));
@@ -570,7 +579,7 @@
     return root;
   }
   ApexPreinstalledData& instance = ApexPreinstalledData::GetInstance();
-  if (auto res = instance.Initialize(paths); !res) {
+  if (auto res = instance.Initialize(paths); !res.ok()) {
     return BinderStatus::fromExceptionCode(
         BinderStatus::EX_SERVICE_SPECIFIC,
         String8(res.error().message().c_str()));
@@ -590,16 +599,18 @@
       for (int i = 0; i < argc && _aidl_data.dataAvail() > 0; i++) {
         args.add(_aidl_data.readString16());
       }
-      sp<IBinder> unusedCallback;
-      sp<IResultReceiver> resultReceiver;
+      sp<IBinder> unused_callback;
+      sp<IResultReceiver> result_receiver;
       status_t status;
-      if ((status = _aidl_data.readNullableStrongBinder(&unusedCallback)) != OK)
+      if ((status = _aidl_data.readNullableStrongBinder(&unused_callback)) !=
+          OK)
         return status;
-      if ((status = _aidl_data.readNullableStrongBinder(&resultReceiver)) != OK)
+      if ((status = _aidl_data.readNullableStrongBinder(&result_receiver)) !=
+          OK)
         return status;
       status = shellCommand(in, out, err, args);
-      if (resultReceiver != nullptr) {
-        resultReceiver->send(status);
+      if (result_receiver != nullptr) {
+        result_receiver->send(status);
       }
       return OK;
     }
@@ -618,7 +629,7 @@
     return BAD_VALUE;
   } else {
     for (const auto& item : list) {
-      std::string msg = toString(item);
+      std::string msg = ToString(item);
       dprintf(fd, "%s", msg.c_str());
     }
   }
@@ -662,25 +673,25 @@
     }
     log << "ApexService:" << std::endl
         << "  help - display this help" << std::endl
-        << "  stagePackages [packagePath1] ([packagePath2]...) - stage "
+        << "  stagePackages [package_path1] ([package_path2]...) - stage "
            "multiple packages from the given path"
         << std::endl
-        << "  getActivePackage [packageName] - return info for active package "
+        << "  getActivePackage [package_name] - return info for active package "
            "with given name, if present"
         << std::endl
         << "  getAllPackages - return the list of all packages" << std::endl
         << "  getActivePackages - return the list of active packages"
         << std::endl
-        << "  activatePackage [packagePath] - activate package from the "
+        << "  activatePackage [package_path] - activate package from the "
            "given path"
         << std::endl
-        << "  deactivatePackage [packagePath] - deactivate package from the "
+        << "  deactivatePackage [package_path] - deactivate package from the "
            "given path"
         << std::endl
-        << "  preinstallPackages [packagePath1] ([packagePath2]...) - run "
+        << "  preinstallPackages [package_path1] ([package_path2]...) - run "
            "pre-install hooks of the given packages"
         << std::endl
-        << "  postinstallPackages [packagePath1] ([packagePath2]...) - run "
+        << "  postinstallPackages [package_path1] ([package_path2]...) - run "
            "post-install hooks of the given packages"
         << std::endl
         << "  getStagedSessionInfo [sessionId] - displays information about a "
@@ -712,7 +723,7 @@
 
   if (cmd == String16("stagePackages")) {
     if (args.size() < 2) {
-      print_help(err, "stagePackages requires at least one packagePath");
+      print_help(err, "stagePackages requires at least one package_path");
       return BAD_VALUE;
     }
     std::vector<std::string> pkgs;
@@ -738,7 +749,7 @@
     BinderStatus status = getAllPackages(&list);
     if (status.isOk()) {
       for (const auto& item : list) {
-        std::string msg = toString(item);
+        std::string msg = ToString(item);
         dprintf(out, "%s", msg.c_str());
       }
       return OK;
@@ -758,7 +769,7 @@
     BinderStatus status = getActivePackages(&list);
     if (status.isOk()) {
       for (const auto& item : list) {
-        std::string msg = toString(item);
+        std::string msg = ToString(item);
         dprintf(out, "%s", msg.c_str());
       }
       return OK;
@@ -778,7 +789,7 @@
     ApexInfo package;
     BinderStatus status = getActivePackage(String8(args[1]).string(), &package);
     if (status.isOk()) {
-      std::string msg = toString(package);
+      std::string msg = ToString(package);
       dprintf(out, "%s", msg.c_str());
       return OK;
     }
@@ -793,7 +804,7 @@
 
   if (cmd == String16("activatePackage")) {
     if (args.size() != 2) {
-      print_help(err, "activatePackage requires one packagePath");
+      print_help(err, "activatePackage requires one package_path");
       return BAD_VALUE;
     }
     BinderStatus status = activatePackage(String8(args[1]).string());
@@ -808,7 +819,7 @@
 
   if (cmd == String16("deactivatePackage")) {
     if (args.size() != 2) {
-      print_help(err, "deactivatePackage requires one packagePath");
+      print_help(err, "deactivatePackage requires one package_path");
       return BAD_VALUE;
     }
     BinderStatus status = deactivatePackage(String8(args[1]).string());
@@ -881,7 +892,7 @@
     BinderStatus status = submitStagedSession(params, &list);
     if (status.isOk()) {
         for (const auto& item : list.apexInfos) {
-          std::string msg = toString(item);
+          std::string msg = ToString(item);
           dprintf(out, "%s", msg.c_str());
         }
       return OK;
@@ -897,7 +908,7 @@
     if (args.size() < 2) {
       print_help(err,
                  "preinstallPackages/postinstallPackages requires at least"
-                 " one packagePath");
+                 " one package_path");
       return BAD_VALUE;
     }
     std::vector<std::string> pkgs;
@@ -954,15 +965,15 @@
   sp<ProcessState> ps(ProcessState::self());
 
   // Create binder service and register with LazyServiceRegistrar
-  sp<ApexService> apexService = new ApexService();
-  auto lazyRegistrar = LazyServiceRegistrar::getInstance();
-  lazyRegistrar.forcePersist(true);
-  lazyRegistrar.registerService(apexService, kApexServiceName);
+  sp<ApexService> apex_service = new ApexService();
+  auto lazy_registrar = LazyServiceRegistrar::getInstance();
+  lazy_registrar.forcePersist(true);
+  lazy_registrar.registerService(apex_service, kApexServiceName);
 }
 
 void AllowServiceShutdown() {
-  auto lazyRegistrar = LazyServiceRegistrar::getInstance();
-  lazyRegistrar.forcePersist(false);
+  auto lazy_registrar = LazyServiceRegistrar::getInstance();
+  lazy_registrar.forcePersist(false);
 }
 
 void StartThreadPool() {
diff --git a/apexd/apexservice_test.cpp b/apexd/apexservice_test.cpp
index 4549939..1a1a1c1 100644
--- a/apexd/apexservice_test.cpp
+++ b/apexd/apexservice_test.cpp
@@ -849,18 +849,10 @@
   ASSERT_TRUE(
       RegularFileExists("/data/misc_ce/0/apexdata/apex.apexd_test/hello.txt"));
 
-  int64_t result;
-  service_->snapshotCeData(0, 123456, "apex.apexd_test", &result);
+  service_->snapshotCeData(0, 123456, "apex.apexd_test");
 
   ASSERT_TRUE(RegularFileExists(
       "/data/misc_ce/0/apexrollback/123456/apex.apexd_test/hello.txt"));
-
-  // Check that the return value is the inode of the snapshot directory.
-  struct stat buf;
-  memset(&buf, 0, sizeof(buf));
-  ASSERT_EQ(0,
-            stat("/data/misc_ce/0/apexrollback/123456/apex.apexd_test", &buf));
-  ASSERT_EQ(int64_t(buf.st_ino), result);
 }
 
 TEST_F(ApexServiceTest, RestoreCeData) {
@@ -923,6 +915,31 @@
   ASSERT_FALSE(DirExists("/data/misc_de/0/apexrollback/123456"));
 }
 
+TEST_F(ApexServiceTest, DestroyCeSnapshots) {
+  CreateDir("/data/misc_ce/0/apexrollback/123456");
+  CreateDir("/data/misc_ce/0/apexrollback/123456/apex.apexd_test");
+  CreateFile("/data/misc_ce/0/apexrollback/123456/apex.apexd_test/file.txt");
+
+  CreateDir("/data/misc_ce/0/apexrollback/77777");
+  CreateDir("/data/misc_ce/0/apexrollback/77777/apex.apexd_test");
+  CreateFile("/data/misc_ce/0/apexrollback/77777/apex.apexd_test/thing.txt");
+
+  ASSERT_TRUE(RegularFileExists(
+      "/data/misc_ce/0/apexrollback/123456/apex.apexd_test/file.txt"));
+  ASSERT_TRUE(RegularFileExists(
+      "/data/misc_ce/0/apexrollback/77777/apex.apexd_test/thing.txt"));
+
+  android::binder::Status st = service_->destroyCeSnapshots(0, 123456);
+  ASSERT_TRUE(IsOk(st));
+  // Should be OK if the directory doesn't exist.
+  st = service_->destroyCeSnapshots(1, 123456);
+  ASSERT_TRUE(IsOk(st));
+
+  ASSERT_TRUE(RegularFileExists(
+      "/data/misc_ce/0/apexrollback/77777/apex.apexd_test/thing.txt"));
+  ASSERT_FALSE(DirExists("/data/misc_ce/0/apexrollback/123456"));
+}
+
 TEST_F(ApexServiceTest, DestroyCeSnapshotsNotSpecified) {
   CreateDir("/data/misc_ce/0/apexrollback/123456");
   CreateDir("/data/misc_ce/0/apexrollback/123456/apex.apexd_test");
@@ -1388,11 +1405,11 @@
 }
 
 TEST_F(ApexServiceTest, GetFactoryPackages) {
-  Result<std::vector<ApexInfo>> factoryPackages = GetFactoryPackages();
-  ASSERT_TRUE(IsOk(factoryPackages));
-  ASSERT_TRUE(factoryPackages->size() > 0);
+  Result<std::vector<ApexInfo>> factory_packages = GetFactoryPackages();
+  ASSERT_TRUE(IsOk(factory_packages));
+  ASSERT_TRUE(factory_packages->size() > 0);
 
-  for (const ApexInfo& package : *factoryPackages) {
+  for (const ApexInfo& package : *factory_packages) {
     bool is_builtin = false;
     for (const auto& dir : kApexPackageBuiltinDirs) {
       if (StartsWith(package.modulePath, dir)) {
@@ -1404,46 +1421,48 @@
 }
 
 TEST_F(ApexServiceTest, NoPackagesAreBothActiveAndInactive) {
-  Result<std::vector<ApexInfo>> activePackages = GetActivePackages();
-  ASSERT_TRUE(IsOk(activePackages));
-  ASSERT_TRUE(activePackages->size() > 0);
-  Result<std::vector<ApexInfo>> inactivePackages = GetInactivePackages();
-  ASSERT_TRUE(IsOk(inactivePackages));
-  std::vector<std::string> activePackagesStrings =
-      GetPackagesStrings(*activePackages);
-  std::vector<std::string> inactivePackagesStrings =
-      GetPackagesStrings(*inactivePackages);
-  std::sort(activePackagesStrings.begin(), activePackagesStrings.end());
-  std::sort(inactivePackagesStrings.begin(), inactivePackagesStrings.end());
+  Result<std::vector<ApexInfo>> active_packages = GetActivePackages();
+  ASSERT_TRUE(IsOk(active_packages));
+  ASSERT_TRUE(active_packages->size() > 0);
+  Result<std::vector<ApexInfo>> inactive_packages = GetInactivePackages();
+  ASSERT_TRUE(IsOk(inactive_packages));
+  std::vector<std::string> active_packages_strings =
+      GetPackagesStrings(*active_packages);
+  std::vector<std::string> inactive_packages_strings =
+      GetPackagesStrings(*inactive_packages);
+  std::sort(active_packages_strings.begin(), active_packages_strings.end());
+  std::sort(inactive_packages_strings.begin(), inactive_packages_strings.end());
   std::vector<std::string> intersection;
   std::set_intersection(
-      activePackagesStrings.begin(), activePackagesStrings.end(),
-      inactivePackagesStrings.begin(), inactivePackagesStrings.end(),
+      active_packages_strings.begin(), active_packages_strings.end(),
+      inactive_packages_strings.begin(), inactive_packages_strings.end(),
       std::back_inserter(intersection));
   ASSERT_THAT(intersection, SizeIs(0));
 }
 
 TEST_F(ApexServiceTest, GetAllPackages) {
-  Result<std::vector<ApexInfo>> allPackages = GetAllPackages();
-  ASSERT_TRUE(IsOk(allPackages));
-  ASSERT_TRUE(allPackages->size() > 0);
-  Result<std::vector<ApexInfo>> activePackages = GetActivePackages();
-  std::vector<std::string> activeStrings = GetPackagesStrings(*activePackages);
-  Result<std::vector<ApexInfo>> factoryPackages = GetFactoryPackages();
-  std::vector<std::string> factoryStrings =
-      GetPackagesStrings(*factoryPackages);
-  for (ApexInfo& apexInfo : *allPackages) {
-    std::string packageString = GetPackageString(apexInfo);
-    bool shouldBeActive = std::find(activeStrings.begin(), activeStrings.end(),
-                                    packageString) != activeStrings.end();
-    bool shouldBeFactory =
-        std::find(factoryStrings.begin(), factoryStrings.end(),
-                  packageString) != factoryStrings.end();
-    ASSERT_EQ(shouldBeActive, apexInfo.isActive)
-        << packageString << " should " << (shouldBeActive ? "" : "not ")
+  Result<std::vector<ApexInfo>> all_packages = GetAllPackages();
+  ASSERT_TRUE(IsOk(all_packages));
+  ASSERT_TRUE(all_packages->size() > 0);
+  Result<std::vector<ApexInfo>> active_packages = GetActivePackages();
+  std::vector<std::string> active_strings =
+      GetPackagesStrings(*active_packages);
+  Result<std::vector<ApexInfo>> factory_packages = GetFactoryPackages();
+  std::vector<std::string> factory_strings =
+      GetPackagesStrings(*factory_packages);
+  for (ApexInfo& apexInfo : *all_packages) {
+    std::string package_string = GetPackageString(apexInfo);
+    bool should_be_active =
+        std::find(active_strings.begin(), active_strings.end(),
+                  package_string) != active_strings.end();
+    bool should_be_factory =
+        std::find(factory_strings.begin(), factory_strings.end(),
+                  package_string) != factory_strings.end();
+    ASSERT_EQ(should_be_active, apexInfo.isActive)
+        << package_string << " should " << (should_be_active ? "" : "not ")
         << "be active";
-    ASSERT_EQ(shouldBeFactory, apexInfo.isFactory)
-        << packageString << " should " << (shouldBeFactory ? "" : "not ")
+    ASSERT_EQ(should_be_factory, apexInfo.isFactory)
+        << package_string << " should " << (should_be_factory ? "" : "not ")
         << "be factory";
   }
 }
@@ -2094,7 +2113,7 @@
   }
 
   // Make sure /data/apex/backups exists.
-  ASSERT_TRUE(IsOk(createDirIfNeeded(std::string(kApexBackupDir), 0700)));
+  ASSERT_TRUE(IsOk(CreateDirIfNeeded(std::string(kApexBackupDir), 0700)));
   // Create some bogus files in /data/apex/backups.
   std::ofstream old_backup(StringPrintf("%s/file1", kApexBackupDir));
   ASSERT_TRUE(old_backup.good());
@@ -2138,7 +2157,7 @@
 
   // Make sure that /data/apex/active exists and is empty
   ASSERT_TRUE(
-      IsOk(createDirIfNeeded(std::string(kActiveApexPackagesDataDir), 0755)));
+      IsOk(CreateDirIfNeeded(std::string(kActiveApexPackagesDataDir), 0755)));
   auto active_pkgs = ReadEntireDir(kActiveApexPackagesDataDir);
   ASSERT_TRUE(IsOk(active_pkgs));
   ASSERT_EQ(0u, active_pkgs->size());
@@ -2237,7 +2256,7 @@
   void SetUp() override { ApexServiceTest::SetUp(); }
 
   void PrepareBackup(const std::vector<std::string>& pkgs) {
-    ASSERT_TRUE(IsOk(createDirIfNeeded(std::string(kApexBackupDir), 0700)));
+    ASSERT_TRUE(IsOk(CreateDirIfNeeded(std::string(kApexBackupDir), 0700)));
     for (const auto& pkg : pkgs) {
       PrepareTestApexForInstall installer(pkg);
       ASSERT_TRUE(installer.Prepare()) << " failed to prepare " << pkg;
@@ -2451,7 +2470,7 @@
   // TODO(ioffe): this is calling into internals of apexd which makes test quite
   //  britle. With some refactoring we should be able to call binder api, or
   //  make this a unit test of apexd.cpp.
-  Result<void> res = ::android::apex::revertActiveSessions(native_process);
+  Result<void> res = ::android::apex::RevertActiveSessions(native_process);
   session = ApexSession::GetSession(1543);
   ASSERT_EQ(session->GetCrashingNativeProcess(), native_process);
 }
diff --git a/docs/howto.md b/docs/howto.md
index 2c52b3a..d755f8a 100644
--- a/docs/howto.md
+++ b/docs/howto.md
@@ -107,7 +107,7 @@
 Use this when a lib has to be accessed across the APEX boundary, e.g. between
 APEXes or between an APEX and the platform.
 
-### `apex_available`
+### apex_available
 
 Any module that is “included” (not just referenced) in an APEX either via the
 direct dependency or the transitive dependency has to correctly set the
diff --git a/libs/libapexutil/apexutil.cpp b/libs/libapexutil/apexutil.cpp
index e0b0787..6203a3b 100644
--- a/libs/libapexutil/apexutil.cpp
+++ b/libs/libapexutil/apexutil.cpp
@@ -18,6 +18,7 @@
 #include "apexutil.h"
 
 #include <dirent.h>
+#include <string.h>
 
 #include <memory>
 
@@ -67,6 +68,8 @@
       continue;
     if (strchr(entry->d_name, '@') != nullptr)
       continue;
+    if (strcmp(entry->d_name, "sharedlibs") == 0)
+      continue;
     std::string apex_path = apex_root + "/" + entry->d_name;
     auto manifest = ParseApexManifest(apex_path + "/apex_manifest.pb");
     if (manifest.ok()) {