Sync fbjni to React Native

Reviewed By: mhorowitz

Differential Revision: D5086537

fbshipit-source-id: a95863113b3c63530a2550d29dfdc9626be86dc0

Author: javache

ReactAndroid/src/main/jni/first-party/fb/include/fb/Build.h

@@ -0,0 +1,26 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#pragma once
+
+#include <stdlib.h>
+
+#if defined(__ANDROID__)
+#  include <sys/system_properties.h>
+#endif
+
+namespace facebook {
+namespace build {
+
+struct Build {
+  static int getAndroidSdk() {
+    static auto android_sdk = ([] {
+       char sdk_version_str[PROP_VALUE_MAX];
+       __system_property_get("ro.build.version.sdk", sdk_version_str);
+       return atoi(sdk_version_str);
+    })();
+    return android_sdk;
+  }
+};
+
+} // build
+} // facebook

ReactAndroid/src/main/jni/first-party/fb/include/fb/Environment.h

@@ -17,6 +17,10 @@
 namespace facebook {
 namespace jni {
 
+namespace internal {
+  struct CacheEnvTag {};
+}
+
 // Keeps a thread-local reference to the current thread's JNIEnv.
 struct Environment {
   // May be null if this thread isn't attached to the JVM
@@ -70,7 +74,16 @@ class FBEXPORT ThreadScope {
   static void WithClassLoader(std::function<void()>&& runnable);
 
   static void OnLoad();
+
+  // This constructor is only used internally by fbjni.
+  ThreadScope(JNIEnv*, internal::CacheEnvTag);
  private:
+  friend struct Environment;
+  ThreadScope* previous_;
+  // If the JNIEnv* is set, it is guaranteed to be valid at least through the
+  // lifetime of this ThreadScope. The only case where that guarantee can be
+  // made is when there is a java frame in the stack below this.
+  JNIEnv* env_;
   bool attachedWithThisScope_;
 };
 }

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/Boxed.h

@@ -58,9 +58,12 @@ DEFINE_BOXED_PRIMITIVE(double, Double)
 
 #undef DEFINE_BOXED_PRIMITIVE
 
+struct JVoid : public jni::JavaClass<JVoid> {
+  static auto constexpr kJavaDescriptor = "Ljava/lang/Void;";
+};
+
 inline local_ref<jobject> autobox(alias_ref<jobject> val) {
   return make_local(val);
 }
 
 }}
-

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/CoreClasses-inl.h

@@ -177,7 +177,12 @@ inline void JClass::registerNatives(std::initializer_list<NativeMethod> methods)
 
 inline bool JClass::isAssignableFrom(alias_ref<JClass> other) const noexcept {
   const auto env = internal::getEnv();
-  const auto result = env->IsAssignableFrom(self(), other.get());
+  // Ths method has behavior compatible with the
+  // java.lang.Class#isAssignableFrom method.  The order of the
+  // arguments to the JNI IsAssignableFrom C function is "opposite"
+  // from what some might expect, which makes this code look a little
+  // odd, but it is correct.
+  const auto result = env->IsAssignableFrom(other.get(), self());
   return result;
 }
 
@@ -341,13 +346,6 @@ struct Convert<const char*> {
 };
 }
 
-// jthrowable //////////////////////////////////////////////////////////////////////////////////////
-
-inline local_ref<JThrowable> JThrowable::initCause(alias_ref<JThrowable> cause) {
-  static auto meth = javaClassStatic()->getMethod<javaobject(javaobject)>("initCause");
-  return meth(self(), cause.get());
-}
-
 // jtypeArray //////////////////////////////////////////////////////////////////////////////////////
 
 namespace detail {

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/CoreClasses.h

@@ -340,14 +340,6 @@ class FBEXPORT JString : public JavaClass<JString, JObject, jstring> {
 FBEXPORT local_ref<JString> make_jstring(const char* modifiedUtf8);
 FBEXPORT local_ref<JString> make_jstring(const std::string& modifiedUtf8);
 
-/// Wrapper to provide functionality to jthrowable references
-class FBEXPORT JThrowable : public JavaClass<JThrowable, JObject, jthrowable> {
- public:
-  static constexpr const char* kJavaDescriptor = "Ljava/lang/Throwable;";
-
-  local_ref<JThrowable> initCause(alias_ref<JThrowable> cause);
-};
-
 namespace detail {
 template<typename Target>
 class ElementProxy {
@@ -565,6 +557,24 @@ class PinnedPrimitiveArray {
    friend class JPrimitiveArray<typename jtype_traits<T>::array_type>;
 };
 
+struct JStackTraceElement : JavaClass<JStackTraceElement> {
+  static auto constexpr kJavaDescriptor = "Ljava/lang/StackTraceElement;";
+
+  static local_ref<javaobject> create(const std::string& declaringClass, const std::string& methodName, const std::string& file, int line);
+};
+
+/// Wrapper to provide functionality to jthrowable references
+class FBEXPORT JThrowable : public JavaClass<JThrowable, JObject, jthrowable> {
+ public:
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/Throwable;";
+
+  using JStackTrace = JArrayClass<JStackTraceElement::javaobject>;
+
+  local_ref<JThrowable> initCause(alias_ref<JThrowable> cause);
+  local_ref<JStackTrace> getStackTrace();
+  void setStackTrace(alias_ref<JArrayClass<JStackTraceElement::javaobject>>);
+};
+
 #pragma push_macro("PlainJniRefMap")
 #undef PlainJniRefMap
 #define PlainJniRefMap(rtype, jtype) \

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/Exceptions.h

@@ -32,6 +32,11 @@
 #include "References.h"
 #include "CoreClasses.h"
 
+#if defined(__ANDROID__) && defined(__ARM_ARCH_5TE__) && !defined(FBJNI_NO_EXCEPTION_PTR)
+// ARMv5 NDK does not support exception_ptr so we cannot use that when building for it.
+#define FBJNI_NO_EXCEPTION_PTR
+#endif
+
 namespace facebook {
 namespace jni {
 
@@ -108,9 +113,16 @@ template<typename... Args>
 }
 
 // Identifies any pending C++ exception and throws it as a Java exception. If the exception can't
-// be thrown, it aborts the program. This is a noexcept function at C++ level.
-FBEXPORT void translatePendingCppExceptionToJavaException() noexcept;
+// be thrown, it aborts the program.
+FBEXPORT void translatePendingCppExceptionToJavaException();
+
+#ifndef FBJNI_NO_EXCEPTION_PTR
+FBEXPORT local_ref<JThrowable> getJavaExceptionForCppException(std::exception_ptr ptr);
+#endif
+
+FBEXPORT local_ref<JThrowable> getJavaExceptionForCppBackTrace();
 
+FBEXPORT local_ref<JThrowable> getJavaExceptionForCppBackTrace(const char* msg);
 // For convenience, some exception names in java.lang are available here.
 
 const char* const gJavaLangIllegalArgumentException = "java/lang/IllegalArgumentException";

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/Hybrid.h

@@ -29,11 +29,59 @@ class BaseHybridClass {
 
 struct FBEXPORT HybridData : public JavaClass<HybridData> {
   constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
-  void setNativePointer(std::unique_ptr<BaseHybridClass> new_value);
-  BaseHybridClass* getNativePointer();
   static local_ref<HybridData> create();
 };
 
+class HybridDestructor : public JavaClass<HybridDestructor> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/facebook/jni/HybridData$Destructor;";
+
+  template <typename T=detail::BaseHybridClass>
+  T* getNativePointer() {
+    static auto pointerField = javaClassStatic()->getField<jlong>("mNativePointer");
+    auto* value = reinterpret_cast<detail::BaseHybridClass*>(getFieldValue(pointerField));
+    if (!value) {
+      throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
+    }
+    return value;
+  }
+
+  template <typename T=detail::BaseHybridClass>
+  void setNativePointer(std::unique_ptr<T> new_value) {
+    static auto pointerField = javaClassStatic()->getField<jlong>("mNativePointer");
+    auto old_value = std::unique_ptr<T>(reinterpret_cast<T*>(getFieldValue(pointerField)));
+    if (new_value && old_value) {
+        FBCRASH("Attempt to set C++ native pointer twice");
+    }
+    setFieldValue(pointerField, reinterpret_cast<jlong>(new_value.release()));
+  }
+};
+
+template<typename T>
+detail::BaseHybridClass* getNativePointer(T t) {
+  return getHolder(t)->getNativePointer();
+}
+
+template<typename T>
+void setNativePointer(T t, std::unique_ptr<detail::BaseHybridClass> new_value) {
+  getHolder(t)->setNativePointer(std::move(new_value));
+}
+
+template<typename T>
+local_ref<HybridDestructor> getHolder(T t) {
+  static auto holderField = t->getClass()->template getField<HybridDestructor::javaobject>("mDestructor");
+  return t->getFieldValue(holderField);
+}
+
+// JavaClass for HybridClassBase
+struct FBEXPORT HybridClassBase : public JavaClass<HybridClassBase> {
+  constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridClassBase;";
+
+  static bool isHybridClassBase(alias_ref<jclass> jclass) {
+    return HybridClassBase::javaClassStatic()->isAssignableFrom(jclass);
+  }
+};
+
 template <typename Base, typename Enabled = void>
 struct HybridTraits {
   // This static assert should actually always fail if we don't use one of the
@@ -139,7 +187,7 @@ class FBEXPORT HybridClass : public detail::HybridTraits<Base>::CxxBase {
 
   static local_ref<detail::HybridData> makeHybridData(std::unique_ptr<T> cxxPart) {
     auto hybridData = detail::HybridData::create();
-    hybridData->setNativePointer(std::move(cxxPart));
+    setNativePointer(hybridData, std::move(cxxPart));
     return hybridData;
   }
 
@@ -148,6 +196,11 @@ class FBEXPORT HybridClass : public detail::HybridTraits<Base>::CxxBase {
     return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
   }
 
+  template <typename... Args>
+  static void setCxxInstance(alias_ref<jhybridobject> o, Args&&... args) {
+    setNativePointer(o, std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
+  }
+
 public:
   // Factory method for creating a hybrid object where the arguments
   // are used to initialize the C++ part directly without passing them
@@ -161,11 +214,23 @@ class FBEXPORT HybridClass : public detail::HybridTraits<Base>::CxxBase {
   // C++ object fails, or any JNI methods throw.
   template <typename... Args>
   static local_ref<JavaPart> newObjectCxxArgs(Args&&... args) {
-    auto hybridData = makeCxxInstance(std::forward<Args>(args)...);
-    return JavaPart::newInstance(hybridData);
+    static bool isHybrid = detail::HybridClassBase::isHybridClassBase(javaClassStatic());
+    auto cxxPart = std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+
+    local_ref<JavaPart> result;
+    if (isHybrid) {
+      result = JavaPart::newInstance();
+      setNativePointer(result, std::move(cxxPart));
+    }
+    else {
+      auto hybridData = makeHybridData(std::move(cxxPart));
+      result = JavaPart::newInstance(hybridData);
+    }
+
+    return result;
   }
 
-  // TODO? Create reusable interface for Allocatable classes and use it to
+ // TODO? Create reusable interface for Allocatable classes and use it to
   // strengthen type-checking (and possibly provide a default
   // implementation of allocate().)
   template <typename... Args>
@@ -195,17 +260,25 @@ class FBEXPORT HybridClass : public detail::HybridTraits<Base>::CxxBase {
 
 template <typename T, typename B>
 inline T* HybridClass<T, B>::JavaPart::cthis() {
-  static auto field =
-    HybridClass<T, B>::JavaPart::javaClassStatic()->template getField<detail::HybridData::javaobject>("mHybridData");
-  auto hybridData = this->getFieldValue(field);
-  if (!hybridData) {
-    throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
+  detail::BaseHybridClass* result = 0;
+  static bool isHybrid = detail::HybridClassBase::isHybridClassBase(this->getClass());
+  if (isHybrid) {
+    result = getNativePointer(this);
+  } else {
+    static auto field =
+      HybridClass<T, B>::JavaPart::javaClassStatic()->template getField<detail::HybridData::javaobject>("mHybridData");
+    auto hybridData = this->getFieldValue(field);
+    if (!hybridData) {
+      throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
+    }
+
+    result = getNativePointer(hybridData);
   }
-  // I'd like to use dynamic_cast here, but -fno-rtti is the default.
-  T* value = static_cast<T*>(hybridData->getNativePointer());
+
   // This would require some serious programmer error.
-  FBASSERTMSGF(value != 0, "Incorrect C++ type in hybrid field");
-  return value;
+  FBASSERTMSGF(result != 0, "Incorrect C++ type in hybrid field");
+  // I'd like to use dynamic_cast here, but -fno-rtti is the default.
+  return static_cast<T*>(result);
 };
 
 template <typename T, typename B>

ReactAndroid/src/main/jni/first-party/fb/include/fb/fbjni/JWeakReference.h

@@ -0,0 +1,37 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#pragma once
+
+#include <fb/visibility.h>
+
+#include "CoreClasses.h"
+
+namespace facebook {
+namespace jni {
+
+/**
+ * Wrap Java's WeakReference instead of using JNI WeakGlobalRefs.
+ * A WeakGlobalRef can yield a strong reference even after the object has been
+  * finalized. See comment in the djinni library.
+ * https://github.com/dropbox/djinni/blob/master/support-lib/jni/djinni_support.hpp
+ */
+template<typename T = jobject>
+class JWeakReference : public JavaClass<JWeakReference<T>> {
+
+ typedef JavaClass<JWeakReference<T>> JavaBase_;
+
+ public:
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/ref/WeakReference;";
+
+  static local_ref<JWeakReference<T>> newInstance(alias_ref<T> object) {
+    return JavaBase_::newInstance(static_ref_cast<jobject>(object));
+  }
+
+  local_ref<T> get() const {
+    static auto method = JavaBase_::javaClassStatic()->template getMethod<jobject()>("get");
+    return static_ref_cast<T>(method(JavaBase_::self()));
+  }
+};
+
+}
+}