Replace folly::make_unique with std::make_unique (#26730)

Summary: There is a mixed usage of `folly::make_unique` and `std::make_unique`. Soon, `folly::make_unique` may be removed (see [this PR](https://github.com/facebook/folly/pull/1150)). Since `react-native` only supports C++14-compilers and later, switch to always using `std::make_unique`. ## Changelog [Internal] [Removed] - Replace folly::make_unique with std::make_unique Pull Request resolved: https://github.com/facebook/react-native/pull/26730 Test Plan: Running the existing test suite. No change in behavior is expected. Joshua Gross: buck install -r fb4a, make sure MP Home and forced teardown works okay on android Reviewed By: shergin Differential Revision: D18062400 Pulled By: JoshuaGross fbshipit-source-id: 978ca794c7e972db872a8dcc57c31bdec7451481
2025-11-01 09:14:26 +00:00 · 2019-10-22 12:21:41 -07:00
parent 468d1a2d2e
commit ba18ee9b87
20 changed files with 412 additions and 341 deletions
@@ -18,7 +18,6 @@
 #include "SystraceSection.h"

 #include <cxxreact/JSIndexedRAMBundle.h>
-#include <folly/Memory.h>
 #include <folly/MoveWrapper.h>
 #include <folly/json.h>

@@ -26,6 +25,7 @@

 #include <condition_variable>
 #include <fstream>
+#include <memory>
 #include <mutex>
 #include <string>

@@ -46,7 +46,7 @@ void Instance::initializeBridge(
  callback_ = std::move(callback);
  moduleRegistry_ = std::move(moduleRegistry);
  jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
-    nativeToJsBridge_ = folly::make_unique<NativeToJsBridge>(
+    nativeToJsBridge_ = std::make_unique<NativeToJsBridge>(
        jsef.get(), moduleRegistry_, jsQueue, callback_);

    std::lock_guard<std::mutex> lock(m_syncMutex);
@@ -57,26 +57,26 @@ void Instance::initializeBridge(
  CHECK(nativeToJsBridge_);
 }

-void Instance::loadApplication(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-                               std::unique_ptr<const JSBigString> string,
-                               std::string sourceURL) {
+void Instance::loadApplication(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL) {
  callback_->incrementPendingJSCalls();
-  SystraceSection s("Instance::loadApplication", "sourceURL",
-                    sourceURL);
-  nativeToJsBridge_->loadApplication(std::move(bundleRegistry), std::move(string),
-                                     std::move(sourceURL));
+  SystraceSection s("Instance::loadApplication", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadApplication(
+      std::move(bundleRegistry), std::move(string), std::move(sourceURL));
 }

-void Instance::loadApplicationSync(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-                                   std::unique_ptr<const JSBigString> string,
-                                   std::string sourceURL) {
+void Instance::loadApplicationSync(
+    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",
-                    sourceURL);
-  nativeToJsBridge_->loadApplicationSync(std::move(bundleRegistry), std::move(string),
-                                         std::move(sourceURL));
+  SystraceSection s("Instance::loadApplicationSync", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadApplicationSync(
+      std::move(bundleRegistry), std::move(string), std::move(sourceURL));
 }

 void Instance::setSourceURL(std::string sourceURL) {
@@ -86,11 +86,11 @@ void Instance::setSourceURL(std::string sourceURL) {
  nativeToJsBridge_->loadApplication(nullptr, nullptr, std::move(sourceURL));
 }

-void Instance::loadScriptFromString(std::unique_ptr<const JSBigString> string,
-                                    std::string sourceURL,
-                                    bool loadSynchronously) {
-  SystraceSection s("Instance::loadScriptFromString", "sourceURL",
-                    sourceURL);
+void Instance::loadScriptFromString(
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL,
+    bool loadSynchronously) {
+  SystraceSection s("Instance::loadScriptFromString", "sourceURL", sourceURL);
  if (loadSynchronously) {
    loadApplicationSync(nullptr, std::move(string), std::move(sourceURL));
  } else {
@@ -110,54 +110,63 @@ bool Instance::isIndexedRAMBundle(const char *sourcePath) {
  return parseTypeFromHeader(header) == ScriptTag::RAMBundle;
 }

-bool Instance::isIndexedRAMBundle(std::unique_ptr<const JSBigString>* script) {
+bool Instance::isIndexedRAMBundle(std::unique_ptr<const JSBigString> *script) {
  BundleHeader header;
-  strncpy(reinterpret_cast<char *>(&header), script->get()->c_str(), sizeof(header));
+  strncpy(
+      reinterpret_cast<char *>(&header),
+      script->get()->c_str(),
+      sizeof(header));

  return parseTypeFromHeader(header) == ScriptTag::RAMBundle;
 }

-void Instance::loadRAMBundleFromString(std::unique_ptr<const JSBigString> script, const std::string& sourceURL) {
-  auto bundle = folly::make_unique<JSIndexedRAMBundle>(std::move(script));
+void Instance::loadRAMBundleFromString(
+    std::unique_ptr<const JSBigString> script,
+    const std::string &sourceURL) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
  auto startupScript = bundle->getStartupCode();
  auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
-  loadRAMBundle(
-    std::move(registry),
-    std::move(startupScript),
-    sourceURL,
-    true);
+  loadRAMBundle(std::move(registry), std::move(startupScript), sourceURL, true);
 }

-void Instance::loadRAMBundleFromFile(const std::string& sourcePath,
-                           const std::string& sourceURL,
-                           bool loadSynchronously) {
-    auto bundle = folly::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
-    auto startupScript = bundle->getStartupCode();
-    auto registry = RAMBundleRegistry::multipleBundlesRegistry(std::move(bundle), JSIndexedRAMBundle::buildFactory());
-    loadRAMBundle(
+void Instance::loadRAMBundleFromFile(
+    const std::string &sourcePath,
+    const std::string &sourceURL,
+    bool loadSynchronously) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
+  auto startupScript = bundle->getStartupCode();
+  auto registry = RAMBundleRegistry::multipleBundlesRegistry(
+      std::move(bundle), JSIndexedRAMBundle::buildFactory());
+  loadRAMBundle(
      std::move(registry),
      std::move(startupScript),
      sourceURL,
      loadSynchronously);
 }

-void Instance::loadRAMBundle(std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-                             std::unique_ptr<const JSBigString> startupScript,
-                             std::string startupScriptSourceURL,
-                             bool loadSynchronously) {
+void Instance::loadRAMBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string startupScriptSourceURL,
+    bool loadSynchronously) {
  if (loadSynchronously) {
-    loadApplicationSync(std::move(bundleRegistry), std::move(startupScript),
-                        std::move(startupScriptSourceURL));
+    loadApplicationSync(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
  } else {
-    loadApplication(std::move(bundleRegistry), std::move(startupScript),
-                    std::move(startupScriptSourceURL));
+    loadApplication(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
  }
 }

-void Instance::setGlobalVariable(std::string propName,
-                                 std::unique_ptr<const JSBigString> jsonValue) {
-  nativeToJsBridge_->setGlobalVariable(std::move(propName),
-                                       std::move(jsonValue));
+void Instance::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {
+  nativeToJsBridge_->setGlobalVariable(
+      std::move(propName), std::move(jsonValue));
 }

 void *Instance::getJavaScriptContext() {
@@ -168,16 +177,18 @@ void *Instance::getJavaScriptContext() {
 bool Instance::isInspectable() {
  return nativeToJsBridge_ ? nativeToJsBridge_->isInspectable() : false;
 }
-  
+
 bool Instance::isBatchActive() {
  return nativeToJsBridge_ ? nativeToJsBridge_->isBatchActive() : false;
 }

-void Instance::callJSFunction(std::string &&module, std::string &&method,
-                              folly::dynamic &&params) {
+void Instance::callJSFunction(
+    std::string &&module,
+    std::string &&method,
+    folly::dynamic &&params) {
  callback_->incrementPendingJSCalls();
-  nativeToJsBridge_->callFunction(std::move(module), std::move(method),
-                                  std::move(params));
+  nativeToJsBridge_->callFunction(
+      std::move(module), std::move(method), std::move(params));
 }

 void Instance::callJSCallback(uint64_t callbackId, folly::dynamic &&params) {
@@ -186,7 +197,9 @@ void Instance::callJSCallback(uint64_t callbackId, folly::dynamic &&params) {
  nativeToJsBridge_->invokeCallback((double)callbackId, std::move(params));
 }

-void Instance::registerBundle(uint32_t bundleId, const std::string& bundlePath) {
+void Instance::registerBundle(
+    uint32_t bundleId,
+    const std::string &bundlePath) {
  nativeToJsBridge_->registerBundle(bundleId, bundlePath);
 }

@@ -194,17 +207,20 @@ const ModuleRegistry &Instance::getModuleRegistry() const {
  return *moduleRegistry_;
 }

-ModuleRegistry &Instance::getModuleRegistry() { return *moduleRegistry_; }
+ModuleRegistry &Instance::getModuleRegistry() {
+  return *moduleRegistry_;
+}

 void Instance::handleMemoryPressure(int pressureLevel) {
  nativeToJsBridge_->handleMemoryPressure(pressureLevel);
 }

-void Instance::invokeAsync(std::function<void()>&& func) {
-  nativeToJsBridge_->runOnExecutorQueue([func=std::move(func)](JSExecutor *executor) {
-    func();
-    executor->flush();
-  });
+void Instance::invokeAsync(std::function<void()> &&func) {
+  nativeToJsBridge_->runOnExecutorQueue(
+      [func = std::move(func)](JSExecutor *executor) {
+        func();
+        executor->flush();
+      });
 }

 } // namespace react