GN(Android): Fix incremental install when manifest has short-hand app name.

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;
@@ skipping 56 matching lines @@
                 }
             }
 
             mClassLoaderPatcher.importNativeLibs(libDir);
             mClassLoaderPatcher.loadDexFiles(dexDir);
 
             if (isFirstRun && mClassLoaderPatcher.mIsPrimaryProcess) {
                 LockFile.clearInstallerLock(firstRunLockFile);
             }
 
-            Bundle metadata = getManifestMetadata();
             // mInstrumentationAppDir is one of a set of fields that is initialized only when
             // instrumentation is active.
             if (Reflect.getField(mActivityThread, "mInstrumentationAppDir") != null) {
-                initInstrumentation(metadata.getString(REAL_INSTRUMENTATION_META_DATA_NAME));
+                String realInstrumentationName =
+                        getClassNameFromMetadata(REAL_INSTRUMENTATION_META_DATA_NAME);
+                initInstrumentation(realInstrumentationName);
             } else {
                 Log.i(TAG, "No instrumentation active.");
             }
 
             // Even when instrumentation is not enabled, ActivityThread uses a default
             // Instrumentation instance internally. We hook it here in order to hook into the
             // call to Instrumentation.onCreate().
             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 = metadata.getString(REAL_APP_META_DATA_NAME);
+            String realApplicationName = getClassNameFromMetadata(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 Instrumentation.onCreate");
         } catch (Exception e) {
             throw new RuntimeException("Incremental install failed.", e);
         }
     }
 
     /**
+     * Returns the fully-qualified class name for the given key, stored in a
+     * <meta> witin the manifest.
+     */
+    private String getClassNameFromMetadata(String key) throws NameNotFoundException {
+        ApplicationInfo appInfo = getPackageManager().getApplicationInfo(getPackageName(),
+                PackageManager.GET_META_DATA);
+        String value = appInfo.metaData.getString(key);
+        if (!value.contains(".")) {
+            value = getPackageName() + "." + value;
+        }
+        return value;
+    }
+
+    /**
      * 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");
 
@@ skipping 33 matching lines @@
         super.onCreate();
         try {
             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 Bundle getManifestMetadata() throws NameNotFoundException {
-        ApplicationInfo appInfo = getPackageManager().getApplicationInfo(getPackageName(),
-                PackageManager.GET_META_DATA);
-        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);
     }
 
     /**
      * Restores the value of ActivityThread.mBoundApplication.providers, and invokes
@@ skipping 35 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);
                 }
             }
         }
     }
 }