1 files changed, 40 insertions, 42 deletions

diff --git a/runtime/oat_file_assistant.cc b/runtime/oat_file_assistant.cc
index cbbb31cd4f..9e16e49e40 100644
--- a/runtime/oat_file_assistant.cc
+++ b/runtime/oat_file_assistant.cc
@@ -453,11 +453,11 @@ bool OatFileAssistant::LoadDexFiles(const OatFile& oat_file,
 
 std::optional<bool> OatFileAssistant::HasDexFiles(std::string* error_msg) {
   ScopedTrace trace("HasDexFiles");
-  std::optional<std::uint32_t> checksum;
-  if (!GetRequiredDexChecksum(&checksum, error_msg)) {
+  const std::vector<std::uint32_t>* checksums = GetRequiredDexChecksums(error_msg);
+  if (checksums == nullptr) {
     return std::nullopt;
   }
-  return checksum.has_value();
+  return !checksums->empty();
 }
 
 OatFileAssistant::OatStatus OatFileAssistant::OdexFileStatus() { return odex_.Status(); }
@@ -471,35 +471,37 @@ bool OatFileAssistant::DexChecksumUpToDate(const OatFile& file, std::string* err
     return true;
   }
   ScopedTrace trace("DexChecksumUpToDate");
-  std::optional<std::uint32_t> dex_checksum;
-  if (!GetRequiredDexChecksum(&dex_checksum, error_msg)) {
+  const std::vector<uint32_t>* required_dex_checksums = GetRequiredDexChecksums(error_msg);
+  if (required_dex_checksums == nullptr) {
     return false;
   }
-  if (!dex_checksum.has_value()) {
+  if (required_dex_checksums->empty()) {
     LOG(WARNING) << "Required dex checksums not found. Assuming dex checksums are up to date.";
     return true;
   }
 
-  std::vector<const OatDexFile*> oat_dex_files;
   uint32_t number_of_dex_files = file.GetOatHeader().GetDexFileCount();
+  if (required_dex_checksums->size() != number_of_dex_files) {
+    *error_msg = StringPrintf(
+        "expected %zu dex files but found %u", required_dex_checksums->size(), number_of_dex_files);
+    return false;
+  }
+
   for (uint32_t i = 0; i < number_of_dex_files; i++) {
     std::string dex = DexFileLoader::GetMultiDexLocation(i, dex_location_.c_str());
+    uint32_t expected_checksum = (*required_dex_checksums)[i];
     const OatDexFile* oat_dex_file = file.GetOatDexFile(dex.c_str(), nullptr);
     if (oat_dex_file == nullptr) {
       *error_msg = StringPrintf("failed to find %s in %s", dex.c_str(), file.GetLocation().c_str());
       return false;
     }
-    oat_dex_files.push_back(oat_dex_file);
-  }
-  uint32_t oat_checksum = DexFileLoader::GetMultiDexChecksum(oat_dex_files);
-
-  CHECK(dex_checksum.has_value());
-  if (dex_checksum != oat_checksum) {
-    VLOG(oat) << "Checksum does not match: " << std::hex << file.GetLocation() << " ("
-              << oat_checksum << ") vs " << dex_location_ << " (" << *dex_checksum << ")";
-    return false;
+    uint32_t actual_checksum = oat_dex_file->GetDexFileLocationChecksum();
+    if (expected_checksum != actual_checksum) {
+      VLOG(oat) << "Dex checksum does not match for dex: " << dex
+                << ". Expected: " << expected_checksum << ", Actual: " << actual_checksum;
+      return false;
+    }
   }
-
   return true;
 }
 
@@ -716,36 +718,33 @@ bool OatFileAssistant::DexLocationToOatFilename(const std::string& location,
   return GetDalvikCacheFilename(location.c_str(), dalvik_cache.c_str(), oat_filename, error_msg);
 }
 
-bool OatFileAssistant::GetRequiredDexChecksum(std::optional<uint32_t>* checksum,
-                                              std::string* error) {
+const std::vector<uint32_t>* OatFileAssistant::GetRequiredDexChecksums(std::string* error_msg) {
   if (!required_dex_checksums_attempted_) {
     required_dex_checksums_attempted_ = true;
+    std::vector<uint32_t> checksums;
+    std::vector<std::string> dex_locations_ignored;
+    if (ArtDexFileLoader::GetMultiDexChecksums(dex_location_.c_str(),
+                                               &checksums,
+                                               &dex_locations_ignored,
+                                               &cached_required_dex_checksums_error_,
+                                               zip_fd_,
+                                               &zip_file_only_contains_uncompressed_dex_)) {
+      if (checksums.empty()) {
+        // The only valid case here is for APKs without dex files.
+        VLOG(oat) << "No dex file found in " << dex_location_;
+      }
 
-    ArtDexFileLoader dex_loader(zip_fd_, dex_location_);
-    std::optional<uint32_t> checksum2;
-    std::string error2;
-    if (dex_loader.GetMultiDexChecksum(
-            &checksum2, &error2, &zip_file_only_contains_uncompressed_dex_)) {
-      cached_required_dex_checksums_ = checksum2;
-      cached_required_dex_checksums_error_ = std::nullopt;
-    } else {
-      cached_required_dex_checksums_ = std::nullopt;
-      cached_required_dex_checksums_error_ = error2;
+      cached_required_dex_checksums_ = std::move(checksums);
     }
   }
 
-  if (cached_required_dex_checksums_error_.has_value()) {
-    *error = cached_required_dex_checksums_error_.value();
-    DCHECK(!error->empty());
-    return false;
-  }
-
-  if (!cached_required_dex_checksums_.has_value()) {
-    // The only valid case here is for APKs without dex files.
-    VLOG(oat) << "No dex file found in " << dex_location_;
+  if (cached_required_dex_checksums_.has_value()) {
+    return &cached_required_dex_checksums_.value();
+  } else {
+    *error_msg = cached_required_dex_checksums_error_;
+    DCHECK(!error_msg->empty());
+    return nullptr;
   }
-  *checksum = cached_required_dex_checksums_;
-  return true;
 }
 
 bool OatFileAssistant::ValidateBootClassPathChecksums(OatFileAssistantContext* ofa_context,
@@ -1381,9 +1380,8 @@ void OatFileAssistant::GetOptimizationStatus(std::string* out_odex_location,
 
 bool OatFileAssistant::ZipFileOnlyContainsUncompressedDex() {
   // zip_file_only_contains_uncompressed_dex_ is only set during fetching the dex checksums.
-  std::optional<uint32_t> checksum;
   std::string error_msg;
-  if (!GetRequiredDexChecksum(&checksum, &error_msg)) {
+  if (GetRequiredDexChecksums(&error_msg) == nullptr) {
     LOG(ERROR) << error_msg;
   }
   return zip_file_only_contains_uncompressed_dex_;