--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -13,16 +13,17 @@
 #include "nsIDOMChromeWindow.h"
 #include "nsIEffectiveTLDService.h"
 #include "nsIObserverService.h"
 #include "nsIPrincipal.h"
 #include "nsIScriptContext.h"
 #include "nsIScriptError.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIStreamTransportService.h"
+#include "nsISupportsPrimitives.h"
 #include "nsISupportsPriority.h"
 #include "nsITimer.h"
 #include "nsIURI.h"
 #include "nsIXULRuntime.h"
 #include "nsPIDOMWindow.h"
 
 #include <algorithm>
 #include "mozilla/ipc/BackgroundChild.h"
@@ -124,16 +125,17 @@ static_assert(MAX_WORKERS_PER_DOMAIN >= 
 #define PREF_WORKERS_MAX_HARDWARE_CONCURRENCY "dom.maxHardwareConcurrency"
 
 #define PREF_MAX_SCRIPT_RUN_TIME_CONTENT "dom.max_script_run_time"
 #define PREF_MAX_SCRIPT_RUN_TIME_CHROME "dom.max_chrome_script_run_time"
 
 #define GC_REQUEST_OBSERVER_TOPIC "child-gc-request"
 #define CC_REQUEST_OBSERVER_TOPIC "child-cc-request"
 #define MEMORY_PRESSURE_OBSERVER_TOPIC "memory-pressure"
+#define FUZZYFOX_UPDATECLOCK_OBSERVER_TOPIC "fuzzyfox-update-clocks"
 
 #define BROADCAST_ALL_WORKERS(_func, ...)                                      \
   PR_BEGIN_MACRO                                                               \
     AssertIsOnMainThread();                                                    \
                                                                                \
     AutoTArray<WorkerPrivate*, 100> workers;                                   \
     {                                                                          \
       MutexAutoLock lock(mMutex);                                              \
@@ -1736,16 +1738,22 @@ RuntimeService::Init()
                                  false))) {
     NS_WARNING("Failed to register for memory pressure notifications!");
   }
 
   if (NS_FAILED(obs->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, false))) {
     NS_WARNING("Failed to register for offline notification event!");
   }
 
+#ifdef MOZ_FUZZYFOX
+  if (NS_FAILED(obs->AddObserver(this, FUZZYFOX_UPDATECLOCK_OBSERVER_TOPIC, false))) {
+    NS_WARNING("Failed to register for fuzzyfox update clock!");
+  }
+#endif
+
   MOZ_ASSERT(!gRuntimeServiceDuringInit, "This should be false!");
   gRuntimeServiceDuringInit = true;
 
   if (NS_FAILED(Preferences::RegisterPrefixCallback(
                                  LoadJSGCMemoryOptions,
                                  PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX)) ||
       NS_FAILED(Preferences::RegisterPrefixCallbackAndCall(
                             LoadJSGCMemoryOptions,
@@ -2095,16 +2103,23 @@ RuntimeService::Cleanup()
                                         MEMORY_PRESSURE_OBSERVER_TOPIC))) {
         NS_WARNING("Failed to unregister for memory pressure notifications!");
       }
 
       if (NS_FAILED(obs->RemoveObserver(this,
                                         NS_IOSERVICE_OFFLINE_STATUS_TOPIC))) {
         NS_WARNING("Failed to unregister for offline notification event!");
       }
+
+#ifdef MOZ_FUZZYFOX
+      if (NS_FAILED(obs->RemoveObserver(this, FUZZYFOX_UPDATECLOCK_OBSERVER_TOPIC))) {
+        NS_WARNING("Failed to unregister for fuzzyfox update clock!");
+      }
+#endif
+
       obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID);
       obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
       mObserved = false;
     }
   }
 
   nsLayoutStatics::Release();
 }
@@ -2528,16 +2543,35 @@ RuntimeService::CycleCollectAllWorkers()
 }
 
 void
 RuntimeService::SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline)
 {
   BROADCAST_ALL_WORKERS(OfflineStatusChangeEvent, aIsOffline);
 }
 
+#ifdef MOZ_FUZZYFOX
+void
+RuntimeService::SendFuzzyFoxClockToAllWorkers(nsISupports* aData)
+{
+  nsCOMPtr<nsISupportsPRInt64> wrapper = do_QueryInterface(aData);
+  if (NS_WARN_IF(!wrapper)) {
+    return;
+  }
+
+  int64_t newTime = 0;
+  nsresult rv = wrapper->GetData(&newTime);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return;
+  }
+
+  BROADCAST_ALL_WORKERS(UpdateFuzzyFoxClock, newTime);
+}
+#endif
+
 void
 RuntimeService::MemoryPressureAllWorkers()
 {
   BROADCAST_ALL_WORKERS(MemoryPressure, /* dummy = */ false);
 }
 
 uint32_t
 RuntimeService::ClampedHardwareConcurrency() const
@@ -2600,16 +2634,23 @@ RuntimeService::Observe(nsISupports* aSu
     MemoryPressureAllWorkers();
     return NS_OK;
   }
   if (!strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC)) {
     SendOfflineStatusChangeEventToAllWorkers(NS_IsOffline());
     return NS_OK;
   }
 
+#ifdef MOZ_FUZZYFOX
+  if (!strcmp(aTopic, FUZZYFOX_UPDATECLOCK_OBSERVER_TOPIC)) {
+    SendFuzzyFoxClockToAllWorkers(aSubject);
+    return NS_OK;
+  }
+#endif
+
   NS_NOTREACHED("Unknown observer topic!");
   return NS_OK;
 }
 
 bool
 LogViolationDetailsRunnable::MainThreadRun()
 {
   AssertIsOnMainThread();

--- a/dom/workers/RuntimeService.h
+++ b/dom/workers/RuntimeService.h
@@ -226,16 +226,21 @@ public:
   GarbageCollectAllWorkers(bool aShrinking);
 
   void
   CycleCollectAllWorkers();
 
   void
   SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline);
 
+#ifdef MOZ_FUZZYFOX
+  void
+  SendFuzzyFoxClockToAllWorkers(nsISupports* aData);
+#endif
+
   void
   MemoryPressureAllWorkers();
 
   uint32_t ClampedHardwareConcurrency() const;
 
   void CrashIfHanging();
 
 private:

--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -755,16 +755,37 @@ private:
   virtual bool
   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
   {
     aWorkerPrivate->UpdateContextOptionsInternal(aCx, mContextOptions);
     return true;
   }
 };
 
+#ifdef MOZ_FUZZYFOX
+class UpdateFuzzyFoxClockRunnable final : public WorkerRunnable
+{
+  int64_t mNewTime;
+
+public:
+  UpdateFuzzyFoxClockRunnable(WorkerPrivate* aWorkerPrivate,
+                             int64_t aNewTime)
+    : WorkerRunnable(aWorkerPrivate)
+    , mNewTime(aNewTime)
+  {}
+
+  virtual bool
+  WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+  {
+    JS_UpdateLockedClock(aCx, mNewTime);
+    return true;
+  }
+};
+#endif
+
 class UpdateLanguagesRunnable final : public WorkerRunnable
 {
   nsTArray<nsString> mLanguages;
 
 public:
   UpdateLanguagesRunnable(WorkerPrivate* aWorkerPrivate,
                           const nsTArray<nsString>& aLanguages)
     : WorkerRunnable(aWorkerPrivate),
@@ -2187,16 +2208,30 @@ WorkerPrivate::OfflineStatusChangeEventI
   RefPtr<Event> event = NS_NewDOMEvent(globalScope, nullptr, nullptr);
 
   event->InitEvent(eventType, false, false);
   event->SetTrusted(true);
 
   globalScope->DispatchEvent(*event);
 }
 
+#ifdef MOZ_FUZZYFOX
+void
+WorkerPrivate::UpdateFuzzyFoxClock(int64_t aNewTime)
+{
+  AssertIsOnParentThread();
+
+  RefPtr<UpdateFuzzyFoxClockRunnable> runnable =
+    new UpdateFuzzyFoxClockRunnable(this, aNewTime);
+  if (!runnable->Dispatch()) {
+    NS_WARNING("Failed to dispatch fuzzy fox clock update event!");
+  }
+}
+#endif
+
 void
 WorkerPrivate::MemoryPressure(bool aDummy)
 {
   AssertIsOnParentThread();
 
   RefPtr<MemoryPressureRunnable> runnable = new MemoryPressureRunnable(this);
   Unused << NS_WARN_IF(!runnable->Dispatch());
 }

--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -1153,16 +1153,21 @@ public:
 #ifdef JS_GC_ZEAL
   void
   UpdateGCZeal(uint8_t aGCZeal, uint32_t aFrequency);
 #endif
 
   void
   OfflineStatusChangeEvent(bool aIsOffline);
 
+#ifdef MOZ_FUZZYFOX
+  void
+  UpdateFuzzyFoxClock(int64_t aNewTime);
+#endif
+
   nsresult
   Dispatch(already_AddRefed<WorkerRunnable> aRunnable,
            nsIEventTarget* aSyncLoopTarget = nullptr);
 
   nsresult
   DispatchControlRunnable(already_AddRefed<WorkerControlRunnable> aWorkerControlRunnable);
 
   nsresult