react-native-windows 0.81.1 → 0.82.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/jsinspector-modern/tracing/RuntimeSamplingProfileTraceEventSerializer.cpp

@@ -0,0 +1,351 @@
+/*
+ * 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 "RuntimeSamplingProfileTraceEventSerializer.h"
+#include "PerformanceTracer.h"
+#include "ProfileTreeNode.h"
+#include "TraceEventSerializer.h"
+
+#include <string_view>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+namespace {
+
+// To capture samples timestamps Hermes is using steady_clock and returns
+// them in microseconds granularity since epoch. In the future we might want to
+// update Hermes to return timestamps in chrono type.
+HighResTimeStamp getHighResTimeStampForSample(
+    const RuntimeSamplingProfile::Sample& sample) {
+  auto microsecondsSinceSteadyClockEpoch = sample.timestamp;
+  auto chronoTimePoint = std::chrono::steady_clock::time_point(
+      std::chrono::microseconds(microsecondsSinceSteadyClockEpoch));
+  return HighResTimeStamp::fromChronoSteadyClockTimePoint(chronoTimePoint);
+}
+
+/// Fallback script ID for artificial call frames, such as (root), (idle) or
+/// (program). Required for emulating the payload in a format that is expected
+/// by Chrome DevTools.
+constexpr uint32_t FALLBACK_SCRIPT_ID = 0;
+
+constexpr std::string_view GARBAGE_COLLECTOR_FRAME_NAME = "(garbage collector)";
+constexpr std::string_view ROOT_FRAME_NAME = "(root)";
+constexpr std::string_view IDLE_FRAME_NAME = "(idle)";
+constexpr std::string_view PROGRAM_FRAME_NAME = "(program)";
+
+TraceEventProfileChunk::CPUProfile::Node convertToTraceEventProfileNode(
+    const ProfileTreeNode& node) {
+  const RuntimeSamplingProfile::SampleCallStackFrame& callFrame =
+      node.getCallFrame();
+  auto traceEventCallFrame =
+      TraceEventProfileChunk::CPUProfile::Node::CallFrame{
+          .codeType =
+              node.getCodeType() == ProfileTreeNode::CodeType::JavaScript
+              ? "JS"
+              : "other",
+          .scriptId = callFrame.scriptId,
+          .functionName = std::string(callFrame.functionName),
+          .url = callFrame.scriptURL
+              ? std::optional<std::string>(std::string(*callFrame.scriptURL))
+              : std::nullopt,
+          .lineNumber = callFrame.lineNumber,
+          .columnNumber = callFrame.columnNumber,
+      };
+
+  return TraceEventProfileChunk::CPUProfile::Node{
+      .id = node.getId(),
+      .callFrame = std::move(traceEventCallFrame),
+      .parentId = node.hasParent() ? std::optional<uint32_t>(node.getParentId())
+                                   : std::nullopt,
+  };
+}
+
+RuntimeSamplingProfile::SampleCallStackFrame createArtificialCallFrame(
+    std::string_view callFrameName) {
+  return RuntimeSamplingProfile::SampleCallStackFrame{
+      .kind = RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction,
+      .scriptId = FALLBACK_SCRIPT_ID,
+      .functionName = callFrameName,
+  };
+};
+
+RuntimeSamplingProfile::SampleCallStackFrame createGarbageCollectorCallFrame() {
+  return RuntimeSamplingProfile::SampleCallStackFrame{
+      .kind =
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::GarbageCollector,
+      .scriptId = FALLBACK_SCRIPT_ID,
+      .functionName = GARBAGE_COLLECTOR_FRAME_NAME,
+  };
+};
+
+class ProfileTreeRootNode : public ProfileTreeNode {
+ public:
+  explicit ProfileTreeRootNode(uint32_t id)
+      : ProfileTreeNode(
+            id,
+            CodeType::Other,
+            createArtificialCallFrame(ROOT_FRAME_NAME)) {}
+};
+
+struct ProfileChunk {
+  ProfileChunk(
+      uint16_t chunkSize,
+      ProcessId chunkProcessId,
+      ThreadId chunkThreadId,
+      HighResTimeStamp chunkTimestamp)
+      : size(chunkSize),
+        processId(chunkProcessId),
+        threadId(chunkThreadId),
+        timestamp(chunkTimestamp) {
+    samples.reserve(size);
+    timeDeltas.reserve(size);
+  }
+
+  inline bool isFull() const {
+    return samples.size() == size;
+  }
+
+  inline bool isEmpty() const {
+    return samples.empty();
+  }
+
+  std::vector<ProfileTreeNode> nodes;
+  std::vector<uint32_t> samples;
+  std::vector<HighResDuration> timeDeltas;
+  uint16_t size;
+  ProcessId processId;
+  ThreadId threadId;
+  HighResTimeStamp timestamp;
+};
+
+// Construct and send "Profile" Trace Event with dispatchCallback.
+void sendProfileTraceEvent(
+    ProcessId processId,
+    ThreadId threadId,
+    RuntimeProfileId profileId,
+    HighResTimeStamp profileStartTimestamp,
+    const std::function<void(folly::dynamic&& traceEventsChunk)>&
+        dispatchCallback) {
+  auto traceEvent = PerformanceTracer::constructRuntimeProfileTraceEvent(
+      profileId, processId, threadId, profileStartTimestamp);
+  folly::dynamic serializedTraceEvent =
+      TraceEventSerializer::serialize(std::move(traceEvent));
+
+  dispatchCallback(folly::dynamic::array(std::move(serializedTraceEvent)));
+}
+
+// Add an empty sample to the chunk.
+void chunkEmptySample(
+    ProfileChunk& chunk,
+    uint32_t idleNodeId,
+    HighResDuration samplesTimeDelta) {
+  chunk.samples.push_back(idleNodeId);
+  chunk.timeDeltas.push_back(samplesTimeDelta);
+}
+
+// Take the current local ProfileChunk, serialize it as "ProfileChunk" Trace
+// Event and buffer it.
+void bufferProfileChunkTraceEvent(
+    ProfileChunk&& chunk,
+    RuntimeProfileId profileId,
+    folly::dynamic& traceEventBuffer) {
+  std::vector<TraceEventProfileChunk::CPUProfile::Node> traceEventNodes;
+  traceEventNodes.reserve(chunk.nodes.size());
+  for (const auto& node : chunk.nodes) {
+    traceEventNodes.push_back(convertToTraceEventProfileNode(node));
+  }
+
+  auto traceEvent = PerformanceTracer::constructRuntimeProfileChunkTraceEvent(
+      profileId,
+      chunk.processId,
+      chunk.threadId,
+      chunk.timestamp,
+      TraceEventProfileChunk{
+          .cpuProfile =
+              TraceEventProfileChunk::CPUProfile{
+                  .nodes = std::move(traceEventNodes),
+                  .samples = std::move(chunk.samples)},
+          .timeDeltas = std::move(chunk.timeDeltas),
+      });
+  auto serializedTraceEvent =
+      TraceEventSerializer::serialize(std::move(traceEvent));
+
+  traceEventBuffer.push_back(std::move(serializedTraceEvent));
+}
+
+// Process a call stack of a single sample and add it to the chunk.
+void processCallStack(
+    std::vector<RuntimeSamplingProfile::SampleCallStackFrame>&& callStack,
+    ProfileChunk& chunk,
+    ProfileTreeNode& rootNode,
+    uint32_t idleNodeId,
+    HighResDuration samplesTimeDelta,
+    IdGenerator& nodeIdGenerator) {
+  if (callStack.empty()) {
+    chunkEmptySample(chunk, idleNodeId, samplesTimeDelta);
+    return;
+  }
+
+  ProfileTreeNode* previousNode = &rootNode;
+  for (auto it = callStack.rbegin(); it != callStack.rend(); ++it) {
+    const RuntimeSamplingProfile::SampleCallStackFrame& callFrame = *it;
+    bool isGarbageCollectorFrame = callFrame.kind ==
+        RuntimeSamplingProfile::SampleCallStackFrame::Kind::GarbageCollector;
+
+    ProfileTreeNode::CodeType childCodeType = isGarbageCollectorFrame
+        ? ProfileTreeNode::CodeType::Other
+        : ProfileTreeNode::CodeType::JavaScript;
+    // We don't need real garbage collector call frame, we change it to
+    // what Chrome DevTools expects.
+    RuntimeSamplingProfile::SampleCallStackFrame childCallFrame =
+        isGarbageCollectorFrame ? createGarbageCollectorCallFrame() : callFrame;
+
+    ProfileTreeNode* maybeExistingChild =
+        previousNode->getIfAlreadyExists(childCodeType, childCallFrame);
+    if (maybeExistingChild != nullptr) {
+      previousNode = maybeExistingChild;
+    } else {
+      previousNode = previousNode->addChild(
+          nodeIdGenerator.getNext(), childCodeType, childCallFrame);
+      chunk.nodes.push_back(*previousNode);
+    }
+  }
+
+  chunk.samples.push_back(previousNode->getId());
+  chunk.timeDeltas.push_back(samplesTimeDelta);
+}
+
+// Send buffered Trace Events and reset the buffer.
+void sendBufferedTraceEvents(
+    folly::dynamic&& traceEventBuffer,
+    const std::function<void(folly::dynamic&& traceEventsChunk)>&
+        dispatchCallback) {
+  dispatchCallback(std::move(traceEventBuffer));
+}
+
+} // namespace
+
+/* static */ void
+RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+    std::vector<RuntimeSamplingProfile>&& profiles,
+    IdGenerator& profileIdGenerator,
+    HighResTimeStamp tracingStartTime,
+    const std::function<void(folly::dynamic&& traceEventsChunk)>&
+        dispatchCallback,
+    uint16_t traceEventChunkSize,
+    uint16_t profileChunkSize,
+    uint16_t maxUniqueNodesPerChunk) {
+  for (auto&& profile : profiles) {
+    serializeAndDispatch(
+        std::move(profile),
+        profileIdGenerator,
+        tracingStartTime,
+        dispatchCallback,
+        traceEventChunkSize,
+        profileChunkSize,
+        maxUniqueNodesPerChunk);
+  }
+}
+
+/* static */ void
+RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+    RuntimeSamplingProfile&& profile,
+    IdGenerator& profileIdGenerator,
+    HighResTimeStamp tracingStartTime,
+    const std::function<void(folly::dynamic&& traceEventsChunk)>&
+        dispatchCallback,
+    uint16_t traceEventChunkSize,
+    uint16_t profileChunkSize,
+    uint16_t maxUniqueNodesPerChunk) {
+  auto samples = std::move(profile.samples);
+  if (samples.empty()) {
+    return;
+  }
+
+  auto traceEventBuffer = folly::dynamic::array();
+  traceEventBuffer.reserve(traceEventChunkSize);
+
+  ThreadId threadId = samples.front().threadId;
+  HighResTimeStamp previousSampleTimestamp = tracingStartTime;
+  HighResTimeStamp currentChunkTimestamp = tracingStartTime;
+  auto profileId = static_cast<RuntimeProfileId>(profileIdGenerator.getNext());
+
+  sendProfileTraceEvent(
+      profile.processId,
+      threadId,
+      profileId,
+      tracingStartTime,
+      dispatchCallback);
+
+  // There could be any number of new nodes in this chunk. Empty if all nodes
+  // are already emitted in previous chunks.
+  ProfileChunk chunk{
+      profileChunkSize, profile.processId, threadId, currentChunkTimestamp};
+
+  IdGenerator nodeIdGenerator{};
+  ProfileTreeRootNode rootNode(nodeIdGenerator.getNext());
+  chunk.nodes.push_back(rootNode);
+
+  ProfileTreeNode* programNode = rootNode.addChild(
+      nodeIdGenerator.getNext(),
+      ProfileTreeNode::CodeType::Other,
+      createArtificialCallFrame(PROGRAM_FRAME_NAME));
+  chunk.nodes.push_back(*programNode);
+
+  ProfileTreeNode* idleNode = rootNode.addChild(
+      nodeIdGenerator.getNext(),
+      ProfileTreeNode::CodeType::Other,
+      createArtificialCallFrame(IDLE_FRAME_NAME));
+  chunk.nodes.push_back(*idleNode);
+  uint32_t idleNodeId = idleNode->getId();
+
+  for (auto& sample : samples) {
+    ThreadId currentSampleThreadId = sample.threadId;
+    auto currentSampleTimestamp = getHighResTimeStampForSample(sample);
+
+    // We should not attempt to merge samples from different threads.
+    // From past observations, this only happens for GC nodes.
+    // We should group samples by thread id once we support executing JavaScript
+    // on different threads.
+    if (currentSampleThreadId != chunk.threadId || chunk.isFull()) {
+      bufferProfileChunkTraceEvent(
+          std::move(chunk), profileId, traceEventBuffer);
+      chunk = ProfileChunk{
+          profileChunkSize,
+          profile.processId,
+          currentSampleThreadId,
+          currentChunkTimestamp};
+    }
+
+    if (traceEventBuffer.size() == traceEventChunkSize) {
+      sendBufferedTraceEvents(std::move(traceEventBuffer), dispatchCallback);
+
+      traceEventBuffer = folly::dynamic::array();
+      traceEventBuffer.reserve(traceEventChunkSize);
+    }
+
+    processCallStack(
+        std::move(sample.callStack),
+        chunk,
+        rootNode,
+        idleNodeId,
+        currentSampleTimestamp - previousSampleTimestamp,
+        nodeIdGenerator);
+
+    previousSampleTimestamp = currentSampleTimestamp;
+  }
+
+  if (!chunk.isEmpty()) {
+    bufferProfileChunkTraceEvent(std::move(chunk), profileId, traceEventBuffer);
+  }
+
+  if (!traceEventBuffer.empty()) {
+    sendBufferedTraceEvents(std::move(traceEventBuffer), dispatchCallback);
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -114,14 +114,14 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
    */
   void emitDeviceEvent(
       const std::string& eventName,
-      ArgFactory argFactory = nullptr);
+      ArgFactory&& argFactory = nullptr);
 
   // Backwards compatibility version
   void emitDeviceEvent(
       jsi::Runtime& /*runtime*/,
 
       const std::string& eventName,
-      ArgFactory argFactory = nullptr) {
+      ArgFactory&& argFactory = nullptr) {
     emitDeviceEvent(eventName, std::move(argFactory));
   }
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/dom/NativeDOM.cpp

@@ -30,15 +30,14 @@ inline std::shared_ptr<const ShadowNode> getShadowNode(
   return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
       runtime, shadowNodeValue);
 }
-} // namespace
 
 #pragma mark - Private helpers
 
-static UIManager& getUIManagerFromRuntime(facebook::jsi::Runtime& runtime) {
+UIManager& getUIManagerFromRuntime(facebook::jsi::Runtime& runtime) {
   return UIManagerBinding::getBinding(runtime)->getUIManager();
 }
 
-static RootShadowNode::Shared getCurrentShadowTreeRevision(
+RootShadowNode::Shared getCurrentShadowTreeRevision(
     facebook::jsi::Runtime& runtime,
     SurfaceId surfaceId) {
   auto shadowTreeRevisionProvider =
@@ -46,7 +45,7 @@ static RootShadowNode::Shared getCurrentShadowTreeRevision(
   return shadowTreeRevisionProvider->getCurrentRevision(surfaceId);
 }
 
-static RootShadowNode::Shared getCurrentShadowTreeRevision(
+RootShadowNode::Shared getCurrentShadowTreeRevision(
     facebook::jsi::Runtime& runtime,
     jsi::Value& nativeNodeReference) {
   if (nativeNodeReference.isNumber()) {
@@ -58,14 +57,13 @@ static RootShadowNode::Shared getCurrentShadowTreeRevision(
       runtime, getShadowNode(runtime, nativeNodeReference)->getSurfaceId());
 }
 
-static facebook::react::PointerEventsProcessor&
-getPointerEventsProcessorFromRuntime(facebook::jsi::Runtime& runtime) {
+facebook::react::PointerEventsProcessor& getPointerEventsProcessorFromRuntime(
+    facebook::jsi::Runtime& runtime) {
   return facebook::react::UIManagerBinding::getBinding(runtime)
       ->getPointerEventsProcessor();
 }
 
-static std::vector<facebook::jsi::Value>
-getArrayOfInstanceHandlesFromShadowNodes(
+std::vector<facebook::jsi::Value> getArrayOfInstanceHandlesFromShadowNodes(
     const std::vector<std::shared_ptr<const ShadowNode>>& nodes,
     facebook::jsi::Runtime& runtime) {
   // JSI doesn't support adding elements to an array after creation,
@@ -83,10 +81,12 @@ getArrayOfInstanceHandlesFromShadowNodes(
   return nonNullInstanceHandles;
 }
 
-static bool isRootShadowNode(const ShadowNode& shadowNode) {
+bool isRootShadowNode(const ShadowNode& shadowNode) {
   return shadowNode.getTraits().check(ShadowNodeTraits::Trait::RootNodeKind);
 }
 
+} // namespace
+
 #pragma mark - NativeDOM
 
 NativeDOM::NativeDOM(std::shared_ptr<CallInvoker> jsInvoker)
@@ -172,6 +172,23 @@ std::vector<jsi::Value> NativeDOM::getChildNodes(
   return getArrayOfInstanceHandlesFromShadowNodes(childNodes, rt);
 }
 
+jsi::Value NativeDOM::getElementById(
+    jsi::Runtime& rt,
+    SurfaceId surfaceId,
+    const std::string& id) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, surfaceId);
+  if (currentRevision == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  auto elementById = dom::getElementById(currentRevision, id);
+  if (elementById == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  return elementById->getInstanceHandle(rt);
+}
+
 jsi::Value NativeDOM::getParentNode(
     jsi::Runtime& rt,
     jsi::Value nativeNodeReference) {
@@ -299,7 +316,7 @@ NativeDOM::getScrollSize(
 }
 
 std::string NativeDOM::getTagName(
-    jsi::Runtime& rt,
+    jsi::Runtime& /*rt*/,
     std::shared_ptr<const ShadowNode> shadowNode) {
   return dom::getTagName(*shadowNode);
 }
@@ -389,44 +406,38 @@ jsi::Value NativeDOM::linkRootNode(
 void NativeDOM::measure(
     jsi::Runtime& rt,
     std::shared_ptr<const ShadowNode> shadowNode,
-    jsi::Function callback) {
+    const MeasureOnSuccessCallback& callback) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    callback.call(rt, {0, 0, 0, 0, 0, 0});
+    callback(0, 0, 0, 0, 0, 0);
     return;
   }
 
   auto measureRect = dom::measure(currentRevision, *shadowNode);
 
-  callback.call(
-      rt,
-      {jsi::Value{rt, measureRect.x},
-       jsi::Value{rt, measureRect.y},
-       jsi::Value{rt, measureRect.width},
-       jsi::Value{rt, measureRect.height},
-       jsi::Value{rt, measureRect.pageX},
-       jsi::Value{rt, measureRect.pageY}});
+  callback(
+      measureRect.x,
+      measureRect.y,
+      measureRect.width,
+      measureRect.height,
+      measureRect.pageX,
+      measureRect.pageY);
 }
 
 void NativeDOM::measureInWindow(
     jsi::Runtime& rt,
     std::shared_ptr<const ShadowNode> shadowNode,
-    jsi::Function callback) {
+    const MeasureInWindowOnSuccessCallback& callback) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    callback.call(rt, {0, 0, 0, 0});
+    callback(0, 0, 0, 0);
     return;
   }
 
   auto rect = dom::measureInWindow(currentRevision, *shadowNode);
-  callback.call(
-      rt,
-      {jsi::Value{rt, rect.x},
-       jsi::Value{rt, rect.y},
-       jsi::Value{rt, rect.width},
-       jsi::Value{rt, rect.height}});
+  callback(rect.x, rect.y, rect.width, rect.height);
 }
 
 void NativeDOM::measureLayout(
@@ -434,7 +445,7 @@ void NativeDOM::measureLayout(
     std::shared_ptr<const ShadowNode> shadowNode,
     std::shared_ptr<const ShadowNode> relativeToShadowNode,
     jsi::Function onFail,
-    jsi::Function onSuccess) {
+    const MeasureLayoutOnSuccessCallback& onSuccess) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -452,12 +463,7 @@ void NativeDOM::measureLayout(
 
   auto rect = maybeRect.value();
 
-  onSuccess.call(
-      rt,
-      {jsi::Value{rt, rect.x},
-       jsi::Value{rt, rect.y},
-       jsi::Value{rt, rect.width},
-       jsi::Value{rt, rect.height}});
+  onSuccess(rect.x, rect.y, rect.width, rect.height);
 }
 
 // [windows MSVC cant handle backtick character in a preprocessor line
@@ -472,4 +478,4 @@ void NativeDOM::setNativeProps(
       shadowNode, RawProps(rt, updatePayload));
 }
 
-} // namespace facebook::react
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/dom/NativeDOM.h

@@ -23,6 +23,15 @@
 
 namespace facebook::react {
 
+using MeasureOnSuccessCallback =
+    SyncCallback<void(double, double, double, double, double, double)>;
+
+using MeasureInWindowOnSuccessCallback =
+    SyncCallback<void(double, double, double, double)>;
+
+using MeasureLayoutOnSuccessCallback =
+    SyncCallback<void(double, double, double, double)>;
+
 class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
  public:
   NativeDOM(std::shared_ptr<CallInvoker> jsInvoker);
@@ -38,6 +47,9 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
       jsi::Runtime& rt,
       jsi::Value nativeNodeReference);
 
+  jsi::Value
+  getElementById(jsi::Runtime& rt, SurfaceId surfaceId, const std::string& id);
+
   jsi::Value getParentNode(jsi::Runtime& rt, jsi::Value nativeNodeReference);
 
   bool isConnected(jsi::Runtime& rt, jsi::Value nativeNodeReference);
@@ -119,19 +131,19 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
   void measure(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
-      jsi::Function callback);
+      const MeasureOnSuccessCallback& callback);
 
   void measureInWindow(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
-      jsi::Function callback);
+      const MeasureInWindowOnSuccessCallback& callback);
 
   void measureLayout(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
       std::shared_ptr<const ShadowNode> relativeToShadowNode,
       jsi::Function onFail,
-      jsi::Function onSuccess);
+      const MeasureLayoutOnSuccessCallback& onSuccess);
 
 // [windows MSVC cant handle backtick character in a preprocessor line
 #pragma mark - Legacy direct manipulation APIs (for ReactNativeElement).

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/componentregistry/ComponentDescriptorRegistry.cpp

@@ -29,7 +29,7 @@ ComponentDescriptorRegistry::ComponentDescriptorRegistry(
       contextContainer_(std::move(contextContainer)) {}
 
 void ComponentDescriptorRegistry::add(
-    ComponentDescriptorProvider componentDescriptorProvider) const {
+    const ComponentDescriptorProvider& componentDescriptorProvider) const {
   std::unique_lock lock(mutex_);
 
   auto componentDescriptor = componentDescriptorProvider.constructor(