Fix crash in PerformanceEntrySorter comparator (#56388)

Summary:
Pull Request resolved: https://github.com/facebook/react-native/pull/56388

Fixed a SIGSEGV crash in the Performance API that occurred when sorting performance entries. The crash was caused by the PerformanceEntrySorter comparator missing the const qualifier on its operator() method.

The PerformanceEntrySorter::operator() was not marked as const, which violates the requirements for comparators used with std::stable_sort. This caused undefined behavior and crashes on Android when sorting performance entries.

Added the const qualifier to PerformanceEntrySorter::operator()() to ensure it's properly const-qualified for use with STL sorting algorithms.

Changelog: [General][Fixed] - Fix crash in Performance API when sorting entries

Reviewed By: rubennorte

Differential Revision: D98674156

fbshipit-source-id: f6cdca0dcaaeb047e829bd30374ff70afbb68c43
This commit is contained in:
Peter Abbondanzo authored and meta-codesync[bot] committed 2026-04-09 13:32:35 -07:00
1 parent 5f861ce1cd
commit 81c99682a4
2 files changed
+63 -1

No files matched your search

@@ -80,7 +80,7 @@ using PerformanceEntry = std::variant<
PerformanceResourceTiming>;
struct PerformanceEntrySorter {
bool operator()(const PerformanceEntry &lhs, const PerformanceEntry &rhs)
bool operator()(const PerformanceEntry &lhs, const PerformanceEntry &rhs) const
{
return std::visit(
[](const auto &left, const auto &right) {
@@ -0,0 +1,62 @@
/*
* 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 <gtest/gtest.h>
#include <algorithm>
#include <type_traits>
#include <vector>
#include "../PerformanceEntry.h"
using namespace facebook::react;
// Verify that PerformanceEntrySorter::operator() is const-qualified.
// Without const, std::stable_sort may fail to compile on toolchains where
// the comparator is passed through a const-qualified code path (e.g.
// libc++ __insertion_sort on NDK 19.x), causing SIGSEGV at runtime on
// others. See T263807207.
TEST(PerformanceEntry, SorterOperatorIsConst) {
static_assert(
std::is_invocable_v<
const PerformanceEntrySorter,
const PerformanceEntry&,
const PerformanceEntry&>,
"PerformanceEntrySorter::operator() must be const-qualified");
}
TEST(PerformanceEntry, SortEntriesByStartTimeThenDuration) {
auto t0 = HighResTimeStamp::now();
auto t1 = t0 + HighResDuration::fromMilliseconds(1);
auto t2 = t0 + HighResDuration::fromMilliseconds(2);
std::vector<PerformanceEntry> entries = {
PerformanceMark{{.name = "c", .startTime = t2}},
PerformanceMark{{.name = "a", .startTime = t0}},
PerformanceMeasure{
{.name = "b",
.startTime = t0,
.duration = HighResDuration::fromMilliseconds(5)}},
PerformanceMark{
{.name = "d", .startTime = t1, .duration = HighResDuration::zero()}},
};
std::stable_sort(entries.begin(), entries.end(), PerformanceEntrySorter{});
// Entries with same startTime are ordered by duration (ascending).
// "a" (t0, dur=0) < "b" (t0, dur=5) < "d" (t1, dur=0) < "c" (t2, dur=0)
ASSERT_EQ(4, entries.size());
auto getName = [](const PerformanceEntry& e) {
return std::visit([](const auto& x) { return x.name; }, e);
};
EXPECT_EQ("a", getName(entries[0]));
EXPECT_EQ("b", getName(entries[1]));
EXPECT_EQ("d", getName(entries[2]));
EXPECT_EQ("c", getName(entries[3]));
}