Bug 1666222: Rip fuzzyfox out of the timestamp classes 2/5 r=smaug
authorTom Ritter <tom@mozilla.com>
Wed, 14 Jul 2021 18:18:16 +0000
changeset 585528 630078a64ccf17151c861d45d807e19497f0afc2
parent 585527 bfcdb5581cb9c85add54570f651ee1a95a136106
child 585529 9f293cb46550863fe4e13f888b6760c26f05e51a
push id38614
push userdluca@mozilla.com
push dateThu, 15 Jul 2021 09:40:37 +0000
treeherdermozilla-central@013ecb3d2bf2 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssmaug
bugs1666222
milestone92.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1666222: Rip fuzzyfox out of the timestamp classes 2/5 r=smaug Differential Revision: https://phabricator.services.mozilla.com/D119637
browser/app/profile/firefox.js
ipc/glue/IPCMessageUtilsSpecializations.h
layout/base/nsRefreshDriver.cpp
mozglue/misc/TimeStamp.cpp
mozglue/misc/TimeStamp.h
mozglue/misc/TimeStamp_darwin.cpp
mozglue/misc/TimeStamp_posix.cpp
mozglue/misc/TimeStamp_windows.cpp
mozglue/misc/TimeStamp_windows.h
toolkit/components/telemetry/app/TelemetryEnvironment.jsm
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1369,18 +1369,16 @@ pref("services.sync.prefs.sync.privacy.c
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.cookies", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.downloads", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.formdata", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.history", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.offlineApps", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.sessions", true);
 pref("services.sync.prefs.sync.privacy.clearOnShutdown.siteSettings", true);
 pref("services.sync.prefs.sync.privacy.donottrackheader.enabled", true);
-pref("services.sync.prefs.sync.privacy.fuzzyfox.enabled", false);
-pref("services.sync.prefs.sync.privacy.fuzzyfox.clockgrainus", false);
 pref("services.sync.prefs.sync.privacy.sanitize.sanitizeOnShutdown", true);
 pref("services.sync.prefs.sync.privacy.trackingprotection.enabled", true);
 pref("services.sync.prefs.sync.privacy.trackingprotection.cryptomining.enabled", true);
 pref("services.sync.prefs.sync.privacy.trackingprotection.fingerprinting.enabled", true);
 pref("services.sync.prefs.sync.privacy.trackingprotection.pbmode.enabled", true);
 pref("services.sync.prefs.sync.privacy.resistFingerprinting", true);
 pref("services.sync.prefs.sync.privacy.reduceTimerPrecision", true);
 pref("services.sync.prefs.sync.privacy.resistFingerprinting.reduceTimerPrecision.microseconds", true);
--- a/ipc/glue/IPCMessageUtilsSpecializations.h
+++ b/ipc/glue/IPCMessageUtilsSpecializations.h
@@ -661,54 +661,28 @@ struct ParamTraits<mozilla::TimeStamp> {
 #ifdef XP_WIN
 
 template <>
 struct ParamTraits<mozilla::TimeStampValue> {
   typedef mozilla::TimeStampValue paramType;
   static void Write(Message* aMsg, const paramType& aParam) {
     WriteParam(aMsg, aParam.mGTC);
     WriteParam(aMsg, aParam.mQPC);
-    WriteParam(aMsg, aParam.mUsedCanonicalNow);
     WriteParam(aMsg, aParam.mIsNull);
     WriteParam(aMsg, aParam.mHasQPC);
   }
   static bool Read(const Message* aMsg, PickleIterator* aIter,
                    paramType* aResult) {
     return (ReadParam(aMsg, aIter, &aResult->mGTC) &&
             ReadParam(aMsg, aIter, &aResult->mQPC) &&
-            ReadParam(aMsg, aIter, &aResult->mUsedCanonicalNow) &&
             ReadParam(aMsg, aIter, &aResult->mIsNull) &&
             ReadParam(aMsg, aIter, &aResult->mHasQPC));
   }
 };
 
-#else
-
-template <>
-struct ParamTraits<mozilla::TimeStamp63Bit> {
-  typedef mozilla::TimeStamp63Bit paramType;
-  static void Write(Message* aMsg, const paramType& aParam) {
-    WriteParam(aMsg, aParam.mUsedCanonicalNow);
-    WriteParam(aMsg, aParam.mTimeStamp);
-  }
-  static bool Read(const Message* aMsg, PickleIterator* aIter,
-                   paramType* aResult) {
-    bool success = true;
-    uint64_t result;
-
-    success &= ReadParam(aMsg, aIter, &result);
-    aResult->mUsedCanonicalNow = result & 0x01;
-
-    success &= ReadParam(aMsg, aIter, &result);
-    aResult->mTimeStamp = result & 0x7FFFFFFFFFFFFFFF;
-
-    return success;
-  }
-};
-
 #endif
 
 template <>
 struct ParamTraits<mozilla::dom::ipc::StructuredCloneData> {
   typedef mozilla::dom::ipc::StructuredCloneData paramType;
 
   static void Write(Message* aMsg, const paramType& aParam) {
     aParam.WriteIPCParams(aMsg);
--- a/layout/base/nsRefreshDriver.cpp
+++ b/layout/base/nsRefreshDriver.cpp
@@ -676,21 +676,17 @@ class VsyncRefreshDriverTimer : public R
       RecordTelemetryProbes(aVsyncTimestamp);
       mLastTick = TimeStamp::Now();
       mLastProcessedTick = aVsyncTimestamp;
 
       // On 32-bit Windows we sometimes get times where TimeStamp::Now() is not
       // monotonic because the underlying system apis produce non-monontonic
       // results. (bug 1306896)
 #if !defined(_WIN32)
-      // Do not compare timestamps unless they are both canonical or fuzzy
-      DebugOnly<TimeStamp> rightnow = TimeStamp::Now();
-      MOZ_ASSERT_IF(
-          (*&rightnow).UsedCanonicalNow() == aVsyncTimestamp.UsedCanonicalNow(),
-          aVsyncTimestamp <= *&rightnow);
+      MOZ_ASSERT(aVsyncTimestamp <= TimeStamp::Now());
 #endif
 
       // Let also non-RefreshDriver code to run at least for awhile if we have
       // a mVsyncRefreshDriverTimer. Note, if nothing else is running,
       // RefreshDriver will still run as fast as possible, some ticks will
       // just be triggered from a normal priority runnable.
       TimeDuration timeForOutsideTick = TimeDuration::FromMilliseconds(0.0f);
 
--- a/mozglue/misc/TimeStamp.cpp
+++ b/mozglue/misc/TimeStamp.cpp
@@ -40,39 +40,16 @@ struct TimeStampInitialization {
     // On Windows < 10, initializing the uptime requires `mFirstTimeStamp` to be
     // valid.
     mozilla::InitializeUptime();
   };
 
   ~TimeStampInitialization() { TimeStamp::Shutdown(); };
 };
 
-static bool sFuzzyfoxEnabled;
-
-/* static */
-bool TimeStamp::GetFuzzyfoxEnabled() { return sFuzzyfoxEnabled; }
-
-/* static */
-void TimeStamp::SetFuzzyfoxEnabled(bool aValue) { sFuzzyfoxEnabled = aValue; }
-
-// These variables store the frozen time (as a TimeStamp) for FuzzyFox that
-// will be reported if FuzzyFox is enabled.
-// We overload the top bit of sCanonicalNow and sCanonicalGTC to
-// indicate if a Timestamp is a fuzzed timestamp (bit set) or not
-// (bit unset).
-#ifdef XP_WIN
-static Atomic<uint64_t> sCanonicalGTC;
-static Atomic<uint64_t> sCanonicalQPC;
-static Atomic<bool> sCanonicalHasQPC;
-#else
-static Atomic<uint64_t> sCanonicalNowTimeStamp;
-#endif
-static Atomic<int64_t> sCanonicalNowTime;
-// This variable stores the frozen time (as ms since the epoch) for FuzzyFox
-// to report if FuzzyFox is enabled.
 static TimeStampInitialization sInitOnce;
 
 MFBT_API TimeStamp TimeStamp::ProcessCreation(bool* aIsInconsistent) {
   if (aIsInconsistent) {
     *aIsInconsistent = false;
   }
 
   if (sInitOnce.mProcessCreation.IsNull()) {
@@ -108,47 +85,9 @@ MFBT_API TimeStamp TimeStamp::ProcessCre
 
   return sInitOnce.mProcessCreation;
 }
 
 void TimeStamp::RecordProcessRestart() {
   sInitOnce.mProcessCreation = TimeStamp();
 }
 
-MFBT_API TimeStamp TimeStamp::NowFuzzy(TimeStampValue aValue) {
-#ifdef XP_WIN
-  TimeStampValue canonicalNow =
-      TimeStampValue(sCanonicalGTC, sCanonicalQPC, sCanonicalHasQPC, true);
-#else
-  TimeStampValue canonicalNow = TimeStampValue(sCanonicalNowTimeStamp);
-#endif
-
-  if (TimeStamp::GetFuzzyfoxEnabled()) {
-    if (MOZ_LIKELY(!canonicalNow.IsNull())) {
-      return TimeStamp(canonicalNow);
-    }
-  }
-  // When we disable Fuzzyfox, time may goes backwards, so we need to make sure
-  // we don't do that.
-  else if (MOZ_UNLIKELY(canonicalNow > aValue)) {
-    return TimeStamp(canonicalNow);
-  }
-
-  return TimeStamp(aValue);
-}
-
-MFBT_API void TimeStamp::UpdateFuzzyTimeStamp(TimeStamp aValue) {
-#ifdef XP_WIN
-  sCanonicalGTC = aValue.mValue.mGTC;
-  sCanonicalQPC = aValue.mValue.mQPC;
-  sCanonicalHasQPC = aValue.mValue.mHasQPC;
-#else
-  sCanonicalNowTimeStamp = aValue.mValue.mTimeStamp;
-#endif
-}
-
-MFBT_API int64_t TimeStamp::NowFuzzyTime() { return sCanonicalNowTime; }
-
-MFBT_API void TimeStamp::UpdateFuzzyTime(int64_t aValue) {
-  sCanonicalNowTime = aValue;
-}
-
 }  // namespace mozilla
--- a/mozglue/misc/TimeStamp.h
+++ b/mozglue/misc/TimeStamp.h
@@ -25,46 +25,17 @@ struct ParamTraits;
 // defines TimeStampValue as a complex value keeping both
 // GetTickCount and QueryPerformanceCounter values
 #  include "TimeStamp_windows.h"
 #endif
 
 namespace mozilla {
 
 #ifndef XP_WIN
-struct TimeStamp63Bit {
-  uint64_t mUsedCanonicalNow : 1;
-  uint64_t mTimeStamp : 63;
-
-  constexpr TimeStamp63Bit() : mUsedCanonicalNow(0), mTimeStamp(0) {}
-
-  MOZ_IMPLICIT constexpr TimeStamp63Bit(const uint64_t aValue)
-      : mUsedCanonicalNow(0), mTimeStamp(aValue) {}
-
-  constexpr TimeStamp63Bit(const bool aUsedCanonicalNow,
-                           const int64_t aTimeStamp)
-      : mUsedCanonicalNow(aUsedCanonicalNow ? 1 : 0), mTimeStamp(aTimeStamp) {}
-
-  bool operator==(const TimeStamp63Bit aOther) const {
-    uint64_t here, there;
-    memcpy(&here, this, sizeof(TimeStamp63Bit));
-    memcpy(&there, &aOther, sizeof(TimeStamp63Bit));
-    return here == there;
-  }
-
-  operator uint64_t() const { return mTimeStamp; }
-
-  bool IsNull() const { return mTimeStamp == 0; }
-
-  bool UsedCanonicalNow() const { return mUsedCanonicalNow; }
-
-  void SetCanonicalNow() { mUsedCanonicalNow = 1; }
-};
-
-typedef TimeStamp63Bit TimeStampValue;
+typedef uint64_t TimeStampValue;
 #endif
 
 class TimeStamp;
 
 /**
  * Platform-specific implementation details of BaseTimeDuration.
  */
 class BaseTimeDurationPlatformUtils {
@@ -392,17 +363,17 @@ typedef BaseTimeDuration<TimeDurationVal
  * Note that, since TimeStamp objects are small, prefer to pass them by value
  * unless there is a specific reason not to do so.
  */
 class TimeStamp {
  public:
   /**
    * Initialize to the "null" moment
    */
-  constexpr TimeStamp() : mValue() {}
+  constexpr TimeStamp() : mValue(0) {}
   // Default copy-constructor and assignment are OK
 
   /**
    * The system timestamps are the same as the TimeStamp
    * retrieved by mozilla::TimeStamp. Since we need this for
    * vsync timestamps, we enable the creation of mozilla::TimeStamps
    * on platforms that support vsync aligned refresh drivers / compositors
    * Verified true as of Jan 31, 2015: B2G and OS X
@@ -412,53 +383,47 @@ class TimeStamp {
    * Wayland/GTK event time also uses CLOCK_MONOTONIC on Weston/Mutter
    * compositors.
    * UNTESTED ON OTHER PLATFORMS
    */
 #if defined(XP_DARWIN) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
   static TimeStamp FromSystemTime(int64_t aSystemTime) {
     static_assert(sizeof(aSystemTime) == sizeof(TimeStampValue),
                   "System timestamp should be same units as TimeStampValue");
-    return TimeStamp(TimeStampValue(false, aSystemTime));
+    return TimeStamp(aSystemTime);
   }
 #endif
 
   /**
    * Return true if this is the "null" moment
    */
-  bool IsNull() const { return mValue.IsNull(); }
+  bool IsNull() const { return mValue == 0; }
 
   /**
    * Return true if this is not the "null" moment, may be used in tests, e.g.:
    * |if (timestamp) { ... }|
    */
-  explicit operator bool() const { return !IsNull(); }
-
-  bool UsedCanonicalNow() const { return mValue.UsedCanonicalNow(); }
-  static MFBT_API bool GetFuzzyfoxEnabled();
-  static MFBT_API void SetFuzzyfoxEnabled(bool aValue);
+  explicit operator bool() const { return mValue != 0; }
 
   /**
    * Return a timestamp reflecting the current elapsed system time. This
    * is monotonically increasing (i.e., does not decrease) over the
    * lifetime of this process' XPCOM session.
    *
    * Now() is trying to ensure the best possible precision on each platform,
    * at least one millisecond.
    *
    * NowLoRes() has been introduced to workaround performance problems of
    * QueryPerformanceCounter on the Windows platform.  NowLoRes() is giving
    * lower precision, usually 15.6 ms, but with very good performance benefit.
    * Use it for measurements of longer times, like >200ms timeouts.
    */
   static TimeStamp Now() { return Now(true); }
   static TimeStamp NowLoRes() { return Now(false); }
-  static TimeStamp NowUnfuzzed() { return NowUnfuzzed(true); }
 
-  static MFBT_API int64_t NowFuzzyTime();
   /**
    * Return a timestamp representing the time when the current process was
    * created which will be comparable with other timestamps taken with this
    * class. If the actual process creation time is detected to be inconsistent
    * the @a aIsInconsistent parameter will be set to true, the returned
    * timestamp however will still be valid though inaccurate.
    *
    * @param aIsInconsistent If non-null, set to true if an inconsistency was
@@ -508,35 +473,29 @@ class TimeStamp {
   }
   TimeStamp& operator+=(const TimeDuration& aOther) {
     MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
     TimeStampValue value = mValue + aOther.mValue;
     // Check for underflow.
     // (We don't check for overflow because it's not obvious what the error
     //  behavior should be in that case.)
     if (aOther.mValue < 0 && value > mValue) {
-      value = TimeStampValue();
-    }
-    if (mValue.UsedCanonicalNow()) {
-      value.SetCanonicalNow();
+      value = 0;
     }
     mValue = value;
     return *this;
   }
   TimeStamp& operator-=(const TimeDuration& aOther) {
     MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
     TimeStampValue value = mValue - aOther.mValue;
     // Check for underflow.
     // (We don't check for overflow because it's not obvious what the error
     //  behavior should be in that case.)
     if (aOther.mValue > 0 && value > mValue) {
-      value = TimeStampValue();
-    }
-    if (mValue.UsedCanonicalNow()) {
-      value.SetCanonicalNow();
+      value = 0;
     }
     mValue = value;
     return *this;
   }
 
   bool operator<(const TimeStamp& aOther) const {
     MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
     MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
@@ -571,21 +530,16 @@ class TimeStamp {
   static MFBT_API void Shutdown();
 
  private:
   friend struct IPC::ParamTraits<mozilla::TimeStamp>;
 
   MOZ_IMPLICIT TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
 
   static MFBT_API TimeStamp Now(bool aHighResolution);
-  static MFBT_API TimeStamp NowUnfuzzed(bool aHighResolution);
-  static MFBT_API TimeStamp NowFuzzy(TimeStampValue aValue);
-
-  static MFBT_API void UpdateFuzzyTime(int64_t aValue);
-  static MFBT_API void UpdateFuzzyTimeStamp(TimeStamp aValue);
 
   /**
    * Computes the uptime of the current process in microseconds. The result
    * is platform-dependent and needs to be checked against existing timestamps
    * for consistency.
    *
    * @returns The number of microseconds since the calling process was started
    *          or 0 if an error was encountered while computing the uptime
@@ -601,15 +555,13 @@ class TimeStamp {
    *
    * PR_INTERVAL_MAX is set at 100,000 ticks per second. So the minimum
    * time to wrap around is about 2^64/100000 seconds, i.e. about
    * 5,849,424 years.
    *
    * When using a system clock, a value is system dependent.
    */
   TimeStampValue mValue;
-
-  friend class Fuzzyfox;
 };
 
 }  // namespace mozilla
 
 #endif /* mozilla_TimeStamp_h */
--- a/mozglue/misc/TimeStamp_darwin.cpp
+++ b/mozglue/misc/TimeStamp_darwin.cpp
@@ -138,21 +138,17 @@ void TimeStamp::Startup() {
   gInitialized = true;
 
   return;
 }
 
 void TimeStamp::Shutdown() {}
 
 TimeStamp TimeStamp::Now(bool aHighResolution) {
-  return TimeStamp::NowFuzzy(TimeStampValue(false, ClockTime()));
-}
-
-TimeStamp TimeStamp::NowUnfuzzed(bool aHighResolution) {
-  return TimeStamp(TimeStampValue(false, ClockTime()));
+  return TimeStamp(ClockTime());
 }
 
 // Computes and returns the process uptime in microseconds.
 // Returns 0 if an error was encountered.
 uint64_t TimeStamp::ComputeProcessUptime() {
   struct timeval tv;
   int rv = gettimeofday(&tv, nullptr);
 
--- a/mozglue/misc/TimeStamp_posix.cpp
+++ b/mozglue/misc/TimeStamp_posix.cpp
@@ -184,21 +184,17 @@ void TimeStamp::Startup() {
     ;
 
   gInitialized = true;
 }
 
 void TimeStamp::Shutdown() {}
 
 TimeStamp TimeStamp::Now(bool aHighResolution) {
-  return TimeStamp::NowFuzzy(TimeStampValue(false, ClockTimeNs()));
-}
-
-TimeStamp TimeStamp::NowUnfuzzed(bool aHighResolution) {
-  return TimeStamp(TimeStampValue(false, ClockTimeNs()));
+  return TimeStamp(ClockTimeNs());
 }
 
 #if defined(XP_LINUX) || defined(ANDROID)
 
 // Calculates the amount of jiffies that have elapsed since boot and up to the
 // starttime value of a specific process as found in its /proc/*/stat file.
 // Returns 0 if an error occurred.
 
--- a/mozglue/misc/TimeStamp_windows.cpp
+++ b/mozglue/misc/TimeStamp_windows.cpp
@@ -250,22 +250,18 @@ static void InitResolution() {
 
   sResolutionSigDigs = sigDigs;
 }
 
 // ----------------------------------------------------------------------------
 // TimeStampValue implementation
 // ----------------------------------------------------------------------------
 MFBT_API
-TimeStampValue::TimeStampValue(ULONGLONG aGTC, ULONGLONG aQPC, bool aHasQPC,
-                               bool aUsedCanonicalNow)
-    : mGTC(aGTC),
-      mQPC(aQPC),
-      mUsedCanonicalNow(aUsedCanonicalNow),
-      mHasQPC(aHasQPC) {
+TimeStampValue::TimeStampValue(ULONGLONG aGTC, ULONGLONG aQPC, bool aHasQPC)
+    : mGTC(aGTC), mQPC(aQPC), mHasQPC(aHasQPC) {
   mIsNull = aGTC == 0 && aQPC == 0;
 }
 
 MFBT_API TimeStampValue& TimeStampValue::operator+=(const int64_t aOther) {
   mGTC += aOther;
   mQPC += aOther;
   return *this;
 }
@@ -489,24 +485,20 @@ MFBT_API void TimeStamp::Shutdown() { De
 
 TimeStampValue NowInternal(bool aHighResolution) {
   // sUseQPC is volatile
   bool useQPC = (aHighResolution && sUseQPC);
 
   // Both values are in [mt] units.
   ULONGLONG QPC = useQPC ? PerformanceCounter() : uint64_t(0);
   ULONGLONG GTC = ms2mt(GetTickCount64());
-  return TimeStampValue(GTC, QPC, useQPC, false);
+  return TimeStampValue(GTC, QPC, useQPC);
 }
 
 MFBT_API TimeStamp TimeStamp::Now(bool aHighResolution) {
-  return TimeStamp::NowFuzzy(NowInternal(aHighResolution));
-}
-
-MFBT_API TimeStamp TimeStamp::NowUnfuzzed(bool aHighResolution) {
   return TimeStamp(NowInternal(aHighResolution));
 }
 
 // Computes and returns the process uptime in microseconds.
 // Returns 0 if an error was encountered.
 
 MFBT_API uint64_t TimeStamp::ComputeProcessUptime() {
   FILETIME start, foo, bar, baz;
--- a/mozglue/misc/TimeStamp_windows.h
+++ b/mozglue/misc/TimeStamp_windows.h
@@ -33,48 +33,41 @@ class TimeStampValue;
 
 TimeStampValue NowInternal(bool aHighResolution);
 
 class TimeStampValue {
   friend TimeStampValue NowInternal(bool);
   friend bool IsCanonicalTimeStamp(TimeStampValue);
   friend struct IPC::ParamTraits<mozilla::TimeStampValue>;
   friend class TimeStamp;
-  friend class Fuzzyfox;
 
   // Both QPC and GTC are kept in [mt] units.
   uint64_t mGTC;
   uint64_t mQPC;
 
-  bool mUsedCanonicalNow;
   bool mIsNull;
   bool mHasQPC;
 
-  MFBT_API TimeStampValue(uint64_t aGTC, uint64_t aQPC, bool aHasQPC,
-                          bool aUsedCanonicalNow);
+  MFBT_API TimeStampValue(uint64_t aGTC, uint64_t aQPC, bool aHasQPC);
 
   MFBT_API uint64_t CheckQPC(const TimeStampValue& aOther) const;
 
-  constexpr MOZ_IMPLICIT TimeStampValue()
-      : mGTC(0),
-        mQPC(0),
-        mUsedCanonicalNow(false),
-        mIsNull(true),
-        mHasQPC(false) {}
+  // This struct is used to allow doing TimeStampValue a = 0 and similar
+  struct _SomethingVeryRandomHere;
+  constexpr MOZ_IMPLICIT TimeStampValue(_SomethingVeryRandomHere* aNullValue)
+      : mGTC(0), mQPC(0), mIsNull(true), mHasQPC(false) {}
 
  public:
   MFBT_API uint64_t operator-(const TimeStampValue& aOther) const;
 
   TimeStampValue operator+(const int64_t aOther) const {
-    return TimeStampValue(mGTC + aOther, mQPC + aOther, mHasQPC,
-                          mUsedCanonicalNow);
+    return TimeStampValue(mGTC + aOther, mQPC + aOther, mHasQPC);
   }
   TimeStampValue operator-(const int64_t aOther) const {
-    return TimeStampValue(mGTC - aOther, mQPC - aOther, mHasQPC,
-                          mUsedCanonicalNow);
+    return TimeStampValue(mGTC - aOther, mQPC - aOther, mHasQPC);
   }
   MFBT_API TimeStampValue& operator+=(const int64_t aOther);
   MFBT_API TimeStampValue& operator-=(const int64_t aOther);
 
   bool operator<(const TimeStampValue& aOther) const {
     return int64_t(*this - aOther) < 0;
   }
   bool operator>(const TimeStampValue& aOther) const {
@@ -87,16 +80,14 @@ class TimeStampValue {
     return int64_t(*this - aOther) >= 0;
   }
   bool operator==(const TimeStampValue& aOther) const {
     return int64_t(*this - aOther) == 0;
   }
   bool operator!=(const TimeStampValue& aOther) const {
     return int64_t(*this - aOther) != 0;
   }
-  bool UsedCanonicalNow() const { return mUsedCanonicalNow; }
-  void SetCanonicalNow() { mUsedCanonicalNow = true; }
   bool IsNull() const { return mIsNull; }
 };
 
 }  // namespace mozilla
 
 #endif /* mozilla_TimeStamp_h */
--- a/toolkit/components/telemetry/app/TelemetryEnvironment.jsm
+++ b/toolkit/components/telemetry/app/TelemetryEnvironment.jsm
@@ -308,17 +308,16 @@ const DEFAULT_ENVIRONMENT_PREFS = new Ma
   ["network.http.windows-sso.enabled", { what: RECORD_PREF_VALUE }],
   ["network.proxy.autoconfig_url", { what: RECORD_PREF_STATE }],
   ["network.proxy.http", { what: RECORD_PREF_STATE }],
   ["network.proxy.ssl", { what: RECORD_PREF_STATE }],
   ["network.trr.mode", { what: RECORD_PREF_VALUE }],
   ["pdfjs.disabled", { what: RECORD_PREF_VALUE }],
   ["places.history.enabled", { what: RECORD_PREF_VALUE }],
   ["plugins.show_infobar", { what: RECORD_PREF_VALUE }],
-  ["privacy.fuzzyfox.enabled", { what: RECORD_PREF_VALUE }],
   ["privacy.firstparty.isolate", { what: RECORD_PREF_VALUE }],
   ["privacy.resistFingerprinting", { what: RECORD_PREF_VALUE }],
   ["privacy.trackingprotection.enabled", { what: RECORD_PREF_VALUE }],
   ["privacy.donottrackheader.enabled", { what: RECORD_PREF_VALUE }],
   ["security.enterprise_roots.auto-enabled", { what: RECORD_PREF_VALUE }],
   ["security.enterprise_roots.enabled", { what: RECORD_PREF_VALUE }],
   ["security.pki.mitm_detected", { what: RECORD_PREF_VALUE }],
   ["security.mixed_content.block_active_content", { what: RECORD_PREF_VALUE }],