react-native-tvos 0.77.1-0 → 0.78.0-0

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

@@ -1,45 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <fb/RefPtr.h>
-#include <fb/assert.h>
-#include <fb/noncopyable.h>
-#include <fb/nonmovable.h>
-#include <atomic>
-
-namespace facebook {
-
-class Countable : public noncopyable, public nonmovable {
- public:
-  // RefPtr expects refcount to start at 0
-  Countable() : m_refcount(0) {}
-  virtual ~Countable() {
-    FBASSERT(m_refcount == 0);
-  }
-
- private:
-  void ref() {
-    ++m_refcount;
-  }
-
-  void unref() {
-    if (0 == --m_refcount) {
-      delete this;
-    }
-  }
-
-  bool hasOnlyOneRef() const {
-    return m_refcount == 1;
-  }
-
-  template <typename T>
-  friend class RefPtr;
-  std::atomic<int> m_refcount;
-};
-
-} // namespace facebook

package/ReactAndroid/src/main/jni/first-party/fb/include/fb/Doxyfile

@@ -1,18 +0,0 @@
-PROJECT_NAME           = "Facebook JNI"
-PROJECT_BRIEF          = "Helper library to provide safe and convenient access to JNI with very low overhead"
-JAVADOC_AUTOBRIEF      = YES
-EXTRACT_ALL            = YES
-RECURSIVE              = YES
-EXCLUDE                = tests Asserts.h Countable.h GlobalReference.h LocalReference.h LocalString.h Registration.h WeakReference.h jni_helpers.h Environment.h
-EXCLUDE_PATTERNS       = *-inl.h *.cpp
-GENERATE_HTML          = YES
-GENERATE_LATEX         = NO
-ENABLE_PREPROCESSING   = YES
-HIDE_UNDOC_MEMBERS     = YES
-HIDE_SCOPE_NAMES       = YES
-HIDE_FRIEND_COMPOUNDS  = YES
-HIDE_UNDOC_CLASSES     = YES
-SHOW_INCLUDE_FILES     = NO
-PREDEFINED             = LOG_TAG=fbjni
-EXAMPLE_PATH           = samples
-#ENABLED_SECTIONS       = INTERNAL

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

@@ -1,93 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <jni.h>
-#include <functional>
-#include <string>
-
-#include <fb/visibility.h>
-
-namespace facebook {
-namespace jni {
-
-namespace internal {
-struct CacheEnvTag {};
-} // namespace internal
-
-// 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
-  FBEXPORT static JNIEnv* current();
-  static void initialize(JavaVM* vm);
-
-  // There are subtle issues with calling the next functions directly. It is
-  // much better to always use a ThreadScope to manage attaching/detaching for
-  // you.
-  FBEXPORT static JNIEnv* ensureCurrentThreadIsAttached();
-  FBEXPORT static void detachCurrentThread();
-};
-
-/**
- * RAII Object that attaches a thread to the JVM. Failing to detach from a
- * thread before it exits will cause a crash, as will calling Detach an extra
- * time, and this guard class helps keep that straight. In addition, it
- * remembers whether it performed the attach or not, so it is safe to nest it
- * with itself or with non-fbjni code that manages the attachment correctly.
- *
- * Potential concerns:
- *  - Attaching to the JVM is fast (~100us on MotoG), but ideally you would
- * attach while the app is not busy.
- *  - Having a thread detach at arbitrary points is not safe in Dalvik; you need
- * to be sure that there is no Java code on the current stack or you run the
- * risk of a crash like: ERROR: detaching thread with interp frames (count=18)
- *    (More detail at
- * https://groups.google.com/forum/#!topic/android-ndk/2H8z5grNqjo) ThreadScope
- * won't do a detach if the thread was already attached before the guard is
- *    instantiated, but there's probably some usage that could trip this up.
- *  - Newly attached C++ threads only get the bootstrap class loader -- i.e.
- * java language classes, not any of our application's classes. This will be
- * different behavior than threads that were initiated on the Java side. A
- * workaround is to pass a global reference for a class or instance to the new
- * thread; this bypasses the need for the class loader. (See
- * http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/invocation.html#attach_current_thread)
- *    If you need access to the application's classes, you can use
- * ThreadScope::WithClassLoader.
- */
-class FBEXPORT ThreadScope {
- public:
-  ThreadScope();
-  ThreadScope(ThreadScope&) = delete;
-  ThreadScope(ThreadScope&&) = default;
-  ThreadScope& operator=(ThreadScope&) = delete;
-  ThreadScope& operator=(ThreadScope&&) = delete;
-  ~ThreadScope();
-
-  /**
-   * This runs the closure in a scope with fbjni's classloader. This should be
-   * the same classloader as the rest of the application and thus anything
-   * running in the closure will have access to the same classes as in a normal
-   * java-create thread.
-   */
-  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_;
-};
-} // namespace jni
-} // namespace facebook

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

@@ -1,58 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <cstring>
-#include <sstream>
-#include <string>
-
-namespace facebook {
-
-#define FROM_HERE facebook::ProgramLocation(__FUNCTION__, __FILE__, __LINE__)
-
-class ProgramLocation {
- public:
-  ProgramLocation()
-      : m_functionName("Unspecified"),
-        m_fileName("Unspecified"),
-        m_lineNumber(0) {}
-
-  ProgramLocation(const char* functionName, const char* fileName, int line)
-      : m_functionName(functionName),
-        m_fileName(fileName),
-        m_lineNumber(line) {}
-
-  const char* functionName() const {
-    return m_functionName;
-  }
-  const char* fileName() const {
-    return m_fileName;
-  }
-  int lineNumber() const {
-    return m_lineNumber;
-  }
-
-  std::string asFormattedString() const {
-    std::stringstream str;
-    str << "Function " << m_functionName << " in file " << m_fileName << ":"
-        << m_lineNumber;
-    return str.str();
-  }
-
-  bool operator==(const ProgramLocation& other) const {
-    // Assumes that the strings are static
-    return (m_functionName == other.m_functionName) &&
-        (m_fileName == other.m_fileName) && m_lineNumber == other.m_lineNumber;
-  }
-
- private:
-  const char* m_functionName;
-  const char* m_fileName;
-  int m_lineNumber;
-};
-
-} // namespace facebook

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

@@ -1,266 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <fb/assert.h>
-#include <utility>
-
-namespace facebook {
-
-// Reference counting smart pointer. This is designed to work with the
-// Countable class or other implementations in the future. It is designed in a
-// way to be both efficient and difficult to misuse. Typical usage is very
-// simple once you learn the patterns (and the compiler will help!):
-//
-// By default, the internal pointer is null.
-//   RefPtr<Foo> ref;
-//
-// Object creation requires explicit construction:
-//   RefPtr<Foo> ref = createNew<Foo>(...);
-//
-// Or if the constructor is not public:
-//   RefPtr<Foo> ref = adoptRef(new Foo(...));
-//
-// But you can implicitly create from nullptr:
-//   RefPtr<Foo> maybeRef = cond ? ref : nullptr;
-//
-// Move/Copy Construction/Assignment are straightforward:
-//   RefPtr<Foo> ref2 = ref;
-//   ref = std::move(ref2);
-//
-// Destruction automatically drops the RefPtr's reference as expected.
-//
-// Upcasting is implicit but downcasting requires an explicit cast:
-//   struct Bar : public Foo {};
-//   RefPtr<Bar> barRef = static_cast<RefPtr<Bar>>(ref);
-//   ref = barRef;
-//
-template <class T>
-class RefPtr {
- public:
-  constexpr RefPtr() : m_ptr(nullptr) {}
-
-  // Allow implicit construction from a pointer only from nullptr
-  constexpr RefPtr(std::nullptr_t ptr) : m_ptr(nullptr) {}
-
-  RefPtr(const RefPtr<T>& ref) : m_ptr(ref.m_ptr) {
-    refIfNecessary(m_ptr);
-  }
-
-  // Only allow implicit upcasts. A downcast will result in a compile error
-  // unless you use static_cast (which will end up invoking the explicit
-  // operator below).
-  template <typename U>
-  RefPtr(
-      const RefPtr<U>& ref,
-      typename std::enable_if<std::is_base_of<T, U>::value, U>::type* = nullptr)
-      : m_ptr(ref.get()) {
-    refIfNecessary(m_ptr);
-  }
-
-  RefPtr(RefPtr<T>&& ref) : m_ptr(nullptr) {
-    *this = std::move(ref);
-  }
-
-  // Only allow implicit upcasts. A downcast will result in a compile error
-  // unless you use static_cast (which will end up invoking the explicit
-  // operator below).
-  template <typename U>
-  RefPtr(
-      RefPtr<U>&& ref,
-      typename std::enable_if<std::is_base_of<T, U>::value, U>::type* = nullptr)
-      : m_ptr(nullptr) {
-    *this = std::move(ref);
-  }
-
-  ~RefPtr() {
-    unrefIfNecessary(m_ptr);
-    m_ptr = nullptr;
-  }
-
-  RefPtr<T>& operator=(const RefPtr<T>& ref) {
-    if (m_ptr != ref.m_ptr) {
-      unrefIfNecessary(m_ptr);
-      m_ptr = ref.m_ptr;
-      refIfNecessary(m_ptr);
-    }
-    return *this;
-  }
-
-  // The STL assumes rvalue references are unique and for simplicity's sake, we
-  // make the same assumption here, that &ref != this.
-  RefPtr<T>& operator=(RefPtr<T>&& ref) {
-    unrefIfNecessary(m_ptr);
-    m_ptr = ref.m_ptr;
-    ref.m_ptr = nullptr;
-    return *this;
-  }
-
-  template <typename U>
-  RefPtr<T>& operator=(RefPtr<U>&& ref) {
-    unrefIfNecessary(m_ptr);
-    m_ptr = ref.m_ptr;
-    ref.m_ptr = nullptr;
-    return *this;
-  }
-
-  void reset() {
-    unrefIfNecessary(m_ptr);
-    m_ptr = nullptr;
-  }
-
-  T* get() const {
-    return m_ptr;
-  }
-
-  T* operator->() const {
-    return m_ptr;
-  }
-
-  T& operator*() const {
-    return *m_ptr;
-  }
-
-  template <typename U>
-  explicit operator RefPtr<U>() const;
-
-  explicit operator bool() const {
-    return m_ptr ? true : false;
-  }
-
-  bool isTheLastRef() const {
-    FBASSERT(m_ptr);
-    return m_ptr->hasOnlyOneRef();
-  }
-
-  // Creates a strong reference from a raw pointer, assuming that is already
-  // referenced from some other RefPtr. This should be used sparingly.
-  static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
-    return RefPtr<T>(ptr, ConstructionMode::External);
-  }
-
-  // Creates a strong reference from a raw pointer, assuming that it points to a
-  // freshly-created object. See the documentation for RefPtr for usage.
-  static inline RefPtr<T> adoptRef(T* ptr) {
-    return RefPtr<T>(ptr, ConstructionMode::Adopted);
-  }
-
- private:
-  enum class ConstructionMode { Adopted, External };
-
-  RefPtr(T* ptr, ConstructionMode mode) : m_ptr(ptr) {
-    FBASSERTMSGF(
-        ptr,
-        "Got null pointer in %s construction mode",
-        mode == ConstructionMode::Adopted ? "adopted" : "external");
-    ptr->ref();
-    if (mode == ConstructionMode::Adopted) {
-      FBASSERT(ptr->hasOnlyOneRef());
-    }
-  }
-
-  static inline void refIfNecessary(T* ptr) {
-    if (ptr) {
-      ptr->ref();
-    }
-  }
-  static inline void unrefIfNecessary(T* ptr) {
-    if (ptr) {
-      ptr->unref();
-    }
-  }
-
-  template <typename U>
-  friend class RefPtr;
-
-  T* m_ptr;
-};
-
-// Creates a strong reference from a raw pointer, assuming that is already
-// referenced from some other RefPtr and that it is non-null. This should be
-// used sparingly.
-template <typename T>
-static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
-  return RefPtr<T>::assumeAlreadyReffed(ptr);
-}
-
-// As above, but tolerant of nullptr.
-template <typename T>
-static inline RefPtr<T> assumeAlreadyReffedOrNull(T* ptr) {
-  return ptr ? RefPtr<T>::assumeAlreadyReffed(ptr) : nullptr;
-}
-
-// Creates a strong reference from a raw pointer, assuming that it points to a
-// freshly-created object. See the documentation for RefPtr for usage.
-template <typename T>
-static inline RefPtr<T> adoptRef(T* ptr) {
-  return RefPtr<T>::adoptRef(ptr);
-}
-
-template <typename T, typename... Args>
-static inline RefPtr<T> createNew(Args&&... arguments) {
-  return RefPtr<T>::adoptRef(new T(std::forward<Args>(arguments)...));
-}
-
-template <typename T>
-template <typename U>
-RefPtr<T>::operator RefPtr<U>() const {
-  static_assert(std::is_base_of<T, U>::value, "Invalid static cast");
-  return assumeAlreadyReffedOrNull<U>(static_cast<U*>(m_ptr));
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() == b.get();
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() != b.get();
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& ref, U* ptr) {
-  return ref.get() == ptr;
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& ref, U* ptr) {
-  return ref.get() != ptr;
-}
-
-template <typename T, typename U>
-inline bool operator==(U* ptr, const RefPtr<T>& ref) {
-  return ref.get() == ptr;
-}
-
-template <typename T, typename U>
-inline bool operator!=(U* ptr, const RefPtr<T>& ref) {
-  return ref.get() != ptr;
-}
-
-template <typename T>
-inline bool operator==(const RefPtr<T>& ref, std::nullptr_t ptr) {
-  return ref.get() == ptr;
-}
-
-template <typename T>
-inline bool operator!=(const RefPtr<T>& ref, std::nullptr_t ptr) {
-  return ref.get() != ptr;
-}
-
-template <typename T>
-inline bool operator==(std::nullptr_t ptr, const RefPtr<T>& ref) {
-  return ref.get() == ptr;
-}
-
-template <typename T>
-inline bool operator!=(std::nullptr_t ptr, const RefPtr<T>& ref) {
-  return ref.get() != ptr;
-}
-
-} // namespace facebook

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

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <fb/assert.h>
-#include <utility>
-
-namespace facebook {
-
-// Class that lets you declare a global but does not add a static constructor
-// to the binary. Eventually I'd like to have this auto-initialize in a
-// multithreaded environment but for now it's easiest just to use manual
-// initialization.
-template <typename T>
-class StaticInitialized {
- public:
-  constexpr StaticInitialized() : m_instance(nullptr) {}
-
-  template <typename... Args>
-  void initialize(Args&&... arguments) {
-    FBASSERT(!m_instance);
-    m_instance = new T(std::forward<Args>(arguments)...);
-  }
-
-  T* operator->() const {
-    return m_instance;
-  }
-
- private:
-  T* m_instance;
-};
-
-} // namespace facebook

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

@@ -1,112 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <errno.h>
-#include <pthread.h>
-
-#include <fb/assert.h>
-
-namespace facebook {
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A thread-local object is a "global" object within a thread. This is useful
- * for writing apartment-threaded code, where nothing is actullay shared
- * between different threads (hence no locking) but those variables are not
- * on stack in local scope. To use it, just do something like this,
- *
- *   ThreadLocal<MyClass> static_object;
- *     static_object->data_ = ...;
- *     static_object->doSomething();
- *
- *   ThreadLocal<int> static_number;
- *     int value = *static_number;
- *
- * So, syntax-wise it's similar to pointers. T can be primitive types, and if
- * it's a class, there has to be a default constructor.
- */
-template <typename T>
-class ThreadLocal {
- public:
-  /**
-   * Constructor that has to be called from a thread-neutral place.
-   */
-  ThreadLocal() : m_key(0), m_cleanup(OnThreadExit) {
-    initialize();
-  }
-
-  /**
-   * As above but with a custom cleanup function
-   */
-  typedef void (*CleanupFunction)(void* obj);
-  explicit ThreadLocal(CleanupFunction cleanup) : m_key(0), m_cleanup(cleanup) {
-    FBASSERT(cleanup);
-    initialize();
-  }
-
-  /**
-   * Access object's member or method through this operator overload.
-   */
-  T* operator->() const {
-    return get();
-  }
-
-  T& operator*() const {
-    return *get();
-  }
-
-  T* get() const {
-    return (T*)pthread_getspecific(m_key);
-  }
-
-  T* release() {
-    T* obj = get();
-    pthread_setspecific(m_key, NULL);
-    return obj;
-  }
-
-  void reset(T* other = NULL) {
-    T* old = (T*)pthread_getspecific(m_key);
-    if (old != other) {
-      FBASSERT(m_cleanup);
-      m_cleanup(old);
-      pthread_setspecific(m_key, other);
-    }
-  }
-
- private:
-  void initialize() {
-    int ret = pthread_key_create(&m_key, m_cleanup);
-    if (ret != 0) {
-      const char* msg = "(unknown error)";
-      switch (ret) {
-        case EAGAIN:
-          msg = "PTHREAD_KEYS_MAX (1024) is exceeded";
-          break;
-        case ENOMEM:
-          msg = "Out-of-memory";
-          break;
-      }
-      (void)msg;
-      FBASSERTMSGF(0, "pthread_key_create failed: %d %s", ret, msg);
-    }
-  }
-
-  static void OnThreadExit(void* obj) {
-    if (NULL != obj) {
-      delete (T*)obj;
-    }
-  }
-
-  pthread_key_t m_key;
-  CleanupFunction m_cleanup;
-};
-
-} // namespace facebook

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

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#ifndef FBASSERT_H
-#define FBASSERT_H
-
-#include <fb/visibility.h>
-
-namespace facebook {
-#define ENABLE_FBASSERT 1
-
-#if ENABLE_FBASSERT
-#define FBASSERTMSGF(expr, msg, ...)                                       \
-  !(expr) ? facebook::assertInternal(                                      \
-                "Assert (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__) \
-          : (void)0
-#else
-#define FBASSERTMSGF(expr, msg, ...)
-#endif // ENABLE_FBASSERT
-
-#define FBASSERT(expr) FBASSERTMSGF(expr, "%s", #expr)
-
-#define FBCRASH(msg, ...)   \
-  facebook::assertInternal( \
-      "Fatal error (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__)
-#define FBUNREACHABLE()     \
-  facebook::assertInternal( \
-      "This code should be unreachable (%s:%d)", __FILE__, __LINE__)
-
-FBEXPORT void assertInternal(const char* formatstr, ...)
-    __attribute__((noreturn));
-
-// This allows storing the assert message before the current process terminates
-// due to a crash
-typedef void (*AssertHandler)(const char* message);
-void setAssertHandler(AssertHandler assertHandler);
-
-} // namespace facebook
-#endif // FBASSERT_H