@ -96,6 +96,16 @@ static_assert(nsIHttpChannelInternal::CORS_MODE_CORS_WITH_FORCED_PREFLIGHT == st
static StaticRefPtr < ServiceWorkerManager > gInstance ;
// Tracks the "dom.disable_open_click_delay" preference. Modified on main
// thread, read on worker threads. This is set once in the ServiceWorkerManager
// constructor before any service workers are spawned.
// It is updated every time a "notificationclick" event is dispatched. While
// this is done without synchronization, at the worst, the thread will just get
// an older value within which a popup is allowed to be displayed, which will
// still be a valid value since it was set in the constructor. I (:nsm) don't
// think this needs to be synchronized.
Atomic < uint32_t > gDOMDisableOpenClickDelay ( 0 ) ;
struct ServiceWorkerManager : : RegistrationDataPerPrincipal
{
// Ordered list of scopes for glob matching.
@ -386,6 +396,8 @@ ServiceWorkerManager::ServiceWorkerManager()
{
// Register this component to PBackground.
MOZ_ALWAYS_TRUE ( BackgroundChild : : GetOrCreateForCurrentThread ( this ) ) ;
gDOMDisableOpenClickDelay = Preferences : : GetInt ( " dom.disable_open_click_delay " ) ;
}
ServiceWorkerManager : : ~ ServiceWorkerManager ( )
@ -531,28 +543,6 @@ private:
} ;
class ServiceWorkerUpdateFinishCallback
{
protected :
virtual ~ ServiceWorkerUpdateFinishCallback ( )
{ }
public :
NS_INLINE_DECL_REFCOUNTING ( ServiceWorkerUpdateFinishCallback )
virtual
void UpdateSucceeded ( ServiceWorkerRegistrationInfo * aInfo )
{ }
virtual
void UpdateFailed ( nsresult aStatus )
{ }
virtual
void UpdateFailed ( const ErrorEventInit & aDesc )
{ }
} ;
class ServiceWorkerResolveWindowPromiseOnUpdateCallback final : public ServiceWorkerUpdateFinishCallback
{
nsRefPtr < nsPIDOMWindow > mWindow ;
@ -586,7 +576,7 @@ public:
}
void
UpdateFailed ( const ErrorEventInit & aErrorDesc ) override
UpdateFailed ( JSExnType aExnType , const ErrorEventInit & aErrorDesc ) override
{
AutoJSAPI jsapi ;
jsapi . Init ( mWindow ) ;
@ -610,7 +600,8 @@ public:
JS : : Rooted < JSString * > msg ( cx , msgval . toString ( ) ) ;
JS : : Rooted < JS : : Value > error ( cx ) ;
if ( ! JS : : CreateError ( cx , JSEXN_ERR , nullptr , fn , aErrorDesc . mLineno ,
if ( ( aExnType < JSEXN_ERR ) | |
! JS : : CreateError ( cx , aExnType , nullptr , fn , aErrorDesc . mLineno ,
aErrorDesc . mColno , nullptr , msg , & error ) ) {
JS_ClearPendingException ( cx ) ;
mPromise - > MaybeReject ( NS_ERROR_DOM_ABORT_ERR ) ;
@ -989,13 +980,17 @@ public:
const nsACString & aMaxScope ) override
{
nsRefPtr < ServiceWorkerRegisterJob > kungFuDeathGrip = this ;
if ( mCanceled ) {
if ( NS_WARN_IF ( mCanceled ) ) {
Fail ( NS_ERROR_DOM_TYPE_ERR ) ;
return ;
}
if ( NS_WARN_IF ( NS_FAILED ( aStatus ) ) ) {
Fail ( NS_ERROR_DOM_TYPE_ERR ) ;
if ( aStatus = = NS_ERROR_DOM_SECURITY_ERR ) {
Fail ( aStatus ) ;
} else {
Fail ( NS_ERROR_DOM_TYPE_ERR ) ;
}
return ;
}
@ -1115,7 +1110,7 @@ public:
// Public so our error handling code can use it.
// Callers MUST hold a strong ref before calling this!
void
Fail ( const ErrorEventInit & aError )
Fail ( JSExnType aExnType , const ErrorEventInit & aError )
{
MOZ_ASSERT ( mCallback ) ;
nsRefPtr < ServiceWorkerUpdateFinishCallback > callback = mCallback . forget ( ) ;
@ -1125,7 +1120,7 @@ public:
// FailCommon relies on it.
// FailCommon does check for cancellation, but let's be safe here.
nsRefPtr < ServiceWorkerRegisterJob > kungFuDeathGrip = this ;
callback - > UpdateFailed ( aError ) ;
callback - > UpdateFailed ( aExnType , aE rror ) ;
FailCommon ( NS_ERROR_DOM_JS_EXCEPTION ) ;
}
@ -1617,10 +1612,11 @@ ServiceWorkerManager::AppendPendingOperation(nsIRunnable* aRunnable)
namespace {
// Just holds a ref to a ServiceWorker until the Promise is fulfilled.
class KeepAliveHandler final : public PromiseNativeHandler
class KeepAliveHandler : public PromiseNativeHandler
{
nsMainThreadPtrHandle < ServiceWorker > mServiceWorker ;
protected :
virtual ~ KeepAliveHandler ( )
{ }
@ -1654,6 +1650,150 @@ public:
NS_IMPL_ISUPPORTS0 ( KeepAliveHandler )
void
DummyCallback ( nsITimer * aTimer , void * aClosure )
{
// Nothing.
}
class AllowWindowInteractionKeepAliveHandler ;
class ClearWindowAllowedRunnable final : public WorkerRunnable
{
public :
ClearWindowAllowedRunnable ( WorkerPrivate * aWorkerPrivate ,
AllowWindowInteractionKeepAliveHandler * aHandler )
: WorkerRunnable ( aWorkerPrivate , WorkerThreadUnchangedBusyCount )
, mHandler ( aHandler )
{ }
private :
bool
PreDispatch ( JSContext * aCx , WorkerPrivate * aWorkerPrivate ) override
{
// WorkerRunnable asserts that the dispatch is from parent thread if
// the busy count modification is WorkerThreadUnchangedBusyCount.
// Since this runnable will be dispatched from the timer thread, we override
// PreDispatch and PostDispatch to skip the check.
return true ;
}
void
PostDispatch ( JSContext * aCx , WorkerPrivate * aWorkerPrivate ,
bool aDispatchResult ) override
{
// Silence bad assertions.
}
bool
WorkerRun ( JSContext * aCx , WorkerPrivate * aWorkerPrivate ) override ;
nsRefPtr < AllowWindowInteractionKeepAliveHandler > mHandler ;
} ;
class AllowWindowInteractionKeepAliveHandler final : public KeepAliveHandler
{
friend class ClearWindowAllowedRunnable ;
nsCOMPtr < nsITimer > mTimer ;
~ AllowWindowInteractionKeepAliveHandler ( )
{
MOZ_ASSERT ( ! mTimer ) ;
}
void
ClearWindowAllowed ( WorkerPrivate * aWorkerPrivate )
{
MOZ_ASSERT ( aWorkerPrivate ) ;
aWorkerPrivate - > AssertIsOnWorkerThread ( ) ;
if ( mTimer ) {
aWorkerPrivate - > GlobalScope ( ) - > ConsumeWindowInteraction ( ) ;
mTimer - > Cancel ( ) ;
mTimer = nullptr ;
MOZ_ALWAYS_TRUE ( aWorkerPrivate - > ModifyBusyCountFromWorker ( aWorkerPrivate - > GetJSContext ( ) , false ) ) ;
}
}
void
StartClearWindowTimer ( WorkerPrivate * aWorkerPrivate )
{
MOZ_ASSERT ( aWorkerPrivate ) ;
aWorkerPrivate - > AssertIsOnWorkerThread ( ) ;
MOZ_ASSERT ( ! mTimer ) ;
nsresult rv ;
nsCOMPtr < nsITimer > timer = do_CreateInstance ( NS_TIMER_CONTRACTID , & rv ) ;
if ( NS_WARN_IF ( NS_FAILED ( rv ) ) ) {
return ;
}
nsRefPtr < ClearWindowAllowedRunnable > r =
new ClearWindowAllowedRunnable ( aWorkerPrivate , this ) ;
nsRefPtr < TimerThreadEventTarget > target =
new TimerThreadEventTarget ( aWorkerPrivate , r ) ;
rv = timer - > SetTarget ( target ) ;
if ( NS_WARN_IF ( NS_FAILED ( rv ) ) ) {
return ;
}
// The important stuff that *has* to be reversed.
if ( NS_WARN_IF ( ! aWorkerPrivate - > ModifyBusyCountFromWorker ( aWorkerPrivate - > GetJSContext ( ) , true ) ) ) {
return ;
}
aWorkerPrivate - > GlobalScope ( ) - > AllowWindowInteraction ( ) ;
timer . swap ( mTimer ) ;
// We swap first and then initialize the timer so that even if initializing
// fails, we still clean the busy count and interaction count correctly.
// The timer can't be initialized before modifying the busy count since the
// timer thread could run and call the timeout but the worker may
// already be terminating and modifying the busy count could fail.
rv = mTimer - > InitWithFuncCallback ( DummyCallback , nullptr , gDOMDisableOpenClickDelay , nsITimer : : TYPE_ONE_SHOT ) ;
if ( NS_WARN_IF ( NS_FAILED ( rv ) ) ) {
ClearWindowAllowed ( aWorkerPrivate ) ;
return ;
}
}
public :
NS_DECL_ISUPPORTS_INHERITED
AllowWindowInteractionKeepAliveHandler ( const nsMainThreadPtrHandle < ServiceWorker > & aServiceWorker ,
WorkerPrivate * aWorkerPrivate )
: KeepAliveHandler ( aServiceWorker )
{
StartClearWindowTimer ( aWorkerPrivate ) ;
}
void
ResolvedCallback ( JSContext * aCx , JS : : Handle < JS : : Value > aValue ) override
{
WorkerPrivate * worker = GetWorkerPrivateFromContext ( aCx ) ;
ClearWindowAllowed ( worker ) ;
KeepAliveHandler : : ResolvedCallback ( aCx , aValue ) ;
}
void
RejectedCallback ( JSContext * aCx , JS : : Handle < JS : : Value > aValue ) override
{
WorkerPrivate * worker = GetWorkerPrivateFromContext ( aCx ) ;
ClearWindowAllowed ( worker ) ;
KeepAliveHandler : : RejectedCallback ( aCx , aValue ) ;
}
} ;
NS_IMPL_ISUPPORTS_INHERITED0 ( AllowWindowInteractionKeepAliveHandler , KeepAliveHandler )
bool
ClearWindowAllowedRunnable : : WorkerRun ( JSContext * aCx , WorkerPrivate * aWorkerPrivate )
{
mHandler - > ClearWindowAllowed ( aWorkerPrivate ) ;
return true ;
}
// Returns a Promise if the event was successfully dispatched and no exceptions
// were raised, otherwise returns null.
already_AddRefed < Promise >
@ -2376,12 +2516,17 @@ public:
return false ;
}
aWorkerPrivate - > GlobalScope ( ) - > AllowWindowInteraction ( ) ;
event - > SetTrusted ( true ) ;
nsRefPtr < Promise > waitUntilPromise =
DispatchExtendableEventOnWorkerScope ( aCx , aWorkerPrivate - > GlobalScope ( ) , event ) ;
// If the handler calls WaitUntil(), that will manage its own interaction
// 'stack'.
aWorkerPrivate - > GlobalScope ( ) - > ConsumeWindowInteraction ( ) ;
if ( waitUntilPromise ) {
nsRefPtr < KeepAliveHandler > handler = new KeepAliveHandler ( mServiceWorker ) ;
nsRefPtr < AllowWindowInteractionKeepAliveHandler > handler =
new AllowWindowInteractionKeepAliveHandler ( mServiceWorker , aWorkerPrivate ) ;
waitUntilPromise - > AppendNativeHandler ( handler ) ;
}
@ -2407,6 +2552,8 @@ ServiceWorkerManager::SendNotificationClickEvent(const nsACString& aOriginSuffix
return NS_ERROR_INVALID_ARG ;
}
gDOMDisableOpenClickDelay = Preferences : : GetInt ( " dom.disable_open_click_delay " ) ;
nsRefPtr < ServiceWorker > serviceWorker =
CreateServiceWorkerForScope ( attrs , aScope , nullptr ) ;
if ( ! serviceWorker ) {
@ -2785,10 +2932,12 @@ ServiceWorkerManager::HandleError(JSContext* aCx,
nsString aLine ,
uint32_t aLineNumber ,
uint32_t aColumnNumber ,
uint32_t aFlags )
uint32_t aFlags ,
JSExnType aExnType )
{
AssertIsOnMainThread ( ) ;
MOZ_ASSERT ( aPrincipal ) ;
MOZ_ASSERT ( ! JSREPORT_IS_WARNING ( aFlags ) ) ;
nsAutoCString scopeKey ;
nsresult rv = PrincipalToScopeKey ( aPrincipal , scopeKey ) ;
@ -2824,7 +2973,7 @@ ServiceWorkerManager::HandleError(JSContext* aCx,
" Script error caused ServiceWorker registration to fail: %s:%u '%s' " ,
NS_ConvertUTF16toUTF8 ( aFilename ) . get ( ) , aLineNumber ,
NS_ConvertUTF16toUTF8 ( aMessage ) . get ( ) ) . get ( ) ) ;
regJob - > Fail ( init ) ;
regJob - > Fail ( aExnType , init ) ;
}
return true ;
@ -4006,7 +4155,8 @@ ServiceWorkerManager::InvalidateServiceWorkerRegistrationWorker(ServiceWorkerReg
void
ServiceWorkerManager : : SoftUpdate ( nsIPrincipal * aPrincipal ,
const nsACString & aScope )
const nsACString & aScope ,
ServiceWorkerUpdateFinishCallback * aCallback )
{
MOZ_ASSERT ( aPrincipal ) ;
@ -4016,21 +4166,23 @@ ServiceWorkerManager::SoftUpdate(nsIPrincipal* aPrincipal,
return ;
}
SoftUpdate ( scopeKey , aScope ) ;
SoftUpdate ( scopeKey , aScope , aCallback ) ;
}
void
ServiceWorkerManager : : SoftUpdate ( const OriginAttributes & aOriginAttributes ,
const nsACString & aScope )
const nsACString & aScope ,
ServiceWorkerUpdateFinishCallback * aCallback )
{
nsAutoCString scopeKey ;
aOriginAttributes . CreateSuffix ( scopeKey ) ;
SoftUpdate ( scopeKey , aScope ) ;
SoftUpdate ( scopeKey , aScope , aCallback ) ;
}
void
ServiceWorkerManager : : SoftUpdate ( const nsACString & aScopeKey ,
const nsACString & aScope )
const nsACString & aScope ,
ServiceWorkerUpdateFinishCallback * aCallback )
{
nsRefPtr < ServiceWorkerRegistrationInfo > registration =
GetRegistration ( aScopeKey , aScope ) ;
@ -4063,8 +4215,10 @@ ServiceWorkerManager::SoftUpdate(const nsACString& aScopeKey,
GetOrCreateJobQueue ( aScopeKey , aScope ) ;
MOZ_ASSERT ( queue ) ;
nsRefPtr < ServiceWorkerUpdateFinishCallback > cb =
new ServiceWorkerUpdateFinishCallback ( ) ;
nsRefPtr < ServiceWorkerUpdateFinishCallback > cb ( aCallback ) ;
if ( ! cb ) {
cb = new ServiceWorkerUpdateFinishCallback ( ) ;
}
// "Invoke Update algorithm, or its equivalent, with client, registration as
// its argument."
