Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 2844 insertions, 0 deletions

diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationInfo.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationInfo.java
new file mode 100644
index 0000000000..0404a467f5
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationInfo.java
@@ -0,0 +1,59 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors;
+
+/** Object holding annotation data. Used by GeneratableElementIterator. */
+public class AnnotationInfo {
+  public enum ExceptionMode {
+    ABORT,
+    NSRESULT,
+    IGNORE;
+
+    String nativeValue() {
+      return "mozilla::jni::ExceptionMode::" + name();
+    }
+  }
+
+  public enum CallingThread {
+    GECKO,
+    UI,
+    ANY;
+
+    String nativeValue() {
+      return "mozilla::jni::CallingThread::" + name();
+    }
+  }
+
+  public enum DispatchTarget {
+    GECKO,
+    GECKO_PRIORITY,
+    PROXY,
+    CURRENT;
+
+    String nativeValue() {
+      return "mozilla::jni::DispatchTarget::" + name();
+    }
+  }
+
+  public final String wrapperName;
+  public final ExceptionMode exceptionMode;
+  public final CallingThread callingThread;
+  public final DispatchTarget dispatchTarget;
+  public final boolean noLiteral;
+
+  public AnnotationInfo(
+      String wrapperName,
+      ExceptionMode exceptionMode,
+      CallingThread callingThread,
+      DispatchTarget dispatchTarget,
+      boolean noLiteral) {
+
+    this.wrapperName = wrapperName;
+    this.exceptionMode = exceptionMode;
+    this.callingThread = callingThread;
+    this.dispatchTarget = dispatchTarget;
+    this.noLiteral = noLiteral;
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationProcessor.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationProcessor.java
new file mode 100644
index 0000000000..8db77eed0b
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/AnnotationProcessor.java
@@ -0,0 +1,231 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.util.Arrays;
+import java.util.Iterator;
+import org.mozilla.gecko.annotationProcessors.classloader.AnnotatableEntity;
+import org.mozilla.gecko.annotationProcessors.classloader.ClassWithOptions;
+import org.mozilla.gecko.annotationProcessors.classloader.IterableJarLoadingURLClassLoader;
+import org.mozilla.gecko.annotationProcessors.utils.GeneratableElementIterator;
+
+public class AnnotationProcessor {
+  private static final String NATIVES_NAME = "Natives";
+  private static final String WRAPPERS_NAME = "Wrappers";
+  private static final String EXPORT_PREFIX = "mozilla/java/";
+
+  public static final String GENERATED_COMMENT =
+      "// GENERATED CODE\n"
+          + "// Generated by the Java program at /build/annotationProcessors at compile time\n"
+          + "// from annotations on Java methods. To update, change the annotations on the\n"
+          + "// corresponding Java methods and rerun the build. Manually updating this file\n"
+          + "// will cause your build to fail.\n"
+          + "\n";
+
+  public static void main(String[] args) {
+    // We expect a list of jars on the commandline. If missing, whinge about it.
+    if (args.length < 2) {
+      System.err.println("Usage: java AnnotationProcessor outprefix jarfiles ...");
+      System.exit(1);
+    }
+
+    final String OUTPUT_PREFIX = args[0];
+    final String QUALIFIER = OUTPUT_PREFIX + "JNI";
+
+    (new File(QUALIFIER)).mkdir();
+
+    System.out.println("Processing annotations...");
+
+    // We want to produce the same output as last time as often as possible. Ordering of
+    // generated statements, therefore, needs to be consistent.
+    final String[] jars = Arrays.copyOfRange(args, 1, args.length);
+    Arrays.sort(jars);
+
+    // Start the clock!
+    long s = System.currentTimeMillis();
+
+    int ret = 0;
+
+    // Get an iterator over the classes in the jar files given...
+    Iterator<ClassWithOptions> jarClassIterator =
+        IterableJarLoadingURLClassLoader.getIteratorOverJars(jars);
+
+    while (jarClassIterator.hasNext()) {
+      final ClassWithOptions annotatedClass = jarClassIterator.next();
+      if (!annotatedClass.hasGenerated()) {
+        continue;
+      }
+
+      final String sourceFileName =
+          QUALIFIER + annotatedClass.generatedName + WRAPPERS_NAME + ".cpp";
+      final String headerFileName =
+          QUALIFIER + File.separator + annotatedClass.generatedName + WRAPPERS_NAME + ".h";
+      final String headerExportedFileName =
+          EXPORT_PREFIX + annotatedClass.generatedName + WRAPPERS_NAME + ".h";
+      final String nativesFileName =
+          QUALIFIER + File.separator + annotatedClass.generatedName + NATIVES_NAME + ".h";
+      final String nativesExportedFileName =
+          EXPORT_PREFIX + annotatedClass.generatedName + NATIVES_NAME + ".h";
+
+      final StringBuilder headerFile = new StringBuilder(GENERATED_COMMENT);
+      final StringBuilder implementationFile = new StringBuilder(GENERATED_COMMENT);
+      final StringBuilder nativesFile = new StringBuilder(GENERATED_COMMENT);
+
+      headerFile.append(
+          "#ifndef "
+              + getHeaderGuardName(headerExportedFileName)
+              + "\n"
+              + "#define "
+              + getHeaderGuardName(headerExportedFileName)
+              + "\n"
+              + "\n"
+              + "#ifndef MOZ_PREPROCESSOR\n"
+              + "#include \"mozilla/jni/Refs.h\"\n"
+              + "#endif\n"
+              + "\n"
+              + "namespace mozilla {\n"
+              + "namespace java {\n"
+              + "\n");
+
+      implementationFile.append(
+          "#ifndef MOZ_PREPROCESSOR\n"
+              + "#include \""
+              + headerExportedFileName
+              + "\"\n"
+              + "#include \"mozilla/jni/Accessors.h\"\n"
+              + "#endif\n"
+              + "\n"
+              + "namespace mozilla {\n"
+              + "namespace java {\n"
+              + "\n");
+
+      nativesFile.append(
+          "#ifndef "
+              + getHeaderGuardName(nativesExportedFileName)
+              + "\n"
+              + "#define "
+              + getHeaderGuardName(nativesExportedFileName)
+              + "\n"
+              + "\n"
+              + "#ifndef MOZ_PREPROCESSOR\n"
+              + "#include \""
+              + headerExportedFileName
+              + "\"\n"
+              + "#include \"mozilla/jni/Natives.h\"\n"
+              + "#endif\n"
+              + "\n"
+              + "namespace mozilla {\n"
+              + "namespace java {\n"
+              + "\n");
+
+      generateClass(annotatedClass, headerFile, implementationFile, nativesFile);
+
+      implementationFile.append("} /* java */\n" + "} /* mozilla */\n");
+
+      headerFile.append(
+          "} /* java */\n"
+              + "} /* mozilla */\n\n"
+              + "#endif // "
+              + getHeaderGuardName(headerExportedFileName)
+              + "\n");
+
+      nativesFile.append(
+          "} /* java */\n"
+              + "} /* mozilla */\n\n"
+              + "#endif // "
+              + getHeaderGuardName(nativesExportedFileName)
+              + "\n");
+
+      ret |= writeOutputFile(sourceFileName, implementationFile);
+      ret |= writeOutputFile(headerFileName, headerFile);
+      ret |= writeOutputFile(nativesFileName, nativesFile);
+    }
+    long e = System.currentTimeMillis();
+    System.out.println("Annotation processing complete in " + (e - s) + "ms");
+
+    System.exit(ret);
+  }
+
+  private static void generateClass(
+      final ClassWithOptions annotatedClass,
+      final StringBuilder headerFile,
+      final StringBuilder implementationFile,
+      final StringBuilder nativesFile) {
+    // Get an iterator over the appropriately generated methods of this class
+    final GeneratableElementIterator methodIterator =
+        new GeneratableElementIterator(annotatedClass);
+    final ClassWithOptions[] innerClasses = methodIterator.getInnerClasses();
+
+    final CodeGenerator generatorInstance = new CodeGenerator(annotatedClass);
+    generatorInstance.generateClasses(innerClasses);
+
+    // Iterate all annotated members in this class..
+    while (methodIterator.hasNext()) {
+      AnnotatableEntity aElementTuple = methodIterator.next();
+      switch (aElementTuple.mEntityType) {
+        case METHOD:
+          generatorInstance.generateMethod(aElementTuple);
+          break;
+        case NATIVE:
+          generatorInstance.generateNative(aElementTuple);
+          break;
+        case FIELD:
+          generatorInstance.generateField(aElementTuple);
+          break;
+        case CONSTRUCTOR:
+          generatorInstance.generateConstructor(aElementTuple);
+          break;
+      }
+    }
+
+    headerFile.append(generatorInstance.getHeaderFileContents());
+    implementationFile.append(generatorInstance.getWrapperFileContents());
+    nativesFile.append(generatorInstance.getNativesFileContents());
+
+    for (ClassWithOptions innerClass : innerClasses) {
+      generateClass(innerClass, headerFile, implementationFile, nativesFile);
+    }
+  }
+
+  private static String getHeaderGuardName(final String name) {
+    return name.replaceAll("\\W", "_");
+  }
+
+  private static int writeOutputFile(final String name, final StringBuilder content) {
+    final byte[] contentBytes = content.toString().getBytes(StandardCharsets.UTF_8);
+
+    try {
+      final byte[] existingBytes = Files.readAllBytes(new File(name).toPath());
+      if (Arrays.equals(contentBytes, existingBytes)) {
+        return 0;
+      }
+    } catch (FileNotFoundException e) {
+      // Pass.
+    } catch (NoSuchFileException e) {
+      // Pass.
+    } catch (IOException e) {
+      System.err.println("Unable to read " + name + ". Perhaps a permissions issue?");
+      e.printStackTrace(System.err);
+      return 1;
+    }
+
+    try (FileOutputStream outStream = new FileOutputStream(name)) {
+      outStream.write(contentBytes);
+    } catch (IOException e) {
+      System.err.println("Unable to write " + name + ". Perhaps a permissions issue?");
+      e.printStackTrace(System.err);
+      return 1;
+    }
+
+    return 0;
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/CodeGenerator.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/CodeGenerator.java
new file mode 100644
index 0000000000..d39b074f50
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/CodeGenerator.java
@@ -0,0 +1,839 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.Locale;
+import org.mozilla.gecko.annotationProcessors.classloader.AnnotatableEntity;
+import org.mozilla.gecko.annotationProcessors.classloader.ClassWithOptions;
+import org.mozilla.gecko.annotationProcessors.utils.Utils;
+
+public class CodeGenerator {
+  private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
+
+  // Buffers holding the strings to ultimately be written to the output files.
+  private final StringBuilder cpp = new StringBuilder();
+  private final StringBuilder header = new StringBuilder();
+  private final StringBuilder natives = new StringBuilder();
+  private final StringBuilder nativesInits = new StringBuilder();
+
+  private final Class<?> cls;
+  private final String clsName;
+  private final ClassWithOptions options;
+  private AnnotationInfo.CallingThread callingThread = null;
+  private int numNativesInits;
+
+  private final HashSet<String> takenMethodNames = new HashSet<String>();
+
+  public CodeGenerator(ClassWithOptions annotatedClass) {
+    this.cls = annotatedClass.wrappedClass;
+    this.clsName = annotatedClass.generatedName;
+    this.options = annotatedClass;
+
+    final String unqualifiedName = Utils.getUnqualifiedName(clsName);
+    header.append(
+        Utils.getIfdefHeader(annotatedClass.ifdef)
+            + "class "
+            + clsName
+            + " : public mozilla::jni::ObjectBase<"
+            + unqualifiedName
+            + ">\n"
+            + "{\n"
+            + "public:\n"
+            + "    static const char name[];\n"
+            + "\n"
+            + "    explicit "
+            + unqualifiedName
+            + "(const Context& ctx) : ObjectBase<"
+            + unqualifiedName
+            + ">(ctx) {}\n"
+            + "\n");
+
+    cpp.append(
+        Utils.getIfdefHeader(annotatedClass.ifdef)
+            + "const char "
+            + clsName
+            + "::name[] =\n"
+            + "        \""
+            + cls.getName().replace('.', '/')
+            + "\";\n"
+            + "\n");
+
+    natives.append(
+        Utils.getIfdefHeader(annotatedClass.ifdef)
+            + "template<class Impl>\n"
+            + "class "
+            + clsName
+            + "::Natives : "
+            + "public mozilla::jni::NativeImpl<"
+            + unqualifiedName
+            + ", Impl>\n"
+            + "{\n"
+            + "public:\n");
+  }
+
+  private String getTraitsName(String uniqueName, boolean includeScope) {
+    return (includeScope ? clsName + "::" : "") + uniqueName + "_t";
+  }
+
+  /**
+   * Return the C++ type name for this class or any class within the chain of declaring classes, if
+   * the target class matches the given type.
+   *
+   * <p>Return null if the given type does not match any class searched.
+   */
+  private String getMatchingClassType(final Class<?> type) {
+    Class<?> cls = this.cls;
+    String clsName = this.clsName;
+
+    while (cls != null) {
+      if (type.equals(cls)) {
+        return clsName;
+      }
+      cls = cls.getDeclaringClass();
+      clsName = clsName.substring(0, Math.max(0, clsName.lastIndexOf("::")));
+    }
+    return null;
+  }
+
+  private String getNativeParameterType(Class<?> type, AnnotationInfo info) {
+    final String clsName = getMatchingClassType(type);
+    if (clsName != null) {
+      return Utils.getUnqualifiedName(clsName) + "::Param";
+    }
+    return Utils.getNativeParameterType(type, info);
+  }
+
+  private String getNativeReturnType(Class<?> type, AnnotationInfo info) {
+    final String clsName = getMatchingClassType(type);
+    if (clsName != null) {
+      return Utils.getUnqualifiedName(clsName) + "::LocalRef";
+    }
+    return Utils.getNativeReturnType(type, info);
+  }
+
+  private void generateMember(
+      AnnotationInfo info, Member member, String uniqueName, Class<?> type, Class<?>[] argTypes) {
+    // Sanity check.
+    if (info.noLiteral
+        && !(member instanceof Field && Utils.isStatic(member) && Utils.isFinal(member))) {
+      throw new IllegalStateException(clsName + "::" + uniqueName + " is not a static final field");
+    }
+
+    final StringBuilder args = new StringBuilder();
+    for (Class<?> argType : argTypes) {
+      args.append("\n                " + getNativeParameterType(argType, info) + ",");
+    }
+    if (args.length() > 0) {
+      args.setLength(args.length() - 1);
+    }
+
+    header.append(
+        "    struct "
+            + getTraitsName(uniqueName, /* includeScope */ false)
+            + " {\n"
+            + "        typedef "
+            + Utils.getUnqualifiedName(clsName)
+            + " Owner;\n"
+            + "        typedef "
+            + getNativeReturnType(type, info)
+            + " ReturnType;\n"
+            + "        typedef "
+            + getNativeParameterType(type, info)
+            + " SetterType;\n"
+            + "        typedef mozilla::jni::Args<"
+            + args
+            + "> Args;\n"
+            + "        static constexpr char name[] = \""
+            + Utils.getMemberName(member)
+            + "\";\n"
+            + "        static constexpr char signature[] =\n"
+            + "                \""
+            + Utils.getSignature(member)
+            + "\";\n"
+            + "        static const bool isStatic = "
+            + Utils.isStatic(member)
+            + ";\n"
+            + "        static const mozilla::jni::ExceptionMode exceptionMode =\n"
+            + "                "
+            + info.exceptionMode.nativeValue()
+            + ";\n"
+            + "        static const mozilla::jni::CallingThread callingThread =\n"
+            + "                "
+            + info.callingThread.nativeValue()
+            + ";\n"
+            + "        static const mozilla::jni::DispatchTarget dispatchTarget =\n"
+            + "                "
+            + info.dispatchTarget.nativeValue()
+            + ";\n"
+            + "    };\n"
+            + "\n");
+
+    cpp.append(
+        "constexpr char "
+            + getTraitsName(uniqueName, /* includeScope */ true)
+            + "::name[];\n"
+            + "constexpr char "
+            + getTraitsName(uniqueName, /* includeScope */ true)
+            + "::signature[];\n"
+            + "\n");
+
+    if (this.callingThread == null) {
+      this.callingThread = info.callingThread;
+    } else if (this.callingThread != info.callingThread) {
+      // We have a mix of calling threads, so specify "any" for the whole class.
+      this.callingThread = AnnotationInfo.CallingThread.ANY;
+    }
+  }
+
+  private String getUniqueMethodName(String basename) {
+    String newName = basename;
+    int index = 1;
+
+    while (takenMethodNames.contains(newName)) {
+      newName = basename + (++index);
+    }
+
+    takenMethodNames.add(newName);
+    return newName;
+  }
+
+  /**
+   * Generate a method prototype that includes return and argument types, without specifiers
+   * (static, const, etc.).
+   */
+  private String generatePrototype(
+      String name,
+      Class<?>[] argTypes,
+      Class<?> returnType,
+      AnnotationInfo info,
+      boolean includeScope,
+      boolean includeArgName,
+      boolean isConst) {
+
+    final StringBuilder proto = new StringBuilder();
+    int argIndex = 0;
+
+    proto.append("auto ");
+
+    if (includeScope) {
+      proto.append(clsName).append("::");
+    }
+
+    proto.append(name).append('(');
+
+    for (Class<?> argType : argTypes) {
+      proto.append(getNativeParameterType(argType, info));
+      if (includeArgName) {
+        proto.append(" a").append(argIndex++);
+      }
+      proto.append(", ");
+    }
+
+    if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT
+        && !returnType.equals(void.class)) {
+      proto.append(getNativeReturnType(returnType, info)).append('*');
+      if (includeArgName) {
+        proto.append(" a").append(argIndex++);
+      }
+      proto.append(", ");
+    }
+
+    if (proto.substring(proto.length() - 2).equals(", ")) {
+      proto.setLength(proto.length() - 2);
+    }
+
+    proto.append(')');
+
+    if (isConst) {
+      proto.append(" const");
+    }
+
+    if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT) {
+      proto.append(" -> nsresult");
+    } else {
+      proto.append(" -> ").append(getNativeReturnType(returnType, info));
+    }
+    return proto.toString();
+  }
+
+  /**
+   * Generate a method declaration that includes the prototype with specifiers, but without the
+   * method body.
+   */
+  private String generateDeclaration(
+      String name,
+      Class<?>[] argTypes,
+      Class<?> returnType,
+      AnnotationInfo info,
+      boolean isStatic) {
+
+    return (isStatic ? "static " : "")
+        + generatePrototype(
+            name,
+            argTypes,
+            returnType,
+            info,
+            /* includeScope */ false, /* includeArgName */
+            false,
+            /* isConst */ !isStatic)
+        + ';';
+  }
+
+  /**
+   * Generate a method definition that includes the prototype with specifiers, and with the method
+   * body.
+   */
+  private String generateDefinition(
+      String accessorName,
+      String name,
+      Class<?>[] argTypes,
+      Class<?> returnType,
+      AnnotationInfo info,
+      boolean isStatic) {
+
+    final StringBuilder def =
+        new StringBuilder(
+            generatePrototype(
+                name,
+                argTypes,
+                returnType,
+                info,
+                /* includeScope */ true, /* includeArgName */
+                true,
+                /* isConst */ !isStatic));
+    def.append("\n{\n");
+
+    // Generate code to handle the return value, if needed.
+    // We initialize rv to NS_OK instead of NS_ERROR_* because loading NS_OK (0) uses
+    // fewer instructions. We are guaranteed to set rv to the correct value later.
+
+    if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT
+        && returnType.equals(void.class)) {
+      def.append("    nsresult rv = NS_OK;\n" + "    ");
+
+    } else if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT) {
+      // Non-void return type
+      final String resultArg = "a" + argTypes.length;
+      def.append(
+          "    MOZ_ASSERT("
+              + resultArg
+              + ");\n"
+              + "    nsresult rv = NS_OK;\n"
+              + "    *"
+              + resultArg
+              + " = ");
+
+    } else {
+      def.append("    return ");
+    }
+
+    // Generate a call, e.g., Method<Traits>::Call(a0, a1, a2);
+
+    def.append(accessorName)
+        .append("(")
+        .append(Utils.getUnqualifiedName(clsName) + (isStatic ? "::Context()" : "::mCtx"));
+
+    if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT) {
+      def.append(", &rv");
+    } else {
+      def.append(", nullptr");
+    }
+
+    // Generate the call argument list.
+    for (int argIndex = 0; argIndex < argTypes.length; argIndex++) {
+      def.append(", a").append(argIndex);
+    }
+
+    def.append(");\n");
+
+    if (info.exceptionMode == AnnotationInfo.ExceptionMode.NSRESULT) {
+      def.append("    return rv;\n");
+    }
+
+    return def.append("}").toString();
+  }
+
+  private static void appendParameterList(
+      final StringBuilder builder, final Class<?> genScope, final Class<?> paramTypes[]) {
+    builder.append("(");
+
+    final int maxParamIndex = paramTypes.length - 1;
+
+    for (int i = 0; i < paramTypes.length; ++i) {
+      builder.append(Utils.getSimplifiedJavaClassName(genScope, paramTypes[i]));
+      if (i < maxParamIndex) {
+        builder.append(", ");
+      }
+    }
+
+    builder.append(")");
+  }
+
+  /**
+   * This method generates a comment for C++ headers containing a simplified form of a method's Java
+   * signature. This is entirely for informational purposes to assist developers with disambiguating
+   * arguments to the native wrappers.
+   */
+  private static String generateJavaStyleMethodSignatureHint(
+      final Method method, final boolean isStatic) {
+    final StringBuilder builder = new StringBuilder("    // ");
+
+    if (isStatic) {
+      builder.append("static ");
+    }
+
+    final Class<?> declaringClass = method.getDeclaringClass();
+
+    builder
+        .append(Utils.getSimplifiedJavaClassName(declaringClass, method.getReturnType()))
+        .append(" ")
+        .append(method.getName());
+
+    appendParameterList(builder, declaringClass, method.getParameterTypes());
+
+    builder.append("\n");
+    return builder.toString();
+  }
+
+  /**
+   * This method generates a comment for C++ headers containing a simplified form of a
+   * constructors's Java signature. This is entirely for informational purposes to assist developers
+   * with disambiguating arguments to the native wrappers.
+   */
+  private static String generateJavaStyleConstructorSignatureHint(
+      final Constructor<?> constructor) {
+    final StringBuilder builder = new StringBuilder("    // ");
+
+    final Class<?> declaringClass = constructor.getDeclaringClass();
+
+    builder.append(declaringClass.getSimpleName());
+
+    appendParameterList(builder, declaringClass, constructor.getParameterTypes());
+
+    builder.append("\n");
+    return builder.toString();
+  }
+
+  /**
+   * Append the appropriate generated code to the buffers for the method provided.
+   *
+   * @param annotatedMethod The Java method, plus annotation data.
+   */
+  public void generateMethod(AnnotatableEntity annotatedMethod) {
+    // Unpack the tuple and extract some useful fields from the Method..
+    final Method method = annotatedMethod.getMethod();
+    final AnnotationInfo info = annotatedMethod.mAnnotationInfo;
+    final String uniqueName = getUniqueMethodName(info.wrapperName);
+    final Class<?>[] argTypes = method.getParameterTypes();
+    final Class<?> returnType = method.getReturnType();
+
+    if (method.isSynthetic()) {
+      return;
+    }
+
+    // Sanity check
+    if (info.dispatchTarget != AnnotationInfo.DispatchTarget.CURRENT) {
+      throw new IllegalStateException(
+          "Invalid dispatch target \""
+              + info.dispatchTarget.name().toLowerCase(Locale.ROOT)
+              + "\" for non-native method "
+              + clsName
+              + "::"
+              + uniqueName);
+    }
+
+    generateMember(info, method, uniqueName, returnType, argTypes);
+
+    final boolean isStatic = Utils.isStatic(method);
+
+    header.append(generateJavaStyleMethodSignatureHint(method, isStatic));
+
+    header.append(
+        "    "
+            + generateDeclaration(info.wrapperName, argTypes, returnType, info, isStatic)
+            + "\n"
+            + "\n");
+
+    cpp.append(
+        generateDefinition(
+                "mozilla::jni::Method<"
+                    + getTraitsName(uniqueName, /* includeScope */ false)
+                    + ">::Call",
+                info.wrapperName,
+                argTypes,
+                returnType,
+                info,
+                isStatic)
+            + "\n"
+            + "\n");
+  }
+
+  /**
+   * Append the appropriate generated code to the buffers for the native method provided.
+   *
+   * @param annotatedMethod The Java native method, plus annotation data.
+   */
+  public void generateNative(AnnotatableEntity annotatedMethod) {
+    // Unpack the tuple and extract some useful fields from the Method..
+    final Method method = annotatedMethod.getMethod();
+    final AnnotationInfo info = annotatedMethod.mAnnotationInfo;
+    final String uniqueName = getUniqueMethodName(info.wrapperName);
+    final Class<?>[] argTypes = method.getParameterTypes();
+    final Class<?> returnType = method.getReturnType();
+
+    // Sanity check
+    if (info.exceptionMode != AnnotationInfo.ExceptionMode.ABORT
+        && info.exceptionMode != AnnotationInfo.ExceptionMode.IGNORE) {
+      throw new IllegalStateException(
+          "Invalid exception mode \""
+              + info.exceptionMode.name().toLowerCase(Locale.ROOT)
+              + "\" for native method "
+              + clsName
+              + "::"
+              + uniqueName);
+    }
+    if (info.dispatchTarget != AnnotationInfo.DispatchTarget.CURRENT && returnType != void.class) {
+      throw new IllegalStateException(
+          "Must return void when not dispatching to current thread for native method "
+              + clsName
+              + "::"
+              + uniqueName);
+    }
+
+    generateNativeSignatureHint(info, method, uniqueName, returnType, argTypes);
+    generateMember(info, method, uniqueName, returnType, argTypes);
+
+    final String traits = getTraitsName(uniqueName, /* includeScope */ true);
+
+    if (nativesInits.length() > 0) {
+      nativesInits.append(',');
+    }
+
+    nativesInits.append(
+        "\n"
+            + "\n"
+            + "    mozilla::jni::MakeNativeMethod<"
+            + traits
+            + ">(\n"
+            + "            mozilla::jni::NativeStub<"
+            + traits
+            + ", Impl>\n"
+            + "            ::template Wrap<&Impl::"
+            + info.wrapperName
+            + ">)");
+    numNativesInits++;
+  }
+
+  private void generateNativeSignatureHint(
+      AnnotationInfo info,
+      Member member,
+      String uniqueName,
+      Class<?> returnType,
+      Class<?>[] argTypes) {
+    final StringBuilder hint =
+        new StringBuilder("    // Suggested header signature for native method:\n    // ");
+
+    if (Utils.isStatic(member)) {
+      hint.append("static ");
+    }
+
+    hint.append(Utils.getNativeReturnTypeHint(returnType, info))
+        .append(" ")
+        .append(uniqueName)
+        .append("(");
+
+    final int maxParamIndex = argTypes.length - 1;
+
+    for (int i = 0; i < argTypes.length; ++i) {
+      hint.append(Utils.getNativeParameterTypeHint(argTypes[i], info));
+      if (i < maxParamIndex) {
+        hint.append(", ");
+      }
+    }
+
+    hint.append(");\n");
+
+    header.append(hint.toString());
+  }
+
+  private String getLiteral(Object val, AnnotationInfo info) {
+    final Class<?> type = val.getClass();
+
+    if (type.equals(char.class) || type.equals(Character.class)) {
+      final char c = (char) val;
+      if (c >= 0x20 && c < 0x7F) {
+        return "'" + c + '\'';
+      }
+      return "u'\\u" + Integer.toHexString(0x10000 | (int) c).substring(1) + '\'';
+
+    } else if (type.equals(CharSequence.class) || type.equals(String.class)) {
+      final CharSequence str = (CharSequence) val;
+      final StringBuilder out = new StringBuilder("u\"");
+      for (int i = 0; i < str.length(); i++) {
+        final char c = str.charAt(i);
+        if (c >= 0x20 && c < 0x7F) {
+          out.append(c);
+        } else {
+          out.append("\\u").append(Integer.toHexString(0x10000 | (int) c).substring(1));
+        }
+      }
+      return out.append('"').toString();
+    }
+
+    return String.valueOf(val);
+  }
+
+  public void generateField(AnnotatableEntity annotatedField) {
+    final Field field = annotatedField.getField();
+    final AnnotationInfo info = annotatedField.mAnnotationInfo;
+    final String uniqueName = info.wrapperName;
+    final Class<?> type = field.getType();
+
+    // Handle various cases where we don't care about the field.
+    if (field.isSynthetic()
+        || field.getName().equals("$VALUES")
+        || field.getName().equals("CREATOR")) {
+      return;
+    }
+
+    // Sanity check
+    if (info.dispatchTarget != AnnotationInfo.DispatchTarget.CURRENT) {
+      throw new IllegalStateException(
+          "Invalid dispatch target \""
+              + info.dispatchTarget.name().toLowerCase(Locale.ROOT)
+              + "\" for field "
+              + clsName
+              + "::"
+              + uniqueName);
+    }
+
+    final boolean isStatic = Utils.isStatic(field);
+    final boolean isFinal = Utils.isFinal(field);
+
+    if (!info.noLiteral
+        && isStatic
+        && isFinal
+        && (type.isPrimitive() || type.equals(String.class))) {
+      Object val = null;
+      try {
+        field.setAccessible(true);
+        val = field.get(null);
+      } catch (final IllegalAccessException e) {
+      }
+
+      if (val != null && type.isPrimitive()) {
+        // For static final primitive fields, we can use a "static const" declaration.
+        header.append(
+            "    static const "
+                + Utils.getNativeReturnType(type, info)
+                + ' '
+                + info.wrapperName
+                + " = "
+                + getLiteral(val, info)
+                + ";\n"
+                + "\n");
+        return;
+
+      } else if (val != null && type.equals(String.class)) {
+        final String nativeType = "char16_t";
+
+        header.append("    static const " + nativeType + ' ' + info.wrapperName + "[];\n" + "\n");
+
+        cpp.append(
+            "const "
+                + nativeType
+                + ' '
+                + clsName
+                + "::"
+                + info.wrapperName
+                + "[] = "
+                + getLiteral(val, info)
+                + ";\n"
+                + "\n");
+        return;
+      }
+
+      // Fall back to using accessors if we encounter an exception.
+    }
+
+    generateMember(info, field, uniqueName, type, EMPTY_CLASS_ARRAY);
+
+    final Class<?>[] getterArgs = EMPTY_CLASS_ARRAY;
+
+    header.append(
+        "    "
+            + generateDeclaration(info.wrapperName, getterArgs, type, info, isStatic)
+            + "\n"
+            + "\n");
+
+    cpp.append(
+        generateDefinition(
+                "mozilla::jni::Field<"
+                    + getTraitsName(uniqueName, /* includeScope */ false)
+                    + ">::Get",
+                info.wrapperName,
+                getterArgs,
+                type,
+                info,
+                isStatic)
+            + "\n"
+            + "\n");
+
+    if (isFinal) {
+      return;
+    }
+
+    final Class<?>[] setterArgs = new Class<?>[] {type};
+
+    header.append(
+        "    "
+            + generateDeclaration(info.wrapperName, setterArgs, void.class, info, isStatic)
+            + "\n"
+            + "\n");
+
+    cpp.append(
+        generateDefinition(
+                "mozilla::jni::Field<"
+                    + getTraitsName(uniqueName, /* includeScope */ false)
+                    + ">::Set",
+                info.wrapperName,
+                setterArgs,
+                void.class,
+                info,
+                isStatic)
+            + "\n"
+            + "\n");
+  }
+
+  public void generateConstructor(AnnotatableEntity annotatedConstructor) {
+    // Unpack the tuple and extract some useful fields from the Method..
+    final Constructor<?> method = annotatedConstructor.getConstructor();
+    final AnnotationInfo info = annotatedConstructor.mAnnotationInfo;
+    final String wrapperName = info.wrapperName.equals("<init>") ? "New" : info.wrapperName;
+    final String uniqueName = getUniqueMethodName(wrapperName);
+    final Class<?>[] argTypes = method.getParameterTypes();
+    final Class<?> returnType = cls;
+
+    if (method.isSynthetic()) {
+      return;
+    }
+
+    // Sanity check
+    if (info.dispatchTarget != AnnotationInfo.DispatchTarget.CURRENT) {
+      throw new IllegalStateException(
+          "Invalid dispatch target \""
+              + info.dispatchTarget.name().toLowerCase(Locale.ROOT)
+              + "\" for constructor "
+              + clsName
+              + "::"
+              + uniqueName);
+    }
+
+    generateMember(info, method, uniqueName, returnType, argTypes);
+
+    header.append(generateJavaStyleConstructorSignatureHint(method));
+
+    header.append(
+        "    "
+            + generateDeclaration(wrapperName, argTypes, returnType, info, /* isStatic */ true)
+            + "\n"
+            + "\n");
+
+    cpp.append(
+        generateDefinition(
+                "mozilla::jni::Constructor<"
+                    + getTraitsName(uniqueName, /* includeScope */ false)
+                    + ">::Call",
+                wrapperName,
+                argTypes,
+                returnType,
+                info, /* isStatic */
+                true)
+            + "\n"
+            + "\n");
+  }
+
+  public void generateClasses(final ClassWithOptions[] classes) {
+    if (classes.length == 0) {
+      return;
+    }
+
+    for (final ClassWithOptions cls : classes) {
+      // Extract "Inner" from "Outer::Inner".
+      header.append("    class " + Utils.getUnqualifiedName(cls.generatedName) + ";\n");
+    }
+    header.append('\n');
+  }
+
+  /**
+   * Get the finalised bytes to go into the generated wrappers file.
+   *
+   * @return The bytes to be written to the wrappers file.
+   */
+  public String getWrapperFileContents() {
+    cpp.append(Utils.getIfdefFooter(options.ifdef));
+    return cpp.toString();
+  }
+
+  private boolean haveNatives() {
+    return nativesInits.length() > 0 || Utils.isJNIObject(cls);
+  }
+
+  /**
+   * Get the finalised bytes to go into the generated header file.
+   *
+   * @return The bytes to be written to the header file.
+   */
+  public String getHeaderFileContents() {
+    if (this.callingThread == null) {
+      this.callingThread = AnnotationInfo.CallingThread.ANY;
+    }
+
+    header.append(
+        "    static const mozilla::jni::CallingThread callingThread =\n"
+            + "            "
+            + this.callingThread.nativeValue()
+            + ";\n"
+            + "\n");
+
+    if (haveNatives()) {
+      header.append("    template<class Impl> class Natives;\n");
+    }
+    header.append("};\n" + "\n" + Utils.getIfdefFooter(options.ifdef));
+    return header.toString();
+  }
+
+  /**
+   * Get the finalised bytes to go into the generated natives header file.
+   *
+   * @return The bytes to be written to the header file.
+   */
+  public String getNativesFileContents() {
+    if (!haveNatives()) {
+      return "";
+    }
+    natives.append(
+        "    static const JNINativeMethod methods["
+            + numNativesInits
+            + "];\n"
+            + "};\n"
+            + "\n"
+            + "template<class Impl>\n"
+            + "const JNINativeMethod "
+            + clsName
+            + "::Natives<Impl>::methods[] = {"
+            + nativesInits
+            + '\n'
+            + "};\n"
+            + "\n"
+            + Utils.getIfdefFooter(options.ifdef));
+    return natives.toString();
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/SDKProcessor.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/SDKProcessor.java
new file mode 100644
index 0000000000..c0a69de49c
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/SDKProcessor.java
@@ -0,0 +1,578 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors;
+
+/**
+ * Generate C++ bindings for SDK classes using a config file.
+ *
+ * <p>java SDKProcessor <sdkjar> <max-sdk-version> <outdir> [<configfile> <fileprefix>]+
+ *
+ * <p><sdkjar>: jar file containing the SDK classes (e.g. android.jar) <max-sdk-version>: SDK
+ * version for generated class members (bindings will not be generated for members with SDK versions
+ * higher than max-sdk-version) <outdir>: output directory for generated binding files <configfile>:
+ * config file for generating bindings <fileprefix>: prefix used for generated binding files
+ *
+ * <p>Each config file is a text file following the .ini format:
+ *
+ * <p>; comment [section1] property = value
+ *
+ * <p># comment [section2] property = value
+ *
+ * <p>Each section specifies a qualified SDK class. Each property specifies a member of that class.
+ * The class and/or the property may specify options found in the WrapForJNI annotation. For
+ * example,
+ *
+ * <p># Generate bindings for Bundle using default options: [android.os.Bundle]
+ *
+ * <p># Generate bindings for Bundle using class options: [android.os.Bundle =
+ * exceptionMode:nsresult]
+ *
+ * <p># Generate bindings for Bundle using method options: [android.os.Bundle] putInt =
+ * stubName:PutInteger
+ *
+ * <p># Generate bindings for Bundle using class options with method override: # (note that all
+ * options are overriden at the same time.) [android.os.Bundle = exceptionMode:nsresult] # putInt
+ * will have stubName "PutInteger", and exceptionMode of "abort" putInt = stubName:PutInteger #
+ * putChar will have stubName "PutCharacter", and exceptionMode of "nsresult" putChar =
+ * stubName:PutCharacter, exceptionMode:nsresult
+ *
+ * <p># Overloded methods can be specified using its signature [android.os.Bundle] # Skip the copy
+ * constructor <init>(Landroid/os/Bundle;)V = skip:true
+ *
+ * <p># Generic member types can be specified [android.view.KeyEvent = skip:true] # Skip everything
+ * except fields <field> = skip:false
+ *
+ * <p># Skip everything except putInt and putChar [android.os.Bundle = skip:true] putInt =
+ * skip:false putChar =
+ *
+ * <p># Avoid conflicts in native bindings [android.os.Bundle] # Bundle(PersistableBundle) native
+ * binding can conflict with Bundle(ClassLoader) <init>(Landroid/os/PersistableBundle;)V =
+ * stubName:NewFromPersistableBundle
+ *
+ * <p># Generate a getter instead of a literal for certain runtime constants
+ * [android.os.Build$VERSION = skip:true] SDK_INT = noLiteral:true
+ */
+import com.android.tools.lint.LintCliClient;
+import com.android.tools.lint.checks.ApiLookup;
+import com.android.tools.lint.client.api.LintClient;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Locale;
+import org.mozilla.gecko.annotationProcessors.classloader.AnnotatableEntity;
+import org.mozilla.gecko.annotationProcessors.classloader.ClassWithOptions;
+import org.mozilla.gecko.annotationProcessors.utils.Utils;
+
+public class SDKProcessor {
+  public static final String GENERATED_COMMENT =
+      "// GENERATED CODE\n"
+          + "// Generated by the Java program at /build/annotationProcessors at compile time\n"
+          + "// from annotations on Java methods. To update, change the annotations on the\n"
+          + "// corresponding Javamethods and rerun the build. Manually updating this file\n"
+          + "// will cause your build to fail.\n"
+          + "\n";
+
+  private static ApiLookup sApiLookup;
+  private static int sMaxSdkVersion;
+
+  private static class ParseException extends Exception {
+    public ParseException(final String message) {
+      super(message);
+    }
+  }
+
+  private static class ClassInfo {
+    public final String name;
+
+    // Map constructor/field/method signature to a set of annotation values.
+    private final HashMap<String, String> mAnnotations = new HashMap<>();
+    // Default set of annotation values to use.
+    private final String mDefaultAnnotation;
+    // List of nested classes to forward declare.
+    private final ArrayList<Class<?>> mNestedClasses;
+
+    public ClassInfo(final String text) {
+      final String[] mapping = text.split("=", 2);
+      name = mapping[0].trim();
+      mDefaultAnnotation = mapping.length > 1 ? mapping[1].trim() : null;
+      mNestedClasses = new ArrayList<>();
+    }
+
+    public void addAnnotation(final String text) throws ParseException {
+      final String[] mapping = text.split("=", 2);
+      final String prop = mapping[0].trim();
+      if (prop.isEmpty()) {
+        throw new ParseException("Missing member name: " + text);
+      }
+      if (mapping.length < 2) {
+        throw new ParseException("Missing equal sign: " + text);
+      }
+      if (mAnnotations.get(prop) != null) {
+        throw new ParseException("Already has member: " + prop);
+      }
+      mAnnotations.put(prop, mapping[1].trim());
+    }
+
+    public AnnotationInfo getAnnotationInfo(final Member member) throws ParseException {
+      String stubName = Utils.getNativeName(member);
+      AnnotationInfo.ExceptionMode mode = AnnotationInfo.ExceptionMode.ABORT;
+      AnnotationInfo.CallingThread thread = AnnotationInfo.CallingThread.ANY;
+      AnnotationInfo.DispatchTarget target = AnnotationInfo.DispatchTarget.CURRENT;
+      boolean noLiteral = false;
+      boolean isGeneric = false;
+
+      final String name = Utils.getMemberName(member);
+      String annotation =
+          mAnnotations.get(
+              name + (member instanceof Field ? ":" : "") + Utils.getSignature(member));
+      if (annotation == null) {
+        // Match name without signature
+        annotation = mAnnotations.get(name);
+      }
+      if (annotation == null) {
+        // Match <constructor>, <field>, <method>
+        annotation =
+            mAnnotations.get(
+                "<" + member.getClass().getSimpleName().toLowerCase(Locale.ROOT) + '>');
+        isGeneric = true;
+      }
+      if (annotation == null) {
+        // Fallback on class options, if any.
+        annotation = mDefaultAnnotation;
+      }
+      if (annotation == null || annotation.isEmpty()) {
+        return new AnnotationInfo(stubName, mode, thread, target, noLiteral);
+      }
+
+      final String[] elements = annotation.split(",");
+      for (final String element : elements) {
+        final String[] pair = element.split(":", 2);
+        if (pair.length < 2) {
+          throw new ParseException("Missing option value: " + element);
+        }
+        final String pairName = pair[0].trim();
+        final String pairValue = pair[1].trim();
+        switch (pairName) {
+          case "skip":
+            if (Boolean.valueOf(pairValue)) {
+              // Return null to signal skipping current method.
+              return null;
+            }
+            break;
+          case "stubName":
+            if (isGeneric) {
+              // Prevent specifying stubName for class options.
+              throw new ParseException("stubName doesn't make sense here: " + pairValue);
+            }
+            stubName = pairValue;
+            break;
+          case "exceptionMode":
+            mode = Utils.getEnumValue(AnnotationInfo.ExceptionMode.class, pairValue);
+            break;
+          case "calledFrom":
+            thread = Utils.getEnumValue(AnnotationInfo.CallingThread.class, pairValue);
+            break;
+          case "dispatchTo":
+            target = Utils.getEnumValue(AnnotationInfo.DispatchTarget.class, pairValue);
+            break;
+          case "noLiteral":
+            noLiteral = Boolean.valueOf(pairValue);
+            break;
+          default:
+            throw new ParseException("Unknown option: " + pairName);
+        }
+      }
+      return new AnnotationInfo(stubName, mode, thread, target, noLiteral);
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    // We expect a list of jars on the commandline. If missing, whinge about it.
+    if (args.length < 3 || args.length % 2 != 1) {
+      System.err.println(
+          "Usage: java SDKProcessor sdkjar max-sdk-version outdir [configfile fileprefix]*");
+      System.exit(1);
+    }
+
+    System.out.println("Processing platform bindings...");
+
+    final File sdkJar = new File(args[0]);
+    sMaxSdkVersion = Integer.parseInt(args[1]);
+    final String outdir = args[2];
+
+    final LintCliClient lintClient = new LintCliClient(LintClient.CLIENT_CLI);
+    sApiLookup = ApiLookup.get(lintClient);
+
+    for (int argIndex = 3; argIndex < args.length; argIndex += 2) {
+      final String configFile = args[argIndex];
+      final String generatedFilePrefix = args[argIndex + 1];
+      System.out.println("Processing bindings from " + configFile);
+
+      // Start the clock!
+      long s = System.currentTimeMillis();
+
+      // Get an iterator over the classes in the jar files given...
+      // Iterator<ClassWithOptions> jarClassIterator =
+      // IterableJarLoadingURLClassLoader.getIteratorOverJars(args);
+
+      StringBuilder headerFile = new StringBuilder(GENERATED_COMMENT);
+      headerFile.append(
+          "#ifndef "
+              + generatedFilePrefix
+              + "_h__\n"
+              + "#define "
+              + generatedFilePrefix
+              + "_h__\n"
+              + "\n"
+              + "#include \"mozilla/jni/Refs.h\"\n"
+              + "\n"
+              + "namespace mozilla {\n"
+              + "namespace java {\n"
+              + "namespace sdk {\n"
+              + "\n");
+
+      StringBuilder implementationFile = new StringBuilder(GENERATED_COMMENT);
+      implementationFile.append(
+          "#include \""
+              + generatedFilePrefix
+              + ".h\"\n"
+              + "#include \"mozilla/jni/Accessors.h\"\n"
+              + "\n"
+              + "namespace mozilla {\n"
+              + "namespace java {\n"
+              + "namespace sdk {\n"
+              + "\n");
+
+      // Used to track the calls to the various class-specific initialisation functions.
+      ClassLoader loader = null;
+      try {
+        loader =
+            URLClassLoader.newInstance(
+                new URL[] {sdkJar.toURI().toURL()}, SDKProcessor.class.getClassLoader());
+      } catch (Exception e) {
+        throw new RuntimeException(e.toString());
+      }
+
+      try {
+        ClassInfo[] classes = getClassList(configFile);
+        classes = addNestedClassForwardDeclarations(classes, loader);
+
+        for (final ClassInfo cls : classes) {
+          System.out.println("Looking up: " + cls.name);
+          generateClass(Class.forName(cls.name, true, loader), cls, implementationFile, headerFile);
+        }
+      } catch (final IllegalStateException | IOException | ParseException e) {
+        System.err.println("***");
+        System.err.println("*** Error parsing config file: " + configFile);
+        System.err.println("*** " + e);
+        System.err.println("***");
+        if (e.getCause() != null) {
+          e.getCause().printStackTrace(System.err);
+        }
+        System.exit(1);
+        return;
+      }
+
+      implementationFile.append("} /* sdk */\n" + "} /* java */\n" + "} /* mozilla */\n");
+
+      headerFile.append("} /* sdk */\n" + "} /* java */\n" + "} /* mozilla */\n" + "#endif\n");
+
+      writeOutputFiles(outdir, generatedFilePrefix, headerFile, implementationFile);
+      long e = System.currentTimeMillis();
+      System.out.println("SDK processing complete in " + (e - s) + "ms");
+    }
+  }
+
+  private static int getAPIVersion(Class<?> cls, Member m) {
+    if (m instanceof Method || m instanceof Constructor) {
+      return sApiLookup.getMethodVersion(
+          cls.getName().replace('.', '/'), Utils.getMemberName(m), Utils.getSignature(m));
+    } else if (m instanceof Field) {
+      return sApiLookup.getFieldVersion(
+          Utils.getClassDescriptor(m.getDeclaringClass()), m.getName());
+    } else {
+      throw new IllegalArgumentException("expected member to be Method, Constructor, or Field");
+    }
+  }
+
+  private static Member[] sortAndFilterMembers(Class<?> cls, Member[] members) {
+    Arrays.sort(
+        members,
+        new Comparator<Member>() {
+          @Override
+          public int compare(Member a, Member b) {
+            int result = a.getName().compareTo(b.getName());
+            if (result == 0) {
+              if (a instanceof Constructor && b instanceof Constructor) {
+                String sa = Arrays.toString(((Constructor) a).getParameterTypes());
+                String sb = Arrays.toString(((Constructor) b).getParameterTypes());
+                result = sa.compareTo(sb);
+              } else if (a instanceof Method && b instanceof Method) {
+                String sa = Arrays.toString(((Method) a).getParameterTypes());
+                String sb = Arrays.toString(((Method) b).getParameterTypes());
+                result = sa.compareTo(sb);
+              }
+            }
+            return result;
+          }
+        });
+
+    ArrayList<Member> list = new ArrayList<>();
+    for (final Member m : members) {
+      if (m.getDeclaringClass() == Object.class) {
+        // Skip methods from Object.
+        continue;
+      }
+
+      // Sometimes (e.g. Bundle) has methods that moved to/from a superclass in a later SDK
+      // version, so we check for both classes and see if we can find a minimum SDK version.
+      int version = getAPIVersion(cls, m);
+      final int version2 = getAPIVersion(m.getDeclaringClass(), m);
+      if (version2 > 0 && version2 < version) {
+        version = version2;
+      }
+      if (version > sMaxSdkVersion) {
+        System.out.println(
+            "Skipping "
+                + m.getDeclaringClass().getName()
+                + "."
+                + Utils.getMemberName(m)
+                + ", version "
+                + version
+                + " > "
+                + sMaxSdkVersion);
+        continue;
+      }
+
+      // Sometimes (e.g. KeyEvent) a field can appear in both a class and a superclass. In
+      // that case we want to filter out the version that appears in the superclass, or
+      // we'll have bindings with duplicate names.
+      try {
+        if (m instanceof Field && !m.equals(cls.getField(m.getName()))) {
+          // m is a field in a superclass that has been hidden by
+          // a field with the same name in a subclass.
+          System.out.println(
+              "Skipping " + Utils.getMemberName(m) + " from " + m.getDeclaringClass().getName());
+          continue;
+        }
+      } catch (final NoSuchFieldException e) {
+      }
+
+      list.add(m);
+    }
+
+    return list.toArray(new Member[list.size()]);
+  }
+
+  private static void generateMembers(CodeGenerator generator, ClassInfo clsInfo, Member[] members)
+      throws ParseException {
+    for (Member m : members) {
+      if (!Modifier.isPublic(m.getModifiers())) {
+        continue;
+      }
+
+      // Default for SDK bindings.
+      final AnnotationInfo info = clsInfo.getAnnotationInfo(m);
+      if (info == null) {
+        // Skip this member.
+        continue;
+      }
+      final AnnotatableEntity entity = new AnnotatableEntity(m, info);
+
+      if (m instanceof Constructor) {
+        generator.generateConstructor(entity);
+      } else if (m instanceof Method) {
+        generator.generateMethod(entity);
+      } else if (m instanceof Field) {
+        generator.generateField(entity);
+      } else {
+        throw new IllegalArgumentException("expected member to be Constructor, Method, or Field");
+      }
+    }
+  }
+
+  private static String getGeneratedName(Class<?> clazz) {
+    ArrayList<String> classes = new ArrayList<>();
+    do {
+      classes.add(clazz.getSimpleName());
+      clazz = clazz.getDeclaringClass();
+    } while (clazz != null);
+    Collections.reverse(classes);
+    return String.join("::", classes);
+  }
+
+  private static void generateClass(
+      Class<?> clazz, ClassInfo clsInfo, StringBuilder implementationFile, StringBuilder headerFile)
+      throws ParseException {
+    String generatedName = getGeneratedName(clazz);
+
+    CodeGenerator generator =
+        new CodeGenerator(new ClassWithOptions(clazz, generatedName, /* ifdef */ ""));
+
+    // Forward declaration for nested classes
+    ClassWithOptions[] nestedClasses =
+        clsInfo.mNestedClasses.stream()
+            .map(
+                nestedClass ->
+                    new ClassWithOptions(nestedClass, getGeneratedName(nestedClass), null))
+            .sorted((a, b) -> a.generatedName.compareTo(b.generatedName))
+            .toArray(ClassWithOptions[]::new);
+    generator.generateClasses(nestedClasses);
+
+    generateMembers(generator, clsInfo, sortAndFilterMembers(clazz, clazz.getConstructors()));
+    generateMembers(generator, clsInfo, sortAndFilterMembers(clazz, clazz.getMethods()));
+    generateMembers(generator, clsInfo, sortAndFilterMembers(clazz, clazz.getFields()));
+
+    headerFile.append(generator.getHeaderFileContents());
+    implementationFile.append(generator.getWrapperFileContents());
+  }
+
+  private static ClassInfo[] getClassList(BufferedReader reader)
+      throws ParseException, IOException {
+    final ArrayList<ClassInfo> classes = new ArrayList<>();
+    ClassInfo currentClass = null;
+    String line;
+
+    while ((line = reader.readLine()) != null) {
+      line = line.trim();
+      if (line.isEmpty()) {
+        continue;
+      }
+      switch (line.charAt(0)) {
+        case ';':
+        case '#':
+          // Comment
+          continue;
+        case '[':
+          // New section
+          if (line.charAt(line.length() - 1) != ']') {
+            throw new ParseException("Missing trailing ']': " + line);
+          }
+          currentClass = new ClassInfo(line.substring(1, line.length() - 1));
+          classes.add(currentClass);
+          break;
+        default:
+          // New mapping
+          if (currentClass == null) {
+            throw new ParseException("Missing class: " + line);
+          }
+          currentClass.addAnnotation(line);
+          break;
+      }
+    }
+    if (classes.isEmpty()) {
+      throw new ParseException("No class found in config file");
+    }
+    return classes.toArray(new ClassInfo[classes.size()]);
+  }
+
+  private static ClassInfo[] getClassList(final String path) throws ParseException, IOException {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new FileReader(path));
+      return getClassList(reader);
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  /**
+   * For each nested class we wish to generate bindings for, this ensures that the generated binding
+   * for its outer class (recursively, until we reach a top-level class) will contain a forward
+   * declaration of the nested class.
+   */
+  private static ClassInfo[] addNestedClassForwardDeclarations(
+      final ClassInfo[] classes, final ClassLoader loader) throws ClassNotFoundException {
+    final HashMap<String, ClassInfo> classMap = new HashMap<>();
+    for (final ClassInfo cls : classes) {
+      classMap.put(cls.name, cls);
+    }
+
+    for (final ClassInfo classInfo : classes) {
+      Class<?> innerClass = Class.forName(classInfo.name, true, loader);
+      while (innerClass.getDeclaringClass() != null) {
+        Class<?> outerClass = innerClass.getDeclaringClass();
+        ClassInfo outerClassInfo = classMap.get(outerClass.getName());
+        if (outerClassInfo == null) {
+          // If there isn't already a ClassInfo object for the outer class then we must insert one.
+          // This ensures that we actually generate a declaration for the outer class, in which we
+          // can forward-declare the inner class. "skip:true" ensures we do not generate bindings
+          // for the outer class' member's, as we simply want to forward declare the inner class.
+          outerClassInfo = new ClassInfo(String.format("%s = skip:true", outerClass.getName()));
+          classMap.put(outerClass.getName(), outerClassInfo);
+        }
+        // Add the inner class to the outer class' mNestedClasses, ensuring the outer class'
+        // generated code will forward-declare the inner class.
+        outerClassInfo.mNestedClasses.add(innerClass);
+
+        innerClass = outerClass;
+      }
+    }
+
+    // Sort to ensure we generate the classes in a deterministic order, and that outer classes are
+    // declared before nested classes.
+    return classMap.values().stream()
+        .sorted((a, b) -> a.name.compareTo(b.name))
+        .toArray(ClassInfo[]::new);
+  }
+
+  private static void writeOutputFiles(
+      String aOutputDir,
+      String aPrefix,
+      StringBuilder aHeaderFile,
+      StringBuilder aImplementationFile) {
+    FileOutputStream implStream = null;
+    try {
+      implStream = new FileOutputStream(new File(aOutputDir, aPrefix + ".cpp"));
+      implStream.write(aImplementationFile.toString().getBytes());
+    } catch (IOException e) {
+      System.err.println("Unable to write " + aOutputDir + ". Perhaps a permissions issue?");
+      e.printStackTrace(System.err);
+    } finally {
+      if (implStream != null) {
+        try {
+          implStream.close();
+        } catch (IOException e) {
+          System.err.println("Unable to close implStream due to " + e);
+          e.printStackTrace(System.err);
+        }
+      }
+    }
+
+    FileOutputStream headerStream = null;
+    try {
+      headerStream = new FileOutputStream(new File(aOutputDir, aPrefix + ".h"));
+      headerStream.write(aHeaderFile.toString().getBytes());
+    } catch (IOException e) {
+      System.err.println("Unable to write " + aOutputDir + ". Perhaps a permissions issue?");
+      e.printStackTrace(System.err);
+    } finally {
+      if (headerStream != null) {
+        try {
+          headerStream.close();
+        } catch (IOException e) {
+          System.err.println("Unable to close headerStream due to " + e);
+          e.printStackTrace(System.err);
+        }
+      }
+    }
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/AnnotatableEntity.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/AnnotatableEntity.java
new file mode 100644
index 0000000000..b2df6587c1
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/AnnotatableEntity.java
@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.classloader;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import org.mozilla.gecko.annotationProcessors.AnnotationInfo;
+
+/**
+ * Union type to hold either a method, field, or ctor. Allows us to iterate "The generatable stuff",
+ * despite the fact that such things can be of either flavour.
+ */
+public class AnnotatableEntity {
+  public enum ENTITY_TYPE {
+    METHOD,
+    NATIVE,
+    FIELD,
+    CONSTRUCTOR
+  }
+
+  private final Member mMember;
+  public final ENTITY_TYPE mEntityType;
+
+  public final AnnotationInfo mAnnotationInfo;
+
+  public AnnotatableEntity(Member aObject, AnnotationInfo aAnnotationInfo) {
+    mMember = aObject;
+    mAnnotationInfo = aAnnotationInfo;
+
+    if (aObject instanceof Method) {
+      if (Modifier.isNative(aObject.getModifiers())) {
+        mEntityType = ENTITY_TYPE.NATIVE;
+      } else {
+        mEntityType = ENTITY_TYPE.METHOD;
+      }
+    } else if (aObject instanceof Field) {
+      mEntityType = ENTITY_TYPE.FIELD;
+    } else {
+      mEntityType = ENTITY_TYPE.CONSTRUCTOR;
+    }
+  }
+
+  public Method getMethod() {
+    if (mEntityType != ENTITY_TYPE.METHOD && mEntityType != ENTITY_TYPE.NATIVE) {
+      throw new UnsupportedOperationException("Attempt to cast to unsupported member type.");
+    }
+    return (Method) mMember;
+  }
+
+  public Field getField() {
+    if (mEntityType != ENTITY_TYPE.FIELD) {
+      throw new UnsupportedOperationException("Attempt to cast to unsupported member type.");
+    }
+    return (Field) mMember;
+  }
+
+  public Constructor<?> getConstructor() {
+    if (mEntityType != ENTITY_TYPE.CONSTRUCTOR) {
+      throw new UnsupportedOperationException("Attempt to cast to unsupported member type.");
+    }
+    return (Constructor<?>) mMember;
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/ClassWithOptions.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/ClassWithOptions.java
new file mode 100644
index 0000000000..d1e4e6cfe0
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/ClassWithOptions.java
@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.classloader;
+
+import org.mozilla.gecko.annotationProcessors.utils.GeneratableElementIterator;
+
+public class ClassWithOptions {
+  public final Class<?> wrappedClass;
+  public final String generatedName;
+  public final String ifdef;
+
+  public ClassWithOptions(Class<?> someClass, String name, String ifdef) {
+    wrappedClass = someClass;
+    generatedName = name;
+    this.ifdef = ifdef;
+  }
+
+  public boolean hasGenerated() {
+    final GeneratableElementIterator methodIterator = new GeneratableElementIterator(this);
+
+    if (methodIterator.hasNext()) {
+      return true;
+    }
+
+    final ClassWithOptions[] innerClasses = methodIterator.getInnerClasses();
+    for (ClassWithOptions innerClass : innerClasses) {
+      if (innerClass.hasGenerated()) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/IterableJarLoadingURLClassLoader.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/IterableJarLoadingURLClassLoader.java
new file mode 100644
index 0000000000..50200ef3ec
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/IterableJarLoadingURLClassLoader.java
@@ -0,0 +1,76 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.classloader;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+/**
+ * A classloader which can be initialised with a list of jar files and which can provide an iterator
+ * over the top level classes in the jar files it was initialised with. classNames is kept sorted to
+ * ensure iteration order is consistent across program invocations. Otherwise, we'd forever be
+ * reporting the outdatedness of the generated code as we permute its contents.
+ */
+public class IterableJarLoadingURLClassLoader extends URLClassLoader {
+  LinkedList<String> classNames = new LinkedList<String>();
+
+  /**
+   * Create an instance and return its iterator. Provides an iterator over the classes in the jar
+   * files provided as arguments. Inner classes are not supported.
+   *
+   * @param args A list of jar file names an iterator over the classes of which is desired.
+   * @return An iterator over the top level classes in the jar files provided, in arbitrary order.
+   */
+  public static Iterator<ClassWithOptions> getIteratorOverJars(String[] args) {
+    URL[] urlArray = new URL[args.length];
+    LinkedList<String> aClassNames = new LinkedList<String>();
+
+    for (int i = 0; i < args.length; i++) {
+      try {
+        urlArray[i] = (new File(args[i])).toURI().toURL();
+
+        Enumeration<JarEntry> entries = new JarFile(args[i]).entries();
+        while (entries.hasMoreElements()) {
+          JarEntry e = entries.nextElement();
+          String fName = e.getName();
+          if (!fName.endsWith(".class")) {
+            continue;
+          }
+          final String className = fName.substring(0, fName.length() - 6).replace('/', '.');
+
+          aClassNames.add(className);
+        }
+      } catch (IOException e) {
+        System.err.println("Error loading jar file \"" + args[i] + '"');
+        e.printStackTrace(System.err);
+      }
+    }
+    Collections.sort(aClassNames);
+    return new JarClassIterator(new IterableJarLoadingURLClassLoader(urlArray, aClassNames));
+  }
+
+  /**
+   * Constructs a classloader capable of loading all classes given as URLs in urls. Used by static
+   * method above.
+   *
+   * @param urls URLs for all classes the new instance shall be capable of loading.
+   * @param aClassNames A list of names of the classes this instance shall be capable of loading.
+   */
+  protected IterableJarLoadingURLClassLoader(
+      URL[] urls,
+      LinkedList<String>
+          aClassNames) { // Array to populate with URLs for each class in the given jars.
+    super(urls);
+    classNames = aClassNames;
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/JarClassIterator.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/JarClassIterator.java
new file mode 100644
index 0000000000..f93667be8d
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/classloader/JarClassIterator.java
@@ -0,0 +1,105 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.classloader;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+
+/**
+ * Class for iterating over an IterableJarLoadingURLClassLoader's classes.
+ *
+ * <p>This class is not thread safe: use it only from a single thread.
+ */
+public class JarClassIterator implements Iterator<ClassWithOptions> {
+  private IterableJarLoadingURLClassLoader mTarget;
+  private Iterator<String> mTargetClassListIterator;
+
+  private ClassWithOptions lookAhead;
+
+  public JarClassIterator(IterableJarLoadingURLClassLoader aTarget) {
+    mTarget = aTarget;
+    mTargetClassListIterator = aTarget.classNames.iterator();
+  }
+
+  @Override
+  public boolean hasNext() {
+    return fillLookAheadIfPossible();
+  }
+
+  @Override
+  public ClassWithOptions next() {
+    if (!fillLookAheadIfPossible()) {
+      throw new IllegalStateException("Failed to look ahead in next()!");
+    }
+    ClassWithOptions next = lookAhead;
+    lookAhead = null;
+    return next;
+  }
+
+  private boolean fillLookAheadIfPossible() {
+    if (lookAhead != null) {
+      return true;
+    }
+
+    if (!mTargetClassListIterator.hasNext()) {
+      return false;
+    }
+
+    String className = mTargetClassListIterator.next();
+    try {
+      Class<?> ret = mTarget.loadClass(className);
+
+      // Incremental builds can leave stale classfiles in the jar. Such classfiles will cause
+      // an exception at this point. We can safely ignore these classes - they cannot possibly
+      // ever be loaded as they conflict with their parent class and will be killed by
+      // Proguard later on anyway.
+      final Class<?> enclosingClass;
+      try {
+        enclosingClass = ret.getEnclosingClass();
+      } catch (IncompatibleClassChangeError e) {
+        return fillLookAheadIfPossible();
+      }
+
+      if (enclosingClass != null) {
+        // Anonymous inner class - unsupported.
+        // Or named inner class, which will be processed when we process the outer class.
+        return fillLookAheadIfPossible();
+      }
+
+      String ifdef = "";
+      for (final Annotation annotation : ret.getDeclaredAnnotations()) {
+        Class<? extends Annotation> annotationType = annotation.annotationType();
+        if (!annotationType.getName().equals("org.mozilla.gecko.annotation.BuildFlag")) {
+          continue;
+        }
+
+        try {
+          final Method valueMethod = annotationType.getDeclaredMethod("value");
+          valueMethod.setAccessible(true);
+          ifdef = (String) valueMethod.invoke(annotation);
+          break;
+        } catch (final Exception e) {
+          System.err.println("Unable to read BuildFlag annotation.");
+          e.printStackTrace(System.err);
+          System.exit(1);
+        }
+      }
+
+      lookAhead = new ClassWithOptions(ret, ret.getSimpleName(), ifdef);
+      return true;
+    } catch (ClassNotFoundException e) {
+      System.err.println("Unable to enumerate class: " + className + ". Corrupted jar file?");
+      e.printStackTrace();
+      System.exit(2);
+    }
+    return false;
+  }
+
+  @Override
+  public void remove() {
+    throw new UnsupportedOperationException("Removal of classes from iterator not supported.");
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/AlphabeticAnnotatableEntityComparator.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/AlphabeticAnnotatableEntityComparator.java
new file mode 100644
index 0000000000..47d8b82fba
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/AlphabeticAnnotatableEntityComparator.java
@@ -0,0 +1,81 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.utils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.util.Comparator;
+
+public class AlphabeticAnnotatableEntityComparator<T extends Member> implements Comparator<T> {
+  @Override
+  public int compare(T aLhs, T aRhs) {
+    // Constructors, Methods, Fields.
+    boolean lIsConstructor = aLhs instanceof Constructor;
+    boolean rIsConstructor = aRhs instanceof Constructor;
+    boolean lIsMethod = aLhs instanceof Method;
+    boolean rIsField = aRhs instanceof Field;
+
+    if (lIsConstructor) {
+      if (!rIsConstructor) {
+        return -1;
+      }
+    } else if (lIsMethod) {
+      if (rIsConstructor) {
+        return 1;
+      } else if (rIsField) {
+        return -1;
+      }
+    } else {
+      if (!rIsField) {
+        return 1;
+      }
+    }
+
+    // Verify these objects are the same type and cast them.
+    if (aLhs instanceof Method) {
+      return compare((Method) aLhs, (Method) aRhs);
+    } else if (aLhs instanceof Field) {
+      return compare((Field) aLhs, (Field) aRhs);
+    } else {
+      return compare((Constructor) aLhs, (Constructor) aRhs);
+    }
+  }
+
+  // Alas, the type system fails us.
+  private static int compare(Method aLhs, Method aRhs) {
+    // Initially, attempt to differentiate the methods be name alone..
+    String lName = aLhs.getName();
+    String rName = aRhs.getName();
+
+    int ret = lName.compareTo(rName);
+    if (ret != 0) {
+      return ret;
+    }
+
+    // The names were the same, so we need to compare signatures to find their uniqueness..
+    lName = Utils.getSignature(aLhs);
+    rName = Utils.getSignature(aRhs);
+
+    return lName.compareTo(rName);
+  }
+
+  private static int compare(Constructor<?> aLhs, Constructor<?> aRhs) {
+    // The names will be the same, so we need to compare signatures to find their uniqueness..
+    String lName = Utils.getSignature(aLhs);
+    String rName = Utils.getSignature(aRhs);
+
+    return lName.compareTo(rName);
+  }
+
+  private static int compare(Field aLhs, Field aRhs) {
+    // Compare field names..
+    String lName = aLhs.getName();
+    String rName = aRhs.getName();
+
+    return lName.compareTo(rName);
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/GeneratableElementIterator.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/GeneratableElementIterator.java
new file mode 100644
index 0000000000..0ef25cab52
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/GeneratableElementIterator.java
@@ -0,0 +1,291 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.utils;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Iterator;
+import org.mozilla.gecko.annotationProcessors.AnnotationInfo;
+import org.mozilla.gecko.annotationProcessors.classloader.AnnotatableEntity;
+import org.mozilla.gecko.annotationProcessors.classloader.ClassWithOptions;
+
+/**
+ * Iterator over the methods in a given method list which have the WrappedJNIMethod annotation.
+ * Returns an object containing both the annotation (Which may contain interesting parameters) and
+ * the argument.
+ */
+public class GeneratableElementIterator implements Iterator<AnnotatableEntity> {
+  private final ClassWithOptions mClass;
+  private final Member[] mObjects;
+  private AnnotatableEntity mNextReturnValue;
+  private int mElementIndex;
+  private AnnotationInfo mClassInfo;
+
+  private boolean mIterateEveryEntry;
+  private boolean mIterateEnumValues;
+  private boolean mSkipCurrentEntry;
+
+  public GeneratableElementIterator(ClassWithOptions annotatedClass) {
+    mClass = annotatedClass;
+
+    final Class<?> aClass = annotatedClass.wrappedClass;
+    // Get all the elements of this class as AccessibleObjects.
+    Member[] aMethods = aClass.getDeclaredMethods();
+    Member[] aFields = aClass.getDeclaredFields();
+    Member[] aCtors = aClass.getDeclaredConstructors();
+
+    // Shove them all into one buffer.
+    Member[] objs = new Member[aMethods.length + aFields.length + aCtors.length];
+
+    int offset = 0;
+    System.arraycopy(aMethods, 0, objs, 0, aMethods.length);
+    offset += aMethods.length;
+    System.arraycopy(aFields, 0, objs, offset, aFields.length);
+    offset += aFields.length;
+    System.arraycopy(aCtors, 0, objs, offset, aCtors.length);
+
+    // Sort the elements to ensure determinism.
+    Arrays.sort(objs, new AlphabeticAnnotatableEntityComparator<Member>());
+    mObjects = objs;
+
+    // Check for "Wrap ALL the things" flag.
+    for (Annotation annotation : aClass.getDeclaredAnnotations()) {
+      mClassInfo = buildAnnotationInfo(aClass, annotation);
+      if (mClassInfo != null) {
+        if (aClass.isEnum()) {
+          // We treat "Wrap ALL the things" differently for enums. See the javadoc for
+          // isAnnotatedEnumField for more information.
+          mIterateEnumValues = true;
+        } else {
+          mIterateEveryEntry = true;
+        }
+        break;
+      }
+    }
+
+    if (mSkipCurrentEntry) {
+      throw new IllegalArgumentException("Cannot skip entire class");
+    }
+
+    findNextValue();
+  }
+
+  private Class<?>[] getFilteredInnerClasses() {
+    // Go through all inner classes and see which ones we want to generate.
+    final Class<?>[] candidates = mClass.wrappedClass.getDeclaredClasses();
+    int count = 0;
+
+    for (int i = 0; i < candidates.length; ++i) {
+      final GeneratableElementIterator testIterator =
+          new GeneratableElementIterator(new ClassWithOptions(candidates[i], null, /* ifdef */ ""));
+      if (testIterator.hasNext() || testIterator.getFilteredInnerClasses() != null) {
+        count++;
+        continue;
+      }
+      // Clear out ones that don't match.
+      candidates[i] = null;
+    }
+    return count > 0 ? candidates : null;
+  }
+
+  public ClassWithOptions[] getInnerClasses() {
+    final Class<?>[] candidates = getFilteredInnerClasses();
+    if (candidates == null) {
+      return new ClassWithOptions[0];
+    }
+
+    int count = 0;
+    for (Class<?> candidate : candidates) {
+      if (candidate != null) {
+        count++;
+      }
+    }
+
+    final ClassWithOptions[] ret = new ClassWithOptions[count];
+    count = 0;
+    for (Class<?> candidate : candidates) {
+      if (candidate != null) {
+        ret[count++] =
+            new ClassWithOptions(
+                candidate, mClass.generatedName + "::" + candidate.getSimpleName(), /* ifdef */ "");
+      }
+    }
+    assert ret.length == count;
+
+    Arrays.sort(
+        ret,
+        new Comparator<ClassWithOptions>() {
+          @Override
+          public int compare(ClassWithOptions lhs, ClassWithOptions rhs) {
+            return lhs.generatedName.compareTo(rhs.generatedName);
+          }
+        });
+    return ret;
+  }
+
+  private AnnotationInfo buildAnnotationInfo(AnnotatedElement element, Annotation annotation) {
+    Class<? extends Annotation> annotationType = annotation.annotationType();
+    final String annotationTypeName = annotationType.getName();
+    if (!annotationTypeName.equals("org.mozilla.gecko.annotation.WrapForJNI")) {
+      return null;
+    }
+
+    String stubName = null;
+    AnnotationInfo.ExceptionMode exceptionMode = null;
+    AnnotationInfo.CallingThread callingThread = null;
+    AnnotationInfo.DispatchTarget dispatchTarget = null;
+    boolean noLiteral = false;
+
+    try {
+      final Method skipMethod = annotationType.getDeclaredMethod("skip");
+      skipMethod.setAccessible(true);
+      if ((Boolean) skipMethod.invoke(annotation)) {
+        mSkipCurrentEntry = true;
+        return null;
+      }
+
+      // Determine the explicitly-given name of the stub to generate, if any.
+      final Method stubNameMethod = annotationType.getDeclaredMethod("stubName");
+      stubNameMethod.setAccessible(true);
+      stubName = (String) stubNameMethod.invoke(annotation);
+
+      final Method exceptionModeMethod = annotationType.getDeclaredMethod("exceptionMode");
+      exceptionModeMethod.setAccessible(true);
+      exceptionMode =
+          Utils.getEnumValue(
+              AnnotationInfo.ExceptionMode.class, (String) exceptionModeMethod.invoke(annotation));
+
+      final Method calledFromMethod = annotationType.getDeclaredMethod("calledFrom");
+      calledFromMethod.setAccessible(true);
+      callingThread =
+          Utils.getEnumValue(
+              AnnotationInfo.CallingThread.class, (String) calledFromMethod.invoke(annotation));
+
+      final Method dispatchToMethod = annotationType.getDeclaredMethod("dispatchTo");
+      dispatchToMethod.setAccessible(true);
+      dispatchTarget =
+          Utils.getEnumValue(
+              AnnotationInfo.DispatchTarget.class, (String) dispatchToMethod.invoke(annotation));
+
+      final Method noLiteralMethod = annotationType.getDeclaredMethod("noLiteral");
+      noLiteralMethod.setAccessible(true);
+      noLiteral = (Boolean) noLiteralMethod.invoke(annotation);
+
+    } catch (NoSuchMethodException e) {
+      System.err.println(
+          "Unable to find expected field on WrapForJNI annotation. Did the signature change?");
+      e.printStackTrace(System.err);
+      System.exit(3);
+    } catch (IllegalAccessException e) {
+      System.err.println(
+          "IllegalAccessException reading fields on WrapForJNI annotation. Seems the semantics of Reflection have changed...");
+      e.printStackTrace(System.err);
+      System.exit(4);
+    } catch (InvocationTargetException e) {
+      System.err.println(
+          "InvocationTargetException reading fields on WrapForJNI annotation. This really shouldn't happen.");
+      e.printStackTrace(System.err);
+      System.exit(5);
+    }
+
+    // If the method name was not explicitly given in the annotation generate one...
+    if (stubName.isEmpty()) {
+      stubName = Utils.getNativeName(element);
+    }
+
+    return new AnnotationInfo(stubName, exceptionMode, callingThread, dispatchTarget, noLiteral);
+  }
+
+  /**
+   * Find and cache the next appropriately annotated method, plus the annotation parameter, if one
+   * exists. Otherwise cache null, so hasNext returns false.
+   */
+  private void findNextValue() {
+    while (mElementIndex < mObjects.length) {
+      Member candidateElement = mObjects[mElementIndex];
+      mElementIndex++;
+      for (Annotation annotation : ((AnnotatedElement) candidateElement).getDeclaredAnnotations()) {
+        AnnotationInfo info = buildAnnotationInfo((AnnotatedElement) candidateElement, annotation);
+        if (info != null) {
+          mNextReturnValue = new AnnotatableEntity(candidateElement, info);
+          return;
+        }
+      }
+
+      if (mSkipCurrentEntry) {
+        mSkipCurrentEntry = false;
+        continue;
+      }
+
+      // If no annotation found, we might be expected to generate anyway
+      // using default arguments, thanks to the "Generate everything" annotation.
+      if (mIterateEveryEntry || isAnnotatedEnumField(candidateElement)) {
+        AnnotationInfo annotationInfo =
+            new AnnotationInfo(
+                Utils.getNativeName(candidateElement),
+                mClassInfo.exceptionMode,
+                mClassInfo.callingThread,
+                mClassInfo.dispatchTarget,
+                mClassInfo.noLiteral);
+        mNextReturnValue = new AnnotatableEntity(candidateElement, annotationInfo);
+        return;
+      }
+    }
+    mNextReturnValue = null;
+  }
+
+  /**
+   * For enums that are annotated in their entirety, we typically only need to generate the
+   * enumerated values, but not other members. This method determines whether the given member is
+   * likely to be one of the enumerated values: We look for public, static, final fields that share
+   * the same class as the declaring enum's class.
+   *
+   * <p>Note that any additional members that should be wrapped may be explicitly annotated on a
+   * case-by-case basis.
+   */
+  private boolean isAnnotatedEnumField(final Member member) {
+    if (!mIterateEnumValues) {
+      return false;
+    }
+
+    if (!Utils.isPublic(member)
+        || !Utils.isStatic(member)
+        || !Utils.isFinal(member)
+        || !(member instanceof Field)) {
+      return false;
+    }
+
+    final Class<?> enumClass = mClass.wrappedClass;
+
+    final Field field = (Field) member;
+    final Class<?> fieldClass = field.getType();
+
+    return enumClass.equals(fieldClass);
+  }
+
+  @Override
+  public boolean hasNext() {
+    return mNextReturnValue != null;
+  }
+
+  @Override
+  public AnnotatableEntity next() {
+    AnnotatableEntity ret = mNextReturnValue;
+    findNextValue();
+    return ret;
+  }
+
+  @Override
+  public void remove() {
+    throw new UnsupportedOperationException(
+        "Removal of methods from GeneratableElementIterator not supported.");
+  }
+}
diff --git a/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/Utils.java b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/Utils.java
new file mode 100644
index 0000000000..3ed9546223
--- /dev/null
+++ b/mobile/android/annotations/src/main/java/org/mozilla/gecko/annotationProcessors/utils/Utils.java
@@ -0,0 +1,480 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.gecko.annotationProcessors.utils;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Locale;
+import org.mozilla.gecko.annotationProcessors.AnnotationInfo;
+
+/** A collection of utility methods used by CodeGenerator. Largely used for translating types. */
+public class Utils {
+
+  // A collection of lookup tables to simplify the functions to follow...
+  private static final HashMap<String, String> NATIVE_TYPES = new HashMap<String, String>();
+
+  static {
+    NATIVE_TYPES.put("void", "void");
+    NATIVE_TYPES.put("boolean", "bool");
+    NATIVE_TYPES.put("byte", "int8_t");
+    NATIVE_TYPES.put("char", "char16_t");
+    NATIVE_TYPES.put("short", "int16_t");
+    NATIVE_TYPES.put("int", "int32_t");
+    NATIVE_TYPES.put("long", "int64_t");
+    NATIVE_TYPES.put("float", "float");
+    NATIVE_TYPES.put("double", "double");
+  }
+
+  private static final HashMap<String, String> NATIVE_ARRAY_TYPES = new HashMap<String, String>();
+
+  static {
+    NATIVE_ARRAY_TYPES.put("boolean", "mozilla::jni::BooleanArray");
+    NATIVE_ARRAY_TYPES.put("byte", "mozilla::jni::ByteArray");
+    NATIVE_ARRAY_TYPES.put("char", "mozilla::jni::CharArray");
+    NATIVE_ARRAY_TYPES.put("short", "mozilla::jni::ShortArray");
+    NATIVE_ARRAY_TYPES.put("int", "mozilla::jni::IntArray");
+    NATIVE_ARRAY_TYPES.put("long", "mozilla::jni::LongArray");
+    NATIVE_ARRAY_TYPES.put("float", "mozilla::jni::FloatArray");
+    NATIVE_ARRAY_TYPES.put("double", "mozilla::jni::DoubleArray");
+  }
+
+  private static final HashMap<String, String> CLASS_DESCRIPTORS = new HashMap<String, String>();
+
+  static {
+    CLASS_DESCRIPTORS.put("void", "V");
+    CLASS_DESCRIPTORS.put("boolean", "Z");
+    CLASS_DESCRIPTORS.put("byte", "B");
+    CLASS_DESCRIPTORS.put("char", "C");
+    CLASS_DESCRIPTORS.put("short", "S");
+    CLASS_DESCRIPTORS.put("int", "I");
+    CLASS_DESCRIPTORS.put("long", "J");
+    CLASS_DESCRIPTORS.put("float", "F");
+    CLASS_DESCRIPTORS.put("double", "D");
+  }
+
+  private static boolean isMozClass(final Class<?> type) {
+    return type.getName().startsWith("org.mozilla.");
+  }
+
+  private static boolean useObjectForType(final Class<?> type, final boolean isHint) {
+    // Essentially we want to know whether we can use generated wrappers or not:
+    // If |type| is not ours, then it most likely doesn't have generated C++ wrappers.
+    // Furthermore, we skip interfaces as we generally do not wrap those.
+    return !isHint || type.equals(Object.class) || !isMozClass(type) || type.isInterface();
+  }
+
+  /**
+   * Returns the simplified name of a class that includes any outer classes but excludes
+   * package/namespace qualifiers.
+   *
+   * @param genScope The current scope of the class containing the current declaration. @Param type
+   *     The class whose simplified name is to be generated. @Param connector String to be used for
+   *     concatenating scopes.
+   * @return String containing the result
+   */
+  private static String getSimplifiedClassName(
+      final Class<?> genScope, final Class<?> type, final String connector) {
+    final ArrayList<String> names = new ArrayList<>();
+
+    // Starting with |type|, walk up our enclosing classes until we either reach genScope or we
+    // have reached the outermost scope. We save them to a list because we need to reverse them
+    // during output.
+    Class<?> c = type;
+    do {
+      names.add(c.getSimpleName());
+      c = c.getEnclosingClass();
+    } while (c != null && (genScope == null || !genScope.equals(c)));
+
+    // Walk through names in reverse order, joining them using |connector|
+    final StringBuilder builder = new StringBuilder();
+    for (int i = names.size() - 1; i >= 0; --i) {
+      builder.append(names.get(i));
+      if (i > 0) {
+        builder.append(connector);
+      }
+    }
+
+    return builder.toString();
+  }
+
+  /**
+   * Returns the simplified name of a Java class that includes any outer classes but excludes
+   * package qualifiers. Used for Java signature hints.
+   *
+   * @param genScope The current scope of the class containing the current declaration. @Param type
+   *     The class whose simplified name is to be generated.
+   * @return String containing the result
+   */
+  public static String getSimplifiedJavaClassName(final Class<?> genScope, final Class<?> type) {
+    return getSimplifiedClassName(genScope, type, ".");
+  }
+
+  /** Returns the fully-qualified name of the native class wrapper for the given type. */
+  public static String getWrappedNativeClassName(final Class<?> type) {
+    return "mozilla::java::" + getSimplifiedClassName(null, type, "::");
+  }
+
+  /**
+   * Get the C++ parameter type corresponding to the provided type parameter.
+   *
+   * @param type Class to determine the corresponding JNI type for.
+   * @return C++ type as a String
+   */
+  public static String getNativeParameterType(Class<?> type, AnnotationInfo info) {
+    return getNativeParameterType(type, info, false);
+  }
+
+  /**
+   * Get the C++ hint type corresponding to the provided type parameter. The returned type may be
+   * more specific than the type returned by getNativeParameterType, as this method is used for
+   * generating comments instead of machine-readable code.
+   *
+   * @param type Class to determine the corresponding JNI type for.
+   * @return C++ type as a String
+   */
+  public static String getNativeParameterTypeHint(Class<?> type, AnnotationInfo info) {
+    return getNativeParameterType(type, info, true);
+  }
+
+  private static String getNativeParameterType(
+      final Class<?> type, final AnnotationInfo info, final boolean isHint) {
+    final String name = type.getName().replace('.', '/');
+
+    String value = NATIVE_TYPES.get(name);
+    if (value != null) {
+      return value;
+    }
+
+    if (type.isArray()) {
+      final String compName = type.getComponentType().getName();
+      value = NATIVE_ARRAY_TYPES.get(compName);
+      if (value != null) {
+        return value + "::Param";
+      }
+      return "mozilla::jni::ObjectArray::Param";
+    }
+
+    if (type.equals(String.class) || type.equals(CharSequence.class)) {
+      return "mozilla::jni::String::Param";
+    }
+
+    if (type.equals(Class.class)) {
+      // You're doing reflection on Java objects from inside C, returning Class objects
+      // to C, generating the corresponding code using this Java program. Really?!
+      return "mozilla::jni::Class::Param";
+    }
+
+    if (type.equals(Throwable.class)) {
+      return "mozilla::jni::Throwable::Param";
+    }
+
+    if (type.equals(ByteBuffer.class)) {
+      return "mozilla::jni::ByteBuffer::Param";
+    }
+
+    if (useObjectForType(type, isHint)) {
+      return "mozilla::jni::Object::Param";
+    }
+
+    return getWrappedNativeClassName(type) + "::Param";
+  }
+
+  /**
+   * Get the C++ return type corresponding to the provided type parameter.
+   *
+   * @param type Class to determine the corresponding JNI type for.
+   * @return C++ type as a String
+   */
+  public static String getNativeReturnType(Class<?> type, AnnotationInfo info) {
+    return getNativeReturnType(type, info, false);
+  }
+
+  /**
+   * Get the C++ hint return type corresponding to the provided type parameter. The returned type
+   * may be more specific than the type returned by getNativeReturnType, as this method is used for
+   * generating comments instead of machine-readable code.
+   *
+   * @param type Class to determine the corresponding JNI type for.
+   * @return C++ type as a String
+   */
+  public static String getNativeReturnTypeHint(Class<?> type, AnnotationInfo info) {
+    return getNativeReturnType(type, info, true);
+  }
+
+  private static String getNativeReturnType(
+      final Class<?> type, final AnnotationInfo info, final boolean isHint) {
+    final String name = type.getName().replace('.', '/');
+
+    String value = NATIVE_TYPES.get(name);
+    if (value != null) {
+      return value;
+    }
+
+    if (type.isArray()) {
+      final String compName = type.getComponentType().getName();
+      value = NATIVE_ARRAY_TYPES.get(compName);
+      if (value != null) {
+        return value + "::LocalRef";
+      }
+      return "mozilla::jni::ObjectArray::LocalRef";
+    }
+
+    if (type.equals(String.class)) {
+      return "mozilla::jni::String::LocalRef";
+    }
+
+    if (type.equals(Class.class)) {
+      // You're doing reflection on Java objects from inside C, returning Class objects
+      // to C, generating the corresponding code using this Java program. Really?!
+      return "mozilla::jni::Class::LocalRef";
+    }
+
+    if (type.equals(Throwable.class)) {
+      return "mozilla::jni::Throwable::LocalRef";
+    }
+
+    if (type.equals(ByteBuffer.class)) {
+      return "mozilla::jni::ByteBuffer::LocalRef";
+    }
+
+    if (useObjectForType(type, isHint)) {
+      return "mozilla::jni::Object::LocalRef";
+    }
+
+    return getWrappedNativeClassName(type) + "::LocalRef";
+  }
+
+  /**
+   * Get the JNI class descriptor corresponding to the provided type parameter.
+   *
+   * @param type Class to determine the corresponding JNI descriptor for.
+   * @return Class descripor as a String
+   */
+  public static String getClassDescriptor(Class<?> type) {
+    final String name = type.getName().replace('.', '/');
+
+    final String classDescriptor = CLASS_DESCRIPTORS.get(name);
+    if (classDescriptor != null) {
+      return classDescriptor;
+    }
+
+    if (type.isArray()) {
+      // Array names are already in class descriptor form.
+      return name;
+    }
+
+    return "L" + name + ';';
+  }
+
+  /**
+   * Get the JNI signaure for a member.
+   *
+   * @param member Member to get the signature for.
+   * @return JNI signature as a string
+   */
+  public static String getSignature(Member member) {
+    return member instanceof Field
+        ? getSignature((Field) member)
+        : member instanceof Method
+            ? getSignature((Method) member)
+            : getSignature((Constructor<?>) member);
+  }
+
+  /**
+   * Get the JNI signaure for a field.
+   *
+   * @param member Field to get the signature for.
+   * @return JNI signature as a string
+   */
+  public static String getSignature(Field member) {
+    return getClassDescriptor(member.getType());
+  }
+
+  private static String getSignature(Class<?>[] args, Class<?> ret) {
+    final StringBuilder sig = new StringBuilder("(");
+    for (int i = 0; i < args.length; i++) {
+      sig.append(getClassDescriptor(args[i]));
+    }
+    return sig.append(')').append(getClassDescriptor(ret)).toString();
+  }
+
+  /**
+   * Get the JNI signaure for a method.
+   *
+   * @param member Method to get the signature for.
+   * @return JNI signature as a string
+   */
+  public static String getSignature(Method member) {
+    return getSignature(member.getParameterTypes(), member.getReturnType());
+  }
+
+  /**
+   * Get the JNI signaure for a constructor.
+   *
+   * @param member Constructor to get the signature for.
+   * @return JNI signature as a string
+   */
+  public static String getSignature(Constructor<?> member) {
+    return getSignature(member.getParameterTypes(), void.class);
+  }
+
+  /**
+   * Get the C++ name for a member.
+   *
+   * @param member Member to get the name for.
+   * @return JNI name as a string
+   */
+  public static String getNativeName(Member member) {
+    final String name = getMemberName(member);
+    return name.substring(0, 1).toUpperCase(Locale.ROOT) + name.substring(1);
+  }
+
+  /**
+   * Get the C++ name for a member.
+   *
+   * @param member Member to get the name for.
+   * @return JNI name as a string
+   */
+  public static String getNativeName(Class<?> clz) {
+    final String name = clz.getName();
+    return name.substring(0, 1).toUpperCase(Locale.ROOT) + name.substring(1);
+  }
+
+  /**
+   * Get the C++ name for a member.
+   *
+   * @param member Member to get the name for.
+   * @return JNI name as a string
+   */
+  public static String getNativeName(AnnotatedElement element) {
+    if (element instanceof Class<?>) {
+      return getNativeName((Class<?>) element);
+    } else if (element instanceof Member) {
+      return getNativeName((Member) element);
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Get the JNI name for a member.
+   *
+   * @param member Member to get the name for.
+   * @return JNI name as a string
+   */
+  public static String getMemberName(Member member) {
+    if (member instanceof Constructor) {
+      return "<init>";
+    }
+    return member.getName();
+  }
+
+  public static String getUnqualifiedName(String name) {
+    return name.substring(name.lastIndexOf(':') + 1);
+  }
+
+  /**
+   * Determine if a member is declared static.
+   *
+   * @param member The Member to check.
+   * @return true if the member is declared static, false otherwise.
+   */
+  public static boolean isStatic(final Member member) {
+    return Modifier.isStatic(member.getModifiers());
+  }
+
+  /**
+   * Determine if a member is declared final.
+   *
+   * @param member The Member to check.
+   * @return true if the member is declared final, false otherwise.
+   */
+  public static boolean isFinal(final Member member) {
+    return Modifier.isFinal(member.getModifiers());
+  }
+
+  /**
+   * Determine if a member is declared public.
+   *
+   * @param member The Member to check.
+   * @return true if the member is declared public, false otherwise.
+   */
+  public static boolean isPublic(final Member member) {
+    return Modifier.isPublic(member.getModifiers());
+  }
+
+  /**
+   * Return an enum value with the given name.
+   *
+   * @param type Enum class type.
+   * @param name Enum value name.
+   * @return Enum value with the given name.
+   */
+  public static <T extends Enum<T>> T getEnumValue(Class<T> type, String name) {
+    try {
+      return Enum.valueOf(type, name.toUpperCase(Locale.ROOT));
+
+    } catch (IllegalArgumentException e) {
+      final Object[] values;
+      try {
+        values = (Object[]) type.getDeclaredMethod("values").invoke(null);
+      } catch (final NoSuchMethodException
+          | IllegalAccessException
+          | InvocationTargetException exception) {
+        throw new RuntimeException("Cannot access enum: " + type, exception);
+      }
+
+      StringBuilder names = new StringBuilder();
+
+      for (int i = 0; i < values.length; i++) {
+        if (i != 0) {
+          names.append(", ");
+        }
+        names.append(values[i].toString().toLowerCase(Locale.ROOT));
+      }
+
+      System.err.println("***");
+      System.err.println("*** Invalid value \"" + name + "\" for " + type.getSimpleName());
+      System.err.println("*** Specify one of " + names.toString());
+      System.err.println("***");
+      e.printStackTrace(System.err);
+      System.exit(1);
+      return null;
+    }
+  }
+
+  public static String getIfdefHeader(String ifdef) {
+    if (ifdef.isEmpty()) {
+      return "";
+    } else if (ifdef.startsWith("!")) {
+      return "#ifndef " + ifdef.substring(1) + "\n";
+    }
+    return "#ifdef " + ifdef + "\n";
+  }
+
+  public static String getIfdefFooter(String ifdef) {
+    if (ifdef.isEmpty()) {
+      return "";
+    }
+    return "#endif // " + ifdef + "\n";
+  }
+
+  public static boolean isJNIObject(Class<?> cls) {
+    for (; cls != null; cls = cls.getSuperclass()) {
+      if (cls.getName().equals("org.mozilla.gecko.mozglue.JNIObject")) {
+        return true;
+      }
+    }
+    return false;
+  }
+}