Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

android/java/src/org/chromium/base/library_loader/Linker.java

 // 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.
 
 package org.chromium.base.library_loader;
 
+import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.ParcelFileDescriptor;
 import android.os.Parcelable;
 
 import org.chromium.base.Log;
 import org.chromium.base.annotations.AccessedByNative;
 
 import java.util.HashMap;
 import java.util.Locale;
@@ skipping 199 matching lines @@
     // Singleton.
     private static Linker sSingleton = null;
     private static Object sSingletonLock = new Object();
 
     // Protected singleton constructor.
     protected Linker() {}
 
     /**
      * Get singleton instance. Returns either a LegacyLinker or a ModernLinker.
      *
+     * Returns a ModernLinker if running on Android M or later, otherwise returns
+     * a LegacyLinker.
+     *
+     * ModernLinker requires OS features from Android M and later: a system linker
+     * that handles packed relocations and load from APK, and android_dlopen_ext()
+     * for shared RELRO support. It cannot run on Android releases earlier than M.
+     *
+     * LegacyLinker runs on all Android releases but it is slower and more complex
+     * than ModernLinker, so ModernLinker is preferred for Android M and later.
+     *
      * @return the Linker implementation instance.
      */
     public static final Linker getInstance() {
         synchronized (sSingletonLock) {
             if (sSingleton == null) {
-                // TODO(simonb): Check version once the Android M build version
-                // code becomes available.
-                // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.<ANDROID-M>) {
-                if (false) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                     sSingleton = ModernLinker.create();
                 } else {
                     sSingleton = LegacyLinker.create();
                 }
                 Log.i(TAG, "Using linker: " + sSingleton.getClass().getName());
             }
             return sSingleton;
         }
     }
 
@@ skipping 212 matching lines @@
     public boolean isChromiumLinkerLibrary(String library) {
         return library.equals(LINKER_JNI_LIBRARY) || library.equals(LINKER_JNI_LIBRARY + ".cr");
     }
 
     /**
      * Load the Linker JNI library. Throws UnsatisfiedLinkError on error.
      * In a component build, the suffix ".cr" is added to each library name, so
      * if the initial load fails we retry with a suffix.
      */
     protected void loadLinkerJNILibrary() {
-        String lib_name = "lib" + LINKER_JNI_LIBRARY + ".so";
+        String libName = "lib" + LINKER_JNI_LIBRARY + ".so";
         if (DEBUG) {
-            Log.i(TAG, "Loading " + lib_name);
+            Log.i(TAG, "Loading " + libName);
         }
         try {
             System.loadLibrary(LINKER_JNI_LIBRARY);
         } catch (UnsatisfiedLinkError e) {
-            Log.w(TAG, "Couldn't load " + lib_name + ", trying " + lib_name + ".so");
+            Log.w(TAG, "Couldn't load " + libName + ", trying " + libName + ".so");
             System.loadLibrary(LINKER_JNI_LIBRARY + ".cr");
         }
     }
 
     /**
      * Obtain a random base load address at which to place loaded libraries.
      *
      * @return new base load address
      */
     protected long getRandomBaseLoadAddress() {
@@ skipping 278 matching lines @@
      * Return a random address that should be free to be mapped with the given size.
      * Maps an area large enough for the largest library we might attempt to load,
      * and if successful then unmaps it and returns the address of the area allocated
      * by the system (with ASLR). The idea is that this area should remain free of
      * other mappings until we map our library into it.
      *
      * @return address to pass to future mmap, or 0 on error.
      */
     private static native long nativeGetRandomBaseLoadAddress();
 }