From c036c2530757bee337e69232433f1944a2f80ea1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Malte=20J=C3=BCrgens?= Date: Mon, 30 Jan 2023 13:09:23 +0100 Subject: [PATCH] Backport Bug 1811567 --- assets/patches.txt | 1 + patches/rfp-performance-api.patch | 231 ++++++++++++++++++++++++++++++ 2 files changed, 232 insertions(+) create mode 100644 patches/rfp-performance-api.patch diff --git a/assets/patches.txt b/assets/patches.txt index f6d9213..24e1d9e 100644 --- a/assets/patches.txt +++ b/assets/patches.txt @@ -10,6 +10,7 @@ patches/librewolf-pref-pane.patch patches/librewolf-prefs.patch patches/mozilla_dirs.patch patches/remove_addons.patch +patches/rfp-performance-api.patch patches/sed-patches/allow-searchengines-non-esr.patch patches/sed-patches/disable-pocket.patch patches/sed-patches/stop-undesired-requests.patch diff --git a/patches/rfp-performance-api.patch b/patches/rfp-performance-api.patch new file mode 100644 index 0000000..f0a2c75 --- /dev/null +++ b/patches/rfp-performance-api.patch @@ -0,0 +1,231 @@ +# Backport of https://phabricator.services.mozilla.com/D167444 +# Should land in 111.0 +--- a/dom/performance/Performance.cpp ++++ b/dom/performance/Performance.cpp +@@ -163,29 +163,17 @@ + JS::Handle aGivenProto) { + return Performance_Binding::Wrap(aCx, this, aGivenProto); + } + + void Performance::GetEntries(nsTArray>& aRetval) { +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- aRetval.Clear(); +- return; +- } +- + aRetval = mResourceEntries.Clone(); + aRetval.AppendElements(mUserEntries); + aRetval.Sort(PerformanceEntryComparator()); + } + + void Performance::GetEntriesByType( + const nsAString& aEntryType, nsTArray>& aRetval) { +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- aRetval.Clear(); +- return; +- } +- + if (aEntryType.EqualsLiteral("resource")) { + aRetval = mResourceEntries.Clone(); + return; + } + +@@ -204,15 +192,10 @@ + void Performance::GetEntriesByName( + const nsAString& aName, const Optional& aEntryType, + nsTArray>& aRetval) { + aRetval.Clear(); + +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- return; +- } +- + RefPtr name = NS_Atomize(aName); + RefPtr entryType = + aEntryType.WasPassed() ? NS_Atomize(aEntryType.Value()) : nullptr; + + if (entryType) { +@@ -365,21 +348,11 @@ + PerformanceMark::Constructor(global, aName, aMarkOptions, aRv); + if (aRv.Failed()) { + return nullptr; + } + +- // To avoid fingerprinting in User Timing L2, we didn't add marks to the +- // buffer so the user could not get timing data (which can be used to +- // fingerprint) from the API. This may no longer be necessary (since +- // performance.now() has reduced precision to protect against fingerprinting +- // and performance.mark's primary fingerprinting issue is probably this timing +- // data) but we need to do a more thorough reanalysis before we remove the +- // fingerprinting protection. For now, we preserve the User Timing L2 behavior +- // while supporting User Timing L3. +- if (!nsContentUtils::ShouldResistFingerprinting()) { +- InsertUserEntry(performanceMark); +- } ++ InsertUserEntry(performanceMark); + + if (profiler_thread_is_being_profiled_for_markers()) { + Maybe innerWindowId; + if (GetOwner()) { + innerWindowId = Some(GetOwner()->WindowID()); +@@ -595,23 +568,10 @@ + if (!GetParentObject()) { + aRv.ThrowInvalidStateError("Global object is unavailable"); + return nullptr; + } + +- // When resisting fingerprinting, we don't add marks to the buffer. Since +- // measure relies on relationships between marks in the buffer, this method +- // will throw if we look for user-entered marks so we return a dummy measure +- // instead of continuing. We could instead return real values for performance +- // timing attributes and dummy values for user-entered marks but this adds +- // complexity that doesn't seem worth the effort because these fingerprinting +- // protections may not longer be necessary (since performance.now() already +- // has reduced precision). +- if (nsContentUtils::ShouldResistFingerprinting()) { +- return do_AddRef(new PerformanceMeasure(GetParentObject(), aName, 0, 0, +- JS::NullHandleValue)); +- } +- + // Maybe is more readable than using the union type directly. + Maybe options; + if (aStartOrMeasureOptions.IsPerformanceMeasureOptions()) { + options.emplace(aStartOrMeasureOptions.GetAsPerformanceMeasureOptions()); + } +@@ -811,10 +811,6 @@ MOZ_ALWAYS_INLINE bool Performance::CanAddResourceTimingEntry() { + void Performance::InsertResourceEntry(PerformanceEntry* aEntry) { + MOZ_ASSERT(aEntry); + +- if (nsContentUtils::ShouldResistFingerprinting()) { +- return; +- } +- + /* + * Let new entry be the input PerformanceEntry to be added. + * +--- a/dom/performance/PerformanceMainThread.cpp ++++ b/dom/performance/PerformanceMainThread.cpp +@@ -409,12 +409,11 @@ + } + + void PerformanceMainThread::CreateNavigationTimingEntry() { + MOZ_ASSERT(!mDocEntry, "mDocEntry should be null."); + +- if (!StaticPrefs::dom_enable_performance_navigation_timing() || +- StaticPrefs::privacy_resistFingerprinting()) { ++ if (!StaticPrefs::dom_enable_performance_navigation_timing()) { + return; + } + + nsAutoString name; + GetURLSpecFromChannel(mChannel, name); +@@ -461,16 +460,10 @@ + return mEventCounts; + } + + void PerformanceMainThread::GetEntries( + nsTArray>& aRetval) { +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- aRetval.Clear(); +- return; +- } +- + aRetval = mResourceEntries.Clone(); + aRetval.AppendElements(mUserEntries); + + if (mDocEntry) { + aRetval.AppendElement(mDocEntry); +@@ -482,16 +475,10 @@ + aRetval.Sort(PerformanceEntryComparator()); + } + + void PerformanceMainThread::GetEntriesByType( + const nsAString& aEntryType, nsTArray>& aRetval) { +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- aRetval.Clear(); +- return; +- } +- + RefPtr type = NS_Atomize(aEntryType); + if (type == nsGkAtoms::navigation) { + aRetval.Clear(); + + if (mDocEntry) { +@@ -524,16 +511,10 @@ + } + + void PerformanceMainThread::GetEntriesByName( + const nsAString& aName, const Optional& aEntryType, + nsTArray>& aRetval) { +- // We return an empty list when 'privacy.resistFingerprinting' is on. +- if (nsContentUtils::ShouldResistFingerprinting()) { +- aRetval.Clear(); +- return; +- } +- + Performance::GetEntriesByName(aName, aEntryType, aRetval); + + if (mFCPTiming && mFCPTiming->GetName()->Equals(aName) && + (!aEntryType.WasPassed() || + mFCPTiming->GetEntryType()->Equals(aEntryType.Value()))) { +--- a/dom/performance/PerformanceNavigationTiming.cpp ++++ b/dom/performance/PerformanceNavigationTiming.cpp +@@ -150,8 +150,7 @@ + nsIHttpChannel* aHttpChannel, nsITimedChannel* aChannel) { + mTimingData->SetPropertiesFromHttpChannel(aHttpChannel, aChannel); + } + + bool PerformanceNavigationTiming::Enabled(JSContext* aCx, JSObject* aGlobal) { +- return (StaticPrefs::dom_enable_performance_navigation_timing() && +- !StaticPrefs::privacy_resistFingerprinting()); ++ return StaticPrefs::dom_enable_performance_navigation_timing(); + } +--- a/dom/performance/PerformanceTiming.cpp ++++ b/dom/performance/PerformanceTiming.cpp +@@ -110,12 +110,11 @@ + mTimingAllowed(true), + mInitialized(false) { + mInitialized = !!aChannel; + mZeroTime = aZeroTime; + +- if (!StaticPrefs::dom_enable_performance() || +- nsContentUtils::ShouldResistFingerprinting()) { ++ if (!StaticPrefs::dom_enable_performance()) { + mZeroTime = 0; + } + + nsCOMPtr uri; + if (aHttpChannel) { +@@ -336,24 +335,22 @@ + // header with the domain of the page that started the load. + return aChannel->TimingAllowCheck(principal); + } + + uint8_t PerformanceTimingData::GetRedirectCount() const { +- if (!StaticPrefs::dom_enable_performance() || !IsInitialized() || +- nsContentUtils::ShouldResistFingerprinting()) { ++ if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return 0; + } + if (!mAllRedirectsSameOrigin) { + return 0; + } + return mRedirectCount; + } + + bool PerformanceTimingData::ShouldReportCrossOriginRedirect( + bool aEnsureSameOriginAndIgnoreTAO) const { +- if (!StaticPrefs::dom_enable_performance() || !IsInitialized() || +- nsContentUtils::ShouldResistFingerprinting()) { ++ if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return false; + } + + if (!mTimingAllowed || mRedirectCount == 0) { + return false; +