Enable loading native libraries with RTLD_DEEPBIND

base/native_library_posix.cc

 // Copyright (c) 2011 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/native_library.h"
 
 #include <dlfcn.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 
 std::string NativeLibraryLoadError::ToString() const {
   return message;
 }
 
 // static
-NativeLibrary LoadNativeLibrary(const FilePath& library_path,
-                                NativeLibraryLoadError* error) {
+NativeLibrary LoadNativeLibraryWithOptions(const FilePath& library_path,
+                                           const NativeLibraryOptions& options,
+                                           NativeLibraryLoadError* error) {
   // dlopen() opens the file off disk.
   ThreadRestrictions::AssertIOAllowed();
 
-  // We deliberately do not use RTLD_DEEPBIND.  For the history why, please
-  // refer to the bug tracker.  Some useful bug reports to read include:
+  // We deliberately do not use RTLD_DEEPBIND by default.  For the history why,
+  // please refer to the bug tracker.  Some useful bug reports to read include:
   // http://crbug.com/17943, http://crbug.com/17557, http://crbug.com/36892,
   // and http://crbug.com/40794.
-  void* dl = dlopen(library_path.value().c_str(), RTLD_LAZY);
+  int flags = RTLD_LAZY;
+#if !defined(OS_ANDROID)
+  if (options.prefer_own_symbols)
+    flags |= RTLD_DEEPBIND;

[Primiano Tucci (use gerrit), 2016/08/24 22:14:09]

are you sue you don't need also  RTLD_GLOBAL?
Can you do a test to you hax toy example, adding an extra library that libhax.so
depends on, which calls malloc and see if RTLD_GLOBAL affects binding of that
third library?

[Ken Rockot(use gerrit already), 2016/08/24 23:23:57]

We may want this behavior but it might be worth keeping that separated from this
CL. I'm not sure what behavior is on Windows for example, and I'd like to write
and test that change indepedently. We do not currently have any need to load
DSOs which are linked against other shared libraries.

+#endif
+  void* dl = dlopen(library_path.value().c_str(), flags);
   if (!dl && error)
     error->message = dlerror();
 
   return dl;
 }
 
 // static
 void UnloadNativeLibrary(NativeLibrary library) {
   int ret = dlclose(library);
   if (ret < 0) {
     DLOG(ERROR) << "dlclose failed: " << dlerror();
     NOTREACHED();
   }
 }
 
 // static
 void* GetFunctionPointerFromNativeLibrary(NativeLibrary library,
                                           StringPiece name) {
   return dlsym(library, name.data());
 }
 
 // static
 std::string GetNativeLibraryName(StringPiece name) {
   DCHECK(IsStringASCII(name));
   return "lib" + name.as_string() + ".so";
 }
 
 }  // namespace base