Enable loading native libraries with RTLD_DEEPBIND

base/native_library_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/files/file_path.h"
 #include "base/native_library.h"
+#include "base/path_service.h"
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_WIN)
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+// This variable name must match the exported variable in
+// native_library_test_library.cc.
+int EXPORT g_native_library_exported_value = 0;
+
+// This function name must match the exported function with the same signature
+// in native_library_test_library.cc. This function must return a different
+// value from the one defined there.
+int EXPORT GetNativeLibraryTestMagicValue() { return 41; }
+
 namespace base {
 
 const FilePath::CharType kDummyLibraryPath[] =
     FILE_PATH_LITERAL("dummy_library");
 
 TEST(NativeLibraryTest, LoadFailure) {
   NativeLibraryLoadError error;
   EXPECT_FALSE(LoadNativeLibrary(FilePath(kDummyLibraryPath), &error));
   EXPECT_FALSE(error.ToString().empty());
 }
@@ skipping 10 matching lines @@
 #elif defined(OS_MACOSX)
       "libmylib.dylib";
 #elif defined(OS_POSIX)
       "libmylib.so";
 #elif defined(OS_WIN)
       "mylib.dll";
 #endif
   EXPECT_EQ(kExpectedName, GetNativeLibraryName("mylib"));
 }
 
+// We don't support dynamic loading on iOS, and ASAN will complain about our
+// intentional ODR violation here.
+#if !defined(OS_IOS) && !defined(ADDRESS_SANITIZER)
+
+const char kTestLibraryName[] =
+#if defined(OS_MACOSX)
+    "libnative_library_test_library.dylib";
+#elif defined(OS_ANDROID) && defined(COMPONENT_BUILD)
+    "libnative_library_test_library.cr.so";
+#elif defined(OS_POSIX)
+    "libnative_library_test_library.so";
+#elif defined(OS_WIN)
+    "native_library_test_library.dll";
+#endif
+
+class TestLibrary {
+ public:
+  explicit TestLibrary(
+      const NativeLibraryOptions& options = NativeLibraryOptions())
+      : library_(nullptr) {
+    base::FilePath exe_path;
+    CHECK(base::PathService::Get(base::DIR_EXE, &exe_path));
+
+    library_ = LoadNativeLibraryWithOptions(
+        exe_path.AppendASCII(kTestLibraryName), options, nullptr);
+    CHECK(library_);
+  }
+
+  ~TestLibrary() {
+    UnloadNativeLibrary(library_);
+  }
+
+  template <typename ReturnType, typename... Args>
+  ReturnType Call(const char* function_name, Args... args) {
+    return reinterpret_cast<ReturnType(*)(Args...)>(
+        GetFunctionPointerFromNativeLibrary(library_, function_name))(args...);
+  }
+
+ private:
+  NativeLibrary library_;
+};
+
+// Verifies that we can load a native library and resolve its exported symbols.
+TEST(NativeLibraryTest, LoadLibrary) {
+  TestLibrary library;
+  EXPECT_EQ(5, library.Call<int>("GetSimpleTestValue"));
+}
+
+// Android dlopen() behavior is not well specified and may vary across versions.
+#if !defined(OS_ANDROID)
+
+// Verifies that the |prefer_own_symbols| option satisfies its guarantee that
+// a loaded library will always prefer local symbol resolution before
+// considering global symbols.
+TEST(NativeLibraryTest, LoadLibraryPreferOwnSymbols) {
+  NativeLibraryOptions options;
+  options.prefer_own_symbols = true;
+  TestLibrary library(options);
+
+  // Verify that this binary and the DSO use different storage for
+  // |g_native_library_exported_value|.
+  g_native_library_exported_value = 1;
+  library.Call<void>("SetExportedValue", 2);
+  EXPECT_EQ(1, g_native_library_exported_value);
+  g_native_library_exported_value = 3;
+  EXPECT_EQ(2, library.Call<int>("GetExportedValue"));
+
+  // Both this binary and the library export GetNativeLibraryTestMagicValue(),
+  // which is called internally by the DSO's GetMagicValue(). We verify here
+  // that the DSO always calls its own local definition rather than ours.
+  EXPECT_EQ(42, library.Call<int>("GetMagicValue"));

[Ken Rockot(use gerrit already), 2016/08/25 17:43:21]

Only problem now: If prefer_own_symbols is false, this check still passes (the
ones above do NOT, as expected). So this means the test is somehow not quite
emulating the malloc behavior we want to test.

+
+  // Likewise, we should always call our own local definition.
+  EXPECT_EQ(41, GetNativeLibraryTestMagicValue());
+}
+
+#endif  // !defined(OS_ANDROID)
+
+#endif  // !defined(OS_IOS) && !defined(ADDRESS_SANITIZER)
+
 }  // namespace base