@depup/react-native 0.85.0-depup.1 → 0.86.2-depup.0

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -29,7 +29,8 @@ Scheduler::Scheduler(
     const SchedulerToolbox& schedulerToolbox,
     UIManagerAnimationDelegate* animationDelegate,
     SchedulerDelegate* delegate)
-    : runtimeExecutor_(schedulerToolbox.runtimeExecutor),
+    : delegateInvalidated_(std::make_shared<std::atomic<bool>>(false)),
+      runtimeExecutor_(schedulerToolbox.runtimeExecutor),
       contextContainer_(schedulerToolbox.contextContainer) {
   // Creating a container for future `EventDispatcher` instance.
   eventDispatcher_ = std::make_shared<std::optional<const EventDispatcher>>();
@@ -88,11 +89,12 @@ Scheduler::Scheduler(
                        EventTarget* eventTarget,
                        const std::string& type,
                        ReactEventPriority priority,
-                       const EventPayload& payload) {
+                       const EventPayload& payload,
+                       HighResTimeStamp eventTimestamp) {
     uiManager->visitBinding(
         [&](const UIManagerBinding& uiManagerBinding) {
           uiManagerBinding.dispatchEvent(
-              runtime, eventTarget, type, priority, payload);
+              runtime, eventTarget, type, priority, payload, eventTimestamp);
         },
         runtime);
   };
@@ -157,6 +159,12 @@ Scheduler::Scheduler(
   }
   uiManager_->setAnimationDelegate(animationDelegate);
 
+  // Initialize ViewTransitionModule
+  if (ReactNativeFeatureFlags::viewTransitionEnabled()) {
+    viewTransitionModule_ = std::make_shared<ViewTransitionModule>();
+    viewTransitionModule_->initialize(uiManager_.get(), viewTransitionModule_);
+  }
+
   uiManager->registerMountHook(*eventPerformanceLogger_);
 }
 
@@ -164,6 +172,15 @@ Scheduler::~Scheduler() {
   LOG(WARNING) << "Scheduler::~Scheduler() was called (address: " << this
                << ").";
 
+  // Invalidate any lambdas already queued via scheduleRenderingUpdate that
+  // captured a raw delegate_ pointer; without this they'd dereference a
+  // dangling SchedulerDelegate after Scheduler teardown. (No replacement
+  // token is allocated here — Scheduler is going away.)
+  // Gated to allow controlled rollout / rollback.
+  if (ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation()) {
+    *delegateInvalidated_ = true;
+  }
+
   auto weakRuntimeScheduler =
       contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
           RuntimeSchedulerKey);
@@ -186,6 +203,7 @@ Scheduler::~Scheduler() {
   // The thread-safety of this operation is guaranteed by this requirement.
   uiManager_->setDelegate(nullptr);
   uiManager_->setAnimationDelegate(nullptr);
+  uiManager_->setViewTransitionDelegate(nullptr);
 
   if (cdpMetricsReporter_) {
     performanceEntryReporter_->removeEventListener(&*cdpMetricsReporter_);
@@ -252,6 +270,21 @@ Scheduler::findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
 #pragma mark - Delegate
 
 void Scheduler::setDelegate(SchedulerDelegate* delegate) {
+  // Gated to allow controlled rollout / rollback.
+  if (ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation() &&
+      delegate_ != delegate) {
+    // Mark the *current* token invalid: any rendering-update lambda already
+    // queued holds a shared_ptr to this atomic and will observe `true` on
+    // its next read, so it no-ops instead of calling into the previous
+    // delegate (which the caller is about to drop).
+    *delegateInvalidated_ = true;
+    // Then install a *fresh* token (a new atomic) so lambdas captured
+    // against the new delegate use their own non-invalidated flag.
+    // Reusing the previous atomic and flipping it back to `false` would
+    // re-arm the in-flight lambdas — exactly the use-after-free we're
+    // trying to prevent — because they share the same shared_ptr.
+    delegateInvalidated_ = std::make_shared<std::atomic<bool>>(false);
+  }
   delegate_ = delegate;
 }
 
@@ -280,10 +313,21 @@ void Scheduler::uiManagerDidFinishTransaction(
     if (!mountSynchronously) {
       auto surfaceId = mountingCoordinator->getSurfaceId();
 
+      // Capture the gating flag at queue time: the lambda's decision to
+      // honor the invalidation guard is fixed when we enqueue, not when it
+      // later runs. Avoids per-invocation feature-flag reads and keeps the
+      // contract for an in-flight lambda stable across flag flips.
+      auto guardEnabled =
+          ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation();
       runtimeScheduler_->scheduleRenderingUpdate(
           surfaceId,
           [delegate = delegate_,
+           invalidated = delegateInvalidated_,
+           guardEnabled,
            mountingCoordinator = std::move(mountingCoordinator)]() {
+            if (guardEnabled && *invalidated) {
+              return;
+            }
             delegate->schedulerShouldRenderTransactions(mountingCoordinator);
           });
     } else {
@@ -306,12 +350,20 @@ void Scheduler::uiManagerDidDispatchCommand(
       "Scheduler::uiManagerDispatchCommand", "commandName", commandName);
   if (delegate_ != nullptr) {
     auto shadowView = ShadowView(*shadowNode);
+    // See comment in uiManagerDidFinishTransaction above for gating shape.
+    auto guardEnabled =
+        ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation();
     runtimeScheduler_->scheduleRenderingUpdate(
         shadowNode->getSurfaceId(),
         [delegate = delegate_,
+         invalidated = delegateInvalidated_,
+         guardEnabled,
          shadowView = std::move(shadowView),
          commandName,
          args]() {
+          if (guardEnabled && *invalidated) {
+            return;
+          }
           delegate->schedulerDidDispatchCommand(shadowView, commandName, args);
         });
   }
@@ -356,6 +408,27 @@ void Scheduler::uiManagerDidUpdateShadowTree(
   }
 }
 
+void Scheduler::uiManagerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerDidCaptureViewSnapshot(tag, surfaceId);
+  }
+}
+
+void Scheduler::uiManagerDidSetViewSnapshot(
+    Tag sourceTag,
+    Tag targetTag,
+    SurfaceId surfaceId) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerDidSetViewSnapshot(sourceTag, targetTag, surfaceId);
+  }
+}
+
+void Scheduler::uiManagerDidClearPendingSnapshots() {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerDidClearPendingSnapshots();
+  }
+}
+
 void Scheduler::uiManagerShouldAddEventListener(
     std::shared_ptr<const EventListener> listener) {
   addEventListener(listener);

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <atomic>
 #include <memory>
 
 #include <ReactCommon/RuntimeExecutor.h>
@@ -27,6 +28,7 @@
 #include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/UIManagerDelegate.h>
+#include <react/renderer/viewtransition/ViewTransitionModule.h>
 #include <react/utils/ContextContainer.h>
 
 namespace facebook::react {
@@ -93,6 +95,9 @@ class Scheduler final : public UIManagerDelegate {
       bool blockNativeResponder) override;
   void uiManagerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) override;
   void uiManagerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
+  void uiManagerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) override;
+  void uiManagerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) override;
+  void uiManagerDidClearPendingSnapshots() override;
   void uiManagerShouldAddEventListener(std::shared_ptr<const EventListener> listener) final;
   void uiManagerShouldRemoveEventListener(const std::shared_ptr<const EventListener> &listener) final;
   void uiManagerDidFinishReactCommit(const ShadowTree &shadowTree) override;
@@ -118,6 +123,11 @@ class Scheduler final : public UIManagerDelegate {
   friend class SurfaceHandler;
 
   SchedulerDelegate *delegate_;
+  // Invalidation token captured by-value into lambdas deferred via
+  // runtimeScheduler_->scheduleRenderingUpdate. Set to true on delegate
+  // change or Scheduler destruction so a lambda that outlives its captured
+  // raw delegate pointer can no-op instead of dereferencing dangling memory.
+  std::shared_ptr<std::atomic<bool>> delegateInvalidated_;
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   RuntimeExecutor runtimeExecutor_;
   std::shared_ptr<UIManager> uiManager_;
@@ -146,6 +156,8 @@ class Scheduler final : public UIManagerDelegate {
 
   RuntimeScheduler *runtimeScheduler_{nullptr};
 
+  std::shared_ptr<ViewTransitionModule> viewTransitionModule_;
+
   mutable std::shared_mutex onSurfaceStartCallbackMutex_;
   OnSurfaceStartCallback onSurfaceStartCallback_;
 };

package/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -66,6 +66,11 @@ class SchedulerDelegate {
 
   virtual void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) = 0;
 
+  // View transition bitmap snapshot capture and application.
+  virtual void schedulerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) = 0;
+  virtual void schedulerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) = 0;
+  virtual void schedulerDidClearPendingSnapshots() = 0;
+
   virtual ~SchedulerDelegate() noexcept = default;
 };
 

package/ReactCommon/react/renderer/textlayoutmanager/platform/android/react/renderer/textlayoutmanager/TextLayoutManager.cpp

@@ -41,7 +41,6 @@ int countAttachments(const AttributedString& attributedString) {
 
 Size measureText(
     const std::shared_ptr<const ContextContainer>& contextContainer,
-    Tag rootTag,
     MapBuffer attributedString,
     MapBuffer paragraphAttributes,
     float minWidth,
@@ -55,7 +54,6 @@ Size measureText(
   static auto measure =
       jni::findClassStatic("com/facebook/react/fabric/FabricUIManager")
           ->getMethod<jlong(
-              jint,
               JReadableMapBuffer::javaobject,
               JReadableMapBuffer::javaobject,
               jfloat,
@@ -71,7 +69,6 @@ Size measureText(
 
   return yogaMeassureToSize(measure(
       fabricUIManager,
-      rootTag,
       attributedStringBuffer.get(),
       paragraphAttributesBuffer.get(),
       minWidth,
@@ -105,7 +102,6 @@ TextMeasurement doMeasure(
 
   auto size = measureText(
       contextContainer,
-      layoutContext.surfaceId,
       std::move(attributedStringMap),
       std::move(paragraphAttributesMap),
       minimumSize.width,
@@ -221,7 +217,6 @@ TextMeasurement TextLayoutManager::measureCachedSpannableById(
 
   auto size = measureText(
       contextContainer_,
-      layoutContext.surfaceId,
       localDataBuilder.build(),
       toMapBuffer(paragraphAttributes),
       minimumSize.width,
@@ -304,7 +299,6 @@ TextLayoutManager::PreparedTextLayout TextLayoutManager::prepareLayout(
   static auto prepareTextLayout =
       jni::findClassStatic("com/facebook/react/fabric/FabricUIManager")
           ->getMethod<JPreparedLayout::javaobject(
-              jint,
               JReadableMapBuffer::javaobject,
               JReadableMapBuffer::javaobject,
               jfloat,
@@ -335,7 +329,6 @@ TextLayoutManager::PreparedTextLayout TextLayoutManager::prepareLayout(
 
         return PreparedTextLayout{jni::make_global(prepareTextLayout(
             fabricUIManager,
-            layoutContext.surfaceId,
             attributedStringMB.get(),
             paragraphAttributesMB.get(),
             minimumSize.width,

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm

@@ -208,8 +208,9 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                                          .width = usedRect.size.width, .height = usedRect.size.height}};
 
                                  CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
+                                 const char *renderedUTF8 = [renderedString UTF8String];
                                  auto line = LineMeasurement{
-                                     std::string([renderedString UTF8String]),
+                                     std::string(renderedUTF8 != nullptr ? renderedUTF8 : ""),
                                      rect,
                                      overallRect.size.height - baseline,
                                      font.capHeight,

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -118,49 +118,51 @@ std::shared_ptr<ShadowNode> UIManager::cloneNode(
 
   auto& componentDescriptor = shadowNode.getComponentDescriptor();
   auto& family = shadowNode.getFamily();
-  auto props = ShadowNodeFragment::propsPlaceholder();
 
+  auto props = ShadowNodeFragment::propsPlaceholder();
   if (!rawProps.isEmpty()) {
-    if (family.nativeProps_DEPRECATED != nullptr) {
-      // 1. update the nativeProps_DEPRECATED props.
-      //
-      // In this step, we want the most recent value for the props
-      // managed by setNativeProps.
-      // Values in `rawProps` patch (take precedence over)
-      // `nativeProps_DEPRECATED`. For example, if both
-      // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'.
-      // Value from `rawProps` overrides what was previously in
-      // `nativeProps_DEPRECATED`. Notice that the `nativeProps_DEPRECATED`
-      // patch will not get more props from `rawProps`: if the key is not
-      // present in `nativeProps_DEPRECATED`, it will not be added.
-      //
-      // The result of this operation is the new `nativeProps_DEPRECATED`.
-      family.nativeProps_DEPRECATED =
-          std::make_unique<folly::dynamic>(mergeDynamicProps(
-              *family.nativeProps_DEPRECATED, // source
-              (folly::dynamic)rawProps, // patch
-              NullValueStrategy::Ignore));
-
-      // 2. Compute the final set of props.
-      //
-      // This step takes the new props handled by `setNativeProps` and
-      // merges them in the `rawProps` managed by React.
-      // The new props handled by `nativeProps` now takes precedence
-      // on the props handled by React, as we want to make sure that
-      // all the props are applied to the component.
-      // We use these finalProps as source of truth for the component.
-      auto finalProps = mergeDynamicProps(
-          (folly::dynamic)rawProps, // source
-          *family.nativeProps_DEPRECATED, // patch
-          NullValueStrategy::Override);
-
-      // 3. Clone the props by using finalProps.
-      props = componentDescriptor.cloneProps(
-          propsParserContext, shadowNode.getProps(), RawProps(finalProps));
-    } else {
-      props = componentDescriptor.cloneProps(
-          propsParserContext, shadowNode.getProps(), std::move(rawProps));
+    std::optional<folly::dynamic> finalProps;
+    {
+      std::lock_guard<std::mutex> lock(family.nativePropsMutex);
+      if (family.nativeProps_DEPRECATED != nullptr) {
+        // 1. update the nativeProps_DEPRECATED props.
+        //
+        // In this step, we want the most recent value for the props
+        // managed by setNativeProps.
+        // Values in `rawProps` patch (take precedence over)
+        // `nativeProps_DEPRECATED`. For example, if both
+        // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'.
+        // Value from `rawProps` overrides what was previously in
+        // `nativeProps_DEPRECATED`. Notice that the `nativeProps_DEPRECATED`
+        // patch will not get more props from `rawProps`: if the key is not
+        // present in `nativeProps_DEPRECATED`, it will not be added.
+        //
+        // The result of this operation is the new `nativeProps_DEPRECATED`.
+        family.nativeProps_DEPRECATED =
+            std::make_unique<folly::dynamic>(mergeDynamicProps(
+                *family.nativeProps_DEPRECATED, // source
+                (folly::dynamic)rawProps, // patch
+                NullValueStrategy::Ignore));
+
+        // 2. Compute the final set of props.
+        //
+        // This step takes the new props handled by `setNativeProps` and
+        // merges them in the `rawProps` managed by React.
+        // The new props handled by `nativeProps` now takes precedence
+        // on the props handled by React, as we want to make sure that
+        // all the props are applied to the component.
+        // We use these finalProps as source of truth for the component.
+        finalProps = mergeDynamicProps(
+            (folly::dynamic)rawProps, // source
+            *family.nativeProps_DEPRECATED, // patch
+            NullValueStrategy::Override);
+      }
     }
+
+    props = componentDescriptor.cloneProps(
+        propsParserContext,
+        shadowNode.getProps(),
+        finalProps ? RawProps(std::move(*finalProps)) : std::move(rawProps));
   }
 
   auto clonedShadowNode = componentDescriptor.cloneShadowNode(
@@ -272,9 +274,13 @@ void UIManager::setSurfaceProps(
 ShadowTree::Unique UIManager::stopSurface(SurfaceId surfaceId) const {
   TraceSection s("UIManager::stopSurface");
 
-  // Stop any ongoing animations.
+  // Stop any ongoing layout animations.
   stopSurfaceForAnimationDelegate(surfaceId);
 
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    animationBackend_->clearRegistryOnSurfaceStop(surfaceId);
+  }
+
   // Waiting for all concurrent commits to be finished and unregistering the
   // `ShadowTree`.
   auto shadowTree = getShadowTreeRegistry().remove(surfaceId);
@@ -435,19 +441,22 @@ void UIManager::setNativeProps_DEPRECATED(
     const std::shared_ptr<const ShadowNode>& shadowNode,
     RawProps rawProps) const {
   auto& family = shadowNode->getFamily();
-  if (family.nativeProps_DEPRECATED) {
-    // Values in `rawProps` patch (take precedence over)
-    // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
-    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what
-    // was previously in `nativeProps_DEPRECATED`.
-    family.nativeProps_DEPRECATED =
-        std::make_unique<folly::dynamic>(mergeDynamicProps(
-            *family.nativeProps_DEPRECATED,
-            (folly::dynamic)rawProps,
-            NullValueStrategy::Override));
-  } else {
-    family.nativeProps_DEPRECATED =
-        std::make_unique<folly::dynamic>((folly::dynamic)rawProps);
+  {
+    std::lock_guard<std::mutex> lock(family.nativePropsMutex);
+    if (family.nativeProps_DEPRECATED) {
+      // Values in `rawProps` patch (take precedence over)
+      // `nativeProps_DEPRECATED`. For example, if both
+      // `nativeProps_DEPRECATED` and `rawProps` contain key 'A'. Value from
+      // `rawProps` overrides what was previously in `nativeProps_DEPRECATED`.
+      family.nativeProps_DEPRECATED =
+          std::make_unique<folly::dynamic>(mergeDynamicProps(
+              *family.nativeProps_DEPRECATED,
+              (folly::dynamic)rawProps,
+              NullValueStrategy::Override));
+    } else {
+      family.nativeProps_DEPRECATED =
+          std::make_unique<folly::dynamic>((folly::dynamic)rawProps);
+    }
   }
 
   shadowTreeRegistry_.visit(
@@ -488,6 +497,10 @@ void UIManager::sendAccessibilityEvent(
   }
 }
 
+UIManagerViewTransitionDelegate* UIManager::getViewTransitionDelegate() const {
+  return viewTransitionDelegate_;
+}
+
 void UIManager::configureNextLayoutAnimation(
     jsi::Runtime& runtime,
     const RawValue& config,
@@ -708,6 +721,13 @@ void UIManager::setNativeAnimatedDelegate(
   nativeAnimatedDelegate_ = delegate;
 }
 
+void UIManager::setViewTransitionDelegate(
+    UIManagerViewTransitionDelegate* delegate) {
+  if (ReactNativeFeatureFlags::viewTransitionEnabled()) {
+    viewTransitionDelegate_ = delegate;
+  }
+}
+
 void UIManager::unstable_setAnimationBackend(
     std::shared_ptr<UIManagerAnimationBackend> animationBackend) {
   animationBackend_ = animationBackend;

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -27,6 +27,7 @@
 #include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 #include <react/renderer/uimanager/UIManagerDelegate.h>
 #include <react/renderer/uimanager/UIManagerNativeAnimatedDelegate.h>
+#include <react/renderer/uimanager/UIManagerViewTransitionDelegate.h>
 #include <react/renderer/uimanager/consistency/LazyShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/uimanager/consistency/ShadowTreeRevisionProvider.h>
 #include <react/renderer/uimanager/primitives.h>
@@ -74,6 +75,12 @@ class UIManager final : public ShadowTreeDelegate {
 
   void setNativeAnimatedDelegate(std::weak_ptr<UIManagerNativeAnimatedDelegate> delegate);
 
+  /**
+   * Sets and gets UIManager's ViewTransition API delegate.
+   */
+  void setViewTransitionDelegate(UIManagerViewTransitionDelegate *delegate);
+  UIManagerViewTransitionDelegate *getViewTransitionDelegate() const;
+
   void animationTick() const;
 
   void synchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props);
@@ -242,6 +249,7 @@ class UIManager final : public ShadowTreeDelegate {
   UIManagerDelegate *delegate_{};
   UIManagerAnimationDelegate *animationDelegate_{nullptr};
   std::weak_ptr<UIManagerNativeAnimatedDelegate> nativeAnimatedDelegate_;
+  UIManagerViewTransitionDelegate *viewTransitionDelegate_{nullptr};
 
   const RuntimeExecutor runtimeExecutor_{};
   ShadowTreeRegistry shadowTreeRegistry_{};

package/ReactCommon/react/renderer/uimanager/UIManagerAnimationBackend.h

@@ -30,7 +30,9 @@ class UIManagerAnimationBackend {
   virtual CallbackId start(const Callback &callback) = 0;
   virtual void stop(CallbackId callbackId) = 0;
   virtual void clearRegistry(SurfaceId surfaceId) = 0;
+  virtual void clearRegistryOnSurfaceStop(SurfaceId surfaceId) = 0;
   virtual void trigger() = 0;
+  virtual void pushAnimationMutations(const Callback &callback) = 0;
   virtual void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) = 0;
 };