GN: Side-load dex files as well as native code in incremental installs

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

Index: build/android/incremental_install/java/org/chromium/incrementalinstall/Reflect.java
diff --git a/build/android/incremental_install/java/org/chromium/incrementalinstall/Reflect.java b/build/android/incremental_install/java/org/chromium/incrementalinstall/Reflect.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c174797cc5bf67cbe079a9ec19713673fcf4e2e
--- /dev/null
+++ b/build/android/incremental_install/java/org/chromium/incrementalinstall/Reflect.java
@@ -0,0 +1,162 @@
+// 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 java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+/**
+ * Reflection helper methods.
+ */
+final class Reflect {
+    /**
+     * Sets the value of an object's field (even if it's not visible).
+     *
+     * @param instance The object containing the field to set.
+     * @param name The name of the field to set.
+     * @param value The new value for the field.
+     */
+    static void setField(Object instance, String name, Object value) throws NoSuchFieldException {
+        Field field = findField(instance, name);
+        try {
+            field.setAccessible(true);
+            field.set(instance, value);
+        } catch (IllegalAccessException e) {
+            // This shouldn't happen.
+        }
+    }
+
+    /**
+     * Retrieves the value of an object's field (even if it's not visible).
+     *
+     * @param instance The object containing the field to set.
+     * @param name The name of the field to set.
+     * @return The field's value. Primitive values are returned as their boxed
+     *         type.
+     */
+    static Object getField(Object instance, String name) throws NoSuchFieldException {
+        Field field = findField(instance, name);
+        try {
+            field.setAccessible(true);
+            return field.get(instance);
+        } catch (IllegalAccessException e) {
+            // This shouldn't happen.
+        }
+        return null;
+    }
+
+    /**
+     * Concatenates two arrays into a new array. The arrays must be of the same
+     * type.

[nyquist, 2015/09/16 06:30:46]

Nit: How do you feel about adding an assert (or just throw) that the types are
the same?

[agrieve, 2015/09/16 14:59:59]

It will already throw if the types are incompatible (the arraycopy throws)

+     */
+    static Object[] concatArrays(Object[] left, Object[] right) {
+        Object[] result = (Object[]) (Array.newInstance(

[nyquist, 2015/09/16 06:30:46]

Nit: paranthesis around Array.newInstance(...) call is unnecessary.

[agrieve, 2015/09/16 14:59:59]

Done.

+                left.getClass().getComponentType(), left.length + right.length));
+        System.arraycopy(left, 0, result, 0, left.length);
+        System.arraycopy(right, 0, result, left.length, right.length);
+        return result;
+    }
+
+    static Object invokeMethod(Object instance, String name, Object... params)
+            throws NoSuchMethodException, InvocationTargetException {
+        Class<?> clazz;
+        if (instance instanceof Class) {
+            clazz = (Class<?>) instance;
+            instance = null;

[nyquist, 2015/09/16 06:30:46]

Nit: This reassigns a parameter value to null which was at first read of this
method odd to me. I wonder if this could be easier to read if we did something
like:
boolean isStatic;
if ( is class ) {
  isStatic = true;
  ..
} else {
  isStatic = false;
  ...
}
...
if (isStatic) return method.invoke(null, params);
return method.invoke(instance, params);

or something along those lines?

[agrieve, 2015/09/16 14:59:59]

Done.

+        } else {
+            clazz = instance.getClass();
+        }
+        Method method = findMethod(clazz, name, params);
+        try {
+            method.setAccessible(true);
+            return method.invoke(instance, params);
+        } catch (IllegalAccessException e) {
+            // This shouldn't happen.
+        }
+        return null;
+    }
+
+    static Object newInstance(Class<?> clazz, Object... params)

[nyquist, 2015/09/16 06:30:46]

Nit: Could you add a comment about whether this works as expected in no-arg
constructors?

[agrieve, 2015/09/16 14:59:59]

Done.

+            throws NoSuchMethodException, InstantiationException, InvocationTargetException {
+        Constructor<?> constructor = findConstructor(clazz, params);
+        try {
+            constructor.setAccessible(true);
+            return constructor.newInstance(params);
+        } catch (IllegalAccessException e) {
+            // This shouldn't happen.
+        }
+        return null;
+    }
+
+    private static Field findField(Object instance, String name) throws NoSuchFieldException {
+        Class<?> clazz;
+        if (instance instanceof Class) {
+            clazz = (Class<?>) instance;
+        } else {
+            clazz = instance.getClass();
+        }
+        for (; clazz != null; clazz = clazz.getSuperclass()) {
+            try {
+                return clazz.getDeclaredField(name);
+            } catch (NoSuchFieldException e) {

[nyquist, 2015/09/16 06:30:46]

Nit: Could you add the boilerplate-like '// This shouldn't happen.' here to keep
me sane? :-p

[agrieve, 2015/09/16 14:59:59]

Done.

+            }
+        }
+        throw new NoSuchFieldException("Field " + name + " not found in " + instance.getClass());
+    }
+
+    private static Method findMethod(Class<?> clazz, String name, Object... params)
+            throws NoSuchMethodException {
+        for (; clazz != null; clazz = clazz.getSuperclass()) {
+            for (Method method : clazz.getDeclaredMethods()) {
+                if (method.getName().equals(name)
+                        && areParametersCompatible(method.getParameterTypes(), params)) {
+                    return method;
+                }
+            }
+        }
+        throw new NoSuchMethodException("Method " + name + " with parameters "
+                + Arrays.asList(params) + " not found in " + clazz);
+    }
+
+    private static Constructor<?> findConstructor(Class<?> clazz, Object... params)
+            throws NoSuchMethodException {
+        for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
+            if (areParametersCompatible(constructor.getParameterTypes(), params)) {
+                return constructor;
+            }
+        }
+        throw new NoSuchMethodException("Constructor with parameters " + Arrays.asList(params)
+                + " not found in " + clazz);
+    }
+
+    private static boolean areParametersCompatible(Class<?>[] paramTypes, Object... params) {
+        if (params.length != paramTypes.length) {
+            return false;
+        }
+        for (int i = 0; i < params.length; i++) {
+            if (!isAssignableFrom(paramTypes[i], params[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean isAssignableFrom(Class<?> left, Object right) {
+        if (right == null) {
+            return !left.isPrimitive();
+        }
+        Class<?> rightClazz = right.getClass();
+        if (left.isPrimitive()) {
+            // TODO(agrieve): Fill in the rest as needed.
+            return left == boolean.class && rightClazz == Boolean.class
+                   || left == int.class && rightClazz == Integer.class;
+        }
+        return left.isAssignableFrom(rightClazz);
+    }
+}