Remove app context init from LibraryLoader.

base/android/java/src/org/chromium/base/library_loader/LibraryLoader.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.content.Context;
 import android.os.AsyncTask;
 import android.os.SystemClock;
 
@@ skipping 111 matching lines @@
         }
     }
 
     private LibraryLoader(int libraryProcessType) {
         mLibraryProcessType = libraryProcessType;
         mPrefetchLibraryHasBeenCalled = new AtomicBoolean();
     }
 
     /**
      *  This method blocks until the library is fully loaded and initialized.
-     *
-     *  @param context The context in which the method is called.
      */
-    public void ensureInitialized(Context context) throws ProcessInitException {
-        // TODO(wnwen): Move this call appropriately down to the tests that need it.
-        ContextUtils.initApplicationContext(context.getApplicationContext());
+    public void ensureInitialized() throws ProcessInitException {
         synchronized (sLock) {
             if (mInitialized) {
                 // Already initialized, nothing to do.
                 return;
             }
-            loadAlreadyLocked(context);
+            loadAlreadyLocked(ContextUtils.getApplicationContext());
             initializeAlreadyLocked();
         }
     }
 
     /**
      * Checks if library is fully loaded and initialized.
      */
     public static boolean isInitialized() {
         return sInstance != null && sInstance.mInitialized;
     }
 
     /**
      * Loads the library and blocks until the load completes. The caller is responsible
      * for subsequently calling ensureInitialized().
      * May be called on any thread, but should only be called once. Note the thread
      * this is called on will be the thread that runs the native code's static initializers.
      * See the comment in doInBackground() for more considerations on this.
      *
-     * @param context The context the code is running.
+     * @throws ProcessInitException if the native library failed to load.
+     */
+    public void loadNow() throws ProcessInitException {
+        loadNow(ContextUtils.getApplicationContext());
+    }
+
+    /**
+     * Override kept for callers that need to load from a different app context.
      *
-     * @throws ProcessInitException if the native library failed to load.
+     * @param context The overriding context to be used to load libraries.
+     * @throws ProcessInitException if the native library failed to load with this context.
      */
     public void loadNow(Context context) throws ProcessInitException {

[Ted C, 2016/09/26 20:49:15]

We should probably name this more explicit as well loadNowWithContextOverride to
make it seem the one you shouldn't call.

[Peter Wen, 2016/09/28 15:55:17]

Done.

         synchronized (sLock) {

[Ted C, 2016/09/26 20:49:15]

If we call this with something other than the application context, I think we
need to be more aggressive about ensure it hasn't already been loaded.

Maybe something like:

if (mLoaded && context != ContextUtils.getApplicationContext) {
    throw new IllegalStateException(....);
}

If we don't do that, then we might allow things to unexpectedly be loaded with
different contexts and have to track that down.

[Peter Wen, 2016/09/28 15:55:17]

Agreed, done.

             loadAlreadyLocked(context);
         }
     }
 
     /**
      * initializes the library here and now: must be called on the thread that the
      * native will call its "main" thread. The library must have previously been
      * loaded with loadNow.
      */
     public void initialize() throws ProcessInitException {
@@ skipping 193 matching lines @@
 
         // From this point on, native code is ready to use and checkIsReady()
         // shouldn't complain from now on (and in fact, it's used by the
         // following calls).
         // Note that this flag can be accessed asynchronously, so any initialization
         // must be performed before.
         mInitialized = true;
     }
 
     // Called after all native initializations are complete.
-    public void onNativeInitializationComplete(Context context) {
-        recordBrowserProcessHistogram(context);
+    public void onNativeInitializationComplete() {
+        recordBrowserProcessHistogram();
     }
 
     // Record Chromium linker histogram state for the main browser process. Called from
     // onNativeInitializationComplete().
-    private void recordBrowserProcessHistogram(Context context) {
+    private void recordBrowserProcessHistogram() {
         if (Linker.getInstance().isUsed()) {
-            nativeRecordChromiumAndroidLinkerBrowserHistogram(mIsUsingBrowserSharedRelros,
-                                                              mLoadAtFixedAddressFailed,
-                                                              getLibraryLoadFromApkStatus(context),
-                                                              mLibraryLoadTimeMs);
+            nativeRecordChromiumAndroidLinkerBrowserHistogram(
+                    mIsUsingBrowserSharedRelros,
+                    mLoadAtFixedAddressFailed,
+                    getLibraryLoadFromApkStatus(),
+                    mLibraryLoadTimeMs);
         }
         if (sLibraryPreloader != null) {
             nativeRecordLibraryPreloaderBrowserHistogram(mLibraryPreloaderStatus);
         }
     }
 
     // Returns the device's status for loading a library directly from the APK file.
     // This method can only be called when the Chromium linker is used.
-    private int getLibraryLoadFromApkStatus(Context context) {
+    private int getLibraryLoadFromApkStatus() {
         assert Linker.getInstance().isUsed();
 
         if (mLibraryWasLoadedFromApk) {
             return LibraryLoadFromApkStatusCodes.SUCCESSFUL;
         }
 
         // There were no libraries to be loaded directly from the APK file.
         return LibraryLoadFromApkStatusCodes.UNKNOWN;
     }
 
@@ skipping 67 matching lines @@
 
     // Finds the ranges corresponding to the native library pages, forks a new
     // process to prefetch these pages and waits for it. The new process then
     // terminates. This is blocking.
     private static native boolean nativeForkAndPrefetchNativeLibrary();
 
     // Returns the percentage of the native library code page that are currently reseident in
     // memory.
     private static native int nativePercentageOfResidentNativeLibraryCode();
 }