GN Incremental Install: Add support for running with instrumentation.

build/android/incremental_install/java/org/chromium/incrementalinstall/BootstrapApplication.java

 // Copyright 2015 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.incrementalinstall;
 
 import android.app.Application;
+import android.app.Instrumentation;
+import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.Bundle;
 import android.util.Log;
 
 import java.io.File;
 import java.lang.ref.WeakReference;
 import java.util.List;
 import java.util.Map;
 
 /**
  * An Application that replaces itself with another Application (as defined in
  * the "incremental-install-real-app" meta-data tag within the
  * AndroidManifest.xml). It loads the other application only after side-loading
  * its .so and .dex files from /data/local/tmp.
  */
 public final class BootstrapApplication extends Application {
     private static final String TAG = "cr.incrementalinstall";
     private static final String MANAGED_DIR_PREFIX = "/data/local/tmp/incremental-app-";
     private static final String REAL_APP_META_DATA_NAME = "incremental-install-real-app";
+    private static final String REAL_INSTRUMENTATION_META_DATA_NAME =
+            "incremental-install-real-instrumentation";
 
     private ClassLoaderPatcher mClassLoaderPatcher;
     private Application mRealApplication;
+    private Instrumentation mRealInstrumentation;
     private Object mStashedProviderList;
     private Object mActivityThread;
 
     @Override
     protected void attachBaseContext(Context context) {
         super.attachBaseContext(context);
         File incrementalRootDir = new File(MANAGED_DIR_PREFIX + context.getPackageName());
         File libDir = new File(incrementalRootDir, "lib");
         File dexDir = new File(incrementalRootDir, "dex");
         File installLockFile = new File(incrementalRootDir, "install.lock");
@@ skipping 16 matching lines @@
                 }
             }
 
             mClassLoaderPatcher.importNativeLibs(libDir);
             mClassLoaderPatcher.loadDexFiles(dexDir);
 
             if (isFirstRun && mClassLoaderPatcher.mIsPrimaryProcess) {
                 LockFile.clearInstallerLock(firstRunLockFile);
             }
 
+            Bundle metadata = getManifestMetadata();
+            if (Reflect.getField(mActivityThread, "mInstrumentationAppDir") != null) {
+                initInstrumentation(metadata.getString(REAL_INSTRUMENTATION_META_DATA_NAME));
+            } else {
+                Log.i(TAG, "No instrumentation active.");
+            }
+
+            // This allows us to detect the instrumentation.onCreate() call.
+            Reflect.setField(mActivityThread, "mInstrumentation",
+                    new BootstrapInstrumentation(this));
+
             // attachBaseContext() is called from ActivityThread#handleBindApplication() and
             // Application#mApplication is changed right after we return. Thus, we cannot swap
             // the Application instances until onCreate() is called.
-            String realApplicationName = getRealApplicationName();
+            String realApplicationName = metadata.getString(REAL_APP_META_DATA_NAME);
             Log.i(TAG, "Instantiating " + realApplicationName);
             mRealApplication =
                     (Application) Reflect.newInstance(Class.forName(realApplicationName));
             Reflect.invokeMethod(mRealApplication, "attachBaseContext", context);
 
             // Between attachBaseContext() and onCreate(), ActivityThread tries to instantiate
             // all ContentProviders. The ContentProviders break without the correct Application
             // class being installed, so temporarily pretend there are no providers, and then
             // instantiate them explicitly within onCreate().
             disableContentProviders();
             Log.i(TAG, "Waiting for onCreate");
         } catch (Exception e) {
             throw new RuntimeException("Incremental install failed.", e);
         }
     }
 
+    /**
+     * Instantiates and initializes mRealInstrumentation (the real Instrumentation class).
+     */
+    private void initInstrumentation(String realInstrumentationName)
+            throws ReflectiveOperationException {
+        Log.i(TAG, "Instantiating instrumentation " + realInstrumentationName);
+        mRealInstrumentation = (Instrumentation) Reflect.newInstance(
+                Class.forName(realInstrumentationName));
+        Instrumentation oldInstrumentation =
+                (Instrumentation) Reflect.getField(mActivityThread, "mInstrumentation");
+
+        // Initialize the fields that are set by Instrumentation.init().
+        String[] initFields = {"mThread", "mMessageQueue", "mInstrContext", "mAppContext",
+                "mWatcher", "mUiAutomationConnection"};
+        for (String fieldName : initFields) {
+            Reflect.setField(mRealInstrumentation, fieldName,
+                    Reflect.getField(oldInstrumentation, fieldName));
+        }
+        // But make sure the correct ComponentName is used.
+        ComponentName newName = new ComponentName(
+                oldInstrumentation.getComponentName().getPackageName(), realInstrumentationName);
+        Reflect.setField(mRealInstrumentation, "mComponent", newName);
+    }
+
+    /**
+     * Called by BootstrapInstrumentation from Instrumentation.onCreate().
+     */
+    void onInstrumentationCreate(Bundle arguments) {

[nyquist, 2015/10/15 19:05:15]

As a layman it sounds like this method will only be called in the
instrumentation case, but in fact it's not. Do you think you could do something
with the naming or as a comment here, to make it clearer that it's also called
in the non-instrumentation case?

I mean, it's only the |mRealInstrumentation != null| block that's
instrumentation specific in this method (other than the fact that this whole
method of course is called from BootstrapInstrumentation).

[agrieve, 2015/10/15 19:20:48]

Left the name (as I couldn't think of a better one), but I've beefed up the
comments in a few places to make it more clear what's going on.

+        Log.i(TAG, "Instrumentation.onCreate() called. Swapping references.");
+        try {
+            swapApplicationReferences();
+            enableContentProviders();
+            if (mRealInstrumentation != null) {
+                Reflect.setField(mActivityThread, "mInstrumentation", mRealInstrumentation);
+                mRealInstrumentation.onCreate(arguments);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Incremental install failed.", e);
+        }
+    }
+
     @Override
     public void onCreate() {
         super.onCreate();
         try {
-            Log.i(TAG, "onCreate() called. Swapping Application references");
-            swapApplicationReferences();
-            enableContentProviders();
-            Log.i(TAG, "Calling onCreate");
+            Log.i(TAG, "Application.onCreate() called.");
             mRealApplication.onCreate();
         } catch (Exception e) {
             throw new RuntimeException("Incremental install failed.", e);
         }
     }
 
     /**
      * Returns the class name of the real Application class (recorded in the
      * AndroidManifest.xml)
      */
-    private String getRealApplicationName() throws NameNotFoundException {
+    private Bundle getManifestMetadata() throws NameNotFoundException {
         ApplicationInfo appInfo = getPackageManager().getApplicationInfo(getPackageName(),
                 PackageManager.GET_META_DATA);
-        return appInfo.metaData.getString(REAL_APP_META_DATA_NAME);
+        return appInfo.metaData;
     }
 
     /**
      * Nulls out ActivityThread.mBoundApplication.providers.
      */
     private void disableContentProviders() throws ReflectiveOperationException {
         Object data = Reflect.getField(mActivityThread, "mBoundApplication");
         mStashedProviderList = Reflect.getField(data, "providers");
         Reflect.setField(data, "providers", null);
     }
@@ skipping 38 matching lines @@
             for (Map.Entry<String, WeakReference<?>> entry : packageMap.entrySet()) {
                 Object loadedApk = entry.getValue().get();
                 if (loadedApk != null && Reflect.getField(loadedApk, "mApplication") == this) {
                     Reflect.setField(loadedApk, "mApplication", mRealApplication);
                     Reflect.setField(mRealApplication, "mLoadedApk", loadedApk);
                 }
             }
         }
     }
 }