Update to Chromium //base at Chromium commit e3a753f17bac62738b0dbf0b36510f767b081e4b.

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;
@@ skipping 130 matching lines @@
  *  - In a service process, finishLibraryLoad() and/or loadLibrary() may
  *    block until the RELRO section Bundle is received. This is typically
  *    done by calling useSharedRelros() from another thread.
  *
  *    This method also ensures the process uses the shared RELROs.
  */
 public abstract class Linker {
     // Log tag for this class.
     private static final String TAG = "cr.library_loader";
 
+    // Name of the library that contains our JNI code.
+    private static final String LINKER_JNI_LIBRARY = "chromium_android_linker";
+
     // Constants used to control the behaviour of the browser process with
     // regards to the shared RELRO section. Not applicable to ModernLinker.
     //   NEVER        -> The browser never uses it itself.
     //   LOW_RAM_ONLY -> It is only used on devices with low RAM.
     //   ALWAYS       -> It is always used.
     // NOTE: These names are known and expected by the Linker test scripts.
     public static final int BROWSER_SHARED_RELRO_CONFIG_NEVER = 0;
     public static final int BROWSER_SHARED_RELRO_CONFIG_LOW_RAM_ONLY = 1;
     public static final int BROWSER_SHARED_RELRO_CONFIG_ALWAYS = 2;
 
@@ skipping 12 matching lines @@
     public static final int MEMORY_DEVICE_CONFIG_INIT = 0;
     public static final int MEMORY_DEVICE_CONFIG_LOW = 1;
     public static final int MEMORY_DEVICE_CONFIG_NORMAL = 2;
 
     // Indicates if this is a low-memory device or not. The default is to
     // determine this by probing the system at runtime, but this can be forced
     // for testing by calling setMemoryDeviceConfigForTesting().
     // Not used by ModernLinker.
     protected int mMemoryDeviceConfig = MEMORY_DEVICE_CONFIG_INIT;
 
-    // Name of the library that contains our JNI code.
-    protected static final String LINKER_JNI_LIBRARY = "chromium_android_linker";
-
     // Set to true to enable debug logs.
     protected static final boolean DEBUG = false;
 
     // Used to pass the shared RELRO Bundle through Binder.
     public static final String EXTRA_LINKER_SHARED_RELROS =
             "org.chromium.base.android.linker.shared_relros";
 
     // Guards all access to the linker.
     protected final Object mLock = new Object();
 
@@ skipping 54 matching lines @@
         }
     }
 
     /**
      * Check that native library linker tests are enabled.
      * If not enabled, calls to testing functions will fail with an assertion
      * error.
      *
      * @return true if native library linker tests are enabled.
      */
-    public static boolean areLinkerTestsEnabled() {
+    public static boolean areTestsEnabled() {
         return NativeLibraries.sEnableLinkerTests;
     }
 
     /**
      * Assert for testing.
      * Hard assertion. Cannot be disabled. Used only by testing methods.
      */
     private static void assertForTesting(boolean flag) {
         if (!flag) {
             throw new AssertionError();
@@ skipping 14 matching lines @@
         }
     }
 
     /**
      * Set Linker implementation type.
      * For testing. Sets either a LegacyLinker or a ModernLinker. Must be called
      * before getInstance().
      *
      * @param type LINKER_IMPLEMENTATION_LEGACY or LINKER_IMPLEMENTATION_MODERN
      */
-    public static final void setLinkerImplementationForTesting(int type) {
+    public static final void setImplementationForTesting(int type) {
         // Sanity check. This method may only be called during tests.
         assertLinkerTestsAreEnabled();
         assertForTesting(
                 type == LINKER_IMPLEMENTATION_LEGACY || type == LINKER_IMPLEMENTATION_MODERN);
 
         synchronized (sSingletonLock) {
             assertForTesting(sSingleton == null);
 
             if (type == LINKER_IMPLEMENTATION_MODERN) {
                 sSingleton = ModernLinker.create();
             } else if (type == LINKER_IMPLEMENTATION_LEGACY) {
                 sSingleton = LegacyLinker.create();
             } else {
                 return;
             }
             Log.i(TAG, "Forced linker: " + sSingleton.getClass().getName());
         }
     }
 
     /**
      * Get Linker implementation type.
      * For testing.
      *
      * @return LINKER_IMPLEMENTATION_LEGACY or LINKER_IMPLEMENTATION_MODERN
      */
-    public int getLinkerImplementationForTesting() {
+    public int getImplementationForTesting() {
         // Sanity check. This method may only be called during tests.
         assertLinkerTestsAreEnabled();
-        assertForTesting(sSingleton != null);
 
-        if (sSingleton instanceof ModernLinker) {
-            return LINKER_IMPLEMENTATION_MODERN;
-        } else if (sSingleton instanceof LegacyLinker) {
-            return LINKER_IMPLEMENTATION_LEGACY;
+        synchronized (sSingletonLock) {
+            assertForTesting(sSingleton != null);
+
+            if (sSingleton instanceof ModernLinker) {
+                return LINKER_IMPLEMENTATION_MODERN;
+            } else if (sSingleton instanceof LegacyLinker) {
+                return LINKER_IMPLEMENTATION_LEGACY;
+            }
+            Log.e(TAG, "Invalid linker: " + sSingleton.getClass().getName());
+            return 0;
         }
-        Log.e(TAG, "Invalid linker: " + sSingleton.getClass().getName());
-        return 0;
     }
 
     /**
      * A public interface used to run runtime linker tests after loading
      * libraries. Should only be used to implement the linker unit tests,
      * which is controlled by the value of NativeLibraries.sEnableLinkerTests
      * configured at build time.
      */
     public interface TestRunner {
         /**
          * Run runtime checks and return true if they all pass.
          *
          * @param memoryDeviceConfig The current memory device configuration.
          * @param inBrowserProcess true iff this is the browser process.
          * @return true if all checks pass.
          */
         public boolean runChecks(int memoryDeviceConfig, boolean inBrowserProcess);
     }
 
     /**
      * Set the TestRunner by its class name. It will be instantiated at
      * runtime after all libraries are loaded.
      *
      * @param testRunnerClassName null or a String for the class name of the
      * TestRunner to use.
      */
     public void setTestRunnerClassNameForTesting(String testRunnerClassName) {
         if (DEBUG) {
-            Log.i(TAG, "setTestRunnerByClassNameForTesting(" + testRunnerClassName + ") called");
+            Log.i(TAG, "setTestRunnerClassNameForTesting(" + testRunnerClassName + ") called");
         }
         // Sanity check. This method may only be called during tests.
         assertLinkerTestsAreEnabled();
 
         synchronized (mLock) {
             assertForTesting(mTestRunnerClassName == null);
             mTestRunnerClassName = testRunnerClassName;
         }
     }
 
     /**
      * Call this to retrieve the name of the current TestRunner class name
      * if any. This can be useful to pass it from the browser process to
      * child ones.
      *
      * @return null or a String holding the name of the class implementing
      * the TestRunner set by calling setTestRunnerClassNameForTesting() previously.
      */
     public String getTestRunnerClassNameForTesting() {
         // Sanity check. This method may only be called during tests.
         assertLinkerTestsAreEnabled();
 
         synchronized (mLock) {
             return mTestRunnerClassName;
         }
     }
 
     /**
+     * Set up the Linker for a test.
+     * Convenience function that calls setImplementationForTesting() to force an
+     * implementation, and then setTestRunnerClassNameForTesting() to set the test
+     * class name.
+     *
+     * On first call, instantiates a Linker of the requested type and sets its test
+     * runner class name. On subsequent calls, checks that the singleton produced by
+     * the first call matches the requested type and test runner class name.
+     */
+    public static void setupForTesting(int type, String testRunnerClassName) {
+        if (DEBUG) {
+            Log.i(TAG, "setupForTesting(" + type + ", " + testRunnerClassName + ") called");
+        }
+        // Sanity check. This method may only be called during tests.
+        assertLinkerTestsAreEnabled();
+
+        synchronized (sSingletonLock) {
+            // If this is the first call, configure the Linker to the given type and test class.
+            if (sSingleton == null) {
+                setImplementationForTesting(type);
+                sSingleton.setTestRunnerClassNameForTesting(testRunnerClassName);
+                return;
+            }
+
+            // If not the first call, check that the Linker configuration matches this request.
+            assertForTesting(sSingleton.getImplementationForTesting() == type);
+            String ourTestRunnerClassName = sSingleton.getTestRunnerClassNameForTesting();
+            if (testRunnerClassName == null) {
+                assertForTesting(ourTestRunnerClassName == null);
+            } else {
+                assertForTesting(ourTestRunnerClassName.equals(testRunnerClassName));
+            }
+        }
+    }
+
+    /**
      * Instantiate and run the current TestRunner, if any. The TestRunner implementation
      * must be instantiated _after_ all libraries are loaded to ensure that its
      * native methods are properly registered.
      *
      * @param memoryDeviceConfig LegacyLinker memory config, or 0 if unused
      * @param inBrowserProcess true if in the browser process
      */
     protected void runTestRunnerClassForTesting(int memoryDeviceConfig, boolean inBrowserProcess) {
         if (DEBUG) {
             Log.i(TAG, "runTestRunnerClassForTesting called");
@@ skipping 64 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() {
+    protected static void loadLinkerJniLibrary() {
         String libName = "lib" + LINKER_JNI_LIBRARY + ".so";
         if (DEBUG) {
             Log.i(TAG, "Loading " + libName);
         }
         try {
             System.loadLibrary(LINKER_JNI_LIBRARY);
         } catch (UnsatisfiedLinkError e) {
-            Log.w(TAG, "Couldn't load " + libName + ", trying " + libName + ".so");
+            Log.w(TAG, "Couldn't load " + libName + ", trying " + libName + ".cr");
             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 53 matching lines @@
             Log.i(TAG, "loadLibraryAtAnyAddress: " + zipFilePath + ", " + libFilePath);
         }
         final boolean isFixedAddressPermitted = false;
         loadLibraryImpl(zipFilePath, libFilePath, isFixedAddressPermitted);
     }
 
     /**
      * Call this method to determine if the chromium project must load the library
      * directly from a zip file.
      */
-    public boolean isInZipFile() {
+    public static boolean isInZipFile() {
         // The auto-generated NativeLibraries.sUseLibraryInZipFile variable will be true
         // if the library remains embedded in the APK zip file on the target.
         return NativeLibraries.sUseLibraryInZipFile;
     }
 
     /**
      * Call this method to determine if this chromium project must
      * use this linker. If not, System.loadLibrary() should be used to load
      * libraries instead.
      */
-    public abstract boolean isUsed();
+    public static boolean isUsed() {
+        // The auto-generated NativeLibraries.sUseLinker variable will be true if the
+        // build has not explicitly disabled Linker features.
+        return NativeLibraries.sUseLinker;
+    }
 
     /**
      * Call this method to determine if the linker will try to use shared RELROs
      * for the browser process.
      */
     public abstract boolean isUsingBrowserSharedRelros();
 
     /**
      * Call this method just before loading any native shared libraries in this process.
      */
@@ skipping 193 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();
 }