1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #include "RuntimeService.h"
9 #include "nsContentSecurityUtils.h"
10 #include "nsIContentSecurityPolicy.h"
11 #include "mozilla/dom/Document.h"
12 #include "nsIObserverService.h"
13 #include "nsIScriptContext.h"
14 #include "nsIStreamTransportService.h"
15 #include "nsISupportsPriority.h"
18 #include "nsIXULRuntime.h"
19 #include "nsPIDOMWindow.h"
22 #include "mozilla/ipc/BackgroundChild.h"
23 #include "GeckoProfiler.h"
24 #include "js/ColumnNumber.h" // JS::ColumnNumberOneOrigin
25 #include "js/experimental/CTypes.h" // JS::CTypesActivityType, JS::SetCTypesActivityCallback
26 #include "jsfriendapi.h"
27 #include "js/friend/ErrorMessages.h" // js::GetErrorMessage, JSMSG_*
28 #include "js/ContextOptions.h"
29 #include "js/Initialization.h"
30 #include "js/LocaleSensitive.h"
31 #include "js/WasmFeatures.h"
32 #include "mozilla/ArrayUtils.h"
33 #include "mozilla/Atomics.h"
34 #include "mozilla/Attributes.h"
35 #include "mozilla/CycleCollectedJSContext.h"
36 #include "mozilla/CycleCollectedJSRuntime.h"
37 #include "mozilla/Telemetry.h"
38 #include "mozilla/TimeStamp.h"
39 #include "mozilla/dom/AtomList.h"
40 #include "mozilla/dom/BindingUtils.h"
41 #include "mozilla/dom/ErrorEventBinding.h"
42 #include "mozilla/dom/EventTargetBinding.h"
43 #include "mozilla/dom/FetchUtil.h"
44 #include "mozilla/dom/MessageChannel.h"
45 #include "mozilla/dom/MessageEventBinding.h"
46 #include "mozilla/dom/PerformanceService.h"
47 #include "mozilla/dom/RemoteWorkerChild.h"
48 #include "mozilla/dom/WorkerBinding.h"
49 #include "mozilla/dom/ScriptSettings.h"
50 #include "mozilla/dom/ShadowRealmGlobalScope.h"
51 #include "mozilla/dom/IndexedDatabaseManager.h"
52 #include "mozilla/DebugOnly.h"
53 #include "mozilla/Preferences.h"
54 #include "mozilla/ScopeExit.h"
55 #include "mozilla/dom/Navigator.h"
56 #include "mozilla/Monitor.h"
57 #include "nsContentUtils.h"
58 #include "nsCycleCollector.h"
59 #include "nsDOMJSUtils.h"
60 #include "nsISupportsImpl.h"
61 #include "nsLayoutStatics.h"
62 #include "nsNetUtil.h"
63 #include "nsServiceManagerUtils.h"
64 #include "nsThreadUtils.h"
66 #include "nsXPCOMPrivate.h"
67 #include "xpcpublic.h"
68 #include "XPCSelfHostedShmem.h"
70 #if defined(XP_MACOSX)
71 # include "nsMacUtilsImpl.h"
74 #include "WorkerDebuggerManager.h"
75 #include "WorkerError.h"
76 #include "WorkerLoadInfo.h"
77 #include "WorkerRunnable.h"
78 #include "WorkerScope.h"
79 #include "WorkerThread.h"
83 # include "nsICookieJarSettings.h"
86 #define WORKERS_SHUTDOWN_TOPIC "web-workers-shutdown"
88 static mozilla::LazyLogModule
gWorkerShutdownDumpLog("WorkerShutdownDump");
93 #define SHUTDOWN_LOG(msg) MOZ_LOG(gWorkerShutdownDumpLog, LogLevel::Debug, msg);
101 using namespace workerinternals
;
103 namespace workerinternals
{
105 // The size of the worker runtime heaps in bytes. May be changed via pref.
106 #define WORKER_DEFAULT_RUNTIME_HEAPSIZE 32 * 1024 * 1024
108 // The size of the worker JS allocation threshold in MB. May be changed via
110 #define WORKER_DEFAULT_ALLOCATION_THRESHOLD 30
112 // Half the size of the actual C stack, to be safe.
113 #define WORKER_CONTEXT_NATIVE_STACK_LIMIT 128 * sizeof(size_t) * 1024
115 // The maximum number of threads to use for workers, overridable via pref.
116 #define MAX_WORKERS_PER_DOMAIN 512
118 static_assert(MAX_WORKERS_PER_DOMAIN
>= 1,
119 "We should allow at least one worker per domain.");
121 #define PREF_WORKERS_PREFIX "dom.workers."
122 #define PREF_WORKERS_MAX_PER_DOMAIN PREF_WORKERS_PREFIX "maxPerDomain"
124 #define GC_REQUEST_OBSERVER_TOPIC "child-gc-request"
125 #define CC_REQUEST_OBSERVER_TOPIC "child-cc-request"
126 #define MEMORY_PRESSURE_OBSERVER_TOPIC "memory-pressure"
127 #define LOW_MEMORY_DATA "low-memory"
128 #define LOW_MEMORY_ONGOING_DATA "low-memory-ongoing"
129 #define MEMORY_PRESSURE_STOP_OBSERVER_TOPIC "memory-pressure-stop"
131 // Prefixes for observing preference changes.
132 #define PREF_JS_OPTIONS_PREFIX "javascript.options."
133 #define PREF_MEM_OPTIONS_PREFIX "mem."
134 #define PREF_GCZEAL "gczeal"
136 static NS_DEFINE_CID(kStreamTransportServiceCID
, NS_STREAMTRANSPORTSERVICE_CID
);
140 const uint32_t kNoIndex
= uint32_t(-1);
142 uint32_t gMaxWorkersPerDomain
= MAX_WORKERS_PER_DOMAIN
;
144 // Does not hold an owning reference.
145 Atomic
<RuntimeService
*> gRuntimeService(nullptr);
147 // Only true during the call to Init.
148 bool gRuntimeServiceDuringInit
= false;
150 class LiteralRebindingCString
: public nsDependentCString
{
153 void RebindLiteral(const char (&aStr
)[N
]) {
158 template <typename T
>
162 struct PrefTraits
<bool> {
163 using PrefValueType
= bool;
165 static inline PrefValueType
Get(const char* aPref
) {
166 AssertIsOnMainThread();
167 return Preferences::GetBool(aPref
);
170 static inline bool Exists(const char* aPref
) {
171 AssertIsOnMainThread();
172 return Preferences::GetType(aPref
) == nsIPrefBranch::PREF_BOOL
;
177 struct PrefTraits
<int32_t> {
178 using PrefValueType
= int32_t;
180 static inline PrefValueType
Get(const char* aPref
) {
181 AssertIsOnMainThread();
182 return Preferences::GetInt(aPref
);
185 static inline bool Exists(const char* aPref
) {
186 AssertIsOnMainThread();
187 return Preferences::GetType(aPref
) == nsIPrefBranch::PREF_INT
;
191 template <typename T
>
192 T
GetPref(const char* aFullPref
, const T aDefault
, bool* aPresent
= nullptr) {
193 AssertIsOnMainThread();
195 using PrefHelper
= PrefTraits
<T
>;
200 if (PrefHelper::Exists(aFullPref
)) {
201 result
= PrefHelper::Get(aFullPref
);
213 void LoadContextOptions(const char* aPrefName
, void* /* aClosure */) {
214 AssertIsOnMainThread();
216 RuntimeService
* rts
= RuntimeService::GetService();
218 // May be shutting down, just bail.
222 const nsDependentCString
prefName(aPrefName
);
224 // Several other pref branches will get included here so bail out if there is
225 // another callback that will handle this change.
226 if (StringBeginsWith(
228 nsLiteralCString(PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX
))) {
233 if (prefName
.EqualsLiteral(PREF_JS_OPTIONS_PREFIX PREF_GCZEAL
)) {
238 JS::ContextOptions contextOptions
;
239 xpc::SetPrefableContextOptions(contextOptions
);
241 nsCOMPtr
<nsIXULRuntime
> xr
= do_GetService("@mozilla.org/xre/runtime;1");
243 bool safeMode
= false;
244 xr
->GetInSafeMode(&safeMode
);
246 contextOptions
.disableOptionsForSafeMode();
250 RuntimeService::SetDefaultContextOptions(contextOptions
);
253 rts
->UpdateAllWorkerContextOptions();
258 void LoadGCZealOptions(const char* /* aPrefName */, void* /* aClosure */) {
259 AssertIsOnMainThread();
261 RuntimeService
* rts
= RuntimeService::GetService();
263 // May be shutting down, just bail.
267 int32_t gczeal
= GetPref
<int32_t>(PREF_JS_OPTIONS_PREFIX PREF_GCZEAL
, -1);
273 GetPref
<int32_t>(PREF_JS_OPTIONS_PREFIX PREF_GCZEAL
".frequency", -1);
275 frequency
= JS_DEFAULT_ZEAL_FREQ
;
278 RuntimeService::SetDefaultGCZeal(uint8_t(gczeal
), uint32_t(frequency
));
281 rts
->UpdateAllWorkerGCZeal();
286 void UpdateCommonJSGCMemoryOption(RuntimeService
* aRuntimeService
,
287 const char* aPrefName
, JSGCParamKey aKey
) {
288 AssertIsOnMainThread();
289 NS_ASSERTION(aPrefName
, "Null pref name!");
291 int32_t prefValue
= GetPref(aPrefName
, -1);
292 Maybe
<uint32_t> value
= (prefValue
< 0 || prefValue
>= 10000)
294 : Some(uint32_t(prefValue
));
296 RuntimeService::SetDefaultJSGCSettings(aKey
, value
);
298 if (aRuntimeService
) {
299 aRuntimeService
->UpdateAllWorkerMemoryParameter(aKey
, value
);
303 void UpdateOtherJSGCMemoryOption(RuntimeService
* aRuntimeService
,
304 JSGCParamKey aKey
, Maybe
<uint32_t> aValue
) {
305 AssertIsOnMainThread();
307 RuntimeService::SetDefaultJSGCSettings(aKey
, aValue
);
309 if (aRuntimeService
) {
310 aRuntimeService
->UpdateAllWorkerMemoryParameter(aKey
, aValue
);
314 void LoadJSGCMemoryOptions(const char* aPrefName
, void* /* aClosure */) {
315 AssertIsOnMainThread();
317 RuntimeService
* rts
= RuntimeService::GetService();
320 // May be shutting down, just bail.
324 constexpr auto memPrefix
=
325 nsLiteralCString
{PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX
};
326 const nsDependentCString
fullPrefName(aPrefName
);
328 // Pull out the string that actually distinguishes the parameter we need to
330 nsDependentCSubstring memPrefName
;
331 if (StringBeginsWith(fullPrefName
, memPrefix
)) {
332 memPrefName
.Rebind(fullPrefName
, memPrefix
.Length());
334 NS_ERROR("Unknown pref name!");
338 struct WorkerGCPref
{
339 nsLiteralCString memName
;
340 const char* fullName
;
344 #define PREF(suffix_, key_) \
346 nsLiteralCString(PREF_MEM_OPTIONS_PREFIX suffix_), \
347 PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX suffix_, key_ \
349 constexpr WorkerGCPref kWorkerPrefs
[] = {
350 PREF("max", JSGC_MAX_BYTES
),
351 PREF("gc_high_frequency_time_limit_ms", JSGC_HIGH_FREQUENCY_TIME_LIMIT
),
352 PREF("gc_low_frequency_heap_growth", JSGC_LOW_FREQUENCY_HEAP_GROWTH
),
353 PREF("gc_high_frequency_large_heap_growth",
354 JSGC_HIGH_FREQUENCY_LARGE_HEAP_GROWTH
),
355 PREF("gc_high_frequency_small_heap_growth",
356 JSGC_HIGH_FREQUENCY_SMALL_HEAP_GROWTH
),
357 PREF("gc_small_heap_size_max_mb", JSGC_SMALL_HEAP_SIZE_MAX
),
358 PREF("gc_large_heap_size_min_mb", JSGC_LARGE_HEAP_SIZE_MIN
),
359 PREF("gc_balanced_heap_limits", JSGC_BALANCED_HEAP_LIMITS_ENABLED
),
360 PREF("gc_heap_growth_factor", JSGC_HEAP_GROWTH_FACTOR
),
361 PREF("gc_allocation_threshold_mb", JSGC_ALLOCATION_THRESHOLD
),
362 PREF("gc_malloc_threshold_base_mb", JSGC_MALLOC_THRESHOLD_BASE
),
363 PREF("gc_small_heap_incremental_limit",
364 JSGC_SMALL_HEAP_INCREMENTAL_LIMIT
),
365 PREF("gc_large_heap_incremental_limit",
366 JSGC_LARGE_HEAP_INCREMENTAL_LIMIT
),
367 PREF("gc_urgent_threshold_mb", JSGC_URGENT_THRESHOLD_MB
),
368 PREF("gc_incremental_slice_ms", JSGC_SLICE_TIME_BUDGET_MS
),
369 PREF("gc_min_empty_chunk_count", JSGC_MIN_EMPTY_CHUNK_COUNT
),
370 PREF("gc_max_empty_chunk_count", JSGC_MAX_EMPTY_CHUNK_COUNT
),
371 PREF("gc_compacting", JSGC_COMPACTING_ENABLED
),
375 auto pref
= kWorkerPrefs
;
376 auto end
= kWorkerPrefs
+ ArrayLength(kWorkerPrefs
);
378 if (gRuntimeServiceDuringInit
) {
379 // During init, we want to update every pref in kWorkerPrefs.
380 MOZ_ASSERT(memPrefName
.IsEmpty(),
381 "Pref branch prefix only expected during init");
383 // Otherwise, find the single pref that changed.
384 while (pref
!= end
) {
385 if (pref
->memName
== memPrefName
) {
393 nsAutoCString
message("Workers don't support the '");
394 message
.Append(memPrefName
);
395 message
.AppendLiteral("' preference!");
396 NS_WARNING(message
.get());
401 while (pref
!= end
) {
403 case JSGC_MAX_BYTES
: {
404 int32_t prefValue
= GetPref(pref
->fullName
, -1);
405 Maybe
<uint32_t> value
= (prefValue
<= 0 || prefValue
>= 0x1000)
407 : Some(uint32_t(prefValue
) * 1024 * 1024);
408 UpdateOtherJSGCMemoryOption(rts
, pref
->key
, value
);
411 case JSGC_SLICE_TIME_BUDGET_MS
: {
412 int32_t prefValue
= GetPref(pref
->fullName
, -1);
413 Maybe
<uint32_t> value
= (prefValue
<= 0 || prefValue
>= 100000)
415 : Some(uint32_t(prefValue
));
416 UpdateOtherJSGCMemoryOption(rts
, pref
->key
, value
);
419 case JSGC_COMPACTING_ENABLED
:
420 case JSGC_PARALLEL_MARKING_ENABLED
:
421 case JSGC_BALANCED_HEAP_LIMITS_ENABLED
: {
423 bool prefValue
= GetPref(pref
->fullName
, false, &present
);
424 Maybe
<uint32_t> value
= present
? Some(prefValue
? 1 : 0) : Nothing();
425 UpdateOtherJSGCMemoryOption(rts
, pref
->key
, value
);
428 case JSGC_HIGH_FREQUENCY_TIME_LIMIT
:
429 case JSGC_LOW_FREQUENCY_HEAP_GROWTH
:
430 case JSGC_HIGH_FREQUENCY_LARGE_HEAP_GROWTH
:
431 case JSGC_HIGH_FREQUENCY_SMALL_HEAP_GROWTH
:
432 case JSGC_SMALL_HEAP_SIZE_MAX
:
433 case JSGC_LARGE_HEAP_SIZE_MIN
:
434 case JSGC_ALLOCATION_THRESHOLD
:
435 case JSGC_MALLOC_THRESHOLD_BASE
:
436 case JSGC_SMALL_HEAP_INCREMENTAL_LIMIT
:
437 case JSGC_LARGE_HEAP_INCREMENTAL_LIMIT
:
438 case JSGC_URGENT_THRESHOLD_MB
:
439 case JSGC_MIN_EMPTY_CHUNK_COUNT
:
440 case JSGC_MAX_EMPTY_CHUNK_COUNT
:
441 case JSGC_HEAP_GROWTH_FACTOR
:
442 UpdateCommonJSGCMemoryOption(rts
, pref
->fullName
, pref
->key
);
445 MOZ_ASSERT_UNREACHABLE("Unknown JSGCParamKey value");
452 bool InterruptCallback(JSContext
* aCx
) {
453 WorkerPrivate
* worker
= GetWorkerPrivateFromContext(aCx
);
456 // Now is a good time to turn on profiling if it's pending.
457 PROFILER_JS_INTERRUPT_CALLBACK();
459 return worker
->InterruptCallback(aCx
);
462 class LogViolationDetailsRunnable final
: public WorkerMainThreadRunnable
{
463 uint16_t mViolationType
;
467 nsString mScriptSample
;
470 LogViolationDetailsRunnable(WorkerPrivate
* aWorker
, uint16_t aViolationType
,
471 const nsString
& aFileName
, uint32_t aLineNum
,
473 const nsAString
& aScriptSample
)
474 : WorkerMainThreadRunnable(aWorker
,
475 "RuntimeService :: LogViolationDetails"_ns
),
476 mViolationType(aViolationType
),
477 mFileName(aFileName
),
479 mColumnNum(aColumnNum
),
480 mScriptSample(aScriptSample
) {
484 virtual bool MainThreadRun() override
;
487 ~LogViolationDetailsRunnable() = default;
490 bool ContentSecurityPolicyAllows(JSContext
* aCx
, JS::RuntimeCode aKind
,
491 JS::Handle
<JSString
*> aCode
) {
492 WorkerPrivate
* worker
= GetWorkerPrivateFromContext(aCx
);
493 worker
->AssertIsOnWorkerThread();
496 bool reportViolation
;
497 uint16_t violationType
;
498 nsAutoJSString scriptSample
;
499 if (aKind
== JS::RuntimeCode::JS
) {
500 if (NS_WARN_IF(!scriptSample
.init(aCx
, aCode
))) {
501 JS_ClearPendingException(aCx
);
505 if (!nsContentSecurityUtils::IsEvalAllowed(
506 aCx
, worker
->UsesSystemPrincipal(), scriptSample
)) {
510 evalOK
= worker
->IsEvalAllowed();
511 reportViolation
= worker
->GetReportEvalCSPViolations();
512 violationType
= nsIContentSecurityPolicy::VIOLATION_TYPE_EVAL
;
514 evalOK
= worker
->IsWasmEvalAllowed();
515 reportViolation
= worker
->GetReportWasmEvalCSPViolations();
516 violationType
= nsIContentSecurityPolicy::VIOLATION_TYPE_WASM_EVAL
;
519 if (reportViolation
) {
521 uint32_t lineNum
= 0;
522 JS::ColumnNumberOneOrigin columnNum
;
524 JS::AutoFilename file
;
525 if (JS::DescribeScriptedCaller(aCx
, &file
, &lineNum
, &columnNum
) &&
527 CopyUTF8toUTF16(MakeStringSpan(file
.get()), fileName
);
529 MOZ_ASSERT(!JS_IsExceptionPending(aCx
));
532 RefPtr
<LogViolationDetailsRunnable
> runnable
=
533 new LogViolationDetailsRunnable(worker
, violationType
, fileName
,
534 lineNum
, columnNum
.zeroOriginValue(),
538 runnable
->Dispatch(Killing
, rv
);
539 if (NS_WARN_IF(rv
.Failed())) {
540 rv
.SuppressException();
547 void CTypesActivityCallback(JSContext
* aCx
, JS::CTypesActivityType aType
) {
548 WorkerPrivate
* worker
= GetWorkerPrivateFromContext(aCx
);
549 worker
->AssertIsOnWorkerThread();
552 case JS::CTypesActivityType::BeginCall
:
553 worker
->BeginCTypesCall();
556 case JS::CTypesActivityType::EndCall
:
557 worker
->EndCTypesCall();
560 case JS::CTypesActivityType::BeginCallback
:
561 worker
->BeginCTypesCallback();
564 case JS::CTypesActivityType::EndCallback
:
565 worker
->EndCTypesCallback();
569 MOZ_CRASH("Unknown type flag!");
573 // JSDispatchableRunnables are WorkerRunnables used to dispatch JS::Dispatchable
574 // back to their worker thread. A WorkerRunnable is used for two reasons:
576 // 1. The JS::Dispatchable::run() callback may run JS so we cannot use a control
577 // runnable since they use async interrupts and break JS run-to-completion.
579 // 2. The DispatchToEventLoopCallback interface is *required* to fail during
580 // shutdown (see jsapi.h) which is exactly what WorkerRunnable::Dispatch() will
581 // do. Moreover, JS_DestroyContext() does *not* block on JS::Dispatchable::run
582 // being called, DispatchToEventLoopCallback failure is expected to happen
584 class JSDispatchableRunnable final
: public WorkerRunnable
{
585 JS::Dispatchable
* mDispatchable
;
587 ~JSDispatchableRunnable() { MOZ_ASSERT(!mDispatchable
); }
589 // Disable the usual pre/post-dispatch thread assertions since we are
590 // dispatching from some random JS engine internal thread:
592 bool PreDispatch(WorkerPrivate
* aWorkerPrivate
) override
{ return true; }
594 void PostDispatch(WorkerPrivate
* aWorkerPrivate
,
595 bool aDispatchResult
) override
{
596 // For the benefit of the destructor assert.
597 if (!aDispatchResult
) {
598 mDispatchable
= nullptr;
603 JSDispatchableRunnable(WorkerPrivate
* aWorkerPrivate
,
604 JS::Dispatchable
* aDispatchable
)
605 : WorkerRunnable(aWorkerPrivate
, WorkerRunnable::WorkerThread
),
606 mDispatchable(aDispatchable
) {
607 MOZ_ASSERT(mDispatchable
);
610 bool WorkerRun(JSContext
* aCx
, WorkerPrivate
* aWorkerPrivate
) override
{
611 MOZ_ASSERT(aWorkerPrivate
== mWorkerPrivate
);
612 MOZ_ASSERT(aCx
== mWorkerPrivate
->GetJSContext());
613 MOZ_ASSERT(mDispatchable
);
618 mDispatchable
->run(mWorkerPrivate
->GetJSContext(),
619 JS::Dispatchable::NotShuttingDown
);
620 mDispatchable
= nullptr; // mDispatchable may delete itself
625 nsresult
Cancel() override
{
626 MOZ_ASSERT(mDispatchable
);
631 mDispatchable
->run(mWorkerPrivate
->GetJSContext(),
632 JS::Dispatchable::ShuttingDown
);
633 mDispatchable
= nullptr; // mDispatchable may delete itself
639 static bool DispatchToEventLoop(void* aClosure
,
640 JS::Dispatchable
* aDispatchable
) {
641 // This callback may execute either on the worker thread or a random
642 // JS-internal helper thread.
644 // See comment at JS::InitDispatchToEventLoop() below for how we know the
645 // WorkerPrivate is alive.
646 WorkerPrivate
* workerPrivate
= reinterpret_cast<WorkerPrivate
*>(aClosure
);
648 // Dispatch is expected to fail during shutdown for the reasons outlined in
649 // the JSDispatchableRunnable comment above.
650 RefPtr
<JSDispatchableRunnable
> r
=
651 new JSDispatchableRunnable(workerPrivate
, aDispatchable
);
652 return r
->Dispatch();
655 static bool ConsumeStream(JSContext
* aCx
, JS::Handle
<JSObject
*> aObj
,
656 JS::MimeType aMimeType
,
657 JS::StreamConsumer
* aConsumer
) {
658 WorkerPrivate
* worker
= GetWorkerPrivateFromContext(aCx
);
660 JS_ReportErrorNumberASCII(aCx
, js::GetErrorMessage
, nullptr,
661 JSMSG_WASM_ERROR_CONSUMING_RESPONSE
);
665 return FetchUtil::StreamResponseToJS(aCx
, aObj
, aMimeType
, aConsumer
, worker
);
668 bool InitJSContextForWorker(WorkerPrivate
* aWorkerPrivate
,
669 JSContext
* aWorkerCx
) {
670 aWorkerPrivate
->AssertIsOnWorkerThread();
671 NS_ASSERTION(!aWorkerPrivate
->GetJSContext(), "Already has a context!");
674 aWorkerPrivate
->CopyJSSettings(settings
);
676 JS::ContextOptionsRef(aWorkerCx
) = settings
.contextOptions
;
678 // This is the real place where we set the max memory for the runtime.
679 for (const auto& setting
: settings
.gcSettings
) {
681 JS_SetGCParameter(aWorkerCx
, setting
.key
, *setting
.value
);
683 JS_ResetGCParameter(aWorkerCx
, setting
.key
);
687 JS_SetNativeStackQuota(aWorkerCx
, WORKER_CONTEXT_NATIVE_STACK_LIMIT
);
690 static const JSSecurityCallbacks securityCallbacks
= {
691 ContentSecurityPolicyAllows
};
692 JS_SetSecurityCallbacks(aWorkerCx
, &securityCallbacks
);
694 // A WorkerPrivate lives strictly longer than its JSRuntime so we can safely
695 // store a raw pointer as the callback's closure argument on the JSRuntime.
696 JS::InitDispatchToEventLoop(aWorkerCx
, DispatchToEventLoop
,
697 (void*)aWorkerPrivate
);
699 JS::InitConsumeStreamCallback(aWorkerCx
, ConsumeStream
,
700 FetchUtil::ReportJSStreamError
);
702 // When available, set the self-hosted shared memory to be read, so that we
703 // can decode the self-hosted content instead of parsing it.
704 auto& shm
= xpc::SelfHostedShmem::GetSingleton();
705 JS::SelfHostedCache selfHostedContent
= shm
.Content();
707 if (!JS::InitSelfHostedCode(aWorkerCx
, selfHostedContent
)) {
708 NS_WARNING("Could not init self-hosted code!");
712 JS_AddInterruptCallback(aWorkerCx
, InterruptCallback
);
714 JS::SetCTypesActivityCallback(aWorkerCx
, CTypesActivityCallback
);
717 JS_SetGCZeal(aWorkerCx
, settings
.gcZeal
, settings
.gcZealFrequency
);
723 static bool PreserveWrapper(JSContext
* cx
, JS::Handle
<JSObject
*> obj
) {
726 MOZ_ASSERT(mozilla::dom::IsDOMObject(obj
));
728 return mozilla::dom::TryPreserveWrapper(obj
);
731 static bool IsWorkerDebuggerGlobalOrSandbox(JS::Handle
<JSObject
*> aGlobal
) {
732 return IsWorkerDebuggerGlobal(aGlobal
) || IsWorkerDebuggerSandbox(aGlobal
);
735 JSObject
* Wrap(JSContext
* cx
, JS::Handle
<JSObject
*> existing
,
736 JS::Handle
<JSObject
*> obj
) {
737 JS::Rooted
<JSObject
*> targetGlobal(cx
, JS::CurrentGlobalOrNull(cx
));
739 // Note: the JS engine unwraps CCWs before calling this callback.
740 JS::Rooted
<JSObject
*> originGlobal(cx
, JS::GetNonCCWObjectGlobal(obj
));
742 const js::Wrapper
* wrapper
= nullptr;
743 if (IsWorkerDebuggerGlobalOrSandbox(targetGlobal
) &&
744 IsWorkerDebuggerGlobalOrSandbox(originGlobal
)) {
745 wrapper
= &js::CrossCompartmentWrapper::singleton
;
747 wrapper
= &js::OpaqueCrossCompartmentWrapper::singleton
;
751 js::Wrapper::Renew(existing
, obj
, wrapper
);
753 return js::Wrapper::New(cx
, obj
, wrapper
);
756 static const JSWrapObjectCallbacks WrapObjectCallbacks
= {
761 class WorkerJSRuntime final
: public mozilla::CycleCollectedJSRuntime
{
763 // The heap size passed here doesn't matter, we will change it later in the
764 // call to JS_SetGCParameter inside InitJSContextForWorker.
765 explicit WorkerJSRuntime(JSContext
* aCx
, WorkerPrivate
* aWorkerPrivate
)
766 : CycleCollectedJSRuntime(aCx
), mWorkerPrivate(aWorkerPrivate
) {
767 MOZ_COUNT_CTOR_INHERITED(WorkerJSRuntime
, CycleCollectedJSRuntime
);
768 MOZ_ASSERT(aWorkerPrivate
);
771 JS::UniqueChars defaultLocale
= aWorkerPrivate
->AdoptDefaultLocale();
772 MOZ_ASSERT(defaultLocale
,
773 "failure of a WorkerPrivate to have a default locale should "
774 "have made the worker fail to spawn");
776 if (!JS_SetDefaultLocale(Runtime(), defaultLocale
.get())) {
777 NS_WARNING("failed to set workerCx's default locale");
782 void Shutdown(JSContext
* cx
) override
{
783 // The CC is shut down, and the superclass destructor will GC, so make sure
784 // we don't try to CC again.
785 mWorkerPrivate
= nullptr;
787 CycleCollectedJSRuntime::Shutdown(cx
);
791 MOZ_COUNT_DTOR_INHERITED(WorkerJSRuntime
, CycleCollectedJSRuntime
);
794 virtual void PrepareForForgetSkippable() override
{}
796 virtual void BeginCycleCollectionCallback(
797 mozilla::CCReason aReason
) override
{}
799 virtual void EndCycleCollectionCallback(
800 CycleCollectorResults
& aResults
) override
{}
802 void DispatchDeferredDeletion(bool aContinuation
, bool aPurge
) override
{
803 MOZ_ASSERT(!aContinuation
);
805 // Do it immediately, no need for asynchronous behavior here.
806 nsCycleCollector_doDeferredDeletion();
809 virtual void CustomGCCallback(JSGCStatus aStatus
) override
{
810 if (!mWorkerPrivate
) {
811 // We're shutting down, no need to do anything.
815 mWorkerPrivate
->AssertIsOnWorkerThread();
817 if (aStatus
== JSGC_END
) {
818 bool collectedAnything
=
819 nsCycleCollector_collect(CCReason::GC_FINISHED
, nullptr);
820 mWorkerPrivate
->SetCCCollectedAnything(collectedAnything
);
825 WorkerPrivate
* mWorkerPrivate
;
828 } // anonymous namespace
830 } // namespace workerinternals
832 class WorkerJSContext final
: public mozilla::CycleCollectedJSContext
{
834 // The heap size passed here doesn't matter, we will change it later in the
835 // call to JS_SetGCParameter inside InitJSContextForWorker.
836 explicit WorkerJSContext(WorkerPrivate
* aWorkerPrivate
)
837 : mWorkerPrivate(aWorkerPrivate
) {
838 MOZ_COUNT_CTOR_INHERITED(WorkerJSContext
, CycleCollectedJSContext
);
839 MOZ_ASSERT(aWorkerPrivate
);
840 // Magical number 2. Workers have the base recursion depth 1, and normal
841 // runnables run at level 2, and we don't want to process microtasks
842 // at any other level.
843 SetTargetedMicroTaskRecursionDepth(2);
846 // MOZ_CAN_RUN_SCRIPT_BOUNDARY because otherwise we have to annotate the
847 // SpiderMonkey JS::JobQueue's destructor as MOZ_CAN_RUN_SCRIPT, which is a
849 MOZ_CAN_RUN_SCRIPT_BOUNDARY
~WorkerJSContext() {
850 MOZ_COUNT_DTOR_INHERITED(WorkerJSContext
, CycleCollectedJSContext
);
851 JSContext
* cx
= MaybeContext();
853 return; // Initialize() must have failed
856 // We expect to come here with the cycle collector already shut down.
857 // The superclass destructor will run the GC one final time and finalize any
858 // JSObjects that were participating in cycles that were broken during CC
860 // Make sure we don't try to CC again.
861 mWorkerPrivate
= nullptr;
864 WorkerJSContext
* GetAsWorkerJSContext() override
{ return this; }
866 CycleCollectedJSRuntime
* CreateRuntime(JSContext
* aCx
) override
{
867 return new WorkerJSRuntime(aCx
, mWorkerPrivate
);
870 nsresult
Initialize(JSRuntime
* aParentRuntime
) {
871 nsresult rv
= CycleCollectedJSContext::Initialize(
872 aParentRuntime
, WORKER_DEFAULT_RUNTIME_HEAPSIZE
);
873 if (NS_WARN_IF(NS_FAILED(rv
))) {
877 JSContext
* cx
= Context();
879 js::SetPreserveWrapperCallbacks(cx
, PreserveWrapper
, HasReleasedWrapper
);
880 JS_InitDestroyPrincipalsCallback(cx
, nsJSPrincipals::Destroy
);
881 JS_InitReadPrincipalsCallback(cx
, nsJSPrincipals::ReadPrincipals
);
882 JS_SetWrapObjectCallbacks(cx
, &WrapObjectCallbacks
);
883 if (mWorkerPrivate
->IsDedicatedWorker()) {
884 JS_SetFutexCanWait(cx
);
890 virtual void DispatchToMicroTask(
891 already_AddRefed
<MicroTaskRunnable
> aRunnable
) override
{
892 RefPtr
<MicroTaskRunnable
> runnable(aRunnable
);
894 MOZ_ASSERT(!NS_IsMainThread());
895 MOZ_ASSERT(runnable
);
897 std::deque
<RefPtr
<MicroTaskRunnable
>>* microTaskQueue
= nullptr;
899 JSContext
* cx
= Context();
900 NS_ASSERTION(cx
, "This should never be null!");
902 JS::Rooted
<JSObject
*> global(cx
, JS::CurrentGlobalOrNull(cx
));
903 NS_ASSERTION(global
, "This should never be null!");
905 // On worker threads, if the current global is the worker global or
906 // ShadowRealm global, we use the main micro task queue. Otherwise, the
907 // current global must be either the debugger global or a debugger sandbox,
908 // and we use the debugger micro task queue instead.
909 if (IsWorkerGlobal(global
) || IsShadowRealmGlobal(global
)) {
910 microTaskQueue
= &GetMicroTaskQueue();
912 MOZ_ASSERT(IsWorkerDebuggerGlobal(global
) ||
913 IsWorkerDebuggerSandbox(global
));
915 microTaskQueue
= &GetDebuggerMicroTaskQueue();
918 JS::JobQueueMayNotBeEmpty(cx
);
919 microTaskQueue
->push_back(std::move(runnable
));
922 bool IsSystemCaller() const override
{
923 return mWorkerPrivate
->UsesSystemPrincipal();
926 void ReportError(JSErrorReport
* aReport
,
927 JS::ConstUTF8CharsZ aToStringResult
) override
{
928 mWorkerPrivate
->ReportError(Context(), aToStringResult
, aReport
);
931 WorkerPrivate
* GetWorkerPrivate() const { return mWorkerPrivate
; }
934 WorkerPrivate
* mWorkerPrivate
;
937 namespace workerinternals
{
941 class WorkerThreadPrimaryRunnable final
: public Runnable
{
942 WorkerPrivate
* mWorkerPrivate
;
943 SafeRefPtr
<WorkerThread
> mThread
;
944 JSRuntime
* mParentRuntime
;
946 class FinishedRunnable final
: public Runnable
{
947 SafeRefPtr
<WorkerThread
> mThread
;
950 explicit FinishedRunnable(SafeRefPtr
<WorkerThread
> aThread
)
951 : Runnable("WorkerThreadPrimaryRunnable::FinishedRunnable"),
952 mThread(std::move(aThread
)) {
956 NS_INLINE_DECL_REFCOUNTING_INHERITED(FinishedRunnable
, Runnable
)
959 ~FinishedRunnable() = default;
965 WorkerThreadPrimaryRunnable(WorkerPrivate
* aWorkerPrivate
,
966 SafeRefPtr
<WorkerThread
> aThread
,
967 JSRuntime
* aParentRuntime
)
968 : mozilla::Runnable("WorkerThreadPrimaryRunnable"),
969 mWorkerPrivate(aWorkerPrivate
),
970 mThread(std::move(aThread
)),
971 mParentRuntime(aParentRuntime
) {
972 MOZ_ASSERT(aWorkerPrivate
);
976 NS_INLINE_DECL_REFCOUNTING_INHERITED(WorkerThreadPrimaryRunnable
, Runnable
)
979 ~WorkerThreadPrimaryRunnable() = default;
984 void PrefLanguagesChanged(const char* /* aPrefName */, void* /* aClosure */) {
985 AssertIsOnMainThread();
987 nsTArray
<nsString
> languages
;
988 Navigator::GetAcceptLanguages(languages
);
990 RuntimeService
* runtime
= RuntimeService::GetService();
992 runtime
->UpdateAllWorkerLanguages(languages
);
996 void AppVersionOverrideChanged(const char* /* aPrefName */,
997 void* /* aClosure */) {
998 AssertIsOnMainThread();
1000 nsAutoString override
;
1001 Preferences::GetString("general.appversion.override", override
);
1003 RuntimeService
* runtime
= RuntimeService::GetService();
1005 runtime
->UpdateAppVersionOverridePreference(override
);
1009 void PlatformOverrideChanged(const char* /* aPrefName */,
1010 void* /* aClosure */) {
1011 AssertIsOnMainThread();
1013 nsAutoString override
;
1014 Preferences::GetString("general.platform.override", override
);
1016 RuntimeService
* runtime
= RuntimeService::GetService();
1018 runtime
->UpdatePlatformOverridePreference(override
);
1022 } /* anonymous namespace */
1024 // This is only touched on the main thread. Initialized in Init() below.
1025 UniquePtr
<JSSettings
> RuntimeService::sDefaultJSSettings
;
1027 RuntimeService::RuntimeService()
1028 : mMutex("RuntimeService::mMutex"),
1030 mShuttingDown(false),
1031 mNavigatorPropertiesLoaded(false) {
1032 AssertIsOnMainThread();
1033 MOZ_ASSERT(!GetService(), "More than one service!");
1036 RuntimeService::~RuntimeService() {
1037 AssertIsOnMainThread();
1039 // gRuntimeService can be null if Init() fails.
1040 MOZ_ASSERT(!GetService() || GetService() == this, "More than one service!");
1042 gRuntimeService
= nullptr;
1046 RuntimeService
* RuntimeService::GetOrCreateService() {
1047 AssertIsOnMainThread();
1049 if (!gRuntimeService
) {
1050 // The observer service now owns us until shutdown.
1051 gRuntimeService
= new RuntimeService();
1052 if (NS_FAILED((*gRuntimeService
).Init())) {
1053 NS_WARNING("Failed to initialize!");
1054 (*gRuntimeService
).Cleanup();
1055 gRuntimeService
= nullptr;
1060 return gRuntimeService
;
1064 RuntimeService
* RuntimeService::GetService() { return gRuntimeService
; }
1066 bool RuntimeService::RegisterWorker(WorkerPrivate
& aWorkerPrivate
) {
1067 aWorkerPrivate
.AssertIsOnParentThread();
1069 WorkerPrivate
* parent
= aWorkerPrivate
.GetParent();
1071 AssertIsOnMainThread();
1073 if (mShuttingDown
) {
1078 const bool isServiceWorker
= aWorkerPrivate
.IsServiceWorker();
1079 const bool isSharedWorker
= aWorkerPrivate
.IsSharedWorker();
1080 const bool isDedicatedWorker
= aWorkerPrivate
.IsDedicatedWorker();
1081 if (isServiceWorker
) {
1082 AssertIsOnMainThread();
1083 Telemetry::Accumulate(Telemetry::SERVICE_WORKER_SPAWN_ATTEMPTS
, 1);
1086 nsCString sharedWorkerScriptSpec
;
1087 if (isSharedWorker
) {
1088 AssertIsOnMainThread();
1090 nsCOMPtr
<nsIURI
> scriptURI
= aWorkerPrivate
.GetResolvedScriptURI();
1091 NS_ASSERTION(scriptURI
, "Null script URI!");
1093 nsresult rv
= scriptURI
->GetSpec(sharedWorkerScriptSpec
);
1094 if (NS_FAILED(rv
)) {
1095 NS_WARNING("GetSpec failed?!");
1099 NS_ASSERTION(!sharedWorkerScriptSpec
.IsEmpty(), "Empty spec!");
1102 bool exemptFromPerDomainMax
= false;
1103 if (isServiceWorker
) {
1104 AssertIsOnMainThread();
1105 exemptFromPerDomainMax
= Preferences::GetBool(
1106 "dom.serviceWorkers.exemptFromPerDomainMax", false);
1109 const nsCString
& domain
= aWorkerPrivate
.Domain();
1111 bool queued
= false;
1113 MutexAutoLock
lock(mMutex
);
1115 auto* const domainInfo
=
1117 .LookupOrInsertWith(
1120 NS_ASSERTION(!parent
, "Shouldn't have a parent here!");
1121 Unused
<< parent
; // silence clang -Wunused-lambda-capture in
1123 auto wdi
= MakeUnique
<WorkerDomainInfo
>();
1124 wdi
->mDomain
= domain
;
1129 queued
= gMaxWorkersPerDomain
&&
1130 domainInfo
->ActiveWorkerCount() >= gMaxWorkersPerDomain
&&
1131 !domain
.IsEmpty() && !exemptFromPerDomainMax
;
1134 domainInfo
->mQueuedWorkers
.AppendElement(&aWorkerPrivate
);
1136 // Worker spawn gets queued due to hitting max workers per domain
1137 // limit so let's log a warning.
1138 WorkerPrivate::ReportErrorToConsole("HittingMaxWorkersPerDomain2");
1140 if (isServiceWorker
) {
1141 Telemetry::Accumulate(Telemetry::SERVICE_WORKER_SPAWN_GETS_QUEUED
, 1);
1142 } else if (isSharedWorker
) {
1143 Telemetry::Accumulate(Telemetry::SHARED_WORKER_SPAWN_GETS_QUEUED
, 1);
1144 } else if (isDedicatedWorker
) {
1145 Telemetry::Accumulate(Telemetry::DEDICATED_WORKER_SPAWN_GETS_QUEUED
, 1);
1147 } else if (parent
) {
1148 domainInfo
->mChildWorkerCount
++;
1149 } else if (isServiceWorker
) {
1150 domainInfo
->mActiveServiceWorkers
.AppendElement(&aWorkerPrivate
);
1152 domainInfo
->mActiveWorkers
.AppendElement(&aWorkerPrivate
);
1156 // From here on out we must call UnregisterWorker if something fails!
1158 if (!parent
->AddChildWorker(aWorkerPrivate
)) {
1159 UnregisterWorker(aWorkerPrivate
);
1163 if (!mNavigatorPropertiesLoaded
) {
1164 if (NS_FAILED(Navigator::GetAppVersion(
1165 mNavigatorProperties
.mAppVersion
, aWorkerPrivate
.GetDocument(),
1166 false /* aUsePrefOverriddenValue */)) ||
1167 NS_FAILED(Navigator::GetPlatform(
1168 mNavigatorProperties
.mPlatform
, aWorkerPrivate
.GetDocument(),
1169 false /* aUsePrefOverriddenValue */))) {
1170 UnregisterWorker(aWorkerPrivate
);
1174 // The navigator overridden properties should have already been read.
1176 Navigator::GetAcceptLanguages(mNavigatorProperties
.mLanguages
);
1177 mNavigatorPropertiesLoaded
= true;
1180 nsPIDOMWindowInner
* window
= aWorkerPrivate
.GetWindow();
1182 if (!isServiceWorker
) {
1183 // Service workers are excluded since their lifetime is separate from
1184 // that of dom windows.
1185 if (auto* const windowArray
= mWindowMap
.GetOrInsertNew(window
, 1);
1186 !windowArray
->Contains(&aWorkerPrivate
)) {
1187 windowArray
->AppendElement(&aWorkerPrivate
);
1189 MOZ_ASSERT(aWorkerPrivate
.IsSharedWorker());
1194 if (!queued
&& !ScheduleWorker(aWorkerPrivate
)) {
1198 if (isServiceWorker
) {
1199 AssertIsOnMainThread();
1200 Telemetry::Accumulate(Telemetry::SERVICE_WORKER_WAS_SPAWNED
, 1);
1205 void RuntimeService::UnregisterWorker(WorkerPrivate
& aWorkerPrivate
) {
1206 aWorkerPrivate
.AssertIsOnParentThread();
1208 WorkerPrivate
* parent
= aWorkerPrivate
.GetParent();
1210 AssertIsOnMainThread();
1213 const nsCString
& domain
= aWorkerPrivate
.Domain();
1215 WorkerPrivate
* queuedWorker
= nullptr;
1217 MutexAutoLock
lock(mMutex
);
1219 WorkerDomainInfo
* domainInfo
;
1220 if (!mDomainMap
.Get(domain
, &domainInfo
)) {
1221 NS_ERROR("Don't have an entry for this domain!");
1224 // Remove old worker from everywhere.
1225 uint32_t index
= domainInfo
->mQueuedWorkers
.IndexOf(&aWorkerPrivate
);
1226 if (index
!= kNoIndex
) {
1227 // Was queued, remove from the list.
1228 domainInfo
->mQueuedWorkers
.RemoveElementAt(index
);
1229 } else if (parent
) {
1230 MOZ_ASSERT(domainInfo
->mChildWorkerCount
, "Must be non-zero!");
1231 domainInfo
->mChildWorkerCount
--;
1232 } else if (aWorkerPrivate
.IsServiceWorker()) {
1233 MOZ_ASSERT(domainInfo
->mActiveServiceWorkers
.Contains(&aWorkerPrivate
),
1234 "Don't know about this worker!");
1235 domainInfo
->mActiveServiceWorkers
.RemoveElement(&aWorkerPrivate
);
1237 MOZ_ASSERT(domainInfo
->mActiveWorkers
.Contains(&aWorkerPrivate
),
1238 "Don't know about this worker!");
1239 domainInfo
->mActiveWorkers
.RemoveElement(&aWorkerPrivate
);
1242 // See if there's a queued worker we can schedule.
1243 if (domainInfo
->ActiveWorkerCount() < gMaxWorkersPerDomain
&&
1244 !domainInfo
->mQueuedWorkers
.IsEmpty()) {
1245 queuedWorker
= domainInfo
->mQueuedWorkers
[0];
1246 domainInfo
->mQueuedWorkers
.RemoveElementAt(0);
1248 if (queuedWorker
->GetParent()) {
1249 domainInfo
->mChildWorkerCount
++;
1250 } else if (queuedWorker
->IsServiceWorker()) {
1251 domainInfo
->mActiveServiceWorkers
.AppendElement(queuedWorker
);
1253 domainInfo
->mActiveWorkers
.AppendElement(queuedWorker
);
1257 if (domainInfo
->HasNoWorkers()) {
1258 MOZ_ASSERT(domainInfo
->mQueuedWorkers
.IsEmpty());
1259 mDomainMap
.Remove(domain
);
1263 // NB: For Shared Workers we used to call ShutdownOnMainThread on the
1264 // RemoteWorkerController; however, that was redundant because
1265 // RemoteWorkerChild uses a WeakWorkerRef which notifies at about the
1266 // same time as us calling into the code here and would race with us.
1269 parent
->RemoveChildWorker(aWorkerPrivate
);
1270 } else if (aWorkerPrivate
.IsSharedWorker()) {
1271 AssertIsOnMainThread();
1273 mWindowMap
.RemoveIf([&aWorkerPrivate
](const auto& iter
) {
1274 const auto& workers
= iter
.Data();
1275 MOZ_ASSERT(workers
);
1277 if (workers
->RemoveElement(&aWorkerPrivate
)) {
1278 MOZ_ASSERT(!workers
->Contains(&aWorkerPrivate
),
1279 "Added worker more than once!");
1281 return workers
->IsEmpty();
1286 } else if (aWorkerPrivate
.IsDedicatedWorker()) {
1288 nsPIDOMWindowInner
* window
= aWorkerPrivate
.GetWindow();
1289 if (auto entry
= mWindowMap
.Lookup(window
)) {
1290 MOZ_ALWAYS_TRUE(entry
.Data()->RemoveElement(&aWorkerPrivate
));
1291 if (entry
.Data()->IsEmpty()) {
1295 MOZ_ASSERT_UNREACHABLE("window is not in mWindowMap");
1299 if (queuedWorker
&& !ScheduleWorker(*queuedWorker
)) {
1300 UnregisterWorker(*queuedWorker
);
1304 bool RuntimeService::ScheduleWorker(WorkerPrivate
& aWorkerPrivate
) {
1305 if (!aWorkerPrivate
.Start()) {
1306 // This is ok, means that we didn't need to make a thread for this worker.
1310 const WorkerThreadFriendKey friendKey
;
1312 SafeRefPtr
<WorkerThread
> thread
= WorkerThread::Create(friendKey
);
1314 UnregisterWorker(aWorkerPrivate
);
1318 if (NS_FAILED(thread
->SetPriority(nsISupportsPriority::PRIORITY_NORMAL
))) {
1319 NS_WARNING("Could not set the thread's priority!");
1322 aWorkerPrivate
.SetThread(thread
.unsafeGetRawPtr());
1323 JSContext
* cx
= CycleCollectedJSContext::Get()->Context();
1324 nsCOMPtr
<nsIRunnable
> runnable
= new WorkerThreadPrimaryRunnable(
1325 &aWorkerPrivate
, thread
.clonePtr(), JS_GetParentRuntime(cx
));
1327 thread
->DispatchPrimaryRunnable(friendKey
, runnable
.forget()))) {
1328 UnregisterWorker(aWorkerPrivate
);
1335 nsresult
RuntimeService::Init() {
1336 AssertIsOnMainThread();
1338 nsLayoutStatics::AddRef();
1340 // Initialize JSSettings.
1341 sDefaultJSSettings
= MakeUnique
<JSSettings
>();
1342 SetDefaultJSGCSettings(JSGC_MAX_BYTES
, Some(WORKER_DEFAULT_RUNTIME_HEAPSIZE
));
1343 SetDefaultJSGCSettings(JSGC_ALLOCATION_THRESHOLD
,
1344 Some(WORKER_DEFAULT_ALLOCATION_THRESHOLD
));
1346 // nsIStreamTransportService is thread-safe but it must be initialized on the
1347 // main-thread. FileReader needs it, so, let's initialize it now.
1349 nsCOMPtr
<nsIStreamTransportService
> sts
=
1350 do_GetService(kStreamTransportServiceCID
, &rv
);
1351 NS_ENSURE_TRUE(sts
, NS_ERROR_FAILURE
);
1353 nsCOMPtr
<nsIObserverService
> obs
= services::GetObserverService();
1354 NS_ENSURE_TRUE(obs
, NS_ERROR_FAILURE
);
1356 rv
= obs
->AddObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID
, false);
1357 NS_ENSURE_SUCCESS(rv
, rv
);
1359 rv
= obs
->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID
, false);
1360 NS_ENSURE_SUCCESS(rv
, rv
);
1364 if (NS_FAILED(obs
->AddObserver(this, GC_REQUEST_OBSERVER_TOPIC
, false))) {
1365 NS_WARNING("Failed to register for GC request notifications!");
1368 if (NS_FAILED(obs
->AddObserver(this, CC_REQUEST_OBSERVER_TOPIC
, false))) {
1369 NS_WARNING("Failed to register for CC request notifications!");
1373 obs
->AddObserver(this, MEMORY_PRESSURE_OBSERVER_TOPIC
, false))) {
1374 NS_WARNING("Failed to register for memory pressure notifications!");
1378 obs
->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC
, false))) {
1379 NS_WARNING("Failed to register for offline notification event!");
1382 MOZ_ASSERT(!gRuntimeServiceDuringInit
, "This should be false!");
1383 gRuntimeServiceDuringInit
= true;
1385 #define WORKER_PREF(name, callback) \
1386 NS_FAILED(Preferences::RegisterCallbackAndCall(callback, name))
1388 if (NS_FAILED(Preferences::RegisterPrefixCallbackAndCall(
1389 LoadJSGCMemoryOptions
,
1390 PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX
)) ||
1392 NS_FAILED(Preferences::RegisterCallback(
1393 LoadGCZealOptions
, PREF_JS_OPTIONS_PREFIX PREF_GCZEAL
)) ||
1395 WORKER_PREF("intl.accept_languages", PrefLanguagesChanged
) ||
1396 WORKER_PREF("general.appversion.override", AppVersionOverrideChanged
) ||
1397 WORKER_PREF("general.platform.override", PlatformOverrideChanged
) ||
1398 NS_FAILED(Preferences::RegisterPrefixCallbackAndCall(
1399 LoadContextOptions
, PREF_JS_OPTIONS_PREFIX
))) {
1400 NS_WARNING("Failed to register pref callbacks!");
1405 MOZ_ASSERT(gRuntimeServiceDuringInit
, "Should be true!");
1406 gRuntimeServiceDuringInit
= false;
1408 int32_t maxPerDomain
=
1409 Preferences::GetInt(PREF_WORKERS_MAX_PER_DOMAIN
, MAX_WORKERS_PER_DOMAIN
);
1410 gMaxWorkersPerDomain
= std::max(0, maxPerDomain
);
1412 if (NS_WARN_IF(!IndexedDatabaseManager::GetOrCreate())) {
1413 return NS_ERROR_UNEXPECTED
;
1416 // PerformanceService must be initialized on the main-thread.
1417 PerformanceService::GetOrCreate();
1422 void RuntimeService::Shutdown() {
1423 AssertIsOnMainThread();
1425 MOZ_ASSERT(!mShuttingDown
);
1426 // That's it, no more workers.
1427 mShuttingDown
= true;
1429 nsCOMPtr
<nsIObserverService
> obs
= services::GetObserverService();
1430 NS_WARNING_ASSERTION(obs
, "Failed to get observer service?!");
1432 // Tell anyone that cares that they're about to lose worker support.
1433 if (obs
&& NS_FAILED(obs
->NotifyObservers(nullptr, WORKERS_SHUTDOWN_TOPIC
,
1435 NS_WARNING("NotifyObservers failed!");
1439 AutoTArray
<WorkerPrivate
*, 100> workers
;
1442 MutexAutoLock
lock(mMutex
);
1444 AddAllTopLevelWorkersToArray(workers
);
1447 // Cancel all top-level workers.
1448 for (const auto& worker
: workers
) {
1449 if (!worker
->Cancel()) {
1450 NS_WARNING("Failed to cancel worker!");
1455 sDefaultJSSettings
= nullptr;
1460 class DumpCrashInfoRunnable
: public WorkerControlRunnable
{
1462 explicit DumpCrashInfoRunnable(WorkerPrivate
* aWorkerPrivate
)
1463 : WorkerControlRunnable(aWorkerPrivate
, WorkerThread
),
1464 mMonitor("DumpCrashInfoRunnable::mMonitor") {}
1466 bool WorkerRun(JSContext
* aCx
, WorkerPrivate
* aWorkerPrivate
) override
{
1467 MonitorAutoLock
lock(mMonitor
);
1469 aWorkerPrivate
->DumpCrashInformation(mMsg
);
1476 nsresult
Cancel() override
{
1477 MonitorAutoLock
lock(mMonitor
);
1479 mMsg
.Assign("Canceled");
1487 bool DispatchAndWait() {
1488 MonitorAutoLock
lock(mMonitor
);
1491 // The worker is already dead but the main thread still didn't remove it
1492 // from RuntimeService's registry.
1496 // To avoid any possibility of process hangs we never receive reports on
1497 // we give the worker 1sec to react.
1498 lock
.Wait(TimeDuration::FromMilliseconds(1000));
1500 mMsg
.Append("NoResponse");
1506 const nsCString
& MsgData() const { return mMsg
; }
1509 bool PreDispatch(WorkerPrivate
* aWorkerPrivate
) override
{ return true; }
1511 void PostDispatch(WorkerPrivate
* aWorkerPrivate
,
1512 bool aDispatchResult
) override
{}
1514 Monitor mMonitor MOZ_UNANNOTATED
;
1516 FlippedOnce
<false> mHasMsg
;
1519 struct ActiveWorkerStats
{
1520 template <uint32_t ActiveWorkerStats::*Category
>
1521 void Update(const nsTArray
<WorkerPrivate
*>& aWorkers
) {
1522 for (const auto worker
: aWorkers
) {
1523 RefPtr
<DumpCrashInfoRunnable
> runnable
=
1524 new DumpCrashInfoRunnable(worker
);
1525 if (runnable
->DispatchAndWait()) {
1526 ++(this->*Category
);
1527 mMessage
.Append(runnable
->MsgData());
1532 uint32_t mWorkers
= 0;
1533 uint32_t mServiceWorkers
= 0;
1539 void RuntimeService::CrashIfHanging() {
1540 MutexAutoLock
lock(mMutex
);
1542 // If we never wanted to shut down we cannot hang.
1543 if (!mShuttingDown
) {
1547 ActiveWorkerStats activeStats
;
1548 uint32_t inactiveWorkers
= 0;
1550 for (const auto& aData
: mDomainMap
.Values()) {
1551 activeStats
.Update
<&ActiveWorkerStats::mWorkers
>(aData
->mActiveWorkers
);
1552 activeStats
.Update
<&ActiveWorkerStats::mServiceWorkers
>(
1553 aData
->mActiveServiceWorkers
);
1555 // These might not be top-level workers...
1556 inactiveWorkers
+= std::count_if(
1557 aData
->mQueuedWorkers
.begin(), aData
->mQueuedWorkers
.end(),
1558 [](const auto* const worker
) { return !worker
->GetParent(); });
1561 if (activeStats
.mWorkers
+ activeStats
.mServiceWorkers
+ inactiveWorkers
==
1568 // A: active Workers | S: active ServiceWorkers | Q: queued Workers
1569 msg
.AppendPrintf("Workers Hanging - %d|A:%d|S:%d|Q:%d", mShuttingDown
? 1 : 0,
1570 activeStats
.mWorkers
, activeStats
.mServiceWorkers
,
1572 msg
.Append(activeStats
.mMessage
);
1574 // This string will be leaked.
1575 MOZ_CRASH_UNSAFE(strdup(msg
.BeginReading()));
1578 // This spins the event loop until all workers are finished and their threads
1579 // have been joined.
1580 void RuntimeService::Cleanup() {
1581 AssertIsOnMainThread();
1583 if (!mShuttingDown
) {
1587 nsCOMPtr
<nsIObserverService
> obs
= services::GetObserverService();
1588 NS_WARNING_ASSERTION(obs
, "Failed to get observer service?!");
1591 MutexAutoLock
lock(mMutex
);
1593 AutoTArray
<WorkerPrivate
*, 100> workers
;
1594 AddAllTopLevelWorkersToArray(workers
);
1596 if (!workers
.IsEmpty()) {
1597 nsIThread
* currentThread
= NS_GetCurrentThread();
1598 NS_ASSERTION(currentThread
, "This should never be null!");
1600 // If the loop below takes too long, we probably have a problematic
1601 // worker. MOZ_LOG some info before the parent process forcibly
1602 // terminates us so that in the event we are a content process, the log
1603 // output can provide useful context about the workers that did not
1604 // cleanly shut down.
1605 nsCOMPtr
<nsITimer
> timer
;
1606 RefPtr
<RuntimeService
> self
= this;
1607 nsresult rv
= NS_NewTimerWithCallback(
1608 getter_AddRefs(timer
),
1609 [self
](nsITimer
*) { self
->DumpRunningWorkers(); },
1610 TimeDuration::FromSeconds(1), nsITimer::TYPE_ONE_SHOT
,
1611 "RuntimeService::WorkerShutdownDump");
1612 Unused
<< NS_WARN_IF(NS_FAILED(rv
));
1614 // And make sure all their final messages have run and all their threads
1616 while (mDomainMap
.Count()) {
1617 MutexAutoUnlock
unlock(mMutex
);
1619 if (!NS_ProcessNextEvent(currentThread
)) {
1620 NS_WARNING("Something bad happened!");
1625 if (NS_SUCCEEDED(rv
)) {
1631 NS_ASSERTION(!mWindowMap
.Count(), "All windows should have been released!");
1633 #define WORKER_PREF(name, callback) \
1634 NS_FAILED(Preferences::UnregisterCallback(callback, name))
1637 if (NS_FAILED(Preferences::UnregisterPrefixCallback(
1638 LoadContextOptions
, PREF_JS_OPTIONS_PREFIX
)) ||
1639 WORKER_PREF("intl.accept_languages", PrefLanguagesChanged
) ||
1640 WORKER_PREF("general.appversion.override", AppVersionOverrideChanged
) ||
1641 WORKER_PREF("general.platform.override", PlatformOverrideChanged
) ||
1643 NS_FAILED(Preferences::UnregisterCallback(
1644 LoadGCZealOptions
, PREF_JS_OPTIONS_PREFIX PREF_GCZEAL
)) ||
1646 NS_FAILED(Preferences::UnregisterPrefixCallback(
1647 LoadJSGCMemoryOptions
,
1648 PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX
))) {
1649 NS_WARNING("Failed to unregister pref callbacks!");
1655 if (NS_FAILED(obs
->RemoveObserver(this, GC_REQUEST_OBSERVER_TOPIC
))) {
1656 NS_WARNING("Failed to unregister for GC request notifications!");
1659 if (NS_FAILED(obs
->RemoveObserver(this, CC_REQUEST_OBSERVER_TOPIC
))) {
1660 NS_WARNING("Failed to unregister for CC request notifications!");
1664 obs
->RemoveObserver(this, MEMORY_PRESSURE_OBSERVER_TOPIC
))) {
1665 NS_WARNING("Failed to unregister for memory pressure notifications!");
1669 obs
->RemoveObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC
))) {
1670 NS_WARNING("Failed to unregister for offline notification event!");
1672 obs
->RemoveObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID
);
1673 obs
->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID
);
1678 nsLayoutStatics::Release();
1681 void RuntimeService::AddAllTopLevelWorkersToArray(
1682 nsTArray
<WorkerPrivate
*>& aWorkers
) {
1683 for (const auto& aData
: mDomainMap
.Values()) {
1685 for (const auto& activeWorker
: aData
->mActiveWorkers
) {
1686 MOZ_ASSERT(!activeWorker
->GetParent(),
1687 "Shouldn't have a parent in this list!");
1689 for (const auto& activeServiceWorker
: aData
->mActiveServiceWorkers
) {
1690 MOZ_ASSERT(!activeServiceWorker
->GetParent(),
1691 "Shouldn't have a parent in this list!");
1695 aWorkers
.AppendElements(aData
->mActiveWorkers
);
1696 aWorkers
.AppendElements(aData
->mActiveServiceWorkers
);
1698 // These might not be top-level workers...
1699 std::copy_if(aData
->mQueuedWorkers
.begin(), aData
->mQueuedWorkers
.end(),
1700 MakeBackInserter(aWorkers
),
1701 [](const auto& worker
) { return !worker
->GetParent(); });
1705 nsTArray
<WorkerPrivate
*> RuntimeService::GetWorkersForWindow(
1706 const nsPIDOMWindowInner
& aWindow
) const {
1707 AssertIsOnMainThread();
1709 nsTArray
<WorkerPrivate
*> result
;
1710 if (nsTArray
<WorkerPrivate
*>* const workers
= mWindowMap
.Get(&aWindow
)) {
1711 NS_ASSERTION(!workers
->IsEmpty(), "Should have been removed!");
1712 result
.AppendElements(*workers
);
1717 void RuntimeService::CancelWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
1718 AssertIsOnMainThread();
1720 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1721 MOZ_ASSERT(!worker
->IsSharedWorker());
1726 void RuntimeService::FreezeWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
1727 AssertIsOnMainThread();
1729 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1730 MOZ_ASSERT(!worker
->IsSharedWorker());
1731 worker
->Freeze(&aWindow
);
1735 void RuntimeService::ThawWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
1736 AssertIsOnMainThread();
1738 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1739 MOZ_ASSERT(!worker
->IsSharedWorker());
1740 worker
->Thaw(&aWindow
);
1744 void RuntimeService::SuspendWorkersForWindow(
1745 const nsPIDOMWindowInner
& aWindow
) {
1746 AssertIsOnMainThread();
1748 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1749 MOZ_ASSERT(!worker
->IsSharedWorker());
1750 worker
->ParentWindowPaused();
1754 void RuntimeService::ResumeWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
1755 AssertIsOnMainThread();
1757 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1758 MOZ_ASSERT(!worker
->IsSharedWorker());
1759 worker
->ParentWindowResumed();
1763 void RuntimeService::PropagateStorageAccessPermissionGranted(
1764 const nsPIDOMWindowInner
& aWindow
) {
1765 AssertIsOnMainThread();
1766 MOZ_ASSERT_IF(aWindow
.GetExtantDoc(), aWindow
.GetExtantDoc()
1767 ->CookieJarSettings()
1768 ->GetRejectThirdPartyContexts());
1770 for (WorkerPrivate
* const worker
: GetWorkersForWindow(aWindow
)) {
1771 worker
->PropagateStorageAccessPermissionGranted();
1775 template <typename Func
>
1776 void RuntimeService::BroadcastAllWorkers(const Func
& aFunc
) {
1777 AssertIsOnMainThread();
1779 AutoTArray
<WorkerPrivate
*, 100> workers
;
1781 MutexAutoLock
lock(mMutex
);
1783 AddAllTopLevelWorkersToArray(workers
);
1786 for (const auto& worker
: workers
) {
1791 void RuntimeService::UpdateAllWorkerContextOptions() {
1792 BroadcastAllWorkers([](auto& worker
) {
1793 worker
.UpdateContextOptions(sDefaultJSSettings
->contextOptions
);
1797 void RuntimeService::UpdateAppVersionOverridePreference(
1798 const nsAString
& aValue
) {
1799 AssertIsOnMainThread();
1800 mNavigatorProperties
.mAppVersionOverridden
= aValue
;
1803 void RuntimeService::UpdatePlatformOverridePreference(const nsAString
& aValue
) {
1804 AssertIsOnMainThread();
1805 mNavigatorProperties
.mPlatformOverridden
= aValue
;
1808 void RuntimeService::UpdateAllWorkerLanguages(
1809 const nsTArray
<nsString
>& aLanguages
) {
1810 MOZ_ASSERT(NS_IsMainThread());
1812 mNavigatorProperties
.mLanguages
= aLanguages
.Clone();
1813 BroadcastAllWorkers(
1814 [&aLanguages
](auto& worker
) { worker
.UpdateLanguages(aLanguages
); });
1817 void RuntimeService::UpdateAllWorkerMemoryParameter(JSGCParamKey aKey
,
1818 Maybe
<uint32_t> aValue
) {
1819 BroadcastAllWorkers([aKey
, aValue
](auto& worker
) {
1820 worker
.UpdateJSWorkerMemoryParameter(aKey
, aValue
);
1825 void RuntimeService::UpdateAllWorkerGCZeal() {
1826 BroadcastAllWorkers([](auto& worker
) {
1827 worker
.UpdateGCZeal(sDefaultJSSettings
->gcZeal
,
1828 sDefaultJSSettings
->gcZealFrequency
);
1833 void RuntimeService::SetLowMemoryStateAllWorkers(bool aState
) {
1834 BroadcastAllWorkers(
1835 [aState
](auto& worker
) { worker
.SetLowMemoryState(aState
); });
1838 void RuntimeService::GarbageCollectAllWorkers(bool aShrinking
) {
1839 BroadcastAllWorkers(
1840 [aShrinking
](auto& worker
) { worker
.GarbageCollect(aShrinking
); });
1843 void RuntimeService::CycleCollectAllWorkers() {
1844 BroadcastAllWorkers([](auto& worker
) { worker
.CycleCollect(); });
1847 void RuntimeService::SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline
) {
1848 BroadcastAllWorkers([aIsOffline
](auto& worker
) {
1849 worker
.OfflineStatusChangeEvent(aIsOffline
);
1853 void RuntimeService::MemoryPressureAllWorkers() {
1854 BroadcastAllWorkers([](auto& worker
) { worker
.MemoryPressure(); });
1857 uint32_t RuntimeService::ClampedHardwareConcurrency(
1858 bool aShouldResistFingerprinting
) const {
1859 // The Firefox Hardware Report says 70% of Firefox users have exactly 2 cores.
1860 // When the resistFingerprinting pref is set, we want to blend into the crowd
1861 // so spoof navigator.hardwareConcurrency = 2 to reduce user uniqueness.
1862 if (MOZ_UNLIKELY(aShouldResistFingerprinting
)) {
1866 // This needs to be atomic, because multiple workers, and even mainthread,
1867 // could race to initialize it at once.
1868 static Atomic
<uint32_t> unclampedHardwareConcurrency
;
1870 // No need to loop here: if compareExchange fails, that just means that some
1871 // other worker has initialized numberOfProcessors, so we're good to go.
1872 if (!unclampedHardwareConcurrency
) {
1873 int32_t numberOfProcessors
= 0;
1874 #if defined(XP_MACOSX)
1875 if (nsMacUtilsImpl::IsTCSMAvailable()) {
1876 // On failure, zero is returned from GetPhysicalCPUCount()
1877 // and we fallback to PR_GetNumberOfProcessors below.
1878 numberOfProcessors
= nsMacUtilsImpl::GetPhysicalCPUCount();
1881 if (numberOfProcessors
== 0) {
1882 numberOfProcessors
= PR_GetNumberOfProcessors();
1884 if (numberOfProcessors
<= 0) {
1885 numberOfProcessors
= 1; // Must be one there somewhere
1887 Unused
<< unclampedHardwareConcurrency
.compareExchange(0,
1888 numberOfProcessors
);
1891 return std::min(uint32_t(unclampedHardwareConcurrency
),
1892 StaticPrefs::dom_maxHardwareConcurrency());
1896 NS_IMPL_ISUPPORTS(RuntimeService
, nsIObserver
)
1900 RuntimeService::Observe(nsISupports
* aSubject
, const char* aTopic
,
1901 const char16_t
* aData
) {
1902 AssertIsOnMainThread();
1904 if (!strcmp(aTopic
, NS_XPCOM_SHUTDOWN_OBSERVER_ID
)) {
1908 if (!strcmp(aTopic
, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID
)) {
1912 if (!strcmp(aTopic
, GC_REQUEST_OBSERVER_TOPIC
)) {
1913 GarbageCollectAllWorkers(/* shrinking = */ false);
1916 if (!strcmp(aTopic
, CC_REQUEST_OBSERVER_TOPIC
)) {
1917 CycleCollectAllWorkers();
1920 if (!strcmp(aTopic
, MEMORY_PRESSURE_OBSERVER_TOPIC
)) {
1921 nsDependentString
data(aData
);
1922 // Don't continue to GC/CC if we are in an ongoing low-memory state since
1923 // its very slow and it likely won't help us anyway.
1924 if (data
.EqualsLiteral(LOW_MEMORY_ONGOING_DATA
)) {
1927 if (data
.EqualsLiteral(LOW_MEMORY_DATA
)) {
1928 SetLowMemoryStateAllWorkers(true);
1930 GarbageCollectAllWorkers(/* shrinking = */ true);
1931 CycleCollectAllWorkers();
1932 MemoryPressureAllWorkers();
1935 if (!strcmp(aTopic
, MEMORY_PRESSURE_STOP_OBSERVER_TOPIC
)) {
1936 SetLowMemoryStateAllWorkers(false);
1939 if (!strcmp(aTopic
, NS_IOSERVICE_OFFLINE_STATUS_TOPIC
)) {
1940 SendOfflineStatusChangeEventToAllWorkers(NS_IsOffline());
1944 MOZ_ASSERT_UNREACHABLE("Unknown observer topic!");
1949 const char* WorkerKindToString(WorkerKind kind
) {
1951 case WorkerKindDedicated
:
1953 case WorkerKindShared
:
1955 case WorkerKindService
:
1958 NS_WARNING("Unknown worker type");
1959 return "unknown worker type";
1963 void LogWorker(WorkerPrivate
* worker
, const char* category
) {
1964 AssertIsOnMainThread();
1966 SHUTDOWN_LOG(("Found %s (%s): %s", category
,
1967 WorkerKindToString(worker
->Kind()),
1968 NS_ConvertUTF16toUTF8(worker
->ScriptURL()).get()));
1970 if (worker
->Kind() == WorkerKindService
) {
1971 SHUTDOWN_LOG(("Scope: %s", worker
->ServiceWorkerScope().get()));
1975 worker
->GetPrincipal()->GetOrigin(origin
);
1976 SHUTDOWN_LOG(("Principal: %s", origin
.get()));
1978 nsCString loadingOrigin
;
1979 worker
->GetLoadingPrincipal()->GetOrigin(loadingOrigin
);
1980 SHUTDOWN_LOG(("LoadingPrincipal: %s", loadingOrigin
.get()));
1982 RefPtr
<DumpCrashInfoRunnable
> runnable
= new DumpCrashInfoRunnable(worker
);
1983 if (runnable
->DispatchAndWait()) {
1984 SHUTDOWN_LOG(("CrashInfo: %s", runnable
->MsgData().get()));
1986 SHUTDOWN_LOG(("CrashInfo: dispatch failed"));
1991 void RuntimeService::DumpRunningWorkers() {
1992 // Temporarily set the LogLevel high enough to be certain the messages are
1994 LogModule
* module
= gWorkerShutdownDumpLog
;
1995 LogLevel prevLevel
= module
->Level();
1997 const auto cleanup
=
1998 MakeScopeExit([module
, prevLevel
] { module
->SetLevel(prevLevel
); });
2000 if (prevLevel
< LogLevel::Debug
) {
2001 module
->SetLevel(LogLevel::Debug
);
2004 MutexAutoLock
lock(mMutex
);
2006 for (const auto& info
: mDomainMap
.Values()) {
2007 for (WorkerPrivate
* worker
: info
->mActiveWorkers
) {
2008 LogWorker(worker
, "ActiveWorker");
2011 for (WorkerPrivate
* worker
: info
->mActiveServiceWorkers
) {
2012 LogWorker(worker
, "ActiveServiceWorker");
2015 for (WorkerPrivate
* worker
: info
->mQueuedWorkers
) {
2016 LogWorker(worker
, "QueuedWorker");
2021 bool LogViolationDetailsRunnable::MainThreadRun() {
2022 AssertIsOnMainThread();
2024 nsIContentSecurityPolicy
* csp
= mWorkerPrivate
->GetCsp();
2026 csp
->LogViolationDetails(mViolationType
,
2027 nullptr, // triggering element
2028 mWorkerPrivate
->CSPEventListener(), mFileName
,
2029 mScriptSample
, mLineNum
, mColumnNum
, u
""_ns
,
2036 // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
2038 MOZ_CAN_RUN_SCRIPT_BOUNDARY
2040 WorkerThreadPrimaryRunnable::Run() {
2041 NS_ConvertUTF16toUTF8
url(mWorkerPrivate
->ScriptURL());
2042 AUTO_PROFILER_LABEL_DYNAMIC_CSTR("WorkerThreadPrimaryRunnable::Run", OTHER
,
2045 using mozilla::ipc::BackgroundChild
;
2048 auto failureCleanup
= MakeScopeExit([&]() {
2049 // The creation of threadHelper above is the point at which a worker is
2050 // considered to have run, because the `mPreStartRunnables` are all
2051 // re-dispatched after `mThread` is set. We need to let the WorkerPrivate
2052 // know so it can clean up the various event loops and delete the worker.
2053 mWorkerPrivate
->RunLoopNeverRan();
2056 mWorkerPrivate
->SetWorkerPrivateInWorkerThread(mThread
.unsafeGetRawPtr());
2058 const auto threadCleanup
= MakeScopeExit([&] {
2059 // This must be called before ScheduleDeletion, which is either called
2060 // from failureCleanup leaving scope, or from the outer scope.
2061 mWorkerPrivate
->ResetWorkerPrivateInWorkerThread();
2064 mWorkerPrivate
->AssertIsOnWorkerThread();
2066 // This needs to be initialized on the worker thread before being used on
2067 // the main thread and calling BackgroundChild::GetOrCreateForCurrentThread
2068 // exposes it to the main thread.
2069 mWorkerPrivate
->EnsurePerformanceStorage();
2071 if (NS_WARN_IF(!BackgroundChild::GetOrCreateForCurrentThread())) {
2072 return NS_ERROR_FAILURE
;
2075 nsWeakPtr globalScopeSentinel
;
2076 nsWeakPtr debuggerScopeSentinel
;
2077 // Never use the following pointers without checking their corresponding
2078 // nsWeakPtr sentinel, defined above and initialized after DoRunLoop ends.
2079 WorkerGlobalScopeBase
* globalScopeRawPtr
= nullptr;
2080 WorkerGlobalScopeBase
* debuggerScopeRawPtr
= nullptr;
2082 nsCycleCollector_startup();
2084 auto context
= MakeUnique
<WorkerJSContext
>(mWorkerPrivate
);
2085 nsresult rv
= context
->Initialize(mParentRuntime
);
2086 if (NS_WARN_IF(NS_FAILED(rv
))) {
2090 JSContext
* cx
= context
->Context();
2092 if (!InitJSContextForWorker(mWorkerPrivate
, cx
)) {
2093 return NS_ERROR_FAILURE
;
2096 failureCleanup
.release();
2099 PROFILER_SET_JS_CONTEXT(cx
);
2102 // We're on the worker thread here, and WorkerPrivate's refcounting is
2103 // non-threadsafe: you can only do it on the parent thread. What that
2104 // means in practice is that we're relying on it being kept alive
2105 // while we run. Hopefully.
2106 MOZ_KnownLive(mWorkerPrivate
)->DoRunLoop(cx
);
2107 // The AutoJSAPI in DoRunLoop should have reported any exceptions left
2109 MOZ_ASSERT(!JS_IsExceptionPending(cx
));
2112 mWorkerPrivate
->ShutdownModuleLoader();
2114 mWorkerPrivate
->RunShutdownTasks();
2116 BackgroundChild::CloseForCurrentThread();
2118 PROFILER_CLEAR_JS_CONTEXT();
2121 // There may still be runnables on the debugger event queue that hold a
2122 // strong reference to the debugger global scope. These runnables are not
2123 // visible to the cycle collector, so we need to make sure to clear the
2124 // debugger event queue before we try to destroy the context. If we don't,
2125 // the garbage collector will crash.
2126 // Note that this just releases the runnables and does not execute them.
2127 mWorkerPrivate
->ClearDebuggerEventQueue();
2129 // Before shutting down the cycle collector we need to do one more pass
2130 // through the event loop to clean up any C++ objects that need deferred
2132 NS_ProcessPendingEvents(nullptr);
2134 // At this point we expect the scopes to be alive if they were ever
2135 // created successfully, keep weak references and set up the sentinels.
2136 globalScopeRawPtr
= mWorkerPrivate
->GlobalScope();
2137 if (globalScopeRawPtr
) {
2138 globalScopeSentinel
= do_GetWeakReference(globalScopeRawPtr
);
2140 MOZ_ASSERT(!globalScopeRawPtr
|| globalScopeSentinel
);
2141 debuggerScopeRawPtr
= mWorkerPrivate
->DebuggerGlobalScope();
2142 if (debuggerScopeRawPtr
) {
2143 debuggerScopeSentinel
= do_GetWeakReference(debuggerScopeRawPtr
);
2145 MOZ_ASSERT(!debuggerScopeRawPtr
|| debuggerScopeSentinel
);
2147 // To our best knowledge nobody should need a reference to our globals
2148 // now (NS_ProcessPendingEvents is the last expected potential usage)
2149 // and we can unroot them.
2150 mWorkerPrivate
->UnrootGlobalScopes();
2152 // Perform a full GC until we collect the main worker global and CC,
2153 // which should break all cycles that touch JS.
2154 bool repeatGCCC
= true;
2155 while (repeatGCCC
) {
2156 JS::PrepareForFullGC(cx
);
2157 JS::NonIncrementalGC(cx
, JS::GCOptions::Shutdown
,
2158 JS::GCReason::WORKER_SHUTDOWN
);
2160 // If we CCed something or got new events as a side effect, repeat.
2161 repeatGCCC
= mWorkerPrivate
->isLastCCCollectedAnything() ||
2162 NS_HasPendingEvents(nullptr);
2163 NS_ProcessPendingEvents(nullptr);
2166 // The worker global should be unrooted and the shutdown of cycle
2167 // collection should break all the remaining cycles.
2168 nsCycleCollector_shutdown();
2170 // If ever the CC shutdown run caused side effects, process them.
2171 NS_ProcessPendingEvents(nullptr);
2173 // Now WorkerJSContext goes out of scope. Do not use any cycle
2174 // collectable objects nor JS after this point!
2177 // Check sentinels if we actually removed all global scope references.
2178 // In case use the earlier set-aside raw pointers to not mess with the
2179 // ref counting after the cycle collector has gone away.
2180 if (globalScopeSentinel
) {
2181 MOZ_ASSERT(!globalScopeSentinel
->IsAlive());
2182 if (NS_WARN_IF(globalScopeSentinel
->IsAlive())) {
2183 globalScopeRawPtr
->NoteWorkerTerminated();
2184 globalScopeRawPtr
= nullptr;
2187 if (debuggerScopeSentinel
) {
2188 MOZ_ASSERT(!debuggerScopeSentinel
->IsAlive());
2189 if (NS_WARN_IF(debuggerScopeSentinel
->IsAlive())) {
2190 debuggerScopeRawPtr
->NoteWorkerTerminated();
2191 debuggerScopeRawPtr
= nullptr;
2196 mWorkerPrivate
->ScheduleDeletion(WorkerPrivate::WorkerRan
);
2198 // It is no longer safe to touch mWorkerPrivate.
2199 mWorkerPrivate
= nullptr;
2201 // Now recycle this thread.
2202 nsCOMPtr
<nsIEventTarget
> mainTarget
= GetMainThreadSerialEventTarget();
2203 MOZ_ASSERT(mainTarget
);
2205 RefPtr
<FinishedRunnable
> finishedRunnable
=
2206 new FinishedRunnable(std::move(mThread
));
2207 MOZ_ALWAYS_SUCCEEDS(
2208 mainTarget
->Dispatch(finishedRunnable
, NS_DISPATCH_NORMAL
));
2214 WorkerThreadPrimaryRunnable::FinishedRunnable::Run() {
2215 AssertIsOnMainThread();
2217 SafeRefPtr
<WorkerThread
> thread
= std::move(mThread
);
2218 if (thread
->ShutdownRequired()) {
2219 MOZ_ALWAYS_SUCCEEDS(thread
->Shutdown());
2225 } // namespace workerinternals
2227 // This is mostly for invoking within a debugger.
2228 void DumpRunningWorkers() {
2229 RuntimeService
* runtimeService
= RuntimeService::GetService();
2230 if (runtimeService
) {
2231 runtimeService
->DumpRunningWorkers();
2233 NS_WARNING("RuntimeService not found");
2237 void CancelWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
2238 AssertIsOnMainThread();
2239 RuntimeService
* runtime
= RuntimeService::GetService();
2241 runtime
->CancelWorkersForWindow(aWindow
);
2245 void FreezeWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
2246 AssertIsOnMainThread();
2247 RuntimeService
* runtime
= RuntimeService::GetService();
2249 runtime
->FreezeWorkersForWindow(aWindow
);
2253 void ThawWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
2254 AssertIsOnMainThread();
2255 RuntimeService
* runtime
= RuntimeService::GetService();
2257 runtime
->ThawWorkersForWindow(aWindow
);
2261 void SuspendWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
2262 AssertIsOnMainThread();
2263 RuntimeService
* runtime
= RuntimeService::GetService();
2265 runtime
->SuspendWorkersForWindow(aWindow
);
2269 void ResumeWorkersForWindow(const nsPIDOMWindowInner
& aWindow
) {
2270 AssertIsOnMainThread();
2271 RuntimeService
* runtime
= RuntimeService::GetService();
2273 runtime
->ResumeWorkersForWindow(aWindow
);
2277 void PropagateStorageAccessPermissionGrantedToWorkers(
2278 const nsPIDOMWindowInner
& aWindow
) {
2279 AssertIsOnMainThread();
2280 MOZ_ASSERT_IF(aWindow
.GetExtantDoc(), aWindow
.GetExtantDoc()
2281 ->CookieJarSettings()
2282 ->GetRejectThirdPartyContexts());
2284 RuntimeService
* runtime
= RuntimeService::GetService();
2286 runtime
->PropagateStorageAccessPermissionGranted(aWindow
);
2290 WorkerPrivate
* GetWorkerPrivateFromContext(JSContext
* aCx
) {
2291 MOZ_ASSERT(!NS_IsMainThread());
2294 CycleCollectedJSContext
* ccjscx
= CycleCollectedJSContext::GetFor(aCx
);
2299 WorkerJSContext
* workerjscx
= ccjscx
->GetAsWorkerJSContext();
2300 // GetWorkerPrivateFromContext is called only for worker contexts. The
2301 // context private is cleared early in ~CycleCollectedJSContext() and so
2302 // GetFor() returns null above if called after ccjscx is no longer a
2304 MOZ_ASSERT(workerjscx
);
2305 return workerjscx
->GetWorkerPrivate();
2308 WorkerPrivate
* GetCurrentThreadWorkerPrivate() {
2309 if (NS_IsMainThread()) {
2313 CycleCollectedJSContext
* ccjscx
= CycleCollectedJSContext::Get();
2318 WorkerJSContext
* workerjscx
= ccjscx
->GetAsWorkerJSContext();
2319 // Even when GetCurrentThreadWorkerPrivate() is called on worker
2320 // threads, the ccjscx will no longer be a WorkerJSContext if called from
2321 // stable state events during ~CycleCollectedJSContext().
2326 return workerjscx
->GetWorkerPrivate();
2329 bool IsCurrentThreadRunningWorker() {
2330 return !NS_IsMainThread() && !!GetCurrentThreadWorkerPrivate();
2333 bool IsCurrentThreadRunningChromeWorker() {
2334 WorkerPrivate
* wp
= GetCurrentThreadWorkerPrivate();
2335 return wp
&& wp
->UsesSystemPrincipal();
2338 JSContext
* GetCurrentWorkerThreadJSContext() {
2339 WorkerPrivate
* wp
= GetCurrentThreadWorkerPrivate();
2343 return wp
->GetJSContext();
2346 JSObject
* GetCurrentThreadWorkerGlobal() {
2347 WorkerPrivate
* wp
= GetCurrentThreadWorkerPrivate();
2351 WorkerGlobalScope
* scope
= wp
->GlobalScope();
2355 return scope
->GetGlobalJSObject();
2358 JSObject
* GetCurrentThreadWorkerDebuggerGlobal() {
2359 WorkerPrivate
* wp
= GetCurrentThreadWorkerPrivate();
2363 WorkerDebuggerGlobalScope
* scope
= wp
->DebuggerGlobalScope();
2367 return scope
->GetGlobalJSObject();
2371 } // namespace mozilla