Additions to support crazy linker callbacks from the UI thread.

base/android/linker/linker_jni.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This is the Android-specific Chromium linker, a tiny shared library
 // implementing a custom dynamic linker that can be used to load the
 // real Chromium libraries (e.g. libcontentshell.so).
 
 // The main point of this linker is to be able to share the RELRO
 // section of libcontentshell.so (or equivalent) between the browser and
@@ skipping 122 matching lines @@
   *field_id = env->GetFieldID(clazz, field_name, field_sig);
   if (!*field_id) {
     LOG_ERROR("Could not find ID for field '%s'", field_name);
     return false;
   }
   LOG_INFO(
       "%s: Found ID %p for field '%s'", __FUNCTION__, *field_id, field_name);
   return true;
 }
 
+// Initialize a jmethodID corresponding to the static method of a given
+// |clazz|, with name |method_name| and signature |method_sig|.
+// |env| is the current JNI environment handle.
+// On success, return true and set |*method_id|.
+bool InitStaticMethodId(JNIEnv* env,
+                        jclass clazz,
+                        const char* method_name,
+                        const char* method_sig,
+                        jmethodID* method_id) {
+  *method_id = env->GetStaticMethodID(clazz, method_name, method_sig);
+  if (!*method_id) {
+    LOG_ERROR("Could not find ID for static method '%s'", method_name);
+    return false;
+  }
+  LOG_INFO("%s: Found ID %p for static method '%s'",
+           __FUNCTION__, *method_id, method_name);
+  return true;
+}
+
 // A class used to model the field IDs of the org.chromium.base.Linker
 // LibInfo inner class, used to communicate data with the Java side
 // of the linker.
 struct LibInfo_class {
   jfieldID load_address_id;
   jfieldID load_size_id;
   jfieldID relro_start_id;
   jfieldID relro_size_id;
   jfieldID relro_fd_id;
 
@@ skipping 122 matching lines @@
 
   // Release library object to keep it alive after the function returns.
   library.Release();
 
   s_lib_info_fields.SetLoadInfo(
       env, lib_info_obj, info.load_address, info.load_size);
   LOG_INFO("%s: Success loading library %s", __FUNCTION__, lib_basename);
   return true;
 }
 
+// Class to support simple callbacks from the Java side. Hold a pointer
+// to a function taking a single void* argument, and an argument value.
+struct callback_t {
+ public:
+  callback_t() : handler(NULL), opaque(NULL) { }
+
+  void (*handler)(void*);
+  void* opaque;
+};
+
+// Designated receiver function for callbacks from Java. Its name is known
+// to the Java side.
+// |env| is the current JNI environment handle and is ignored here.
+// |clazz| is the static class handle for org.chromium.base.Linker,
+// and is ignored here.
+// |arg| is a pointer to an allocated callback_t.
+void ReceiveCallbackFromMainThread(JNIEnv* env, jclass clazz, jlong arg) {
+  callback_t* callback = reinterpret_cast<callback_t*>(arg);
+
+  LOG_INFO("%s: Called back from java with handler %p, opaque %p",
+           __FUNCTION__, callback->handler, callback->opaque);
+
+  (*callback->handler)(callback->opaque);
+  delete callback;
+}
+
+// Class holding the Java class and method ID for the Java side Linker
+// PostCallbackOnMainThread method. Like crazy_context_t, there is
+// only one of these, requiring no locking.
+struct callback_refs_t {
+ public:
+  callback_refs_t() : clazz(NULL), method_id(NULL) { }
+
+  jclass clazz;
+  jmethodID method_id;
+};
+
+static callback_refs_t s_callback_refs;
+
+// Request a callback from Java. Constructs a new callback_t and calls
+// the Java side's PostCallbackOnMainThread, which will some time later
+// call back to our ReceiveCallbackFromMainThread.
+// |handler| is a handler function, taking a single void* argument.
+// |opaque| is the argument to supply to the handler when run in the callback.
+// Returns true if the callback request succeeded.
+static bool PostForLaterExecution(void (*handler)(void*), void *opaque) {

[bulach, 2014/04/15 13:58:14]

nit: s/void *opaque/void* opaque/

[simonb1, 2014/04/17 14:45:43]

Done.

+  crazy_context_t* context = GetCrazyContext();
+
+  JavaVM* vm;
+  int minimum_jni_version;
+  crazy_context_get_java_vm(context,
+                            reinterpret_cast<void**>(&vm),
+                            &minimum_jni_version);
+
+  // Do not reuse JNIEnv from JNI_OnLoad, but retrieve our own.
+  JNIEnv* env;
+  if (JNI_OK != vm->GetEnv(
+      reinterpret_cast<void**>(&env), minimum_jni_version)) {
+    LOG_ERROR("Could not create JNIEnv");
+    return false;
+  }
+
+  callback_t* callback = new callback_t();
+  callback->handler = handler;
+  callback->opaque = opaque;
+
+  LOG_INFO("%s: Calling back to java with handler %p, opaque %p",
+           __FUNCTION__, callback->handler, callback->opaque);
+
+  jlong arg = static_cast<jlong>(reinterpret_cast<intptr_t>(callback));
+  env->CallStaticVoidMethod(
+      s_callback_refs.clazz, s_callback_refs.method_id, arg);

[bulach, 2014/04/15 13:58:14]

need to clear any java exception (assuming it's safe to 'swallow' them since
there's a return value here):

if (env->ExceptionCheck() == JNI_FALSE)
  return true;
env->ExceptionDescribe();
env->ExceptionClear();
return false;

[simonb1, 2014/04/17 14:45:43]

Done.

+  return true;
+}
+
 jboolean CreateSharedRelro(JNIEnv* env,
                            jclass clazz,
                            jstring library_name,
                            jlong load_address,
                            jobject lib_info_obj) {
   String lib_name(env, library_name);
 
   LOG_INFO("%s: Called for %s", __FUNCTION__, lib_name.c_str());
 
   if (!IsValidAddress(load_address)) {
@@ skipping 89 matching lines @@
 
 const JNINativeMethod kNativeMethods[] = {
     {"nativeLoadLibrary",
      "("
      "Ljava/lang/String;"
      "J"
      "Lorg/chromium/base/library_loader/Linker$LibInfo;"
      ")"
      "Z",
      reinterpret_cast<void*>(&LoadLibrary)},
+    {"nativeReceiveCallbackFromMainThread",
+     "("
+     "J"
+     ")"
+     "V",
+     reinterpret_cast<void*>(&ReceiveCallbackFromMainThread)},
     {"nativeCreateSharedRelro",
      "("
      "Ljava/lang/String;"
      "J"
      "Lorg/chromium/base/library_loader/Linker$LibInfo;"
      ")"
      "Z",
      reinterpret_cast<void*>(&CreateSharedRelro)},
     {"nativeUseSharedRelro",
      "("
      "Ljava/lang/String;"
      "Lorg/chromium/base/library_loader/Linker$LibInfo;"
      ")"
      "Z",
      reinterpret_cast<void*>(&UseSharedRelro)},
     {"nativeCanUseSharedRelro",
      "("
      ")"
      "Z",
      reinterpret_cast<void*>(&CanUseSharedRelro)},
     {"nativeGetPageSize",
      "("
      ")"
      "J",
      reinterpret_cast<void*>(&GetPageSize)}, };
-
 }  // namespace
 
 // JNI_OnLoad() hook called when the linker library is loaded through
 // the regular System.LoadLibrary) API. This shall save the Java VM
 // handle and initialize LibInfo fields.
 jint JNI_OnLoad(JavaVM* vm, void* reserved) {
   LOG_INFO("%s: Entering", __FUNCTION__);
   // Get new JNIEnv
   JNIEnv* env;
   if (JNI_OK != vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_4)) {
     LOG_ERROR("Could not create JNIEnv");
     return -1;
   }
 
   // Register native methods.
   jclass linker_class;
-  if (!InitClassReference(
-           env, "org/chromium/base/library_loader/Linker", &linker_class))
+  if (!InitClassReference(env,
+                          "org/chromium/base/library_loader/Linker",
+                          &linker_class))
     return -1;
 
   LOG_INFO("%s: Registering native methods", __FUNCTION__);
   env->RegisterNatives(linker_class,
                        kNativeMethods,
                        sizeof(kNativeMethods) / sizeof(kNativeMethods[0]));
 
   // Find LibInfo field ids.
   LOG_INFO("%s: Caching field IDs", __FUNCTION__);
   if (!s_lib_info_fields.Init(env)) {
     return -1;
   }
 
   // Save JavaVM* handle into context.
   crazy_context_t* context = GetCrazyContext();
   crazy_context_set_java_vm(context, vm, JNI_VERSION_1_4);
 
+  // Resolve the Java side Linker callback method.
+  jmethodID method_id;
+  if (!InitStaticMethodId(env,
+                          linker_class,
+                          "PostCallbackOnMainThread",
+                          "(J)V",
+                          &method_id))
+    return -1;
+
+  // Save the callback class and method, and register the function that
+  // the crazy linker can call to post code for later execution.
+  s_callback_refs.clazz = linker_class;
+  s_callback_refs.method_id = method_id;
+  crazy_context_set_post_for_later_execution(context, &PostForLaterExecution);
+
   LOG_INFO("%s: Done", __FUNCTION__);
   return JNI_VERSION_1_4;
 }