react-native-tvos 0.79.3-0 → 0.80.0-0

package/ReactCommon/jsinspector-modern/tracing/TraceEventProfile.h

@@ -9,8 +9,6 @@
 
 #include <folly/dynamic.h>
 
-#include <utility>
-
 namespace facebook::react::jsinspector_modern::tracing {
 
 /// Arbitrary data structure, which represents payload of the "ProfileChunk"
@@ -19,21 +17,11 @@ struct TraceEventProfileChunk {
   /// Deltas between timestamps of chronolocigally sorted samples.
   /// Will be sent as part of the "ProfileChunk" trace event.
   struct TimeDeltas {
-   public:
-    explicit TimeDeltas(std::vector<long long> deltas)
-        : deltas_(std::move(deltas)) {}
-
-    folly::dynamic asDynamic() const {
-      folly::dynamic value = folly::dynamic::array();
-      for (auto delta : deltas_) {
-        value.push_back(delta);
-      }
-
-      return value;
+    folly::dynamic toDynamic() const {
+      return folly::dynamic::array(deltas.begin(), deltas.end());
     }
 
-   private:
-    std::vector<long long> deltas_;
+    std::vector<long long> deltas;
   };
 
   /// Contains Profile information that will be emitted in this chunk: nodes and
@@ -45,113 +33,73 @@ struct TraceEventProfileChunk {
     struct Node {
       /// Unique call frame in the call stack.
       struct CallFrame {
-       public:
-        CallFrame(
-            std::string codeType,
-            uint32_t scriptId,
-            std::string functionName,
-            std::optional<std::string> url = std::nullopt,
-            std::optional<uint32_t> lineNumber = std::nullopt,
-            std::optional<uint32_t> columnNumber = std::nullopt)
-            : codeType_(std::move(codeType)),
-              scriptId_(scriptId),
-              functionName_(std::move(functionName)),
-              url_(std::move(url)),
-              lineNumber_(lineNumber),
-              columnNumber_(columnNumber) {}
-
-        folly::dynamic asDynamic() const {
+        folly::dynamic toDynamic() const {
           folly::dynamic dynamicCallFrame = folly::dynamic::object();
-          dynamicCallFrame["codeType"] = codeType_;
-          dynamicCallFrame["scriptId"] = scriptId_;
-          dynamicCallFrame["functionName"] = functionName_;
-          if (url_.has_value()) {
-            dynamicCallFrame["url"] = url_.value();
+          dynamicCallFrame["codeType"] = codeType;
+          dynamicCallFrame["scriptId"] = scriptId;
+          dynamicCallFrame["functionName"] = functionName;
+          if (url.has_value()) {
+            dynamicCallFrame["url"] = url.value();
           }
-          if (lineNumber_.has_value()) {
-            dynamicCallFrame["lineNumber"] = lineNumber_.value();
+          if (lineNumber.has_value()) {
+            dynamicCallFrame["lineNumber"] = lineNumber.value();
           }
-          if (columnNumber_.has_value()) {
-            dynamicCallFrame["columnNumber"] = columnNumber_.value();
+          if (columnNumber.has_value()) {
+            dynamicCallFrame["columnNumber"] = columnNumber.value();
           }
 
           return dynamicCallFrame;
         }
 
-       private:
-        std::string codeType_;
-        uint32_t scriptId_;
-        std::string functionName_;
-        std::optional<std::string> url_;
-        std::optional<uint32_t> lineNumber_;
-        std::optional<uint32_t> columnNumber_;
+        std::string codeType;
+        uint32_t scriptId;
+        std::string functionName;
+        std::optional<std::string> url;
+        std::optional<uint32_t> lineNumber;
+        std::optional<uint32_t> columnNumber;
       };
 
-     public:
-      Node(
-          uint32_t id,
-          CallFrame callFrame,
-          std::optional<uint32_t> parentId = std::nullopt)
-          : id_(id), callFrame_(std::move(callFrame)), parentId_(parentId) {}
-
-      folly::dynamic asDynamic() const {
+      folly::dynamic toDynamic() const {
         folly::dynamic dynamicNode = folly::dynamic::object();
 
-        dynamicNode["callFrame"] = callFrame_.asDynamic();
-        dynamicNode["id"] = id_;
-        if (parentId_.has_value()) {
-          dynamicNode["parent"] = parentId_.value();
+        dynamicNode["callFrame"] = callFrame.toDynamic();
+        dynamicNode["id"] = id;
+        if (parentId.has_value()) {
+          dynamicNode["parent"] = parentId.value();
         }
 
         return dynamicNode;
       }
 
-     private:
-      uint32_t id_;
-      CallFrame callFrame_;
-      std::optional<uint32_t> parentId_;
+      uint32_t id;
+      CallFrame callFrame;
+      std::optional<uint32_t> parentId;
     };
 
-   public:
-    CPUProfile(std::vector<Node> nodes, std::vector<uint32_t> samples)
-        : nodes_(std::move(nodes)), samples_(std::move(samples)) {}
-
-    folly::dynamic asDynamic() const {
+    folly::dynamic toDynamic() const {
       folly::dynamic dynamicNodes = folly::dynamic::array();
-      for (const auto& node : nodes_) {
-        dynamicNodes.push_back(node.asDynamic());
-      }
-
-      folly::dynamic dynamicSamples = folly::dynamic::array();
-      for (auto sample : samples_) {
-        dynamicSamples.push_back(sample);
+      dynamicNodes.reserve(nodes.size());
+      for (const auto& node : nodes) {
+        dynamicNodes.push_back(node.toDynamic());
       }
+      folly::dynamic dynamicSamples =
+          folly::dynamic::array(samples.begin(), samples.end());
 
       return folly::dynamic::object("nodes", dynamicNodes)(
           "samples", dynamicSamples);
     }
 
-   private:
-    std::vector<Node> nodes_;
-    std::vector<uint32_t> samples_;
+    std::vector<Node> nodes;
+    std::vector<uint32_t> samples;
   };
 
- public:
-  TraceEventProfileChunk(CPUProfile cpuProfile, TimeDeltas timeDeltas)
-      : cpuProfile_(std::move(cpuProfile)),
-        timeDeltas_(std::move(timeDeltas)) {}
-
-  folly::dynamic asDynamic() const {
-    folly::dynamic value = folly::dynamic::object;
-    value["cpuProfile"] = cpuProfile_.asDynamic();
-    value["timeDeltas"] = timeDeltas_.asDynamic();
-
-    return value;
+  folly::dynamic toDynamic() const {
+    return folly::dynamic::object("cpuProfile", cpuProfile.toDynamic())(
+        "timeDeltas", timeDeltas.toDynamic());
   }
 
- private:
-  CPUProfile cpuProfile_;
-  TimeDeltas timeDeltas_;
+  CPUProfile cpuProfile;
+  TimeDeltas timeDeltas;
 };
 
 } // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/tests/ProfileTreeNodeTest.cpp

@@ -12,47 +12,39 @@
 
 namespace facebook::react::jsinspector_modern::tracing {
 
-TEST(ProfileTreeNodeTest, EqualityOperator) {
-  auto callFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+TEST(ProfileTreeNodeTest, OnlyAddsUniqueChildren) {
+  auto fooCallFrame = RuntimeSamplingProfile::SampleCallStackFrame{
       RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "foo"};
-  ProfileTreeNode* node1;
-  ProfileTreeNode* node2;
-
-  node1 = new ProfileTreeNode(
-      1, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
-  node2 = new ProfileTreeNode(
-      2, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
-  EXPECT_EQ(*node1 == node2, true);
-
-  node1 = new ProfileTreeNode(
-      3, ProfileTreeNode::CodeType::JavaScript, node1, callFrame);
-  node2 = new ProfileTreeNode(
-      4, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
-  EXPECT_EQ(*node1 == node2, false);
-
-  node1 = new ProfileTreeNode(
-      5, ProfileTreeNode::CodeType::JavaScript, node2, callFrame);
-  node2 = new ProfileTreeNode(
-      6, ProfileTreeNode::CodeType::JavaScript, node2, callFrame);
-  EXPECT_EQ(*node1 == node2, true);
+  auto barCallFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+      RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "bar"};
+
+  ProfileTreeNode parent(
+      1, ProfileTreeNode::CodeType::JavaScript, fooCallFrame);
+  ProfileTreeNode* child =
+      parent.addChild(2, ProfileTreeNode::CodeType::JavaScript, barCallFrame);
+
+  auto maybeAlreadyExistingChild = parent.getIfAlreadyExists(
+      ProfileTreeNode::CodeType::JavaScript, barCallFrame);
+  EXPECT_NE(maybeAlreadyExistingChild, nullptr);
+
+  auto maybeExistingChildOfChild = child->getIfAlreadyExists(
+      ProfileTreeNode::CodeType::JavaScript, barCallFrame);
+  EXPECT_EQ(maybeExistingChildOfChild, nullptr);
 }
 
-TEST(ProfileTreeNodeTest, OnlyAddsUniqueChildren) {
-  auto callFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+TEST(ProfileTreeNodeTest, ConsidersCodeTypeOfChild) {
+  auto parentCallFrame = RuntimeSamplingProfile::SampleCallStackFrame{
       RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "foo"};
-  ProfileTreeNode* parent = new ProfileTreeNode(
-      1, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
-  ProfileTreeNode* existingChild = new ProfileTreeNode(
-      2, ProfileTreeNode::CodeType::JavaScript, parent, callFrame);
-
-  auto maybeAlreadyExistingChild = parent->addChild(existingChild);
-  EXPECT_EQ(maybeAlreadyExistingChild, nullptr);
+  auto childCallFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+      RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "bar"};
 
-  auto copyOfExistingChild = new ProfileTreeNode(
-      3, ProfileTreeNode::CodeType::JavaScript, parent, callFrame);
+  ProfileTreeNode parent(
+      1, ProfileTreeNode::CodeType::JavaScript, parentCallFrame);
+  parent.addChild(2, ProfileTreeNode::CodeType::JavaScript, childCallFrame);
 
-  maybeAlreadyExistingChild = parent->addChild(copyOfExistingChild);
-  EXPECT_EQ(maybeAlreadyExistingChild, existingChild);
+  auto maybeExistingChild = parent.getIfAlreadyExists(
+      ProfileTreeNode::CodeType::Other, childCallFrame);
+  EXPECT_EQ(maybeExistingChild, nullptr);
 }
 
 } // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/tests/RuntimeSamplingProfileTraceEventSerializerTest.cpp

@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <jsinspector-modern/tracing/RuntimeSamplingProfileTraceEventSerializer.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <chrono>
+#include <utility>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+class RuntimeSamplingProfileTraceEventSerializerTest : public ::testing::Test {
+ protected:
+  std::vector<folly::dynamic> notificationEvents_;
+
+  std::function<void(const folly::dynamic& traceEventsChunk)>
+  createNotificationCallback() {
+    return [this](const folly::dynamic& traceEventsChunk) {
+      notificationEvents_.push_back(traceEventsChunk);
+    };
+  }
+
+  RuntimeSamplingProfile::SampleCallStackFrame createJSCallFrame(
+      std::string functionName,
+      uint32_t scriptId = 1,
+      std::optional<std::string> url = std::nullopt,
+      std::optional<uint32_t> lineNumber = std::nullopt,
+      std::optional<uint32_t> columnNumber = std::nullopt) {
+    return RuntimeSamplingProfile::SampleCallStackFrame(
+        RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction,
+        scriptId,
+        std::move(functionName),
+        std::move(url),
+        lineNumber,
+        columnNumber);
+  }
+
+  RuntimeSamplingProfile::SampleCallStackFrame createGCCallFrame() {
+    return RuntimeSamplingProfile::SampleCallStackFrame(
+        RuntimeSamplingProfile::SampleCallStackFrame::Kind::GarbageCollector,
+        0,
+        "(garbage collector)");
+  }
+
+  RuntimeSamplingProfile::Sample createSample(
+      uint64_t timestamp,
+      uint64_t threadId,
+      std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack) {
+    return {timestamp, threadId, std::move(callStack)};
+  }
+
+  RuntimeSamplingProfile createEmptyProfile() {
+    return {"TestRuntime", {}};
+  }
+
+  RuntimeSamplingProfile createProfileWithSamples(
+      std::vector<RuntimeSamplingProfile::Sample> samples) {
+    return {"TestRuntime", std::move(samples)};
+  }
+};
+
+TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, EmptyProfile) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(), notificationCallback, 10);
+
+  auto profile = createEmptyProfile();
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // Nothing should be reported if the profile is empty.
+  EXPECT_TRUE(notificationEvents_.empty());
+}
+
+TEST_F(
+    RuntimeSamplingProfileTraceEventSerializerTest,
+    SameCallFramesAreMerged) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(), notificationCallback, 10);
+
+  // [     foo     ]
+  // [     bar     ]
+  //     [baz][(gc)]
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack1 = {
+      createJSCallFrame("bar", 1, "test.js", 20, 10),
+      createJSCallFrame("foo", 1, "test.js", 10, 5),
+  };
+
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack2 = {
+      createJSCallFrame("baz", 1, "other.js", 5, 1),
+      createJSCallFrame("bar", 1, "test.js", 20, 10),
+      createJSCallFrame("foo", 1, "test.js", 10, 5),
+  };
+
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack3 = {
+      createGCCallFrame(),
+      createJSCallFrame("bar", 1, "test.js", 20, 10),
+      createJSCallFrame("foo", 1, "test.js", 10, 5),
+  };
+
+  uint64_t threadId = 1;
+  uint64_t timestamp1 = 1000000;
+  uint64_t timestamp2 = 2000000;
+  uint64_t timestamp3 = 3000000;
+
+  auto samples = std::vector<RuntimeSamplingProfile::Sample>{};
+  samples.emplace_back(createSample(timestamp1, threadId, callStack1));
+  samples.emplace_back(createSample(timestamp2, threadId, callStack2));
+  samples.emplace_back(createSample(timestamp3, threadId, callStack3));
+
+  auto profile = createProfileWithSamples(std::move(samples));
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // Verify
+  ASSERT_EQ(notificationEvents_.size(), 2);
+  // (root), (program), (idle), foo, bar, baz, (garbage collector)
+  ASSERT_EQ(
+      notificationEvents_[1][0]["args"]["data"]["cpuProfile"]["nodes"].size(),
+      7);
+}
+
+TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, EmptySample) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(), notificationCallback, 10);
+
+  // Create an empty sample (no call stack)
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> emptyCallStack;
+
+  uint64_t threadId = 1;
+  uint64_t timestamp = 1000000;
+
+  auto samples = std::vector<RuntimeSamplingProfile::Sample>{};
+  samples.emplace_back(createSample(timestamp, threadId, emptyCallStack));
+  auto profile = createProfileWithSamples(std::move(samples));
+
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Mock the performance tracer methods
+  folly::dynamic profileEvent = folly::dynamic::object;
+  folly::dynamic chunkEvent = folly::dynamic::object;
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // Verify
+  // [["Profile"], ["ProfileChunk"]]
+  ASSERT_EQ(notificationEvents_.size(), 2);
+  // (root), (program), (idle)
+  ASSERT_EQ(
+      notificationEvents_[1][0]["args"]["data"]["cpuProfile"]["nodes"].size(),
+      3);
+}
+
+TEST_F(
+    RuntimeSamplingProfileTraceEventSerializerTest,
+    SamplesFromDifferentThreads) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(), notificationCallback, 10);
+
+  // Create samples with different thread IDs
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
+      createJSCallFrame("foo", 1, "test.js", 10, 5)};
+
+  uint64_t timestamp = 1000000;
+  uint64_t threadId1 = 1;
+  uint64_t threadId2 = 2;
+
+  auto samples = std::vector<RuntimeSamplingProfile::Sample>{};
+  samples.emplace_back(createSample(timestamp, threadId1, callStack));
+  samples.emplace_back(createSample(timestamp + 1000, threadId2, callStack));
+  samples.emplace_back(createSample(timestamp + 2000, threadId1, callStack));
+
+  auto profile = createProfileWithSamples(std::move(samples));
+
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // [["Profile"], ["ProfileChunk", "ProfileChunk", "ProfileChunk]]
+  // Samples from different thread should never be grouped together in the same
+  // chunk.
+  ASSERT_EQ(notificationEvents_.size(), 2);
+  ASSERT_EQ(notificationEvents_[1].size(), 3);
+}
+
+TEST_F(
+    RuntimeSamplingProfileTraceEventSerializerTest,
+    TraceEventChunkSizeLimit) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  uint16_t traceEventChunkSize = 2;
+  uint16_t profileChunkSize = 2;
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(),
+      notificationCallback,
+      traceEventChunkSize,
+      profileChunkSize);
+
+  // Create multiple samples
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
+      createJSCallFrame("foo", 1, "test.js", 10, 5)};
+
+  uint64_t timestamp = 1000000;
+  uint64_t threadId = 1;
+
+  std::vector<RuntimeSamplingProfile::Sample> samples;
+  samples.reserve(5);
+  for (int i = 0; i < 5; i++) {
+    samples.push_back(createSample(timestamp + i * 1000, threadId, callStack));
+  }
+
+  auto profile = createProfileWithSamples(std::move(samples));
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // [["Profile"], ["ProfileChunk", "ProfileChunk"], ["ProfileChunk"]]
+  ASSERT_EQ(notificationEvents_.size(), 3);
+
+  // Check that each chunk has at most traceEventChunkSize events
+  for (size_t i = 1; i < notificationEvents_.size(); i++) {
+    EXPECT_LE(notificationEvents_[i].size(), traceEventChunkSize);
+  }
+}
+
+TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, ProfileChunkSizeLimit) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  // Set a small profile chunk size to test profile chunking
+  uint16_t traceEventChunkSize = 10;
+  uint16_t profileChunkSize = 2;
+  double samplesCount = 5;
+  RuntimeSamplingProfileTraceEventSerializer serializer(
+      PerformanceTracer::getInstance(),
+      notificationCallback,
+      traceEventChunkSize,
+      profileChunkSize);
+
+  // Create multiple samples
+  std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
+      createJSCallFrame("foo", 1, "test.js", 10, 5)};
+
+  uint64_t timestamp = 1000000;
+  uint64_t threadId = 1;
+
+  std::vector<RuntimeSamplingProfile::Sample> samples;
+  samples.reserve(samplesCount);
+  for (int i = 0; i < samplesCount; i++) {
+    samples.push_back(createSample(timestamp + i * 1000, threadId, callStack));
+  }
+
+  auto profile = createProfileWithSamples(std::move(samples));
+  auto tracingStartTime = std::chrono::steady_clock::now();
+
+  // Execute
+  serializer.serializeAndNotify(profile, tracingStartTime);
+
+  // [["Profile"], ["ProfileChunk", "ProfileChunk", "ProfileChunk"]]
+  ASSERT_EQ(notificationEvents_.size(), 2);
+  ASSERT_EQ(
+      notificationEvents_[1].size(),
+      std::ceil(samplesCount / profileChunkSize));
+
+  for (auto& profileChunk : notificationEvents_[1]) {
+    EXPECT_LE(
+        profileChunk["args"]["data"]["cpuProfile"]["samples"].size(),
+        profileChunkSize);
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsitooling/CMakeLists.txt

@@ -6,14 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"ReactNative\")
-
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 file(GLOB jsitooling_SRC CONFIGURE_DEPENDS react/runtime/*.cpp)
 add_library(jsitooling OBJECT ${jsitooling_SRC})
 
@@ -28,3 +21,6 @@ target_link_libraries(jsitooling
         folly_runtime
         glog
         jsi)
+
+target_compile_reactnative_options(jsitooling PRIVATE "ReactNative")
+target_compile_options(jsitooling PRIVATE -Wpedantic)

package/ReactCommon/jsitooling/React-jsitooling.podspec

@@ -16,20 +16,6 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-boost_config = get_boost_config()
-boost_compiler_flags = boost_config[:compiler_flags]
-
-header_search_paths = [
-  "\"$(PODS_ROOT)/boost\"",
-  "\"$(PODS_ROOT)/RCT-Folly\"",
-  "\"$(PODS_ROOT)/DoubleConversion\"",
-  "\"$(PODS_ROOT)/fast_float/include\"",
-  "\"$(PODS_ROOT)/fmt/include\""
-]
-
 Pod::Spec.new do |s|
   s.name                   = "React-jsitooling"
   s.version                = version
@@ -40,7 +26,6 @@ Pod::Spec.new do |s|
   s.platforms              = min_supported_versions
   s.source                 = source
   s.source_files           = "react/runtime/*.{cpp,h}"
-  s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
   s.header_dir             = "react/runtime"
 
   if ENV['USE_FRAMEWORKS']
@@ -49,18 +34,15 @@ Pod::Spec.new do |s|
   end
 
   s.pod_target_xcconfig    = {
-    "HEADER_SEARCH_PATHS" => header_search_paths.join(" "),
     "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
     "DEFINES_MODULE" => "YES",
   }
 
   s.dependency "React-cxxreact", version
   s.dependency "React-jsi", version
-  s.dependency "RCT-Folly", folly_version
-  s.dependency "DoubleConversion"
-  s.dependency "fast_float", "6.1.4"
-  s.dependency "fmt", "11.0.2"
-  s.dependency "glog"
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
+  add_dependency(s, "React-jsinspectorcdp", :framework_name => 'jsinspector_moderncdp')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
+
+  add_rn_third_party_dependencies(s)
 end

package/ReactCommon/logger/CMakeLists.txt

@@ -6,7 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(-fexceptions)
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB logger_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(logger OBJECT ${logger_SRC})
@@ -14,3 +14,4 @@ add_library(logger OBJECT ${logger_SRC})
 target_include_directories(logger PUBLIC .)
 
 target_link_libraries(logger glog)
+target_compile_reactnative_options(logger PRIVATE)

package/ReactCommon/logger/React-logger.podspec

@@ -17,12 +17,6 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-boost_config = get_boost_config()
-boost_compiler_flags = boost_config[:compiler_flags] 
-
 Pod::Spec.new do |s|
   s.name                   = "React-logger"
   s.version                = version
@@ -33,9 +27,7 @@ Pod::Spec.new do |s|
   s.platforms              = min_supported_versions
   s.source                 = source
   s.source_files           = "*.{cpp,h}"
-  s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "" }
   s.header_dir             = "logger"
 
-  s.dependency "glog"
+  add_rn_third_party_dependencies(s)
 end

package/ReactCommon/logger/react_native_log.cpp

@@ -8,7 +8,7 @@
 #include "react_native_log.h"
 #include <glog/logging.h>
 
-static reactnativelogfunctype _reactnativelogfunc = NULL;
+static reactnativelogfunctype _reactnativelogfunc = nullptr;
 
 void set_react_native_logfunc(reactnativelogfunctype newlogfunc) {
   _reactnativelogfunc = newlogfunc;
@@ -27,7 +27,7 @@ void react_native_log_fatal(const char* message) {
 }
 
 void _react_native_log(ReactNativeLogLevel level, const char* message) {
-  if (_reactnativelogfunc == NULL) {
+  if (_reactnativelogfunc == nullptr) {
     _react_native_log_default(level, message);
   } else {
     _reactnativelogfunc(level, message);