mirror of
https://github.com/facebook/react-native.git
synced 2025-11-01 09:14:26 +00:00
Drop support for webworkers
Reviewed By: AaaChiuuu Differential Revision: D4916449 fbshipit-source-id: a447233d3b7cfee98db2ce00f1c0505d513e2429
This commit is contained in:
Pieter De Baets
committed by
Facebook Github Bot
Facebook Github Bot
parent
a20882f62e
commit
34bc6bd2ae
@@ -22,23 +22,11 @@ namespace react {
|
||||
// This class manages calls from JS to native code.
|
||||
class JsToNativeBridge : public react::ExecutorDelegate {
|
||||
public:
|
||||
JsToNativeBridge(NativeToJsBridge* nativeToJs,
|
||||
std::shared_ptr<ModuleRegistry> registry,
|
||||
JsToNativeBridge(std::shared_ptr<ModuleRegistry> registry,
|
||||
std::shared_ptr<InstanceCallback> callback)
|
||||
: m_nativeToJs(nativeToJs)
|
||||
, m_registry(registry)
|
||||
: m_registry(registry)
|
||||
, m_callback(callback) {}
|
||||
|
||||
void registerExecutor(std::unique_ptr<JSExecutor> executor,
|
||||
std::shared_ptr<MessageQueueThread> queue) override {
|
||||
m_nativeToJs->registerExecutor(m_callback->createExecutorToken(), std::move(executor), queue);
|
||||
}
|
||||
|
||||
std::unique_ptr<JSExecutor> unregisterExecutor(JSExecutor& executor) override {
|
||||
m_callback->onExecutorStopped(m_nativeToJs->getTokenForExecutor(executor));
|
||||
return m_nativeToJs->unregisterExecutor(executor);
|
||||
}
|
||||
|
||||
std::shared_ptr<ModuleRegistry> getModuleRegistry() override {
|
||||
return m_registry;
|
||||
}
|
||||
@@ -48,15 +36,13 @@ public:
|
||||
|
||||
CHECK(m_registry || calls.empty()) <<
|
||||
"native module calls cannot be completed with no native modules";
|
||||
ExecutorToken token = m_nativeToJs->getTokenForExecutor(executor);
|
||||
m_batchHadNativeModuleCalls = m_batchHadNativeModuleCalls || !calls.empty();
|
||||
|
||||
// An exception anywhere in here stops processing of the batch. This
|
||||
// was the behavior of the Android bridge, and since exception handling
|
||||
// terminates the whole bridge, there's not much point in continuing.
|
||||
for (auto& call : parseMethodCalls(std::move(calls))) {
|
||||
m_registry->callNativeMethod(
|
||||
token, call.moduleId, call.methodId, std::move(call.arguments), call.callId);
|
||||
m_registry->callNativeMethod(call.moduleId, call.methodId, std::move(call.arguments), call.callId);
|
||||
}
|
||||
if (isEndOfBatch) {
|
||||
// onBatchComplete will be called on the native (module) queue, but
|
||||
@@ -73,18 +59,14 @@ public:
|
||||
MethodCallResult callSerializableNativeHook(
|
||||
JSExecutor& executor, unsigned int moduleId, unsigned int methodId,
|
||||
folly::dynamic&& args) override {
|
||||
ExecutorToken token = m_nativeToJs->getTokenForExecutor(executor);
|
||||
return m_registry->callSerializableNativeHook(token, moduleId, methodId, std::move(args));
|
||||
return m_registry->callSerializableNativeHook(moduleId, methodId, std::move(args));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
// These methods are always invoked from an Executor. The NativeToJsBridge
|
||||
// keeps a reference to the root executor, and when destroy() is
|
||||
// called, the Executors are all destroyed synchronously on their
|
||||
// bridges. So, the bridge pointer will will always point to a
|
||||
// valid object during a call to a delegate method from an exectuto.
|
||||
NativeToJsBridge* m_nativeToJs;
|
||||
// keeps a reference to the executor, and when destroy() is called, the
|
||||
// executor is destroyed synchronously on its queue.
|
||||
std::shared_ptr<ModuleRegistry> m_registry;
|
||||
std::shared_ptr<InstanceCallback> m_callback;
|
||||
bool m_batchHadNativeModuleCalls = false;
|
||||
@@ -96,14 +78,9 @@ NativeToJsBridge::NativeToJsBridge(
|
||||
std::shared_ptr<MessageQueueThread> jsQueue,
|
||||
std::shared_ptr<InstanceCallback> callback)
|
||||
: m_destroyed(std::make_shared<bool>(false))
|
||||
, m_mainExecutorToken(callback->createExecutorToken())
|
||||
, m_delegate(std::make_shared<JsToNativeBridge>(this, registry, callback)) {
|
||||
std::unique_ptr<JSExecutor> mainExecutor =
|
||||
jsExecutorFactory->createJSExecutor(m_delegate, jsQueue);
|
||||
// cached to avoid locked map lookup in the common case
|
||||
m_mainExecutor = mainExecutor.get();
|
||||
registerExecutor(m_mainExecutorToken, std::move(mainExecutor), jsQueue);
|
||||
}
|
||||
, m_delegate(std::make_shared<JsToNativeBridge>(registry, callback))
|
||||
, m_executor(jsExecutorFactory->createJSExecutor(m_delegate, jsQueue))
|
||||
, m_executorMessageQueueThread(std::move(jsQueue)) {}
|
||||
|
||||
// This must be called on the same thread on which the constructor was called.
|
||||
NativeToJsBridge::~NativeToJsBridge() {
|
||||
@@ -116,7 +93,6 @@ void NativeToJsBridge::loadApplication(
|
||||
std::unique_ptr<const JSBigString> startupScript,
|
||||
std::string startupScriptSourceURL) {
|
||||
runOnExecutorQueue(
|
||||
m_mainExecutorToken,
|
||||
[unbundleWrap=folly::makeMoveWrapper(std::move(unbundle)),
|
||||
startupScript=folly::makeMoveWrapper(std::move(startupScript)),
|
||||
startupScriptSourceURL=std::move(startupScriptSourceURL)]
|
||||
@@ -135,14 +111,13 @@ void NativeToJsBridge::loadApplicationSync(
|
||||
std::unique_ptr<const JSBigString> startupScript,
|
||||
std::string startupScriptSourceURL) {
|
||||
if (unbundle) {
|
||||
m_mainExecutor->setJSModulesUnbundle(std::move(unbundle));
|
||||
m_executor->setJSModulesUnbundle(std::move(unbundle));
|
||||
}
|
||||
m_mainExecutor->loadApplicationScript(std::move(startupScript),
|
||||
m_executor->loadApplicationScript(std::move(startupScript),
|
||||
std::move(startupScriptSourceURL));
|
||||
}
|
||||
|
||||
void NativeToJsBridge::callFunction(
|
||||
ExecutorToken executorToken,
|
||||
std::string&& module,
|
||||
std::string&& method,
|
||||
folly::dynamic&& arguments) {
|
||||
@@ -160,23 +135,24 @@ void NativeToJsBridge::callFunction(
|
||||
std::string tracingName;
|
||||
#endif
|
||||
|
||||
runOnExecutorQueue(executorToken, [module = std::move(module), method = std::move(method), arguments = std::move(arguments), tracingName = std::move(tracingName), systraceCookie] (JSExecutor* executor) {
|
||||
#ifdef WITH_FBSYSTRACE
|
||||
FbSystraceAsyncFlow::end(
|
||||
TRACE_TAG_REACT_CXX_BRIDGE,
|
||||
tracingName.c_str(),
|
||||
systraceCookie);
|
||||
SystraceSection s(tracingName.c_str());
|
||||
#endif
|
||||
runOnExecutorQueue([module = std::move(module), method = std::move(method), arguments = std::move(arguments), tracingName = std::move(tracingName), systraceCookie]
|
||||
(JSExecutor* executor) {
|
||||
#ifdef WITH_FBSYSTRACE
|
||||
FbSystraceAsyncFlow::end(
|
||||
TRACE_TAG_REACT_CXX_BRIDGE,
|
||||
tracingName.c_str(),
|
||||
systraceCookie);
|
||||
SystraceSection s(tracingName.c_str());
|
||||
#endif
|
||||
|
||||
// This is safe because we are running on the executor's thread: it won't
|
||||
// destruct until after it's been unregistered (which we check above) and
|
||||
// that will happen on this thread
|
||||
executor->callFunction(module, method, arguments);
|
||||
});
|
||||
// This is safe because we are running on the executor's thread: it won't
|
||||
// destruct until after it's been unregistered (which we check above) and
|
||||
// that will happen on this thread
|
||||
executor->callFunction(module, method, arguments);
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::invokeCallback(ExecutorToken executorToken, double callbackId, folly::dynamic&& arguments) {
|
||||
void NativeToJsBridge::invokeCallback(double callbackId, folly::dynamic&& arguments) {
|
||||
int systraceCookie = -1;
|
||||
#ifdef WITH_FBSYSTRACE
|
||||
systraceCookie = m_systraceCookie++;
|
||||
@@ -186,24 +162,23 @@ void NativeToJsBridge::invokeCallback(ExecutorToken executorToken, double callba
|
||||
systraceCookie);
|
||||
#endif
|
||||
|
||||
runOnExecutorQueue(executorToken, [callbackId, arguments = std::move(arguments), systraceCookie] (JSExecutor* executor) {
|
||||
#ifdef WITH_FBSYSTRACE
|
||||
FbSystraceAsyncFlow::end(
|
||||
TRACE_TAG_REACT_CXX_BRIDGE,
|
||||
"<callback>",
|
||||
systraceCookie);
|
||||
SystraceSection s("NativeToJsBridge.invokeCallback");
|
||||
#endif
|
||||
runOnExecutorQueue([callbackId, arguments = std::move(arguments), systraceCookie]
|
||||
(JSExecutor* executor) {
|
||||
#ifdef WITH_FBSYSTRACE
|
||||
FbSystraceAsyncFlow::end(
|
||||
TRACE_TAG_REACT_CXX_BRIDGE,
|
||||
"<callback>",
|
||||
systraceCookie);
|
||||
SystraceSection s("NativeToJsBridge.invokeCallback");
|
||||
#endif
|
||||
|
||||
executor->invokeCallback(callbackId, arguments);
|
||||
});
|
||||
executor->invokeCallback(callbackId, arguments);
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::setGlobalVariable(std::string propName,
|
||||
std::unique_ptr<const JSBigString> jsonValue) {
|
||||
runOnExecutorQueue(
|
||||
m_mainExecutorToken,
|
||||
[propName=std::move(propName), jsonValue=folly::makeMoveWrapper(std::move(jsonValue))]
|
||||
runOnExecutorQueue([propName=std::move(propName), jsonValue=folly::makeMoveWrapper(std::move(jsonValue))]
|
||||
(JSExecutor* executor) mutable {
|
||||
executor->setGlobalVariable(propName, jsonValue.move());
|
||||
});
|
||||
@@ -211,149 +186,72 @@ void NativeToJsBridge::setGlobalVariable(std::string propName,
|
||||
|
||||
void* NativeToJsBridge::getJavaScriptContext() {
|
||||
// TODO(cjhopman): this seems unsafe unless we require that it is only called on the main js queue.
|
||||
return m_mainExecutor->getJavaScriptContext();
|
||||
return m_executor->getJavaScriptContext();
|
||||
}
|
||||
|
||||
bool NativeToJsBridge::supportsProfiling() {
|
||||
// Intentionally doesn't post to jsqueue. supportsProfiling() can be called from any thread.
|
||||
return m_mainExecutor->supportsProfiling();
|
||||
return m_executor->supportsProfiling();
|
||||
}
|
||||
|
||||
void NativeToJsBridge::startProfiler(const std::string& title) {
|
||||
runOnExecutorQueue(m_mainExecutorToken, [=] (JSExecutor* executor) {
|
||||
runOnExecutorQueue([=] (JSExecutor* executor) {
|
||||
executor->startProfiler(title);
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::stopProfiler(const std::string& title, const std::string& filename) {
|
||||
runOnExecutorQueue(m_mainExecutorToken, [=] (JSExecutor* executor) {
|
||||
runOnExecutorQueue([=] (JSExecutor* executor) {
|
||||
executor->stopProfiler(title, filename);
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::handleMemoryPressureUiHidden() {
|
||||
runOnExecutorQueue(m_mainExecutorToken, [=] (JSExecutor* executor) {
|
||||
runOnExecutorQueue([=] (JSExecutor* executor) {
|
||||
executor->handleMemoryPressureUiHidden();
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::handleMemoryPressureModerate() {
|
||||
runOnExecutorQueue(m_mainExecutorToken, [=] (JSExecutor* executor) {
|
||||
runOnExecutorQueue([=] (JSExecutor* executor) {
|
||||
executor->handleMemoryPressureModerate();
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::handleMemoryPressureCritical() {
|
||||
runOnExecutorQueue(m_mainExecutorToken, [=] (JSExecutor* executor) {
|
||||
runOnExecutorQueue([=] (JSExecutor* executor) {
|
||||
executor->handleMemoryPressureCritical();
|
||||
});
|
||||
}
|
||||
|
||||
ExecutorToken NativeToJsBridge::getMainExecutorToken() const {
|
||||
return m_mainExecutorToken;
|
||||
}
|
||||
|
||||
ExecutorToken NativeToJsBridge::registerExecutor(
|
||||
ExecutorToken token,
|
||||
std::unique_ptr<JSExecutor> executor,
|
||||
std::shared_ptr<MessageQueueThread> messageQueueThread) {
|
||||
std::lock_guard<std::mutex> registrationGuard(m_registrationMutex);
|
||||
|
||||
CHECK(m_executorTokenMap.find(executor.get()) == m_executorTokenMap.end())
|
||||
<< "Trying to register an already registered executor!";
|
||||
|
||||
m_executorTokenMap.emplace(executor.get(), token);
|
||||
m_executorMap.emplace(
|
||||
token,
|
||||
ExecutorRegistration(std::move(executor), messageQueueThread));
|
||||
|
||||
return token;
|
||||
}
|
||||
|
||||
std::unique_ptr<JSExecutor> NativeToJsBridge::unregisterExecutor(JSExecutor& executor) {
|
||||
std::unique_ptr<JSExecutor> ret;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> registrationGuard(m_registrationMutex);
|
||||
|
||||
auto it = m_executorTokenMap.find(&executor);
|
||||
CHECK(it != m_executorTokenMap.end())
|
||||
<< "Trying to unregister an executor that was never registered!";
|
||||
auto it2 = m_executorMap.find(it->second);
|
||||
ret = std::move(it2->second.executor_);
|
||||
|
||||
m_executorTokenMap.erase(it);
|
||||
m_executorMap.erase(it2);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
MessageQueueThread* NativeToJsBridge::getMessageQueueThread(const ExecutorToken& executorToken) {
|
||||
std::lock_guard<std::mutex> registrationGuard(m_registrationMutex);
|
||||
auto it = m_executorMap.find(executorToken);
|
||||
if (it == m_executorMap.end()) {
|
||||
return nullptr;
|
||||
}
|
||||
return it->second.messageQueueThread_.get();
|
||||
}
|
||||
|
||||
JSExecutor* NativeToJsBridge::getExecutor(const ExecutorToken& executorToken) {
|
||||
std::lock_guard<std::mutex> registrationGuard(m_registrationMutex);
|
||||
auto it = m_executorMap.find(executorToken);
|
||||
if (it == m_executorMap.end()) {
|
||||
return nullptr;
|
||||
}
|
||||
return it->second.executor_.get();
|
||||
}
|
||||
|
||||
ExecutorToken NativeToJsBridge::getTokenForExecutor(JSExecutor& executor) {
|
||||
std::lock_guard<std::mutex> registrationGuard(m_registrationMutex);
|
||||
return m_executorTokenMap.at(&executor);
|
||||
}
|
||||
|
||||
void NativeToJsBridge::destroy() {
|
||||
auto* executorMessageQueueThread = getMessageQueueThread(m_mainExecutorToken);
|
||||
// All calls made through runOnExecutorQueue have an early exit if
|
||||
// m_destroyed is true. Setting this before the runOnQueueSync will cause
|
||||
// pending work to be cancelled and we won't have to wait for it.
|
||||
*m_destroyed = true;
|
||||
executorMessageQueueThread->runOnQueueSync([this, executorMessageQueueThread] {
|
||||
m_mainExecutor->destroy();
|
||||
executorMessageQueueThread->quitSynchronous();
|
||||
m_delegate->unregisterExecutor(*m_mainExecutor);
|
||||
m_mainExecutor = nullptr;
|
||||
m_executorMessageQueueThread->runOnQueueSync([this] {
|
||||
m_executor->destroy();
|
||||
m_executorMessageQueueThread->quitSynchronous();
|
||||
m_executor = nullptr;
|
||||
});
|
||||
}
|
||||
|
||||
void NativeToJsBridge::runOnExecutorQueue(ExecutorToken executorToken, std::function<void(JSExecutor*)> task) {
|
||||
void NativeToJsBridge::runOnExecutorQueue(std::function<void(JSExecutor*)> task) {
|
||||
if (*m_destroyed) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto executorMessageQueueThread = getMessageQueueThread(executorToken);
|
||||
if (executorMessageQueueThread == nullptr) {
|
||||
LOG(WARNING) << "Dropping JS action for executor that has been unregistered...";
|
||||
return;
|
||||
}
|
||||
|
||||
std::shared_ptr<bool> isDestroyed = m_destroyed;
|
||||
executorMessageQueueThread->runOnQueue([this, isDestroyed, executorToken, task=std::move(task)] {
|
||||
m_executorMessageQueueThread->runOnQueue([this, isDestroyed, task=std::move(task)] {
|
||||
if (*isDestroyed) {
|
||||
return;
|
||||
}
|
||||
|
||||
JSExecutor *executor = getExecutor(executorToken);
|
||||
if (executor == nullptr) {
|
||||
LOG(WARNING) << "Dropping JS call for executor that has been unregistered...";
|
||||
return;
|
||||
}
|
||||
|
||||
// The executor is guaranteed to be valid for the duration of the task because:
|
||||
// 1. the executor is only destroyed after it is unregistered
|
||||
// 2. the executor is unregistered on this queue
|
||||
// 3. we just confirmed that the executor hasn't been unregistered above
|
||||
task(executor);
|
||||
task(m_executor.get());
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user