[Android] Fix a few issues related to old lib deletion.

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.SystemClock;
 import android.util.Log;
 
@@ skipping 29 matching lines @@
     // One-way switch becomes true when the libraries are initialized (
     // by calling nativeLibraryLoaded, which forwards to LibraryLoaded(...) in
     // library_loader_hooks.cc).
     private static boolean sInitialized = false;
 
     // One-way switch becomes true if the system library loading failed,
     // and the right native library was found and loaded by the hack.
     // The flag is used to report UMA stats later.
     private static boolean sNativeLibraryHackWasUsed = false;
 
-
-    /**
-     * TODO: http://crbug.com/354655
-     * remove this method once WebViewChromiumFactoryProvider.java
-     * changes the call to ensureInitialized(null).
-     */
-    public static void ensureInitialized() throws ProcessInitException {
-        ensureInitialized(null);
+    // TODO(fqian): Remove this method once downstream CL is
+    // committed.
+    public static void ensureInitialized(Context context) throws ProcessInitException {
+        ensureInitialized(context, true);
     }
 
     /**
+     * The same as ensureInitialized(null, false), should only be called
+     * by non-browser processes.
+     *
+     * @throws ProcessInitException
+     */
+    public static void ensureInitialized() throws ProcessInitException {
+        ensureInitialized(null, false);
+    }
+
+    /**
      *  This method blocks until the library is fully loaded and initialized.
      *
      *  @param context The context in which the method is called, the caller
      *    may pass in a null context if it doesn't know in which context it
      *    is running, or it doesn't need to work around the issue
      *    http://b/13216167.
      *
      *    When the context is not null and native library was not extracted
      *    by Android package manager, the LibraryLoader class
      *    will extract the native libraries from APK. This is a hack used to
      *    work around some Sony devices with the following platform bug:
      *    http://b/13216167.
+     *
+     *  @param inBrowserProcess The caller indicates it is running in the browser
+     *    process, so the code will perform browser-specific file cleanup.
      */
-    public static void ensureInitialized(Context context) throws ProcessInitException {
+    public static void ensureInitialized(Context context, boolean inBrowserProcess)
+            throws ProcessInitException {
         synchronized (sLock) {
             if (sInitialized) {
                 // Already initialized, nothing to do.
                 return;
             }
-            loadAlreadyLocked(context);
+            loadAlreadyLocked(context, inBrowserProcess);
             initializeAlreadyLocked(CommandLine.getJavaSwitchesOrNull());
         }
     }
 
     /**
      * Checks if library is fully loaded and initialized.
      */
     public static boolean isInitialized() {
         synchronized (sLock) {
             return sInitialized;
         }
     }
 
     /**
+     * The same as loadNow(null, false), should only be called by
+     * non-browser process.
+     *
+     * @throws ProcessInitException
+     */
+    public static void loadNow() throws ProcessInitException {
+        loadNow(null, false);
+    }
+
+    /**
      * 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, or null if it doesn't have one.
+     * @param inBrowserProcess The flag tells whether the code is running in
+     *   the browser process.

[cjhopman, 2014/04/02 22:24:24]

It's unclear (from this documentation) what this flag does. How about renaming
it to something like shouldDeleteOldWorkaroundLibraries (or something shorter).

Then it also won't feel so much like this "knows about" the browser process.

[Feng Qian, 2014/04/03 00:50:42]

ok, I am fine with renaming.

On 2014/04/02 22:24:24, cjhopman wrote:

+     *
      * @throws ProcessInitException if the native library failed to load.
      */
-    public static void loadNow(Context context) throws ProcessInitException {
+    public static void loadNow(Context context, boolean inBrowserProcess)
+            throws ProcessInitException {
         synchronized (sLock) {
-            loadAlreadyLocked(context);
+            loadAlreadyLocked(context, inBrowserProcess);
         }
     }
 
     /**
      * 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.
      * @param initCommandLine The command line arguments that native command line will
      * be initialized with.
      */
     public static void initialize(String[] initCommandLine) throws ProcessInitException {
         synchronized (sLock) {
             initializeAlreadyLocked(initCommandLine);
         }
     }
 
     // Invoke System.loadLibrary(...), triggering JNI_OnLoad in native code
-    private static void loadAlreadyLocked(Context context) throws ProcessInitException {
+    private static void loadAlreadyLocked(Context context, boolean inBrowserProcess)
+            throws ProcessInitException {
         try {
             if (!sLoaded) {
                 assert !sInitialized;
 
                 long startTime = SystemClock.uptimeMillis();
                 boolean useChromiumLinker = Linker.isUsed();
 
                 if (useChromiumLinker) Linker.prepareLibraryLoad();
 
+                boolean workaroundLibrariesDeleted = false;
                 for (String library : NativeLibraries.LIBRARIES) {
                     Log.i(TAG, "Loading: " + library);
                     if (useChromiumLinker) {
                         Linker.loadLibrary(library);
                     } else {
                         try {
                             System.loadLibrary(library);
-                            if (context != null) {
+                            if (context != null
+                                && inBrowserProcess

[boliu, 2014/04/03 01:03:22]

Webview technically only has the browser process, so "inBrowserProcess" is
misleading. Can we rename this to what it actually does, something like
"skipDeleteWorkaroundLibrary"?

Or just set it to true in webview, since context is NULL in webview anyway...

+                                && !workaroundLibrariesDeleted) {
                                 LibraryLoaderHelper.deleteWorkaroundLibrariesAsynchronously(
                                     context);
+                                workaroundLibrariesDeleted = true;

[cjhopman, 2014/04/02 22:24:24]

Since we only want this to happen once, how about moving it outside of the loop
over libraries. sNativeLibraryHackWasUsed is probably a better signal for
whether or not we should delete the workaround libraries anyway.

[Feng Qian, 2014/04/03 00:50:42]

The code is not just run when sNativeLibraryHackWasUsed is true.
But you bring up a good point that, even if the content linker is used for this
build, the previous build might used the hack, so the code should always run.

On 2014/04/02 22:24:24, cjhopman wrote:

                             }
                         } catch (UnsatisfiedLinkError e) {
                             if (context != null
                                 && LibraryLoaderHelper.tryLoadLibraryUsingWorkaround(context,
                                                                                      library)) {
                                 sNativeLibraryHackWasUsed = true;
                             } else {
                                 throw e;
                             }
                         }
@@ skipping 60 matching lines @@
     private static native void nativeRecordChromiumAndroidLinkerHistogram(
             boolean loadedAtFixedAddressFailed,
             boolean isLowMemoryDevice);
 
     // Get the version of the native library. This is needed so that we can check we
     // have the right version before initializing the (rest of the) JNI.
     private static native String nativeGetVersionNumber();
 
     private static native void nativeRecordNativeLibraryHack(boolean usedHack);
 }