react-native-tvos 0.72.6-1 → 0.73.0-0

package/ReactCommon/cxxreact/Instance.cpp

@@ -31,8 +31,7 @@
 #include <mutex>
 #include <string>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 Instance::~Instance() {
   if (nativeToJsBridge_) {
@@ -60,7 +59,7 @@ void Instance::initializeBridge(
      */
     jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
 
-    std::lock_guard<std::mutex> lock(m_syncMutex);
+    std::scoped_lock lock(m_syncMutex);
     m_syncReady = true;
     m_syncCV.notify_all();
   });
@@ -111,7 +110,7 @@ void Instance::loadScriptFromString(
 
 void Instance::loadRAMBundleFromString(
     std::unique_ptr<const JSBigString> script,
-    const std::string &sourceURL) {
+    const std::string& sourceURL) {
   auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
   auto startupScript = bundle->getStartupCode();
   auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
@@ -119,8 +118,8 @@ void Instance::loadRAMBundleFromString(
 }
 
 void Instance::loadRAMBundleFromFile(
-    const std::string &sourcePath,
-    const std::string &sourceURL,
+    const std::string& sourcePath,
+    const std::string& sourceURL,
     bool loadSynchronously) {
   auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
   auto startupScript = bundle->getStartupCode();
@@ -158,7 +157,7 @@ void Instance::setGlobalVariable(
       std::move(propName), std::move(jsonValue));
 }
 
-void *Instance::getJavaScriptContext() {
+void* Instance::getJavaScriptContext() {
   return nativeToJsBridge_ ? nativeToJsBridge_->getJavaScriptContext()
                            : nullptr;
 }
@@ -172,15 +171,15 @@ bool Instance::isBatchActive() {
 }
 
 void Instance::callJSFunction(
-    std::string &&module,
-    std::string &&method,
-    folly::dynamic &&params) {
+    std::string&& module,
+    std::string&& method,
+    folly::dynamic&& params) {
   callback_->incrementPendingJSCalls();
   nativeToJsBridge_->callFunction(
       std::move(module), std::move(method), std::move(params));
 }
 
-void Instance::callJSCallback(uint64_t callbackId, folly::dynamic &&params) {
+void Instance::callJSCallback(uint64_t callbackId, folly::dynamic&& params) {
   SystraceSection s("Instance::callJSCallback");
   callback_->incrementPendingJSCalls();
   nativeToJsBridge_->invokeCallback((double)callbackId, std::move(params));
@@ -188,15 +187,15 @@ void Instance::callJSCallback(uint64_t callbackId, folly::dynamic &&params) {
 
 void Instance::registerBundle(
     uint32_t bundleId,
-    const std::string &bundlePath) {
+    const std::string& bundlePath) {
   nativeToJsBridge_->registerBundle(bundleId, bundlePath);
 }
 
-const ModuleRegistry &Instance::getModuleRegistry() const {
+const ModuleRegistry& Instance::getModuleRegistry() const {
   return *moduleRegistry_;
 }
 
-ModuleRegistry &Instance::getModuleRegistry() {
+ModuleRegistry& Instance::getModuleRegistry() {
   return *moduleRegistry_;
 }
 
@@ -221,18 +220,18 @@ RuntimeExecutor Instance::getRuntimeExecutor() {
 
   std::weak_ptr<NativeToJsBridge> weakNativeToJsBridge = nativeToJsBridge_;
   return [weakNativeToJsBridge](
-             std::function<void(jsi::Runtime & runtime)> &&callback) {
+             std::function<void(jsi::Runtime & runtime)>&& callback) {
     if (auto strongNativeToJsBridge = weakNativeToJsBridge.lock()) {
       strongNativeToJsBridge->runOnExecutorQueue(
-          [callback = std::move(callback)](JSExecutor *executor) {
+          [callback = std::move(callback)](JSExecutor* executor) {
             // Assumes the underlying executor is a JSIExecutor
-            jsi::Runtime *runtime =
-                (jsi::Runtime *)executor->getJavaScriptContext();
+            jsi::Runtime* runtime =
+                (jsi::Runtime*)executor->getJavaScriptContext();
             try {
               react_native_assert(runtime != nullptr);
               callback(*runtime);
               executor->flush();
-            } catch (jsi::JSError &originalError) {
+            } catch (jsi::JSError& originalError) {
               handleJSError(*runtime, originalError, true);
             }
           });
@@ -240,14 +239,16 @@ RuntimeExecutor Instance::getRuntimeExecutor() {
   };
 }
 
-std::shared_ptr<CallInvoker> Instance::getDecoratedNativeCallInvoker(
-    std::shared_ptr<CallInvoker> nativeInvoker) {
-  return nativeToJsBridge_->getDecoratedNativeCallInvoker(nativeInvoker);
+std::shared_ptr<NativeMethodCallInvoker>
+Instance::getDecoratedNativeMethodCallInvoker(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) {
+  return nativeToJsBridge_->getDecoratedNativeMethodCallInvoker(
+      nativeMethodCallInvoker);
 }
 
 void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
     std::weak_ptr<NativeToJsBridge> nativeToJsBridge) {
-  std::lock_guard<std::mutex> guard(m_mutex);
+  std::scoped_lock guard(m_mutex);
 
   m_shouldBuffer = false;
   m_nativeToJsBridge = nativeToJsBridge;
@@ -257,14 +258,14 @@ void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
   }
 }
 
-void Instance::JSCallInvoker::invokeSync(std::function<void()> &&work) {
+void Instance::JSCallInvoker::invokeSync(std::function<void()>&& work) {
   // TODO: Replace JS Callinvoker with RuntimeExecutor.
   throw std::runtime_error(
       "Synchronous native -> JS calls are currently not supported.");
 }
 
-void Instance::JSCallInvoker::invokeAsync(std::function<void()> &&work) {
-  std::lock_guard<std::mutex> guard(m_mutex);
+void Instance::JSCallInvoker::invokeAsync(std::function<void()>&& work) {
+  std::scoped_lock guard(m_mutex);
 
   /**
    * Why is is necessary to queue up async work?
@@ -288,15 +289,14 @@ void Instance::JSCallInvoker::invokeAsync(std::function<void()> &&work) {
   scheduleAsync(std::move(work));
 }
 
-void Instance::JSCallInvoker::scheduleAsync(std::function<void()> &&work) {
+void Instance::JSCallInvoker::scheduleAsync(std::function<void()>&& work) {
   if (auto strongNativeToJsBridge = m_nativeToJsBridge.lock()) {
     strongNativeToJsBridge->runOnExecutorQueue(
-        [work = std::move(work)](JSExecutor *executor) {
+        [work = std::move(work)](JSExecutor* executor) {
           work();
           executor->flush();
         });
   }
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/Instance.h

@@ -23,8 +23,7 @@ namespace folly {
 struct dynamic;
 }
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class JSBigString;
 class JSExecutorFactory;
@@ -58,10 +57,10 @@ class RN_EXPORT Instance {
       bool loadSynchronously);
   void loadRAMBundleFromString(
       std::unique_ptr<const JSBigString> script,
-      const std::string &sourceURL);
+      const std::string& sourceURL);
   void loadRAMBundleFromFile(
-      const std::string &sourcePath,
-      const std::string &sourceURL,
+      const std::string& sourcePath,
+      const std::string& sourceURL,
       bool loadSynchronously);
   void loadRAMBundle(
       std::unique_ptr<RAMBundleRegistry> bundleRegistry,
@@ -72,20 +71,20 @@ class RN_EXPORT Instance {
   void setGlobalVariable(
       std::string propName,
       std::unique_ptr<const JSBigString> jsonValue);
-  void *getJavaScriptContext();
+  void* getJavaScriptContext();
   bool isInspectable();
   bool isBatchActive();
   void callJSFunction(
-      std::string &&module,
-      std::string &&method,
-      folly::dynamic &&params);
-  void callJSCallback(uint64_t callbackId, folly::dynamic &&params);
+      std::string&& module,
+      std::string&& method,
+      folly::dynamic&& params);
+  void callJSCallback(uint64_t callbackId, folly::dynamic&& params);
 
   // This method is experimental, and may be modified or removed.
-  void registerBundle(uint32_t bundleId, const std::string &bundlePath);
+  void registerBundle(uint32_t bundleId, const std::string& bundlePath);
 
-  const ModuleRegistry &getModuleRegistry() const;
-  ModuleRegistry &getModuleRegistry();
+  const ModuleRegistry& getModuleRegistry() const;
+  ModuleRegistry& getModuleRegistry();
 
   void handleMemoryPressure(int pressureLevel);
 
@@ -102,10 +101,10 @@ class RN_EXPORT Instance {
   std::shared_ptr<CallInvoker> getJSCallInvoker();
 
   /**
-   * Native CallInvoker is used by TurboModules to schedule work on the
+   * NativeMethodCallInvoker is used by TurboModules to schedule work on the
    * NativeModule thread(s).
    *
-   * Why is the bridge decorating native CallInvoker?
+   * Why is the bridge decorating NativeMethodCallInvoker?
    *
    * - The bridge must be informed of all TurboModule async method calls. Why?
    *   When all queued NativeModule method calls are flushed by a call from
@@ -117,16 +116,16 @@ class RN_EXPORT Instance {
    *   since the last time the bridge was flushed. If this number is non-zero,
    *   we fire onBatchComplete.
    *
-   * Why can't we just create and return a new native CallInvoker?
+   * Why can't we just create and return a new NativeMethodCallInvoker?
    *
    * - On Android, we have one NativeModule thread. That thread is created and
    *   managed outside of NativeToJsBridge. On iOS, we have one MethodQueue per
    *   module. Those MethodQueues are also created and managed outside of
-   *   NativeToJsBridge. Therefore, we need to pass in a CallInvoker that
-   *   schedules work on the respective thread.
+   *   NativeToJsBridge. Therefore, we need to pass in a
+   * NativeMethodCallInvoker that schedules work on the respective thread.
    */
-  std::shared_ptr<CallInvoker> getDecoratedNativeCallInvoker(
-      std::shared_ptr<CallInvoker> nativeInvoker);
+  std::shared_ptr<NativeMethodCallInvoker> getDecoratedNativeMethodCallInvoker(
+      std::shared_ptr<NativeMethodCallInvoker> nativeInvoker);
 
   /**
    * RuntimeExecutor is used by Fabric to access the jsi::Runtime.
@@ -134,7 +133,7 @@ class RN_EXPORT Instance {
   RuntimeExecutor getRuntimeExecutor();
 
  private:
-  void callNativeModules(folly::dynamic &&calls, bool isEndOfBatch);
+  void callNativeModules(folly::dynamic&& calls, bool isEndOfBatch);
   void loadBundle(
       std::unique_ptr<RAMBundleRegistry> bundleRegistry,
       std::unique_ptr<const JSBigString> startupScript,
@@ -159,18 +158,17 @@ class RN_EXPORT Instance {
     bool m_shouldBuffer = true;
     std::list<std::function<void()>> m_workBuffer;
 
-    void scheduleAsync(std::function<void()> &&work);
+    void scheduleAsync(std::function<void()>&& work);
 
    public:
     void setNativeToJsBridgeAndFlushCalls(
         std::weak_ptr<NativeToJsBridge> nativeToJsBridge);
-    void invokeAsync(std::function<void()> &&work) override;
-    void invokeSync(std::function<void()> &&work) override;
+    void invokeAsync(std::function<void()>&& work) override;
+    void invokeSync(std::function<void()>&& work) override;
   };
 
   std::shared_ptr<JSCallInvoker> jsCallInvoker_ =
       std::make_shared<JSCallInvoker>();
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSBigString.cpp

@@ -10,7 +10,6 @@
 #include <glog/logging.h>
 
 #include <folly/Memory.h>
-#include <folly/ScopeGuard.h>
 #include <folly/portability/Fcntl.h>
 #include <folly/portability/SysMman.h>
 #include <folly/portability/SysStat.h>
@@ -18,12 +17,18 @@
 
 #include <memory>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 JSBigFileString::JSBigFileString(int fd, size_t size, off_t offset /*= 0*/)
     : m_fd{-1}, m_data{nullptr} {
-  folly::checkUnixError(m_fd = dup(fd), "Could not duplicate file descriptor");
+  m_fd = dup(fd);
+
+  if (m_fd == -1) {
+    const char* message =
+        "JSBigFileString::JSBigFileString - Could not duplicate file descriptor";
+    LOG(ERROR) << message;
+    throw std::runtime_error(message);
+  }
 
   // Offsets given to mmap must be page aligned. We abstract away that
   // restriction by sending a page aligned offset to mmap, and keeping track
@@ -45,18 +50,18 @@ JSBigFileString::JSBigFileString(int fd, size_t size, off_t offset /*= 0*/)
 
 JSBigFileString::~JSBigFileString() {
   if (m_data) {
-    munmap((void *)m_data, m_size);
+    munmap((void*)m_data, m_size);
   }
   close(m_fd);
 }
 
-const char *JSBigFileString::c_str() const {
+const char* JSBigFileString::c_str() const {
   if (m_size == 0) {
     return "";
   }
   if (!m_data) {
     m_data =
-        (const char *)mmap(0, m_size, PROT_READ, MAP_PRIVATE, m_fd, m_mapOff);
+        (const char*)mmap(0, m_size, PROT_READ, MAP_PRIVATE, m_fd, m_mapOff);
     CHECK(m_data != MAP_FAILED)
         << " fd: " << m_fd << " size: " << m_size << " offset: " << m_mapOff
         << " error: " << std::strerror(errno);
@@ -64,7 +69,7 @@ const char *JSBigFileString::c_str() const {
   static const size_t kMinPageSize = 4096;
   CHECK(!(reinterpret_cast<uintptr_t>(m_data) & (kMinPageSize - 1)))
       << "mmap address misaligned, likely corrupted"
-      << " m_data: " << (const void *)m_data;
+      << " m_data: " << (const void*)m_data;
   CHECK(m_pageOff <= m_size)
       << "offset impossibly large, likely corrupted"
       << " m_pageOff: " << m_pageOff << " m_size: " << m_size;
@@ -82,18 +87,31 @@ int JSBigFileString::fd() const {
 }
 
 std::unique_ptr<const JSBigFileString> JSBigFileString::fromPath(
-    const std::string &sourceURL) {
+    const std::string& sourceURL) {
   int fd = ::open(sourceURL.c_str(), O_RDONLY);
-  folly::checkUnixError(fd, "Could not open file", sourceURL);
-  SCOPE_EXIT {
-    CHECK(::close(fd) == 0);
-  };
 
-  struct stat fileInfo;
-  folly::checkUnixError(::fstat(fd, &fileInfo), "fstat on bundle failed.");
+  if (fd == -1) {
+    const std::string message =
+        std::string("JSBigFileString::fromPath - Could not open file: ") +
+        sourceURL;
+    LOG(ERROR) << message;
+    throw std::runtime_error(message.c_str());
+  }
+
+  struct stat fileInfo {};
+  int res = ::fstat(fd, &fileInfo);
+
+  if (res == -1) {
+    const std::string message =
+        "JSBigFileString::fromPath - fstat on bundle failed: " + sourceURL;
+    LOG(ERROR) << message;
+    ::close(fd);
+    throw std::runtime_error(message.c_str());
+  }
 
-  return std::make_unique<const JSBigFileString>(fd, fileInfo.st_size);
+  auto ptr = std::make_unique<const JSBigFileString>(fd, fileInfo.st_size);
+  CHECK(::close(fd) == 0);
+  return ptr;
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSBigString.h

@@ -17,8 +17,7 @@
 #endif
 #endif
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 // JSExecutor functions sometimes take large strings, on the order of
 // megabytes.  Copying these can be expensive.  Introducing a
@@ -32,15 +31,15 @@ class JSBigString {
   JSBigString() = default;
 
   // Not copyable
-  JSBigString(const JSBigString &) = delete;
-  JSBigString &operator=(const JSBigString &) = delete;
+  JSBigString(const JSBigString&) = delete;
+  JSBigString& operator=(const JSBigString&) = delete;
 
   virtual ~JSBigString() {}
 
   virtual bool isAscii() const = 0;
 
   // This needs to be a \0 terminated string
-  virtual const char *c_str() const = 0;
+  virtual const char* c_str() const = 0;
 
   // Length of the c_str without the NULL byte.
   virtual size_t size() const = 0;
@@ -57,7 +56,7 @@ class JSBigStdString : public JSBigString {
     return m_isAscii;
   }
 
-  const char *c_str() const override {
+  const char* c_str() const override {
     return m_str.c_str();
   }
 
@@ -90,7 +89,7 @@ class RN_EXPORT JSBigBufferString : public JSBigString {
     return true;
   }
 
-  const char *c_str() const override {
+  const char* c_str() const override {
     return m_data;
   }
 
@@ -98,12 +97,12 @@ class RN_EXPORT JSBigBufferString : public JSBigString {
     return m_size;
   }
 
-  char *data() {
+  char* data() {
     return m_data;
   }
 
  private:
-  char *m_data;
+  char* m_data;
   size_t m_size;
 };
 
@@ -117,21 +116,20 @@ class RN_EXPORT JSBigFileString : public JSBigString {
     return true;
   }
 
-  const char *c_str() const override;
+  const char* c_str() const override;
 
   size_t size() const override;
   int fd() const;
 
   static std::unique_ptr<const JSBigFileString> fromPath(
-      const std::string &sourceURL);
+      const std::string& sourceURL);
 
  private:
   int m_fd; // The file descriptor being mmapped
   size_t m_size; // The size of the mmapped region
   mutable off_t m_pageOff; // The offset in the mmapped region to the data.
   off_t m_mapOff; // The offset in the file to the mmapped region.
-  mutable const char *m_data; // Pointer to the mmapped region.
+  mutable const char* m_data; // Pointer to the mmapped region.
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSBundleType.cpp

@@ -7,41 +7,34 @@
 
 #include "JSBundleType.h"
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 static uint32_t constexpr RAMBundleMagicNumber = 0xFB0BD1E5;
-static uint32_t constexpr MetroHBCBundleMagicNumber = 0xFFE7C3C3;
 
 // "Hermes" in ancient Greek encoded in UTF-16BE and truncated to 8 bytes.
 static uint64_t constexpr HermesBCBundleMagicNumber = 0x1F1903C103BC1FC6;
 
-ScriptTag parseTypeFromHeader(const BundleHeader &header) {
+ScriptTag parseTypeFromHeader(const BundleHeader& header) {
   switch (header.magic32.value) {
     case RAMBundleMagicNumber:
       return ScriptTag::RAMBundle;
-    case MetroHBCBundleMagicNumber:
-      return ScriptTag::MetroHBCBundle;
     default:
       return ScriptTag::String;
   }
 }
 
-const char *stringForScriptTag(const ScriptTag &tag) {
+const char* stringForScriptTag(const ScriptTag& tag) {
   switch (tag) {
     case ScriptTag::String:
       return "String";
     case ScriptTag::RAMBundle:
       return "RAM Bundle";
-    case ScriptTag::MetroHBCBundle:
-      return "Metro Hermes Bytecode Bundle";
   }
   return "";
 }
 
-bool isHermesBytecodeBundle(const BundleHeader &header) {
+bool isHermesBytecodeBundle(const BundleHeader& header) {
   return header.magic64 == HermesBCBundleMagicNumber;
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSBundleType.h

@@ -15,8 +15,7 @@
 #define RN_EXPORT __attribute__((visibility("default")))
 #endif
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Scripts given to the JS Executors to run could be in any of the following
@@ -27,7 +26,6 @@ namespace react {
 enum struct ScriptTag {
   String = 0,
   RAMBundle,
-  MetroHBCBundle,
 };
 
 /**
@@ -59,18 +57,17 @@ FOLLY_PACK_POP
  * Takes the first 8 bytes of a bundle, and returns a tag describing the
  * bundle's format.
  */
-RN_EXPORT ScriptTag parseTypeFromHeader(const BundleHeader &header);
+RN_EXPORT ScriptTag parseTypeFromHeader(const BundleHeader& header);
 
 /**
  * Convert an `ScriptTag` enum into a string, useful for emitting in errors
  * and diagnostic messages.
  */
-RN_EXPORT const char *stringForScriptTag(const ScriptTag &tag);
+RN_EXPORT const char* stringForScriptTag(const ScriptTag& tag);
 
 /**
  * Check whether a given bundle is hermesc-generated bytecode
  */
-RN_EXPORT bool isHermesBytecodeBundle(const BundleHeader &header);
+RN_EXPORT bool isHermesBytecodeBundle(const BundleHeader& header);
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSExecutor.cpp

@@ -13,12 +13,11 @@
 
 #include <chrono>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 std::string JSExecutor::getSyntheticBundlePath(
     uint32_t bundleId,
-    const std::string &bundlePath) {
+    const std::string& bundlePath) {
   if (bundleId == RAMBundleRegistry::MAIN_BUNDLE_ID) {
     return bundlePath;
   }
@@ -35,5 +34,4 @@ double JSExecutor::performanceNow() {
   return duration / NANOSECONDS_IN_MILLISECOND;
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/cxxreact/JSExecutor.h

@@ -17,8 +17,7 @@
 #define RN_EXPORT __attribute__((visibility("default")))
 #endif
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class JSBigString;
 class JSExecutor;
@@ -36,18 +35,18 @@ class ExecutorDelegate {
   virtual std::shared_ptr<ModuleRegistry> getModuleRegistry() = 0;
 
   virtual void callNativeModules(
-      JSExecutor &executor,
-      folly::dynamic &&calls,
+      JSExecutor& executor,
+      folly::dynamic&& calls,
       bool isEndOfBatch) = 0;
   virtual MethodCallResult callSerializableNativeHook(
-      JSExecutor &executor,
+      JSExecutor& executor,
       unsigned int moduleId,
       unsigned int methodId,
-      folly::dynamic &&args) = 0;
+      folly::dynamic&& args) = 0;
 };
 
 using NativeExtensionsProvider =
-    std::function<folly::dynamic(const std::string &)>;
+    std::function<folly::dynamic(const std::string&)>;
 
 class JSExecutorFactory {
  public:
@@ -82,7 +81,7 @@ class RN_EXPORT JSExecutor {
    */
   virtual void registerBundle(
       uint32_t bundleId,
-      const std::string &bundlePath) = 0;
+      const std::string& bundlePath) = 0;
 
   /**
    * Executes BatchedBridge.callFunctionReturnFlushedQueue with the module ID,
@@ -91,9 +90,9 @@ class RN_EXPORT JSExecutor {
    * native modules methods.
    */
   virtual void callFunction(
-      const std::string &moduleId,
-      const std::string &methodId,
-      const folly::dynamic &arguments) = 0;
+      const std::string& moduleId,
+      const std::string& methodId,
+      const folly::dynamic& arguments) = 0;
 
   /**
    * Executes BatchedBridge.invokeCallbackAndReturnFlushedQueue with the cbID,
@@ -103,13 +102,13 @@ class RN_EXPORT JSExecutor {
    */
   virtual void invokeCallback(
       const double callbackId,
-      const folly::dynamic &arguments) = 0;
+      const folly::dynamic& arguments) = 0;
 
   virtual void setGlobalVariable(
       std::string propName,
       std::unique_ptr<const JSBigString> jsonValue) = 0;
 
-  virtual void *getJavaScriptContext() {
+  virtual void* getJavaScriptContext() {
     return nullptr;
   }
 
@@ -137,10 +136,9 @@ class RN_EXPORT JSExecutor {
 
   static std::string getSyntheticBundlePath(
       uint32_t bundleId,
-      const std::string &bundlePath);
+      const std::string& bundlePath);
 
   static double performanceNow();
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react