Add UMA for testing whether the Chromium library was page aligned in the APK file.

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 140 matching lines @@
  *    useSharedRelros() from another thread.
  *
  *    This method also ensures the process uses the shared RELROs.
  */
 public class Linker {
 
     // Log tag for this class. This must match the name of the linker's native library.
     private static final String TAG = "chromium_android_linker";
 
     // Set to true to enable debug logs.
-    private static final boolean DEBUG = false;
+    public static final boolean DEBUG = false;
 
     // Constants used to control the behaviour of the browser process with
     // regards to the shared RELRO section.
     //   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 523 matching lines @@
         if (!sInBrowserProcess)
             closeLibInfoMap(relroMap);
 
         if (DEBUG) Log.i(TAG, "Linker.useSharedRelrosLocked() exiting");
     }
 
     /**
      * Load a native shared library with the Chromium linker.
      * The shared library is uncompressed and page aligned inside the zipfile.
      * Note the crazy linker treats libraries and files as equivalent,
-     * so you can only open one library in a given zip file.
+     * so you can only open one library in a given zip file. The library must
+     * not be the Chromium linker library.
      *
      * @param zipfile The filename of the zipfile contain the library.
      * @param library The library's base name.
      */
     public static void loadLibraryInZipFile(String zipfile, String library) {
         loadLibraryMaybeInZipFile(zipfile, library);
     }
 
     /**
-     * Load a native shared library with the Chromium linker.
+     * Load a native shared library with the Chromium linker. The library must
+     * not be the Chromium linker library.
      *
      * @param library The library's base name.
      */
     public static void loadLibrary(String library) {
         loadLibraryMaybeInZipFile(null, library);
     }
 
     private static void loadLibraryMaybeInZipFile(
             @Nullable String zipFile, String library) {
         if (DEBUG) Log.i(TAG, "loadLibrary: " + library);
-
-        // Don't self-load the linker. This is because the build system is
-        // not clever enough to understand that all the libraries packaged
-        // in the final .apk don't need to be explicitly loaded.
-        // Also deal with the component build that adds a .cr suffix to the name.
-        if (library.equals(TAG) || library.equals(TAG + ".cr")) {
-            if (DEBUG) Log.i(TAG, "ignoring self-linker load");
-            return;
-        }
+        assert !isLinkerLibrary(library);
 
         synchronized (Linker.class) {
             ensureInitializedLocked();
 
             // Security: Ensure prepareLibraryLoad() was called before.
             // In theory, this can be done lazily here, but it's more consistent
             // to use a pair of functions (i.e. prepareLibraryLoad() + finishLibraryLoad())
             // that wrap all calls to loadLibrary() in the library loader.
             assert sPrepareLibraryLoadCalled;
 
@@ skipping 69 matching lines @@
                 // only.
                 sCurrentLoadAddress = libInfo.mLoadAddress + libInfo.mLoadSize;
             }
 
             sLoadedLibraries.put(sharedRelRoName, libInfo);
             if (DEBUG) Log.i(TAG, "Library details " + libInfo.toString());
         }
     }
 
     /**
+     * Determine whether a library is the linker library. Also deal with the
+     * component build that adds a .cr suffix to the name.
+     */
+    public static boolean isLinkerLibrary(String library) {

[rmcilroy, 2014/10/28 13:07:15]

nit - isChromiumLinkerLibrary

[petrcermak, 2014/10/28 13:48:15]

Done.

+        return library.equals(TAG) || library.equals(TAG + ".cr");
+    }
+
+    /**
      * 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) {
         assert apkFile != null;
         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;
         }
     }
 
     /**
+     * Check whether a library is page aligned in the APK file.
+     *
+     * @param apkFile Filename of the APK.
+     * @param library The library's base name.
+     * @return true if page aligned.
+     */
+    public static boolean checkLibraryAlignedInApk(String apkFile, String library) {
+        synchronized (Linker.class) {
+            ensureInitializedLocked();
+
+            if (DEBUG) Log.i(TAG, "checkLibraryAlignedInApk: " + apkFile + ", " + library);
+            boolean aligned = nativeCheckLibraryAlignedInApk(apkFile, library);
+            if (DEBUG) Log.i(TAG, library + " is " + (aligned ? "" : "NOT ") +
+                    "page aligned in " + apkFile);
+            return aligned;
+        }
+    }
+
+    /**
      * 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 82 matching lines @@
      * @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);
 
     /**
+     * Native method which checks whether a library is page aligned in the APK file.
+     *
+     * @param apkFile Filename of the APK.
+     * @param library The library's base name.
+     * @return true if page aligned.
+     */
+    private static native boolean nativeCheckLibraryAlignedInApk(String apkFile, String library);
+
+    /**
      * 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";
 }