| ChromeWorker.cpp |
static |
3086 |
| ChromeWorker.h |
unused |
1137 |
| ChromeWorkerScope.cpp |
|
1887 |
| ChromeWorkerScope.h |
|
646 |
| JSExecutionManager.cpp |
|
7197 |
| JSExecutionManager.h |
|
6963 |
| JSSettings.h |
|
1819 |
| loader |
|
|
| MessageEventRunnable.cpp |
|
5494 |
| MessageEventRunnable.h |
|
1257 |
| moz.build |
|
2388 |
| nsIWorkerDebugger.idl |
|
2142 |
| nsIWorkerDebuggerManager.idl |
|
627 |
| Queue.h |
mozilla_dom_workerinternals_Queue_h |
3754 |
| RegisterBindings.cpp |
|
1673 |
| remoteworkers |
|
|
| RuntimeService.cpp |
|
76349 |
| RuntimeService.h |
|
5438 |
| ScriptLoader.cpp |
|
64168 |
| ScriptLoader.h |
|
13621 |
| sharedworkers |
|
|
| test |
|
|
| Worker.cpp |
static |
7410 |
| Worker.h |
mozilla_dom_Worker_h |
2206 |
| WorkerCommon.h |
|
1589 |
| WorkerCSPEventListener.cpp |
static |
3070 |
| WorkerCSPEventListener.h |
|
1100 |
| WorkerDebugger.cpp |
|
17515 |
| WorkerDebugger.h |
Sends back a PerformanceInfo struct from the counters
in mWorkerPrivate. Counters are reset to zero after this call.
|
1924 |
| WorkerDebuggerManager.cpp |
anonymous namespace |
9492 |
| WorkerDebuggerManager.h |
|
3251 |
| WorkerDocumentListener.cpp |
|
3493 |
| WorkerDocumentListener.h |
mozilla_dom_WorkerDocumentListener_h__ |
1153 |
| WorkerError.cpp |
isErrorEvent |
16850 |
| WorkerError.h |
|
2428 |
| WorkerEventTarget.cpp |
|
4675 |
| WorkerEventTarget.h |
|
1619 |
| WorkerIPCUtils.h |
|
879 |
| WorkerLoadInfo.cpp |
|
17518 |
| WorkerLoadInfo.h |
|
6238 |
| WorkerLocation.cpp |
static |
1419 |
| WorkerLocation.h |
|
2491 |
| WorkerNavigator.cpp |
static |
8521 |
| WorkerNavigator.h |
unused |
3633 |
| WorkerPrivate.cpp |
|
189821 |
| WorkerPrivate.h |
|
54393 |
| WorkerRef.cpp |
static |
6616 |
| WorkerRef.h |
If you want to play with a DOM Worker, you must know that it can go away
at any time if nothing prevents its shutting down. This documentation helps
to understand how to play with DOM Workers correctly.
There are several reasons why a DOM Worker could go away. Here is the
complete list:
a. GC/CC - If the DOM Worker thread is idle and the Worker object is garbage
collected, it goes away.
b. The worker script can call self.close()
c. The Worker object calls worker.terminate()
d. Firefox is shutting down.
When a DOM Worker goes away, it does several steps. See more in
WorkerStatus.h. The DOM Worker thread will basically stop scheduling
WorkerRunnables, and eventually WorkerControlRunnables. But if there is
something preventing the shutting down, it will always possible to dispatch
WorkerControlRunnables. Of course, at some point, the worker _must_ be
released, otherwise firefox will leak it and the browser shutdown will hang.
WeakWorkerRef is a refcounted, NON thread-safe object.
From this object, you can obtain a WorkerPrivate, calling
WeakWorkerRef::GetPrivate(). It returns nullptr if the worker is shutting
down or if it is already gone away.
If you want to know when a DOM Worker starts the shutting down procedure,
pass a callback to the mozilla::dom::WeakWorkerRef::Create() method.
Your function will be called. Note that _after_ the callback,
WeakWorkerRef::GetPrivate() will return nullptr.
How to keep a DOM Worker alive?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you need to keep the worker alive, you must use StrongWorkerRef.
You can have this refcounted, NON thread-safe object, calling
mozilla::dom::StrongWorkerRef::Create(WorkerPrivate* aWorkerPrivate);
If you have a StrongWorkerRef:
a. the DOM Worker is kept alive.
b. you can have access to the WorkerPrivate, calling: Private().
c. WorkerControlRunnable can be dispatched.
Note that the DOM Worker shutdown can start at any time, but having a
StrongWorkerRef prevents the full shutdown. Also with StrongWorkerRef, you
can pass a callback when calling mozilla::dom::StrongWorkerRef::Create().
When the DOM Worker shutdown starts, WorkerRunnable cannot be dispatched
anymore. At this point, you should dispatch WorkerControlRunnable just to
release resources.
How to have a thread-safe DOM Worker reference?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sometimes you need to play with threads and you need a thread-safe worker
reference. ThreadSafeWorkerRef is what you want.
Just because this object can be sent to different threads, we don't allow the
setting of a callback. It would be confusing.
ThreadSafeWorkerRef can be destroyed in any thread. Internally it keeps a
reference to its StrongWorkerRef creator and this ref will be dropped on the
correct thread when the ThreadSafeWorkerRef is deleted.
IPC WorkerRef
~~~~~~~~~~~~~
IPDL protocols require a correct shutdown sequence. Because of this, they
need a special configuration:
1. they need to be informed when the Worker starts the shutting down
2. they don't want to prevent the shutdown
3. but at the same time, they need to block the shutdown until the WorkerRef
is not longer alive.
Point 1 is a standard feature of WorkerRef; point 2 is similar to
WeakWorkerRef; point 3 is similar to StrongWorkerRef.
You can create a special IPC WorkerRef using this static method:
mozilla::dom::IPCWorkerRef::Create(WorkerPrivate* aWorkerPrivate,
const char* * aName);
|
8084 |
| WorkerRunnable.cpp |
|
24107 |
| WorkerRunnable.h |
|
19622 |
| WorkerScope.cpp |
|
46950 |
| WorkerScope.h |
|
17569 |
| WorkerStatus.h |
Use this chart to help figure out behavior during each of the closing
statuses. Details below.
+========================================================+
| Closing Statuses |
+=============+=============+=================+==========+
| status | clear queue | abort execution | notified |
+=============+=============+=================+==========+
| Closing | yes | no | no |
+-------------+-------------+-----------------+----------+
| Canceling | yes | yes | yes |
+-------------+-------------+-----------------+----------+
| Killing | yes | yes | yes |
+-------------+-------------+-----------------+----------+
|
2185 |
| WorkerTestUtils.cpp |
|
814 |
| WorkerTestUtils.h |
dom/webidl/WorkerTestUtils.webidl defines APIs to expose worker's internal
status for glass-box testing. The APIs are only exposed to Workers with prefs
dom.workers.testing.enabled.
WorkerTestUtils is the implementation of dom/webidl/WorkerTestUtils.webidl
|
1333 |
| WorkerThread.cpp |
aKey |
10779 |
| WorkerThread.h |
|
3239 |