Fix crash caused by using ShareableHandle in multiple remote runtimes

[tomekzaw]

Summary

Fixes Expensify/react-native-live-markdown#574. See root cause analysis in Expensify/react-native-live-markdown#574 (comment).

This PR fixes a crash caused by calling ShareableHandle::toJSValue with second remote runtime after initializing remoteValue_ with a jsi::Value belonging to the first remote runtime.

I assume that this is a rare scenario so we only memoize the value for the first remote runtime and we recreate the value for all subsequent runtimes.

Test plan

Reproduction:

EmptyExample.tsx

import { Text, StyleSheet, View } from 'react-native';

import React from 'react';
import {
  createWorkletRuntime,
  runOnRuntime,
  useAnimatedStyle,
} from 'react-native-reanimated';

const regex = /\d/;

const workletRuntime = createWorkletRuntime('another');

export default function EmptyExample() {
  useAnimatedStyle(() => {
    console.log('useAnimatedStyle', String(regex));
    return {};
  });

  runOnRuntime(workletRuntime, () => {
    'worklet';
    console.log('runOnRuntime', String(regex));
    return {};
  })();

  return (
    <View style={styles.container}>
      <Text>Hello world!</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    alignItems: 'center',
    justifyContent: 'center',
  },
});

[tomekzaw]

Please confirm that we don't need any additional synchronization involving initializationMutex_ prior to merging.

cc @tjzel who touched this code some time ago

[tjzel]

LGTM

[piaskowyk]

Changes look ok, and probably we also need to add that logic to RetainingShareable. What do you think? 🤔

[tomekzaw]

Looks like RetainingShareable already supports multiple runtimes. There's a comparison of &rt with primaryRuntime_ and secondaryRuntime_ and there's a call to BaseClass::toJSValue(rt) that generates a new instance for yet another runtime:

react-native-reanimated/packages/react-native-reanimated/Common/cpp/worklets/SharedItems/Shareables.cpp

Lines 142 to 163 in 2a947a8

	template <typename BaseClass>
	jsi::Value RetainingShareable<BaseClass>::toJSValue(jsi::Runtime &rt) {
	if (&rt == primaryRuntime_) {
	// TODO: it is suboptimal to generate new object every time getJS is
	// called on host runtime – the objects we are generating already exists
	// and we should possibly just grab a hold of such object and use it here
	// instead of creating a new JS representation. As far as I understand the
	// only case where it can be realistically called this way is when a
	// shared value is created and then accessed on the same runtime
	return BaseClass::toJSValue(rt);
	}
	if (secondaryValue_ == nullptr) {
	auto value = BaseClass::toJSValue(rt);
	secondaryValue_ = std::make_unique<jsi::Value>(rt, value);
	secondaryRuntime_ = &rt;
	return value;
	}
	if (&rt == secondaryRuntime_) {
	return jsi::Value(rt, *secondaryValue_);
	}
	return BaseClass::toJSValue(rt);
	}