[Feat][Multibundling] Split loadApplicationScript to initializeRuntime and loadBundle

React/CxxBridge/RCTCxxBridge.mm

@@ -1336,7 +1336,7 @@ - (void)executeApplicationScript:(NSData *)script
       self->_reactInstance->loadScriptFromString(std::make_unique<NSDataBigString>(script),
                                                  sourceUrlStr.UTF8String, !async);
     } else {
-      std::string methodName = async ? "loadApplicationScript" : "loadApplicationScriptSync";
+      std::string methodName = async ? "loadBundle" : "loadBundleSync";
       throw std::logic_error("Attempt to call " + methodName + ": on uninitialized bridge");
     }
   }];

React/CxxBridge/RCTObjcExecutor.mm

@@ -74,7 +74,11 @@
       std::make_unique<JSBigStdString>(folly::toJson(config)));
   }
 
-  void loadApplicationScript(
+  void initializeRuntime() {
+    // We do nothing here since initialization is done in the constructor
+  }
+
+  void loadBundle(
       std::unique_ptr<const JSBigString> script,
       std::string sourceURL) override {
     RCTProfileBeginFlowEvent();

ReactAndroid/src/main/java/com/facebook/react/bridge/JavaJSExecutor.java

@@ -37,7 +37,7 @@ public ProxyExecutorException(Throwable cause) {
    * @param sourceURL url or file location from which script content was loaded
    */
   @DoNotStrip
-  void loadApplicationScript(String sourceURL) throws ProxyExecutorException;
+  void loadBundle(String sourceURL) throws ProxyExecutorException;
 
   /**
    * Execute javascript method within js context

ReactAndroid/src/main/java/com/facebook/react/bridge/ReactMarkerConstants.java

@@ -57,8 +57,8 @@ public enum ReactMarkerConstants {
   UNPACKING_JS_BUNDLE_LOADER_CHECK_END,
   UNPACKING_JS_BUNDLE_LOADER_EXTRACTED,
   UNPACKING_JS_BUNDLE_LOADER_BLOCKED,
-  loadApplicationScript_startStringConvert,
-  loadApplicationScript_endStringConvert,
+  loadBundle_startStringConvert,
+  loadBundle_endStringConvert,
   PRE_SETUP_REACT_CONTEXT_START,
   PRE_SETUP_REACT_CONTEXT_END,
   PRE_RUN_JS_BUNDLE_START,

ReactAndroid/src/main/java/com/facebook/react/devsupport/JSDebuggerWebSocketClient.java

@@ -80,7 +80,7 @@ public void prepareJSRuntime(JSDebuggerCallback callback) {
     }
   }
 
-  public void loadApplicationScript(
+  public void loadBundle(
       String sourceURL, HashMap<String, String> injectedObjects, JSDebuggerCallback callback) {
     int requestID = mRequestID.getAndIncrement();
     mCallbacks.put(requestID, callback);

ReactAndroid/src/main/java/com/facebook/react/devsupport/WebsocketJavaScriptExecutor.java

@@ -152,10 +152,10 @@ public void close() {
   }
 
   @Override
-  public void loadApplicationScript(String sourceURL) throws JavaJSExecutor.ProxyExecutorException {
+  public void loadBundle(String sourceURL) throws JavaJSExecutor.ProxyExecutorException {
     JSExecutorCallbackFuture callback = new JSExecutorCallbackFuture();
     Assertions.assertNotNull(mWebSocketClient)
-        .loadApplicationScript(sourceURL, mInjectedObjects, callback);
+        .loadBundle(sourceURL, mInjectedObjects, callback);
     try {
       callback.get();
     } catch (Throwable cause) {
@@ -177,7 +177,7 @@ public void loadApplicationScript(String sourceURL) throws JavaJSExecutor.ProxyE
 
   @Override
   public void setGlobalVariable(String propertyName, String jsonEncodedValue) {
-    // Store and use in the next loadApplicationScript() call.
+    // Store and use in the next loadBundle() call.
     mInjectedObjects.put(propertyName, jsonEncodedValue);
   }
 }

ReactAndroid/src/main/jni/react/jni/JReactMarker.cpp

@@ -42,10 +42,10 @@ void JReactMarker::logPerfMarker(const ReactMarker::ReactMarkerId markerId, cons
       JReactMarker::logMarker("CREATE_REACT_CONTEXT_END");
       break;
     case ReactMarker::JS_BUNDLE_STRING_CONVERT_START:
-      JReactMarker::logMarker("loadApplicationScript_startStringConvert");
+      JReactMarker::logMarker("loadBundle_startStringConvert");
       break;
     case ReactMarker::JS_BUNDLE_STRING_CONVERT_STOP:
-      JReactMarker::logMarker("loadApplicationScript_endStringConvert");
+      JReactMarker::logMarker("loadBundle_endStringConvert");
       break;
     case ReactMarker::NATIVE_MODULE_SETUP_START:
       JReactMarker::logMarker("NATIVE_MODULE_SETUP_START", tag);

ReactAndroid/src/main/jni/react/jni/ProxyExecutor.cpp

@@ -49,10 +49,7 @@ ProxyExecutor::~ProxyExecutor() {
   m_executor.reset();
 }
 
-void ProxyExecutor::loadApplicationScript(
-    std::unique_ptr<const JSBigString>,
-    std::string sourceURL) {
-
+void ProxyExecutor::initializeRuntime() {
   folly::dynamic nativeModuleConfig = folly::dynamic::array;
 
   {
@@ -74,13 +71,18 @@ void ProxyExecutor::loadApplicationScript(
       "__fbBatchedBridgeConfig",
       folly::make_unique<JSBigStdString>(folly::toJson(config)));
   }
+}
+
+void ProxyExecutor::loadBundle(
+    std::unique_ptr<const JSBigString>,
+    std::string sourceURL) {
 
-  static auto loadApplicationScript =
-    jni::findClassStatic(EXECUTOR_BASECLASS)->getMethod<void(jstring)>("loadApplicationScript");
+  static auto loadBundle =
+    jni::findClassStatic(EXECUTOR_BASECLASS)->getMethod<void(jstring)>("loadBundle");
 
   // The proxy ignores the script data passed in.
 
-  loadApplicationScript(
+  loadBundle(
     m_executor.get(),
     jni::make_jstring(sourceURL).get());
   // We can get pending calls here to native but the queue will be drained when

ReactAndroid/src/main/jni/react/jni/ProxyExecutor.h

@@ -35,7 +35,8 @@ class ProxyExecutor : public JSExecutor {
   ProxyExecutor(jni::global_ref<jobject>&& executorInstance,
                 std::shared_ptr<ExecutorDelegate> delegate);
   virtual ~ProxyExecutor() override;
-  virtual void loadApplicationScript(
+  virtual void initializeRuntime() override;
+  virtual void loadBundle(
     std::unique_ptr<const JSBigString> script,
     std::string sourceURL) override;
   virtual void setBundleRegistry(

ReactAndroid/src/test/java/com/facebook/react/devsupport/JSDebuggerWebSocketClientTest.java

@@ -39,7 +39,7 @@ public void test_prepareJSRuntime_ShouldSendCorrectMessage() throws Exception {
   }
 
   @Test
-  public void test_loadApplicationScript_ShouldSendCorrectMessage() throws Exception {
+  public void test_loadBundle_ShouldSendCorrectMessage() throws Exception {
     final JSDebuggerWebSocketClient.JSDebuggerCallback cb =
         PowerMockito.mock(JSDebuggerWebSocketClient.JSDebuggerCallback.class);
 
@@ -48,7 +48,7 @@ public void test_loadApplicationScript_ShouldSendCorrectMessage() throws Excepti
     injectedObjects.put("key1", "value1");
     injectedObjects.put("key2", "value2");
 
-    client.loadApplicationScript("http://localhost:8080/index.js", injectedObjects, cb);
+    client.loadBundle("http://localhost:8080/index.js", injectedObjects, cb);
     PowerMockito.verifyPrivate(client)
         .invoke(
             "sendMessage",

ReactCommon/cxxreact/Instance.cpp

@@ -46,7 +46,8 @@ void Instance::initializeBridge(
   jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
     nativeToJsBridge_ = folly::make_unique<NativeToJsBridge>(
         jsef.get(), moduleRegistry_, jsQueue, callback_);
-
+    // TODO investigate why it has to be async
+    nativeToJsBridge_->initializeRuntime();
     std::lock_guard<std::mutex> lock(m_syncMutex);
     m_syncReady = true;
     m_syncCV.notify_all();
@@ -55,33 +56,33 @@ void Instance::initializeBridge(
   CHECK(nativeToJsBridge_);
 }
 
-void Instance::loadApplication(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+void Instance::loadBundle(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
                                std::unique_ptr<const JSBigString> string,
                                std::string sourceURL) {
   callback_->incrementPendingJSCalls();
-  SystraceSection s("Instance::loadApplication", "sourceURL",
+  SystraceSection s("Instance::loadBundle", "sourceURL",
                     sourceURL);
-  nativeToJsBridge_->loadApplication(std::move(bundleRegistry), std::move(string),
+  nativeToJsBridge_->loadBundle(std::move(bundleRegistry), std::move(string),
                                      std::move(sourceURL));
 }
 
-void Instance::loadApplicationSync(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+void Instance::loadBundleSync(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
                                    std::unique_ptr<const JSBigString> string,
                                    std::string sourceURL) {
   std::unique_lock<std::mutex> lock(m_syncMutex);
   m_syncCV.wait(lock, [this] { return m_syncReady; });
 
-  SystraceSection s("Instance::loadApplicationSync", "sourceURL",
+  SystraceSection s("Instance::loadBundleSync", "sourceURL",
                     sourceURL);
-  nativeToJsBridge_->loadApplicationSync(std::move(bundleRegistry), std::move(string),
+  nativeToJsBridge_->loadBundleSync(std::move(bundleRegistry), std::move(string),
                                          std::move(sourceURL));
 }
 
 void Instance::setSourceURL(std::string sourceURL) {
   callback_->incrementPendingJSCalls();
   SystraceSection s("Instance::setSourceURL", "sourceURL", sourceURL);
 
-  nativeToJsBridge_->loadApplication(nullptr, nullptr, std::move(sourceURL));
+  nativeToJsBridge_->loadBundle(nullptr, nullptr, std::move(sourceURL));
 }
 
 void Instance::loadScriptFromString(std::unique_ptr<const JSBigString> string,
@@ -90,9 +91,9 @@ void Instance::loadScriptFromString(std::unique_ptr<const JSBigString> string,
   SystraceSection s("Instance::loadScriptFromString", "sourceURL",
                     sourceURL);
   if (loadSynchronously) {
-    loadApplicationSync(nullptr, std::move(string), std::move(sourceURL));
+    loadBundleSync(nullptr, std::move(string), std::move(sourceURL));
   } else {
-    loadApplication(nullptr, std::move(string), std::move(sourceURL));
+    loadBundle(nullptr, std::move(string), std::move(sourceURL));
   }
 }
 
@@ -144,10 +145,10 @@ void Instance::loadRAMBundle(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
                              std::string startupScriptSourceURL,
                              bool loadSynchronously) {
   if (loadSynchronously) {
-    loadApplicationSync(std::move(bundleRegistry), std::move(startupScript),
+    loadBundleSync(std::move(bundleRegistry), std::move(startupScript),
                         std::move(startupScriptSourceURL));
   } else {
-    loadApplication(std::move(bundleRegistry), std::move(startupScript),
+    loadBundle(std::move(bundleRegistry), std::move(startupScript),
                     std::move(startupScriptSourceURL));
   }
 }

ReactCommon/cxxreact/Instance.h

@@ -42,6 +42,8 @@ class RN_EXPORT Instance {
                         std::shared_ptr<MessageQueueThread> jsQueue,
                         std::shared_ptr<ModuleRegistry> moduleRegistry);
 
+  void initializeRuntime();
+
   void setSourceURL(std::string sourceURL);
 
   void loadScriptFromString(std::unique_ptr<const JSBigString> string,
@@ -77,10 +79,10 @@ class RN_EXPORT Instance {
 
 private:
   void callNativeModules(folly::dynamic &&calls, bool isEndOfBatch);
-  void loadApplication(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+  void loadBundle(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
                        std::unique_ptr<const JSBigString> startupScript,
                        std::string startupScriptSourceURL);
-  void loadApplicationSync(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+  void loadBundleSync(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
                            std::unique_ptr<const JSBigString> startupScript,
                            std::string startupScriptSourceURL);
 

ReactCommon/cxxreact/JSExecutor.h

@@ -51,10 +51,15 @@ class JSExecutorFactory {
 
 class RN_EXPORT JSExecutor {
 public:
+  /**
+   * Sets all globals in the JS context.
+   */
+  virtual void initializeRuntime() = 0;
+
   /**
    * Execute an application script bundle in the JS context.
    */
-  virtual void loadApplicationScript(std::unique_ptr<const JSBigString> script,
+  virtual void loadBundle(std::unique_ptr<const JSBigString> script,
                                      std::string sourceURL) = 0;
 
   /**

ReactCommon/cxxreact/NativeToJsBridge.cpp

@@ -100,7 +100,14 @@ NativeToJsBridge::~NativeToJsBridge() {
     "NativeToJsBridge::destroy() must be called before deallocating the NativeToJsBridge!";
 }
 
-void NativeToJsBridge::loadApplication(
+void NativeToJsBridge::initializeRuntime() {
+  runOnExecutorQueue([]
+    (JSExecutor* executor) mutable {
+      executor->initializeRuntime();
+    });
+}
+
+void NativeToJsBridge::loadBundle(
     std::unique_ptr<RAMBundleRegistry> bundleRegistry,
     std::unique_ptr<const JSBigString> startupScript,
     std::string startupScriptSourceURL) {
@@ -116,7 +123,7 @@ void NativeToJsBridge::loadApplication(
       executor->setBundleRegistry(std::move(bundleRegistry));
     }
     try {
-      executor->loadApplicationScript(std::move(*startupScript),
+      executor->loadBundle(std::move(*startupScript),
                                       std::move(startupScriptSourceURL));
     } catch (...) {
       m_applicationScriptHasFailure = true;
@@ -125,15 +132,15 @@ void NativeToJsBridge::loadApplication(
   });
 }
 
-void NativeToJsBridge::loadApplicationSync(
+void NativeToJsBridge::loadBundleSync(
     std::unique_ptr<RAMBundleRegistry> bundleRegistry,
     std::unique_ptr<const JSBigString> startupScript,
     std::string startupScriptSourceURL) {
   if (bundleRegistry) {
     m_executor->setBundleRegistry(std::move(bundleRegistry));
   }
   try {
-    m_executor->loadApplicationScript(std::move(startupScript),
+    m_executor->loadBundle(std::move(startupScript),
                                           std::move(startupScriptSourceURL));
   } catch (...) {
     m_applicationScriptHasFailure = true;

ReactCommon/cxxreact/NativeToJsBridge.h

@@ -29,7 +29,7 @@ class RAMBundleRegistry;
 // executors and their threads.  All functions here can be called from
 // any thread.
 //
-// Except for loadApplicationScriptSync(), all void methods will queue
+// Except for loadBundleSync(), all void methods will queue
 // work to run on the jsQueue passed to the ctor, and return
 // immediately.
 class NativeToJsBridge {
@@ -56,17 +56,22 @@ class NativeToJsBridge {
    * Invokes a callback with the cbID, and optional additional arguments in JS.
    */
   void invokeCallback(double callbackId, folly::dynamic&& args);
+
+  /**
+   * Sets global variables in the JS Context.
+   */
+  void initializeRuntime();
 
   /**
    * Starts the JS application.  If bundleRegistry is non-null, then it is
    * used to fetch JavaScript modules as individual scripts.
    * Otherwise, the script is assumed to include all the modules.
    */
-  void loadApplication(
+  void loadBundle(
     std::unique_ptr<RAMBundleRegistry> bundleRegistry,
     std::unique_ptr<const JSBigString> startupCode,
     std::string sourceURL);
-  void loadApplicationSync(
+  void loadBundleSync(
     std::unique_ptr<RAMBundleRegistry> bundleRegistry,
     std::unique_ptr<const JSBigString> startupCode,
     std::string sourceURL);

ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -67,13 +67,8 @@ JSIExecutor::JSIExecutor(
       *runtime, "__jsiExecutorDescription", runtime->description());
 }
 
-void JSIExecutor::loadApplicationScript(
-    std::unique_ptr<const JSBigString> script,
-    std::string sourceURL) {
-  SystraceSection s("JSIExecutor::loadApplicationScript");
-
-  // TODO: check for and use precompiled HBC
-
+void JSIExecutor::initializeRuntime() {
+  SystraceSection s("JSIExecutor::initializeRuntime");
   runtime_->global().setProperty(
       *runtime_,
       "nativeModuleProxy",
@@ -131,6 +126,18 @@ void JSIExecutor::loadApplicationScript(
   if (runtimeInstaller_) {
     runtimeInstaller_(*runtime_);
   }
+  bool hasLogger(ReactMarker::logTaggedMarker);
+  if (hasLogger) {
+    ReactMarker::logMarker(ReactMarker::CREATE_REACT_CONTEXT_STOP);
+  }
+}
+
+void JSIExecutor::loadBundle(
+    std::unique_ptr<const JSBigString> script,
+    std::string sourceURL) {
+  SystraceSection s("JSIExecutor::loadBundle");
+
+  // TODO: check for and use precompiled HBC
 
   bool hasLogger(ReactMarker::logTaggedMarker);
   std::string scriptName = simpleBasename(sourceURL);
@@ -142,7 +149,6 @@ void JSIExecutor::loadApplicationScript(
       std::make_unique<BigStringBuffer>(std::move(script)), sourceURL);
   flush();
   if (hasLogger) {
-    ReactMarker::logMarker(ReactMarker::CREATE_REACT_CONTEXT_STOP);
     ReactMarker::logTaggedMarker(
         ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
   }

ReactCommon/jsiexecutor/jsireact/JSIExecutor.h

@@ -75,7 +75,8 @@ class JSIExecutor : public JSExecutor {
       std::shared_ptr<ExecutorDelegate> delegate,
       const JSIScopedTimeoutInvoker &timeoutInvoker,
       RuntimeInstaller runtimeInstaller);
-  void loadApplicationScript(
+  void initializeRuntime() override;
+  void loadBundle(
       std::unique_ptr<const JSBigString> script,
       std::string sourceURL) override;
   void setBundleRegistry(std::unique_ptr<RAMBundleRegistry>) override;