Update from https://crrev.com/327068

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 110 matching lines @@
   *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;
 }
 
+// Initialize a jfieldID corresponding to the static field of a given |clazz|,
+// with name |field_name| and signature |field_sig|.
+// |env| is the current JNI environment handle.
+// On success, return true and set |*field_id|.
+bool InitStaticFieldId(JNIEnv* env,
+                       jclass clazz,
+                       const char* field_name,
+                       const char* field_sig,
+                       jfieldID* field_id) {
+  *field_id = env->GetStaticFieldID(clazz, field_name, field_sig);
+  if (!*field_id) {
+    LOG_ERROR("Could not find ID for static field '%s'", field_name);
+    return false;
+  }
+  LOG_INFO(
+      "%s: Found ID %p for static field '%s'",
+      __FUNCTION__, *field_id, field_name);
+  return true;
+}
+
+// Initialize a jint corresponding to the static integer field of a class
+// with class name |class_name| and field name |field_name|.
+// |env| is the current JNI environment handle.
+// On success, return true and set |*value|.
+bool InitStaticInt(JNIEnv* env,
+                   const char* class_name,
+                   const char* field_name,
+                   jint* value) {
+  jclass clazz;
+  if (!InitClassReference(env, class_name, &clazz))
+    return false;
+
+  jfieldID field_id;
+  if (!InitStaticFieldId(env, clazz, field_name, "I", &field_id))
+    return false;
+
+  *value = env->GetStaticIntField(clazz, field_id);
+  LOG_INFO(
+      "%s: Found value %d for class '%s', static field '%s'",
+      __FUNCTION__, *value, class_name, field_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 42 matching lines @@
                     size_t relro_size,
                     int relro_fd) {
     env->SetLongField(library_info_obj, relro_start_id, relro_start);
     env->SetLongField(library_info_obj, relro_size_id, relro_size);
     env->SetIntField(library_info_obj, relro_fd_id, relro_fd);
   }
 };
 
 static LibInfo_class s_lib_info_fields;
 
+// Retrieve the SDK build version and pass it into the crazy linker. This
+// needs to be done early in initialization, before any other crazy linker
+// code is run.
+// |env| is the current JNI environment handle.
+// On success, return true.
+bool InitSDKVersionInfo(JNIEnv* env) {
+  jint value = 0;
+  if (!InitStaticInt(env, "android/os/Build$VERSION", "SDK_INT", &value))
+    return false;
+
+  crazy_set_sdk_build_version(static_cast<int>(value));
+  LOG_INFO("%s: Set SDK build version to %d",
+           __FUNCTION__, static_cast<int>(value));
+
+  return true;
+}
+
 // The linker uses a single crazy_context_t object created on demand.
 // There is no need to protect this against concurrent access, locking
 // is already handled on the Java side.
 static crazy_context_t* s_crazy_context;
 
 crazy_context_t* GetCrazyContext() {
   if (!s_crazy_context) {
     // Create new context.
     s_crazy_context = crazy_context_create();
 
@@ skipping 548 matching lines @@
 // 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;
   }
 
+  // Initialize SDK version info.
+  LOG_INFO("%s: Retrieving SDK version info", __FUNCTION__);
+  if (!InitSDKVersionInfo(env))
+    return -1;
+
   // Register native methods.
   jclass 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,
@@ skipping 15 matching lines @@
   crazy_context_t* context = GetCrazyContext();
   crazy_context_set_java_vm(context, vm, JNI_VERSION_1_4);
 
   // Register the function that the crazy linker can call to post code
   // for later execution.
   crazy_context_set_callback_poster(context, &PostForLaterExecution, NULL);
 
   LOG_INFO("%s: Done", __FUNCTION__);
   return JNI_VERSION_1_4;
 }