react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.h

@@ -28,14 +28,14 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
   /*
    * Not copyable.
    */
-  RuntimeScheduler_Modern(const RuntimeScheduler_Modern&) = delete;
-  RuntimeScheduler_Modern& operator=(const RuntimeScheduler_Modern&) = delete;
+  RuntimeScheduler_Modern(const RuntimeScheduler_Modern &) = delete;
+  RuntimeScheduler_Modern &operator=(const RuntimeScheduler_Modern &) = delete;
 
   /*
    * Not movable.
    */
-  RuntimeScheduler_Modern(RuntimeScheduler_Modern&&) = delete;
-  RuntimeScheduler_Modern& operator=(RuntimeScheduler_Modern&&) = delete;
+  RuntimeScheduler_Modern(RuntimeScheduler_Modern &&) = delete;
+  RuntimeScheduler_Modern &operator=(RuntimeScheduler_Modern &&) = delete;
 
   /*
    * Alias for scheduleTask with immediate priority.
@@ -43,7 +43,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * To be removed when we finish testing this implementation.
    * All callers should use scheduleTask with the right priority after that.
    */
-  void scheduleWork(RawCallback&& callback) noexcept override;
+  void scheduleWork(RawCallback &&callback) noexcept override;
 
   /*
    * Grants access to the runtime synchronously on the caller's thread.
@@ -52,41 +52,35 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * by dispatching a synchronous event via event emitter in your native
    * component.
    */
-  void executeNowOnTheSameThread(RawCallback&& callback) override;
+  void executeNowOnTheSameThread(RawCallback &&callback) override;
 
   /*
    * Adds a JavaScript callback to the priority queue with the given priority.
    * Triggers event loop if needed.
    */
-  std::shared_ptr<Task> scheduleTask(
-      SchedulerPriority priority,
-      jsi::Function&& callback) noexcept override;
+  std::shared_ptr<Task> scheduleTask(SchedulerPriority priority, jsi::Function &&callback) noexcept override;
 
   /*
    * Adds a custom callback to the priority queue with the given priority.
    * Triggers event loop if needed.
    */
-  std::shared_ptr<Task> scheduleTask(
-      SchedulerPriority priority,
-      RawCallback&& callback) noexcept override;
+  std::shared_ptr<Task> scheduleTask(SchedulerPriority priority, RawCallback &&callback) noexcept override;
 
   /*
    * Adds a JavaScript callback to the idle queue with the given timeout.
    * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleIdleTask(
-      jsi::Function&& callback,
-      HighResDuration customTimeout = timeoutForSchedulerPriority(
-          SchedulerPriority::IdlePriority)) noexcept override;
+      jsi::Function &&callback,
+      HighResDuration customTimeout = timeoutForSchedulerPriority(SchedulerPriority::IdlePriority)) noexcept override;
 
   /*
    * Adds a custom callback to the idle queue with the given timeout.
    * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleIdleTask(
-      RawCallback&& callback,
-      HighResDuration customTimeout = timeoutForSchedulerPriority(
-          SchedulerPriority::IdlePriority)) noexcept override;
+      RawCallback &&callback,
+      HighResDuration customTimeout = timeoutForSchedulerPriority(SchedulerPriority::IdlePriority)) noexcept override;
 
   /*
    * Cancelled task will never be executed.
@@ -94,7 +88,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * Operates on JSI object.
    * Thread synchronization must be enforced externally.
    */
-  void cancelTask(Task& task) noexcept override;
+  void cancelTask(Task &task) noexcept override;
 
   /*
    * Return value indicates if host platform has a pending access to the
@@ -129,7 +123,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    *
    * TODO remove when we add support for microtasks
    */
-  void callExpiredTasks(jsi::Runtime& runtime) override;
+  void callExpiredTasks(jsi::Runtime &runtime) override;
 
   /**
    * Schedules a function that notifies or applies UI changes in the host
@@ -137,34 +131,24 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * event loop. If the step is not enabled, the function is executed
    * immediately.
    */
-  void scheduleRenderingUpdate(
-      SurfaceId surfaceId,
-      RuntimeSchedulerRenderingUpdate&& renderingUpdate) override;
+  void scheduleRenderingUpdate(SurfaceId surfaceId, RuntimeSchedulerRenderingUpdate &&renderingUpdate) override;
 
   void setShadowTreeRevisionConsistencyManager(
-      ShadowTreeRevisionConsistencyManager*
-          shadowTreeRevisionConsistencyManager) override;
+      ShadowTreeRevisionConsistencyManager *shadowTreeRevisionConsistencyManager) override;
 
-  void setPerformanceEntryReporter(
-      PerformanceEntryReporter* performanceEntryReporter) override;
+  void setPerformanceEntryReporter(PerformanceEntryReporter *performanceEntryReporter) override;
 
-  void setEventTimingDelegate(
-      RuntimeSchedulerEventTimingDelegate* eventTimingDelegate) override;
+  void setEventTimingDelegate(RuntimeSchedulerEventTimingDelegate *eventTimingDelegate) override;
 
   void setIntersectionObserverDelegate(
-      RuntimeSchedulerIntersectionObserverDelegate*
-          intersectionObserverDelegate) override;
+      RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) override;
 
  private:
   std::atomic<uint_fast8_t> syncTaskRequests_{0};
 
-  std::priority_queue<
-      std::shared_ptr<Task>,
-      std::vector<std::shared_ptr<Task>>,
-      TaskPriorityComparer>
-      taskQueue_;
+  std::priority_queue<std::shared_ptr<Task>, std::vector<std::shared_ptr<Task>>, TaskPriorityComparer> taskQueue_;
 
-  Task* currentTask_{};
+  Task *currentTask_{};
   HighResTimeStamp lastYieldingOpportunity_;
   HighResDuration longestPeriodWithoutYieldingOpportunity_;
 
@@ -179,7 +163,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
   SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
 
   void scheduleEventLoop();
-  void runEventLoop(jsi::Runtime& runtime);
+  void runEventLoop(jsi::Runtime &runtime);
 
   std::shared_ptr<Task> selectTask();
 
@@ -191,22 +175,16 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * In the future, this will include other steps in the Web event loop, like
    * updating the UI in native, executing resize observer callbacks, etc.
    */
-  void runEventLoopTick(jsi::Runtime& runtime, Task& task);
+  void runEventLoopTick(jsi::Runtime &runtime, Task &task);
 
-  void executeTask(
-      jsi::Runtime& runtime,
-      Task& task,
-      bool didUserCallbackTimeout) const;
+  void executeTask(jsi::Runtime &runtime, Task &task, bool didUserCallbackTimeout) const;
 
   void updateRendering(HighResTimeStamp taskEndTime);
 
   bool performingMicrotaskCheckpoint_{false};
-  void performMicrotaskCheckpoint(jsi::Runtime& runtime);
+  void performMicrotaskCheckpoint(jsi::Runtime &runtime);
 
-  void reportLongTasks(
-      const Task& task,
-      HighResTimeStamp startTime,
-      HighResTimeStamp endTime);
+  void reportLongTasks(const Task &task, HighResTimeStamp startTime, HighResTimeStamp endTime);
 
   /*
    * Returns a time point representing the current point in time. May be called
@@ -226,14 +204,11 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
   // TODO(T227212654) eventTimingDelegate_ is only set once during startup, so
   // the real fix here would be to delay runEventLoop until
   // setEventTimingDelegate.
-  std::atomic<ShadowTreeRevisionConsistencyManager*>
-      shadowTreeRevisionConsistencyManager_{nullptr};
-  std::atomic<RuntimeSchedulerEventTimingDelegate*> eventTimingDelegate_{
-      nullptr};
-
-  PerformanceEntryReporter* performanceEntryReporter_{nullptr};
-  RuntimeSchedulerIntersectionObserverDelegate* intersectionObserverDelegate_{
-      nullptr};
+  std::atomic<ShadowTreeRevisionConsistencyManager *> shadowTreeRevisionConsistencyManager_{nullptr};
+  std::atomic<RuntimeSchedulerEventTimingDelegate *> eventTimingDelegate_{nullptr};
+
+  PerformanceEntryReporter *performanceEntryReporter_{nullptr};
+  RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate_{nullptr};
 
   RuntimeSchedulerTaskErrorHandler onTaskError_;
 };

package/ReactCommon/react/renderer/runtimescheduler/SchedulerPriorityUtils.h

@@ -14,13 +14,13 @@
 
 namespace facebook::react {
 
-static constexpr std::underlying_type<SchedulerPriority>::type serialize(
-    SchedulerPriority schedulerPriority) {
-  return static_cast<std::underlying_type<SchedulerPriority>::type>(
-      schedulerPriority);
+static constexpr std::underlying_type<SchedulerPriority>::type serialize(SchedulerPriority schedulerPriority)
+{
+  return static_cast<std::underlying_type<SchedulerPriority>::type>(schedulerPriority);
 }
 
-static inline SchedulerPriority fromRawValue(double value) {
+static inline SchedulerPriority fromRawValue(double value)
+{
   switch ((int)value) {
     case 1:
       return SchedulerPriority::ImmediatePriority;
@@ -38,8 +38,8 @@ static inline SchedulerPriority fromRawValue(double value) {
   }
 }
 
-static inline HighResDuration timeoutForSchedulerPriority(
-    SchedulerPriority schedulerPriority) noexcept {
+static inline HighResDuration timeoutForSchedulerPriority(SchedulerPriority schedulerPriority) noexcept
+{
   switch (schedulerPriority) {
     case SchedulerPriority::ImmediatePriority:
       return HighResDuration::fromChrono(std::chrono::milliseconds(0));

package/ReactCommon/react/renderer/runtimescheduler/Task.h

@@ -21,18 +21,12 @@ class RuntimeScheduler_Legacy;
 class RuntimeScheduler_Modern;
 class TaskPriorityComparer;
 
-using RawCallback = std::function<void(jsi::Runtime&)>;
+using RawCallback = std::function<void(jsi::Runtime &)>;
 
 struct Task final : public jsi::NativeState {
-  Task(
-      SchedulerPriority priority,
-      jsi::Function&& callback,
-      HighResTimeStamp expirationTime);
+  Task(SchedulerPriority priority, jsi::Function &&callback, HighResTimeStamp expirationTime);
 
-  Task(
-      SchedulerPriority priority,
-      RawCallback&& callback,
-      HighResTimeStamp expirationTime);
+  Task(SchedulerPriority priority, RawCallback &&callback, HighResTimeStamp expirationTime);
 
  private:
   friend RuntimeScheduler_Legacy;
@@ -44,14 +38,13 @@ struct Task final : public jsi::NativeState {
   HighResTimeStamp expirationTime;
   uint64_t id;
 
-  jsi::Value execute(jsi::Runtime& runtime, bool didUserCallbackTimeout);
+  jsi::Value execute(jsi::Runtime &runtime, bool didUserCallbackTimeout);
 };
 
 class TaskPriorityComparer {
  public:
-  inline bool operator()(
-      const std::shared_ptr<Task>& lhs,
-      const std::shared_ptr<Task>& rhs) {
+  inline bool operator()(const std::shared_ptr<Task> &lhs, const std::shared_ptr<Task> &rhs)
+  {
     return lhs->expirationTime > rhs->expirationTime;
   }
 };

package/ReactCommon/react/renderer/runtimescheduler/primitives.h

@@ -12,17 +12,15 @@
 
 namespace facebook::react {
 
-inline static jsi::Value valueFromTask(
-    jsi::Runtime& runtime,
-    std::shared_ptr<Task> task) {
+inline static jsi::Value valueFromTask(jsi::Runtime &runtime, std::shared_ptr<Task> task)
+{
   jsi::Object obj(runtime);
   obj.setNativeState(runtime, std::move(task));
   return obj;
 }
 
-inline static std::shared_ptr<Task> taskFromValue(
-    jsi::Runtime& runtime,
-    const jsi::Value& value) {
+inline static std::shared_ptr<Task> taskFromValue(jsi::Runtime &runtime, const jsi::Value &value)
+{
   if (value.isNull()) {
     return nullptr;
   }

package/ReactCommon/react/renderer/runtimescheduler/tests/StubClock.h

@@ -13,19 +13,23 @@ namespace facebook::react {
 
 class StubClock {
  public:
-  HighResTimeStamp getNow() const {
+  HighResTimeStamp getNow() const
+  {
     return timePoint_;
   }
 
-  void setTimePoint(HighResTimeStamp timePoint) {
+  void setTimePoint(HighResTimeStamp timePoint)
+  {
     timePoint_ = timePoint;
   }
 
-  HighResTimeStamp getTimePoint() {
+  HighResTimeStamp getTimePoint()
+  {
     return timePoint_;
   }
 
-  void advanceTimeBy(HighResDuration duration) {
+  void advanceTimeBy(HighResDuration duration)
+  {
     timePoint_ += duration;
   }
 

package/ReactCommon/react/renderer/runtimescheduler/tests/StubErrorUtils.h

@@ -17,17 +17,15 @@ namespace facebook::react {
  */
 class StubErrorUtils : public jsi::HostObject {
  public:
-  static std::shared_ptr<StubErrorUtils> createAndInstallIfNeeded(
-      jsi::Runtime& runtime) {
+  static std::shared_ptr<StubErrorUtils> createAndInstallIfNeeded(jsi::Runtime &runtime)
+  {
     auto errorUtilsModuleName = "ErrorUtils";
-    auto errorUtilsValue =
-        runtime.global().getProperty(runtime, errorUtilsModuleName);
+    auto errorUtilsValue = runtime.global().getProperty(runtime, errorUtilsModuleName);
 
     if (errorUtilsValue.isUndefined()) {
       auto stubErrorUtils = std::make_shared<StubErrorUtils>();
       auto object = jsi::Object::createFromHostObject(runtime, stubErrorUtils);
-      runtime.global().setProperty(
-          runtime, errorUtilsModuleName, std::move(object));
+      runtime.global().setProperty(runtime, errorUtilsModuleName, std::move(object));
       return stubErrorUtils;
     }
 
@@ -38,7 +36,8 @@ class StubErrorUtils : public jsi::HostObject {
   /*
    * `jsi::HostObject` specific overloads.
    */
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& name) override {
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override
+  {
     auto propertyName = name.utf8(runtime);
 
     if (propertyName == "reportFatalError") {
@@ -47,10 +46,7 @@ class StubErrorUtils : public jsi::HostObject {
           name,
           1,
           [this](
-              jsi::Runtime& runtime,
-              const jsi::Value&,
-              const jsi::Value* arguments,
-              size_t) noexcept -> jsi::Value {
+              jsi::Runtime &runtime, const jsi::Value &, const jsi::Value *arguments, size_t) noexcept -> jsi::Value {
             reportFatalCallCount_++;
             return jsi::Value::undefined();
           });
@@ -59,7 +55,8 @@ class StubErrorUtils : public jsi::HostObject {
     return jsi::Value::undefined();
   }
 
-  int getReportFatalCallCount() const {
+  int getReportFatalCallCount() const
+  {
     return reportFatalCallCount_;
   }
 

package/ReactCommon/react/renderer/runtimescheduler/tests/StubQueue.h

@@ -12,7 +12,8 @@
 
 class StubQueue {
  public:
-  void runOnQueue(std::function<void()>&& func) {
+  void runOnQueue(std::function<void()> &&func)
+  {
     {
       std::lock_guard<std::mutex> lock(mutex_);
       callbackQueue_.push(func);
@@ -21,13 +22,15 @@ class StubQueue {
     signal_.notify_one();
   }
 
-  void flush() {
+  void flush()
+  {
     while (size() > 0) {
       tick();
     }
   }
 
-  void tick() {
+  void tick()
+  {
     std::function<void()> callback;
     {
       std::lock_guard<std::mutex> lock(mutex_);
@@ -42,22 +45,23 @@ class StubQueue {
     }
   }
 
-  size_t size() const {
+  size_t size() const
+  {
     std::lock_guard<std::mutex> lock(mutex_);
     return callbackQueue_.size();
   }
 
-  bool waitForTask() const {
+  bool waitForTask() const
+  {
     std::unique_lock<std::mutex> lock(mutex_);
-    return signal_.wait_for(
-        lock, StubQueue::timeout, [this]() { return !callbackQueue_.empty(); });
+    return signal_.wait_for(lock, StubQueue::timeout, [this]() { return !callbackQueue_.empty(); });
   }
 
-  bool waitForTasks(std::size_t numberOfTasks) const {
+  bool waitForTasks(std::size_t numberOfTasks) const
+  {
     std::unique_lock<std::mutex> lock(mutex_);
-    return signal_.wait_for(lock, StubQueue::timeout, [this, numberOfTasks]() {
-      return numberOfTasks == callbackQueue_.size();
-    });
+    return signal_.wait_for(
+        lock, StubQueue::timeout, [this, numberOfTasks]() { return numberOfTasks == callbackQueue_.size(); });
   }
 
  private:
@@ -65,6 +69,5 @@ class StubQueue {
   mutable std::mutex mutex_;
   std::queue<std::function<void()>> callbackQueue_;
 
-  static constexpr std::chrono::duration<double> timeout =
-      std::chrono::milliseconds(100);
+  static constexpr std::chrono::duration<double> timeout = std::chrono::milliseconds(100);
 };

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -24,33 +24,6 @@
 
 namespace facebook::react {
 
-namespace {
-
-class UIManagerCommitHookManagerImpl : public UIManagerCommitHookManager {
- public:
-  explicit UIManagerCommitHookManagerImpl(std::weak_ptr<UIManager> uiManager)
-      : uiManager_(std::move(uiManager)) {}
-
-  ~UIManagerCommitHookManagerImpl() override = default;
-
-  void registerCommitHook(UIManagerCommitHook& commitHook) override {
-    if (auto uiManager = uiManager_.lock()) {
-      uiManager->registerCommitHook(commitHook);
-    }
-  }
-
-  void unregisterCommitHook(UIManagerCommitHook& commitHook) override {
-    if (auto uiManager = uiManager_.lock()) {
-      uiManager->unregisterCommitHook(commitHook);
-    }
-  }
-
- private:
-  std::weak_ptr<UIManager> uiManager_;
-};
-
-} // namespace
-
 Scheduler::Scheduler(
     const SchedulerToolbox& schedulerToolbox,
     UIManagerAnimationDelegate* animationDelegate,
@@ -68,7 +41,12 @@ Scheduler::Scheduler(
   if (ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
       ReactNativeFeatureFlags::cdpInteractionMetricsEnabled()) {
     cdpMetricsReporter_.emplace(CdpMetricsReporter{runtimeExecutor_});
-    performanceEntryReporter_->addEventTimingListener(&*cdpMetricsReporter_);
+    performanceEntryReporter_->addEventListener(&*cdpMetricsReporter_);
+  }
+
+  if (ReactNativeFeatureFlags::perfIssuesEnabled()) {
+    cdpPerfIssuesReporter_.emplace(CdpPerfIssuesReporter{runtimeExecutor_});
+    performanceEntryReporter_->addEventListener(&*cdpPerfIssuesReporter_);
   }
 
   eventPerformanceLogger_ =
@@ -76,11 +54,6 @@ Scheduler::Scheduler(
 
   auto uiManager =
       std::make_shared<UIManager>(runtimeExecutor_, contextContainer_);
-  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
-    contextContainer_->insert(
-        std::string(UIManagerCommitHookManagerKey),
-        std::make_shared<UIManagerCommitHookManagerImpl>(uiManager));
-  }
 
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
@@ -204,7 +177,10 @@ Scheduler::~Scheduler() {
   uiManager_->setAnimationDelegate(nullptr);
 
   if (cdpMetricsReporter_) {
-    performanceEntryReporter_->removeEventTimingListener(&*cdpMetricsReporter_);
+    performanceEntryReporter_->removeEventListener(&*cdpMetricsReporter_);
+  }
+  if (cdpPerfIssuesReporter_) {
+    performanceEntryReporter_->removeEventListener(&*cdpPerfIssuesReporter_);
   }
 
   // Then, let's verify that the requirement was satisfied.
@@ -315,8 +291,8 @@ void Scheduler::uiManagerDidDispatchCommand(
     const std::shared_ptr<const ShadowNode>& shadowNode,
     const std::string& commandName,
     const folly::dynamic& args) {
-  TraceSection s("Scheduler::uiManagerDispatchCommand");
-
+  TraceSection s(
+      "Scheduler::uiManagerDispatchCommand", "commandName", commandName);
   if (delegate_ != nullptr) {
     auto shadowView = ShadowView(*shadowNode);
     runtimeScheduler_->scheduleRenderingUpdate(

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -11,6 +11,7 @@
 
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/performance/cdpmetrics/CdpMetricsReporter.h>
+#include <react/performance/cdpmetrics/CdpPerfIssuesReporter.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/ComponentDescriptor.h>
@@ -36,9 +37,9 @@ namespace facebook::react {
 class Scheduler final : public UIManagerDelegate {
  public:
   Scheduler(
-      const SchedulerToolbox& schedulerToolbox,
-      UIManagerAnimationDelegate* animationDelegate,
-      SchedulerDelegate* delegate);
+      const SchedulerToolbox &schedulerToolbox,
+      UIManagerAnimationDelegate *animationDelegate,
+      SchedulerDelegate *delegate);
   ~Scheduler() override;
 
 #pragma mark - Surface Management
@@ -48,17 +49,15 @@ class Scheduler final : public UIManagerDelegate {
    * All registered `SurfaceHandler` objects must be unregistered
    * (with the same `Scheduler`) before their deallocation.
    */
-  void registerSurface(const SurfaceHandler& surfaceHandler) const noexcept;
-  void unregisterSurface(const SurfaceHandler& surfaceHandler) const noexcept;
+  void registerSurface(const SurfaceHandler &surfaceHandler) const noexcept;
+  void unregisterSurface(const SurfaceHandler &surfaceHandler) const noexcept;
 
   /*
    * This is broken. Please do not use.
    * `ComponentDescriptor`s are not designed to be used outside of `UIManager`,
    * there is no any guarantees about their lifetime.
    */
-  const ComponentDescriptor*
-  findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
-      ComponentHandle handle) const;
+  const ComponentDescriptor *findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(ComponentHandle handle) const;
 
 #pragma mark - Delegate
 
@@ -67,8 +66,8 @@ class Scheduler final : public UIManagerDelegate {
    * If you requesting a ComponentDescriptor and unsure that it's there, you are
    * doing something wrong.
    */
-  void setDelegate(SchedulerDelegate* delegate);
-  SchedulerDelegate* getDelegate() const;
+  void setDelegate(SchedulerDelegate *delegate);
+  SchedulerDelegate *getDelegate() const;
 
 #pragma mark - UIManagerAnimationDelegate
   // This is not needed on iOS or any platform that has a "pull" instead of
@@ -82,28 +81,23 @@ class Scheduler final : public UIManagerDelegate {
   void uiManagerDidFinishTransaction(
       std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) override;
-  void uiManagerDidCreateShadowNode(const ShadowNode& shadowNode) override;
+  void uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) override;
   void uiManagerDidDispatchCommand(
-      const std::shared_ptr<const ShadowNode>& shadowNode,
-      const std::string& commandName,
-      const folly::dynamic& args) override;
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::string &commandName,
+      const folly::dynamic &args) override;
   void uiManagerDidSendAccessibilityEvent(
-      const std::shared_ptr<const ShadowNode>& shadowNode,
-      const std::string& eventType) override;
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::string &eventType) override;
   void uiManagerDidSetIsJSResponder(
-      const std::shared_ptr<const ShadowNode>& shadowNode,
+      const std::shared_ptr<const ShadowNode> &shadowNode,
       bool isJSResponder,
       bool blockNativeResponder) override;
-  void uiManagerShouldSynchronouslyUpdateViewOnUIThread(
-      Tag tag,
-      const folly::dynamic& props) override;
-  void uiManagerDidUpdateShadowTree(
-      const std::unordered_map<Tag, folly::dynamic>& tagToProps) override;
-  void uiManagerShouldAddEventListener(
-      std::shared_ptr<const EventListener> listener) final;
-  void uiManagerShouldRemoveEventListener(
-      const std::shared_ptr<const EventListener>& listener) final;
-  void uiManagerDidStartSurface(const ShadowTree& shadowTree) override;
+  void uiManagerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) override;
+  void uiManagerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
+  void uiManagerShouldAddEventListener(std::shared_ptr<const EventListener> listener) final;
+  void uiManagerShouldRemoveEventListener(const std::shared_ptr<const EventListener> &listener) final;
+  void uiManagerDidStartSurface(const ShadowTree &shadowTree) override;
 
 #pragma mark - ContextContainer
   std::shared_ptr<const ContextContainer> getContextContainer() const;
@@ -115,17 +109,15 @@ class Scheduler final : public UIManagerDelegate {
 
 #pragma mark - Event listeners
   void addEventListener(std::shared_ptr<const EventListener> listener);
-  void removeEventListener(
-      const std::shared_ptr<const EventListener>& listener);
+  void removeEventListener(const std::shared_ptr<const EventListener> &listener);
 
 #pragma mark - Surface start callback
-  void uiManagerShouldSetOnSurfaceStartCallback(
-      OnSurfaceStartCallback&& callback) override;
+  void uiManagerShouldSetOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) override;
 
  private:
   friend class SurfaceHandler;
 
-  SchedulerDelegate* delegate_;
+  SchedulerDelegate *delegate_;
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   RuntimeExecutor runtimeExecutor_;
   std::shared_ptr<UIManager> uiManager_;
@@ -143,6 +135,7 @@ class Scheduler final : public UIManagerDelegate {
 
   std::shared_ptr<PerformanceEntryReporter> performanceEntryReporter_;
   std::optional<CdpMetricsReporter> cdpMetricsReporter_;
+  std::optional<CdpPerfIssuesReporter> cdpPerfIssuesReporter_;
   std::shared_ptr<EventPerformanceLogger> eventPerformanceLogger_;
 
   /**
@@ -151,7 +144,7 @@ class Scheduler final : public UIManagerDelegate {
    */
   std::shared_ptr<const ContextContainer> contextContainer_;
 
-  RuntimeScheduler* runtimeScheduler_{nullptr};
+  RuntimeScheduler *runtimeScheduler_{nullptr};
 
   mutable std::shared_mutex onSurfaceStartCallbackMutex_;
   OnSurfaceStartCallback onSurfaceStartCallback_;