Inject CanAddURLToHistory into TopSitesImpl

third_party/android_crazy_linker/src/src/crazy_linker_shared_library.cpp

 // Copyright 2014 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 "crazy_linker_shared_library.h"
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <elf.h>
@@ skipping 83 matching lines @@
 // An instance of ElfRelocator::SymbolResolver that can be used
 // to resolve symbols in a shared library being loaded by
 // LibraryList::LoadLibrary.
 class SharedLibraryResolver : public ElfRelocations::SymbolResolver {
  public:
   SharedLibraryResolver(SharedLibrary* lib,
                         LibraryList* lib_list,
                         Vector<LibraryView*>* preloads,
                         Vector<LibraryView*>* dependencies)
       : main_program_handle_(::dlopen(NULL, RTLD_NOW)),
-        sdk_build_version_(*Globals::GetSDKBuildVersion()),
         lib_(lib), preloads_(preloads), dependencies_(dependencies) {}
 
   virtual void* Lookup(const char* symbol_name) {
     // First, look inside the current library.
     const ELF::Sym* entry = lib_->LookupSymbolEntry(symbol_name);
     if (entry)
       return reinterpret_cast<void*>(lib_->load_bias() + entry->st_value);
 
     // Special case: redirect the dynamic linker symbols to our wrappers.
     // This ensures that loaded libraries can call dlopen() / dlsym()
     // and transparently use the crazy linker to perform their duty.
     void* address = WrapLinkerSymbol(symbol_name);
     if (address)
       return address;
 
-    // Make sure that we do nothing here for non-Lollipop platforms.
-    // In practice, preloads_ will be empty (because we ignore LD_PRELOAD
-    // when not Lollipop) and searching in the main executable should be
-    // benign. But crbug/479220 is weird enough that we want to take all
-    // possible precautions.
+    // Then look inside the preloads.
     //
-    // For more, see:
-    //   https://code.google.com/p/chromium/issues/detail?id=479220
-    if (sdk_build_version_ == SDK_VERSION_CODE_LOLLIPOP) {
-      // Then look inside the preloads.
-      //
-      // Note that searching preloads *before* the main executable is opposite
-      // to the search ordering used by the system linker, but it is required
-      // to work round a dlsym() bug in some Android releases (on releases
-      // without this dlsym() bug preloads_ will be empty, making this preloads
-      // search a no-op).
-      //
-      // For more, see commentary in LibraryList(), and
-      //   https://code.google.com/p/android/issues/detail?id=74255
-      for (size_t n = 0; n < preloads_->GetCount(); ++n) {
-        LibraryView* wrap = (*preloads_)[n];
-        // LOG("%s: Looking into preload %p (%s)\n", __FUNCTION__, wrap,
-        // wrap->GetName());
-        address = LookupInWrap(symbol_name, wrap);
-        if (address)
-          return address;
-      }
-    }
-
-    // Do not lookup inside the main executable for pre-Lollipop, for
-    // crbug/479220. We do however want to do it for Lollipop and
-    // later, because in Lollipop-mr1 the dlsym() bug is fixed, so that
-    // we don't explicitly handle LD_PRELOADS but instead rely on dlsym
-    // correctly searching preloads via the main executable.
+    // Note that searching preloads *before* the main executable is opposite
+    // to the search ordering used by the system linker, but it is required
+    // to work round a dlsym() bug in some Android releases (on releases
+    // without this dlsym() bug preloads_ will be empty, making this preloads
+    // search a no-op).
     //
-    // For more, see:
-    //   https://code.google.com/p/chromium/issues/detail?id=479220
-    if (sdk_build_version_ >= SDK_VERSION_CODE_LOLLIPOP) {
-      // Then look inside the main executable.
-      address = ::dlsym(main_program_handle_, symbol_name);
+    // For more, see commentary in LibraryList(), and
+    //   https://code.google.com/p/android/issues/detail?id=74255
+    for (size_t n = 0; n < preloads_->GetCount(); ++n) {
+      LibraryView* wrap = (*preloads_)[n];
+      // LOG("%s: Looking into preload %p (%s)\n", __FUNCTION__, wrap,
+      // wrap->GetName());
+      address = LookupInWrap(symbol_name, wrap);
       if (address)
         return address;
     }
 
+    // Then lookup inside the main executable.
+    address = ::dlsym(main_program_handle_, symbol_name);
+    if (address)
+      return address;
+
     // Then look inside the dependencies.
     for (size_t n = 0; n < dependencies_->GetCount(); ++n) {
       LibraryView* wrap = (*dependencies_)[n];
       // LOG("%s: Looking into dependency %p (%s)\n", __FUNCTION__, wrap,
       // wrap->GetName());
       address = LookupInWrap(symbol_name, wrap);
       if (address)
         return address;
     }
 
@@ skipping 28 matching lines @@
     if (wrap->IsCrazy()) {
       SharedLibrary* crazy = wrap->GetCrazy();
       const ELF::Sym* entry = crazy->LookupSymbolEntry(symbol_name);
       if (entry)
         return reinterpret_cast<void*>(crazy->load_bias() + entry->st_value);
     }
 
     return NULL;
   }
 
-  const int sdk_build_version_;
   void* main_program_handle_;
   SharedLibrary* lib_;
   Vector<LibraryView*>* preloads_;
   Vector<LibraryView*>* dependencies_;
 };
 
 #if defined(__arm__) || defined(__aarch64__)
 
 // Helper class to provide a simple scoped buffer.  ScopedPtr is not
 // usable here because it calls delete, not delete [].
@@ skipping 384 matching lines @@
     if (iter_.GetTag() == DT_NEEDED) {
       dep_name_ = symbols_->GetStringById(iter_.GetValue());
       iter_.GetNext();
       return true;
     }
   }
   return false;
 }
 
 }  // namespace crazy