Split JNI init so native library preloading dosn't cause native init.

base/android/library_loader/library_loader_hooks.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.
 
 #include "base/android/library_loader/library_loader_hooks.h"
 
 #include "base/android/command_line_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/library_loader/library_load_from_apk_status_codes.h"
 #include "base/android/library_loader/library_prefetcher.h"
 #include "base/at_exit.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "jni/LibraryLoader_jni.h"
 
 namespace base {
 namespace android {
 
 namespace {
 
 base::AtExitManager* g_at_exit_manager = NULL;
 const char* g_library_version_number = "";
 LibraryLoadedHook* g_registration_callback = NULL;
+NativeInitializationHook* g_native_initialization_hook = NULL;
 
 enum RendererHistogramCode {
   // Renderer load at fixed address success, fail, or not attempted.
   // Renderers do not attempt to load at at fixed address if on a
   // low-memory device on which browser load at fixed address has already
   // failed.
   LFA_SUCCESS = 0,
   LFA_BACKOFF_USED = 1,
   LFA_NOT_ATTEMPTED = 2,
 
@@ skipping 108 matching lines @@
 }
 
 static void RegisterLibraryPreloaderRendererHistogram(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     jint status) {
   g_library_preloader_renderer_histogram_code = status;
   g_library_preloader_renderer_histogram_code_registered = true;
 }
 
+void SetNativeInitializationHook(
+    NativeInitializationHook native_initialization_hook) {
+  g_native_initialization_hook = native_initialization_hook;
+}
+
 void RecordLibraryLoaderRendererHistograms() {
   RecordChromiumAndroidLinkerRendererHistogram();
   RecordLibraryPreloaderRendereHistogram();
 }
 
 void SetLibraryLoadedHook(LibraryLoadedHook* func) {
   g_registration_callback = func;
 }
 
 static void InitCommandLine(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     const JavaParamRef<jobjectArray>& init_command_line) {
   InitNativeCommandLineFromJavaArray(env, init_command_line);
 }
 
 static jboolean LibraryLoaded(JNIEnv* env,
                               const JavaParamRef<jobject>& jcaller) {
+  if (g_native_initialization_hook && !g_native_initialization_hook()) {
+    return false;
+  }
   if (g_registration_callback == NULL) {

[Torne, 2017/01/03 12:13:50]

g_registration_callback already appears to be the exact mechanism you're adding
here, though the variable name doesn't match the "SetLibraryLoadedHook" function
used to set it. Could we just use this instead (and rename the variable to
g_library_loaded_hook)?

The content layer Init() function already does nothing other than call
SetLibraryLoadedHook. It seems like the current Init function chain is an
unnecessary level of indirection that we could just remove and replace with
this, as a minimum.

[Tobias Sargeant, 2017/01/04 00:24:53]

I started doing this, and removing the callback chain means touching a lot of
test code. Would you consider leaving it as a follow-up CL so that we can get
multiprocess fixed with this one?

I also can't coalesce the two hooks because currently the
g_registration_callback is used to run something after all native library
initialization is done, from a point where it can't just do it as the last
thing.

     return true;
   }
   return g_registration_callback(env, NULL);
 }
 
 void LibraryLoaderExitHook() {
   if (g_at_exit_manager) {
     delete g_at_exit_manager;
     g_at_exit_manager = NULL;
   }
@@ skipping 29 matching lines @@
   return static_cast<LibraryProcessType>(
       Java_LibraryLoader_getLibraryProcessType(env));
 }
 
 void InitAtExitManager() {
   g_at_exit_manager = new base::AtExitManager();
 }
 
 }  // namespace android
 }  // namespace base