Revert "Use real locations when opening dex files from the context"

This reverts commit 821a2595e2438554424879d6cb3594810ca8e636.

Reason for revert: Oat file assistant logic was updated to not
use realpaths anymore. So this is no longer needed.

Test: m test-art-host-gtest

Change-Id: Ia63a50f60b82ec3e20606d0be852607c9d2eb26e

2 files changed, 30 insertions, 68 deletions

diff --git a/runtime/class_loader_context.cc b/runtime/class_loader_context.cc
index 38f59efdf7..b62764f4c6 100644
--- a/runtime/class_loader_context.cc
+++ b/runtime/class_loader_context.cc
@@ -16,9 +16,6 @@
 
 #include "class_loader_context.h"
 
-#include <stdlib.h>
-
-#include "android-base/file.h"
 #include "art_field-inl.h"
 #include "base/dchecked_vector.h"
 #include "base/stl_util.h"
@@ -210,19 +207,9 @@ bool ClassLoaderContext::OpenDexFiles(InstructionSet isa, const std::string& cla
     size_t opened_dex_files_index = info.opened_dex_files.size();
     for (const std::string& cp_elem : info.classpath) {
       // If path is relative, append it to the provided base directory.
-      std::string raw_location = cp_elem;
-      if (raw_location[0] != '/' && !classpath_dir.empty()) {
-        raw_location = classpath_dir + '/' + raw_location;
-      }
-
-      std::string location;  // the real location of the class path element.
-
-      if (!android::base::Realpath(raw_location, &location)) {
-        // If we can't get the realpath of the location there might be something wrong with the
-        // classpath (maybe the file was deleted).
-        // Do not continue in this case and return false.
-        PLOG(WARNING) << "Could not get the realpath of dex location " << raw_location;
-        return false;
+      std::string location = cp_elem;
+      if (location[0] != '/' && !classpath_dir.empty()) {
+        location = classpath_dir + '/' + location;
       }
 
       std::string error_msg;
@@ -728,15 +715,20 @@ bool ClassLoaderContext::VerifyClassLoaderContextMatch(const std::string& contex
         dex_name = info.classpath[k];
         expected_dex_name = OatFile::ResolveRelativeEncodedDexLocation(
             info.classpath[k].c_str(), expected_info.classpath[k]);
-      } else {
+      } else if (is_expected_dex_name_absolute) {
         // The runtime name is relative but the compiled name is absolute.
         // There is no expected use case that would end up here as dex files are always loaded
         // with their absolute location. However, be tolerant and do the best effort (in case
         // there are unexpected new use case...).
-        DCHECK(is_expected_dex_name_absolute);
         dex_name = OatFile::ResolveRelativeEncodedDexLocation(
             expected_info.classpath[k].c_str(), info.classpath[k]);
         expected_dex_name = expected_info.classpath[k];
+      } else {
+        // Both locations are relative. In this case there's not much we can be sure about
+        // except that the names are the same. The checksum will ensure that the files are
+        // are same. This should not happen outside testing and manual invocations.
+        dex_name = info.classpath[k];
+        expected_dex_name = expected_info.classpath[k];
       }
 
       // Compare the locations.
diff --git a/runtime/class_loader_context_test.cc b/runtime/class_loader_context_test.cc
index be6acde4a9..fc3446c3f9 100644
--- a/runtime/class_loader_context_test.cc
+++ b/runtime/class_loader_context_test.cc
@@ -17,17 +17,13 @@
 #include "class_loader_context.h"
 
 #include <gtest/gtest.h>
-#include <stdlib.h>
 
 #include "android-base/strings.h"
-
 #include "base/dchecked_vector.h"
 #include "base/stl_util.h"
-#include "class_loader_context.h"
 #include "class_linker.h"
 #include "common_runtime_test.h"
 #include "dex_file.h"
-#include "dex2oat_environment_test.h"
 #include "handle_scope-inl.h"
 #include "mirror/class.h"
 #include "mirror/class_loader.h"
@@ -84,6 +80,10 @@ class ClassLoaderContextTest : public CommonRuntimeTest {
     kEndsWith
   };
 
+  static bool IsAbsoluteLocation(const std::string& location) {
+    return !location.empty() && location[0] == '/';
+  }
+
   void VerifyOpenDexFiles(
       ClassLoaderContext* context,
       size_t index,
@@ -100,17 +100,22 @@ class ClassLoaderContextTest : public CommonRuntimeTest {
             info.opened_dex_files[cur_open_dex_index++];
       std::unique_ptr<const DexFile>& expected_dex_file = (*all_dex_files)[k];
 
-      std::string expected_location =
-          DexFileLoader::GetBaseLocation(expected_dex_file->GetLocation());
-      UniqueCPtr<const char[]> expected_real_location(
-          realpath(expected_location.c_str(), nullptr));
-      ASSERT_TRUE(expected_real_location != nullptr) << expected_location;
-      expected_location.assign(expected_real_location.get());
-      expected_location += DexFileLoader::GetMultiDexSuffix(expected_dex_file->GetLocation());
-
-      ASSERT_EQ(expected_location, opened_dex_file->GetLocation());
+      std::string expected_location = expected_dex_file->GetLocation();
+
+      const std::string& opened_location = opened_dex_file->GetLocation();
+      if (!IsAbsoluteLocation(opened_location)) {
+        // If the opened location is relative (it was open from a relative path without a
+        // classpath_dir) it might not match the expected location which is absolute in tests).
+        // So we compare the endings (the checksum will validate it's actually the same file).
+        ASSERT_EQ(0, expected_location.compare(
+            expected_location.length() - opened_location.length(),
+            opened_location.length(),
+            opened_location));
+      } else {
+        ASSERT_EQ(expected_location, opened_location);
+      }
       ASSERT_EQ(expected_dex_file->GetLocationChecksum(), opened_dex_file->GetLocationChecksum());
-      ASSERT_EQ(info.classpath[k], opened_dex_file->GetLocation());
+      ASSERT_EQ(info.classpath[k], opened_location);
     }
   }
 
@@ -252,6 +257,7 @@ TEST_F(ClassLoaderContextTest, OpenValidDexFiles) {
   std::string myclass_dex_name = GetTestDexFileName("MyClass");
   std::string dex_name = GetTestDexFileName("Main");
 
+
   std::unique_ptr<ClassLoaderContext> context =
       ClassLoaderContext::Create(
           "PCL[" + multidex_name + ":" + myclass_dex_name + "];" +
@@ -272,42 +278,6 @@ TEST_F(ClassLoaderContextTest, OpenValidDexFiles) {
   VerifyOpenDexFiles(context.get(), 1, &all_dex_files1);
 }
 
-class ScratchSymLink {
- public:
-  explicit ScratchSymLink(const std::string& file) {
-    // Use a temporary scratch file to get a unique name for the link.
-    ScratchFile scratchFile;
-    scratch_link_name_ = scratchFile.GetFilename() + ".link.jar";
-    CHECK_EQ(0, symlink(file.c_str(), scratch_link_name_.c_str()));
-  }
-
-  ~ScratchSymLink() {
-    CHECK_EQ(0, unlink(scratch_link_name_.c_str()));
-  }
-
-  const std::string& GetFilename() { return scratch_link_name_; }
-
- private:
-  std::string scratch_link_name_;
-};
-
-TEST_F(ClassLoaderContextTest, OpenValidDexFilesSymLink) {
-  std::string myclass_dex_name = GetTestDexFileName("MyClass");
-  // Now replace the dex location with a symlink.
-  ScratchSymLink link(myclass_dex_name);
-
-  std::unique_ptr<ClassLoaderContext> context =
-      ClassLoaderContext::Create("PCL[" + link.GetFilename() + "]");
-
-  ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, /*classpath_dir*/ ""));
-
-  VerifyContextSize(context.get(), 1);
-
-  std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
-
-  VerifyOpenDexFiles(context.get(), 0, &myclass_dex_files);
-}
-
 static std::string CreateRelativeString(const std::string& in, const char* cwd) {
   int cwd_len = strlen(cwd);
   if (!android::base::StartsWith(in, cwd) || (cwd_len < 1)) {