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

package/ReactCommon/react/performance/cdpmetrics/CdpPerfIssuesReporter.h

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <react/performance/timeline/PerformanceEntry.h>
+#include <react/performance/timeline/PerformanceEntryReporterListeners.h>
+#include <react/timing/primitives.h>
+
+namespace facebook::react {
+
+/**
+ * [Experimental] Reports new Performance Issues via the
+ * "__react_native_perf_issues_reporter" runtime binding.
+ *
+ * This populates the Perf Issues indicator in the V2 Perf Monitor. Events are
+ * reported immediately and do not require an active CDP Tracing session.
+ */
+class CdpPerfIssuesReporter : public PerformanceEntryReporterEventListener {
+ public:
+  explicit CdpPerfIssuesReporter(RuntimeExecutor runtimeExecutor);
+
+  void onMeasureEntry(const PerformanceMeasure &entry, const std::optional<UserTimingDetailProvider> &detailProvider)
+      override;
+
+ private:
+  const RuntimeExecutor runtimeExecutor_{};
+};
+
+} // namespace facebook::react

package/ReactCommon/react/performance/timeline/CircularBuffer.h

@@ -25,7 +25,8 @@ namespace facebook::react {
 template <class T>
 class CircularBuffer {
  public:
-  explicit CircularBuffer(size_t maxSize) : maxSize_(maxSize) {
+  explicit CircularBuffer(size_t maxSize) : maxSize_(maxSize)
+  {
     entries_.reserve(maxSize_);
   }
 
@@ -36,7 +37,8 @@ class CircularBuffer {
    * buffer reached the max allowed size, in which case `true` is returned. If
    * no items were overridden `false` is returned.
    */
-  bool add(const T& el) {
+  bool add(const T &el)
+  {
     if (entries_.size() < maxSize_) {
       // Haven't reached max buffer size yet, just add and grow the buffer
       entries_.emplace_back(el);
@@ -49,15 +51,18 @@ class CircularBuffer {
     }
   }
 
-  T& operator[](size_t idx) {
+  T &operator[](size_t idx)
+  {
     return entries_[(position_ + idx) % entries_.size()];
   }
 
-  size_t size() const {
+  size_t size() const
+  {
     return entries_.size();
   }
 
-  void clear() {
+  void clear()
+  {
     entries_.clear();
     position_ = 0;
   }
@@ -65,12 +70,13 @@ class CircularBuffer {
   /**
    * Clears buffer entries by predicate
    */
-  void clear(std::function<bool(const T&)> predicate) {
+  void clear(std::function<bool(const T &)> predicate)
+  {
     std::vector<T> entries;
 
     entries.reserve(maxSize_);
     for (size_t i = 0; i < entries_.size(); i++) {
-      T& el = entries_[(i + position_) % entries_.size()];
+      T &el = entries_[(i + position_) % entries_.size()];
       if (predicate(el)) {
         continue;
       }
@@ -85,7 +91,8 @@ class CircularBuffer {
   /**
    * Retrieves buffer entries, whether consumed or not
    */
-  std::vector<T> getEntries() const {
+  std::vector<T> getEntries() const
+  {
     std::vector<T> res;
     getEntries(res);
     return res;
@@ -94,27 +101,25 @@ class CircularBuffer {
   /**
    * Retrieves buffer entries, whether consumed or not, with predicate
    */
-  std::vector<T> getEntries(std::function<bool(const T&)> predicate) const {
+  std::vector<T> getEntries(std::function<bool(const T &)> predicate) const
+  {
     std::vector<T> res;
     getEntries(res, predicate);
     return res;
   }
 
-  void getEntries(std::vector<T>& res) const {
+  void getEntries(std::vector<T> &res) const
+  {
     const size_t oldSize = res.size();
     res.resize(oldSize + entries_.size());
-    std::copy(
-        entries_.begin() + position_, entries_.end(), res.begin() + oldSize);
-    std::copy(
-        entries_.begin(),
-        entries_.begin() + position_,
-        res.begin() + oldSize + entries_.size() - position_);
+    std::copy(entries_.begin() + position_, entries_.end(), res.begin() + oldSize);
+    std::copy(entries_.begin(), entries_.begin() + position_, res.begin() + oldSize + entries_.size() - position_);
   }
 
-  void getEntries(std::vector<T>& res, std::function<bool(const T&)> predicate)
-      const {
+  void getEntries(std::vector<T> &res, std::function<bool(const T &)> predicate) const
+  {
     for (size_t i = 0; i < entries_.size(); i++) {
-      const T& el = entries_[(i + position_) % entries_.size()];
+      const T &el = entries_[(i + position_) % entries_.size()];
       if (predicate(el)) {
         res.push_back(el);
       }

package/ReactCommon/react/performance/timeline/PerformanceEntry.h

@@ -38,8 +38,7 @@ struct PerformanceMark : AbstractPerformanceEntry {
 };
 
 struct PerformanceMeasure : AbstractPerformanceEntry {
-  static constexpr PerformanceEntryType entryType =
-      PerformanceEntryType::MEASURE;
+  static constexpr PerformanceEntryType entryType = PerformanceEntryType::MEASURE;
 };
 
 struct PerformanceEventTiming : AbstractPerformanceEntry {
@@ -54,13 +53,11 @@ struct PerformanceEventTiming : AbstractPerformanceEntry {
 };
 
 struct PerformanceLongTaskTiming : AbstractPerformanceEntry {
-  static constexpr PerformanceEntryType entryType =
-      PerformanceEntryType::LONGTASK;
+  static constexpr PerformanceEntryType entryType = PerformanceEntryType::LONGTASK;
 };
 
 struct PerformanceResourceTiming : AbstractPerformanceEntry {
-  static constexpr PerformanceEntryType entryType =
-      PerformanceEntryType::RESOURCE;
+  static constexpr PerformanceEntryType entryType = PerformanceEntryType::RESOURCE;
   /** Aligns with `startTime`. */
   HighResTimeStamp fetchStart;
   HighResTimeStamp requestStart;
@@ -69,7 +66,10 @@ struct PerformanceResourceTiming : AbstractPerformanceEntry {
   std::optional<HighResTimeStamp> responseStart;
   /** Aligns with `duration`. */
   std::optional<HighResTimeStamp> responseEnd;
-  std::optional<int> responseStatus;
+  int responseStatus;
+  std::string contentType;
+  int encodedBodySize;
+  int decodedBodySize;
 };
 
 using PerformanceEntry = std::variant<
@@ -80,9 +80,10 @@ using PerformanceEntry = std::variant<
     PerformanceResourceTiming>;
 
 struct PerformanceEntrySorter {
-  bool operator()(const PerformanceEntry& lhs, const PerformanceEntry& rhs) {
+  bool operator()(const PerformanceEntry &lhs, const PerformanceEntry &rhs)
+  {
     return std::visit(
-        [](const auto& left, const auto& right) {
+        [](const auto &left, const auto &right) {
           if (left.startTime != right.startTime) {
             return left.startTime < right.startTime;
           }

package/ReactCommon/react/performance/timeline/PerformanceEntryBuffer.h

@@ -28,13 +28,11 @@ class PerformanceEntryBuffer {
   explicit PerformanceEntryBuffer() = default;
   virtual ~PerformanceEntryBuffer() = default;
 
-  virtual void add(const PerformanceEntry& entry) = 0;
-  virtual void getEntries(std::vector<PerformanceEntry>& target) const = 0;
-  virtual void getEntries(
-      std::vector<PerformanceEntry>& target,
-      const std::string& name) const = 0;
+  virtual void add(const PerformanceEntry &entry) = 0;
+  virtual void getEntries(std::vector<PerformanceEntry> &target) const = 0;
+  virtual void getEntries(std::vector<PerformanceEntry> &target, const std::string &name) const = 0;
   virtual void clear() = 0;
-  virtual void clear(const std::string& name) = 0;
+  virtual void clear(const std::string &name) = 0;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/performance/timeline/PerformanceEntryCircularBuffer.h

@@ -17,15 +17,13 @@ class PerformanceEntryCircularBuffer : public PerformanceEntryBuffer {
   explicit PerformanceEntryCircularBuffer(size_t size) : buffer_(size) {}
   ~PerformanceEntryCircularBuffer() override = default;
 
-  void add(const PerformanceEntry& entry) override;
+  void add(const PerformanceEntry &entry) override;
 
-  void getEntries(std::vector<PerformanceEntry>& target) const override;
-  void getEntries(
-      std::vector<PerformanceEntry>& target,
-      const std::string& name) const override;
+  void getEntries(std::vector<PerformanceEntry> &target) const override;
+  void getEntries(std::vector<PerformanceEntry> &target, const std::string &name) const override;
 
   void clear() override;
-  void clear(const std::string& name) override;
+  void clear(const std::string &name) override;
 
  private:
   CircularBuffer<PerformanceEntry> buffer_;

package/ReactCommon/react/performance/timeline/PerformanceEntryKeyedBuffer.h

@@ -18,18 +18,16 @@ class PerformanceEntryKeyedBuffer : public PerformanceEntryBuffer {
  public:
   PerformanceEntryKeyedBuffer() = default;
 
-  void add(const PerformanceEntry& entry) override;
+  void add(const PerformanceEntry &entry) override;
 
-  void getEntries(std::vector<PerformanceEntry>& target) const override;
+  void getEntries(std::vector<PerformanceEntry> &target) const override;
 
-  void getEntries(
-      std::vector<PerformanceEntry>& target,
-      const std::string& name) const override;
+  void getEntries(std::vector<PerformanceEntry> &target, const std::string &name) const override;
 
   void clear() override;
-  void clear(const std::string& name) override;
+  void clear(const std::string &name) override;
 
-  std::optional<PerformanceEntry> find(const std::string& name) const;
+  std::optional<PerformanceEntry> find(const std::string &name) const;
 
  private:
   std::unordered_map<std::string, std::vector<PerformanceEntry>> entryMap_{};

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.cpp

@@ -88,19 +88,18 @@ PerformanceEntryReporter::PerformanceEntryReporter()
 #endif
 }
 
-void PerformanceEntryReporter::addEventTimingListener(
-    PerformanceEntryReporterEventTimingListener* listener) {
+void PerformanceEntryReporter::addEventListener(
+    PerformanceEntryReporterEventListener* listener) {
   std::unique_lock lock(listenersMutex_);
-  eventTimingListeners_.push_back(listener);
+  eventListeners_.push_back(listener);
 }
 
-void PerformanceEntryReporter::removeEventTimingListener(
-    PerformanceEntryReporterEventTimingListener* listener) {
+void PerformanceEntryReporter::removeEventListener(
+    PerformanceEntryReporterEventListener* listener) {
   std::unique_lock lock(listenersMutex_);
-  auto it = std::find(
-      eventTimingListeners_.begin(), eventTimingListeners_.end(), listener);
-  if (it != eventTimingListeners_.end()) {
-    eventTimingListeners_.erase(it);
+  auto it = std::find(eventListeners_.begin(), eventListeners_.end(), listener);
+  if (it != eventListeners_.end()) {
+    eventListeners_.erase(it);
   }
 }
 
@@ -208,13 +207,13 @@ void PerformanceEntryReporter::reportMeasure(
     const std::string& name,
     HighResTimeStamp startTime,
     HighResDuration duration,
-    UserTimingDetailProvider&& detailProvider) {
+    const std::optional<UserTimingDetailProvider>& detailProvider) {
   const auto entry = PerformanceMeasure{
       {.name = std::string(name),
        .startTime = startTime,
        .duration = duration}};
 
-  traceMeasure(entry, std::move(detailProvider));
+  traceMeasure(entry, detailProvider);
 
   // Add to buffers & notify observers
   {
@@ -223,6 +222,16 @@ void PerformanceEntryReporter::reportMeasure(
   }
 
   observerRegistry_->queuePerformanceEntry(entry);
+
+  std::vector<PerformanceEntryReporterEventListener*> listenersCopy;
+  {
+    std::shared_lock lock(listenersMutex_);
+    listenersCopy = eventListeners_;
+  }
+
+  for (auto* listener : listenersCopy) {
+    listener->onMeasureEntry(entry, detailProvider);
+  }
 }
 
 void PerformanceEntryReporter::clearEventCounts() {
@@ -272,10 +281,10 @@ void PerformanceEntryReporter::reportEvent(
   // TODO(T198982346): Log interaction events to jsinspector_modern
   observerRegistry_->queuePerformanceEntry(entry);
 
-  std::vector<PerformanceEntryReporterEventTimingListener*> listenersCopy;
+  std::vector<PerformanceEntryReporterEventListener*> listenersCopy;
   {
     std::shared_lock lock(listenersMutex_);
-    listenersCopy = eventTimingListeners_;
+    listenersCopy = eventListeners_;
   }
 
   for (auto* listener : listenersCopy) {
@@ -297,16 +306,6 @@ void PerformanceEntryReporter::reportLongTask(
   }
 
   observerRegistry_->queuePerformanceEntry(entry);
-
-  std::vector<PerformanceEntryReporterEventTimingListener*> listenersCopy;
-  {
-    std::shared_lock lock(listenersMutex_);
-    listenersCopy = eventTimingListeners_;
-  }
-
-  for (auto* listener : listenersCopy) {
-    listener->onLongTaskEntry(entry);
-  }
 }
 
 void PerformanceEntryReporter::reportResourceTiming(
@@ -317,7 +316,10 @@ void PerformanceEntryReporter::reportResourceTiming(
     std::optional<HighResTimeStamp> connectEnd,
     HighResTimeStamp responseStart,
     HighResTimeStamp responseEnd,
-    const std::optional<int>& responseStatus) {
+    int responseStatus,
+    const std::string& contentType,
+    int encodedBodySize,
+    int decodedBodySize) {
   const auto entry = PerformanceResourceTiming{
       {.name = url, .startTime = fetchStart},
       fetchStart,
@@ -327,6 +329,9 @@ void PerformanceEntryReporter::reportResourceTiming(
       responseStart,
       responseEnd,
       responseStatus,
+      contentType,
+      encodedBodySize,
+      decodedBodySize,
   };
 
   // Add to buffers & notify observers
@@ -358,11 +363,13 @@ void PerformanceEntryReporter::traceMark(
 
 void PerformanceEntryReporter::traceMeasure(
     const PerformanceMeasure& entry,
-    UserTimingDetailProvider&& detailProvider) const {
+    const std::optional<UserTimingDetailProvider>& detailProvider) const {
   auto& performanceTracer =
       jsinspector_modern::tracing::PerformanceTracer::getInstance();
   if (performanceTracer.isTracing() || ReactPerfettoLogger::isTracing()) {
-    auto detail = detailProvider != nullptr ? detailProvider() : nullptr;
+    auto detail = detailProvider && detailProvider.has_value()
+        ? (*detailProvider)()
+        : nullptr;
 
     if (ReactPerfettoLogger::isTracing()) {
       ReactPerfettoLogger::measure(

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.h

@@ -28,8 +28,7 @@ constexpr size_t EVENT_BUFFER_SIZE = 150;
 constexpr size_t LONG_TASK_BUFFER_SIZE = 200;
 constexpr size_t RESOURCE_TIMING_BUFFER_SIZE = 250;
 
-constexpr HighResDuration LONG_TASK_DURATION_THRESHOLD =
-    HighResDuration::fromMilliseconds(50);
+constexpr HighResDuration LONG_TASK_DURATION_THRESHOLD = HighResDuration::fromMilliseconds(50);
 
 class PerformanceEntryReporter {
  public:
@@ -39,68 +38,56 @@ class PerformanceEntryReporter {
   // the same thread.
   // TODO: Consider passing it as a parameter to the corresponding modules at
   // creation time instead of having the singleton.
-  static std::shared_ptr<PerformanceEntryReporter>& getInstance();
+  static std::shared_ptr<PerformanceEntryReporter> &getInstance();
 
-  PerformanceObserverRegistry& getObserverRegistry() {
+  PerformanceObserverRegistry &getObserverRegistry()
+  {
     return *observerRegistry_;
   }
 
   std::vector<PerformanceEntry> getEntries() const;
-  void getEntries(std::vector<PerformanceEntry>& dest) const;
-
-  std::vector<PerformanceEntry> getEntries(
-      PerformanceEntryType entryType) const;
-  void getEntries(
-      std::vector<PerformanceEntry>& dest,
-      PerformanceEntryType entryType) const;
-
-  std::vector<PerformanceEntry> getEntries(
-      PerformanceEntryType entryType,
-      const std::string& entryName) const;
-  void getEntries(
-      std::vector<PerformanceEntry>& dest,
-      PerformanceEntryType entryType,
-      const std::string& entryName) const;
+  void getEntries(std::vector<PerformanceEntry> &dest) const;
+
+  std::vector<PerformanceEntry> getEntries(PerformanceEntryType entryType) const;
+  void getEntries(std::vector<PerformanceEntry> &dest, PerformanceEntryType entryType) const;
+
+  std::vector<PerformanceEntry> getEntries(PerformanceEntryType entryType, const std::string &entryName) const;
+  void getEntries(std::vector<PerformanceEntry> &dest, PerformanceEntryType entryType, const std::string &entryName)
+      const;
 
   void clearEntries();
   void clearEntries(PerformanceEntryType entryType);
-  void clearEntries(
-      PerformanceEntryType entryType,
-      const std::string& entryName);
+  void clearEntries(PerformanceEntryType entryType, const std::string &entryName);
 
-  void addEventTimingListener(
-      PerformanceEntryReporterEventTimingListener* listener);
-  void removeEventTimingListener(
-      PerformanceEntryReporterEventTimingListener* listener);
+  void addEventListener(PerformanceEntryReporterEventListener *listener);
+  void removeEventListener(PerformanceEntryReporterEventListener *listener);
 
   static std::vector<PerformanceEntryType> getSupportedEntryTypes();
 
   uint32_t getDroppedEntriesCount(PerformanceEntryType type) const noexcept;
 
-  const std::unordered_map<std::string, uint32_t>& getEventCounts() const {
+  const std::unordered_map<std::string, uint32_t> &getEventCounts() const
+  {
     return eventCounts_;
   }
 
   void clearEventCounts();
 
-  std::optional<HighResTimeStamp> getMarkTime(
-      const std::string& markName) const;
+  std::optional<HighResTimeStamp> getMarkTime(const std::string &markName) const;
 
   using UserTimingDetailProvider = std::function<folly::dynamic()>;
 
-  void reportMark(
-      const std::string& name,
-      HighResTimeStamp startTime,
-      UserTimingDetailProvider&& detailProvider = nullptr);
+  void
+  reportMark(const std::string &name, HighResTimeStamp startTime, UserTimingDetailProvider &&detailProvider = nullptr);
 
   void reportMeasure(
-      const std::string& name,
+      const std::string &name,
       HighResTimeStamp startTime,
       HighResDuration duration,
-      UserTimingDetailProvider&& detailProvider = nullptr);
+      const std::optional<UserTimingDetailProvider> &detailProvider = std::nullopt);
 
   void reportEvent(
-      const std::string& name,
+      const std::string &name,
       HighResTimeStamp startTime,
       HighResDuration duration,
       HighResTimeStamp processingStart,
@@ -111,14 +98,17 @@ class PerformanceEntryReporter {
   void reportLongTask(HighResTimeStamp startTime, HighResDuration duration);
 
   void reportResourceTiming(
-      const std::string& url,
+      const std::string &url,
       HighResTimeStamp fetchStart,
       HighResTimeStamp requestStart,
       std::optional<HighResTimeStamp> connectStart,
       std::optional<HighResTimeStamp> connectEnd,
       HighResTimeStamp responseStart,
       HighResTimeStamp responseEnd,
-      const std::optional<int>& responseStatus);
+      int responseStatus,
+      const std::string &contentType,
+      int encodedBodySize,
+      int decodedBodySize);
 
  private:
   std::unique_ptr<PerformanceObserverRegistry> observerRegistry_;
@@ -126,19 +116,17 @@ class PerformanceEntryReporter {
   mutable std::shared_mutex buffersMutex_;
   PerformanceEntryCircularBuffer eventBuffer_{EVENT_BUFFER_SIZE};
   PerformanceEntryCircularBuffer longTaskBuffer_{LONG_TASK_BUFFER_SIZE};
-  PerformanceEntryCircularBuffer resourceTimingBuffer_{
-      RESOURCE_TIMING_BUFFER_SIZE};
+  PerformanceEntryCircularBuffer resourceTimingBuffer_{RESOURCE_TIMING_BUFFER_SIZE};
   PerformanceEntryKeyedBuffer markBuffer_;
   PerformanceEntryKeyedBuffer measureBuffer_;
 
   std::unordered_map<std::string, uint32_t> eventCounts_;
 
   mutable std::shared_mutex listenersMutex_;
-  std::vector<PerformanceEntryReporterEventTimingListener*>
-      eventTimingListeners_{};
+  std::vector<PerformanceEntryReporterEventListener *> eventListeners_{};
 
-  const inline PerformanceEntryBuffer& getBuffer(
-      PerformanceEntryType entryType) const {
+  const inline PerformanceEntryBuffer &getBuffer(PerformanceEntryType entryType) const
+  {
     switch (entryType) {
       case PerformanceEntryType::EVENT:
         return eventBuffer_;
@@ -157,7 +145,8 @@ class PerformanceEntryReporter {
     }
   }
 
-  inline PerformanceEntryBuffer& getBufferRef(PerformanceEntryType entryType) {
+  inline PerformanceEntryBuffer &getBufferRef(PerformanceEntryType entryType)
+  {
     switch (entryType) {
       case PerformanceEntryType::EVENT:
         return eventBuffer_;
@@ -176,12 +165,14 @@ class PerformanceEntryReporter {
     }
   }
 
-  void traceMark(
-      const PerformanceMark& entry,
-      UserTimingDetailProvider&& detailProvider) const;
-  void traceMeasure(
-      const PerformanceMeasure& entry,
-      UserTimingDetailProvider&& detailProvider) const;
+  void traceMark(const PerformanceMark &entry, UserTimingDetailProvider &&detailProvider) const;
+  void traceMeasure(const PerformanceMeasure &entry, const std::optional<UserTimingDetailProvider> &detailProvider)
+      const;
+  void traceResourceTiming(
+      const PerformanceResourceTiming &entry,
+      const std::optional<std::string> &devtoolsRequestId,
+      const std::optional<std::string> &requestMethod,
+      const std::optional<std::string> &resourceType) const;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/performance/timeline/PerformanceEntryReporterListeners.h

@@ -14,13 +14,19 @@
 
 namespace facebook::react {
 
-class PerformanceEntryReporterEventTimingListener {
+using UserTimingDetailProvider = std::function<folly::dynamic()>;
+
+class PerformanceEntryReporterEventListener {
  public:
-  virtual ~PerformanceEntryReporterEventTimingListener() = default;
+  virtual ~PerformanceEntryReporterEventListener() = default;
 
-  virtual void onEventTimingEntry(const PerformanceEventTiming& /*entry*/) {}
+  virtual void onMeasureEntry(
+      const PerformanceMeasure & /*entry*/,
+      const std::optional<UserTimingDetailProvider> & /*detailProvider*/)
+  {
+  }
 
-  virtual void onLongTaskEntry(const PerformanceLongTaskTiming& /*entry*/) {}
+  virtual void onEventTimingEntry(const PerformanceEventTiming & /*entry*/) {}
 };
 
 } // namespace facebook::react

package/ReactCommon/react/performance/timeline/PerformanceObserver.h

@@ -19,8 +19,7 @@
 
 namespace facebook::react {
 
-using PerformanceObserverEntryTypeFilter =
-    std::unordered_set<PerformanceEntryType>;
+using PerformanceObserverEntryTypeFilter = std::unordered_set<PerformanceEntryType>;
 using PerformanceObserverCallback = std::function<void()>;
 
 /**
@@ -52,8 +51,7 @@ struct PerformanceObserverObserveSingleOptions {
  * Entries are pushed to the observer by the `PerformanceEntryReporter` class,
  * through the `PerformanceObserverRegistry` class which acts as a central hub.
  */
-class PerformanceObserver
-    : public std::enable_shared_from_this<PerformanceObserver> {
+class PerformanceObserver : public std::enable_shared_from_this<PerformanceObserver> {
  private:
   struct PrivateUseCreateMethod {
     explicit PrivateUseCreateMethod() = default;
@@ -62,15 +60,17 @@ class PerformanceObserver
  public:
   explicit PerformanceObserver(
       PrivateUseCreateMethod /*unused*/,
-      PerformanceObserverRegistry& registry,
-      PerformanceObserverCallback&& callback)
-      : registry_(registry), callback_(std::move(callback)) {}
+      PerformanceObserverRegistry &registry,
+      PerformanceObserverCallback &&callback)
+      : registry_(registry), callback_(std::move(callback))
+  {
+  }
 
   static std::shared_ptr<PerformanceObserver> create(
-      PerformanceObserverRegistry& registry,
-      PerformanceObserverCallback&& callback) {
-    return std::make_shared<PerformanceObserver>(
-        PrivateUseCreateMethod(), registry, std::move(callback));
+      PerformanceObserverRegistry &registry,
+      PerformanceObserverCallback &&callback)
+  {
+    return std::make_shared<PerformanceObserver>(PrivateUseCreateMethod(), registry, std::move(callback));
   }
 
   ~PerformanceObserver() = default;
@@ -78,7 +78,7 @@ class PerformanceObserver
   /**
    * Append entry to the buffer if this observer should handle this entry.
    */
-  void handleEntry(const PerformanceEntry& entry);
+  void handleEntry(const PerformanceEntry &entry);
 
   /**
    * Returns current observer buffer and clears it.
@@ -95,9 +95,7 @@ class PerformanceObserver
    * calls to this methods remove any previous watch configuration (as per
    * spec).
    */
-  void observe(
-      PerformanceEntryType type,
-      PerformanceObserverObserveSingleOptions options = {});
+  void observe(PerformanceEntryType type, PerformanceObserverObserveSingleOptions options = {});
 
   /**
    * Configures the observer to watch for specified entry type.
@@ -122,7 +120,7 @@ class PerformanceObserver
  private:
   void scheduleFlushBuffer();
 
-  PerformanceObserverRegistry& registry_;
+  PerformanceObserverRegistry &registry_;
   PerformanceObserverCallback callback_;
   PerformanceObserverEntryTypeFilter observedTypes_;
 
@@ -133,9 +131,8 @@ class PerformanceObserver
   bool requiresDroppedEntries_ = false;
 };
 
-inline bool operator==(
-    const PerformanceObserver& lhs,
-    const PerformanceObserver& rhs) {
+inline bool operator==(const PerformanceObserver &lhs, const PerformanceObserver &rhs)
+{
   return &lhs == &rhs;
 }