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

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTHermesInstance.mm

@@ -9,21 +9,15 @@
 
 namespace facebook::react {
 
-RCTHermesInstance::RCTHermesInstance() : RCTHermesInstance(nullptr, nullptr, false) {}
+RCTHermesInstance::RCTHermesInstance() : RCTHermesInstance(nullptr, false) {}
 
-RCTHermesInstance::RCTHermesInstance(
-    std::shared_ptr<const ReactNativeConfig> reactNativeConfig,
-    CrashManagerProvider crashManagerProvider)
-    : RCTHermesInstance(reactNativeConfig, std::move(crashManagerProvider), false)
+RCTHermesInstance::RCTHermesInstance(CrashManagerProvider crashManagerProvider)
+    : RCTHermesInstance(std::move(crashManagerProvider), false)
 {
 }
 
-RCTHermesInstance::RCTHermesInstance(
-    std::shared_ptr<const ReactNativeConfig> reactNativeConfig,
-    CrashManagerProvider crashManagerProvider,
-    bool allocInOldGenBeforeTTI)
-    : _reactNativeConfig(std::move(reactNativeConfig)),
-      _crashManagerProvider(std::move(crashManagerProvider)),
+RCTHermesInstance::RCTHermesInstance(CrashManagerProvider crashManagerProvider, bool allocInOldGenBeforeTTI)
+    : _crashManagerProvider(std::move(crashManagerProvider)),
       _hermesInstance(std::make_unique<HermesInstance>()),
       _allocInOldGenBeforeTTI(allocInOldGenBeforeTTI)
 {
@@ -33,10 +27,7 @@ std::unique_ptr<JSRuntime> RCTHermesInstance::createJSRuntime(
     std::shared_ptr<MessageQueueThread> msgQueueThread) noexcept
 {
   return _hermesInstance->createJSRuntime(
-      _reactNativeConfig,
-      _crashManagerProvider ? _crashManagerProvider() : nullptr,
-      std::move(msgQueueThread),
-      _allocInOldGenBeforeTTI);
+      _crashManagerProvider ? _crashManagerProvider() : nullptr, std::move(msgQueueThread), _allocInOldGenBeforeTTI);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTHost.mm

@@ -254,7 +254,9 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
   surface.surfaceHandler.setDisplayMode(displayMode);
   [self _attachSurface:surface];
 
-  [_instance callFunctionOnBufferedRuntimeExecutor:[surface](facebook::jsi::Runtime &_) { [surface start]; }];
+  __weak RCTFabricSurface *weakSurface = surface;
+  // Use the BufferedRuntimeExecutor to start the surface after the main JS bundle was fully executed.
+  [_instance callFunctionOnBufferedRuntimeExecutor:[weakSurface](facebook::jsi::Runtime &_) { [weakSurface start]; }];
   return surface;
 }
 

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -121,8 +121,11 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
       [_bridgeModuleDecorator.callableJSModules
           setBridgelessJSModuleMethodInvoker:^(
               NSString *moduleName, NSString *methodName, NSArray *args, dispatch_block_t onComplete) {
-            // TODO: Make RCTInstance call onComplete
             [weakSelf callFunctionOnJSModule:moduleName method:methodName args:args];
+            if (onComplete) {
+              [weakSelf
+                  callFunctionOnBufferedRuntimeExecutor:[onComplete](facebook::jsi::Runtime &_) { onComplete(); }];
+            }
           }];
     }
     _launchOptions = launchOptions;
@@ -182,22 +185,19 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
 
 - (Class)getModuleClassFromName:(const char *)name
 {
-  if ([_appTMMDelegate respondsToSelector:@selector(getModuleClassFromName:)]) {
-    return [_appTMMDelegate getModuleClassFromName:name];
-  }
-
-  return nil;
+  return [_appTMMDelegate getModuleClassFromName:name];
 }
 
 - (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
 {
-  if ([_appTMMDelegate respondsToSelector:@selector(getModuleInstanceFromClass:)]) {
-    id<RCTTurboModule> module = [_appTMMDelegate getModuleInstanceFromClass:moduleClass];
-    [self _attachBridgelessAPIsToModule:module];
-    return module;
+  id<RCTTurboModule> module = [_appTMMDelegate getModuleInstanceFromClass:moduleClass];
+
+  if (!module) {
+    module = [moduleClass new];
   }
 
-  return nil;
+  [self _attachBridgelessAPIsToModule:module];
+  return module;
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
@@ -232,7 +232,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   objCTimerRegistryRawPtr->setTimerManager(timerManager);
 
   __weak __typeof(self) weakSelf = self;
-  auto onJsError = [=](jsi::Runtime &runtime, const JsErrorHandler::ParsedError &error) {
+  auto onJsError = [=](jsi::Runtime &runtime, const JsErrorHandler::ProcessedError &error) {
     [weakSelf _handleJSError:error withRuntime:runtime];
   };
 
@@ -302,7 +302,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
       "RCTEventDispatcher",
       facebook::react::wrapManagedObject([_turboModuleManager moduleForName:"RCTEventDispatcher"]));
   contextContainer->insert("RCTBridgeModuleDecorator", facebook::react::wrapManagedObject(_bridgeModuleDecorator));
-  contextContainer->insert("RuntimeScheduler", std::weak_ptr<RuntimeScheduler>(_reactInstance->getRuntimeScheduler()));
+  contextContainer->insert(RuntimeSchedulerKey, std::weak_ptr<RuntimeScheduler>(_reactInstance->getRuntimeScheduler()));
   contextContainer->insert("RCTBridgeProxy", facebook::react::wrapManagedObject(bridgeProxy));
 
   _surfacePresenter = [[RCTSurfacePresenter alloc]
@@ -477,7 +477,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   });
 }
 
-- (void)_handleJSError:(const JsErrorHandler::ParsedError &)error withRuntime:(jsi::Runtime &)runtime
+- (void)_handleJSError:(const JsErrorHandler::ProcessedError &)error withRuntime:(jsi::Runtime &)runtime
 {
   NSMutableDictionary<NSString *, id> *errorData = [NSMutableDictionary new];
   errorData[@"message"] = @(error.message.c_str());
@@ -492,7 +492,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   }
 
   NSMutableArray<NSDictionary<NSString *, id> *> *stack = [NSMutableArray new];
-  for (const JsErrorHandler::ParsedError::StackFrame &frame : error.stack) {
+  for (const JsErrorHandler::ProcessedError::StackFrame &frame : error.stack) {
     NSMutableDictionary<NSString *, id> *stackFrame = [NSMutableDictionary new];
     if (frame.file) {
       stackFrame[@"file"] = @(frame.file->c_str());

package/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -124,10 +124,11 @@ class ReactInstanceTest : public ::testing::Test {
     auto mockRegistry = std::make_unique<MockTimerRegistry>();
     mockRegistry_ = mockRegistry.get();
     timerManager_ = std::make_shared<TimerManager>(std::move(mockRegistry));
-    auto onJsError = [](jsi::Runtime& /*runtime*/,
-                        const JsErrorHandler::ParsedError& /*error*/) noexcept {
-      // Do nothing
-    };
+    auto onJsError =
+        [](jsi::Runtime& /*runtime*/,
+           const JsErrorHandler::ProcessedError& /*error*/) noexcept {
+          // Do nothing
+        };
 
     instance_ = std::make_unique<ReactInstance>(
         std::move(runtime),

package/ReactCommon/react/test_utils/shadowTreeGeneration.h

@@ -14,7 +14,6 @@
 #include <memory>
 #include <random>
 
-#include <react/config/ReactNativeConfig.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/stubs/stubs.h>
@@ -245,8 +244,6 @@ static inline ShadowNode::Unshared messWithYogaStyles(
   }
 
   ContextContainer contextContainer;
-  contextContainer.insert(
-      "ReactNativeConfig", std::make_shared<EmptyReactNativeConfig>());
 
   PropsParserContext parserContext{-1, contextContainer};
 

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.cpp

@@ -14,6 +14,13 @@
 
 namespace facebook::react {
 
+namespace {
+
+/** Process ID for all emitted events. */
+const uint64_t PID = 1000;
+
+} // namespace
+
 bool FuseboxTracer::isTracing() {
   std::lock_guard lock(mutex_);
   return tracing_;
@@ -43,34 +50,43 @@ bool FuseboxTracer::stopTracing(
   }
 
   auto traceEvents = folly::dynamic::array();
+
+  // Register "Main" process
+  traceEvents.push_back(folly::dynamic::object(
+      "args", folly::dynamic::object("name", "Main"))("cat", "__metadata")(
+      "name", "process_name")("ph", "M")("pid", PID)("tid", 0)("ts", 0));
+  // Register "Timings" track
+  // NOTE: This is a hack to make the trace viewer show a "Timings" track
+  // adjacent to custom tracks in our current build of Chrome DevTools.
+  // In future, we should align events exactly.
+  traceEvents.push_back(folly::dynamic::object(
+      "args", folly::dynamic::object("name", "Timings"))("cat", "__metadata")(
+      "name", "thread_name")("ph", "M")("pid", PID)("tid", 1000)("ts", 0));
+
   auto savedBuffer = std::move(buffer_);
   buffer_.clear();
-
   std::unordered_map<std::string, uint64_t> trackIdMap;
-  uint64_t nextTrack = 1000;
-
-  // Name the main process. Only one process is supported currently.
-  traceEvents.push_back(folly::dynamic::object(
-      "args", folly::dynamic::object("name", "Main App"))("cat", "__metadata")(
-      "name", "process_name")("ph", "M")("pid", 1000)("tid", 0)("ts", 0));
+  uint64_t nextTrack = 1001;
 
   for (auto& event : savedBuffer) {
-    if (!trackIdMap.contains(event.track)) {
+    // For events with a custom track name, register track
+    if (event.track.length() && !trackIdMap.contains(event.track)) {
       auto trackId = nextTrack++;
       trackIdMap[event.track] = trackId;
-      // New track
       traceEvents.push_back(folly::dynamic::object(
           "args", folly::dynamic::object("name", event.track))(
-          "cat", "__metadata")("name", "thread_name")("ph", "M")("pid", 1000)(
+          "cat", "__metadata")("name", "thread_name")("ph", "M")("pid", PID)(
           "tid", trackId)("ts", 0));
     }
-    auto trackId = trackIdMap[event.track];
 
-    // New event
+    auto trackId =
+        trackIdMap.contains(event.track) ? trackIdMap[event.track] : 1000;
+
+    // Emit "blink.user_timing" trace event
     traceEvents.push_back(folly::dynamic::object(
-        "args", folly::dynamic::object())("cat", "react.native")(
+        "args", folly::dynamic::object())("cat", "blink.user_timing")(
         "dur", (event.end - event.start) * 1000)("name", event.name)("ph", "X")(
-        "ts", event.start * 1000)("pid", 1000)("tid", trackId));
+        "ts", event.start * 1000)("pid", PID)("tid", trackId));
 
     if (traceEvents.size() >= 1000) {
       resultCallback(traceEvents);
@@ -88,13 +104,13 @@ void FuseboxTracer::addEvent(
     const std::string_view& name,
     uint64_t start,
     uint64_t end,
-    const std::string_view& track) {
+    const std::optional<std::string_view>& track) {
   std::lock_guard<std::mutex> lock(mutex_);
   if (!tracing_) {
     return;
   }
-  buffer_.push_back(
-      BufferEvent{start, end, std::string(name), std::string(track)});
+  buffer_.push_back(BufferEvent{
+      start, end, std::string(name), std::string(track.value_or(""))});
 }
 
 bool FuseboxTracer::stopTracingAndWriteToFile(const std::string& path) {

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.h

@@ -7,9 +7,11 @@
 
 #pragma once
 
+#include "folly/dynamic.h"
+
 #include <functional>
+#include <optional>
 #include <vector>
-#include "folly/dynamic.h"
 
 namespace facebook::react {
 
@@ -20,6 +22,10 @@ struct BufferEvent {
   std::string track;
 };
 
+/**
+ * @deprecated Replaced by jsinspector_modern::PerformanceTracer and will be
+ * removed when we delete FuseboxPerfettoDataSource.
+ */
 class FuseboxTracer {
  public:
   FuseboxTracer(const FuseboxTracer&) = delete;
@@ -38,7 +44,7 @@ class FuseboxTracer {
       const std::string_view& name,
       uint64_t start,
       uint64_t end,
-      const std::string_view& track);
+      const std::optional<std::string_view>& track);
 
   static FuseboxTracer& getFuseboxTracer();
 

package/ReactCommon/reactperflogger/reactperflogger/{ReactPerfLogger.cpp → ReactPerfettoLogger.cpp}

@@ -5,32 +5,38 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "ReactPerfLogger.h"
-
-#include <react/timing/primitives.h>
-#if __has_include(<reactperflogger/fusebox/FuseboxTracer.h>)
-#include <reactperflogger/fusebox/FuseboxTracer.h>
-#define HAS_FUSEBOX
-#endif
-#include <chrono>
+#include "ReactPerfettoLogger.h"
 
+#ifdef WITH_PERFETTO
 #include "ReactPerfetto.h"
+#endif
 
 namespace facebook::react {
 
-/* static */ void ReactPerfLogger::measure(
+#ifdef WITH_PERFETTO
+namespace {
+
+const std::string PERFETTO_DEFAULT_TRACK_NAME = "# Web Performance";
+const std::string PERFETTO_TRACK_NAME_PREFIX = "# Web Performance: ";
+
+std::string toPerfettoTrackName(
+    const std::optional<std::string_view>& trackName) {
+  return trackName.has_value()
+      ? PERFETTO_TRACK_NAME_PREFIX + std::string(trackName.value())
+      : PERFETTO_DEFAULT_TRACK_NAME;
+}
+
+} // namespace
+#endif
+
+/* static */ void ReactPerfettoLogger::measure(
     const std::string_view& eventName,
     double startTime,
     double endTime,
-    const std::string_view& trackName) {
-#ifdef HAS_FUSEBOX
-  FuseboxTracer::getFuseboxTracer().addEvent(
-      eventName, (uint64_t)startTime, (uint64_t)endTime, trackName);
-#endif
-
+    const std::optional<std::string_view>& trackName) {
 #ifdef WITH_PERFETTO
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
-    auto track = getPerfettoWebPerfTrackAsync(std::string(trackName));
+    auto track = getPerfettoWebPerfTrackAsync(toPerfettoTrackName(trackName));
     TRACE_EVENT_BEGIN(
         "react-native",
         perfetto::DynamicString(eventName.data(), eventName.size()),
@@ -42,24 +48,19 @@ namespace facebook::react {
 #endif
 }
 
-/* static */ void ReactPerfLogger::mark(
+/* static */ void ReactPerfettoLogger::mark(
     const std::string_view& eventName,
     double startTime,
-    const std::string_view& trackName) {
-  // TODO(T203046480) Support mark in FuseboxTracer
-
+    const std::optional<std::string_view>& trackName) {
 #ifdef WITH_PERFETTO
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
     TRACE_EVENT_INSTANT(
         "react-native",
         perfetto::DynamicString(eventName.data(), eventName.size()),
-        getPerfettoWebPerfTrackSync(std::string(trackName)),
+        getPerfettoWebPerfTrackSync(toPerfettoTrackName(trackName)),
         performanceNowToPerfettoTraceTime(startTime));
   }
 #endif
 }
 
-/* static */ double ReactPerfLogger::performanceNow() {
-  return chronoToDOMHighResTimeStamp(std::chrono::steady_clock::now());
-}
 } // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/{ReactPerfLogger.h → ReactPerfettoLogger.h}

@@ -8,28 +8,28 @@
 #pragma once
 
 #include <reactperflogger/ReactPerfettoCategories.h>
+
+#include <optional>
 #include <string>
 
 namespace facebook::react {
 
-class ReactPerfLogger {
+/**
+ * An internal interface for logging performance events to Perfetto, when
+ * configured.
+ */
+class ReactPerfettoLogger {
  public:
   static void mark(
       const std::string_view& eventName,
       double startTime,
-      const std::string_view& trackName);
+      const std::optional<std::string_view>& trackName);
 
-  /**
-   * This accepts performance events that should go to internal tracing
-   * frameworks like Perfetto, and should go to DevTools like Fusebox.
-   */
   static void measure(
       const std::string_view& eventName,
       double startTime,
       double endTime,
-      const std::string_view& trackName);
-
-  static double performanceNow();
+      const std::optional<std::string_view>& trackName);
 };
 
 } // namespace facebook::react

package/ReactCommon/yoga/yoga/YGEnums.cpp

@@ -245,6 +245,12 @@ const char* YGUnitToString(const YGUnit value) {
       return "percent";
     case YGUnitAuto:
       return "auto";
+    case YGUnitMaxContent:
+      return "max-content";
+    case YGUnitFitContent:
+      return "fit-content";
+    case YGUnitStretch:
+      return "stretch";
   }
   return "unknown";
 }

package/ReactCommon/yoga/yoga/YGEnums.h

@@ -131,7 +131,10 @@ YG_ENUM_DECL(
     YGUnitUndefined,
     YGUnitPoint,
     YGUnitPercent,
-    YGUnitAuto)
+    YGUnitAuto,
+    YGUnitMaxContent,
+    YGUnitFitContent,
+    YGUnitStretch)
 
 YG_ENUM_DECL(
     YGWrap,