Rationalize and fix chromium android linker histogram recording.

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 197 matching lines @@
 
     // The map of all RELRO sections either created or used in this process.
     private static Bundle sSharedRelros = null;
 
     // Current common random base load address.
     private static long sBaseLoadAddress = 0;
 
     // Current fixed-location load address for the next library called by loadLibrary().
     private static long sCurrentLoadAddress = 0;
 
-    // Becomes true if any library fails to load at a given, non-0, fixed address.
-    private static boolean sLoadAtFixedAddressFailed = false;
-
     // Becomes true once prepareLibraryLoad() has been called.
     private static boolean sPrepareLibraryLoadCalled = false;
 
     // Used internally to initialize the linker's static data. Assume lock is held.
     private static void ensureInitializedLocked() {
         assert Thread.holdsLock(Linker.class);
 
         if (!sInitialized) {
             sRelroSharingSupported = false;
             if (NativeLibraries.USE_LINKER) {
@@ skipping 462 matching lines @@
         }
 
         // In service processes, close all file descriptors from the map now.
         if (!sInBrowserProcess)
             closeLibInfoMap(relroMap);
 
         if (DEBUG) Log.i(TAG, "Linker.useSharedRelrosLocked() exiting");
     }
 
     /**
-     * Returns whether the linker was unable to load one library at a given fixed address.
-     *
-     * @return true if at least one library was not loaded at the expected fixed address.
-     */
-    public static boolean loadAtFixedAddressFailed() {
-        return sLoadAtFixedAddressFailed;
-    }
-
-    /**
      * 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.
      *
      * @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);
@@ skipping 42 matching lines @@
 
             LibInfo libInfo = new LibInfo();
             long loadAddress = 0;
             if ((sInBrowserProcess && sBrowserUsesSharedRelro) || sWaitForSharedRelros) {
                 // Load the library at a fixed address.
                 loadAddress = sCurrentLoadAddress;
             }
 
             String sharedRelRoName = libName;
             if (zipFile != null) {
-                if (!nativeLoadLibraryInZipFile(
-                        zipFile, libName, loadAddress, libInfo)) {
-                    String errorMessage =
-                            "Unable to load library: " + libName + " in: " +
-                            zipFile;
+                if (!nativeLoadLibraryInZipFile(zipFile, libName, loadAddress, libInfo)) {
+                    String errorMessage = "Unable to load library: " + libName +
+                                          ", in: " + zipFile;
                     Log.e(TAG, errorMessage);
                     throw new UnsatisfiedLinkError(errorMessage);
                 }
                 sharedRelRoName = zipFile;
             } else {
                 if (!nativeLoadLibrary(libName, loadAddress, libInfo)) {
                     String errorMessage = "Unable to load library: " + libName;
                     Log.e(TAG, errorMessage);
                     throw new UnsatisfiedLinkError(errorMessage);
                 }
             }
-            // Keep track whether the library has been loaded at the expected load address.
-            if (loadAddress != 0 && loadAddress != libInfo.mLoadAddress)
-                sLoadAtFixedAddressFailed = true;
 
             // Print the load address to the logcat when testing the linker. The format
             // of the string is expected by the Python test_runner script as one of:
             //    BROWSER_LIBRARY_ADDRESS: <library-name> <address>
             //    RENDERER_LIBRARY_ADDRESS: <library-name> <address>
             // Where <library-name> is the library name, and <address> is the hexadecimal load
             // address.
             if (NativeLibraries.ENABLE_LINKER_TESTS) {
                 Log.i(TAG, String.format(
                         Locale.US,
@@ skipping 258 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";
 }