Add UMA for testing whether device supports memory mapping APK files with executable permissions.

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

 // 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.
 
 package org.chromium.base.library_loader;
 
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.ParcelFileDescriptor;
 import android.os.Parcelable;
@@ skipping 118 matching lines @@
  *       - Compute the fixed address to be used to load the same library
  *         in service processes.
  *       - Create a shared memory region populated with the RELRO region
  *         content pre-relocated for the specific fixed address above.
  *
  *    Note that these shared RELRO regions cannot be used inside the browser
  *    process. They are also never mapped into it.
  *
  *    This behaviour is altered by the BROWSER_SHARED_RELRO_CONFIG configuration
  *    variable below, which may force the browser to load the libraries at
- *    fixed addresses to.
+ *    fixed addresses too.
  *
  *  - Once all libraries are loaded in the browser process, one can call
  *    getSharedRelros() which returns a Bundle instance containing a map that
  *    links each loaded library to its shared RELRO region.
  *
  *    This Bundle must be passed to each service process, for example through
  *    a Binder call (note that the Bundle includes file descriptors and cannot
  *    be added as an Intent extra).
  *
  *  - In a service process, finishLibraryLoad() will block until the RELRO
@@ skipping 225 matching lines @@
      * for the browser process.
      */
     public static boolean isUsingBrowserSharedRelros() {
         synchronized (Linker.class) {
             ensureInitializedLocked();
             return sBrowserUsesSharedRelro;
         }
     }
 
     /**
+     * Call this method to determine if the linker is running in the browser
+     * process.
+     *
+     * @return true if the linker is running in the browser process.
+     */
+    public static boolean isInBrowserProcess() {
+        synchronized (Linker.class) {
+            ensureInitializedLocked();
+            return sInBrowserProcess;
+        }
+    }
+
+    /**
      * Call this method to determine if the chromium project must load
      * the library directly from the zip file.
      */
     public static boolean isInZipFile() {
         return NativeLibraries.USE_LIBRARY_IN_ZIP_FILE;
     }
 
     /**
      * Call this method just before loading any native shared libraries in this process.
      */
@@ skipping 418 matching lines @@
                 // only.
                 sCurrentLoadAddress = libInfo.mLoadAddress + libInfo.mLoadSize;
             }
 
             sLoadedLibraries.put(libName, libInfo);
             if (DEBUG) Log.i(TAG, "Library details " + libInfo.toString());
         }
     }
 
     /**
+     * Check whether the device supports loading a library directly from the APK file.
+     *
+     * @param apkFile Filename of the APK.
+     * @return true if supported.
+     */
+    public static boolean checkLibraryLoadFromApkSupport(String apkFile) {
+        synchronized (Linker.class) {
+            ensureInitializedLocked();
+
+            if (DEBUG) Log.i(TAG, "checkLibraryLoadFromApkSupported: " + apkFile);
+            boolean supported = nativeCheckLibraryLoadFromApkSupport(apkFile);
+            if (DEBUG) Log.i(TAG, "Loading a library directly from the APK file " +
+                    (supported ? "" : "NOT ") + "supported");
+            return supported;
+        }
+    }
+
+    /**
      * Move activity from the native thread to the main UI thread.
      * Called from native code on its own thread.  Posts a callback from
      * the UI thread back to native code.
      *
      * @param opaque Opaque argument.
      */
     @CalledByNative
     public static void postCallbackOnMainThread(final long opaque) {
         ThreadUtils.postOnUiThread(new Runnable() {
             @Override
@@ skipping 77 matching lines @@
      * Maps an area of size bytes, 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.
      * @param sizeBytes Size of area in bytes to search for.
      * @return address to pass to future mmap, or 0 on error.
      */
     private static native long nativeGetRandomBaseLoadAddress(long sizeBytes);
 
     /**
+     * Native method which checks whether the device supports loading a library
+     * directly from the APK file.
+     *
+     * @param apkFile Filename of the APK.
+     * @return true if supported.
+     *
+     */
+    private static native boolean nativeCheckLibraryLoadFromApkSupport(String apkFile);
+
+    /**
      * Record information for a given library.
      * IMPORTANT: Native code knows about this class's fields, so
      * don't change them without modifying the corresponding C++ sources.
      * Also, the LibInfo instance owns the ashmem file descriptor.
      */
     public static class LibInfo implements Parcelable {
 
         public LibInfo() {
             mLoadAddress = 0;
             mLoadSize = 0;
@@ skipping 114 matching lines @@
         }
     }
 
     // The map of libraries that are currently loaded in this process.
     private static HashMap<String, LibInfo> sLoadedLibraries = null;
 
     // Used to pass the shared RELRO Bundle through Binder.
     public static final String EXTRA_LINKER_SHARED_RELROS =
         "org.chromium.base.android.linker.shared_relros";
 }