diff options
Diffstat (limited to 'dom/workers')
730 files changed, 66297 insertions, 0 deletions
diff --git a/dom/workers/ChromeWorkerScope.cpp b/dom/workers/ChromeWorkerScope.cpp new file mode 100644 index 000000000..68ebebfc3 --- /dev/null +++ b/dom/workers/ChromeWorkerScope.cpp @@ -0,0 +1,74 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ChromeWorkerScope.h" + +#include "jsapi.h" + +#include "nsXPCOM.h" +#include "nsNativeCharsetUtils.h" +#include "nsString.h" + +#include "WorkerPrivate.h" + +using namespace mozilla::dom; +USING_WORKERS_NAMESPACE + +namespace { + +#ifdef BUILD_CTYPES + +char* +UnicodeToNative(JSContext* aCx, const char16_t* aSource, size_t aSourceLen) +{ + nsDependentString unicode(aSource, aSourceLen); + + nsAutoCString native; + if (NS_FAILED(NS_CopyUnicodeToNative(unicode, native))) { + JS_ReportErrorASCII(aCx, "Could not convert string to native charset!"); + return nullptr; + } + + char* result = static_cast<char*>(JS_malloc(aCx, native.Length() + 1)); + if (!result) { + return nullptr; + } + + memcpy(result, native.get(), native.Length()); + result[native.Length()] = 0; + return result; +} + +#endif // BUILD_CTYPES + +} // namespace + +BEGIN_WORKERS_NAMESPACE + +bool +DefineChromeWorkerFunctions(JSContext* aCx, JS::Handle<JSObject*> aGlobal) +{ + // Currently ctypes is the only special property given to ChromeWorkers. +#ifdef BUILD_CTYPES + { + JS::Rooted<JS::Value> ctypes(aCx); + if (!JS_InitCTypesClass(aCx, aGlobal) || + !JS_GetProperty(aCx, aGlobal, "ctypes", &ctypes)) { + return false; + } + + static const JSCTypesCallbacks callbacks = { + UnicodeToNative + }; + + JS_SetCTypesCallbacks(ctypes.toObjectOrNull(), &callbacks); + } +#endif // BUILD_CTYPES + + return true; +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ChromeWorkerScope.h b/dom/workers/ChromeWorkerScope.h new file mode 100644 index 000000000..306397b66 --- /dev/null +++ b/dom/workers/ChromeWorkerScope.h @@ -0,0 +1,19 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_chromeworkerscope_h__ +#define mozilla_dom_workers_chromeworkerscope_h__ + +#include "Workers.h" + +BEGIN_WORKERS_NAMESPACE + +bool +DefineChromeWorkerFunctions(JSContext* aCx, JS::Handle<JSObject*> aGlobal); + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_chromeworkerscope_h__ diff --git a/dom/workers/FileReaderSync.cpp b/dom/workers/FileReaderSync.cpp new file mode 100644 index 000000000..18efcb194 --- /dev/null +++ b/dom/workers/FileReaderSync.cpp @@ -0,0 +1,264 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "FileReaderSync.h" + +#include "jsfriendapi.h" +#include "mozilla/Unused.h" +#include "mozilla/Base64.h" +#include "mozilla/dom/EncodingUtils.h" +#include "mozilla/dom/File.h" +#include "nsContentUtils.h" +#include "mozilla/dom/FileReaderSyncBinding.h" +#include "nsCExternalHandlerService.h" +#include "nsComponentManagerUtils.h" +#include "nsCOMPtr.h" +#include "nsDOMClassInfoID.h" +#include "nsError.h" +#include "nsIConverterInputStream.h" +#include "nsIInputStream.h" +#include "nsISeekableStream.h" +#include "nsISupportsImpl.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" + +#include "RuntimeService.h" + +using namespace mozilla; +using namespace mozilla::dom; +using mozilla::dom::Optional; +using mozilla::dom::GlobalObject; + +// static +already_AddRefed<FileReaderSync> +FileReaderSync::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv) +{ + RefPtr<FileReaderSync> frs = new FileReaderSync(); + + return frs.forget(); +} + +bool +FileReaderSync::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto, + JS::MutableHandle<JSObject*> aReflector) +{ + return FileReaderSyncBinding::Wrap(aCx, this, aGivenProto, aReflector); +} + +void +FileReaderSync::ReadAsArrayBuffer(JSContext* aCx, + JS::Handle<JSObject*> aScopeObj, + Blob& aBlob, + JS::MutableHandle<JSObject*> aRetval, + ErrorResult& aRv) +{ + uint64_t blobSize = aBlob.GetSize(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + UniquePtr<char[], JS::FreePolicy> bufferData(js_pod_malloc<char>(blobSize)); + if (!bufferData) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + nsCOMPtr<nsIInputStream> stream; + aBlob.GetInternalStream(getter_AddRefs(stream), aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + uint32_t numRead; + aRv = stream->Read(bufferData.get(), blobSize, &numRead); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + NS_ASSERTION(numRead == blobSize, "failed to read data"); + + JSObject* arrayBuffer = JS_NewArrayBufferWithContents(aCx, blobSize, bufferData.get()); + if (!arrayBuffer) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + // arrayBuffer takes the ownership when it is not null. Otherwise we + // need to release it explicitly. + mozilla::Unused << bufferData.release(); + + aRetval.set(arrayBuffer); +} + +void +FileReaderSync::ReadAsBinaryString(Blob& aBlob, + nsAString& aResult, + ErrorResult& aRv) +{ + nsCOMPtr<nsIInputStream> stream; + aBlob.GetInternalStream(getter_AddRefs(stream), aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + uint32_t numRead; + do { + char readBuf[4096]; + aRv = stream->Read(readBuf, sizeof(readBuf), &numRead); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + uint32_t oldLength = aResult.Length(); + AppendASCIItoUTF16(Substring(readBuf, readBuf + numRead), aResult); + if (aResult.Length() - oldLength != numRead) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + } while (numRead > 0); +} + +void +FileReaderSync::ReadAsText(Blob& aBlob, + const Optional<nsAString>& aEncoding, + nsAString& aResult, + ErrorResult& aRv) +{ + nsCOMPtr<nsIInputStream> stream; + aBlob.GetInternalStream(getter_AddRefs(stream), aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + nsAutoCString encoding; + unsigned char sniffBuf[3] = { 0, 0, 0 }; + uint32_t numRead; + aRv = stream->Read(reinterpret_cast<char*>(sniffBuf), + sizeof(sniffBuf), &numRead); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + // The BOM sniffing is baked into the "decode" part of the Encoding + // Standard, which the File API references. + if (!nsContentUtils::CheckForBOM(sniffBuf, numRead, encoding)) { + // BOM sniffing failed. Try the API argument. + if (!aEncoding.WasPassed() || + !EncodingUtils::FindEncodingForLabel(aEncoding.Value(), + encoding)) { + // API argument failed. Try the type property of the blob. + nsAutoString type16; + aBlob.GetType(type16); + NS_ConvertUTF16toUTF8 type(type16); + nsAutoCString specifiedCharset; + bool haveCharset; + int32_t charsetStart, charsetEnd; + NS_ExtractCharsetFromContentType(type, + specifiedCharset, + &haveCharset, + &charsetStart, + &charsetEnd); + if (!EncodingUtils::FindEncodingForLabel(specifiedCharset, encoding)) { + // Type property failed. Use UTF-8. + encoding.AssignLiteral("UTF-8"); + } + } + } + + nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(stream); + if (!seekable) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + // Seek to 0 because to undo the BOM sniffing advance. UTF-8 and UTF-16 + // decoders will swallow the BOM. + aRv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + aRv = ConvertStream(stream, encoding.get(), aResult); + if (NS_WARN_IF(aRv.Failed())) { + return; + } +} + +void +FileReaderSync::ReadAsDataURL(Blob& aBlob, nsAString& aResult, + ErrorResult& aRv) +{ + nsAutoString scratchResult; + scratchResult.AssignLiteral("data:"); + + nsString contentType; + aBlob.GetType(contentType); + + if (contentType.IsEmpty()) { + scratchResult.AppendLiteral("application/octet-stream"); + } else { + scratchResult.Append(contentType); + } + scratchResult.AppendLiteral(";base64,"); + + nsCOMPtr<nsIInputStream> stream; + aBlob.GetInternalStream(getter_AddRefs(stream), aRv); + if (NS_WARN_IF(aRv.Failed())){ + return; + } + + uint64_t size = aBlob.GetSize(aRv); + if (NS_WARN_IF(aRv.Failed())){ + return; + } + + nsCOMPtr<nsIInputStream> bufferedStream; + aRv = NS_NewBufferedInputStream(getter_AddRefs(bufferedStream), stream, size); + if (NS_WARN_IF(aRv.Failed())){ + return; + } + + nsAutoString encodedData; + aRv = Base64EncodeInputStream(bufferedStream, encodedData, size); + if (NS_WARN_IF(aRv.Failed())){ + return; + } + + scratchResult.Append(encodedData); + + aResult = scratchResult; +} + +nsresult +FileReaderSync::ConvertStream(nsIInputStream *aStream, + const char *aCharset, + nsAString &aResult) +{ + nsCOMPtr<nsIConverterInputStream> converterStream = + do_CreateInstance("@mozilla.org/intl/converter-input-stream;1"); + NS_ENSURE_TRUE(converterStream, NS_ERROR_FAILURE); + + nsresult rv = converterStream->Init(aStream, aCharset, 8192, + nsIConverterInputStream::DEFAULT_REPLACEMENT_CHARACTER); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIUnicharInputStream> unicharStream = + do_QueryInterface(converterStream); + NS_ENSURE_TRUE(unicharStream, NS_ERROR_FAILURE); + + uint32_t numChars; + nsString result; + while (NS_SUCCEEDED(unicharStream->ReadString(8192, result, &numChars)) && + numChars > 0) { + uint32_t oldLength = aResult.Length(); + aResult.Append(result); + if (aResult.Length() - oldLength != result.Length()) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + + return rv; +} + diff --git a/dom/workers/FileReaderSync.h b/dom/workers/FileReaderSync.h new file mode 100644 index 000000000..db8f9d574 --- /dev/null +++ b/dom/workers/FileReaderSync.h @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_filereadersync_h__ +#define mozilla_dom_filereadersync_h__ + +#include "Workers.h" + +class nsIInputStream; + +namespace mozilla { +class ErrorResult; + +namespace dom { +class Blob; +class GlobalObject; +template<typename> class Optional; + +class FileReaderSync final +{ + NS_INLINE_DECL_REFCOUNTING(FileReaderSync) + +private: + // Private destructor, to discourage deletion outside of Release(): + ~FileReaderSync() + { + } + + nsresult ConvertStream(nsIInputStream *aStream, const char *aCharset, + nsAString &aResult); + +public: + static already_AddRefed<FileReaderSync> + Constructor(const GlobalObject& aGlobal, ErrorResult& aRv); + + bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector); + + void ReadAsArrayBuffer(JSContext* aCx, JS::Handle<JSObject*> aScopeObj, + Blob& aBlob, JS::MutableHandle<JSObject*> aRetval, + ErrorResult& aRv); + void ReadAsBinaryString(Blob& aBlob, nsAString& aResult, ErrorResult& aRv); + void ReadAsText(Blob& aBlob, const Optional<nsAString>& aEncoding, + nsAString& aResult, ErrorResult& aRv); + void ReadAsDataURL(Blob& aBlob, nsAString& aResult, ErrorResult& aRv); +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_filereadersync_h__ diff --git a/dom/workers/PServiceWorkerManager.ipdl b/dom/workers/PServiceWorkerManager.ipdl new file mode 100644 index 000000000..e7b97672d --- /dev/null +++ b/dom/workers/PServiceWorkerManager.ipdl @@ -0,0 +1,45 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +include protocol PBackground; + +include PBackgroundSharedTypes; +include ServiceWorkerRegistrarTypes; + +using mozilla::PrincipalOriginAttributes from "mozilla/ipc/BackgroundUtils.h"; + +namespace mozilla { +namespace dom { + +protocol PServiceWorkerManager +{ + manager PBackground; + +parent: + async Register(ServiceWorkerRegistrationData data); + + async Unregister(PrincipalInfo principalInfo, nsString scope); + + async PropagateSoftUpdate(PrincipalOriginAttributes originAttributes, + nsString scope); + async PropagateUnregister(PrincipalInfo principalInfo, nsString scope); + + async PropagateRemove(nsCString host); + + async PropagateRemoveAll(); + + async Shutdown(); + +child: + async NotifyRegister(ServiceWorkerRegistrationData data); + async NotifySoftUpdate(PrincipalOriginAttributes originAttributes, nsString scope); + async NotifyUnregister(PrincipalInfo principalInfo, nsString scope); + async NotifyRemove(nsCString host); + async NotifyRemoveAll(); + + async __delete__(); +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/Principal.cpp b/dom/workers/Principal.cpp new file mode 100644 index 000000000..8fcd9ed10 --- /dev/null +++ b/dom/workers/Principal.cpp @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "Principal.h" + +#include "jsapi.h" +#include "mozilla/Assertions.h" + +BEGIN_WORKERS_NAMESPACE + +struct WorkerPrincipal final : public JSPrincipals +{ + bool write(JSContext* aCx, JSStructuredCloneWriter* aWriter) override { + MOZ_CRASH("WorkerPrincipal::write not implemented"); + return false; + } +}; + +JSPrincipals* +GetWorkerPrincipal() +{ + static WorkerPrincipal sPrincipal; + + /* + * To make sure the the principals refcount is initialized to one, atomically + * increment it on every pass though this function. If we discover this wasn't + * the first time, decrement it again. This avoids the need for + * synchronization. + */ + int32_t prevRefcount = sPrincipal.refcount++; + if (prevRefcount > 0) { + --sPrincipal.refcount; + } else { +#ifdef DEBUG + sPrincipal.debugToken = kJSPrincipalsDebugToken; +#endif + } + + return &sPrincipal; +} + +void +DestroyWorkerPrincipals(JSPrincipals* aPrincipals) +{ + MOZ_ASSERT_UNREACHABLE("Worker principals refcount should never fall below one"); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/Principal.h b/dom/workers/Principal.h new file mode 100644 index 000000000..5bfe19443 --- /dev/null +++ b/dom/workers/Principal.h @@ -0,0 +1,22 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_principal_h__ +#define mozilla_dom_workers_principal_h__ + +#include "Workers.h" + +BEGIN_WORKERS_NAMESPACE + +JSPrincipals* +GetWorkerPrincipal(); + +void +DestroyWorkerPrincipals(JSPrincipals* aPrincipals); + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_principal_h__ */ diff --git a/dom/workers/Queue.h b/dom/workers/Queue.h new file mode 100644 index 000000000..c7a99158b --- /dev/null +++ b/dom/workers/Queue.h @@ -0,0 +1,203 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_queue_h__ +#define mozilla_dom_workers_queue_h__ + +#include "Workers.h" + +#include "mozilla/Mutex.h" +#include "nsTArray.h" + +BEGIN_WORKERS_NAMESPACE + +template <typename T, int TCount> +struct StorageWithTArray +{ + typedef AutoTArray<T, TCount> StorageType; + + static void Reverse(StorageType& aStorage) + { + uint32_t length = aStorage.Length(); + for (uint32_t index = 0; index < length / 2; index++) { + uint32_t reverseIndex = length - 1 - index; + + T t1 = aStorage.ElementAt(index); + T t2 = aStorage.ElementAt(reverseIndex); + + aStorage.ReplaceElementsAt(index, 1, t2); + aStorage.ReplaceElementsAt(reverseIndex, 1, t1); + } + } + + static bool IsEmpty(const StorageType& aStorage) + { + return !!aStorage.IsEmpty(); + } + + static bool Push(StorageType& aStorage, const T& aEntry) + { + return !!aStorage.AppendElement(aEntry); + } + + static bool Pop(StorageType& aStorage, T& aEntry) + { + if (IsEmpty(aStorage)) { + return false; + } + + uint32_t index = aStorage.Length() - 1; + aEntry = aStorage.ElementAt(index); + aStorage.RemoveElementAt(index); + return true; + } + + static void Clear(StorageType& aStorage) + { + aStorage.Clear(); + } + + static void Compact(StorageType& aStorage) + { + aStorage.Compact(); + } +}; + +class LockingWithMutex +{ + mozilla::Mutex mMutex; + +protected: + LockingWithMutex() + : mMutex("LockingWithMutex::mMutex") + { } + + void Lock() + { + mMutex.Lock(); + } + + void Unlock() + { + mMutex.Unlock(); + } + + class AutoLock + { + LockingWithMutex& mHost; + + public: + explicit AutoLock(LockingWithMutex& aHost) + : mHost(aHost) + { + mHost.Lock(); + } + + ~AutoLock() + { + mHost.Unlock(); + } + }; + + friend class AutoLock; +}; + +class NoLocking +{ +protected: + void Lock() + { } + + void Unlock() + { } + + class AutoLock + { + public: + explicit AutoLock(NoLocking& aHost) + { } + + ~AutoLock() + { } + }; +}; + +template <typename T, + int TCount = 256, + class LockingPolicy = NoLocking, + class StoragePolicy = StorageWithTArray<T, TCount % 2 ? + TCount / 2 + 1 : + TCount / 2> > +class Queue : public LockingPolicy +{ + typedef typename StoragePolicy::StorageType StorageType; + typedef typename LockingPolicy::AutoLock AutoLock; + + StorageType mStorage1; + StorageType mStorage2; + + StorageType* mFront; + StorageType* mBack; + +public: + Queue() + : mFront(&mStorage1), mBack(&mStorage2) + { } + + bool IsEmpty() + { + AutoLock lock(*this); + return StoragePolicy::IsEmpty(*mFront) && + StoragePolicy::IsEmpty(*mBack); + } + + bool Push(const T& aEntry) + { + AutoLock lock(*this); + return StoragePolicy::Push(*mBack, aEntry); + } + + bool Pop(T& aEntry) + { + AutoLock lock(*this); + if (StoragePolicy::IsEmpty(*mFront)) { + StoragePolicy::Compact(*mFront); + StoragePolicy::Reverse(*mBack); + StorageType* tmp = mFront; + mFront = mBack; + mBack = tmp; + } + return StoragePolicy::Pop(*mFront, aEntry); + } + + void Clear() + { + AutoLock lock(*this); + StoragePolicy::Clear(*mFront); + StoragePolicy::Clear(*mBack); + } + + // XXX Do we need this? + void Lock() + { + LockingPolicy::Lock(); + } + + // XXX Do we need this? + void Unlock() + { + LockingPolicy::Unlock(); + } + +private: + // Queue is not copyable. + Queue(const Queue&); + Queue & operator=(const Queue&); +}; + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_queue_h__ */ diff --git a/dom/workers/RegisterBindings.cpp b/dom/workers/RegisterBindings.cpp new file mode 100644 index 000000000..b6c1e9cfd --- /dev/null +++ b/dom/workers/RegisterBindings.cpp @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerPrivate.h" +#include "ChromeWorkerScope.h" +#include "RuntimeService.h" + +#include "jsapi.h" +#include "mozilla/dom/RegisterWorkerBindings.h" +#include "mozilla/dom/RegisterWorkerDebuggerBindings.h" +#include "mozilla/OSFileConstants.h" + +USING_WORKERS_NAMESPACE +using namespace mozilla::dom; + +bool +WorkerPrivate::RegisterBindings(JSContext* aCx, JS::Handle<JSObject*> aGlobal) +{ + // Init Web IDL bindings + if (!RegisterWorkerBindings(aCx, aGlobal)) { + return false; + } + + if (IsChromeWorker()) { + if (!DefineChromeWorkerFunctions(aCx, aGlobal) || + !DefineOSFileConstants(aCx, aGlobal)) { + return false; + } + } + + if (!JS_DefineProfilingFunctions(aCx, aGlobal)) { + return false; + } + + return true; +} + +bool +WorkerPrivate::RegisterDebuggerBindings(JSContext* aCx, + JS::Handle<JSObject*> aGlobal) +{ + // Init Web IDL bindings + if (!RegisterWorkerDebuggerBindings(aCx, aGlobal)) { + return false; + } + + if (!JS_DefineDebuggerObject(aCx, aGlobal)) { + return false; + } + + return true; +} diff --git a/dom/workers/RuntimeService.cpp b/dom/workers/RuntimeService.cpp new file mode 100644 index 000000000..d1d76e3d1 --- /dev/null +++ b/dom/workers/RuntimeService.cpp @@ -0,0 +1,2966 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "RuntimeService.h" + +#include "nsAutoPtr.h" +#include "nsIChannel.h" +#include "nsIContentSecurityPolicy.h" +#include "nsIDocument.h" +#include "nsIDOMChromeWindow.h" +#include "nsIEffectiveTLDService.h" +#include "nsIObserverService.h" +#include "nsIPrincipal.h" +#include "nsIScriptContext.h" +#include "nsIScriptError.h" +#include "nsIScriptSecurityManager.h" +#include "nsISupportsPriority.h" +#include "nsITimer.h" +#include "nsIURI.h" +#include "nsPIDOMWindow.h" + +#include <algorithm> +#include "BackgroundChild.h" +#include "GeckoProfiler.h" +#include "jsfriendapi.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/Atomics.h" +#include "mozilla/CycleCollectedJSContext.h" +#include "mozilla/Telemetry.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/asmjscache/AsmJSCache.h" +#include "mozilla/dom/AtomList.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/ErrorEventBinding.h" +#include "mozilla/dom/EventTargetBinding.h" +#include "mozilla/dom/MessageChannel.h" +#include "mozilla/dom/MessageEventBinding.h" +#include "mozilla/dom/WorkerBinding.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/IndexedDatabaseManager.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/Preferences.h" +#include "mozilla/dom/Navigator.h" +#include "nsContentUtils.h" +#include "nsCycleCollector.h" +#include "nsDOMJSUtils.h" +#include "nsIIPCBackgroundChildCreateCallback.h" +#include "nsISupportsImpl.h" +#include "nsLayoutStatics.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsThreadUtils.h" +#include "nsXPCOM.h" +#include "nsXPCOMPrivate.h" +#include "OSFileConstants.h" +#include "xpcpublic.h" + +#include "Principal.h" +#include "SharedWorker.h" +#include "WorkerDebuggerManager.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" +#include "WorkerThread.h" +#include "prsystem.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +USING_WORKERS_NAMESPACE + +using mozilla::MutexAutoLock; +using mozilla::MutexAutoUnlock; +using mozilla::Preferences; + +// The size of the worker runtime heaps in bytes. May be changed via pref. +#define WORKER_DEFAULT_RUNTIME_HEAPSIZE 32 * 1024 * 1024 + +// The size of the generational GC nursery for workers, in bytes. +#define WORKER_DEFAULT_NURSERY_SIZE 1 * 1024 * 1024 + +// The size of the worker JS allocation threshold in MB. May be changed via pref. +#define WORKER_DEFAULT_ALLOCATION_THRESHOLD 30 + +// Half the size of the actual C stack, to be safe. +#define WORKER_CONTEXT_NATIVE_STACK_LIMIT 128 * sizeof(size_t) * 1024 + +// The maximum number of hardware concurrency, overridable via pref. +#define MAX_HARDWARE_CONCURRENCY 8 + +// The maximum number of threads to use for workers, overridable via pref. +#define MAX_WORKERS_PER_DOMAIN 512 + +static_assert(MAX_WORKERS_PER_DOMAIN >= 1, + "We should allow at least one worker per domain."); + +// The default number of seconds that close handlers will be allowed to run for +// content workers. +#define MAX_SCRIPT_RUN_TIME_SEC 10 + +// The number of seconds that idle threads can hang around before being killed. +#define IDLE_THREAD_TIMEOUT_SEC 30 + +// The maximum number of threads that can be idle at one time. +#define MAX_IDLE_THREADS 20 + +#define PREF_WORKERS_PREFIX "dom.workers." +#define PREF_WORKERS_MAX_PER_DOMAIN PREF_WORKERS_PREFIX "maxPerDomain" +#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 BROADCAST_ALL_WORKERS(_func, ...) \ + PR_BEGIN_MACRO \ + AssertIsOnMainThread(); \ + \ + AutoTArray<WorkerPrivate*, 100> workers; \ + { \ + MutexAutoLock lock(mMutex); \ + \ + AddAllTopLevelWorkersToArray(workers); \ + } \ + \ + if (!workers.IsEmpty()) { \ + for (uint32_t index = 0; index < workers.Length(); index++) { \ + workers[index]-> _func (__VA_ARGS__); \ + } \ + } \ + PR_END_MACRO + +// Prefixes for observing preference changes. +#define PREF_JS_OPTIONS_PREFIX "javascript.options." +#define PREF_WORKERS_OPTIONS_PREFIX PREF_WORKERS_PREFIX "options." +#define PREF_MEM_OPTIONS_PREFIX "mem." +#define PREF_GCZEAL "gcZeal" + +namespace { + +const uint32_t kNoIndex = uint32_t(-1); + +uint32_t gMaxWorkersPerDomain = MAX_WORKERS_PER_DOMAIN; +uint32_t gMaxHardwareConcurrency = MAX_HARDWARE_CONCURRENCY; + +// Does not hold an owning reference. +RuntimeService* gRuntimeService = nullptr; + +// Only true during the call to Init. +bool gRuntimeServiceDuringInit = false; + +class LiteralRebindingCString : public nsDependentCString +{ +public: + template<int N> + void RebindLiteral(const char (&aStr)[N]) + { + Rebind(aStr, N-1); + } +}; + +template <typename T> +struct PrefTraits; + +template <> +struct PrefTraits<bool> +{ + typedef bool PrefValueType; + + static const PrefValueType kDefaultValue = false; + + static inline PrefValueType + Get(const char* aPref) + { + AssertIsOnMainThread(); + return Preferences::GetBool(aPref); + } + + static inline bool + Exists(const char* aPref) + { + AssertIsOnMainThread(); + return Preferences::GetType(aPref) == nsIPrefBranch::PREF_BOOL; + } +}; + +template <> +struct PrefTraits<int32_t> +{ + typedef int32_t PrefValueType; + + static inline PrefValueType + Get(const char* aPref) + { + AssertIsOnMainThread(); + return Preferences::GetInt(aPref); + } + + static inline bool + Exists(const char* aPref) + { + AssertIsOnMainThread(); + return Preferences::GetType(aPref) == nsIPrefBranch::PREF_INT; + } +}; + +template <typename T> +T +GetWorkerPref(const nsACString& aPref, + const T aDefault = PrefTraits<T>::kDefaultValue) +{ + AssertIsOnMainThread(); + + typedef PrefTraits<T> PrefHelper; + + T result; + + nsAutoCString prefName; + prefName.AssignLiteral(PREF_WORKERS_OPTIONS_PREFIX); + prefName.Append(aPref); + + if (PrefHelper::Exists(prefName.get())) { + result = PrefHelper::Get(prefName.get()); + } + else { + prefName.AssignLiteral(PREF_JS_OPTIONS_PREFIX); + prefName.Append(aPref); + + if (PrefHelper::Exists(prefName.get())) { + result = PrefHelper::Get(prefName.get()); + } + else { + result = aDefault; + } + } + + return result; +} + +// This fn creates a key for a SharedWorker that contains the name, script +// spec, and the serialized origin attributes: +// "name|scriptSpec^key1=val1&key2=val2&key3=val3" +void +GenerateSharedWorkerKey(const nsACString& aScriptSpec, + const nsACString& aName, + const PrincipalOriginAttributes& aAttrs, + nsCString& aKey) +{ + nsAutoCString suffix; + aAttrs.CreateSuffix(suffix); + + aKey.Truncate(); + aKey.SetCapacity(aName.Length() + aScriptSpec.Length() + suffix.Length() + 2); + aKey.Append(aName); + aKey.Append('|'); + aKey.Append(aScriptSpec); + aKey.Append(suffix); +} + +void +LoadContextOptions(const char* aPrefName, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + RuntimeService* rts = RuntimeService::GetService(); + if (!rts) { + // May be shutting down, just bail. + return; + } + + const nsDependentCString prefName(aPrefName); + + // Several other pref branches will get included here so bail out if there is + // another callback that will handle this change. + if (StringBeginsWith(prefName, + NS_LITERAL_CSTRING(PREF_JS_OPTIONS_PREFIX + PREF_MEM_OPTIONS_PREFIX)) || + StringBeginsWith(prefName, + NS_LITERAL_CSTRING(PREF_WORKERS_OPTIONS_PREFIX + PREF_MEM_OPTIONS_PREFIX))) { + return; + } + +#ifdef JS_GC_ZEAL + if (prefName.EqualsLiteral(PREF_JS_OPTIONS_PREFIX PREF_GCZEAL) || + prefName.EqualsLiteral(PREF_WORKERS_OPTIONS_PREFIX PREF_GCZEAL)) { + return; + } +#endif + + // Context options. + JS::ContextOptions contextOptions; + contextOptions.setAsmJS(GetWorkerPref<bool>(NS_LITERAL_CSTRING("asmjs"))) + .setWasm(GetWorkerPref<bool>(NS_LITERAL_CSTRING("wasm"))) + .setThrowOnAsmJSValidationFailure(GetWorkerPref<bool>( + NS_LITERAL_CSTRING("throw_on_asmjs_validation_failure"))) + .setBaseline(GetWorkerPref<bool>(NS_LITERAL_CSTRING("baselinejit"))) + .setIon(GetWorkerPref<bool>(NS_LITERAL_CSTRING("ion"))) + .setNativeRegExp(GetWorkerPref<bool>(NS_LITERAL_CSTRING("native_regexp"))) + .setAsyncStack(GetWorkerPref<bool>(NS_LITERAL_CSTRING("asyncstack"))) + .setWerror(GetWorkerPref<bool>(NS_LITERAL_CSTRING("werror"))) + .setExtraWarnings(GetWorkerPref<bool>(NS_LITERAL_CSTRING("strict"))); + + RuntimeService::SetDefaultContextOptions(contextOptions); + + if (rts) { + rts->UpdateAllWorkerContextOptions(); + } +} + +#ifdef JS_GC_ZEAL +void +LoadGCZealOptions(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + RuntimeService* rts = RuntimeService::GetService(); + if (!rts) { + // May be shutting down, just bail. + return; + } + + int32_t gczeal = GetWorkerPref<int32_t>(NS_LITERAL_CSTRING(PREF_GCZEAL), -1); + if (gczeal < 0) { + gczeal = 0; + } + + int32_t frequency = + GetWorkerPref<int32_t>(NS_LITERAL_CSTRING("gcZeal.frequency"), -1); + if (frequency < 0) { + frequency = JS_DEFAULT_ZEAL_FREQ; + } + + RuntimeService::SetDefaultGCZeal(uint8_t(gczeal), uint32_t(frequency)); + + if (rts) { + rts->UpdateAllWorkerGCZeal(); + } +} +#endif + +void +UpdateCommonJSGCMemoryOption(RuntimeService* aRuntimeService, + const nsACString& aPrefName, JSGCParamKey aKey) +{ + AssertIsOnMainThread(); + NS_ASSERTION(!aPrefName.IsEmpty(), "Empty pref name!"); + + int32_t prefValue = GetWorkerPref(aPrefName, -1); + uint32_t value = + (prefValue < 0 || prefValue >= 10000) ? 0 : uint32_t(prefValue); + + RuntimeService::SetDefaultJSGCSettings(aKey, value); + + if (aRuntimeService) { + aRuntimeService->UpdateAllWorkerMemoryParameter(aKey, value); + } +} + +void +UpdateOtherJSGCMemoryOption(RuntimeService* aRuntimeService, + JSGCParamKey aKey, uint32_t aValue) +{ + AssertIsOnMainThread(); + + RuntimeService::SetDefaultJSGCSettings(aKey, aValue); + + if (aRuntimeService) { + aRuntimeService->UpdateAllWorkerMemoryParameter(aKey, aValue); + } +} + + +void +LoadJSGCMemoryOptions(const char* aPrefName, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + RuntimeService* rts = RuntimeService::GetService(); + + if (!rts) { + // May be shutting down, just bail. + return; + } + + NS_NAMED_LITERAL_CSTRING(jsPrefix, PREF_JS_OPTIONS_PREFIX); + NS_NAMED_LITERAL_CSTRING(workersPrefix, PREF_WORKERS_OPTIONS_PREFIX); + + const nsDependentCString fullPrefName(aPrefName); + + // Pull out the string that actually distinguishes the parameter we need to + // change. + nsDependentCSubstring memPrefName; + if (StringBeginsWith(fullPrefName, jsPrefix)) { + memPrefName.Rebind(fullPrefName, jsPrefix.Length()); + } + else if (StringBeginsWith(fullPrefName, workersPrefix)) { + memPrefName.Rebind(fullPrefName, workersPrefix.Length()); + } + else { + NS_ERROR("Unknown pref name!"); + return; + } + +#ifdef DEBUG + // During Init() we get called back with a branch string here, so there should + // be no just a "mem." pref here. + if (!rts) { + NS_ASSERTION(memPrefName.EqualsLiteral(PREF_MEM_OPTIONS_PREFIX), "Huh?!"); + } +#endif + + // If we're running in Init() then do this for every pref we care about. + // Otherwise we just want to update the parameter that changed. + for (uint32_t index = !gRuntimeServiceDuringInit + ? JSSettings::kGCSettingsArraySize - 1 : 0; + index < JSSettings::kGCSettingsArraySize; + index++) { + LiteralRebindingCString matchName; + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "max"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 0)) { + int32_t prefValue = GetWorkerPref(matchName, -1); + uint32_t value = (prefValue <= 0 || prefValue >= 0x1000) ? + uint32_t(-1) : + uint32_t(prefValue) * 1024 * 1024; + UpdateOtherJSGCMemoryOption(rts, JSGC_MAX_BYTES, value); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "high_water_mark"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 1)) { + int32_t prefValue = GetWorkerPref(matchName, 128); + UpdateOtherJSGCMemoryOption(rts, JSGC_MAX_MALLOC_BYTES, + uint32_t(prefValue) * 1024 * 1024); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_high_frequency_time_limit_ms"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 2)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_HIGH_FREQUENCY_TIME_LIMIT); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_low_frequency_heap_growth"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 3)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_LOW_FREQUENCY_HEAP_GROWTH); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_high_frequency_heap_growth_min"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 4)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_high_frequency_heap_growth_max"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 5)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_high_frequency_low_limit_mb"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 6)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_HIGH_FREQUENCY_LOW_LIMIT); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_high_frequency_high_limit_mb"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 7)) { + UpdateCommonJSGCMemoryOption(rts, matchName, + JSGC_HIGH_FREQUENCY_HIGH_LIMIT); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX + "gc_allocation_threshold_mb"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 8)) { + UpdateCommonJSGCMemoryOption(rts, matchName, JSGC_ALLOCATION_THRESHOLD); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_incremental_slice_ms"); + if (memPrefName == matchName || (gRuntimeServiceDuringInit && index == 9)) { + int32_t prefValue = GetWorkerPref(matchName, -1); + uint32_t value = + (prefValue <= 0 || prefValue >= 100000) ? 0 : uint32_t(prefValue); + UpdateOtherJSGCMemoryOption(rts, JSGC_SLICE_TIME_BUDGET, value); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_dynamic_heap_growth"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 10)) { + bool prefValue = GetWorkerPref(matchName, false); + UpdateOtherJSGCMemoryOption(rts, JSGC_DYNAMIC_HEAP_GROWTH, + prefValue ? 0 : 1); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_dynamic_mark_slice"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 11)) { + bool prefValue = GetWorkerPref(matchName, false); + UpdateOtherJSGCMemoryOption(rts, JSGC_DYNAMIC_MARK_SLICE, + prefValue ? 0 : 1); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_min_empty_chunk_count"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 12)) { + UpdateCommonJSGCMemoryOption(rts, matchName, JSGC_MIN_EMPTY_CHUNK_COUNT); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_max_empty_chunk_count"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 13)) { + UpdateCommonJSGCMemoryOption(rts, matchName, JSGC_MAX_EMPTY_CHUNK_COUNT); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_compacting"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 14)) { + bool prefValue = GetWorkerPref(matchName, false); + UpdateOtherJSGCMemoryOption(rts, JSGC_COMPACTING_ENABLED, + prefValue ? 0 : 1); + continue; + } + + matchName.RebindLiteral(PREF_MEM_OPTIONS_PREFIX "gc_refresh_frame_slices_enabled"); + if (memPrefName == matchName || + (gRuntimeServiceDuringInit && index == 15)) { + bool prefValue = GetWorkerPref(matchName, false); + UpdateOtherJSGCMemoryOption(rts, JSGC_REFRESH_FRAME_SLICES_ENABLED, + prefValue ? 0 : 1); + continue; + } + +#ifdef DEBUG + nsAutoCString message("Workers don't support the 'mem."); + message.Append(memPrefName); + message.AppendLiteral("' preference!"); + NS_WARNING(message.get()); +#endif + } +} + +bool +InterruptCallback(JSContext* aCx) +{ + WorkerPrivate* worker = GetWorkerPrivateFromContext(aCx); + MOZ_ASSERT(worker); + + // Now is a good time to turn on profiling if it's pending. + profiler_js_operation_callback(); + + return worker->InterruptCallback(aCx); +} + +class LogViolationDetailsRunnable final : public WorkerMainThreadRunnable +{ + nsString mFileName; + uint32_t mLineNum; + +public: + LogViolationDetailsRunnable(WorkerPrivate* aWorker, + const nsString& aFileName, + uint32_t aLineNum) + : WorkerMainThreadRunnable(aWorker, + NS_LITERAL_CSTRING("RuntimeService :: LogViolationDetails")) + , mFileName(aFileName), mLineNum(aLineNum) + { + MOZ_ASSERT(aWorker); + } + + virtual bool MainThreadRun() override; + +private: + ~LogViolationDetailsRunnable() {} +}; + +bool +ContentSecurityPolicyAllows(JSContext* aCx) +{ + WorkerPrivate* worker = GetWorkerPrivateFromContext(aCx); + worker->AssertIsOnWorkerThread(); + + if (worker->GetReportCSPViolations()) { + nsString fileName; + uint32_t lineNum = 0; + + JS::AutoFilename file; + if (JS::DescribeScriptedCaller(aCx, &file, &lineNum) && file.get()) { + fileName = NS_ConvertUTF8toUTF16(file.get()); + } else { + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + } + + RefPtr<LogViolationDetailsRunnable> runnable = + new LogViolationDetailsRunnable(worker, fileName, lineNum); + + ErrorResult rv; + runnable->Dispatch(rv); + if (NS_WARN_IF(rv.Failed())) { + rv.SuppressException(); + } + } + + return worker->IsEvalAllowed(); +} + +void +CTypesActivityCallback(JSContext* aCx, + js::CTypesActivityType aType) +{ + WorkerPrivate* worker = GetWorkerPrivateFromContext(aCx); + worker->AssertIsOnWorkerThread(); + + switch (aType) { + case js::CTYPES_CALL_BEGIN: + worker->BeginCTypesCall(); + break; + + case js::CTYPES_CALL_END: + worker->EndCTypesCall(); + break; + + case js::CTYPES_CALLBACK_BEGIN: + worker->BeginCTypesCallback(); + break; + + case js::CTYPES_CALLBACK_END: + worker->EndCTypesCallback(); + break; + + default: + MOZ_CRASH("Unknown type flag!"); + } +} + +static nsIPrincipal* +GetPrincipalForAsmJSCacheOp() +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + if (!workerPrivate) { + return nullptr; + } + + // asmjscache::OpenEntryForX guarnatee to only access the given nsIPrincipal + // from the main thread. + return workerPrivate->GetPrincipalDontAssertMainThread(); +} + +static bool +AsmJSCacheOpenEntryForRead(JS::Handle<JSObject*> aGlobal, + const char16_t* aBegin, + const char16_t* aLimit, + size_t* aSize, + const uint8_t** aMemory, + intptr_t *aHandle) +{ + nsIPrincipal* principal = GetPrincipalForAsmJSCacheOp(); + if (!principal) { + return false; + } + + return asmjscache::OpenEntryForRead(principal, aBegin, aLimit, aSize, aMemory, + aHandle); +} + +static JS::AsmJSCacheResult +AsmJSCacheOpenEntryForWrite(JS::Handle<JSObject*> aGlobal, + bool aInstalled, + const char16_t* aBegin, + const char16_t* aEnd, + size_t aSize, + uint8_t** aMemory, + intptr_t* aHandle) +{ + nsIPrincipal* principal = GetPrincipalForAsmJSCacheOp(); + if (!principal) { + return JS::AsmJSCache_InternalError; + } + + return asmjscache::OpenEntryForWrite(principal, aInstalled, aBegin, aEnd, + aSize, aMemory, aHandle); +} + +class AsyncTaskWorkerHolder final : public WorkerHolder +{ + bool Notify(Status aStatus) override + { + // The async task must complete in bounded time and there is not (currently) + // a clean way to cancel it. Async tasks do not run arbitrary content. + return true; + } + +public: + WorkerPrivate* Worker() const + { + return mWorkerPrivate; + } +}; + +template <class RunnableBase> +class AsyncTaskBase : public RunnableBase +{ + UniquePtr<AsyncTaskWorkerHolder> mHolder; + + // Disable the usual pre/post-dispatch thread assertions since we are + // dispatching from some random JS engine internal thread: + + bool PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + return true; + } + + void PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { } + +protected: + explicit AsyncTaskBase(UniquePtr<AsyncTaskWorkerHolder> aHolder) + : RunnableBase(aHolder->Worker(), + WorkerRunnable::WorkerThreadUnchangedBusyCount) + , mHolder(Move(aHolder)) + { + MOZ_ASSERT(mHolder); + } + + ~AsyncTaskBase() + { + MOZ_ASSERT(!mHolder); + } + + void DestroyHolder() + { + MOZ_ASSERT(mHolder); + mHolder.reset(); + } + +public: + UniquePtr<AsyncTaskWorkerHolder> StealHolder() + { + return Move(mHolder); + } +}; + +class AsyncTaskRunnable final : public AsyncTaskBase<WorkerRunnable> +{ + JS::AsyncTask* mTask; + + ~AsyncTaskRunnable() + { + MOZ_ASSERT(!mTask); + } + + void PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // For the benefit of the destructor assert. + if (!aDispatchResult) { + mTask = nullptr; + } + } + +public: + AsyncTaskRunnable(UniquePtr<AsyncTaskWorkerHolder> aHolder, + JS::AsyncTask* aTask) + : AsyncTaskBase<WorkerRunnable>(Move(aHolder)) + , mTask(aTask) + { + MOZ_ASSERT(mTask); + } + + bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate == mWorkerPrivate); + MOZ_ASSERT(aCx == mWorkerPrivate->GetJSContext()); + MOZ_ASSERT(mTask); + + AutoJSAPI jsapi; + jsapi.Init(); + + mTask->finish(mWorkerPrivate->GetJSContext()); + mTask = nullptr; // mTask may delete itself + + DestroyHolder(); + + return true; + } + + nsresult Cancel() override + { + MOZ_ASSERT(mTask); + + AutoJSAPI jsapi; + jsapi.Init(); + + mTask->cancel(mWorkerPrivate->GetJSContext()); + mTask = nullptr; // mTask may delete itself + + DestroyHolder(); + + return WorkerRunnable::Cancel(); + } +}; + +class AsyncTaskControlRunnable final + : public AsyncTaskBase<WorkerControlRunnable> +{ +public: + explicit AsyncTaskControlRunnable(UniquePtr<AsyncTaskWorkerHolder> aHolder) + : AsyncTaskBase<WorkerControlRunnable>(Move(aHolder)) + { } + + bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + // See comment in FinishAsyncTaskCallback. + DestroyHolder(); + return true; + } +}; + +static bool +StartAsyncTaskCallback(JSContext* aCx, JS::AsyncTask* aTask) +{ + WorkerPrivate* worker = GetWorkerPrivateFromContext(aCx); + worker->AssertIsOnWorkerThread(); + + auto holder = MakeUnique<AsyncTaskWorkerHolder>(); + if (!holder->HoldWorker(worker, Status::Closing)) { + return false; + } + + // Matched by a UniquePtr in FinishAsyncTaskCallback which, by + // interface contract, must be called in the future. + aTask->user = holder.release(); + return true; +} + +static bool +FinishAsyncTaskCallback(JS::AsyncTask* aTask) +{ + // May execute either on the worker thread or a random JS-internal helper + // thread. + + // Match the release() in StartAsyncTaskCallback. + UniquePtr<AsyncTaskWorkerHolder> holder( + static_cast<AsyncTaskWorkerHolder*>(aTask->user)); + + RefPtr<AsyncTaskRunnable> r = new AsyncTaskRunnable(Move(holder), aTask); + + // WorkerRunnable::Dispatch() can fail during worker shutdown. In that case, + // report failure back to the JS engine but make sure to release the + // WorkerHolder on the worker thread using a control runnable. Control + // runables aren't suitable for calling AsyncTask::finish() since they are run + // via the interrupt callback which breaks JS run-to-completion. + if (!r->Dispatch()) { + RefPtr<AsyncTaskControlRunnable> cr = + new AsyncTaskControlRunnable(r->StealHolder()); + + MOZ_ALWAYS_TRUE(cr->Dispatch()); + return false; + } + + return true; +} + +class WorkerJSContext; + +class WorkerThreadContextPrivate : private PerThreadAtomCache +{ + friend class WorkerJSContext; + + WorkerPrivate* mWorkerPrivate; + +public: + // This can't return null, but we can't lose the "Get" prefix in the name or + // it will be ambiguous with the WorkerPrivate class name. + WorkerPrivate* + GetWorkerPrivate() const + { + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(mWorkerPrivate); + + return mWorkerPrivate; + } + +private: + explicit + WorkerThreadContextPrivate(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) + { + MOZ_ASSERT(!NS_IsMainThread()); + + // Zero out the base class members. + memset(this, 0, sizeof(PerThreadAtomCache)); + + MOZ_ASSERT(mWorkerPrivate); + } + + ~WorkerThreadContextPrivate() + { + MOZ_ASSERT(!NS_IsMainThread()); + } + + WorkerThreadContextPrivate(const WorkerThreadContextPrivate&) = delete; + + WorkerThreadContextPrivate& + operator=(const WorkerThreadContextPrivate&) = delete; +}; + +bool +InitJSContextForWorker(WorkerPrivate* aWorkerPrivate, JSContext* aWorkerCx) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + NS_ASSERTION(!aWorkerPrivate->GetJSContext(), "Already has a context!"); + + JSSettings settings; + aWorkerPrivate->CopyJSSettings(settings); + + { + JS::UniqueChars defaultLocale = aWorkerPrivate->AdoptDefaultLocale(); + MOZ_ASSERT(defaultLocale, + "failure of a WorkerPrivate to have a default locale should " + "have made the worker fail to spawn"); + + if (!JS_SetDefaultLocale(aWorkerCx, defaultLocale.get())) { + NS_WARNING("failed to set workerCx's default locale"); + return false; + } + } + + JS::ContextOptionsRef(aWorkerCx) = settings.contextOptions; + + JSSettings::JSGCSettingsArray& gcSettings = settings.gcSettings; + + // This is the real place where we set the max memory for the runtime. + for (uint32_t index = 0; index < ArrayLength(gcSettings); index++) { + const JSSettings::JSGCSetting& setting = gcSettings[index]; + if (setting.IsSet()) { + NS_ASSERTION(setting.value, "Can't handle 0 values!"); + JS_SetGCParameter(aWorkerCx, setting.key, setting.value); + } + } + + JS_SetNativeStackQuota(aWorkerCx, WORKER_CONTEXT_NATIVE_STACK_LIMIT); + + // Security policy: + static const JSSecurityCallbacks securityCallbacks = { + ContentSecurityPolicyAllows + }; + JS_SetSecurityCallbacks(aWorkerCx, &securityCallbacks); + + // Set up the asm.js cache callbacks + static const JS::AsmJSCacheOps asmJSCacheOps = { + AsmJSCacheOpenEntryForRead, + asmjscache::CloseEntryForRead, + AsmJSCacheOpenEntryForWrite, + asmjscache::CloseEntryForWrite + }; + JS::SetAsmJSCacheOps(aWorkerCx, &asmJSCacheOps); + + JS::SetAsyncTaskCallbacks(aWorkerCx, StartAsyncTaskCallback, FinishAsyncTaskCallback); + + if (!JS::InitSelfHostedCode(aWorkerCx)) { + NS_WARNING("Could not init self-hosted code!"); + return false; + } + + JS_AddInterruptCallback(aWorkerCx, InterruptCallback); + + js::SetCTypesActivityCallback(aWorkerCx, CTypesActivityCallback); + +#ifdef JS_GC_ZEAL + JS_SetGCZeal(aWorkerCx, settings.gcZeal, settings.gcZealFrequency); +#endif + + return true; +} + +static bool +PreserveWrapper(JSContext *cx, JSObject *obj) +{ + MOZ_ASSERT(cx); + MOZ_ASSERT(obj); + MOZ_ASSERT(mozilla::dom::IsDOMObject(obj)); + + return mozilla::dom::TryPreserveWrapper(obj); +} + +JSObject* +Wrap(JSContext *cx, JS::HandleObject existing, JS::HandleObject obj) +{ + JSObject* targetGlobal = JS::CurrentGlobalOrNull(cx); + if (!IsDebuggerGlobal(targetGlobal) && !IsDebuggerSandbox(targetGlobal)) { + MOZ_CRASH("There should be no edges from the debuggee to the debugger."); + } + + JSObject* originGlobal = js::GetGlobalForObjectCrossCompartment(obj); + + const js::Wrapper* wrapper = nullptr; + if (IsDebuggerGlobal(originGlobal) || IsDebuggerSandbox(originGlobal)) { + wrapper = &js::CrossCompartmentWrapper::singleton; + } else { + wrapper = &js::OpaqueCrossCompartmentWrapper::singleton; + } + + if (existing) { + js::Wrapper::Renew(cx, existing, obj, wrapper); + } + return js::Wrapper::New(cx, obj, wrapper); +} + +static const JSWrapObjectCallbacks WrapObjectCallbacks = { + Wrap, + nullptr, +}; + +class MOZ_STACK_CLASS WorkerJSContext final : public mozilla::CycleCollectedJSContext +{ +public: + // The heap size passed here doesn't matter, we will change it later in the + // call to JS_SetGCParameter inside InitJSContextForWorker. + explicit WorkerJSContext(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + } + + ~WorkerJSContext() + { + JSContext* cx = MaybeContext(); + if (!cx) { + return; // Initialize() must have failed + } + + delete static_cast<WorkerThreadContextPrivate*>(JS_GetContextPrivate(cx)); + JS_SetContextPrivate(cx, nullptr); + + // The worker global should be unrooted and the shutdown cycle collection + // should break all remaining cycles. The superclass destructor will run + // the GC one final time and finalize any JSObjects that were participating + // in cycles that were broken during CC shutdown. + nsCycleCollector_shutdown(); + + // The CC is shut down, and the superclass destructor will GC, so make sure + // we don't try to CC again. + mWorkerPrivate = nullptr; + } + + nsresult Initialize(JSContext* aParentContext) + { + nsresult rv = + CycleCollectedJSContext::Initialize(aParentContext, + WORKER_DEFAULT_RUNTIME_HEAPSIZE, + WORKER_DEFAULT_NURSERY_SIZE); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + JSContext* cx = Context(); + + JS_SetContextPrivate(cx, new WorkerThreadContextPrivate(mWorkerPrivate)); + + js::SetPreserveWrapperCallback(cx, PreserveWrapper); + JS_InitDestroyPrincipalsCallback(cx, DestroyWorkerPrincipals); + JS_SetWrapObjectCallbacks(cx, &WrapObjectCallbacks); + if (mWorkerPrivate->IsDedicatedWorker()) { + JS_SetFutexCanWait(cx); + } + + return NS_OK; + } + + virtual void + PrepareForForgetSkippable() override + { + } + + virtual void + BeginCycleCollectionCallback() override + { + } + + virtual void + EndCycleCollectionCallback(CycleCollectorResults &aResults) override + { + } + + void + DispatchDeferredDeletion(bool aContinuation, bool aPurge) override + { + MOZ_ASSERT(!aContinuation); + + // Do it immediately, no need for asynchronous behavior here. + nsCycleCollector_doDeferredDeletion(); + } + + virtual void CustomGCCallback(JSGCStatus aStatus) override + { + if (!mWorkerPrivate) { + // We're shutting down, no need to do anything. + return; + } + + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (aStatus == JSGC_END) { + nsCycleCollector_collect(nullptr); + } + } + + virtual void AfterProcessTask(uint32_t aRecursionDepth) override + { + // Only perform the Promise microtask checkpoint on the outermost event + // loop. Don't run it, for example, during sync XHR or importScripts. + if (aRecursionDepth == 2) { + CycleCollectedJSContext::AfterProcessTask(aRecursionDepth); + } else if (aRecursionDepth > 2) { + AutoDisableMicroTaskCheckpoint disableMicroTaskCheckpoint; + CycleCollectedJSContext::AfterProcessTask(aRecursionDepth); + } + } + + virtual void DispatchToMicroTask(already_AddRefed<nsIRunnable> aRunnable) override + { + RefPtr<nsIRunnable> runnable(aRunnable); + + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(runnable); + + std::queue<nsCOMPtr<nsIRunnable>>* microTaskQueue = nullptr; + + JSContext* cx = GetCurrentThreadJSContext(); + NS_ASSERTION(cx, "This should never be null!"); + + JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx)); + NS_ASSERTION(global, "This should never be null!"); + + // On worker threads, if the current global is the worker global, we use the + // main promise micro task queue. Otherwise, the current global must be + // either the debugger global or a debugger sandbox, and we use the debugger + // promise micro task queue instead. + if (IsWorkerGlobal(global)) { + microTaskQueue = &mPromiseMicroTaskQueue; + } else { + MOZ_ASSERT(IsDebuggerGlobal(global) || IsDebuggerSandbox(global)); + + microTaskQueue = &mDebuggerPromiseMicroTaskQueue; + } + + microTaskQueue->push(runnable.forget()); + } + +private: + WorkerPrivate* mWorkerPrivate; +}; + +class WorkerThreadPrimaryRunnable final : public Runnable +{ + WorkerPrivate* mWorkerPrivate; + RefPtr<WorkerThread> mThread; + JSContext* mParentContext; + + class FinishedRunnable final : public Runnable + { + RefPtr<WorkerThread> mThread; + + public: + explicit FinishedRunnable(already_AddRefed<WorkerThread> aThread) + : mThread(aThread) + { + MOZ_ASSERT(mThread); + } + + NS_DECL_ISUPPORTS_INHERITED + + private: + ~FinishedRunnable() + { } + + NS_DECL_NSIRUNNABLE + }; + +public: + WorkerThreadPrimaryRunnable(WorkerPrivate* aWorkerPrivate, + WorkerThread* aThread, + JSContext* aParentContext) + : mWorkerPrivate(aWorkerPrivate), mThread(aThread), mParentContext(aParentContext) + { + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aThread); + } + + NS_DECL_ISUPPORTS_INHERITED + +private: + ~WorkerThreadPrimaryRunnable() + { } + + NS_DECL_NSIRUNNABLE +}; + +class WorkerTaskRunnable final : public WorkerRunnable +{ + RefPtr<WorkerTask> mTask; + +public: + WorkerTaskRunnable(WorkerPrivate* aWorkerPrivate, WorkerTask* aTask) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), mTask(aTask) + { + MOZ_ASSERT(aTask); + } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // May be called on any thread! + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // May be called on any thread! + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return mTask->RunTask(aCx); + } +}; + +void +PrefLanguagesChanged(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + nsTArray<nsString> languages; + Navigator::GetAcceptLanguages(languages); + + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->UpdateAllWorkerLanguages(languages); + } +} + +void +AppNameOverrideChanged(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + const nsAdoptingString& override = + mozilla::Preferences::GetString("general.appname.override"); + + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->UpdateAppNameOverridePreference(override); + } +} + +void +AppVersionOverrideChanged(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + const nsAdoptingString& override = + mozilla::Preferences::GetString("general.appversion.override"); + + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->UpdateAppVersionOverridePreference(override); + } +} + +void +PlatformOverrideChanged(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + const nsAdoptingString& override = + mozilla::Preferences::GetString("general.platform.override"); + + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->UpdatePlatformOverridePreference(override); + } +} + +class BackgroundChildCallback final + : public nsIIPCBackgroundChildCreateCallback +{ +public: + BackgroundChildCallback() + { + AssertIsOnMainThread(); + } + + NS_DECL_ISUPPORTS + +private: + ~BackgroundChildCallback() + { + AssertIsOnMainThread(); + } + + virtual void + ActorCreated(PBackgroundChild* aActor) override + { + AssertIsOnMainThread(); + MOZ_ASSERT(aActor); + } + + virtual void + ActorFailed() override + { + AssertIsOnMainThread(); + MOZ_CRASH("Unable to connect PBackground actor for the main thread!"); + } +}; + +NS_IMPL_ISUPPORTS(BackgroundChildCallback, nsIIPCBackgroundChildCreateCallback) + +} /* anonymous namespace */ + +BEGIN_WORKERS_NAMESPACE + +void +CancelWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->CancelWorkersForWindow(aWindow); + } +} + +void +FreezeWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->FreezeWorkersForWindow(aWindow); + } +} + +void +ThawWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->ThawWorkersForWindow(aWindow); + } +} + +void +SuspendWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->SuspendWorkersForWindow(aWindow); + } +} + +void +ResumeWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + RuntimeService* runtime = RuntimeService::GetService(); + if (runtime) { + runtime->ResumeWorkersForWindow(aWindow); + } +} + +WorkerCrossThreadDispatcher::WorkerCrossThreadDispatcher( + WorkerPrivate* aWorkerPrivate) +: mMutex("WorkerCrossThreadDispatcher::mMutex"), + mWorkerPrivate(aWorkerPrivate) +{ + MOZ_ASSERT(aWorkerPrivate); +} + +bool +WorkerCrossThreadDispatcher::PostTask(WorkerTask* aTask) +{ + MOZ_ASSERT(aTask); + + MutexAutoLock lock(mMutex); + + if (!mWorkerPrivate) { + NS_WARNING("Posted a task to a WorkerCrossThreadDispatcher that is no " + "longer accepting tasks!"); + return false; + } + + RefPtr<WorkerTaskRunnable> runnable = + new WorkerTaskRunnable(mWorkerPrivate, aTask); + return runnable->Dispatch(); +} + +WorkerPrivate* +GetWorkerPrivateFromContext(JSContext* aCx) +{ + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(aCx); + + void* cxPrivate = JS_GetContextPrivate(aCx); + if (!cxPrivate) { + return nullptr; + } + + return + static_cast<WorkerThreadContextPrivate*>(cxPrivate)->GetWorkerPrivate(); +} + +WorkerPrivate* +GetCurrentThreadWorkerPrivate() +{ + MOZ_ASSERT(!NS_IsMainThread()); + + CycleCollectedJSContext* ccjscx = CycleCollectedJSContext::Get(); + if (!ccjscx) { + return nullptr; + } + + JSContext* cx = ccjscx->Context(); + MOZ_ASSERT(cx); + + void* cxPrivate = JS_GetContextPrivate(cx); + if (!cxPrivate) { + // This can happen if the nsCycleCollector_shutdown() in ~WorkerJSContext() + // triggers any calls to GetCurrentThreadWorkerPrivate(). At this stage + // CycleCollectedJSContext::Get() will still return a context, but + // the context private has already been cleared. + return nullptr; + } + + return + static_cast<WorkerThreadContextPrivate*>(cxPrivate)->GetWorkerPrivate(); +} + +bool +IsCurrentThreadRunningChromeWorker() +{ + return GetCurrentThreadWorkerPrivate()->UsesSystemPrincipal(); +} + +JSContext* +GetCurrentThreadJSContext() +{ + WorkerPrivate* wp = GetCurrentThreadWorkerPrivate(); + if (!wp) { + return nullptr; + } + return wp->GetJSContext(); +} + +JSObject* +GetCurrentThreadWorkerGlobal() +{ + WorkerPrivate* wp = GetCurrentThreadWorkerPrivate(); + if (!wp) { + return nullptr; + } + WorkerGlobalScope* scope = wp->GlobalScope(); + if (!scope) { + return nullptr; + } + return scope->GetGlobalJSObject(); +} + +END_WORKERS_NAMESPACE + +struct RuntimeService::IdleThreadInfo +{ + RefPtr<WorkerThread> mThread; + mozilla::TimeStamp mExpirationTime; +}; + +// This is only touched on the main thread. Initialized in Init() below. +JSSettings RuntimeService::sDefaultJSSettings; +bool RuntimeService::sDefaultPreferences[WORKERPREF_COUNT] = { false }; + +RuntimeService::RuntimeService() +: mMutex("RuntimeService::mMutex"), mObserved(false), + mShuttingDown(false), mNavigatorPropertiesLoaded(false) +{ + AssertIsOnMainThread(); + NS_ASSERTION(!gRuntimeService, "More than one service!"); +} + +RuntimeService::~RuntimeService() +{ + AssertIsOnMainThread(); + + // gRuntimeService can be null if Init() fails. + NS_ASSERTION(!gRuntimeService || gRuntimeService == this, + "More than one service!"); + + gRuntimeService = nullptr; +} + +// static +RuntimeService* +RuntimeService::GetOrCreateService() +{ + AssertIsOnMainThread(); + + if (!gRuntimeService) { + // The observer service now owns us until shutdown. + gRuntimeService = new RuntimeService(); + if (NS_FAILED(gRuntimeService->Init())) { + NS_WARNING("Failed to initialize!"); + gRuntimeService->Cleanup(); + gRuntimeService = nullptr; + return nullptr; + } + } + + return gRuntimeService; +} + +// static +RuntimeService* +RuntimeService::GetService() +{ + return gRuntimeService; +} + +bool +RuntimeService::RegisterWorker(WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnParentThread(); + + WorkerPrivate* parent = aWorkerPrivate->GetParent(); + if (!parent) { + AssertIsOnMainThread(); + + if (mShuttingDown) { + return false; + } + } + + const bool isServiceWorker = aWorkerPrivate->IsServiceWorker(); + const bool isSharedWorker = aWorkerPrivate->IsSharedWorker(); + const bool isDedicatedWorker = aWorkerPrivate->IsDedicatedWorker(); + if (isServiceWorker) { + AssertIsOnMainThread(); + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_SPAWN_ATTEMPTS, 1); + } + + nsCString sharedWorkerScriptSpec; + if (isSharedWorker) { + AssertIsOnMainThread(); + + nsCOMPtr<nsIURI> scriptURI = aWorkerPrivate->GetResolvedScriptURI(); + NS_ASSERTION(scriptURI, "Null script URI!"); + + nsresult rv = scriptURI->GetSpec(sharedWorkerScriptSpec); + if (NS_FAILED(rv)) { + NS_WARNING("GetSpec failed?!"); + return false; + } + + NS_ASSERTION(!sharedWorkerScriptSpec.IsEmpty(), "Empty spec!"); + } + + bool exemptFromPerDomainMax = false; + if (isServiceWorker) { + AssertIsOnMainThread(); + exemptFromPerDomainMax = Preferences::GetBool("dom.serviceWorkers.exemptFromPerDomainMax", + false); + } + + const nsCString& domain = aWorkerPrivate->Domain(); + + WorkerDomainInfo* domainInfo; + bool queued = false; + { + MutexAutoLock lock(mMutex); + + if (!mDomainMap.Get(domain, &domainInfo)) { + NS_ASSERTION(!parent, "Shouldn't have a parent here!"); + + domainInfo = new WorkerDomainInfo(); + domainInfo->mDomain = domain; + mDomainMap.Put(domain, domainInfo); + } + + queued = gMaxWorkersPerDomain && + domainInfo->ActiveWorkerCount() >= gMaxWorkersPerDomain && + !domain.IsEmpty() && + !exemptFromPerDomainMax; + + if (queued) { + domainInfo->mQueuedWorkers.AppendElement(aWorkerPrivate); + + // Worker spawn gets queued due to hitting max workers per domain + // limit so let's log a warning. + WorkerPrivate::ReportErrorToConsole("HittingMaxWorkersPerDomain2"); + + if (isServiceWorker) { + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_SPAWN_GETS_QUEUED, 1); + } else if (isSharedWorker) { + Telemetry::Accumulate(Telemetry::SHARED_WORKER_SPAWN_GETS_QUEUED, 1); + } else if (isDedicatedWorker) { + Telemetry::Accumulate(Telemetry::DEDICATED_WORKER_SPAWN_GETS_QUEUED, 1); + } + } + else if (parent) { + domainInfo->mChildWorkerCount++; + } + else if (isServiceWorker) { + domainInfo->mActiveServiceWorkers.AppendElement(aWorkerPrivate); + } + else { + domainInfo->mActiveWorkers.AppendElement(aWorkerPrivate); + } + + if (isSharedWorker) { + const nsCString& sharedWorkerName = aWorkerPrivate->WorkerName(); + nsAutoCString key; + GenerateSharedWorkerKey(sharedWorkerScriptSpec, sharedWorkerName, + aWorkerPrivate->GetOriginAttributes(), key); + MOZ_ASSERT(!domainInfo->mSharedWorkerInfos.Get(key)); + + SharedWorkerInfo* sharedWorkerInfo = + new SharedWorkerInfo(aWorkerPrivate, sharedWorkerScriptSpec, + sharedWorkerName); + domainInfo->mSharedWorkerInfos.Put(key, sharedWorkerInfo); + } + } + + // From here on out we must call UnregisterWorker if something fails! + if (parent) { + if (!parent->AddChildWorker(aWorkerPrivate)) { + UnregisterWorker(aWorkerPrivate); + return false; + } + } + else { + if (!mNavigatorPropertiesLoaded) { + Navigator::AppName(mNavigatorProperties.mAppName, + false /* aUsePrefOverriddenValue */); + if (NS_FAILED(Navigator::GetAppVersion(mNavigatorProperties.mAppVersion, + false /* aUsePrefOverriddenValue */)) || + NS_FAILED(Navigator::GetPlatform(mNavigatorProperties.mPlatform, + false /* aUsePrefOverriddenValue */))) { + UnregisterWorker(aWorkerPrivate); + return false; + } + + // The navigator overridden properties should have already been read. + + Navigator::GetAcceptLanguages(mNavigatorProperties.mLanguages); + mNavigatorPropertiesLoaded = true; + } + + nsPIDOMWindowInner* window = aWorkerPrivate->GetWindow(); + + if (!isServiceWorker) { + // Service workers are excluded since their lifetime is separate from + // that of dom windows. + nsTArray<WorkerPrivate*>* windowArray; + if (!mWindowMap.Get(window, &windowArray)) { + windowArray = new nsTArray<WorkerPrivate*>(1); + mWindowMap.Put(window, windowArray); + } + + if (!windowArray->Contains(aWorkerPrivate)) { + windowArray->AppendElement(aWorkerPrivate); + } else { + MOZ_ASSERT(aWorkerPrivate->IsSharedWorker()); + } + } + } + + if (!queued && !ScheduleWorker(aWorkerPrivate)) { + return false; + } + + if (isServiceWorker) { + AssertIsOnMainThread(); + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_WAS_SPAWNED, 1); + } + return true; +} + +void +RuntimeService::RemoveSharedWorker(WorkerDomainInfo* aDomainInfo, + WorkerPrivate* aWorkerPrivate) +{ + for (auto iter = aDomainInfo->mSharedWorkerInfos.Iter(); + !iter.Done(); + iter.Next()) { + SharedWorkerInfo* data = iter.UserData(); + if (data->mWorkerPrivate == aWorkerPrivate) { +#ifdef DEBUG + nsAutoCString key; + GenerateSharedWorkerKey(data->mScriptSpec, data->mName, + aWorkerPrivate->GetOriginAttributes(), key); + MOZ_ASSERT(iter.Key() == key); +#endif + iter.Remove(); + break; + } + } +} + +void +RuntimeService::UnregisterWorker(WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnParentThread(); + + WorkerPrivate* parent = aWorkerPrivate->GetParent(); + if (!parent) { + AssertIsOnMainThread(); + } + + const nsCString& domain = aWorkerPrivate->Domain(); + + WorkerPrivate* queuedWorker = nullptr; + { + MutexAutoLock lock(mMutex); + + WorkerDomainInfo* domainInfo; + if (!mDomainMap.Get(domain, &domainInfo)) { + NS_ERROR("Don't have an entry for this domain!"); + } + + // Remove old worker from everywhere. + uint32_t index = domainInfo->mQueuedWorkers.IndexOf(aWorkerPrivate); + if (index != kNoIndex) { + // Was queued, remove from the list. + domainInfo->mQueuedWorkers.RemoveElementAt(index); + } + else if (parent) { + MOZ_ASSERT(domainInfo->mChildWorkerCount, "Must be non-zero!"); + domainInfo->mChildWorkerCount--; + } + else if (aWorkerPrivate->IsServiceWorker()) { + MOZ_ASSERT(domainInfo->mActiveServiceWorkers.Contains(aWorkerPrivate), + "Don't know about this worker!"); + domainInfo->mActiveServiceWorkers.RemoveElement(aWorkerPrivate); + } + else { + MOZ_ASSERT(domainInfo->mActiveWorkers.Contains(aWorkerPrivate), + "Don't know about this worker!"); + domainInfo->mActiveWorkers.RemoveElement(aWorkerPrivate); + } + + if (aWorkerPrivate->IsSharedWorker()) { + RemoveSharedWorker(domainInfo, aWorkerPrivate); + } + + // See if there's a queued worker we can schedule. + if (domainInfo->ActiveWorkerCount() < gMaxWorkersPerDomain && + !domainInfo->mQueuedWorkers.IsEmpty()) { + queuedWorker = domainInfo->mQueuedWorkers[0]; + domainInfo->mQueuedWorkers.RemoveElementAt(0); + + if (queuedWorker->GetParent()) { + domainInfo->mChildWorkerCount++; + } + else if (queuedWorker->IsServiceWorker()) { + domainInfo->mActiveServiceWorkers.AppendElement(queuedWorker); + } + else { + domainInfo->mActiveWorkers.AppendElement(queuedWorker); + } + } + + if (domainInfo->HasNoWorkers()) { + MOZ_ASSERT(domainInfo->mQueuedWorkers.IsEmpty()); + mDomainMap.Remove(domain); + } + } + + if (aWorkerPrivate->IsServiceWorker()) { + AssertIsOnMainThread(); + Telemetry::AccumulateTimeDelta(Telemetry::SERVICE_WORKER_LIFE_TIME, + aWorkerPrivate->CreationTimeStamp()); + } + + if (aWorkerPrivate->IsSharedWorker() || + aWorkerPrivate->IsServiceWorker()) { + AssertIsOnMainThread(); + aWorkerPrivate->CloseAllSharedWorkers(); + } + + if (parent) { + parent->RemoveChildWorker(aWorkerPrivate); + } + else if (aWorkerPrivate->IsSharedWorker()) { + AssertIsOnMainThread(); + + for (auto iter = mWindowMap.Iter(); !iter.Done(); iter.Next()) { + nsAutoPtr<nsTArray<WorkerPrivate*>>& workers = iter.Data(); + MOZ_ASSERT(workers.get()); + + if (workers->RemoveElement(aWorkerPrivate)) { + MOZ_ASSERT(!workers->Contains(aWorkerPrivate), + "Added worker more than once!"); + + if (workers->IsEmpty()) { + iter.Remove(); + } + } + } + } + else if (aWorkerPrivate->IsDedicatedWorker()) { + // May be null. + nsPIDOMWindowInner* window = aWorkerPrivate->GetWindow(); + + nsTArray<WorkerPrivate*>* windowArray; + MOZ_ALWAYS_TRUE(mWindowMap.Get(window, &windowArray)); + + MOZ_ALWAYS_TRUE(windowArray->RemoveElement(aWorkerPrivate)); + + if (windowArray->IsEmpty()) { + mWindowMap.Remove(window); + } + } + + if (queuedWorker && !ScheduleWorker(queuedWorker)) { + UnregisterWorker(queuedWorker); + } +} + +bool +RuntimeService::ScheduleWorker(WorkerPrivate* aWorkerPrivate) +{ + if (!aWorkerPrivate->Start()) { + // This is ok, means that we didn't need to make a thread for this worker. + return true; + } + + RefPtr<WorkerThread> thread; + { + MutexAutoLock lock(mMutex); + if (!mIdleThreadArray.IsEmpty()) { + uint32_t index = mIdleThreadArray.Length() - 1; + mIdleThreadArray[index].mThread.swap(thread); + mIdleThreadArray.RemoveElementAt(index); + } + } + + const WorkerThreadFriendKey friendKey; + + if (!thread) { + thread = WorkerThread::Create(friendKey); + if (!thread) { + UnregisterWorker(aWorkerPrivate); + return false; + } + } + + int32_t priority = aWorkerPrivate->IsChromeWorker() ? + nsISupportsPriority::PRIORITY_NORMAL : + nsISupportsPriority::PRIORITY_LOW; + + if (NS_FAILED(thread->SetPriority(priority))) { + NS_WARNING("Could not set the thread's priority!"); + } + + JSContext* cx = CycleCollectedJSContext::Get()->Context(); + nsCOMPtr<nsIRunnable> runnable = + new WorkerThreadPrimaryRunnable(aWorkerPrivate, thread, + JS_GetParentContext(cx)); + if (NS_FAILED(thread->DispatchPrimaryRunnable(friendKey, runnable.forget()))) { + UnregisterWorker(aWorkerPrivate); + return false; + } + + return true; +} + +// static +void +RuntimeService::ShutdownIdleThreads(nsITimer* aTimer, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + RuntimeService* runtime = RuntimeService::GetService(); + NS_ASSERTION(runtime, "This should never be null!"); + + NS_ASSERTION(aTimer == runtime->mIdleThreadTimer, "Wrong timer!"); + + // Cheat a little and grab all threads that expire within one second of now. + TimeStamp now = TimeStamp::NowLoRes() + TimeDuration::FromSeconds(1); + + TimeStamp nextExpiration; + + AutoTArray<RefPtr<WorkerThread>, 20> expiredThreads; + { + MutexAutoLock lock(runtime->mMutex); + + for (uint32_t index = 0; index < runtime->mIdleThreadArray.Length(); + index++) { + IdleThreadInfo& info = runtime->mIdleThreadArray[index]; + if (info.mExpirationTime > now) { + nextExpiration = info.mExpirationTime; + break; + } + + RefPtr<WorkerThread>* thread = expiredThreads.AppendElement(); + thread->swap(info.mThread); + } + + if (!expiredThreads.IsEmpty()) { + runtime->mIdleThreadArray.RemoveElementsAt(0, expiredThreads.Length()); + } + } + + if (!nextExpiration.IsNull()) { + TimeDuration delta = nextExpiration - TimeStamp::NowLoRes(); + uint32_t delay(delta > TimeDuration(0) ? delta.ToMilliseconds() : 0); + + // Reschedule the timer. + MOZ_ALWAYS_SUCCEEDS( + aTimer->InitWithFuncCallback(ShutdownIdleThreads, + nullptr, + delay, + nsITimer::TYPE_ONE_SHOT)); + } + + for (uint32_t index = 0; index < expiredThreads.Length(); index++) { + if (NS_FAILED(expiredThreads[index]->Shutdown())) { + NS_WARNING("Failed to shutdown thread!"); + } + } +} + +nsresult +RuntimeService::Init() +{ + AssertIsOnMainThread(); + + nsLayoutStatics::AddRef(); + + // Make sure PBackground actors are connected as soon as possible for the main + // thread in case workers clone remote blobs here. + if (!BackgroundChild::GetForCurrentThread()) { + RefPtr<BackgroundChildCallback> callback = new BackgroundChildCallback(); + if (!BackgroundChild::GetOrCreateForCurrentThread(callback)) { + MOZ_CRASH("Unable to connect PBackground actor for the main thread!"); + } + } + + // Initialize JSSettings. + if (!sDefaultJSSettings.gcSettings[0].IsSet()) { + sDefaultJSSettings.contextOptions = JS::ContextOptions(); + sDefaultJSSettings.chrome.maxScriptRuntime = -1; + sDefaultJSSettings.chrome.compartmentOptions.behaviors().setVersion(JSVERSION_LATEST); + sDefaultJSSettings.content.maxScriptRuntime = MAX_SCRIPT_RUN_TIME_SEC; +#ifdef JS_GC_ZEAL + sDefaultJSSettings.gcZealFrequency = JS_DEFAULT_ZEAL_FREQ; + sDefaultJSSettings.gcZeal = 0; +#endif + SetDefaultJSGCSettings(JSGC_MAX_BYTES, WORKER_DEFAULT_RUNTIME_HEAPSIZE); + SetDefaultJSGCSettings(JSGC_ALLOCATION_THRESHOLD, + WORKER_DEFAULT_ALLOCATION_THRESHOLD); + } + + mIdleThreadTimer = do_CreateInstance(NS_TIMER_CONTRACTID); + NS_ENSURE_STATE(mIdleThreadTimer); + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE); + + nsresult rv = + obs->AddObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID, false); + NS_ENSURE_SUCCESS(rv, rv); + + rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + NS_ENSURE_SUCCESS(rv, rv); + + mObserved = true; + + if (NS_FAILED(obs->AddObserver(this, GC_REQUEST_OBSERVER_TOPIC, false))) { + NS_WARNING("Failed to register for GC request notifications!"); + } + + if (NS_FAILED(obs->AddObserver(this, CC_REQUEST_OBSERVER_TOPIC, false))) { + NS_WARNING("Failed to register for CC request notifications!"); + } + + if (NS_FAILED(obs->AddObserver(this, MEMORY_PRESSURE_OBSERVER_TOPIC, + 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!"); + } + + MOZ_ASSERT(!gRuntimeServiceDuringInit, "This should be false!"); + gRuntimeServiceDuringInit = true; + + if (NS_FAILED(Preferences::RegisterCallback( + LoadJSGCMemoryOptions, + PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX, + nullptr)) || + NS_FAILED(Preferences::RegisterCallbackAndCall( + LoadJSGCMemoryOptions, + PREF_WORKERS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX, + nullptr)) || +#ifdef JS_GC_ZEAL + NS_FAILED(Preferences::RegisterCallback( + LoadGCZealOptions, + PREF_JS_OPTIONS_PREFIX PREF_GCZEAL, + nullptr)) || +#endif + +#define WORKER_SIMPLE_PREF(name, getter, NAME) \ + NS_FAILED(Preferences::RegisterCallbackAndCall( \ + WorkerPrefChanged, \ + name, \ + reinterpret_cast<void*>(WORKERPREF_##NAME))) || +#define WORKER_PREF(name, callback) \ + NS_FAILED(Preferences::RegisterCallbackAndCall( \ + callback, \ + name, \ + nullptr)) || +#include "WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + + NS_FAILED(Preferences::RegisterCallbackAndCall( + LoadContextOptions, + PREF_WORKERS_OPTIONS_PREFIX, + nullptr)) || + NS_FAILED(Preferences::RegisterCallback(LoadContextOptions, + PREF_JS_OPTIONS_PREFIX, + nullptr))) { + NS_WARNING("Failed to register pref callbacks!"); + } + + MOZ_ASSERT(gRuntimeServiceDuringInit, "Should be true!"); + gRuntimeServiceDuringInit = false; + + // We assume atomic 32bit reads/writes. If this assumption doesn't hold on + // some wacky platform then the worst that could happen is that the close + // handler will run for a slightly different amount of time. + if (NS_FAILED(Preferences::AddIntVarCache( + &sDefaultJSSettings.content.maxScriptRuntime, + PREF_MAX_SCRIPT_RUN_TIME_CONTENT, + MAX_SCRIPT_RUN_TIME_SEC)) || + NS_FAILED(Preferences::AddIntVarCache( + &sDefaultJSSettings.chrome.maxScriptRuntime, + PREF_MAX_SCRIPT_RUN_TIME_CHROME, -1))) { + NS_WARNING("Failed to register timeout cache!"); + } + + int32_t maxPerDomain = Preferences::GetInt(PREF_WORKERS_MAX_PER_DOMAIN, + MAX_WORKERS_PER_DOMAIN); + gMaxWorkersPerDomain = std::max(0, maxPerDomain); + + int32_t maxHardwareConcurrency = + Preferences::GetInt(PREF_WORKERS_MAX_HARDWARE_CONCURRENCY, + MAX_HARDWARE_CONCURRENCY); + gMaxHardwareConcurrency = std::max(0, maxHardwareConcurrency); + + rv = InitOSFileConstants(); + if (NS_FAILED(rv)) { + return rv; + } + + if (NS_WARN_IF(!IndexedDatabaseManager::GetOrCreate())) { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +void +RuntimeService::Shutdown() +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(!mShuttingDown); + // That's it, no more workers. + mShuttingDown = true; + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_WARNING_ASSERTION(obs, "Failed to get observer service?!"); + + // Tell anyone that cares that they're about to lose worker support. + if (obs && NS_FAILED(obs->NotifyObservers(nullptr, WORKERS_SHUTDOWN_TOPIC, + nullptr))) { + NS_WARNING("NotifyObservers failed!"); + } + + { + MutexAutoLock lock(mMutex); + + AutoTArray<WorkerPrivate*, 100> workers; + AddAllTopLevelWorkersToArray(workers); + + if (!workers.IsEmpty()) { + // Cancel all top-level workers. + { + MutexAutoUnlock unlock(mMutex); + + for (uint32_t index = 0; index < workers.Length(); index++) { + if (!workers[index]->Kill()) { + NS_WARNING("Failed to cancel worker!"); + } + } + } + } + } +} + +// This spins the event loop until all workers are finished and their threads +// have been joined. +void +RuntimeService::Cleanup() +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_WARNING_ASSERTION(obs, "Failed to get observer service?!"); + + if (mIdleThreadTimer) { + if (NS_FAILED(mIdleThreadTimer->Cancel())) { + NS_WARNING("Failed to cancel idle timer!"); + } + mIdleThreadTimer = nullptr; + } + + { + MutexAutoLock lock(mMutex); + + AutoTArray<WorkerPrivate*, 100> workers; + AddAllTopLevelWorkersToArray(workers); + + if (!workers.IsEmpty()) { + nsIThread* currentThread = NS_GetCurrentThread(); + NS_ASSERTION(currentThread, "This should never be null!"); + + // Shut down any idle threads. + if (!mIdleThreadArray.IsEmpty()) { + AutoTArray<RefPtr<WorkerThread>, 20> idleThreads; + + uint32_t idleThreadCount = mIdleThreadArray.Length(); + idleThreads.SetLength(idleThreadCount); + + for (uint32_t index = 0; index < idleThreadCount; index++) { + NS_ASSERTION(mIdleThreadArray[index].mThread, "Null thread!"); + idleThreads[index].swap(mIdleThreadArray[index].mThread); + } + + mIdleThreadArray.Clear(); + + MutexAutoUnlock unlock(mMutex); + + for (uint32_t index = 0; index < idleThreadCount; index++) { + if (NS_FAILED(idleThreads[index]->Shutdown())) { + NS_WARNING("Failed to shutdown thread!"); + } + } + } + + // And make sure all their final messages have run and all their threads + // have joined. + while (mDomainMap.Count()) { + MutexAutoUnlock unlock(mMutex); + + if (!NS_ProcessNextEvent(currentThread)) { + NS_WARNING("Something bad happened!"); + break; + } + } + } + } + + NS_ASSERTION(!mWindowMap.Count(), "All windows should have been released!"); + + if (mObserved) { + if (NS_FAILED(Preferences::UnregisterCallback(LoadContextOptions, + PREF_JS_OPTIONS_PREFIX, + nullptr)) || + NS_FAILED(Preferences::UnregisterCallback(LoadContextOptions, + PREF_WORKERS_OPTIONS_PREFIX, + nullptr)) || + +#define WORKER_SIMPLE_PREF(name, getter, NAME) \ + NS_FAILED(Preferences::UnregisterCallback( \ + WorkerPrefChanged, \ + name, \ + reinterpret_cast<void*>(WORKERPREF_##NAME))) || +#define WORKER_PREF(name, callback) \ + NS_FAILED(Preferences::UnregisterCallback( \ + callback, \ + name, \ + nullptr)) || +#include "WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + +#ifdef JS_GC_ZEAL + NS_FAILED(Preferences::UnregisterCallback( + LoadGCZealOptions, + PREF_JS_OPTIONS_PREFIX PREF_GCZEAL, + nullptr)) || +#endif + NS_FAILED(Preferences::UnregisterCallback( + LoadJSGCMemoryOptions, + PREF_JS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX, + nullptr)) || + NS_FAILED(Preferences::UnregisterCallback( + LoadJSGCMemoryOptions, + PREF_WORKERS_OPTIONS_PREFIX PREF_MEM_OPTIONS_PREFIX, + nullptr))) { + NS_WARNING("Failed to unregister pref callbacks!"); + } + + if (obs) { + if (NS_FAILED(obs->RemoveObserver(this, GC_REQUEST_OBSERVER_TOPIC))) { + NS_WARNING("Failed to unregister for GC request notifications!"); + } + + if (NS_FAILED(obs->RemoveObserver(this, CC_REQUEST_OBSERVER_TOPIC))) { + NS_WARNING("Failed to unregister for CC request notifications!"); + } + + if (NS_FAILED(obs->RemoveObserver(this, + 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!"); + } + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID); + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + mObserved = false; + } + } + + CleanupOSFileConstants(); + nsLayoutStatics::Release(); +} + +void +RuntimeService::AddAllTopLevelWorkersToArray(nsTArray<WorkerPrivate*>& aWorkers) +{ + for (auto iter = mDomainMap.Iter(); !iter.Done(); iter.Next()) { + + WorkerDomainInfo* aData = iter.UserData(); + +#ifdef DEBUG + for (uint32_t index = 0; index < aData->mActiveWorkers.Length(); index++) { + MOZ_ASSERT(!aData->mActiveWorkers[index]->GetParent(), + "Shouldn't have a parent in this list!"); + } + for (uint32_t index = 0; index < aData->mActiveServiceWorkers.Length(); index++) { + MOZ_ASSERT(!aData->mActiveServiceWorkers[index]->GetParent(), + "Shouldn't have a parent in this list!"); + } +#endif + + aWorkers.AppendElements(aData->mActiveWorkers); + aWorkers.AppendElements(aData->mActiveServiceWorkers); + + // These might not be top-level workers... + for (uint32_t index = 0; index < aData->mQueuedWorkers.Length(); index++) { + WorkerPrivate* worker = aData->mQueuedWorkers[index]; + if (!worker->GetParent()) { + aWorkers.AppendElement(worker); + } + } + } +} + +void +RuntimeService::GetWorkersForWindow(nsPIDOMWindowInner* aWindow, + nsTArray<WorkerPrivate*>& aWorkers) +{ + AssertIsOnMainThread(); + + nsTArray<WorkerPrivate*>* workers; + if (mWindowMap.Get(aWindow, &workers)) { + NS_ASSERTION(!workers->IsEmpty(), "Should have been removed!"); + aWorkers.AppendElements(*workers); + } + else { + NS_ASSERTION(aWorkers.IsEmpty(), "Should be empty!"); + } +} + +void +RuntimeService::CancelWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + + nsTArray<WorkerPrivate*> workers; + GetWorkersForWindow(aWindow, workers); + + if (!workers.IsEmpty()) { + for (uint32_t index = 0; index < workers.Length(); index++) { + WorkerPrivate*& worker = workers[index]; + + if (worker->IsSharedWorker()) { + worker->CloseSharedWorkersForWindow(aWindow); + } else { + worker->Cancel(); + } + } + } +} + +void +RuntimeService::FreezeWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + nsTArray<WorkerPrivate*> workers; + GetWorkersForWindow(aWindow, workers); + + for (uint32_t index = 0; index < workers.Length(); index++) { + workers[index]->Freeze(aWindow); + } +} + +void +RuntimeService::ThawWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + nsTArray<WorkerPrivate*> workers; + GetWorkersForWindow(aWindow, workers); + + for (uint32_t index = 0; index < workers.Length(); index++) { + workers[index]->Thaw(aWindow); + } +} + +void +RuntimeService::SuspendWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + nsTArray<WorkerPrivate*> workers; + GetWorkersForWindow(aWindow, workers); + + for (uint32_t index = 0; index < workers.Length(); index++) { + workers[index]->ParentWindowPaused(); + } +} + +void +RuntimeService::ResumeWorkersForWindow(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + nsTArray<WorkerPrivate*> workers; + GetWorkersForWindow(aWindow, workers); + + for (uint32_t index = 0; index < workers.Length(); index++) { + workers[index]->ParentWindowResumed(); + } +} + +nsresult +RuntimeService::CreateSharedWorker(const GlobalObject& aGlobal, + const nsAString& aScriptURL, + const nsACString& aName, + SharedWorker** aSharedWorker) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal.GetAsSupports()); + MOZ_ASSERT(window); + + JSContext* cx = aGlobal.Context(); + + WorkerLoadInfo loadInfo; + nsresult rv = WorkerPrivate::GetLoadInfo(cx, window, nullptr, aScriptURL, + false, + WorkerPrivate::OverrideLoadGroup, + WorkerTypeShared, &loadInfo); + NS_ENSURE_SUCCESS(rv, rv); + + return CreateSharedWorkerFromLoadInfo(cx, &loadInfo, aScriptURL, aName, + aSharedWorker); +} + +nsresult +RuntimeService::CreateSharedWorkerFromLoadInfo(JSContext* aCx, + WorkerLoadInfo* aLoadInfo, + const nsAString& aScriptURL, + const nsACString& aName, + SharedWorker** aSharedWorker) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aLoadInfo); + MOZ_ASSERT(aLoadInfo->mResolvedScriptURI); + + RefPtr<WorkerPrivate> workerPrivate; + { + MutexAutoLock lock(mMutex); + + WorkerDomainInfo* domainInfo; + SharedWorkerInfo* sharedWorkerInfo; + + nsCString scriptSpec; + nsresult rv = aLoadInfo->mResolvedScriptURI->GetSpec(scriptSpec); + NS_ENSURE_SUCCESS(rv, rv); + + MOZ_ASSERT(aLoadInfo->mPrincipal); + nsAutoCString key; + GenerateSharedWorkerKey(scriptSpec, aName, + BasePrincipal::Cast(aLoadInfo->mPrincipal)->OriginAttributesRef(), key); + + if (mDomainMap.Get(aLoadInfo->mDomain, &domainInfo) && + domainInfo->mSharedWorkerInfos.Get(key, &sharedWorkerInfo)) { + workerPrivate = sharedWorkerInfo->mWorkerPrivate; + } + } + + // Keep a reference to the window before spawning the worker. If the worker is + // a Shared/Service worker and the worker script loads and executes before + // the SharedWorker object itself is created before then WorkerScriptLoaded() + // will reset the loadInfo's window. + nsCOMPtr<nsPIDOMWindowInner> window = aLoadInfo->mWindow; + + // shouldAttachToWorkerPrivate tracks whether our SharedWorker should actually + // get attached to the WorkerPrivate we're using. It will become false if the + // WorkerPrivate already exists and its secure context state doesn't match + // what we want for the new SharedWorker. + bool shouldAttachToWorkerPrivate = true; + bool created = false; + ErrorResult rv; + if (!workerPrivate) { + workerPrivate = + WorkerPrivate::Constructor(aCx, aScriptURL, false, + WorkerTypeShared, aName, aLoadInfo, rv); + NS_ENSURE_TRUE(workerPrivate, rv.StealNSResult()); + + created = true; + } else { + // Check whether the secure context state matches. The current compartment + // of aCx is the compartment of the SharedWorker constructor that was + // invoked, which is the compartment of the document that will be hooked up + // to the worker, so that's what we want to check. + shouldAttachToWorkerPrivate = + workerPrivate->IsSecureContext() == + JS_GetIsSecureContext(js::GetContextCompartment(aCx)); + + // If we're attaching to an existing SharedWorker private, then we + // must update the overriden load group to account for our document's + // load group. + if (shouldAttachToWorkerPrivate) { + workerPrivate->UpdateOverridenLoadGroup(aLoadInfo->mLoadGroup); + } + } + + // We don't actually care about this MessageChannel, but we use it to 'steal' + // its 2 connected ports. + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(window); + RefPtr<MessageChannel> channel = MessageChannel::Constructor(global, rv); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + RefPtr<SharedWorker> sharedWorker = new SharedWorker(window, workerPrivate, + channel->Port1()); + + if (!shouldAttachToWorkerPrivate) { + // We're done here. Just queue up our error event and return our + // dead-on-arrival SharedWorker. + RefPtr<AsyncEventDispatcher> errorEvent = + new AsyncEventDispatcher(sharedWorker, NS_LITERAL_STRING("error"), false); + errorEvent->PostDOMEvent(); + sharedWorker.forget(aSharedWorker); + return NS_OK; + } + + if (!workerPrivate->RegisterSharedWorker(sharedWorker, channel->Port2())) { + NS_WARNING("Worker is unreachable, this shouldn't happen!"); + sharedWorker->Close(); + return NS_ERROR_FAILURE; + } + + // This is normally handled in RegisterWorker, but that wasn't called if the + // worker already existed. + if (!created) { + nsTArray<WorkerPrivate*>* windowArray; + if (!mWindowMap.Get(window, &windowArray)) { + windowArray = new nsTArray<WorkerPrivate*>(1); + mWindowMap.Put(window, windowArray); + } + + if (!windowArray->Contains(workerPrivate)) { + windowArray->AppendElement(workerPrivate); + } + } + + sharedWorker.forget(aSharedWorker); + return NS_OK; +} + +void +RuntimeService::ForgetSharedWorker(WorkerPrivate* aWorkerPrivate) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerPrivate->IsSharedWorker()); + + MutexAutoLock lock(mMutex); + + WorkerDomainInfo* domainInfo; + if (mDomainMap.Get(aWorkerPrivate->Domain(), &domainInfo)) { + RemoveSharedWorker(domainInfo, aWorkerPrivate); + } +} + +void +RuntimeService::NoteIdleThread(WorkerThread* aThread) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aThread); + + bool shutdownThread = mShuttingDown; + bool scheduleTimer = false; + + if (!shutdownThread) { + static TimeDuration timeout = + TimeDuration::FromSeconds(IDLE_THREAD_TIMEOUT_SEC); + + TimeStamp expirationTime = TimeStamp::NowLoRes() + timeout; + + MutexAutoLock lock(mMutex); + + uint32_t previousIdleCount = mIdleThreadArray.Length(); + + if (previousIdleCount < MAX_IDLE_THREADS) { + IdleThreadInfo* info = mIdleThreadArray.AppendElement(); + info->mThread = aThread; + info->mExpirationTime = expirationTime; + + scheduleTimer = previousIdleCount == 0; + } else { + shutdownThread = true; + } + } + + MOZ_ASSERT_IF(shutdownThread, !scheduleTimer); + MOZ_ASSERT_IF(scheduleTimer, !shutdownThread); + + // Too many idle threads, just shut this one down. + if (shutdownThread) { + MOZ_ALWAYS_SUCCEEDS(aThread->Shutdown()); + } else if (scheduleTimer) { + MOZ_ALWAYS_SUCCEEDS( + mIdleThreadTimer->InitWithFuncCallback(ShutdownIdleThreads, + nullptr, + IDLE_THREAD_TIMEOUT_SEC * 1000, + nsITimer::TYPE_ONE_SHOT)); + } +} + +void +RuntimeService::UpdateAllWorkerContextOptions() +{ + BROADCAST_ALL_WORKERS(UpdateContextOptions, sDefaultJSSettings.contextOptions); +} + +void +RuntimeService::UpdateAppNameOverridePreference(const nsAString& aValue) +{ + AssertIsOnMainThread(); + mNavigatorProperties.mAppNameOverridden = aValue; +} + +void +RuntimeService::UpdateAppVersionOverridePreference(const nsAString& aValue) +{ + AssertIsOnMainThread(); + mNavigatorProperties.mAppVersionOverridden = aValue; +} + +void +RuntimeService::UpdatePlatformOverridePreference(const nsAString& aValue) +{ + AssertIsOnMainThread(); + mNavigatorProperties.mPlatformOverridden = aValue; +} + +void +RuntimeService::UpdateAllWorkerPreference(WorkerPreference aPref, bool aValue) +{ + BROADCAST_ALL_WORKERS(UpdatePreference, aPref, aValue); +} + +void +RuntimeService::UpdateAllWorkerLanguages(const nsTArray<nsString>& aLanguages) +{ + MOZ_ASSERT(NS_IsMainThread()); + + mNavigatorProperties.mLanguages = aLanguages; + BROADCAST_ALL_WORKERS(UpdateLanguages, aLanguages); +} + +void +RuntimeService::UpdateAllWorkerMemoryParameter(JSGCParamKey aKey, + uint32_t aValue) +{ + BROADCAST_ALL_WORKERS(UpdateJSWorkerMemoryParameter, aKey, aValue); +} + +#ifdef JS_GC_ZEAL +void +RuntimeService::UpdateAllWorkerGCZeal() +{ + BROADCAST_ALL_WORKERS(UpdateGCZeal, sDefaultJSSettings.gcZeal, + sDefaultJSSettings.gcZealFrequency); +} +#endif + +void +RuntimeService::GarbageCollectAllWorkers(bool aShrinking) +{ + BROADCAST_ALL_WORKERS(GarbageCollect, aShrinking); +} + +void +RuntimeService::CycleCollectAllWorkers() +{ + BROADCAST_ALL_WORKERS(CycleCollect, /* dummy = */ false); +} + +void +RuntimeService::SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline) +{ + BROADCAST_ALL_WORKERS(OfflineStatusChangeEvent, aIsOffline); +} + +void +RuntimeService::MemoryPressureAllWorkers() +{ + BROADCAST_ALL_WORKERS(MemoryPressure, /* dummy = */ false); +} + +uint32_t +RuntimeService::ClampedHardwareConcurrency() const +{ + // This needs to be atomic, because multiple workers, and even mainthread, + // could race to initialize it at once. + static Atomic<uint32_t> clampedHardwareConcurrency; + + // No need to loop here: if compareExchange fails, that just means that some + // other worker has initialized numberOfProcessors, so we're good to go. + if (!clampedHardwareConcurrency) { + int32_t numberOfProcessors = PR_GetNumberOfProcessors(); + if (numberOfProcessors <= 0) { + numberOfProcessors = 1; // Must be one there somewhere + } + uint32_t clampedValue = std::min(uint32_t(numberOfProcessors), + gMaxHardwareConcurrency); + clampedHardwareConcurrency.compareExchange(0, clampedValue); + } + + return clampedHardwareConcurrency; +} + +// nsISupports +NS_IMPL_ISUPPORTS(RuntimeService, nsIObserver) + +// nsIObserver +NS_IMETHODIMP +RuntimeService::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + AssertIsOnMainThread(); + + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + Shutdown(); + return NS_OK; + } + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID)) { + Cleanup(); + return NS_OK; + } + if (!strcmp(aTopic, GC_REQUEST_OBSERVER_TOPIC)) { + GarbageCollectAllWorkers(/* shrinking = */ false); + return NS_OK; + } + if (!strcmp(aTopic, CC_REQUEST_OBSERVER_TOPIC)) { + CycleCollectAllWorkers(); + return NS_OK; + } + if (!strcmp(aTopic, MEMORY_PRESSURE_OBSERVER_TOPIC)) { + GarbageCollectAllWorkers(/* shrinking = */ true); + CycleCollectAllWorkers(); + MemoryPressureAllWorkers(); + return NS_OK; + } + if (!strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC)) { + SendOfflineStatusChangeEventToAllWorkers(NS_IsOffline()); + return NS_OK; + } + + NS_NOTREACHED("Unknown observer topic!"); + return NS_OK; +} + +/* static */ void +RuntimeService::WorkerPrefChanged(const char* aPrefName, void* aClosure) +{ + AssertIsOnMainThread(); + + const WorkerPreference key = + static_cast<WorkerPreference>(reinterpret_cast<uintptr_t>(aClosure)); + + switch (key) { +#define WORKER_SIMPLE_PREF(name, getter, NAME) case WORKERPREF_##NAME: +#define WORKER_PREF(name, callback) +#include "WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + sDefaultPreferences[key] = Preferences::GetBool(aPrefName, false); + break; + + default: + MOZ_ASSERT_UNREACHABLE("Invalid pref key"); + break; + } + + RuntimeService* rts = RuntimeService::GetService(); + if (rts) { + rts->UpdateAllWorkerPreference(key, sDefaultPreferences[key]); + } +} + +void +RuntimeService::JSVersionChanged(const char* /* aPrefName */, void* /* aClosure */) +{ + AssertIsOnMainThread(); + + bool useLatest = Preferences::GetBool("dom.workers.latestJSVersion", false); + JS::CompartmentOptions& options = sDefaultJSSettings.content.compartmentOptions; + options.behaviors().setVersion(useLatest ? JSVERSION_LATEST : JSVERSION_DEFAULT); +} + +bool +LogViolationDetailsRunnable::MainThreadRun() +{ + AssertIsOnMainThread(); + + nsIContentSecurityPolicy* csp = mWorkerPrivate->GetCSP(); + if (csp) { + NS_NAMED_LITERAL_STRING(scriptSample, + "Call to eval() or related function blocked by CSP."); + if (mWorkerPrivate->GetReportCSPViolations()) { + csp->LogViolationDetails(nsIContentSecurityPolicy::VIOLATION_TYPE_EVAL, + mFileName, scriptSample, mLineNum, + EmptyString(), EmptyString()); + } + } + + return true; +} + +NS_IMPL_ISUPPORTS_INHERITED0(WorkerThreadPrimaryRunnable, Runnable) + +NS_IMETHODIMP +WorkerThreadPrimaryRunnable::Run() +{ + using mozilla::ipc::BackgroundChild; + + char stackBaseGuess; + + PR_SetCurrentThreadName("DOM Worker"); + + nsAutoCString threadName; + threadName.AssignLiteral("DOM Worker '"); + threadName.Append(NS_LossyConvertUTF16toASCII(mWorkerPrivate->ScriptURL())); + threadName.Append('\''); + + profiler_register_thread(threadName.get(), &stackBaseGuess); + + // Note: SynchronouslyCreateForCurrentThread() must be called prior to + // mWorkerPrivate->SetThread() in order to avoid accidentally consuming + // worker messages here. + if (NS_WARN_IF(!BackgroundChild::SynchronouslyCreateForCurrentThread())) { + // XXX need to fire an error at parent. + // Failed in creating BackgroundChild: probably in shutdown. Continue to run + // without BackgroundChild created. + } + + class MOZ_STACK_CLASS SetThreadHelper final + { + // Raw pointer: this class is on the stack. + WorkerPrivate* mWorkerPrivate; + + public: + SetThreadHelper(WorkerPrivate* aWorkerPrivate, WorkerThread* aThread) + : mWorkerPrivate(aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aThread); + + mWorkerPrivate->SetThread(aThread); + } + + ~SetThreadHelper() + { + if (mWorkerPrivate) { + mWorkerPrivate->SetThread(nullptr); + } + } + + void Nullify() + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->SetThread(nullptr); + mWorkerPrivate = nullptr; + } + }; + + SetThreadHelper threadHelper(mWorkerPrivate, mThread); + + mWorkerPrivate->AssertIsOnWorkerThread(); + + { + nsCycleCollector_startup(); + + WorkerJSContext context(mWorkerPrivate); + nsresult rv = context.Initialize(mParentContext); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + JSContext* cx = context.Context(); + + if (!InitJSContextForWorker(mWorkerPrivate, cx)) { + // XXX need to fire an error at parent. + NS_ERROR("Failed to create context!"); + return NS_ERROR_FAILURE; + } + + { +#ifdef MOZ_ENABLE_PROFILER_SPS + PseudoStack* stack = mozilla_get_pseudo_stack(); + if (stack) { + stack->sampleContext(cx); + } +#endif + + { + JSAutoRequest ar(cx); + + mWorkerPrivate->DoRunLoop(cx); + // The AutoJSAPI in DoRunLoop should have reported any exceptions left + // on cx. Note that we still need the JSAutoRequest above because + // AutoJSAPI on workers does NOT enter a request! + MOZ_ASSERT(!JS_IsExceptionPending(cx)); + } + + BackgroundChild::CloseForCurrentThread(); + +#ifdef MOZ_ENABLE_PROFILER_SPS + if (stack) { + stack->sampleContext(nullptr); + } +#endif + } + + // There may still be runnables on the debugger event queue that hold a + // strong reference to the debugger global scope. These runnables are not + // visible to the cycle collector, so we need to make sure to clear the + // debugger event queue before we try to destroy the context. If we don't, + // the garbage collector will crash. + mWorkerPrivate->ClearDebuggerEventQueue(); + + // Perform a full GC. This will collect the main worker global and CC, + // which should break all cycles that touch JS. + JS_GC(cx); + + // Before shutting down the cycle collector we need to do one more pass + // through the event loop to clean up any C++ objects that need deferred + // cleanup. + mWorkerPrivate->ClearMainEventQueue(WorkerPrivate::WorkerRan); + + // Now WorkerJSContext goes out of scope and its destructor will shut + // down the cycle collector. This breaks any remaining cycles and collects + // any remaining C++ objects. + } + + threadHelper.Nullify(); + + mWorkerPrivate->ScheduleDeletion(WorkerPrivate::WorkerRan); + + // It is no longer safe to touch mWorkerPrivate. + mWorkerPrivate = nullptr; + + // Now recycle this thread. + nsCOMPtr<nsIThread> mainThread = do_GetMainThread(); + MOZ_ASSERT(mainThread); + + RefPtr<FinishedRunnable> finishedRunnable = + new FinishedRunnable(mThread.forget()); + MOZ_ALWAYS_SUCCEEDS(mainThread->Dispatch(finishedRunnable, + NS_DISPATCH_NORMAL)); + + profiler_unregister_thread(); + return NS_OK; +} + +NS_IMPL_ISUPPORTS_INHERITED0(WorkerThreadPrimaryRunnable::FinishedRunnable, + Runnable) + +NS_IMETHODIMP +WorkerThreadPrimaryRunnable::FinishedRunnable::Run() +{ + AssertIsOnMainThread(); + + RefPtr<WorkerThread> thread; + mThread.swap(thread); + + RuntimeService* rts = RuntimeService::GetService(); + if (rts) { + rts->NoteIdleThread(thread); + } + else if (thread->ShutdownRequired()) { + MOZ_ALWAYS_SUCCEEDS(thread->Shutdown()); + } + + return NS_OK; +} diff --git a/dom/workers/RuntimeService.h b/dom/workers/RuntimeService.h new file mode 100644 index 000000000..2e5cc1dad --- /dev/null +++ b/dom/workers/RuntimeService.h @@ -0,0 +1,287 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_runtimeservice_h__ +#define mozilla_dom_workers_runtimeservice_h__ + +#include "Workers.h" + +#include "nsIObserver.h" + +#include "mozilla/dom/BindingDeclarations.h" +#include "nsClassHashtable.h" +#include "nsHashKeys.h" +#include "nsTArray.h" + +class nsITimer; +class nsPIDOMWindowInner; + +BEGIN_WORKERS_NAMESPACE + +class SharedWorker; +class WorkerThread; + +class RuntimeService final : public nsIObserver +{ + struct SharedWorkerInfo + { + WorkerPrivate* mWorkerPrivate; + nsCString mScriptSpec; + nsCString mName; + + SharedWorkerInfo(WorkerPrivate* aWorkerPrivate, + const nsACString& aScriptSpec, + const nsACString& aName) + : mWorkerPrivate(aWorkerPrivate), mScriptSpec(aScriptSpec), mName(aName) + { } + }; + + struct WorkerDomainInfo + { + nsCString mDomain; + nsTArray<WorkerPrivate*> mActiveWorkers; + nsTArray<WorkerPrivate*> mActiveServiceWorkers; + nsTArray<WorkerPrivate*> mQueuedWorkers; + nsClassHashtable<nsCStringHashKey, SharedWorkerInfo> mSharedWorkerInfos; + uint32_t mChildWorkerCount; + + WorkerDomainInfo() + : mActiveWorkers(1), mChildWorkerCount(0) + { } + + uint32_t + ActiveWorkerCount() const + { + return mActiveWorkers.Length() + + mChildWorkerCount; + } + + uint32_t + ActiveServiceWorkerCount() const + { + return mActiveServiceWorkers.Length(); + } + + bool + HasNoWorkers() const + { + return ActiveWorkerCount() == 0 && + ActiveServiceWorkerCount() == 0; + } + }; + + struct IdleThreadInfo; + + mozilla::Mutex mMutex; + + // Protected by mMutex. + nsClassHashtable<nsCStringHashKey, WorkerDomainInfo> mDomainMap; + + // Protected by mMutex. + nsTArray<IdleThreadInfo> mIdleThreadArray; + + // *Not* protected by mMutex. + nsClassHashtable<nsPtrHashKey<nsPIDOMWindowInner>, + nsTArray<WorkerPrivate*> > mWindowMap; + + // Only used on the main thread. + nsCOMPtr<nsITimer> mIdleThreadTimer; + + static JSSettings sDefaultJSSettings; + static bool sDefaultPreferences[WORKERPREF_COUNT]; + +public: + struct NavigatorProperties + { + nsString mAppName; + nsString mAppNameOverridden; + nsString mAppVersion; + nsString mAppVersionOverridden; + nsString mPlatform; + nsString mPlatformOverridden; + nsTArray<nsString> mLanguages; + }; + +private: + NavigatorProperties mNavigatorProperties; + + // True when the observer service holds a reference to this object. + bool mObserved; + bool mShuttingDown; + bool mNavigatorPropertiesLoaded; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + + static RuntimeService* + GetOrCreateService(); + + static RuntimeService* + GetService(); + + bool + RegisterWorker(WorkerPrivate* aWorkerPrivate); + + void + UnregisterWorker(WorkerPrivate* aWorkerPrivate); + + void + RemoveSharedWorker(WorkerDomainInfo* aDomainInfo, + WorkerPrivate* aWorkerPrivate); + + void + CancelWorkersForWindow(nsPIDOMWindowInner* aWindow); + + void + FreezeWorkersForWindow(nsPIDOMWindowInner* aWindow); + + void + ThawWorkersForWindow(nsPIDOMWindowInner* aWindow); + + void + SuspendWorkersForWindow(nsPIDOMWindowInner* aWindow); + + void + ResumeWorkersForWindow(nsPIDOMWindowInner* aWindow); + + nsresult + CreateSharedWorker(const GlobalObject& aGlobal, + const nsAString& aScriptURL, + const nsACString& aName, + SharedWorker** aSharedWorker); + + void + ForgetSharedWorker(WorkerPrivate* aWorkerPrivate); + + const NavigatorProperties& + GetNavigatorProperties() const + { + return mNavigatorProperties; + } + + void + NoteIdleThread(WorkerThread* aThread); + + static void + GetDefaultJSSettings(JSSettings& aSettings) + { + AssertIsOnMainThread(); + aSettings = sDefaultJSSettings; + } + + static void + GetDefaultPreferences(bool aPreferences[WORKERPREF_COUNT]) + { + AssertIsOnMainThread(); + memcpy(aPreferences, sDefaultPreferences, WORKERPREF_COUNT * sizeof(bool)); + } + + static void + SetDefaultContextOptions(const JS::ContextOptions& aContextOptions) + { + AssertIsOnMainThread(); + sDefaultJSSettings.contextOptions = aContextOptions; + } + + void + UpdateAppNameOverridePreference(const nsAString& aValue); + + void + UpdateAppVersionOverridePreference(const nsAString& aValue); + + void + UpdatePlatformOverridePreference(const nsAString& aValue); + + void + UpdateAllWorkerContextOptions(); + + void + UpdateAllWorkerLanguages(const nsTArray<nsString>& aLanguages); + + void + UpdateAllWorkerPreference(WorkerPreference aPref, bool aValue); + + static void + SetDefaultJSGCSettings(JSGCParamKey aKey, uint32_t aValue) + { + AssertIsOnMainThread(); + sDefaultJSSettings.ApplyGCSetting(aKey, aValue); + } + + void + UpdateAllWorkerMemoryParameter(JSGCParamKey aKey, uint32_t aValue); + +#ifdef JS_GC_ZEAL + static void + SetDefaultGCZeal(uint8_t aGCZeal, uint32_t aFrequency) + { + AssertIsOnMainThread(); + sDefaultJSSettings.gcZeal = aGCZeal; + sDefaultJSSettings.gcZealFrequency = aFrequency; + } + + void + UpdateAllWorkerGCZeal(); +#endif + + void + GarbageCollectAllWorkers(bool aShrinking); + + void + CycleCollectAllWorkers(); + + void + SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline); + + void + MemoryPressureAllWorkers(); + + uint32_t ClampedHardwareConcurrency() const; + +private: + RuntimeService(); + ~RuntimeService(); + + nsresult + Init(); + + void + Shutdown(); + + void + Cleanup(); + + void + AddAllTopLevelWorkersToArray(nsTArray<WorkerPrivate*>& aWorkers); + + void + GetWorkersForWindow(nsPIDOMWindowInner* aWindow, + nsTArray<WorkerPrivate*>& aWorkers); + + bool + ScheduleWorker(WorkerPrivate* aWorkerPrivate); + + static void + ShutdownIdleThreads(nsITimer* aTimer, void* aClosure); + + static void + WorkerPrefChanged(const char* aPrefName, void* aClosure); + + static void + JSVersionChanged(const char* aPrefName, void* aClosure); + + nsresult + CreateSharedWorkerFromLoadInfo(JSContext* aCx, + WorkerLoadInfo* aLoadInfo, + const nsAString& aScriptURL, + const nsACString& aName, + SharedWorker** aSharedWorker); +}; + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_runtimeservice_h__ */ diff --git a/dom/workers/ScriptLoader.cpp b/dom/workers/ScriptLoader.cpp new file mode 100644 index 000000000..46545e737 --- /dev/null +++ b/dom/workers/ScriptLoader.cpp @@ -0,0 +1,2290 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ScriptLoader.h" + +#include "nsIChannel.h" +#include "nsIContentPolicy.h" +#include "nsIContentSecurityPolicy.h" +#include "nsIDocShell.h" +#include "nsIDOMDocument.h" +#include "nsIHttpChannel.h" +#include "nsIHttpChannelInternal.h" +#include "nsIInputStreamPump.h" +#include "nsIIOService.h" +#include "nsIProtocolHandler.h" +#include "nsIScriptError.h" +#include "nsIScriptSecurityManager.h" +#include "nsIStreamLoader.h" +#include "nsIStreamListenerTee.h" +#include "nsIThreadRetargetableRequest.h" +#include "nsIURI.h" + +#include "jsapi.h" +#include "jsfriendapi.h" +#include "nsError.h" +#include "nsContentPolicyUtils.h" +#include "nsContentUtils.h" +#include "nsDocShellCID.h" +#include "nsISupportsPrimitives.h" +#include "nsNetUtil.h" +#include "nsIPipe.h" +#include "nsIOutputStream.h" +#include "nsPrintfCString.h" +#include "nsScriptLoader.h" +#include "nsString.h" +#include "nsStreamUtils.h" +#include "nsTArray.h" +#include "nsThreadUtils.h" +#include "nsXPCOM.h" +#include "xpcpublic.h" + +#include "mozilla/Assertions.h" +#include "mozilla/LoadContext.h" +#include "mozilla/Maybe.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/dom/CacheBinding.h" +#include "mozilla/dom/cache/CacheTypes.h" +#include "mozilla/dom/cache/Cache.h" +#include "mozilla/dom/cache/CacheStorage.h" +#include "mozilla/dom/ChannelInfo.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/InternalResponse.h" +#include "mozilla/dom/nsCSPService.h" +#include "mozilla/dom/nsCSPUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/Response.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/SRILogHelper.h" +#include "mozilla/UniquePtr.h" +#include "Principal.h" +#include "WorkerHolder.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" + +#define MAX_CONCURRENT_SCRIPTS 1000 + +USING_WORKERS_NAMESPACE + +using namespace mozilla; +using namespace mozilla::dom; +using mozilla::dom::cache::Cache; +using mozilla::dom::cache::CacheStorage; +using mozilla::ipc::PrincipalInfo; + +namespace { + +nsIURI* +GetBaseURI(bool aIsMainScript, WorkerPrivate* aWorkerPrivate) +{ + MOZ_ASSERT(aWorkerPrivate); + nsIURI* baseURI; + WorkerPrivate* parentWorker = aWorkerPrivate->GetParent(); + if (aIsMainScript) { + if (parentWorker) { + baseURI = parentWorker->GetBaseURI(); + NS_ASSERTION(baseURI, "Should have been set already!"); + } + else { + // May be null. + baseURI = aWorkerPrivate->GetBaseURI(); + } + } + else { + baseURI = aWorkerPrivate->GetBaseURI(); + NS_ASSERTION(baseURI, "Should have been set already!"); + } + + return baseURI; +} + +nsresult +ChannelFromScriptURL(nsIPrincipal* principal, + nsIURI* baseURI, + nsIDocument* parentDoc, + nsILoadGroup* loadGroup, + nsIIOService* ios, + nsIScriptSecurityManager* secMan, + const nsAString& aScriptURL, + bool aIsMainScript, + WorkerScriptType aWorkerScriptType, + nsContentPolicyType aContentPolicyType, + nsLoadFlags aLoadFlags, + bool aDefaultURIEncoding, + nsIChannel** aChannel) +{ + AssertIsOnMainThread(); + + nsresult rv; + nsCOMPtr<nsIURI> uri; + + if (aDefaultURIEncoding) { + rv = NS_NewURI(getter_AddRefs(uri), aScriptURL, nullptr, baseURI); + } else { + rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri), + aScriptURL, parentDoc, + baseURI); + } + + if (NS_FAILED(rv)) { + return NS_ERROR_DOM_SYNTAX_ERR; + } + + // If we have the document, use it. Unfortunately, for dedicated workers + // 'parentDoc' ends up being the parent document, which is not the document + // that we want to use. So make sure to avoid using 'parentDoc' in that + // situation. + if (parentDoc && parentDoc->NodePrincipal() != principal) { + parentDoc = nullptr; + } + + aLoadFlags |= nsIChannel::LOAD_CLASSIFY_URI; + uint32_t secFlags = aIsMainScript ? nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED + : nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS; + + if (aWorkerScriptType == DebuggerScript) { + // A DebuggerScript needs to be a local resource like chrome: or resource: + bool isUIResource = false; + rv = NS_URIChainHasFlags(uri, nsIProtocolHandler::URI_IS_UI_RESOURCE, + &isUIResource); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (!isUIResource) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + secFlags |= nsILoadInfo::SEC_ALLOW_CHROME; + } + + // Note: this is for backwards compatibility and goes against spec. + // We should find a better solution. + bool isData = false; + if (aIsMainScript && NS_SUCCEEDED(uri->SchemeIs("data", &isData)) && isData) { + secFlags = nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL; + } + + nsCOMPtr<nsIChannel> channel; + // If we have the document, use it. Unfortunately, for dedicated workers + // 'parentDoc' ends up being the parent document, which is not the document + // that we want to use. So make sure to avoid using 'parentDoc' in that + // situation. + if (parentDoc && parentDoc->NodePrincipal() == principal) { + rv = NS_NewChannel(getter_AddRefs(channel), + uri, + parentDoc, + secFlags, + aContentPolicyType, + loadGroup, + nullptr, // aCallbacks + aLoadFlags, + ios); + } else { + // We must have a loadGroup with a load context for the principal to + // traverse the channel correctly. + MOZ_ASSERT(loadGroup); + MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(loadGroup, principal)); + + rv = NS_NewChannel(getter_AddRefs(channel), + uri, + principal, + secFlags, + aContentPolicyType, + loadGroup, + nullptr, // aCallbacks + aLoadFlags, + ios); + } + + NS_ENSURE_SUCCESS(rv, rv); + + if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel)) { + rv = nsContentUtils::SetFetchReferrerURIWithPolicy(principal, parentDoc, + httpChannel, mozilla::net::RP_Default); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + channel.forget(aChannel); + return rv; +} + +struct ScriptLoadInfo +{ + ScriptLoadInfo() + : mScriptTextBuf(nullptr) + , mScriptTextLength(0) + , mLoadResult(NS_ERROR_NOT_INITIALIZED) + , mLoadingFinished(false) + , mExecutionScheduled(false) + , mExecutionResult(false) + , mCacheStatus(Uncached) + { } + + ~ScriptLoadInfo() + { + if (mScriptTextBuf) { + js_free(mScriptTextBuf); + } + } + + bool + ReadyToExecute() + { + return !mChannel && NS_SUCCEEDED(mLoadResult) && !mExecutionScheduled; + } + + nsString mURL; + + // This full URL string is populated only if this object is used in a + // ServiceWorker. + nsString mFullURL; + + // This promise is set only when the script is for a ServiceWorker but + // it's not in the cache yet. The promise is resolved when the full body is + // stored into the cache. mCachePromise will be set to nullptr after + // resolution. + RefPtr<Promise> mCachePromise; + + // The reader stream the cache entry should be filled from, for those cases + // when we're going to have an mCachePromise. + nsCOMPtr<nsIInputStream> mCacheReadStream; + + nsCOMPtr<nsIChannel> mChannel; + char16_t* mScriptTextBuf; + size_t mScriptTextLength; + + nsresult mLoadResult; + bool mLoadingFinished; + bool mExecutionScheduled; + bool mExecutionResult; + + enum CacheStatus { + // By default a normal script is just loaded from the network. But for + // ServiceWorkers, we have to check if the cache contains the script and + // load it from the cache. + Uncached, + + WritingToCache, + + ReadingFromCache, + + // This script has been loaded from the ServiceWorker cache. + Cached, + + // This script must be stored in the ServiceWorker cache. + ToBeCached, + + // Something went wrong or the worker went away. + Cancel + }; + + CacheStatus mCacheStatus; + + Maybe<bool> mMutedErrorFlag; + + bool Finished() const + { + return mLoadingFinished && !mCachePromise && !mChannel; + } +}; + +class ScriptLoaderRunnable; + +class ScriptExecutorRunnable final : public MainThreadWorkerSyncRunnable +{ + ScriptLoaderRunnable& mScriptLoader; + bool mIsWorkerScript; + uint32_t mFirstIndex; + uint32_t mLastIndex; + +public: + ScriptExecutorRunnable(ScriptLoaderRunnable& aScriptLoader, + nsIEventTarget* aSyncLoopTarget, + bool aIsWorkerScript, + uint32_t aFirstIndex, + uint32_t aLastIndex); + +private: + ~ScriptExecutorRunnable() + { } + + virtual bool + IsDebuggerRunnable() const override; + + virtual bool + PreRun(WorkerPrivate* aWorkerPrivate) override; + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override; + + virtual void + PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult) + override; + + nsresult + Cancel() override; + + void + ShutdownScriptLoader(JSContext* aCx, + WorkerPrivate* aWorkerPrivate, + bool aResult, + bool aMutedError); + + void LogExceptionToConsole(JSContext* aCx, + WorkerPrivate* WorkerPrivate); +}; + +class CacheScriptLoader; + +class CacheCreator final : public PromiseNativeHandler +{ +public: + NS_DECL_ISUPPORTS + + explicit CacheCreator(WorkerPrivate* aWorkerPrivate) + : mCacheName(aWorkerPrivate->ServiceWorkerCacheName()) + , mOriginAttributes(aWorkerPrivate->GetOriginAttributes()) + { + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + MOZ_ASSERT(aWorkerPrivate->LoadScriptAsPartOfLoadingServiceWorkerScript()); + AssertIsOnMainThread(); + } + + void + AddLoader(CacheScriptLoader* aLoader) + { + AssertIsOnMainThread(); + MOZ_ASSERT(!mCacheStorage); + mLoaders.AppendElement(aLoader); + } + + virtual void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + virtual void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + // Try to load from cache with aPrincipal used for cache access. + nsresult + Load(nsIPrincipal* aPrincipal); + + Cache* + Cache_() const + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCache); + return mCache; + } + + nsIGlobalObject* + Global() const + { + AssertIsOnMainThread(); + MOZ_ASSERT(mSandboxGlobalObject); + return mSandboxGlobalObject; + } + + void + DeleteCache(); + +private: + ~CacheCreator() + { + } + + nsresult + CreateCacheStorage(nsIPrincipal* aPrincipal); + + void + FailLoaders(nsresult aRv); + + RefPtr<Cache> mCache; + RefPtr<CacheStorage> mCacheStorage; + nsCOMPtr<nsIGlobalObject> mSandboxGlobalObject; + nsTArray<RefPtr<CacheScriptLoader>> mLoaders; + + nsString mCacheName; + PrincipalOriginAttributes mOriginAttributes; +}; + +NS_IMPL_ISUPPORTS0(CacheCreator) + +class CacheScriptLoader final : public PromiseNativeHandler + , public nsIStreamLoaderObserver +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISTREAMLOADEROBSERVER + + CacheScriptLoader(WorkerPrivate* aWorkerPrivate, ScriptLoadInfo& aLoadInfo, + uint32_t aIndex, bool aIsWorkerScript, + ScriptLoaderRunnable* aRunnable) + : mLoadInfo(aLoadInfo) + , mIndex(aIndex) + , mRunnable(aRunnable) + , mIsWorkerScript(aIsWorkerScript) + , mFailed(false) + { + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + mBaseURI = GetBaseURI(mIsWorkerScript, aWorkerPrivate); + AssertIsOnMainThread(); + } + + void + Fail(nsresult aRv); + + void + Load(Cache* aCache); + + virtual void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + virtual void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + +private: + ~CacheScriptLoader() + { + AssertIsOnMainThread(); + } + + ScriptLoadInfo& mLoadInfo; + uint32_t mIndex; + RefPtr<ScriptLoaderRunnable> mRunnable; + bool mIsWorkerScript; + bool mFailed; + nsCOMPtr<nsIInputStreamPump> mPump; + nsCOMPtr<nsIURI> mBaseURI; + mozilla::dom::ChannelInfo mChannelInfo; + UniquePtr<PrincipalInfo> mPrincipalInfo; +}; + +NS_IMPL_ISUPPORTS(CacheScriptLoader, nsIStreamLoaderObserver) + +class CachePromiseHandler final : public PromiseNativeHandler +{ +public: + NS_DECL_ISUPPORTS + + CachePromiseHandler(ScriptLoaderRunnable* aRunnable, + ScriptLoadInfo& aLoadInfo, + uint32_t aIndex) + : mRunnable(aRunnable) + , mLoadInfo(aLoadInfo) + , mIndex(aIndex) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mRunnable); + } + + virtual void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + virtual void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + +private: + ~CachePromiseHandler() + { + AssertIsOnMainThread(); + } + + RefPtr<ScriptLoaderRunnable> mRunnable; + ScriptLoadInfo& mLoadInfo; + uint32_t mIndex; +}; + +NS_IMPL_ISUPPORTS0(CachePromiseHandler) + +class LoaderListener final : public nsIStreamLoaderObserver + , public nsIRequestObserver +{ +public: + NS_DECL_ISUPPORTS + + LoaderListener(ScriptLoaderRunnable* aRunnable, uint32_t aIndex) + : mRunnable(aRunnable) + , mIndex(aIndex) + { + MOZ_ASSERT(mRunnable); + } + + NS_IMETHOD + OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aStringLen, + const uint8_t* aString) override; + + NS_IMETHOD + OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) override; + + NS_IMETHOD + OnStopRequest(nsIRequest* aRequest, nsISupports* aContext, + nsresult aStatusCode) override + { + // Nothing to do here! + return NS_OK; + } + +private: + ~LoaderListener() {} + + RefPtr<ScriptLoaderRunnable> mRunnable; + uint32_t mIndex; +}; + +NS_IMPL_ISUPPORTS(LoaderListener, nsIStreamLoaderObserver, nsIRequestObserver) + +class ScriptLoaderHolder; + +class ScriptLoaderRunnable final : public nsIRunnable +{ + friend class ScriptExecutorRunnable; + friend class ScriptLoaderHolder; + friend class CachePromiseHandler; + friend class CacheScriptLoader; + friend class LoaderListener; + + WorkerPrivate* mWorkerPrivate; + nsCOMPtr<nsIEventTarget> mSyncLoopTarget; + nsTArray<ScriptLoadInfo> mLoadInfos; + RefPtr<CacheCreator> mCacheCreator; + bool mIsMainScript; + WorkerScriptType mWorkerScriptType; + bool mCanceled; + bool mCanceledMainThread; + ErrorResult& mRv; + +public: + NS_DECL_THREADSAFE_ISUPPORTS + + ScriptLoaderRunnable(WorkerPrivate* aWorkerPrivate, + nsIEventTarget* aSyncLoopTarget, + nsTArray<ScriptLoadInfo>& aLoadInfos, + bool aIsMainScript, + WorkerScriptType aWorkerScriptType, + ErrorResult& aRv) + : mWorkerPrivate(aWorkerPrivate), mSyncLoopTarget(aSyncLoopTarget), + mIsMainScript(aIsMainScript), mWorkerScriptType(aWorkerScriptType), + mCanceled(false), mCanceledMainThread(false), mRv(aRv) + { + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(aSyncLoopTarget); + MOZ_ASSERT_IF(aIsMainScript, aLoadInfos.Length() == 1); + + mLoadInfos.SwapElements(aLoadInfos); + } + +private: + ~ScriptLoaderRunnable() + { } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + nsresult rv = RunInternal(); + if (NS_WARN_IF(NS_FAILED(rv))) { + CancelMainThread(rv); + } + + return NS_OK; + } + + void + LoadingFinished(uint32_t aIndex, nsresult aRv) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + ScriptLoadInfo& loadInfo = mLoadInfos[aIndex]; + + loadInfo.mLoadResult = aRv; + + MOZ_ASSERT(!loadInfo.mLoadingFinished); + loadInfo.mLoadingFinished = true; + + MaybeExecuteFinishedScripts(aIndex); + } + + void + MaybeExecuteFinishedScripts(uint32_t aIndex) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + ScriptLoadInfo& loadInfo = mLoadInfos[aIndex]; + + // We execute the last step if we don't have a pending operation with the + // cache and the loading is completed. + if (loadInfo.Finished()) { + ExecuteFinishedScripts(); + } + } + + nsresult + OnStreamComplete(nsIStreamLoader* aLoader, uint32_t aIndex, + nsresult aStatus, uint32_t aStringLen, + const uint8_t* aString) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + + nsresult rv = OnStreamCompleteInternal(aLoader, aStatus, aStringLen, + aString, mLoadInfos[aIndex]); + LoadingFinished(aIndex, rv); + return NS_OK; + } + + nsresult + OnStartRequest(nsIRequest* aRequest, uint32_t aIndex) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + + // If one load info cancels or hits an error, it can race with the start + // callback coming from another load info. + if (mCanceledMainThread || !mCacheCreator) { + aRequest->Cancel(NS_ERROR_FAILURE); + return NS_ERROR_FAILURE; + } + + ScriptLoadInfo& loadInfo = mLoadInfos[aIndex]; + + nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); + MOZ_ASSERT(channel == loadInfo.mChannel); + + // We synthesize the result code, but its never exposed to content. + RefPtr<mozilla::dom::InternalResponse> ir = + new mozilla::dom::InternalResponse(200, NS_LITERAL_CSTRING("OK")); + ir->SetBody(loadInfo.mCacheReadStream, InternalResponse::UNKNOWN_BODY_SIZE); + // Drop our reference to the stream now that we've passed it along, so it + // doesn't hang around once the cache is done with it and keep data alive. + loadInfo.mCacheReadStream = nullptr; + + // Set the channel info of the channel on the response so that it's + // saved in the cache. + ir->InitChannelInfo(channel); + + // Save the principal of the channel since its URI encodes the script URI + // rather than the ServiceWorkerRegistrationInfo URI. + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(ssm, "Should never be null!"); + + nsCOMPtr<nsIPrincipal> channelPrincipal; + nsresult rv = ssm->GetChannelResultPrincipal(channel, getter_AddRefs(channelPrincipal)); + if (NS_WARN_IF(NS_FAILED(rv))) { + channel->Cancel(rv); + return rv; + } + + UniquePtr<PrincipalInfo> principalInfo(new PrincipalInfo()); + rv = PrincipalToPrincipalInfo(channelPrincipal, principalInfo.get()); + if (NS_WARN_IF(NS_FAILED(rv))) { + channel->Cancel(rv); + return rv; + } + + ir->SetPrincipalInfo(Move(principalInfo)); + + RefPtr<mozilla::dom::Response> response = + new mozilla::dom::Response(mCacheCreator->Global(), ir); + + mozilla::dom::RequestOrUSVString request; + + MOZ_ASSERT(!loadInfo.mFullURL.IsEmpty()); + request.SetAsUSVString().Rebind(loadInfo.mFullURL.Data(), + loadInfo.mFullURL.Length()); + + ErrorResult error; + RefPtr<Promise> cachePromise = + mCacheCreator->Cache_()->Put(request, *response, error); + if (NS_WARN_IF(error.Failed())) { + nsresult rv = error.StealNSResult(); + channel->Cancel(rv); + return rv; + } + + RefPtr<CachePromiseHandler> promiseHandler = + new CachePromiseHandler(this, loadInfo, aIndex); + cachePromise->AppendNativeHandler(promiseHandler); + + loadInfo.mCachePromise.swap(cachePromise); + loadInfo.mCacheStatus = ScriptLoadInfo::WritingToCache; + + return NS_OK; + } + + bool + Notify(Status aStatus) + { + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (aStatus >= Terminating && !mCanceled) { + mCanceled = true; + + MOZ_ALWAYS_SUCCEEDS( + NS_DispatchToMainThread(NewRunnableMethod(this, + &ScriptLoaderRunnable::CancelMainThreadWithBindingAborted))); + } + + return true; + } + + bool + IsMainWorkerScript() const + { + return mIsMainScript && mWorkerScriptType == WorkerScript; + } + + void + CancelMainThreadWithBindingAborted() + { + CancelMainThread(NS_BINDING_ABORTED); + } + + void + CancelMainThread(nsresult aCancelResult) + { + AssertIsOnMainThread(); + + if (mCanceledMainThread) { + return; + } + + mCanceledMainThread = true; + + if (mCacheCreator) { + MOZ_ASSERT(mWorkerPrivate->IsServiceWorker()); + DeleteCache(); + } + + // Cancel all the channels that were already opened. + for (uint32_t index = 0; index < mLoadInfos.Length(); index++) { + ScriptLoadInfo& loadInfo = mLoadInfos[index]; + + // If promise or channel is non-null, their failures will lead to + // LoadingFinished being called. + bool callLoadingFinished = true; + + if (loadInfo.mCachePromise) { + MOZ_ASSERT(mWorkerPrivate->IsServiceWorker()); + loadInfo.mCachePromise->MaybeReject(aCancelResult); + loadInfo.mCachePromise = nullptr; + callLoadingFinished = false; + } + + if (loadInfo.mChannel) { + if (NS_SUCCEEDED(loadInfo.mChannel->Cancel(aCancelResult))) { + callLoadingFinished = false; + } else { + NS_WARNING("Failed to cancel channel!"); + } + } + + if (callLoadingFinished && !loadInfo.Finished()) { + LoadingFinished(index, aCancelResult); + } + } + + ExecuteFinishedScripts(); + } + + void + DeleteCache() + { + AssertIsOnMainThread(); + + if (!mCacheCreator) { + return; + } + + mCacheCreator->DeleteCache(); + mCacheCreator = nullptr; + } + + nsresult + RunInternal() + { + AssertIsOnMainThread(); + + if (IsMainWorkerScript() && mWorkerPrivate->IsServiceWorker()) { + mWorkerPrivate->SetLoadingWorkerScript(true); + } + + if (!mWorkerPrivate->IsServiceWorker() || + !mWorkerPrivate->LoadScriptAsPartOfLoadingServiceWorkerScript()) { + for (uint32_t index = 0, len = mLoadInfos.Length(); index < len; + ++index) { + nsresult rv = LoadScript(index); + if (NS_WARN_IF(NS_FAILED(rv))) { + LoadingFinished(index, rv); + return rv; + } + } + + return NS_OK; + } + + MOZ_ASSERT(!mCacheCreator); + mCacheCreator = new CacheCreator(mWorkerPrivate); + + for (uint32_t index = 0, len = mLoadInfos.Length(); index < len; ++index) { + RefPtr<CacheScriptLoader> loader = + new CacheScriptLoader(mWorkerPrivate, mLoadInfos[index], index, + IsMainWorkerScript(), this); + mCacheCreator->AddLoader(loader); + } + + // The worker may have a null principal on first load, but in that case its + // parent definitely will have one. + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + if (!principal) { + WorkerPrivate* parentWorker = mWorkerPrivate->GetParent(); + MOZ_ASSERT(parentWorker, "Must have a parent!"); + principal = parentWorker->GetPrincipal(); + } + + nsresult rv = mCacheCreator->Load(principal); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; + } + + nsresult + LoadScript(uint32_t aIndex) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + + WorkerPrivate* parentWorker = mWorkerPrivate->GetParent(); + + // Figure out which principal to use. + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + nsCOMPtr<nsILoadGroup> loadGroup = mWorkerPrivate->GetLoadGroup(); + if (!principal) { + NS_ASSERTION(parentWorker, "Must have a principal!"); + NS_ASSERTION(mIsMainScript, "Must have a principal for importScripts!"); + + principal = parentWorker->GetPrincipal(); + loadGroup = parentWorker->GetLoadGroup(); + } + NS_ASSERTION(principal, "This should never be null here!"); + MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(loadGroup, principal)); + + // Figure out our base URI. + nsCOMPtr<nsIURI> baseURI = GetBaseURI(mIsMainScript, mWorkerPrivate); + + // May be null. + nsCOMPtr<nsIDocument> parentDoc = mWorkerPrivate->GetDocument(); + + nsCOMPtr<nsIChannel> channel; + if (IsMainWorkerScript()) { + // May be null. + channel = mWorkerPrivate->ForgetWorkerChannel(); + } + + nsCOMPtr<nsIIOService> ios(do_GetIOService()); + + nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(secMan, "This should never be null!"); + + ScriptLoadInfo& loadInfo = mLoadInfos[aIndex]; + nsresult& rv = loadInfo.mLoadResult; + + nsLoadFlags loadFlags = nsIRequest::LOAD_NORMAL; + + // Get the top-level worker. + WorkerPrivate* topWorkerPrivate = mWorkerPrivate; + WorkerPrivate* parent = topWorkerPrivate->GetParent(); + while (parent) { + topWorkerPrivate = parent; + parent = topWorkerPrivate->GetParent(); + } + + // If the top-level worker is a dedicated worker and has a window, and the + // window has a docshell, the caching behavior of this worker should match + // that of that docshell. + if (topWorkerPrivate->IsDedicatedWorker()) { + nsCOMPtr<nsPIDOMWindowInner> window = topWorkerPrivate->GetWindow(); + if (window) { + nsCOMPtr<nsIDocShell> docShell = window->GetDocShell(); + if (docShell) { + nsresult rv = docShell->GetDefaultLoadFlags(&loadFlags); + NS_ENSURE_SUCCESS(rv, rv); + } + } + } + + // If we are loading a script for a ServiceWorker then we must not + // try to intercept it. If the interception matches the current + // ServiceWorker's scope then we could deadlock the load. + if (mWorkerPrivate->IsServiceWorker()) { + loadFlags |= nsIChannel::LOAD_BYPASS_SERVICE_WORKER; + } + + if (!channel) { + // Only top level workers' main script use the document charset for the + // script uri encoding. Otherwise, default encoding (UTF-8) is applied. + bool useDefaultEncoding = !(!parentWorker && IsMainWorkerScript()); + rv = ChannelFromScriptURL(principal, baseURI, parentDoc, loadGroup, ios, + secMan, loadInfo.mURL, IsMainWorkerScript(), + mWorkerScriptType, + mWorkerPrivate->ContentPolicyType(), loadFlags, + useDefaultEncoding, + getter_AddRefs(channel)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + // We need to know which index we're on in OnStreamComplete so we know + // where to put the result. + RefPtr<LoaderListener> listener = new LoaderListener(this, aIndex); + + // We don't care about progress so just use the simple stream loader for + // OnStreamComplete notification only. + nsCOMPtr<nsIStreamLoader> loader; + rv = NS_NewStreamLoader(getter_AddRefs(loader), listener); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (loadInfo.mCacheStatus != ScriptLoadInfo::ToBeCached) { + rv = channel->AsyncOpen2(loader); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } else { + nsCOMPtr<nsIOutputStream> writer; + + // In case we return early. + loadInfo.mCacheStatus = ScriptLoadInfo::Cancel; + + rv = NS_NewPipe(getter_AddRefs(loadInfo.mCacheReadStream), + getter_AddRefs(writer), 0, + UINT32_MAX, // unlimited size to avoid writer WOULD_BLOCK case + true, false); // non-blocking reader, blocking writer + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIStreamListenerTee> tee = + do_CreateInstance(NS_STREAMLISTENERTEE_CONTRACTID); + rv = tee->Init(loader, writer, listener); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsresult rv = channel->AsyncOpen2(tee); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + loadInfo.mChannel.swap(channel); + + return NS_OK; + } + + nsresult + OnStreamCompleteInternal(nsIStreamLoader* aLoader, nsresult aStatus, + uint32_t aStringLen, const uint8_t* aString, + ScriptLoadInfo& aLoadInfo) + { + AssertIsOnMainThread(); + + if (!aLoadInfo.mChannel) { + return NS_BINDING_ABORTED; + } + + aLoadInfo.mChannel = nullptr; + + if (NS_FAILED(aStatus)) { + return aStatus; + } + + NS_ASSERTION(aString, "This should never be null!"); + + nsCOMPtr<nsIRequest> request; + nsresult rv = aLoader->GetRequest(getter_AddRefs(request)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel = do_QueryInterface(request); + MOZ_ASSERT(channel); + + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(ssm, "Should never be null!"); + + nsCOMPtr<nsIPrincipal> channelPrincipal; + rv = ssm->GetChannelResultPrincipal(channel, getter_AddRefs(channelPrincipal)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + if (!principal) { + WorkerPrivate* parentWorker = mWorkerPrivate->GetParent(); + MOZ_ASSERT(parentWorker, "Must have a parent!"); + principal = parentWorker->GetPrincipal(); + } + + // We don't mute the main worker script becase we've already done + // same-origin checks on them so we should be able to see their errors. + // Note that for data: url, where we allow it through the same-origin check + // but then give it a different origin. + aLoadInfo.mMutedErrorFlag.emplace(IsMainWorkerScript() + ? false + : !principal->Subsumes(channelPrincipal)); + + // Make sure we're not seeing the result of a 404 or something by checking + // the 'requestSucceeded' attribute on the http channel. + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(request); + nsAutoCString tCspHeaderValue, tCspROHeaderValue, tRPHeaderCValue; + + if (httpChannel) { + bool requestSucceeded; + rv = httpChannel->GetRequestSucceeded(&requestSucceeded); + NS_ENSURE_SUCCESS(rv, rv); + + if (!requestSucceeded) { + return NS_ERROR_NOT_AVAILABLE; + } + + httpChannel->GetResponseHeader( + NS_LITERAL_CSTRING("content-security-policy"), + tCspHeaderValue); + + httpChannel->GetResponseHeader( + NS_LITERAL_CSTRING("content-security-policy-report-only"), + tCspROHeaderValue); + + httpChannel->GetResponseHeader( + NS_LITERAL_CSTRING("referrer-policy"), + tRPHeaderCValue); + } + + // May be null. + nsIDocument* parentDoc = mWorkerPrivate->GetDocument(); + + // Use the regular nsScriptLoader for this grunt work! Should be just fine + // because we're running on the main thread. + // Unlike <script> tags, Worker scripts are always decoded as UTF-8, + // per spec. So we explicitly pass in the charset hint. + rv = nsScriptLoader::ConvertToUTF16(aLoadInfo.mChannel, aString, aStringLen, + NS_LITERAL_STRING("UTF-8"), parentDoc, + aLoadInfo.mScriptTextBuf, + aLoadInfo.mScriptTextLength); + if (NS_FAILED(rv)) { + return rv; + } + + if (!aLoadInfo.mScriptTextLength && !aLoadInfo.mScriptTextBuf) { + nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, + NS_LITERAL_CSTRING("DOM"), parentDoc, + nsContentUtils::eDOM_PROPERTIES, + "EmptyWorkerSourceWarning"); + } else if (!aLoadInfo.mScriptTextBuf) { + return NS_ERROR_FAILURE; + } + + // Figure out what we actually loaded. + nsCOMPtr<nsIURI> finalURI; + rv = NS_GetFinalChannelURI(channel, getter_AddRefs(finalURI)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCString filename; + rv = finalURI->GetSpec(filename); + NS_ENSURE_SUCCESS(rv, rv); + + if (!filename.IsEmpty()) { + // This will help callers figure out what their script url resolved to in + // case of errors. + aLoadInfo.mURL.Assign(NS_ConvertUTF8toUTF16(filename)); + } + + nsCOMPtr<nsILoadInfo> chanLoadInfo = channel->GetLoadInfo(); + if (chanLoadInfo && chanLoadInfo->GetEnforceSRI()) { + // importScripts() and the Worker constructor do not support integrity metadata + // (or any fetch options). Until then, we can just block. + // If we ever have those data in the future, we'll have to the check to + // by using the SRICheck module + MOZ_LOG(SRILogHelper::GetSriLog(), mozilla::LogLevel::Debug, + ("Scriptloader::Load, SRI required but not supported in workers")); + nsCOMPtr<nsIContentSecurityPolicy> wcsp; + chanLoadInfo->LoadingPrincipal()->GetCsp(getter_AddRefs(wcsp)); + MOZ_ASSERT(wcsp, "We sould have a CSP for the worker here"); + if (wcsp) { + wcsp->LogViolationDetails( + nsIContentSecurityPolicy::VIOLATION_TYPE_REQUIRE_SRI_FOR_SCRIPT, + aLoadInfo.mURL, EmptyString(), 0, EmptyString(), EmptyString()); + } + return NS_ERROR_SRI_CORRUPT; + } + + // Update the principal of the worker and its base URI if we just loaded the + // worker's primary script. + if (IsMainWorkerScript()) { + // Take care of the base URI first. + mWorkerPrivate->SetBaseURI(finalURI); + + // Store the channel info if needed. + mWorkerPrivate->InitChannelInfo(channel); + + // Now to figure out which principal to give this worker. + WorkerPrivate* parent = mWorkerPrivate->GetParent(); + + NS_ASSERTION(mWorkerPrivate->GetPrincipal() || parent, + "Must have one of these!"); + + nsCOMPtr<nsIPrincipal> loadPrincipal = mWorkerPrivate->GetPrincipal() ? + mWorkerPrivate->GetPrincipal() : + parent->GetPrincipal(); + + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(ssm, "Should never be null!"); + + nsCOMPtr<nsIPrincipal> channelPrincipal; + rv = ssm->GetChannelResultPrincipal(channel, getter_AddRefs(channelPrincipal)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsILoadGroup> channelLoadGroup; + rv = channel->GetLoadGroup(getter_AddRefs(channelLoadGroup)); + NS_ENSURE_SUCCESS(rv, rv); + MOZ_ASSERT(channelLoadGroup); + + // If the load principal is the system principal then the channel + // principal must also be the system principal (we do not allow chrome + // code to create workers with non-chrome scripts, and if we ever decide + // to change this we need to make sure we don't always set + // mPrincipalIsSystem to true in WorkerPrivate::GetLoadInfo()). Otherwise + // this channel principal must be same origin with the load principal (we + // check again here in case redirects changed the location of the script). + if (nsContentUtils::IsSystemPrincipal(loadPrincipal)) { + if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) { + // See if this is a resource URI. Since JSMs usually come from + // resource:// URIs we're currently considering all URIs with the + // URI_IS_UI_RESOURCE flag as valid for creating privileged workers. + bool isResource; + rv = NS_URIChainHasFlags(finalURI, + nsIProtocolHandler::URI_IS_UI_RESOURCE, + &isResource); + NS_ENSURE_SUCCESS(rv, rv); + + if (isResource) { + // Assign the system principal to the resource:// worker only if it + // was loaded from code using the system principal. + channelPrincipal = loadPrincipal; + } else { + return NS_ERROR_DOM_BAD_URI; + } + } + } + + // The principal can change, but it should still match the original + // load group's appId and browser element flag. + MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(channelLoadGroup, channelPrincipal)); + + mWorkerPrivate->SetPrincipal(channelPrincipal, channelLoadGroup); + + // We did inherit CSP in bug 1223647. If we do not already have a CSP, we + // should get it from the HTTP headers on the worker script. + if (!mWorkerPrivate->GetCSP() && CSPService::sCSPEnabled) { + NS_ConvertASCIItoUTF16 cspHeaderValue(tCspHeaderValue); + NS_ConvertASCIItoUTF16 cspROHeaderValue(tCspROHeaderValue); + + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + MOZ_ASSERT(principal, "Should not be null"); + + nsCOMPtr<nsIContentSecurityPolicy> csp; + rv = principal->EnsureCSP(nullptr, getter_AddRefs(csp)); + + if (csp) { + // If there's a CSP header, apply it. + if (!cspHeaderValue.IsEmpty()) { + rv = CSP_AppendCSPFromHeader(csp, cspHeaderValue, false); + NS_ENSURE_SUCCESS(rv, rv); + } + // If there's a report-only CSP header, apply it. + if (!cspROHeaderValue.IsEmpty()) { + rv = CSP_AppendCSPFromHeader(csp, cspROHeaderValue, true); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Set evalAllowed, default value is set in GetAllowsEval + bool evalAllowed = false; + bool reportEvalViolations = false; + rv = csp->GetAllowsEval(&reportEvalViolations, &evalAllowed); + NS_ENSURE_SUCCESS(rv, rv); + + mWorkerPrivate->SetCSP(csp); + mWorkerPrivate->SetEvalAllowed(evalAllowed); + mWorkerPrivate->SetReportCSPViolations(reportEvalViolations); + + // Set ReferrerPolicy, default value is set in GetReferrerPolicy + bool hasReferrerPolicy = false; + uint32_t rp = mozilla::net::RP_Default; + rv = csp->GetReferrerPolicy(&rp, &hasReferrerPolicy); + NS_ENSURE_SUCCESS(rv, rv); + + + if (hasReferrerPolicy) { //FIXME bug 1307366: move RP out of CSP code + mWorkerPrivate->SetReferrerPolicy(static_cast<net::ReferrerPolicy>(rp)); + } + } + } + if (parent) { + // XHR Params Allowed + mWorkerPrivate->SetXHRParamsAllowed(parent->XHRParamsAllowed()); + } + } + + NS_ConvertUTF8toUTF16 tRPHeaderValue(tRPHeaderCValue); + // If there's a Referrer-Policy header, apply it. + if (!tRPHeaderValue.IsEmpty()) { + net::ReferrerPolicy policy = + nsContentUtils::GetReferrerPolicyFromHeader(tRPHeaderValue); + if (policy != net::RP_Unset) { + mWorkerPrivate->SetReferrerPolicy(policy); + } + } + + return NS_OK; + } + + void + DataReceivedFromCache(uint32_t aIndex, const uint8_t* aString, + uint32_t aStringLen, + const mozilla::dom::ChannelInfo& aChannelInfo, + UniquePtr<PrincipalInfo> aPrincipalInfo) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aIndex < mLoadInfos.Length()); + ScriptLoadInfo& loadInfo = mLoadInfos[aIndex]; + MOZ_ASSERT(loadInfo.mCacheStatus == ScriptLoadInfo::Cached); + + nsCOMPtr<nsIPrincipal> responsePrincipal = + PrincipalInfoToPrincipal(*aPrincipalInfo); + + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + if (!principal) { + WorkerPrivate* parentWorker = mWorkerPrivate->GetParent(); + MOZ_ASSERT(parentWorker, "Must have a parent!"); + principal = parentWorker->GetPrincipal(); + } + + loadInfo.mMutedErrorFlag.emplace(!principal->Subsumes(responsePrincipal)); + + // May be null. + nsIDocument* parentDoc = mWorkerPrivate->GetDocument(); + + MOZ_ASSERT(!loadInfo.mScriptTextBuf); + + nsresult rv = + nsScriptLoader::ConvertToUTF16(nullptr, aString, aStringLen, + NS_LITERAL_STRING("UTF-8"), parentDoc, + loadInfo.mScriptTextBuf, + loadInfo.mScriptTextLength); + if (NS_SUCCEEDED(rv) && IsMainWorkerScript()) { + nsCOMPtr<nsIURI> finalURI; + rv = NS_NewURI(getter_AddRefs(finalURI), loadInfo.mFullURL, nullptr, nullptr); + if (NS_SUCCEEDED(rv)) { + mWorkerPrivate->SetBaseURI(finalURI); + } + + mozilla::DebugOnly<nsIPrincipal*> principal = mWorkerPrivate->GetPrincipal(); + MOZ_ASSERT(principal); + nsILoadGroup* loadGroup = mWorkerPrivate->GetLoadGroup(); + MOZ_ASSERT(loadGroup); + + mozilla::DebugOnly<bool> equal = false; + MOZ_ASSERT(responsePrincipal && NS_SUCCEEDED(responsePrincipal->Equals(principal, &equal))); + MOZ_ASSERT(equal); + + mWorkerPrivate->InitChannelInfo(aChannelInfo); + mWorkerPrivate->SetPrincipal(responsePrincipal, loadGroup); + } + + if (NS_SUCCEEDED(rv)) { + DataReceived(); + } + + LoadingFinished(aIndex, rv); + } + + void + DataReceived() + { + if (IsMainWorkerScript()) { + WorkerPrivate* parent = mWorkerPrivate->GetParent(); + + if (parent) { + // XHR Params Allowed + mWorkerPrivate->SetXHRParamsAllowed(parent->XHRParamsAllowed()); + + // Set Eval and ContentSecurityPolicy + mWorkerPrivate->SetCSP(parent->GetCSP()); + mWorkerPrivate->SetEvalAllowed(parent->IsEvalAllowed()); + } + } + } + + void + ExecuteFinishedScripts() + { + AssertIsOnMainThread(); + + if (IsMainWorkerScript()) { + mWorkerPrivate->WorkerScriptLoaded(); + } + + uint32_t firstIndex = UINT32_MAX; + uint32_t lastIndex = UINT32_MAX; + + // Find firstIndex based on whether mExecutionScheduled is unset. + for (uint32_t index = 0; index < mLoadInfos.Length(); index++) { + if (!mLoadInfos[index].mExecutionScheduled) { + firstIndex = index; + break; + } + } + + // Find lastIndex based on whether mChannel is set, and update + // mExecutionScheduled on the ones we're about to schedule. + if (firstIndex != UINT32_MAX) { + for (uint32_t index = firstIndex; index < mLoadInfos.Length(); index++) { + ScriptLoadInfo& loadInfo = mLoadInfos[index]; + + if (!loadInfo.Finished()) { + break; + } + + // We can execute this one. + loadInfo.mExecutionScheduled = true; + + lastIndex = index; + } + } + + // This is the last index, we can unused things before the exection of the + // script and the stopping of the sync loop. + if (lastIndex == mLoadInfos.Length() - 1) { + mCacheCreator = nullptr; + } + + if (firstIndex != UINT32_MAX && lastIndex != UINT32_MAX) { + RefPtr<ScriptExecutorRunnable> runnable = + new ScriptExecutorRunnable(*this, mSyncLoopTarget, IsMainWorkerScript(), + firstIndex, lastIndex); + if (!runnable->Dispatch()) { + MOZ_ASSERT(false, "This should never fail!"); + } + } + } +}; + +NS_IMPL_ISUPPORTS(ScriptLoaderRunnable, nsIRunnable) + +class MOZ_STACK_CLASS ScriptLoaderHolder final : public WorkerHolder +{ + // Raw pointer because this holder object follows the mRunnable life-time. + ScriptLoaderRunnable* mRunnable; + +public: + explicit ScriptLoaderHolder(ScriptLoaderRunnable* aRunnable) + : mRunnable(aRunnable) + { + MOZ_ASSERT(aRunnable); + } + + virtual bool + Notify(Status aStatus) override + { + mRunnable->Notify(aStatus); + return true; + } +}; + +NS_IMETHODIMP +LoaderListener::OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aStringLen, + const uint8_t* aString) +{ + return mRunnable->OnStreamComplete(aLoader, mIndex, aStatus, aStringLen, aString); +} + +NS_IMETHODIMP +LoaderListener::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) +{ + return mRunnable->OnStartRequest(aRequest, mIndex); +} + +void +CachePromiseHandler::ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + // May already have been canceled by CacheScriptLoader::Fail from + // CancelMainThread. + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::WritingToCache || + mLoadInfo.mCacheStatus == ScriptLoadInfo::Cancel); + MOZ_ASSERT_IF(mLoadInfo.mCacheStatus == ScriptLoadInfo::Cancel, !mLoadInfo.mCachePromise); + + if (mLoadInfo.mCachePromise) { + mLoadInfo.mCacheStatus = ScriptLoadInfo::Cached; + mLoadInfo.mCachePromise = nullptr; + mRunnable->MaybeExecuteFinishedScripts(mIndex); + } +} + +void +CachePromiseHandler::RejectedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + // May already have been canceled by CacheScriptLoader::Fail from + // CancelMainThread. + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::WritingToCache || + mLoadInfo.mCacheStatus == ScriptLoadInfo::Cancel); + mLoadInfo.mCacheStatus = ScriptLoadInfo::Cancel; + + mLoadInfo.mCachePromise = nullptr; + + // This will delete the cache object and will call LoadingFinished() with an + // error for each ongoing operation. + mRunnable->DeleteCache(); +} + +nsresult +CacheCreator::CreateCacheStorage(nsIPrincipal* aPrincipal) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!mCacheStorage); + MOZ_ASSERT(aPrincipal); + + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + + mozilla::AutoSafeJSContext cx; + JS::Rooted<JSObject*> sandbox(cx); + nsresult rv = xpc->CreateSandbox(cx, aPrincipal, sandbox.address()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + mSandboxGlobalObject = xpc::NativeGlobal(sandbox); + if (NS_WARN_IF(!mSandboxGlobalObject)) { + return NS_ERROR_FAILURE; + } + + // If we're in private browsing mode, don't even try to create the + // CacheStorage. Instead, just fail immediately to terminate the + // ServiceWorker load. + if (NS_WARN_IF(mOriginAttributes.mPrivateBrowsingId > 0)) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + // Create a CacheStorage bypassing its trusted origin checks. The + // ServiceWorker has already performed its own checks before getting + // to this point. + ErrorResult error; + mCacheStorage = + CacheStorage::CreateOnMainThread(mozilla::dom::cache::CHROME_ONLY_NAMESPACE, + mSandboxGlobalObject, + aPrincipal, + false, /* privateBrowsing can't be true here */ + true /* force trusted origin */, + error); + if (NS_WARN_IF(error.Failed())) { + return error.StealNSResult(); + } + + return NS_OK; +} + +nsresult +CacheCreator::Load(nsIPrincipal* aPrincipal) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!mLoaders.IsEmpty()); + + nsresult rv = CreateCacheStorage(aPrincipal); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + ErrorResult error; + MOZ_ASSERT(!mCacheName.IsEmpty()); + RefPtr<Promise> promise = mCacheStorage->Open(mCacheName, error); + if (NS_WARN_IF(error.Failed())) { + return error.StealNSResult(); + } + + promise->AppendNativeHandler(this); + return NS_OK; +} + +void +CacheCreator::FailLoaders(nsresult aRv) +{ + AssertIsOnMainThread(); + + // Fail() can call LoadingFinished() which may call ExecuteFinishedScripts() + // which sets mCacheCreator to null, so hold a ref. + RefPtr<CacheCreator> kungfuDeathGrip = this; + + for (uint32_t i = 0, len = mLoaders.Length(); i < len; ++i) { + mLoaders[i]->Fail(aRv); + } + + mLoaders.Clear(); +} + +void +CacheCreator::RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + FailLoaders(NS_ERROR_FAILURE); +} + +void +CacheCreator::ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + + if (!aValue.isObject()) { + FailLoaders(NS_ERROR_FAILURE); + return; + } + + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + Cache* cache = nullptr; + nsresult rv = UNWRAP_OBJECT(Cache, &obj, cache); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailLoaders(NS_ERROR_FAILURE); + return; + } + + mCache = cache; + MOZ_DIAGNOSTIC_ASSERT(mCache); + + // If the worker is canceled, CancelMainThread() will have cleared the + // loaders via DeleteCache(). + for (uint32_t i = 0, len = mLoaders.Length(); i < len; ++i) { + MOZ_DIAGNOSTIC_ASSERT(mLoaders[i]); + mLoaders[i]->Load(cache); + } +} + +void +CacheCreator::DeleteCache() +{ + AssertIsOnMainThread(); + + // This is called when the load is canceled which can occur before + // mCacheStorage is initialized. + if (mCacheStorage) { + // It's safe to do this while Cache::Match() and Cache::Put() calls are + // running. + IgnoredErrorResult rv; + RefPtr<Promise> promise = mCacheStorage->Delete(mCacheName, rv); + + // We don't care to know the result of the promise object. + } + + // Always call this here to ensure the loaders array is cleared. + FailLoaders(NS_ERROR_FAILURE); +} + +void +CacheScriptLoader::Fail(nsresult aRv) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(NS_FAILED(aRv)); + + if (mFailed) { + return; + } + + mFailed = true; + + if (mPump) { + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::ReadingFromCache); + mPump->Cancel(aRv); + mPump = nullptr; + } + + mLoadInfo.mCacheStatus = ScriptLoadInfo::Cancel; + + // Stop if the load was aborted on the main thread. + // Can't use Finished() because mCachePromise may still be true. + if (mLoadInfo.mLoadingFinished) { + MOZ_ASSERT(!mLoadInfo.mChannel); + MOZ_ASSERT_IF(mLoadInfo.mCachePromise, + mLoadInfo.mCacheStatus == ScriptLoadInfo::WritingToCache || + mLoadInfo.mCacheStatus == ScriptLoadInfo::Cancel); + return; + } + + mRunnable->LoadingFinished(mIndex, aRv); +} + +void +CacheScriptLoader::Load(Cache* aCache) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aCache); + + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), mLoadInfo.mURL, nullptr, + mBaseURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + nsAutoCString spec; + rv = uri->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + MOZ_ASSERT(mLoadInfo.mFullURL.IsEmpty()); + CopyUTF8toUTF16(spec, mLoadInfo.mFullURL); + + mozilla::dom::RequestOrUSVString request; + request.SetAsUSVString().Rebind(mLoadInfo.mFullURL.Data(), + mLoadInfo.mFullURL.Length()); + + mozilla::dom::CacheQueryOptions params; + + ErrorResult error; + RefPtr<Promise> promise = aCache->Match(request, params, error); + if (NS_WARN_IF(error.Failed())) { + Fail(error.StealNSResult()); + return; + } + + promise->AppendNativeHandler(this); +} + +void +CacheScriptLoader::RejectedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::Uncached); + Fail(NS_ERROR_FAILURE); +} + +void +CacheScriptLoader::ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + // If we have already called 'Fail', we should not proceed. + if (mFailed) { + return; + } + + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::Uncached); + + nsresult rv; + + if (aValue.isUndefined()) { + mLoadInfo.mCacheStatus = ScriptLoadInfo::ToBeCached; + rv = mRunnable->LoadScript(mIndex); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + } + return; + } + + MOZ_ASSERT(aValue.isObject()); + + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + mozilla::dom::Response* response = nullptr; + rv = UNWRAP_OBJECT(Response, &obj, response); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + nsCOMPtr<nsIInputStream> inputStream; + response->GetBody(getter_AddRefs(inputStream)); + mChannelInfo = response->GetChannelInfo(); + const UniquePtr<PrincipalInfo>& pInfo = response->GetPrincipalInfo(); + if (pInfo) { + mPrincipalInfo = mozilla::MakeUnique<PrincipalInfo>(*pInfo); + } + + if (!inputStream) { + mLoadInfo.mCacheStatus = ScriptLoadInfo::Cached; + mRunnable->DataReceivedFromCache(mIndex, (uint8_t*)"", 0, mChannelInfo, + Move(mPrincipalInfo)); + return; + } + + MOZ_ASSERT(!mPump); + rv = NS_NewInputStreamPump(getter_AddRefs(mPump), inputStream); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + nsCOMPtr<nsIStreamLoader> loader; + rv = NS_NewStreamLoader(getter_AddRefs(loader), this); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + rv = mPump->AsyncRead(loader, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPump = nullptr; + Fail(rv); + return; + } + + + nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(mPump); + if (rr) { + nsCOMPtr<nsIEventTarget> sts = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + rv = rr->RetargetDeliveryTo(sts); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the nsIInputStreamPump to a IO thread."); + } + } + + mLoadInfo.mCacheStatus = ScriptLoadInfo::ReadingFromCache; +} + +NS_IMETHODIMP +CacheScriptLoader::OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aStringLen, + const uint8_t* aString) +{ + AssertIsOnMainThread(); + + mPump = nullptr; + + if (NS_FAILED(aStatus)) { + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::ReadingFromCache || + mLoadInfo.mCacheStatus == ScriptLoadInfo::Cancel); + Fail(aStatus); + return NS_OK; + } + + MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::ReadingFromCache); + mLoadInfo.mCacheStatus = ScriptLoadInfo::Cached; + + MOZ_ASSERT(mPrincipalInfo); + mRunnable->DataReceivedFromCache(mIndex, aString, aStringLen, mChannelInfo, + Move(mPrincipalInfo)); + return NS_OK; +} + +class ChannelGetterRunnable final : public WorkerMainThreadRunnable +{ + const nsAString& mScriptURL; + nsIChannel** mChannel; + nsresult mResult; + +public: + ChannelGetterRunnable(WorkerPrivate* aParentWorker, + const nsAString& aScriptURL, + nsIChannel** aChannel) + : WorkerMainThreadRunnable(aParentWorker, + NS_LITERAL_CSTRING("ScriptLoader :: ChannelGetter")) + , mScriptURL(aScriptURL) + , mChannel(aChannel) + , mResult(NS_ERROR_FAILURE) + { + MOZ_ASSERT(aParentWorker); + aParentWorker->AssertIsOnWorkerThread(); + } + + virtual bool + MainThreadRun() override + { + AssertIsOnMainThread(); + + nsIPrincipal* principal = mWorkerPrivate->GetPrincipal(); + MOZ_ASSERT(principal); + + // Figure out our base URI. + nsCOMPtr<nsIURI> baseURI = mWorkerPrivate->GetBaseURI(); + MOZ_ASSERT(baseURI); + + // May be null. + nsCOMPtr<nsIDocument> parentDoc = mWorkerPrivate->GetDocument(); + + nsCOMPtr<nsILoadGroup> loadGroup = mWorkerPrivate->GetLoadGroup(); + + nsCOMPtr<nsIChannel> channel; + mResult = + scriptloader::ChannelFromScriptURLMainThread(principal, baseURI, + parentDoc, loadGroup, + mScriptURL, + // Nested workers are always dedicated. + nsIContentPolicy::TYPE_INTERNAL_WORKER, + // Nested workers use default uri encoding. + true, + getter_AddRefs(channel)); + if (NS_SUCCEEDED(mResult)) { + channel.forget(mChannel); + } + + return true; + } + + nsresult + GetResult() const + { + return mResult; + } + +private: + virtual ~ChannelGetterRunnable() + { } +}; + +ScriptExecutorRunnable::ScriptExecutorRunnable( + ScriptLoaderRunnable& aScriptLoader, + nsIEventTarget* aSyncLoopTarget, + bool aIsWorkerScript, + uint32_t aFirstIndex, + uint32_t aLastIndex) +: MainThreadWorkerSyncRunnable(aScriptLoader.mWorkerPrivate, aSyncLoopTarget), + mScriptLoader(aScriptLoader), mIsWorkerScript(aIsWorkerScript), + mFirstIndex(aFirstIndex), mLastIndex(aLastIndex) +{ + MOZ_ASSERT(aFirstIndex <= aLastIndex); + MOZ_ASSERT(aLastIndex < aScriptLoader.mLoadInfos.Length()); +} + +bool +ScriptExecutorRunnable::IsDebuggerRunnable() const +{ + // ScriptExecutorRunnable is used to execute both worker and debugger scripts. + // In the latter case, the runnable needs to be dispatched to the debugger + // queue. + return mScriptLoader.mWorkerScriptType == DebuggerScript; +} + +bool +ScriptExecutorRunnable::PreRun(WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mIsWorkerScript) { + return true; + } + + if (!aWorkerPrivate->GetJSContext()) { + return false; + } + + MOZ_ASSERT(mFirstIndex == 0); + MOZ_ASSERT(!mScriptLoader.mRv.Failed()); + + AutoJSAPI jsapi; + jsapi.Init(); + + WorkerGlobalScope* globalScope = + aWorkerPrivate->GetOrCreateGlobalScope(jsapi.cx()); + if (NS_WARN_IF(!globalScope)) { + NS_WARNING("Failed to make global!"); + // There's no way to report the exception on jsapi right now, because there + // is no way to even enter a compartment on this thread anymore. Just clear + // the exception. We'll report some sort of error to our caller in + // ShutdownScriptLoader, but it will get squelched for the same reason we're + // squelching here: all the error reporting machinery relies on being able + // to enter a compartment to report the error. + jsapi.ClearException(); + return false; + } + + return true; +} + +bool +ScriptExecutorRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + + nsTArray<ScriptLoadInfo>& loadInfos = mScriptLoader.mLoadInfos; + + // Don't run if something else has already failed. + for (uint32_t index = 0; index < mFirstIndex; index++) { + ScriptLoadInfo& loadInfo = loadInfos.ElementAt(index); + + NS_ASSERTION(!loadInfo.mChannel, "Should no longer have a channel!"); + NS_ASSERTION(loadInfo.mExecutionScheduled, "Should be scheduled!"); + + if (!loadInfo.mExecutionResult) { + return true; + } + } + + // If nothing else has failed, our ErrorResult better not be a failure either. + MOZ_ASSERT(!mScriptLoader.mRv.Failed(), "Who failed it and why?"); + + // Slightly icky action at a distance, but there's no better place to stash + // this value, really. + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + MOZ_ASSERT(global); + + for (uint32_t index = mFirstIndex; index <= mLastIndex; index++) { + ScriptLoadInfo& loadInfo = loadInfos.ElementAt(index); + + NS_ASSERTION(!loadInfo.mChannel, "Should no longer have a channel!"); + NS_ASSERTION(loadInfo.mExecutionScheduled, "Should be scheduled!"); + NS_ASSERTION(!loadInfo.mExecutionResult, "Should not have executed yet!"); + + MOZ_ASSERT(!mScriptLoader.mRv.Failed(), "Who failed it and why?"); + mScriptLoader.mRv.MightThrowJSException(); + if (NS_FAILED(loadInfo.mLoadResult)) { + scriptloader::ReportLoadError(mScriptLoader.mRv, + loadInfo.mLoadResult, loadInfo.mURL); + // Top level scripts only! + if (mIsWorkerScript) { + aWorkerPrivate->MaybeDispatchLoadFailedRunnable(); + } + return true; + } + + NS_ConvertUTF16toUTF8 filename(loadInfo.mURL); + + JS::CompileOptions options(aCx); + options.setFileAndLine(filename.get(), 1) + .setNoScriptRval(true); + + if (mScriptLoader.mWorkerScriptType == DebuggerScript) { + options.setVersion(JSVERSION_LATEST); + } + + MOZ_ASSERT(loadInfo.mMutedErrorFlag.isSome()); + options.setMutedErrors(loadInfo.mMutedErrorFlag.valueOr(true)); + + JS::SourceBufferHolder srcBuf(loadInfo.mScriptTextBuf, + loadInfo.mScriptTextLength, + JS::SourceBufferHolder::GiveOwnership); + loadInfo.mScriptTextBuf = nullptr; + loadInfo.mScriptTextLength = 0; + + // Our ErrorResult still shouldn't be a failure. + MOZ_ASSERT(!mScriptLoader.mRv.Failed(), "Who failed it and why?"); + JS::Rooted<JS::Value> unused(aCx); + if (!JS::Evaluate(aCx, options, srcBuf, &unused)) { + mScriptLoader.mRv.StealExceptionFromJSContext(aCx); + return true; + } + + loadInfo.mExecutionResult = true; + } + + return true; +} + +void +ScriptExecutorRunnable::PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, + bool aRunResult) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!JS_IsExceptionPending(aCx), "Who left an exception on there?"); + + nsTArray<ScriptLoadInfo>& loadInfos = mScriptLoader.mLoadInfos; + + if (mLastIndex == loadInfos.Length() - 1) { + // All done. If anything failed then return false. + bool result = true; + bool mutedError = false; + for (uint32_t index = 0; index < loadInfos.Length(); index++) { + if (!loadInfos[index].mExecutionResult) { + mutedError = loadInfos[index].mMutedErrorFlag.valueOr(true); + result = false; + break; + } + } + + // The only way we can get here with "result" false but without + // mScriptLoader.mRv being a failure is if we're loading the main worker + // script and GetOrCreateGlobalScope() fails. In that case we would have + // returned false from WorkerRun, so assert that. + MOZ_ASSERT_IF(!result && !mScriptLoader.mRv.Failed(), + !aRunResult); + ShutdownScriptLoader(aCx, aWorkerPrivate, result, mutedError); + } +} + +nsresult +ScriptExecutorRunnable::Cancel() +{ + if (mLastIndex == mScriptLoader.mLoadInfos.Length() - 1) { + ShutdownScriptLoader(mWorkerPrivate->GetJSContext(), mWorkerPrivate, + false, false); + } + return MainThreadWorkerSyncRunnable::Cancel(); +} + +void +ScriptExecutorRunnable::ShutdownScriptLoader(JSContext* aCx, + WorkerPrivate* aWorkerPrivate, + bool aResult, + bool aMutedError) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + + MOZ_ASSERT(mLastIndex == mScriptLoader.mLoadInfos.Length() - 1); + + if (mIsWorkerScript && aWorkerPrivate->IsServiceWorker()) { + aWorkerPrivate->SetLoadingWorkerScript(false); + } + + if (!aResult) { + // At this point there are two possibilities: + // + // 1) mScriptLoader.mRv.Failed(). In that case we just want to leave it + // as-is, except if it has a JS exception and we need to mute JS + // exceptions. In that case, we log the exception without firing any + // events and then replace it on the ErrorResult with a NetworkError, + // per spec. + // + // 2) mScriptLoader.mRv succeeded. As far as I can tell, this can only + // happen when loading the main worker script and + // GetOrCreateGlobalScope() fails or if ScriptExecutorRunnable::Cancel + // got called. Does it matter what we throw in this case? I'm not + // sure... + if (mScriptLoader.mRv.Failed()) { + if (aMutedError && mScriptLoader.mRv.IsJSException()) { + LogExceptionToConsole(aCx, aWorkerPrivate); + mScriptLoader.mRv.Throw(NS_ERROR_DOM_NETWORK_ERR); + } + } else { + mScriptLoader.mRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + } + } + + aWorkerPrivate->StopSyncLoop(mSyncLoopTarget, aResult); +} + +void +ScriptExecutorRunnable::LogExceptionToConsole(JSContext* aCx, + WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + + MOZ_ASSERT(mScriptLoader.mRv.IsJSException()); + + JS::Rooted<JS::Value> exn(aCx); + if (!ToJSValue(aCx, mScriptLoader.mRv, &exn)) { + return; + } + + // Now the exception state should all be in exn. + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + MOZ_ASSERT(!mScriptLoader.mRv.Failed()); + + js::ErrorReport report(aCx); + if (!report.init(aCx, exn, js::ErrorReport::WithSideEffects)) { + JS_ClearPendingException(aCx); + return; + } + + RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport(); + xpcReport->Init(report.report(), report.toStringResult().c_str(), + aWorkerPrivate->IsChromeWorker(), aWorkerPrivate->WindowID()); + + RefPtr<AsyncErrorReporter> r = new AsyncErrorReporter(xpcReport); + NS_DispatchToMainThread(r); +} + +void +LoadAllScripts(WorkerPrivate* aWorkerPrivate, + nsTArray<ScriptLoadInfo>& aLoadInfos, bool aIsMainScript, + WorkerScriptType aWorkerScriptType, ErrorResult& aRv) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + NS_ASSERTION(!aLoadInfos.IsEmpty(), "Bad arguments!"); + + AutoSyncLoopHolder syncLoop(aWorkerPrivate); + + RefPtr<ScriptLoaderRunnable> loader = + new ScriptLoaderRunnable(aWorkerPrivate, syncLoop.EventTarget(), + aLoadInfos, aIsMainScript, aWorkerScriptType, + aRv); + + NS_ASSERTION(aLoadInfos.IsEmpty(), "Should have swapped!"); + + ScriptLoaderHolder workerHolder(loader); + + if (NS_WARN_IF(!workerHolder.HoldWorker(aWorkerPrivate, Terminating))) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (NS_FAILED(NS_DispatchToMainThread(loader))) { + NS_ERROR("Failed to dispatch!"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + syncLoop.Run(); +} + +} /* anonymous namespace */ + +BEGIN_WORKERS_NAMESPACE + +namespace scriptloader { + +nsresult +ChannelFromScriptURLMainThread(nsIPrincipal* aPrincipal, + nsIURI* aBaseURI, + nsIDocument* aParentDoc, + nsILoadGroup* aLoadGroup, + const nsAString& aScriptURL, + nsContentPolicyType aContentPolicyType, + bool aDefaultURIEncoding, + nsIChannel** aChannel) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIIOService> ios(do_GetIOService()); + + nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(secMan, "This should never be null!"); + + return ChannelFromScriptURL(aPrincipal, aBaseURI, aParentDoc, aLoadGroup, + ios, secMan, aScriptURL, true, WorkerScript, + aContentPolicyType, nsIRequest::LOAD_NORMAL, + aDefaultURIEncoding, aChannel); +} + +nsresult +ChannelFromScriptURLWorkerThread(JSContext* aCx, + WorkerPrivate* aParent, + const nsAString& aScriptURL, + nsIChannel** aChannel) +{ + aParent->AssertIsOnWorkerThread(); + + RefPtr<ChannelGetterRunnable> getter = + new ChannelGetterRunnable(aParent, aScriptURL, aChannel); + + ErrorResult rv; + getter->Dispatch(rv); + if (rv.Failed()) { + NS_ERROR("Failed to dispatch!"); + return rv.StealNSResult(); + } + + return getter->GetResult(); +} + +void ReportLoadError(ErrorResult& aRv, nsresult aLoadResult, + const nsAString& aScriptURL) +{ + MOZ_ASSERT(!aRv.Failed()); + + switch (aLoadResult) { + case NS_ERROR_FILE_NOT_FOUND: + case NS_ERROR_NOT_AVAILABLE: + aLoadResult = NS_ERROR_DOM_NETWORK_ERR; + break; + + case NS_ERROR_MALFORMED_URI: + aLoadResult = NS_ERROR_DOM_SYNTAX_ERR; + break; + + case NS_BINDING_ABORTED: + // Note: we used to pretend like we didn't set an exception for + // NS_BINDING_ABORTED, but then ShutdownScriptLoader did it anyway. The + // other callsite, in WorkerPrivate::Constructor, never passed in + // NS_BINDING_ABORTED. So just throw it directly here. Consumers will + // deal as needed. But note that we do NOT want to ThrowDOMException() + // for this case, because that will make it impossible for consumers to + // realize that our error was NS_BINDING_ABORTED. + aRv.Throw(aLoadResult); + return; + + case NS_ERROR_DOM_SECURITY_ERR: + case NS_ERROR_DOM_SYNTAX_ERR: + break; + + case NS_ERROR_DOM_BAD_URI: + // This is actually a security error. + aLoadResult = NS_ERROR_DOM_SECURITY_ERR; + break; + + default: + // For lack of anything better, go ahead and throw a NetworkError here. + // We don't want to throw a JS exception, because for toplevel script + // loads that would get squelched. + aRv.ThrowDOMException(NS_ERROR_DOM_NETWORK_ERR, + nsPrintfCString("Failed to load worker script at %s (nsresult = 0x%x)", + NS_ConvertUTF16toUTF8(aScriptURL).get(), + aLoadResult)); + return; + } + + aRv.ThrowDOMException(aLoadResult, + NS_LITERAL_CSTRING("Failed to load worker script at \"") + + NS_ConvertUTF16toUTF8(aScriptURL) + + NS_LITERAL_CSTRING("\"")); +} + +void +LoadMainScript(WorkerPrivate* aWorkerPrivate, + const nsAString& aScriptURL, + WorkerScriptType aWorkerScriptType, + ErrorResult& aRv) +{ + nsTArray<ScriptLoadInfo> loadInfos; + + ScriptLoadInfo* info = loadInfos.AppendElement(); + info->mURL = aScriptURL; + + LoadAllScripts(aWorkerPrivate, loadInfos, true, aWorkerScriptType, aRv); +} + +void +Load(WorkerPrivate* aWorkerPrivate, + const nsTArray<nsString>& aScriptURLs, WorkerScriptType aWorkerScriptType, + ErrorResult& aRv) +{ + const uint32_t urlCount = aScriptURLs.Length(); + + if (!urlCount) { + return; + } + + if (urlCount > MAX_CONCURRENT_SCRIPTS) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + nsTArray<ScriptLoadInfo> loadInfos; + loadInfos.SetLength(urlCount); + + for (uint32_t index = 0; index < urlCount; index++) { + loadInfos[index].mURL = aScriptURLs[index]; + } + + LoadAllScripts(aWorkerPrivate, loadInfos, false, aWorkerScriptType, aRv); +} + +} // namespace scriptloader + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ScriptLoader.h b/dom/workers/ScriptLoader.h new file mode 100644 index 000000000..c92c369ad --- /dev/null +++ b/dom/workers/ScriptLoader.h @@ -0,0 +1,68 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_scriptloader_h__ +#define mozilla_dom_workers_scriptloader_h__ + +#include "Workers.h" +#include "nsIContentPolicyBase.h" + +class nsIPrincipal; +class nsIURI; +class nsIDocument; +class nsILoadGroup; +class nsString; +class nsIChannel; + +namespace mozilla { + +class ErrorResult; + +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +enum WorkerScriptType { + WorkerScript, + DebuggerScript +}; + +namespace scriptloader { + +nsresult +ChannelFromScriptURLMainThread(nsIPrincipal* aPrincipal, + nsIURI* aBaseURI, + nsIDocument* aParentDoc, + nsILoadGroup* aLoadGroup, + const nsAString& aScriptURL, + nsContentPolicyType aContentPolicyType, + bool aDefaultURIEncoding, + nsIChannel** aChannel); + +nsresult +ChannelFromScriptURLWorkerThread(JSContext* aCx, + WorkerPrivate* aParent, + const nsAString& aScriptURL, + nsIChannel** aChannel); + +void ReportLoadError(ErrorResult& aRv, nsresult aLoadResult, + const nsAString& aScriptURL); + +void LoadMainScript(WorkerPrivate* aWorkerPrivate, + const nsAString& aScriptURL, + WorkerScriptType aWorkerScriptType, + ErrorResult& aRv); + +void Load(WorkerPrivate* aWorkerPrivate, + const nsTArray<nsString>& aScriptURLs, + WorkerScriptType aWorkerScriptType, + mozilla::ErrorResult& aRv); + +} // namespace scriptloader + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_scriptloader_h__ */ diff --git a/dom/workers/ServiceWorker.cpp b/dom/workers/ServiceWorker.cpp new file mode 100644 index 000000000..6a6995d59 --- /dev/null +++ b/dom/workers/ServiceWorker.cpp @@ -0,0 +1,103 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorker.h" + +#include "nsIDocument.h" +#include "nsPIDOMWindow.h" +#include "ServiceWorkerClient.h" +#include "ServiceWorkerManager.h" +#include "ServiceWorkerPrivate.h" +#include "WorkerPrivate.h" + +#include "mozilla/Preferences.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/ServiceWorkerGlobalScopeBinding.h" + +#ifdef XP_WIN +#undef PostMessage +#endif + +using mozilla::ErrorResult; +using namespace mozilla::dom; + +namespace mozilla { +namespace dom { +namespace workers { + +bool +ServiceWorkerVisible(JSContext* aCx, JSObject* aObj) +{ + if (NS_IsMainThread()) { + return Preferences::GetBool("dom.serviceWorkers.enabled", false); + } + + return IS_INSTANCE_OF(ServiceWorkerGlobalScope, aObj); +} + +ServiceWorker::ServiceWorker(nsPIDOMWindowInner* aWindow, + ServiceWorkerInfo* aInfo) + : DOMEventTargetHelper(aWindow), + mInfo(aInfo) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aInfo); + + // This will update our state too. + mInfo->AppendWorker(this); +} + +ServiceWorker::~ServiceWorker() +{ + AssertIsOnMainThread(); + mInfo->RemoveWorker(this); +} + +NS_IMPL_ADDREF_INHERITED(ServiceWorker, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(ServiceWorker, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorker) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +JSObject* +ServiceWorker::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + AssertIsOnMainThread(); + + return ServiceWorkerBinding::Wrap(aCx, this, aGivenProto); +} + +void +ServiceWorker::GetScriptURL(nsString& aURL) const +{ + CopyUTF8toUTF16(mInfo->ScriptSpec(), aURL); +} + +void +ServiceWorker::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + if (State() == ServiceWorkerState::Redundant) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(GetParentObject()); + if (!window || !window->GetExtantDoc()) { + NS_WARNING("Trying to call post message from an invalid dom object."); + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + UniquePtr<ServiceWorkerClientInfo> clientInfo(new ServiceWorkerClientInfo(window->GetExtantDoc())); + ServiceWorkerPrivate* workerPrivate = mInfo->WorkerPrivate(); + aRv = workerPrivate->SendMessageEvent(aCx, aMessage, aTransferable, Move(clientInfo)); +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorker.h b/dom/workers/ServiceWorker.h new file mode 100644 index 000000000..e49f334e6 --- /dev/null +++ b/dom/workers/ServiceWorker.h @@ -0,0 +1,85 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworker_h__ +#define mozilla_dom_workers_serviceworker_h__ + +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/ServiceWorkerBinding.h" // For ServiceWorkerState. + +class nsPIDOMWindowInner; + +namespace mozilla { +namespace dom { + +namespace workers { + +class ServiceWorkerInfo; +class ServiceWorkerManager; +class SharedWorker; + +bool +ServiceWorkerVisible(JSContext* aCx, JSObject* aObj); + +class ServiceWorker final : public DOMEventTargetHelper +{ + friend class ServiceWorkerInfo; +public: + NS_DECL_ISUPPORTS_INHERITED + + IMPL_EVENT_HANDLER(statechange) + IMPL_EVENT_HANDLER(error) + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + ServiceWorkerState + State() const + { + return mState; + } + + void + SetState(ServiceWorkerState aState) + { + mState = aState; + } + + void + GetScriptURL(nsString& aURL) const; + + void + DispatchStateChange(ServiceWorkerState aState) + { + DOMEventTargetHelper::DispatchTrustedEvent(NS_LITERAL_STRING("statechange")); + } + +#ifdef XP_WIN +#undef PostMessage +#endif + + void + PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + +private: + // This class can only be created from ServiceWorkerInfo::GetOrCreateInstance(). + ServiceWorker(nsPIDOMWindowInner* aWindow, ServiceWorkerInfo* aInfo); + + // This class is reference-counted and will be destroyed from Release(). + ~ServiceWorker(); + + ServiceWorkerState mState; + const RefPtr<ServiceWorkerInfo> mInfo; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworker_h__ diff --git a/dom/workers/ServiceWorkerClient.cpp b/dom/workers/ServiceWorkerClient.cpp new file mode 100644 index 000000000..660512a5f --- /dev/null +++ b/dom/workers/ServiceWorkerClient.cpp @@ -0,0 +1,232 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "ServiceWorkerClient.h" +#include "ServiceWorkerContainer.h" + +#include "mozilla/dom/MessageEvent.h" +#include "mozilla/dom/Navigator.h" +#include "mozilla/dom/ServiceWorkerMessageEvent.h" +#include "mozilla/dom/ServiceWorkerMessageEventBinding.h" +#include "nsGlobalWindow.h" +#include "nsIBrowserDOMWindow.h" +#include "nsIDocument.h" +#include "ServiceWorker.h" +#include "ServiceWorkerPrivate.h" +#include "WorkerPrivate.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::dom::workers; + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ServiceWorkerClient, mOwner) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(ServiceWorkerClient) +NS_IMPL_CYCLE_COLLECTING_RELEASE(ServiceWorkerClient) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServiceWorkerClient) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +ServiceWorkerClientInfo::ServiceWorkerClientInfo(nsIDocument* aDoc) + : mWindowId(0) + , mFrameType(FrameType::None) +{ + MOZ_ASSERT(aDoc); + nsresult rv = aDoc->GetOrCreateId(mClientId); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to get the UUID of the document."); + } + + RefPtr<nsGlobalWindow> innerWindow = nsGlobalWindow::Cast(aDoc->GetInnerWindow()); + if (innerWindow) { + // XXXcatalinb: The inner window can be null if the document is navigating + // and was detached. + mWindowId = innerWindow->WindowID(); + } + + nsCOMPtr<nsIURI> originalURI = aDoc->GetOriginalURI(); + if (originalURI) { + nsAutoCString spec; + originalURI->GetSpec(spec); + CopyUTF8toUTF16(spec, mUrl); + } + mVisibilityState = aDoc->VisibilityState(); + + ErrorResult result; + mFocused = aDoc->HasFocus(result); + if (result.Failed()) { + NS_WARNING("Failed to get focus information."); + } + + RefPtr<nsGlobalWindow> outerWindow = nsGlobalWindow::Cast(aDoc->GetWindow()); + if (!outerWindow) { + MOZ_ASSERT(mFrameType == FrameType::None); + } else if (!outerWindow->IsTopLevelWindow()) { + mFrameType = FrameType::Nested; + } else if (outerWindow->HadOriginalOpener()) { + mFrameType = FrameType::Auxiliary; + } else { + mFrameType = FrameType::Top_level; + } +} + +JSObject* +ServiceWorkerClient::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return ClientBinding::Wrap(aCx, this, aGivenProto); +} + +namespace { + +class ServiceWorkerClientPostMessageRunnable final + : public Runnable + , public StructuredCloneHolder +{ + uint64_t mWindowId; + +public: + explicit ServiceWorkerClientPostMessageRunnable(uint64_t aWindowId) + : StructuredCloneHolder(CloningSupported, TransferringSupported, + StructuredCloneScope::SameProcessDifferentThread) + , mWindowId(aWindowId) + {} + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + nsGlobalWindow* window = nsGlobalWindow::GetInnerWindowWithId(mWindowId); + if (!window) { + return NS_ERROR_FAILURE; + } + + ErrorResult result; + dom::Navigator* navigator = window->GetNavigator(result); + if (NS_WARN_IF(result.Failed())) { + return result.StealNSResult(); + } + + RefPtr<ServiceWorkerContainer> container = navigator->ServiceWorker(); + AutoJSAPI jsapi; + if (NS_WARN_IF(!jsapi.Init(window))) { + return NS_ERROR_FAILURE; + } + JSContext* cx = jsapi.cx(); + + return DispatchDOMEvent(cx, container); + } + +private: + NS_IMETHOD + DispatchDOMEvent(JSContext* aCx, ServiceWorkerContainer* aTargetContainer) + { + AssertIsOnMainThread(); + + MOZ_ASSERT(aTargetContainer->GetParentObject(), + "How come we don't have a window here?!"); + + JS::Rooted<JS::Value> messageData(aCx); + ErrorResult rv; + Read(aTargetContainer->GetParentObject(), aCx, &messageData, rv); + if (NS_WARN_IF(rv.Failed())) { + xpc::Throw(aCx, rv.StealNSResult()); + return NS_ERROR_FAILURE; + } + + RootedDictionary<ServiceWorkerMessageEventInit> init(aCx); + + nsCOMPtr<nsIPrincipal> principal = aTargetContainer->GetParentObject()->PrincipalOrNull(); + NS_WARNING_ASSERTION(principal, "Why is the principal null here?"); + + bool isNullPrincipal = false; + bool isSystemPrincipal = false; + if (principal) { + isNullPrincipal = principal->GetIsNullPrincipal(); + MOZ_ASSERT(!isNullPrincipal); + isSystemPrincipal = principal->GetIsSystemPrincipal(); + MOZ_ASSERT(!isSystemPrincipal); + } + + init.mData = messageData; + nsAutoCString origin; + if (principal && !isNullPrincipal && !isSystemPrincipal) { + principal->GetOrigin(origin); + } + init.mOrigin = NS_ConvertUTF8toUTF16(origin); + + RefPtr<ServiceWorker> serviceWorker = aTargetContainer->GetController(); + if (serviceWorker) { + init.mSource.SetValue().SetAsServiceWorker() = serviceWorker; + } + + if (!TakeTransferredPortsAsSequence(init.mPorts)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + RefPtr<ServiceWorkerMessageEvent> event = + ServiceWorkerMessageEvent::Constructor(aTargetContainer, + NS_LITERAL_STRING("message"), + init); + + event->SetTrusted(true); + bool status = false; + aTargetContainer->DispatchEvent(static_cast<dom::Event*>(event.get()), + &status); + + if (!status) { + return NS_ERROR_FAILURE; + } + + return NS_OK; + } +}; + +} // namespace + +void +ServiceWorkerClient::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + + JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue()); + if (aTransferable.WasPassed()) { + const Sequence<JS::Value>& realTransferable = aTransferable.Value(); + + JS::HandleValueArray elements = + JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(), + realTransferable.Elements()); + + JSObject* array = JS_NewArrayObject(aCx, elements); + if (!array) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + transferable.setObject(*array); + } + + RefPtr<ServiceWorkerClientPostMessageRunnable> runnable = + new ServiceWorkerClientPostMessageRunnable(mWindowId); + + runnable->Write(aCx, aMessage, transferable, JS::CloneDataPolicy().denySharedArrayBuffer(), + aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + aRv = workerPrivate->DispatchToMainThread(runnable.forget()); + if (NS_WARN_IF(aRv.Failed())) { + return; + } +} + diff --git a/dom/workers/ServiceWorkerClient.h b/dom/workers/ServiceWorkerClient.h new file mode 100644 index 000000000..36a9cc168 --- /dev/null +++ b/dom/workers/ServiceWorkerClient.h @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef mozilla_dom_workers_serviceworkerclient_h +#define mozilla_dom_workers_serviceworkerclient_h + +#include "nsCOMPtr.h" +#include "nsWrapperCache.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/ClientBinding.h" + +class nsIDocument; + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerClient; +class ServiceWorkerWindowClient; + +// Used as a container object for information needed to create +// client objects. +class ServiceWorkerClientInfo final +{ + friend class ServiceWorkerClient; + friend class ServiceWorkerWindowClient; + +public: + explicit ServiceWorkerClientInfo(nsIDocument* aDoc); + + const nsString& ClientId() const + { + return mClientId; + } + +private: + nsString mClientId; + uint64_t mWindowId; + nsString mUrl; + + // Window Clients + VisibilityState mVisibilityState; + bool mFocused; + FrameType mFrameType; +}; + +class ServiceWorkerClient : public nsISupports, + public nsWrapperCache +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ServiceWorkerClient) + + ServiceWorkerClient(nsISupports* aOwner, + const ServiceWorkerClientInfo& aClientInfo) + : mOwner(aOwner) + , mId(aClientInfo.mClientId) + , mUrl(aClientInfo.mUrl) + , mWindowId(aClientInfo.mWindowId) + , mFrameType(aClientInfo.mFrameType) + { + MOZ_ASSERT(aOwner); + } + + nsISupports* + GetParentObject() const + { + return mOwner; + } + + void GetId(nsString& aRetval) const + { + aRetval = mId; + } + + void + GetUrl(nsAString& aUrl) const + { + aUrl.Assign(mUrl); + } + + mozilla::dom::FrameType + FrameType() const + { + return mFrameType; + } + + void + PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + + JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + +protected: + virtual ~ServiceWorkerClient() + { } + +private: + nsCOMPtr<nsISupports> mOwner; + nsString mId; + nsString mUrl; + +protected: + uint64_t mWindowId; + mozilla::dom::FrameType mFrameType; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerclient_h diff --git a/dom/workers/ServiceWorkerClients.cpp b/dom/workers/ServiceWorkerClients.cpp new file mode 100644 index 000000000..11f864443 --- /dev/null +++ b/dom/workers/ServiceWorkerClients.cpp @@ -0,0 +1,864 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerClients.h" + +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" + +#include "ServiceWorkerClient.h" +#include "ServiceWorkerManager.h" +#include "ServiceWorkerPrivate.h" +#include "ServiceWorkerWindowClient.h" + +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" + +#include "nsContentUtils.h" +#include "nsIBrowserDOMWindow.h" +#include "nsIDocShell.h" +#include "nsIDOMChromeWindow.h" +#include "nsIDOMWindow.h" +#include "nsIWebNavigation.h" +#include "nsIWebProgress.h" +#include "nsIWebProgressListener.h" +#include "nsIWindowMediator.h" +#include "nsIWindowWatcher.h" +#include "nsNetUtil.h" +#include "nsPIWindowWatcher.h" +#include "nsWindowWatcher.h" +#include "nsWeakReference.h" + +#ifdef MOZ_WIDGET_ANDROID +#include "AndroidBridge.h" +#endif + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::dom::workers; + +NS_IMPL_CYCLE_COLLECTING_ADDREF(ServiceWorkerClients) +NS_IMPL_CYCLE_COLLECTING_RELEASE(ServiceWorkerClients) +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ServiceWorkerClients, mWorkerScope) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServiceWorkerClients) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +ServiceWorkerClients::ServiceWorkerClients(ServiceWorkerGlobalScope* aWorkerScope) + : mWorkerScope(aWorkerScope) +{ + MOZ_ASSERT(mWorkerScope); +} + +JSObject* +ServiceWorkerClients::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return ClientsBinding::Wrap(aCx, this, aGivenProto); +} + +namespace { + +class GetRunnable final : public Runnable +{ + class ResolvePromiseWorkerRunnable final : public WorkerRunnable + { + RefPtr<PromiseWorkerProxy> mPromiseProxy; + UniquePtr<ServiceWorkerClientInfo> mValue; + nsresult mRv; + + public: + ResolvePromiseWorkerRunnable(WorkerPrivate* aWorkerPrivate, + PromiseWorkerProxy* aPromiseProxy, + UniquePtr<ServiceWorkerClientInfo>&& aValue, + nsresult aRv) + : WorkerRunnable(aWorkerPrivate), + mPromiseProxy(aPromiseProxy), + mValue(Move(aValue)), + mRv(Move(aRv)) + { + AssertIsOnMainThread(); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + Promise* promise = mPromiseProxy->WorkerPromise(); + MOZ_ASSERT(promise); + + if (NS_FAILED(mRv)) { + promise->MaybeReject(mRv); + } else if (mValue) { + RefPtr<ServiceWorkerWindowClient> windowClient = + new ServiceWorkerWindowClient(promise->GetParentObject(), *mValue); + promise->MaybeResolve(windowClient.get()); + } else { + promise->MaybeResolveWithUndefined(); + } + mPromiseProxy->CleanUp(); + return true; + } + }; + + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsString mClientId; +public: + GetRunnable(PromiseWorkerProxy* aPromiseProxy, + const nsAString& aClientId) + : mPromiseProxy(aPromiseProxy), + mClientId(aClientId) + { + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + UniquePtr<ServiceWorkerClientInfo> result; + ErrorResult rv; + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + rv = NS_ERROR_FAILURE; + } else { + result = swm->GetClient(workerPrivate->GetPrincipal(), mClientId, rv); + } + + RefPtr<ResolvePromiseWorkerRunnable> r = + new ResolvePromiseWorkerRunnable(mPromiseProxy->GetWorkerPrivate(), + mPromiseProxy, Move(result), + rv.StealNSResult()); + rv.SuppressException(); + + r->Dispatch(); + return NS_OK; + } +}; + +class MatchAllRunnable final : public Runnable +{ + class ResolvePromiseWorkerRunnable final : public WorkerRunnable + { + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsTArray<ServiceWorkerClientInfo> mValue; + + public: + ResolvePromiseWorkerRunnable(WorkerPrivate* aWorkerPrivate, + PromiseWorkerProxy* aPromiseProxy, + nsTArray<ServiceWorkerClientInfo>& aValue) + : WorkerRunnable(aWorkerPrivate), + mPromiseProxy(aPromiseProxy) + { + AssertIsOnMainThread(); + mValue.SwapElements(aValue); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + Promise* promise = mPromiseProxy->WorkerPromise(); + MOZ_ASSERT(promise); + + nsTArray<RefPtr<ServiceWorkerClient>> ret; + for (size_t i = 0; i < mValue.Length(); i++) { + ret.AppendElement(RefPtr<ServiceWorkerClient>( + new ServiceWorkerWindowClient(promise->GetParentObject(), + mValue.ElementAt(i)))); + } + + promise->MaybeResolve(ret); + mPromiseProxy->CleanUp(); + return true; + } + }; + + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsCString mScope; + bool mIncludeUncontrolled; +public: + MatchAllRunnable(PromiseWorkerProxy* aPromiseProxy, + const nsCString& aScope, + bool aIncludeUncontrolled) + : mPromiseProxy(aPromiseProxy), + mScope(aScope), + mIncludeUncontrolled(aIncludeUncontrolled) + { + MOZ_ASSERT(mPromiseProxy); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + nsTArray<ServiceWorkerClientInfo> result; + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->GetAllClients(mPromiseProxy->GetWorkerPrivate()->GetPrincipal(), + mScope, mIncludeUncontrolled, result); + } + RefPtr<ResolvePromiseWorkerRunnable> r = + new ResolvePromiseWorkerRunnable(mPromiseProxy->GetWorkerPrivate(), + mPromiseProxy, result); + + r->Dispatch(); + return NS_OK; + } +}; + +class ResolveClaimRunnable final : public WorkerRunnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsresult mResult; + +public: + ResolveClaimRunnable(WorkerPrivate* aWorkerPrivate, + PromiseWorkerProxy* aPromiseProxy, + nsresult aResult) + : WorkerRunnable(aWorkerPrivate) + , mPromiseProxy(aPromiseProxy) + , mResult(aResult) + { + AssertIsOnMainThread(); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<Promise> promise = mPromiseProxy->WorkerPromise(); + MOZ_ASSERT(promise); + + if (NS_SUCCEEDED(mResult)) { + promise->MaybeResolveWithUndefined(); + } else { + promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR); + } + + mPromiseProxy->CleanUp(); + return true; + } +}; + +class ClaimRunnable final : public Runnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsCString mScope; + uint64_t mServiceWorkerID; + +public: + ClaimRunnable(PromiseWorkerProxy* aPromiseProxy, const nsCString& aScope) + : mPromiseProxy(aPromiseProxy) + , mScope(aScope) + // Safe to call GetWorkerPrivate() since we are being called on the worker + // thread via script (so no clean up has occured yet). + , mServiceWorkerID(aPromiseProxy->GetWorkerPrivate()->ServiceWorkerID()) + { + MOZ_ASSERT(aPromiseProxy); + } + + NS_IMETHOD + Run() override + { + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + nsresult rv = NS_OK; + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + rv = NS_ERROR_FAILURE; + } else { + rv = swm->ClaimClients(workerPrivate->GetPrincipal(), mScope, + mServiceWorkerID); + } + + RefPtr<ResolveClaimRunnable> r = + new ResolveClaimRunnable(workerPrivate, mPromiseProxy, rv); + + r->Dispatch(); + return NS_OK; + } +}; + +class ResolveOpenWindowRunnable final : public WorkerRunnable +{ +public: + ResolveOpenWindowRunnable(PromiseWorkerProxy* aPromiseProxy, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo, + const nsresult aStatus) + : WorkerRunnable(aPromiseProxy->GetWorkerPrivate()) + , mPromiseProxy(aPromiseProxy) + , mClientInfo(Move(aClientInfo)) + , mStatus(aStatus) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aPromiseProxy); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + Promise* promise = mPromiseProxy->WorkerPromise(); + if (NS_WARN_IF(NS_FAILED(mStatus))) { + promise->MaybeReject(mStatus); + } else if (mClientInfo) { + RefPtr<ServiceWorkerWindowClient> client = + new ServiceWorkerWindowClient(promise->GetParentObject(), + *mClientInfo); + promise->MaybeResolve(client); + } else { + promise->MaybeResolve(JS::NullHandleValue); + } + + mPromiseProxy->CleanUp(); + return true; + } + +private: + RefPtr<PromiseWorkerProxy> mPromiseProxy; + UniquePtr<ServiceWorkerClientInfo> mClientInfo; + const nsresult mStatus; +}; + +class WebProgressListener final : public nsIWebProgressListener, + public nsSupportsWeakReference +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(WebProgressListener, nsIWebProgressListener) + + WebProgressListener(PromiseWorkerProxy* aPromiseProxy, + ServiceWorkerPrivate* aServiceWorkerPrivate, + nsPIDOMWindowOuter* aWindow, + nsIURI* aBaseURI) + : mPromiseProxy(aPromiseProxy) + , mServiceWorkerPrivate(aServiceWorkerPrivate) + , mWindow(aWindow) + , mBaseURI(aBaseURI) + { + MOZ_ASSERT(aPromiseProxy); + MOZ_ASSERT(aServiceWorkerPrivate); + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aWindow->IsOuterWindow()); + MOZ_ASSERT(aBaseURI); + AssertIsOnMainThread(); + + mServiceWorkerPrivate->StoreISupports(static_cast<nsIWebProgressListener*>(this)); + } + + NS_IMETHOD + OnStateChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + uint32_t aStateFlags, nsresult aStatus) override + { + if (!(aStateFlags & STATE_IS_DOCUMENT) || + !(aStateFlags & (STATE_STOP | STATE_TRANSFERRING))) { + return NS_OK; + } + + // Our caller keeps a strong reference, so it is safe to remove the listener + // from ServiceWorkerPrivate. + mServiceWorkerPrivate->RemoveISupports(static_cast<nsIWebProgressListener*>(this)); + aWebProgress->RemoveProgressListener(this); + + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + nsCOMPtr<nsIDocument> doc = mWindow->GetExtantDoc(); + UniquePtr<ServiceWorkerClientInfo> clientInfo; + if (doc) { + // Check same origin. + nsCOMPtr<nsIScriptSecurityManager> securityManager = + nsContentUtils::GetSecurityManager(); + nsresult rv = securityManager->CheckSameOriginURI(doc->GetOriginalURI(), + mBaseURI, false); + if (NS_SUCCEEDED(rv)) { + clientInfo.reset(new ServiceWorkerClientInfo(doc)); + } + } + + RefPtr<ResolveOpenWindowRunnable> r = + new ResolveOpenWindowRunnable(mPromiseProxy, + Move(clientInfo), + NS_OK); + r->Dispatch(); + + return NS_OK; + } + + NS_IMETHOD + OnProgressChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + int32_t aCurSelfProgress, + int32_t aMaxSelfProgress, + int32_t aCurTotalProgress, + int32_t aMaxTotalProgress) override + { + MOZ_ASSERT(false, "Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnLocationChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsIURI* aLocation, + uint32_t aFlags) override + { + MOZ_ASSERT(false, "Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnStatusChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsresult aStatus, const char16_t* aMessage) override + { + MOZ_ASSERT(false, "Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnSecurityChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + uint32_t aState) override + { + MOZ_ASSERT(false, "Unexpected notification."); + return NS_OK; + } + +private: + ~WebProgressListener() + { } + + RefPtr<PromiseWorkerProxy> mPromiseProxy; + RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate; + nsCOMPtr<nsPIDOMWindowOuter> mWindow; + nsCOMPtr<nsIURI> mBaseURI; +}; + +NS_IMPL_CYCLE_COLLECTING_ADDREF(WebProgressListener) +NS_IMPL_CYCLE_COLLECTING_RELEASE(WebProgressListener) +NS_IMPL_CYCLE_COLLECTION(WebProgressListener, mPromiseProxy, + mServiceWorkerPrivate, mWindow) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END + +class OpenWindowRunnable final : public Runnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsString mUrl; + nsString mScope; + +public: + OpenWindowRunnable(PromiseWorkerProxy* aPromiseProxy, + const nsAString& aUrl, + const nsAString& aScope) + : mPromiseProxy(aPromiseProxy) + , mUrl(aUrl) + , mScope(aScope) + { + MOZ_ASSERT(aPromiseProxy); + MOZ_ASSERT(aPromiseProxy->GetWorkerPrivate()); + aPromiseProxy->GetWorkerPrivate()->AssertIsOnWorkerThread(); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + +#ifdef MOZ_WIDGET_ANDROID + // This fires an intent that will start launching Fennec and foreground it, + // if necessary. + java::GeckoAppShell::OpenWindowForNotification(); +#endif + + nsCOMPtr<nsPIDOMWindowOuter> window; + nsresult rv = OpenWindow(getter_AddRefs(window)); + if (NS_SUCCEEDED(rv)) { + MOZ_ASSERT(window); + + rv = nsContentUtils::DispatchFocusChromeEvent(window); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + WorkerPrivate::LocationInfo& info = workerPrivate->GetLocationInfo(); + nsCOMPtr<nsIURI> baseURI; + nsresult rv = NS_NewURI(getter_AddRefs(baseURI), info.mHref); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIDocShell> docShell = window->GetDocShell(); + nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell); + + if (!webProgress) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIPrincipal> principal = workerPrivate->GetPrincipal(); + MOZ_ASSERT(principal); + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(principal, NS_ConvertUTF16toUTF8(mScope)); + if (NS_WARN_IF(!registration)) { + return NS_ERROR_FAILURE; + } + RefPtr<ServiceWorkerInfo> serviceWorkerInfo = + registration->GetServiceWorkerInfoById(workerPrivate->ServiceWorkerID()); + if (NS_WARN_IF(!serviceWorkerInfo)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIWebProgressListener> listener = + new WebProgressListener(mPromiseProxy, serviceWorkerInfo->WorkerPrivate(), + window, baseURI); + + rv = webProgress->AddProgressListener(listener, + nsIWebProgress::NOTIFY_STATE_DOCUMENT); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return NS_OK; + } +#ifdef MOZ_WIDGET_ANDROID + else if (rv == NS_ERROR_NOT_AVAILABLE) { + // We couldn't get a browser window, so Fennec must not be running. + // Send an Intent to launch Fennec and wait for "BrowserChrome:Ready" + // to try opening a window again. + nsCOMPtr<nsIObserverService> os = services::GetObserverService(); + NS_ENSURE_STATE(os); + + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIPrincipal> principal = workerPrivate->GetPrincipal(); + MOZ_ASSERT(principal); + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(principal, NS_ConvertUTF16toUTF8(mScope)); + if (NS_WARN_IF(!registration)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerInfo> serviceWorkerInfo = + registration->GetServiceWorkerInfoById(workerPrivate->ServiceWorkerID()); + if (NS_WARN_IF(!serviceWorkerInfo)) { + return NS_ERROR_FAILURE; + } + + os->AddObserver(static_cast<nsIObserver*>(serviceWorkerInfo->WorkerPrivate()), + "BrowserChrome:Ready", true); + serviceWorkerInfo->WorkerPrivate()->AddPendingWindow(this); + return NS_OK; + } +#endif + + RefPtr<ResolveOpenWindowRunnable> resolveRunnable = + new ResolveOpenWindowRunnable(mPromiseProxy, nullptr, rv); + + Unused << NS_WARN_IF(!resolveRunnable->Dispatch()); + + return NS_OK; + } + +private: + nsresult + OpenWindow(nsPIDOMWindowOuter** aWindow) + { + MOZ_DIAGNOSTIC_ASSERT(aWindow); + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + + // [[1. Let url be the result of parsing url with entry settings object's API + // base URL.]] + nsCOMPtr<nsIURI> uri; + WorkerPrivate::LocationInfo& info = workerPrivate->GetLocationInfo(); + + nsCOMPtr<nsIURI> baseURI; + nsresult rv = NS_NewURI(getter_AddRefs(baseURI), info.mHref); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_TYPE_ERR; + } + + rv = NS_NewURI(getter_AddRefs(uri), mUrl, nullptr, baseURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_TYPE_ERR; + } + + // [[6.1 Open Window]] + nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, + &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (XRE_IsContentProcess()) { + // ContentProcess + nsCOMPtr<nsIWindowWatcher> wwatch = + do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + nsCOMPtr<nsPIWindowWatcher> pwwatch(do_QueryInterface(wwatch)); + NS_ENSURE_STATE(pwwatch); + + nsCString spec; + rv = uri->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<mozIDOMWindowProxy> newWindow; + rv = pwwatch->OpenWindow2(nullptr, + spec.get(), + nullptr, + nullptr, + false, false, true, nullptr, + // Not a spammy popup; we got permission, we swear! + /* aIsPopupSpam = */ false, + // Don't force noopener. We're not passing in an + // opener anyway, and we _do_ want the returned + // window. + /* aForceNoOpener = */ false, + /* aLoadInfp = */ nullptr, + getter_AddRefs(newWindow)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + nsCOMPtr<nsPIDOMWindowOuter> pwindow = nsPIDOMWindowOuter::From(newWindow); + pwindow.forget(aWindow); + MOZ_DIAGNOSTIC_ASSERT(*aWindow); + return NS_OK; + } + + // Find the most recent browser window and open a new tab in it. + nsCOMPtr<nsPIDOMWindowOuter> browserWindow = + nsContentUtils::GetMostRecentNonPBWindow(); + if (!browserWindow) { + // It is possible to be running without a browser window on Mac OS, so + // we need to open a new chrome window. + // TODO(catalinb): open new chrome window. Bug 1218080 + return NS_ERROR_NOT_AVAILABLE; + } + + nsCOMPtr<nsIDOMChromeWindow> chromeWin = do_QueryInterface(browserWindow); + if (NS_WARN_IF(!chromeWin)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIBrowserDOMWindow> bwin; + chromeWin->GetBrowserDOMWindow(getter_AddRefs(bwin)); + + if (NS_WARN_IF(!bwin)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<mozIDOMWindowProxy> win; + rv = bwin->OpenURI(uri, nullptr, + nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW, + nsIBrowserDOMWindow::OPEN_NEW, + getter_AddRefs(win)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + NS_ENSURE_STATE(win); + + nsCOMPtr<nsPIDOMWindowOuter> pWin = nsPIDOMWindowOuter::From(win); + pWin.forget(aWindow); + MOZ_DIAGNOSTIC_ASSERT(*aWindow); + + return NS_OK; + } +}; + +} // namespace + +already_AddRefed<Promise> +ServiceWorkerClients::Get(const nsAString& aClientId, ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + + RefPtr<Promise> promise = Promise::Create(mWorkerScope, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + if (!promiseProxy) { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + return promise.forget(); + } + + RefPtr<GetRunnable> r = + new GetRunnable(promiseProxy, aClientId); + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(r.forget())); + return promise.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerClients::MatchAll(const ClientQueryOptions& aOptions, + ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + + nsString scope; + mWorkerScope->GetScope(scope); + + if (aOptions.mType != ClientType::Window) { + aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); + return nullptr; + } + + RefPtr<Promise> promise = Promise::Create(mWorkerScope, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + if (!promiseProxy) { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + return promise.forget(); + } + + RefPtr<MatchAllRunnable> r = + new MatchAllRunnable(promiseProxy, + NS_ConvertUTF16toUTF8(scope), + aOptions.mIncludeUncontrolled); + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(r.forget())); + return promise.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerClients::OpenWindow(const nsAString& aUrl, + ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + RefPtr<Promise> promise = Promise::Create(mWorkerScope, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + if (aUrl.EqualsLiteral("about:blank")) { + promise->MaybeReject(NS_ERROR_TYPE_ERR); + return promise.forget(); + } + + // [[4. If this algorithm is not allowed to show a popup ..]] + // In Gecko the service worker is allowed to show a popup only if the user + // just clicked on a notification. + if (!workerPrivate->GlobalScope()->WindowInteractionAllowed()) { + promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR); + return promise.forget(); + } + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + + if (!promiseProxy) { + return nullptr; + } + + nsString scope; + mWorkerScope->GetScope(scope); + + RefPtr<OpenWindowRunnable> r = new OpenWindowRunnable(promiseProxy, + aUrl, scope); + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(r.forget())); + + return promise.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerClients::Claim(ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + RefPtr<Promise> promise = Promise::Create(mWorkerScope, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + if (!promiseProxy) { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + return promise.forget(); + } + + nsString scope; + mWorkerScope->GetScope(scope); + + RefPtr<ClaimRunnable> runnable = + new ClaimRunnable(promiseProxy, NS_ConvertUTF16toUTF8(scope)); + + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(runnable.forget())); + return promise.forget(); +} diff --git a/dom/workers/ServiceWorkerClients.h b/dom/workers/ServiceWorkerClients.h new file mode 100644 index 000000000..3c507516f --- /dev/null +++ b/dom/workers/ServiceWorkerClients.h @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef mozilla_dom_workers_serviceworkerclients_h +#define mozilla_dom_workers_serviceworkerclients_h + +#include "nsWrapperCache.h" + +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/ClientsBinding.h" +#include "mozilla/ErrorResult.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerClients final : public nsISupports, + public nsWrapperCache +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ServiceWorkerClients) + + explicit ServiceWorkerClients(ServiceWorkerGlobalScope* aWorkerScope); + + already_AddRefed<Promise> + Get(const nsAString& aClientId, ErrorResult& aRv); + + already_AddRefed<Promise> + MatchAll(const ClientQueryOptions& aOptions, ErrorResult& aRv); + + already_AddRefed<Promise> + OpenWindow(const nsAString& aUrl, ErrorResult& aRv); + + already_AddRefed<Promise> + Claim(ErrorResult& aRv); + + JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + ServiceWorkerGlobalScope* + GetParentObject() const + { + return mWorkerScope; + } + +private: + ~ServiceWorkerClients() + { + } + + RefPtr<ServiceWorkerGlobalScope> mWorkerScope; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerclients_h diff --git a/dom/workers/ServiceWorkerCommon.h b/dom/workers/ServiceWorkerCommon.h new file mode 100644 index 000000000..1c272c125 --- /dev/null +++ b/dom/workers/ServiceWorkerCommon.h @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ServiceWorkerCommon_h +#define mozilla_dom_ServiceWorkerCommon_h + +namespace mozilla { +namespace dom { + +// Use multiples of 2 since they can be bitwise ORed when calling +// InvalidateServiceWorkerRegistrationWorker. +enum class WhichServiceWorker { + INSTALLING_WORKER = 1, + WAITING_WORKER = 2, + ACTIVE_WORKER = 4, +}; +MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(WhichServiceWorker) + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ServiceWorkerCommon_h diff --git a/dom/workers/ServiceWorkerContainer.cpp b/dom/workers/ServiceWorkerContainer.cpp new file mode 100644 index 000000000..274d72d50 --- /dev/null +++ b/dom/workers/ServiceWorkerContainer.cpp @@ -0,0 +1,341 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerContainer.h" + +#include "nsContentUtils.h" +#include "nsIDocument.h" +#include "nsIServiceWorkerManager.h" +#include "nsIURL.h" +#include "nsNetUtil.h" +#include "nsPIDOMWindow.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" + +#include "nsCycleCollectionParticipant.h" +#include "nsServiceManagerUtils.h" + +#include "mozilla/dom/Navigator.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/ServiceWorkerContainerBinding.h" +#include "mozilla/dom/workers/bindings/ServiceWorker.h" + +#include "ServiceWorker.h" + +namespace mozilla { +namespace dom { + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorkerContainer) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_ADDREF_INHERITED(ServiceWorkerContainer, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(ServiceWorkerContainer, DOMEventTargetHelper) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(ServiceWorkerContainer, DOMEventTargetHelper, + mControllerWorker, mReadyPromise) + +/* static */ bool +ServiceWorkerContainer::IsEnabled(JSContext* aCx, JSObject* aGlobal) +{ + MOZ_ASSERT(NS_IsMainThread()); + + JS::Rooted<JSObject*> global(aCx, aGlobal); + nsCOMPtr<nsPIDOMWindowInner> window = Navigator::GetWindowFromGlobal(global); + if (!window) { + return false; + } + + nsIDocument* doc = window->GetExtantDoc(); + if (!doc || nsContentUtils::IsInPrivateBrowsing(doc)) { + return false; + } + + return Preferences::GetBool("dom.serviceWorkers.enabled", false); +} + +ServiceWorkerContainer::ServiceWorkerContainer(nsPIDOMWindowInner* aWindow) + : DOMEventTargetHelper(aWindow) +{ +} + +ServiceWorkerContainer::~ServiceWorkerContainer() +{ + RemoveReadyPromise(); +} + +void +ServiceWorkerContainer::DisconnectFromOwner() +{ + mControllerWorker = nullptr; + RemoveReadyPromise(); + DOMEventTargetHelper::DisconnectFromOwner(); +} + +void +ServiceWorkerContainer::ControllerChanged(ErrorResult& aRv) +{ + mControllerWorker = nullptr; + aRv = DispatchTrustedEvent(NS_LITERAL_STRING("controllerchange")); +} + +void +ServiceWorkerContainer::RemoveReadyPromise() +{ + if (nsCOMPtr<nsPIDOMWindowInner> window = GetOwner()) { + nsCOMPtr<nsIServiceWorkerManager> swm = + mozilla::services::GetServiceWorkerManager(); + if (!swm) { + // If the browser is shutting down, we don't need to remove the promise. + return; + } + + swm->RemoveReadyPromise(window); + } +} + +JSObject* +ServiceWorkerContainer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return ServiceWorkerContainerBinding::Wrap(aCx, this, aGivenProto); +} + +static nsresult +CheckForSlashEscapedCharsInPath(nsIURI* aURI) +{ + MOZ_ASSERT(aURI); + + // A URL that can't be downcast to a standard URL is an invalid URL and should + // be treated as such and fail with SecurityError. + nsCOMPtr<nsIURL> url(do_QueryInterface(aURI)); + if (NS_WARN_IF(!url)) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsAutoCString path; + nsresult rv = url->GetFilePath(path); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + ToLowerCase(path); + if (path.Find("%2f") != kNotFound || + path.Find("%5c") != kNotFound) { + return NS_ERROR_DOM_TYPE_ERR; + } + + return NS_OK; +} + +already_AddRefed<Promise> +ServiceWorkerContainer::Register(const nsAString& aScriptURL, + const RegistrationOptions& aOptions, + ErrorResult& aRv) +{ + nsCOMPtr<nsISupports> promise; + + nsCOMPtr<nsIServiceWorkerManager> swm = mozilla::services::GetServiceWorkerManager(); + if (!swm) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsCOMPtr<nsIURI> baseURI; + + nsIDocument* doc = GetEntryDocument(); + if (doc) { + baseURI = doc->GetBaseURI(); + } else { + // XXXnsm. One of our devtools browser test calls register() from a content + // script where there is no valid entry document. Use the window to resolve + // the uri in that case. + nsCOMPtr<nsPIDOMWindowInner> window = GetOwner(); + nsCOMPtr<nsPIDOMWindowOuter> outerWindow; + if (window && (outerWindow = window->GetOuterWindow()) && + outerWindow->GetServiceWorkersTestingEnabled()) { + baseURI = window->GetDocBaseURI(); + } + } + + nsresult rv; + nsCOMPtr<nsIURI> scriptURI; + rv = NS_NewURI(getter_AddRefs(scriptURI), aScriptURL, nullptr, baseURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + aRv.ThrowTypeError<MSG_INVALID_URL>(aScriptURL); + return nullptr; + } + + aRv = CheckForSlashEscapedCharsInPath(scriptURI); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + // In ServiceWorkerContainer.register() the scope argument is parsed against + // different base URLs depending on whether it was passed or not. + nsCOMPtr<nsIURI> scopeURI; + + // Step 4. If none passed, parse against script's URL + if (!aOptions.mScope.WasPassed()) { + NS_NAMED_LITERAL_STRING(defaultScope, "./"); + rv = NS_NewURI(getter_AddRefs(scopeURI), defaultScope, + nullptr, scriptURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + nsAutoCString spec; + scriptURI->GetSpec(spec); + NS_ConvertUTF8toUTF16 wSpec(spec); + aRv.ThrowTypeError<MSG_INVALID_SCOPE>(defaultScope, wSpec); + return nullptr; + } + } else { + // Step 5. Parse against entry settings object's base URL. + rv = NS_NewURI(getter_AddRefs(scopeURI), aOptions.mScope.Value(), + nullptr, baseURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + nsIURI* uri = baseURI ? baseURI : scriptURI; + nsAutoCString spec; + uri->GetSpec(spec); + NS_ConvertUTF8toUTF16 wSpec(spec); + aRv.ThrowTypeError<MSG_INVALID_SCOPE>(aOptions.mScope.Value(), wSpec); + return nullptr; + } + + aRv = CheckForSlashEscapedCharsInPath(scopeURI); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + } + + // The spec says that the "client" passed to Register() must be the global + // where the ServiceWorkerContainer was retrieved from. + aRv = swm->Register(GetOwner(), scopeURI, scriptURI, getter_AddRefs(promise)); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<Promise> ret = static_cast<Promise*>(promise.get()); + MOZ_ASSERT(ret); + return ret.forget(); +} + +already_AddRefed<workers::ServiceWorker> +ServiceWorkerContainer::GetController() +{ + if (!mControllerWorker) { + nsCOMPtr<nsIServiceWorkerManager> swm = mozilla::services::GetServiceWorkerManager(); + if (!swm) { + return nullptr; + } + + // TODO: What should we do here if the ServiceWorker script fails to load? + // In theory the DOM ServiceWorker object can exist without the worker + // thread running, but it seems our design does not expect that. + nsCOMPtr<nsISupports> serviceWorker; + nsresult rv = swm->GetDocumentController(GetOwner(), + getter_AddRefs(serviceWorker)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + mControllerWorker = + static_cast<workers::ServiceWorker*>(serviceWorker.get()); + } + + RefPtr<workers::ServiceWorker> ref = mControllerWorker; + return ref.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerContainer::GetRegistrations(ErrorResult& aRv) +{ + nsresult rv; + nsCOMPtr<nsIServiceWorkerManager> swm = do_GetService(SERVICEWORKERMANAGER_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + aRv.Throw(rv); + return nullptr; + } + + nsCOMPtr<nsISupports> promise; + aRv = swm->GetRegistrations(GetOwner(), getter_AddRefs(promise)); + if (aRv.Failed()) { + return nullptr; + } + + RefPtr<Promise> ret = static_cast<Promise*>(promise.get()); + MOZ_ASSERT(ret); + return ret.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerContainer::GetRegistration(const nsAString& aDocumentURL, + ErrorResult& aRv) +{ + nsresult rv; + nsCOMPtr<nsIServiceWorkerManager> swm = do_GetService(SERVICEWORKERMANAGER_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + aRv.Throw(rv); + return nullptr; + } + + nsCOMPtr<nsISupports> promise; + aRv = swm->GetRegistration(GetOwner(), aDocumentURL, getter_AddRefs(promise)); + if (aRv.Failed()) { + return nullptr; + } + + RefPtr<Promise> ret = static_cast<Promise*>(promise.get()); + MOZ_ASSERT(ret); + return ret.forget(); +} + +Promise* +ServiceWorkerContainer::GetReady(ErrorResult& aRv) +{ + if (mReadyPromise) { + return mReadyPromise; + } + + nsCOMPtr<nsIServiceWorkerManager> swm = mozilla::services::GetServiceWorkerManager(); + if (!swm) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsCOMPtr<nsISupports> promise; + aRv = swm->GetReadyPromise(GetOwner(), getter_AddRefs(promise)); + + mReadyPromise = static_cast<Promise*>(promise.get()); + return mReadyPromise; +} + +// Testing only. +void +ServiceWorkerContainer::GetScopeForUrl(const nsAString& aUrl, + nsString& aScope, + ErrorResult& aRv) +{ + nsCOMPtr<nsIServiceWorkerManager> swm = mozilla::services::GetServiceWorkerManager(); + if (!swm) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + nsCOMPtr<nsPIDOMWindowInner> window = GetOwner(); + if (NS_WARN_IF(!window)) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (NS_WARN_IF(!doc)) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + aRv = swm->GetScopeForUrl(doc->NodePrincipal(), + aUrl, aScope); +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerContainer.h b/dom/workers/ServiceWorkerContainer.h new file mode 100644 index 000000000..efd70a601 --- /dev/null +++ b/dom/workers/ServiceWorkerContainer.h @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_serviceworkercontainer_h__ +#define mozilla_dom_serviceworkercontainer_h__ + +#include "mozilla/DOMEventTargetHelper.h" + +class nsPIDOMWindowInner; + +namespace mozilla { +namespace dom { + +class Promise; +struct RegistrationOptions; + +namespace workers { +class ServiceWorker; +} // namespace workers + +// Lightweight serviceWorker APIs collection. +class ServiceWorkerContainer final : public DOMEventTargetHelper +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerContainer, DOMEventTargetHelper) + + IMPL_EVENT_HANDLER(controllerchange) + IMPL_EVENT_HANDLER(error) + IMPL_EVENT_HANDLER(message) + + static bool IsEnabled(JSContext* aCx, JSObject* aGlobal); + + explicit ServiceWorkerContainer(nsPIDOMWindowInner* aWindow); + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + already_AddRefed<Promise> + Register(const nsAString& aScriptURL, + const RegistrationOptions& aOptions, + ErrorResult& aRv); + + already_AddRefed<workers::ServiceWorker> + GetController(); + + already_AddRefed<Promise> + GetRegistration(const nsAString& aDocumentURL, + ErrorResult& aRv); + + already_AddRefed<Promise> + GetRegistrations(ErrorResult& aRv); + + Promise* + GetReady(ErrorResult& aRv); + + // Testing only. + void + GetScopeForUrl(const nsAString& aUrl, nsString& aScope, ErrorResult& aRv); + + // DOMEventTargetHelper + void DisconnectFromOwner() override; + + // Invalidates |mControllerWorker| and dispatches a "controllerchange" + // event. + void + ControllerChanged(ErrorResult& aRv); + +private: + ~ServiceWorkerContainer(); + + void RemoveReadyPromise(); + + // This only changes when a worker hijacks everything in its scope by calling + // claim. + RefPtr<workers::ServiceWorker> mControllerWorker; + + RefPtr<Promise> mReadyPromise; +}; + +} // namespace dom +} // namespace mozilla + +#endif /* mozilla_dom_workers_serviceworkercontainer_h__ */ diff --git a/dom/workers/ServiceWorkerEvents.cpp b/dom/workers/ServiceWorkerEvents.cpp new file mode 100644 index 000000000..09b09a24b --- /dev/null +++ b/dom/workers/ServiceWorkerEvents.cpp @@ -0,0 +1,1280 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerEvents.h" + +#include "nsAutoPtr.h" +#include "nsIConsoleReportCollector.h" +#include "nsIHttpChannelInternal.h" +#include "nsINetworkInterceptController.h" +#include "nsIOutputStream.h" +#include "nsIScriptError.h" +#include "nsIUnicodeDecoder.h" +#include "nsIUnicodeEncoder.h" +#include "nsContentPolicyUtils.h" +#include "nsContentUtils.h" +#include "nsComponentManagerUtils.h" +#include "nsServiceManagerUtils.h" +#include "nsStreamUtils.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsSerializationHelper.h" +#include "nsQueryObject.h" +#include "ServiceWorkerClient.h" +#include "ServiceWorkerManager.h" + +#include "mozilla/ErrorResult.h" +#include "mozilla/Preferences.h" +#include "mozilla/dom/BodyUtil.h" +#include "mozilla/dom/DOMException.h" +#include "mozilla/dom/DOMExceptionBinding.h" +#include "mozilla/dom/EncodingUtils.h" +#include "mozilla/dom/FetchEventBinding.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/PushEventBinding.h" +#include "mozilla/dom/PushMessageDataBinding.h" +#include "mozilla/dom/PushUtil.h" +#include "mozilla/dom/Request.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/dom/Response.h" +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/dom/workers/bindings/ServiceWorker.h" + +#include "js/Conversions.h" +#include "js/TypeDecls.h" +#include "WorkerPrivate.h" +#include "xpcpublic.h" + +using namespace mozilla::dom; +using namespace mozilla::dom::workers; + +namespace { + +void +AsyncLog(nsIInterceptedChannel *aInterceptedChannel, + const nsACString& aRespondWithScriptSpec, + uint32_t aRespondWithLineNumber, uint32_t aRespondWithColumnNumber, + const nsACString& aMessageName, const nsTArray<nsString>& aParams) +{ + MOZ_ASSERT(aInterceptedChannel); + nsCOMPtr<nsIConsoleReportCollector> reporter = + aInterceptedChannel->GetConsoleReportCollector(); + if (reporter) { + reporter->AddConsoleReport(nsIScriptError::errorFlag, + NS_LITERAL_CSTRING("Service Worker Interception"), + nsContentUtils::eDOM_PROPERTIES, + aRespondWithScriptSpec, + aRespondWithLineNumber, + aRespondWithColumnNumber, + aMessageName, aParams); + } +} + +template<typename... Params> +void +AsyncLog(nsIInterceptedChannel* aInterceptedChannel, + const nsACString& aRespondWithScriptSpec, + uint32_t aRespondWithLineNumber, uint32_t aRespondWithColumnNumber, + // We have to list one explicit string so that calls with an + // nsTArray of params won't end up in here. + const nsACString& aMessageName, const nsAString& aFirstParam, + Params&&... aParams) +{ + nsTArray<nsString> paramsList(sizeof...(Params) + 1); + StringArrayAppender::Append(paramsList, sizeof...(Params) + 1, + aFirstParam, Forward<Params>(aParams)...); + AsyncLog(aInterceptedChannel, aRespondWithScriptSpec, aRespondWithLineNumber, + aRespondWithColumnNumber, aMessageName, paramsList); +} + +} // anonymous namespace + +BEGIN_WORKERS_NAMESPACE + +CancelChannelRunnable::CancelChannelRunnable(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + nsresult aStatus) + : mChannel(aChannel) + , mRegistration(aRegistration) + , mStatus(aStatus) +{ +} + +NS_IMETHODIMP +CancelChannelRunnable::Run() +{ + MOZ_ASSERT(NS_IsMainThread()); + mChannel->Cancel(mStatus); + mRegistration->MaybeScheduleUpdate(); + return NS_OK; +} + +FetchEvent::FetchEvent(EventTarget* aOwner) + : ExtendableEvent(aOwner) + , mPreventDefaultLineNumber(0) + , mPreventDefaultColumnNumber(0) + , mIsReload(false) + , mWaitToRespond(false) +{ +} + +FetchEvent::~FetchEvent() +{ +} + +void +FetchEvent::PostInit(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + const nsACString& aScriptSpec) +{ + mChannel = aChannel; + mRegistration = aRegistration; + mScriptSpec.Assign(aScriptSpec); +} + +/*static*/ already_AddRefed<FetchEvent> +FetchEvent::Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const FetchEventInit& aOptions, + ErrorResult& aRv) +{ + RefPtr<EventTarget> owner = do_QueryObject(aGlobal.GetAsSupports()); + MOZ_ASSERT(owner); + RefPtr<FetchEvent> e = new FetchEvent(owner); + bool trusted = e->Init(owner); + e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable); + e->SetTrusted(trusted); + e->SetComposed(aOptions.mComposed); + e->mRequest = aOptions.mRequest; + e->mClientId = aOptions.mClientId; + e->mIsReload = aOptions.mIsReload; + return e.forget(); +} + +namespace { + +class FinishResponse final : public Runnable +{ + nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel; + RefPtr<InternalResponse> mInternalResponse; + ChannelInfo mWorkerChannelInfo; + const nsCString mScriptSpec; + const nsCString mResponseURLSpec; + +public: + FinishResponse(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + InternalResponse* aInternalResponse, + const ChannelInfo& aWorkerChannelInfo, + const nsACString& aScriptSpec, + const nsACString& aResponseURLSpec) + : mChannel(aChannel) + , mInternalResponse(aInternalResponse) + , mWorkerChannelInfo(aWorkerChannelInfo) + , mScriptSpec(aScriptSpec) + , mResponseURLSpec(aResponseURLSpec) + { + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + nsCOMPtr<nsIChannel> underlyingChannel; + nsresult rv = mChannel->GetChannel(getter_AddRefs(underlyingChannel)); + NS_ENSURE_SUCCESS(rv, rv); + NS_ENSURE_TRUE(underlyingChannel, NS_ERROR_UNEXPECTED); + nsCOMPtr<nsILoadInfo> loadInfo = underlyingChannel->GetLoadInfo(); + + if (!CSPPermitsResponse(loadInfo)) { + mChannel->Cancel(NS_ERROR_CONTENT_BLOCKED); + return NS_OK; + } + + ChannelInfo channelInfo; + if (mInternalResponse->GetChannelInfo().IsInitialized()) { + channelInfo = mInternalResponse->GetChannelInfo(); + } else { + // We are dealing with a synthesized response here, so fall back to the + // channel info for the worker script. + channelInfo = mWorkerChannelInfo; + } + rv = mChannel->SetChannelInfo(&channelInfo); + if (NS_WARN_IF(NS_FAILED(rv))) { + mChannel->Cancel(NS_ERROR_INTERCEPTION_FAILED); + return NS_OK; + } + + rv = mChannel->SynthesizeStatus(mInternalResponse->GetUnfilteredStatus(), + mInternalResponse->GetUnfilteredStatusText()); + if (NS_WARN_IF(NS_FAILED(rv))) { + mChannel->Cancel(NS_ERROR_INTERCEPTION_FAILED); + return NS_OK; + } + + AutoTArray<InternalHeaders::Entry, 5> entries; + mInternalResponse->UnfilteredHeaders()->GetEntries(entries); + for (uint32_t i = 0; i < entries.Length(); ++i) { + mChannel->SynthesizeHeader(entries[i].mName, entries[i].mValue); + } + + loadInfo->MaybeIncreaseTainting(mInternalResponse->GetTainting()); + + rv = mChannel->FinishSynthesizedResponse(mResponseURLSpec); + if (NS_WARN_IF(NS_FAILED(rv))) { + mChannel->Cancel(NS_ERROR_INTERCEPTION_FAILED); + return NS_OK; + } + + nsCOMPtr<nsIObserverService> obsService = services::GetObserverService(); + if (obsService) { + obsService->NotifyObservers(underlyingChannel, "service-worker-synthesized-response", nullptr); + } + + return rv; + } + bool CSPPermitsResponse(nsILoadInfo* aLoadInfo) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aLoadInfo); + nsresult rv; + nsCOMPtr<nsIURI> uri; + nsCString url = mInternalResponse->GetUnfilteredURL(); + if (url.IsEmpty()) { + // Synthetic response. The buck stops at the worker script. + url = mScriptSpec; + } + rv = NS_NewURI(getter_AddRefs(uri), url, nullptr, nullptr); + NS_ENSURE_SUCCESS(rv, false); + int16_t decision = nsIContentPolicy::ACCEPT; + rv = NS_CheckContentLoadPolicy(aLoadInfo->InternalContentPolicyType(), uri, + aLoadInfo->LoadingPrincipal(), + aLoadInfo->LoadingNode(), EmptyCString(), + nullptr, &decision); + NS_ENSURE_SUCCESS(rv, false); + return decision == nsIContentPolicy::ACCEPT; + } +}; + +class RespondWithHandler final : public PromiseNativeHandler +{ + nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel; + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + const RequestMode mRequestMode; + const RequestRedirect mRequestRedirectMode; +#ifdef DEBUG + const bool mIsClientRequest; +#endif + const nsCString mScriptSpec; + const nsString mRequestURL; + const nsCString mRespondWithScriptSpec; + const uint32_t mRespondWithLineNumber; + const uint32_t mRespondWithColumnNumber; + bool mRequestWasHandled; +public: + NS_DECL_ISUPPORTS + + RespondWithHandler(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + RequestMode aRequestMode, bool aIsClientRequest, + RequestRedirect aRedirectMode, + const nsACString& aScriptSpec, + const nsAString& aRequestURL, + const nsACString& aRespondWithScriptSpec, + uint32_t aRespondWithLineNumber, + uint32_t aRespondWithColumnNumber) + : mInterceptedChannel(aChannel) + , mRegistration(aRegistration) + , mRequestMode(aRequestMode) + , mRequestRedirectMode(aRedirectMode) +#ifdef DEBUG + , mIsClientRequest(aIsClientRequest) +#endif + , mScriptSpec(aScriptSpec) + , mRequestURL(aRequestURL) + , mRespondWithScriptSpec(aRespondWithScriptSpec) + , mRespondWithLineNumber(aRespondWithLineNumber) + , mRespondWithColumnNumber(aRespondWithColumnNumber) + , mRequestWasHandled(false) + { + } + + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + void CancelRequest(nsresult aStatus); + + void AsyncLog(const nsACString& aMessageName, const nsTArray<nsString>& aParams) + { + ::AsyncLog(mInterceptedChannel, mRespondWithScriptSpec, mRespondWithLineNumber, + mRespondWithColumnNumber, aMessageName, aParams); + } + + void AsyncLog(const nsACString& aSourceSpec, uint32_t aLine, uint32_t aColumn, + const nsACString& aMessageName, const nsTArray<nsString>& aParams) + { + ::AsyncLog(mInterceptedChannel, aSourceSpec, aLine, aColumn, aMessageName, + aParams); + } + +private: + ~RespondWithHandler() + { + if (!mRequestWasHandled) { + ::AsyncLog(mInterceptedChannel, mRespondWithScriptSpec, + mRespondWithLineNumber, mRespondWithColumnNumber, + NS_LITERAL_CSTRING("InterceptionFailedWithURL"), mRequestURL); + CancelRequest(NS_ERROR_INTERCEPTION_FAILED); + } + } +}; + +struct RespondWithClosure +{ + nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel; + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + RefPtr<InternalResponse> mInternalResponse; + ChannelInfo mWorkerChannelInfo; + const nsCString mScriptSpec; + const nsCString mResponseURLSpec; + const nsString mRequestURL; + const nsCString mRespondWithScriptSpec; + const uint32_t mRespondWithLineNumber; + const uint32_t mRespondWithColumnNumber; + + RespondWithClosure(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + InternalResponse* aInternalResponse, + const ChannelInfo& aWorkerChannelInfo, + const nsCString& aScriptSpec, + const nsACString& aResponseURLSpec, + const nsAString& aRequestURL, + const nsACString& aRespondWithScriptSpec, + uint32_t aRespondWithLineNumber, + uint32_t aRespondWithColumnNumber) + : mInterceptedChannel(aChannel) + , mRegistration(aRegistration) + , mInternalResponse(aInternalResponse) + , mWorkerChannelInfo(aWorkerChannelInfo) + , mScriptSpec(aScriptSpec) + , mResponseURLSpec(aResponseURLSpec) + , mRequestURL(aRequestURL) + , mRespondWithScriptSpec(aRespondWithScriptSpec) + , mRespondWithLineNumber(aRespondWithLineNumber) + , mRespondWithColumnNumber(aRespondWithColumnNumber) + { + } +}; + +void RespondWithCopyComplete(void* aClosure, nsresult aStatus) +{ + nsAutoPtr<RespondWithClosure> data(static_cast<RespondWithClosure*>(aClosure)); + nsCOMPtr<nsIRunnable> event; + if (NS_WARN_IF(NS_FAILED(aStatus))) { + AsyncLog(data->mInterceptedChannel, data->mRespondWithScriptSpec, + data->mRespondWithLineNumber, data->mRespondWithColumnNumber, + NS_LITERAL_CSTRING("InterceptionFailedWithURL"), + data->mRequestURL); + event = new CancelChannelRunnable(data->mInterceptedChannel, + data->mRegistration, + NS_ERROR_INTERCEPTION_FAILED); + } else { + event = new FinishResponse(data->mInterceptedChannel, + data->mInternalResponse, + data->mWorkerChannelInfo, + data->mScriptSpec, + data->mResponseURLSpec); + } + // In theory this can happen after the worker thread is terminated. + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + if (worker) { + MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(event.forget())); + } else { + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(event.forget())); + } +} + +namespace { + +void +ExtractErrorValues(JSContext* aCx, JS::Handle<JS::Value> aValue, + nsACString& aSourceSpecOut, uint32_t *aLineOut, + uint32_t *aColumnOut, nsString& aMessageOut) +{ + MOZ_ASSERT(aLineOut); + MOZ_ASSERT(aColumnOut); + + if (aValue.isObject()) { + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + RefPtr<DOMException> domException; + + // Try to process as an Error object. Use the file/line/column values + // from the Error as they will be more specific to the root cause of + // the problem. + JSErrorReport* err = obj ? JS_ErrorFromException(aCx, obj) : nullptr; + if (err) { + // Use xpc to extract the error message only. We don't actually send + // this report anywhere. + RefPtr<xpc::ErrorReport> report = new xpc::ErrorReport(); + report->Init(err, + "<unknown>", // toString result + false, // chrome + 0); // window ID + + if (!report->mFileName.IsEmpty()) { + CopyUTF16toUTF8(report->mFileName, aSourceSpecOut); + *aLineOut = report->mLineNumber; + *aColumnOut = report->mColumn; + } + aMessageOut.Assign(report->mErrorMsg); + } + + // Next, try to unwrap the rejection value as a DOMException. + else if(NS_SUCCEEDED(UNWRAP_OBJECT(DOMException, obj, domException))) { + + nsAutoString filename; + domException->GetFilename(aCx, filename); + if (!filename.IsEmpty()) { + CopyUTF16toUTF8(filename, aSourceSpecOut); + *aLineOut = domException->LineNumber(aCx); + *aColumnOut = domException->ColumnNumber(); + } + + domException->GetName(aMessageOut); + aMessageOut.AppendLiteral(": "); + + nsAutoString message; + domException->GetMessageMoz(message); + aMessageOut.Append(message); + } + } + + // If we could not unwrap a specific error type, then perform default safe + // string conversions on primitives. Objects will result in "[Object]" + // unfortunately. + if (aMessageOut.IsEmpty()) { + nsAutoJSString jsString; + if (jsString.init(aCx, aValue)) { + aMessageOut = jsString; + } else { + JS_ClearPendingException(aCx); + } + } +} + +} // anonymous namespace + +class MOZ_STACK_CLASS AutoCancel +{ + RefPtr<RespondWithHandler> mOwner; + nsCString mSourceSpec; + uint32_t mLine; + uint32_t mColumn; + nsCString mMessageName; + nsTArray<nsString> mParams; + +public: + AutoCancel(RespondWithHandler* aOwner, const nsString& aRequestURL) + : mOwner(aOwner) + , mLine(0) + , mColumn(0) + , mMessageName(NS_LITERAL_CSTRING("InterceptionFailedWithURL")) + { + mParams.AppendElement(aRequestURL); + } + + ~AutoCancel() + { + if (mOwner) { + if (mSourceSpec.IsEmpty()) { + mOwner->AsyncLog(mMessageName, mParams); + } else { + mOwner->AsyncLog(mSourceSpec, mLine, mColumn, mMessageName, mParams); + } + mOwner->CancelRequest(NS_ERROR_INTERCEPTION_FAILED); + } + } + + template<typename... Params> + void SetCancelMessage(const nsACString& aMessageName, Params&&... aParams) + { + MOZ_ASSERT(mOwner); + MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL")); + MOZ_ASSERT(mParams.Length() == 1); + mMessageName = aMessageName; + mParams.Clear(); + StringArrayAppender::Append(mParams, sizeof...(Params), + Forward<Params>(aParams)...); + } + + template<typename... Params> + void SetCancelMessageAndLocation(const nsACString& aSourceSpec, + uint32_t aLine, uint32_t aColumn, + const nsACString& aMessageName, + Params&&... aParams) + { + MOZ_ASSERT(mOwner); + MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL")); + MOZ_ASSERT(mParams.Length() == 1); + + mSourceSpec = aSourceSpec; + mLine = aLine; + mColumn = aColumn; + + mMessageName = aMessageName; + mParams.Clear(); + StringArrayAppender::Append(mParams, sizeof...(Params), + Forward<Params>(aParams)...); + } + + void Reset() + { + mOwner = nullptr; + } +}; + +NS_IMPL_ISUPPORTS0(RespondWithHandler) + +void +RespondWithHandler::ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AutoCancel autoCancel(this, mRequestURL); + + if (!aValue.isObject()) { + NS_WARNING("FetchEvent::RespondWith was passed a promise resolved to a non-Object value"); + + nsCString sourceSpec; + uint32_t line = 0; + uint32_t column = 0; + nsString valueString; + ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column, valueString); + + autoCancel.SetCancelMessageAndLocation(sourceSpec, line, column, + NS_LITERAL_CSTRING("InterceptedNonResponseWithURL"), + mRequestURL, valueString); + return; + } + + RefPtr<Response> response; + nsresult rv = UNWRAP_OBJECT(Response, &aValue.toObject(), response); + if (NS_FAILED(rv)) { + nsCString sourceSpec; + uint32_t line = 0; + uint32_t column = 0; + nsString valueString; + ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column, valueString); + + autoCancel.SetCancelMessageAndLocation(sourceSpec, line, column, + NS_LITERAL_CSTRING("InterceptedNonResponseWithURL"), + mRequestURL, valueString); + return; + } + + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + + // Section "HTTP Fetch", step 3.3: + // If one of the following conditions is true, return a network error: + // * response's type is "error". + // * request's mode is not "no-cors" and response's type is "opaque". + // * request's redirect mode is not "manual" and response's type is + // "opaqueredirect". + // * request's redirect mode is not "follow" and response's url list + // has more than one item. + + if (response->Type() == ResponseType::Error) { + autoCancel.SetCancelMessage( + NS_LITERAL_CSTRING("InterceptedErrorResponseWithURL"), mRequestURL); + return; + } + + MOZ_ASSERT_IF(mIsClientRequest, mRequestMode == RequestMode::Same_origin || + mRequestMode == RequestMode::Navigate); + + if (response->Type() == ResponseType::Opaque && mRequestMode != RequestMode::No_cors) { + uint32_t mode = static_cast<uint32_t>(mRequestMode); + NS_ConvertASCIItoUTF16 modeString(RequestModeValues::strings[mode].value, + RequestModeValues::strings[mode].length); + + autoCancel.SetCancelMessage( + NS_LITERAL_CSTRING("BadOpaqueInterceptionRequestModeWithURL"), + mRequestURL, modeString); + return; + } + + if (mRequestRedirectMode != RequestRedirect::Manual && + response->Type() == ResponseType::Opaqueredirect) { + autoCancel.SetCancelMessage( + NS_LITERAL_CSTRING("BadOpaqueRedirectInterceptionWithURL"), mRequestURL); + return; + } + + if (mRequestRedirectMode != RequestRedirect::Follow && response->Redirected()) { + autoCancel.SetCancelMessage( + NS_LITERAL_CSTRING("BadRedirectModeInterceptionWithURL"), mRequestURL); + return; + } + + if (NS_WARN_IF(response->BodyUsed())) { + autoCancel.SetCancelMessage( + NS_LITERAL_CSTRING("InterceptedUsedResponseWithURL"), mRequestURL); + return; + } + + RefPtr<InternalResponse> ir = response->GetInternalResponse(); + if (NS_WARN_IF(!ir)) { + return; + } + // When an opaque response is encountered, we need the original channel's principal + // to reflect the final URL. Non-opaque responses are either same-origin or CORS-enabled + // cross-origin responses, which are treated as same-origin by consumers. + nsCString responseURL; + if (response->Type() == ResponseType::Opaque) { + responseURL = ir->GetUnfilteredURL(); + if (NS_WARN_IF(responseURL.IsEmpty())) { + return; + } + } + nsAutoPtr<RespondWithClosure> closure(new RespondWithClosure(mInterceptedChannel, + mRegistration, ir, + worker->GetChannelInfo(), + mScriptSpec, + responseURL, + mRequestURL, + mRespondWithScriptSpec, + mRespondWithLineNumber, + mRespondWithColumnNumber)); + nsCOMPtr<nsIInputStream> body; + ir->GetUnfilteredBody(getter_AddRefs(body)); + // Errors and redirects may not have a body. + if (body) { + response->SetBodyUsed(); + + nsCOMPtr<nsIOutputStream> responseBody; + rv = mInterceptedChannel->GetResponseBody(getter_AddRefs(responseBody)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + const uint32_t kCopySegmentSize = 4096; + + // Depending on how the Response passed to .respondWith() was created, we may + // get a non-buffered input stream. In addition, in some configurations the + // destination channel's output stream can be unbuffered. We wrap the output + // stream side here so that NS_AsyncCopy() works. Wrapping the output side + // provides the most consistent operation since there are fewer stream types + // we are writing to. The input stream can be a wide variety of concrete + // objects which may or many not play well with NS_InputStreamIsBuffered(). + if (!NS_OutputStreamIsBuffered(responseBody)) { + nsCOMPtr<nsIOutputStream> buffered; + rv = NS_NewBufferedOutputStream(getter_AddRefs(buffered), responseBody, + kCopySegmentSize); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + responseBody = buffered; + } + + nsCOMPtr<nsIEventTarget> stsThread = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_WARN_IF(!stsThread)) { + return; + } + + // XXXnsm, Fix for Bug 1141332 means that if we decide to make this + // streaming at some point, we'll need a different solution to that bug. + rv = NS_AsyncCopy(body, responseBody, stsThread, NS_ASYNCCOPY_VIA_WRITESEGMENTS, + kCopySegmentSize, RespondWithCopyComplete, closure.forget()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } else { + RespondWithCopyComplete(closure.forget(), NS_OK); + } + + MOZ_ASSERT(!closure); + autoCancel.Reset(); + mRequestWasHandled = true; +} + +void +RespondWithHandler::RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + nsCString sourceSpec = mRespondWithScriptSpec; + uint32_t line = mRespondWithLineNumber; + uint32_t column = mRespondWithColumnNumber; + nsString valueString; + + ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column, valueString); + + ::AsyncLog(mInterceptedChannel, sourceSpec, line, column, + NS_LITERAL_CSTRING("InterceptionRejectedResponseWithURL"), + mRequestURL, valueString); + + CancelRequest(NS_ERROR_INTERCEPTION_FAILED); +} + +void +RespondWithHandler::CancelRequest(nsresult aStatus) +{ + nsCOMPtr<nsIRunnable> runnable = + new CancelChannelRunnable(mInterceptedChannel, mRegistration, aStatus); + // Note, this may run off the worker thread during worker termination. + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + if (worker) { + MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(runnable.forget())); + } else { + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable.forget())); + } + mRequestWasHandled = true; +} + +} // namespace + +void +FetchEvent::RespondWith(JSContext* aCx, Promise& aArg, ErrorResult& aRv) +{ + if (EventPhase() == nsIDOMEvent::NONE || mWaitToRespond) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + + // Record where respondWith() was called in the script so we can include the + // information in any error reporting. We should be guaranteed not to get + // a file:// string here because service workers require http/https. + nsCString spec; + uint32_t line = 0; + uint32_t column = 0; + nsJSUtils::GetCallingLocation(aCx, spec, &line, &column); + + RefPtr<InternalRequest> ir = mRequest->GetInternalRequest(); + + nsAutoCString requestURL; + ir->GetURL(requestURL); + + StopImmediatePropagation(); + mWaitToRespond = true; + RefPtr<RespondWithHandler> handler = + new RespondWithHandler(mChannel, mRegistration, mRequest->Mode(), + ir->IsClientRequest(), mRequest->Redirect(), + mScriptSpec, NS_ConvertUTF8toUTF16(requestURL), + spec, line, column); + aArg.AppendNativeHandler(handler); + + // Append directly to the lifecycle promises array. Don't call WaitUntil() + // because that will lead to double-reporting any errors. + mPromises.AppendElement(&aArg); +} + +void +FetchEvent::PreventDefault(JSContext* aCx) +{ + MOZ_ASSERT(aCx); + + if (mPreventDefaultScriptSpec.IsEmpty()) { + // Note when the FetchEvent might have been canceled by script, but don't + // actually log the location until we are sure it matters. This is + // determined in ServiceWorkerPrivate.cpp. We only remember the first + // call to preventDefault() as its the most likely to have actually canceled + // the event. + nsJSUtils::GetCallingLocation(aCx, mPreventDefaultScriptSpec, + &mPreventDefaultLineNumber, + &mPreventDefaultColumnNumber); + } + + Event::PreventDefault(aCx); +} + +void +FetchEvent::ReportCanceled() +{ + MOZ_ASSERT(!mPreventDefaultScriptSpec.IsEmpty()); + + RefPtr<InternalRequest> ir = mRequest->GetInternalRequest(); + nsAutoCString url; + ir->GetURL(url); + + // The variadic template provided by StringArrayAppender requires exactly + // an nsString. + NS_ConvertUTF8toUTF16 requestURL(url); + //nsString requestURL; + //CopyUTF8toUTF16(url, requestURL); + + ::AsyncLog(mChannel.get(), mPreventDefaultScriptSpec, + mPreventDefaultLineNumber, mPreventDefaultColumnNumber, + NS_LITERAL_CSTRING("InterceptionCanceledWithURL"), requestURL); +} + +namespace { + +class WaitUntilHandler final : public PromiseNativeHandler +{ + WorkerPrivate* mWorkerPrivate; + const nsCString mScope; + nsCString mSourceSpec; + uint32_t mLine; + uint32_t mColumn; + nsString mRejectValue; + + ~WaitUntilHandler() + { + } + +public: + NS_DECL_THREADSAFE_ISUPPORTS + + WaitUntilHandler(WorkerPrivate* aWorkerPrivate, JSContext* aCx) + : mWorkerPrivate(aWorkerPrivate) + , mScope(mWorkerPrivate->WorkerName()) + , mLine(0) + , mColumn(0) + { + mWorkerPrivate->AssertIsOnWorkerThread(); + + // Save the location of the waitUntil() call itself as a fallback + // in case the rejection value does not contain any location info. + nsJSUtils::GetCallingLocation(aCx, mSourceSpec, &mLine, &mColumn); + } + + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + // do nothing, we are only here to report errors + } + + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + mWorkerPrivate->AssertIsOnWorkerThread(); + + nsCString spec; + uint32_t line = 0; + uint32_t column = 0; + ExtractErrorValues(aCx, aValue, spec, &line, &column, mRejectValue); + + // only use the extracted location if we found one + if (!spec.IsEmpty()) { + mSourceSpec = spec; + mLine = line; + mColumn = column; + } + + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread( + NewRunnableMethod(this, &WaitUntilHandler::ReportOnMainThread))); + } + + void + ReportOnMainThread() + { + AssertIsOnMainThread(); + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return; + } + + // TODO: Make the error message a localized string. (bug 1222720) + nsString message; + message.AppendLiteral("Service worker event waitUntil() was passed a " + "promise that rejected with '"); + message.Append(mRejectValue); + message.AppendLiteral("'."); + + // Note, there is a corner case where this won't report to the window + // that triggered the error. Consider a navigation fetch event that + // rejects waitUntil() without holding respondWith() open. In this case + // there is no controlling document yet, the window did call .register() + // because there is no documeny yet, and the navigation is no longer + // being intercepted. + + swm->ReportToAllClients(mScope, message, NS_ConvertUTF8toUTF16(mSourceSpec), + EmptyString(), mLine, mColumn, + nsIScriptError::errorFlag); + } +}; + +NS_IMPL_ISUPPORTS0(WaitUntilHandler) + +} // anonymous namespace + +NS_IMPL_ADDREF_INHERITED(FetchEvent, ExtendableEvent) +NS_IMPL_RELEASE_INHERITED(FetchEvent, ExtendableEvent) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FetchEvent) +NS_INTERFACE_MAP_END_INHERITING(ExtendableEvent) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(FetchEvent, ExtendableEvent, mRequest) + +ExtendableEvent::ExtendableEvent(EventTarget* aOwner) + : Event(aOwner, nullptr, nullptr) +{ +} + +void +ExtendableEvent::WaitUntil(JSContext* aCx, Promise& aPromise, ErrorResult& aRv) +{ + MOZ_ASSERT(!NS_IsMainThread()); + + if (EventPhase() == nsIDOMEvent::NONE) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + // Append our handler to each waitUntil promise separately so we + // can record the location in script where waitUntil was called. + RefPtr<WaitUntilHandler> handler = + new WaitUntilHandler(GetCurrentThreadWorkerPrivate(), aCx); + aPromise.AppendNativeHandler(handler); + + mPromises.AppendElement(&aPromise); +} + +already_AddRefed<Promise> +ExtendableEvent::GetPromise() +{ + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + + nsIGlobalObject* globalObj = worker->GlobalScope(); + + AutoJSAPI jsapi; + if (!jsapi.Init(globalObj)) { + return nullptr; + } + JSContext* cx = jsapi.cx(); + + GlobalObject global(cx, globalObj->GetGlobalJSObject()); + + ErrorResult result; + RefPtr<Promise> p = Promise::All(global, Move(mPromises), result); + if (NS_WARN_IF(result.MaybeSetPendingException(cx))) { + return nullptr; + } + + return p.forget(); +} + +NS_IMPL_ADDREF_INHERITED(ExtendableEvent, Event) +NS_IMPL_RELEASE_INHERITED(ExtendableEvent, Event) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ExtendableEvent) +NS_INTERFACE_MAP_END_INHERITING(Event) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(ExtendableEvent, Event, mPromises) + +namespace { +nsresult +ExtractBytesFromUSVString(const nsAString& aStr, nsTArray<uint8_t>& aBytes) +{ + MOZ_ASSERT(aBytes.IsEmpty()); + nsCOMPtr<nsIUnicodeEncoder> encoder = EncodingUtils::EncoderForEncoding("UTF-8"); + if (NS_WARN_IF(!encoder)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + int32_t srcLen = aStr.Length(); + int32_t destBufferLen; + nsresult rv = encoder->GetMaxLength(aStr.BeginReading(), srcLen, &destBufferLen); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (NS_WARN_IF(!aBytes.SetLength(destBufferLen, fallible))) { + return NS_ERROR_OUT_OF_MEMORY; + } + + char* destBuffer = reinterpret_cast<char*>(aBytes.Elements()); + int32_t outLen = destBufferLen; + rv = encoder->Convert(aStr.BeginReading(), &srcLen, destBuffer, &outLen); + if (NS_WARN_IF(NS_FAILED(rv))) { + aBytes.Clear(); + return rv; + } + + aBytes.TruncateLength(outLen); + + return NS_OK; +} + +nsresult +ExtractBytesFromData(const OwningArrayBufferViewOrArrayBufferOrUSVString& aDataInit, nsTArray<uint8_t>& aBytes) +{ + if (aDataInit.IsArrayBufferView()) { + const ArrayBufferView& view = aDataInit.GetAsArrayBufferView(); + if (NS_WARN_IF(!PushUtil::CopyArrayBufferViewToArray(view, aBytes))) { + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_OK; + } + if (aDataInit.IsArrayBuffer()) { + const ArrayBuffer& buffer = aDataInit.GetAsArrayBuffer(); + if (NS_WARN_IF(!PushUtil::CopyArrayBufferToArray(buffer, aBytes))) { + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_OK; + } + if (aDataInit.IsUSVString()) { + return ExtractBytesFromUSVString(aDataInit.GetAsUSVString(), aBytes); + } + NS_NOTREACHED("Unexpected push message data"); + return NS_ERROR_FAILURE; +} +} + +PushMessageData::PushMessageData(nsISupports* aOwner, + nsTArray<uint8_t>&& aBytes) + : mOwner(aOwner), mBytes(Move(aBytes)) {} + +PushMessageData::~PushMessageData() +{ +} + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PushMessageData, mOwner) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PushMessageData) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PushMessageData) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PushMessageData) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +JSObject* +PushMessageData::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return mozilla::dom::PushMessageDataBinding::Wrap(aCx, this, aGivenProto); +} + +void +PushMessageData::Json(JSContext* cx, JS::MutableHandle<JS::Value> aRetval, + ErrorResult& aRv) +{ + if (NS_FAILED(EnsureDecodedText())) { + aRv.Throw(NS_ERROR_DOM_UNKNOWN_ERR); + return; + } + BodyUtil::ConsumeJson(cx, aRetval, mDecodedText, aRv); +} + +void +PushMessageData::Text(nsAString& aData) +{ + if (NS_SUCCEEDED(EnsureDecodedText())) { + aData = mDecodedText; + } +} + +void +PushMessageData::ArrayBuffer(JSContext* cx, + JS::MutableHandle<JSObject*> aRetval, + ErrorResult& aRv) +{ + uint8_t* data = GetContentsCopy(); + if (data) { + BodyUtil::ConsumeArrayBuffer(cx, aRetval, mBytes.Length(), data, aRv); + } +} + +already_AddRefed<mozilla::dom::Blob> +PushMessageData::Blob(ErrorResult& aRv) +{ + uint8_t* data = GetContentsCopy(); + if (data) { + RefPtr<mozilla::dom::Blob> blob = BodyUtil::ConsumeBlob( + mOwner, EmptyString(), mBytes.Length(), data, aRv); + if (blob) { + return blob.forget(); + } + } + return nullptr; +} + +nsresult +PushMessageData::EnsureDecodedText() +{ + if (mBytes.IsEmpty() || !mDecodedText.IsEmpty()) { + return NS_OK; + } + nsresult rv = BodyUtil::ConsumeText( + mBytes.Length(), + reinterpret_cast<uint8_t*>(mBytes.Elements()), + mDecodedText + ); + if (NS_WARN_IF(NS_FAILED(rv))) { + mDecodedText.Truncate(); + return rv; + } + return NS_OK; +} + +uint8_t* +PushMessageData::GetContentsCopy() +{ + uint32_t length = mBytes.Length(); + void* data = malloc(length); + if (!data) { + return nullptr; + } + memcpy(data, mBytes.Elements(), length); + return reinterpret_cast<uint8_t*>(data); +} + +PushEvent::PushEvent(EventTarget* aOwner) + : ExtendableEvent(aOwner) +{ +} + +already_AddRefed<PushEvent> +PushEvent::Constructor(mozilla::dom::EventTarget* aOwner, + const nsAString& aType, + const PushEventInit& aOptions, + ErrorResult& aRv) +{ + RefPtr<PushEvent> e = new PushEvent(aOwner); + bool trusted = e->Init(aOwner); + e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable); + e->SetTrusted(trusted); + e->SetComposed(aOptions.mComposed); + if(aOptions.mData.WasPassed()){ + nsTArray<uint8_t> bytes; + nsresult rv = ExtractBytesFromData(aOptions.mData.Value(), bytes); + if (NS_FAILED(rv)) { + aRv.Throw(rv); + return nullptr; + } + e->mData = new PushMessageData(aOwner, Move(bytes)); + } + return e.forget(); +} + +NS_IMPL_ADDREF_INHERITED(PushEvent, ExtendableEvent) +NS_IMPL_RELEASE_INHERITED(PushEvent, ExtendableEvent) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(PushEvent) +NS_INTERFACE_MAP_END_INHERITING(ExtendableEvent) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(PushEvent, ExtendableEvent, mData) + +JSObject* +PushEvent::WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return mozilla::dom::PushEventBinding::Wrap(aCx, this, aGivenProto); +} + +ExtendableMessageEvent::ExtendableMessageEvent(EventTarget* aOwner) + : ExtendableEvent(aOwner) + , mData(JS::UndefinedValue()) +{ + mozilla::HoldJSObjects(this); +} + +ExtendableMessageEvent::~ExtendableMessageEvent() +{ + mData.setUndefined(); + DropJSObjects(this); +} + +void +ExtendableMessageEvent::GetData(JSContext* aCx, + JS::MutableHandle<JS::Value> aData, + ErrorResult& aRv) +{ + aData.set(mData); + if (!JS_WrapValue(aCx, aData)) { + aRv.Throw(NS_ERROR_FAILURE); + } +} + +void +ExtendableMessageEvent::GetSource(Nullable<OwningClientOrServiceWorkerOrMessagePort>& aValue) const +{ + if (mClient) { + aValue.SetValue().SetAsClient() = mClient; + } else if (mServiceWorker) { + aValue.SetValue().SetAsServiceWorker() = mServiceWorker; + } else if (mMessagePort) { + aValue.SetValue().SetAsMessagePort() = mMessagePort; + } else { + MOZ_CRASH("Unexpected source value"); + } +} + +/* static */ already_AddRefed<ExtendableMessageEvent> +ExtendableMessageEvent::Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const ExtendableMessageEventInit& aOptions, + ErrorResult& aRv) +{ + nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports()); + return Constructor(t, aType, aOptions, aRv); +} + +/* static */ already_AddRefed<ExtendableMessageEvent> +ExtendableMessageEvent::Constructor(mozilla::dom::EventTarget* aEventTarget, + const nsAString& aType, + const ExtendableMessageEventInit& aOptions, + ErrorResult& aRv) +{ + RefPtr<ExtendableMessageEvent> event = new ExtendableMessageEvent(aEventTarget); + + event->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable); + bool trusted = event->Init(aEventTarget); + event->SetTrusted(trusted); + + event->mData = aOptions.mData; + event->mOrigin = aOptions.mOrigin; + event->mLastEventId = aOptions.mLastEventId; + + if (!aOptions.mSource.IsNull()) { + if (aOptions.mSource.Value().IsClient()) { + event->mClient = aOptions.mSource.Value().GetAsClient(); + } else if (aOptions.mSource.Value().IsServiceWorker()){ + event->mServiceWorker = aOptions.mSource.Value().GetAsServiceWorker(); + } else if (aOptions.mSource.Value().IsMessagePort()){ + event->mMessagePort = aOptions.mSource.Value().GetAsMessagePort(); + } + } + + event->mPorts.AppendElements(aOptions.mPorts); + return event.forget(); +} + +void +ExtendableMessageEvent::GetPorts(nsTArray<RefPtr<MessagePort>>& aPorts) +{ + aPorts = mPorts; +} + +NS_IMPL_CYCLE_COLLECTION_CLASS(ExtendableMessageEvent) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(ExtendableMessageEvent, Event) + tmp->mData.setUndefined(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mClient) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mServiceWorker) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mPorts) +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ExtendableMessageEvent, Event) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mClient) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mServiceWorker) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPorts) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(ExtendableMessageEvent, Event) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mData) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ExtendableMessageEvent) +NS_INTERFACE_MAP_END_INHERITING(Event) + +NS_IMPL_ADDREF_INHERITED(ExtendableMessageEvent, Event) +NS_IMPL_RELEASE_INHERITED(ExtendableMessageEvent, Event) + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerEvents.h b/dom/workers/ServiceWorkerEvents.h new file mode 100644 index 000000000..25702f8f3 --- /dev/null +++ b/dom/workers/ServiceWorkerEvents.h @@ -0,0 +1,316 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerevents_h__ +#define mozilla_dom_workers_serviceworkerevents_h__ + +#include "mozilla/dom/Event.h" +#include "mozilla/dom/ExtendableEventBinding.h" +#include "mozilla/dom/ExtendableMessageEventBinding.h" +#include "mozilla/dom/FetchEventBinding.h" +#include "mozilla/dom/File.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Response.h" +#include "mozilla/dom/workers/bindings/ServiceWorker.h" +#include "mozilla/dom/workers/Workers.h" + +#include "nsProxyRelease.h" +#include "nsContentUtils.h" + +class nsIInterceptedChannel; + +namespace mozilla { +namespace dom { +class Blob; +class MessagePort; +class Request; +class ResponseOrPromise; + +struct PushEventInit; +} // namespace dom +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +class ServiceWorkerRegistrationInfo; + +class CancelChannelRunnable final : public Runnable +{ + nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel; + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + const nsresult mStatus; +public: + CancelChannelRunnable(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + nsresult aStatus); + + NS_IMETHOD Run() override; +}; + +class ExtendableEvent : public Event +{ +protected: + nsTArray<RefPtr<Promise>> mPromises; + + explicit ExtendableEvent(mozilla::dom::EventTarget* aOwner); + ~ExtendableEvent() {} + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ExtendableEvent, Event) + NS_FORWARD_TO_EVENT + + virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override + { + return mozilla::dom::ExtendableEventBinding::Wrap(aCx, this, aGivenProto); + } + + static already_AddRefed<ExtendableEvent> + Constructor(mozilla::dom::EventTarget* aOwner, + const nsAString& aType, + const EventInit& aOptions) + { + RefPtr<ExtendableEvent> e = new ExtendableEvent(aOwner); + bool trusted = e->Init(aOwner); + e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable); + e->SetTrusted(trusted); + e->SetComposed(aOptions.mComposed); + return e.forget(); + } + + static already_AddRefed<ExtendableEvent> + Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const EventInit& aOptions, + ErrorResult& aRv) + { + nsCOMPtr<EventTarget> target = do_QueryInterface(aGlobal.GetAsSupports()); + return Constructor(target, aType, aOptions); + } + + void + WaitUntil(JSContext* aCx, Promise& aPromise, ErrorResult& aRv); + + already_AddRefed<Promise> + GetPromise(); + + virtual ExtendableEvent* AsExtendableEvent() override + { + return this; + } +}; + +class FetchEvent final : public ExtendableEvent +{ + nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel; + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + RefPtr<Request> mRequest; + nsCString mScriptSpec; + nsCString mPreventDefaultScriptSpec; + nsString mClientId; + uint32_t mPreventDefaultLineNumber; + uint32_t mPreventDefaultColumnNumber; + bool mIsReload; + bool mWaitToRespond; +protected: + explicit FetchEvent(EventTarget* aOwner); + ~FetchEvent(); + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FetchEvent, ExtendableEvent) + + // Note, we cannot use NS_FORWARD_TO_EVENT because we want a different + // PreventDefault(JSContext*) override. + NS_FORWARD_NSIDOMEVENT(Event::) + + virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override + { + return FetchEventBinding::Wrap(aCx, this, aGivenProto); + } + + void PostInit(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + const nsACString& aScriptSpec); + + static already_AddRefed<FetchEvent> + Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const FetchEventInit& aOptions, + ErrorResult& aRv); + + bool + WaitToRespond() const + { + return mWaitToRespond; + } + + Request* + Request_() const + { + MOZ_ASSERT(mRequest); + return mRequest; + } + + void + GetClientId(nsAString& aClientId) const + { + aClientId = mClientId; + } + + bool + IsReload() const + { + return mIsReload; + } + + void + RespondWith(JSContext* aCx, Promise& aArg, ErrorResult& aRv); + + already_AddRefed<Promise> + ForwardTo(const nsAString& aUrl); + + already_AddRefed<Promise> + Default(); + + void + PreventDefault(JSContext* aCx) override; + + void + ReportCanceled(); +}; + +class PushMessageData final : public nsISupports, + public nsWrapperCache +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(PushMessageData) + + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + nsISupports* GetParentObject() const { + return mOwner; + } + + void Json(JSContext* cx, JS::MutableHandle<JS::Value> aRetval, + ErrorResult& aRv); + void Text(nsAString& aData); + void ArrayBuffer(JSContext* cx, JS::MutableHandle<JSObject*> aRetval, + ErrorResult& aRv); + already_AddRefed<mozilla::dom::Blob> Blob(ErrorResult& aRv); + + PushMessageData(nsISupports* aOwner, nsTArray<uint8_t>&& aBytes); +private: + nsCOMPtr<nsISupports> mOwner; + nsTArray<uint8_t> mBytes; + nsString mDecodedText; + ~PushMessageData(); + + nsresult EnsureDecodedText(); + uint8_t* GetContentsCopy(); +}; + +class PushEvent final : public ExtendableEvent +{ + RefPtr<PushMessageData> mData; + +protected: + explicit PushEvent(mozilla::dom::EventTarget* aOwner); + ~PushEvent() {} + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PushEvent, ExtendableEvent) + NS_FORWARD_TO_EVENT + + virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + static already_AddRefed<PushEvent> + Constructor(mozilla::dom::EventTarget* aOwner, + const nsAString& aType, + const PushEventInit& aOptions, + ErrorResult& aRv); + + static already_AddRefed<PushEvent> + Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const PushEventInit& aOptions, + ErrorResult& aRv) + { + nsCOMPtr<EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports()); + return Constructor(owner, aType, aOptions, aRv); + } + + PushMessageData* + GetData() const + { + return mData; + } +}; + +class ExtendableMessageEvent final : public ExtendableEvent +{ + JS::Heap<JS::Value> mData; + nsString mOrigin; + nsString mLastEventId; + RefPtr<ServiceWorkerClient> mClient; + RefPtr<ServiceWorker> mServiceWorker; + RefPtr<MessagePort> mMessagePort; + nsTArray<RefPtr<MessagePort>> mPorts; + +protected: + explicit ExtendableMessageEvent(EventTarget* aOwner); + ~ExtendableMessageEvent(); + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(ExtendableMessageEvent, + ExtendableEvent) + + NS_FORWARD_TO_EVENT + + virtual JSObject* WrapObjectInternal( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override + { + return mozilla::dom::ExtendableMessageEventBinding::Wrap(aCx, this, aGivenProto); + } + + static already_AddRefed<ExtendableMessageEvent> + Constructor(mozilla::dom::EventTarget* aOwner, + const nsAString& aType, + const ExtendableMessageEventInit& aOptions, + ErrorResult& aRv); + + static already_AddRefed<ExtendableMessageEvent> + Constructor(const GlobalObject& aGlobal, + const nsAString& aType, + const ExtendableMessageEventInit& aOptions, + ErrorResult& aRv); + + void GetData(JSContext* aCx, JS::MutableHandle<JS::Value> aData, + ErrorResult& aRv); + + void GetSource(Nullable<OwningClientOrServiceWorkerOrMessagePort>& aValue) const; + + NS_IMETHOD GetOrigin(nsAString& aOrigin) + { + aOrigin = mOrigin; + return NS_OK; + } + + NS_IMETHOD GetLastEventId(nsAString& aLastEventId) + { + aLastEventId = mLastEventId; + return NS_OK; + } + + void GetPorts(nsTArray<RefPtr<MessagePort>>& aPorts); +}; + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_serviceworkerevents_h__ */ diff --git a/dom/workers/ServiceWorkerInfo.cpp b/dom/workers/ServiceWorkerInfo.cpp new file mode 100644 index 000000000..fa08b97a6 --- /dev/null +++ b/dom/workers/ServiceWorkerInfo.cpp @@ -0,0 +1,229 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerInfo.h" + +#include "ServiceWorkerScriptCache.h" + +BEGIN_WORKERS_NAMESPACE + +static_assert(nsIServiceWorkerInfo::STATE_INSTALLING == static_cast<uint16_t>(ServiceWorkerState::Installing), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); +static_assert(nsIServiceWorkerInfo::STATE_INSTALLED == static_cast<uint16_t>(ServiceWorkerState::Installed), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); +static_assert(nsIServiceWorkerInfo::STATE_ACTIVATING == static_cast<uint16_t>(ServiceWorkerState::Activating), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); +static_assert(nsIServiceWorkerInfo::STATE_ACTIVATED == static_cast<uint16_t>(ServiceWorkerState::Activated), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); +static_assert(nsIServiceWorkerInfo::STATE_REDUNDANT == static_cast<uint16_t>(ServiceWorkerState::Redundant), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); +static_assert(nsIServiceWorkerInfo::STATE_UNKNOWN == static_cast<uint16_t>(ServiceWorkerState::EndGuard_), + "ServiceWorkerState enumeration value should match state values from nsIServiceWorkerInfo."); + +NS_IMPL_ISUPPORTS(ServiceWorkerInfo, nsIServiceWorkerInfo) + +NS_IMETHODIMP +ServiceWorkerInfo::GetScriptSpec(nsAString& aScriptSpec) +{ + AssertIsOnMainThread(); + CopyUTF8toUTF16(mScriptSpec, aScriptSpec); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerInfo::GetCacheName(nsAString& aCacheName) +{ + AssertIsOnMainThread(); + aCacheName = mCacheName; + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerInfo::GetState(uint16_t* aState) +{ + MOZ_ASSERT(aState); + AssertIsOnMainThread(); + *aState = static_cast<uint16_t>(mState); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerInfo::GetDebugger(nsIWorkerDebugger** aResult) +{ + if (NS_WARN_IF(!aResult)) { + return NS_ERROR_FAILURE; + } + + return mServiceWorkerPrivate->GetDebugger(aResult); +} + +NS_IMETHODIMP +ServiceWorkerInfo::AttachDebugger() +{ + return mServiceWorkerPrivate->AttachDebugger(); +} + +NS_IMETHODIMP +ServiceWorkerInfo::DetachDebugger() +{ + return mServiceWorkerPrivate->DetachDebugger(); +} + +void +ServiceWorkerInfo::AppendWorker(ServiceWorker* aWorker) +{ + MOZ_ASSERT(aWorker); +#ifdef DEBUG + nsAutoString workerURL; + aWorker->GetScriptURL(workerURL); + MOZ_ASSERT(workerURL.Equals(NS_ConvertUTF8toUTF16(mScriptSpec))); +#endif + MOZ_ASSERT(!mInstances.Contains(aWorker)); + + mInstances.AppendElement(aWorker); + aWorker->SetState(State()); +} + +void +ServiceWorkerInfo::RemoveWorker(ServiceWorker* aWorker) +{ + MOZ_ASSERT(aWorker); +#ifdef DEBUG + nsAutoString workerURL; + aWorker->GetScriptURL(workerURL); + MOZ_ASSERT(workerURL.Equals(NS_ConvertUTF8toUTF16(mScriptSpec))); +#endif + MOZ_ASSERT(mInstances.Contains(aWorker)); + + mInstances.RemoveElement(aWorker); +} + +namespace { + +class ChangeStateUpdater final : public Runnable +{ +public: + ChangeStateUpdater(const nsTArray<ServiceWorker*>& aInstances, + ServiceWorkerState aState) + : mState(aState) + { + for (size_t i = 0; i < aInstances.Length(); ++i) { + mInstances.AppendElement(aInstances[i]); + } + } + + NS_IMETHOD Run() override + { + // We need to update the state of all instances atomically before notifying + // them to make sure that the observed state for all instances inside + // statechange event handlers is correct. + for (size_t i = 0; i < mInstances.Length(); ++i) { + mInstances[i]->SetState(mState); + } + for (size_t i = 0; i < mInstances.Length(); ++i) { + mInstances[i]->DispatchStateChange(mState); + } + + return NS_OK; + } + +private: + AutoTArray<RefPtr<ServiceWorker>, 1> mInstances; + ServiceWorkerState mState; +}; + +} + +void +ServiceWorkerInfo::UpdateState(ServiceWorkerState aState) +{ + AssertIsOnMainThread(); +#ifdef DEBUG + // Any state can directly transition to redundant, but everything else is + // ordered. + if (aState != ServiceWorkerState::Redundant) { + MOZ_ASSERT_IF(mState == ServiceWorkerState::EndGuard_, aState == ServiceWorkerState::Installing); + MOZ_ASSERT_IF(mState == ServiceWorkerState::Installing, aState == ServiceWorkerState::Installed); + MOZ_ASSERT_IF(mState == ServiceWorkerState::Installed, aState == ServiceWorkerState::Activating); + MOZ_ASSERT_IF(mState == ServiceWorkerState::Activating, aState == ServiceWorkerState::Activated); + } + // Activated can only go to redundant. + MOZ_ASSERT_IF(mState == ServiceWorkerState::Activated, aState == ServiceWorkerState::Redundant); +#endif + // Flush any pending functional events to the worker when it transitions to the + // activated state. + // TODO: Do we care that these events will race with the propagation of the + // state change? + if (aState == ServiceWorkerState::Activated && mState != aState) { + mServiceWorkerPrivate->Activated(); + } + mState = aState; + nsCOMPtr<nsIRunnable> r = new ChangeStateUpdater(mInstances, mState); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r.forget())); + if (mState == ServiceWorkerState::Redundant) { + serviceWorkerScriptCache::PurgeCache(mPrincipal, mCacheName); + } +} + +ServiceWorkerInfo::ServiceWorkerInfo(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + const nsAString& aCacheName) + : mPrincipal(aPrincipal) + , mScope(aScope) + , mScriptSpec(aScriptSpec) + , mCacheName(aCacheName) + , mState(ServiceWorkerState::EndGuard_) + , mServiceWorkerID(GetNextID()) + , mServiceWorkerPrivate(new ServiceWorkerPrivate(this)) + , mSkipWaitingFlag(false) +{ + MOZ_ASSERT(mPrincipal); + // cache origin attributes so we can use them off main thread + mOriginAttributes = BasePrincipal::Cast(mPrincipal)->OriginAttributesRef(); + MOZ_ASSERT(!mScope.IsEmpty()); + MOZ_ASSERT(!mScriptSpec.IsEmpty()); + MOZ_ASSERT(!mCacheName.IsEmpty()); +} + +ServiceWorkerInfo::~ServiceWorkerInfo() +{ + MOZ_ASSERT(mServiceWorkerPrivate); + mServiceWorkerPrivate->NoteDeadServiceWorkerInfo(); +} + +static uint64_t gServiceWorkerInfoCurrentID = 0; + +uint64_t +ServiceWorkerInfo::GetNextID() const +{ + return ++gServiceWorkerInfoCurrentID; +} + +already_AddRefed<ServiceWorker> +ServiceWorkerInfo::GetOrCreateInstance(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + RefPtr<ServiceWorker> ref; + + for (uint32_t i = 0; i < mInstances.Length(); ++i) { + MOZ_ASSERT(mInstances[i]); + if (mInstances[i]->GetOwner() == aWindow) { + ref = mInstances[i]; + break; + } + } + + if (!ref) { + ref = new ServiceWorker(aWindow, this); + } + + return ref.forget(); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerInfo.h b/dom/workers/ServiceWorkerInfo.h new file mode 100644 index 000000000..80910bdad --- /dev/null +++ b/dom/workers/ServiceWorkerInfo.h @@ -0,0 +1,151 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerinfo_h +#define mozilla_dom_workers_serviceworkerinfo_h + +#include "mozilla/dom/ServiceWorkerBinding.h" // For ServiceWorkerState +#include "nsIServiceWorkerManager.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorker; +class ServiceWorkerPrivate; + +/* + * Wherever the spec treats a worker instance and a description of said worker + * as the same thing; i.e. "Resolve foo with + * _GetNewestWorker(serviceWorkerRegistration)", we represent the description + * by this class and spawn a ServiceWorker in the right global when required. + */ +class ServiceWorkerInfo final : public nsIServiceWorkerInfo +{ +private: + nsCOMPtr<nsIPrincipal> mPrincipal; + const nsCString mScope; + const nsCString mScriptSpec; + const nsString mCacheName; + ServiceWorkerState mState; + PrincipalOriginAttributes mOriginAttributes; + + // This id is shared with WorkerPrivate to match requests issued by service + // workers to their corresponding serviceWorkerInfo. + uint64_t mServiceWorkerID; + + // We hold rawptrs since the ServiceWorker constructor and destructor ensure + // addition and removal. + // There is a high chance of there being at least one ServiceWorker + // associated with this all the time. + AutoTArray<ServiceWorker*, 1> mInstances; + + RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate; + bool mSkipWaitingFlag; + + ~ServiceWorkerInfo(); + + // Generates a unique id for the service worker, with zero being treated as + // invalid. + uint64_t + GetNextID() const; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISERVICEWORKERINFO + + class ServiceWorkerPrivate* + WorkerPrivate() const + { + MOZ_ASSERT(mServiceWorkerPrivate); + return mServiceWorkerPrivate; + } + + nsIPrincipal* + GetPrincipal() const + { + return mPrincipal; + } + + const nsCString& + ScriptSpec() const + { + return mScriptSpec; + } + + const nsCString& + Scope() const + { + return mScope; + } + + bool SkipWaitingFlag() const + { + AssertIsOnMainThread(); + return mSkipWaitingFlag; + } + + void SetSkipWaitingFlag() + { + AssertIsOnMainThread(); + mSkipWaitingFlag = true; + } + + ServiceWorkerInfo(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + const nsAString& aCacheName); + + ServiceWorkerState + State() const + { + return mState; + } + + const PrincipalOriginAttributes& + GetOriginAttributes() const + { + return mOriginAttributes; + } + + const nsString& + CacheName() const + { + return mCacheName; + } + + uint64_t + ID() const + { + return mServiceWorkerID; + } + + void + UpdateState(ServiceWorkerState aState); + + // Only used to set initial state when loading from disk! + void + SetActivateStateUncheckedWithoutEvent(ServiceWorkerState aState) + { + AssertIsOnMainThread(); + mState = aState; + } + + void + AppendWorker(ServiceWorker* aWorker); + + void + RemoveWorker(ServiceWorker* aWorker); + + already_AddRefed<ServiceWorker> + GetOrCreateInstance(nsPIDOMWindowInner* aWindow); +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerinfo_h diff --git a/dom/workers/ServiceWorkerJob.cpp b/dom/workers/ServiceWorkerJob.cpp new file mode 100644 index 000000000..3d0a8e2cd --- /dev/null +++ b/dom/workers/ServiceWorkerJob.cpp @@ -0,0 +1,246 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerJob.h" + +#include "nsProxyRelease.h" +#include "nsThreadUtils.h" +#include "Workers.h" + +namespace mozilla { +namespace dom { +namespace workers { + +ServiceWorkerJob::Type +ServiceWorkerJob::GetType() const +{ + return mType; +} + +ServiceWorkerJob::State +ServiceWorkerJob::GetState() const +{ + return mState; +} + +bool +ServiceWorkerJob::Canceled() const +{ + return mCanceled; +} + +bool +ServiceWorkerJob::ResultCallbacksInvoked() const +{ + return mResultCallbacksInvoked; +} + +bool +ServiceWorkerJob::IsEquivalentTo(ServiceWorkerJob* aJob) const +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + return mType == aJob->mType && + mScope.Equals(aJob->mScope) && + mScriptSpec.Equals(aJob->mScriptSpec) && + mPrincipal->Equals(aJob->mPrincipal); +} + +void +ServiceWorkerJob::AppendResultCallback(Callback* aCallback) +{ + AssertIsOnMainThread(); + MOZ_DIAGNOSTIC_ASSERT(mState != State::Finished); + MOZ_DIAGNOSTIC_ASSERT(aCallback); + MOZ_DIAGNOSTIC_ASSERT(mFinalCallback != aCallback); + MOZ_ASSERT(!mResultCallbackList.Contains(aCallback)); + MOZ_DIAGNOSTIC_ASSERT(!mResultCallbacksInvoked); + mResultCallbackList.AppendElement(aCallback); +} + +void +ServiceWorkerJob::StealResultCallbacksFrom(ServiceWorkerJob* aJob) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + MOZ_ASSERT(aJob->mState == State::Initial); + + // Take the callbacks from the other job immediately to avoid the + // any possibility of them existing on both jobs at once. + nsTArray<RefPtr<Callback>> callbackList; + callbackList.SwapElements(aJob->mResultCallbackList); + + for (RefPtr<Callback>& callback : callbackList) { + // Use AppendResultCallback() so that assertion checking is performed on + // each callback. + AppendResultCallback(callback); + } +} + +void +ServiceWorkerJob::Start(Callback* aFinalCallback) +{ + AssertIsOnMainThread(); + MOZ_DIAGNOSTIC_ASSERT(!mCanceled); + + MOZ_DIAGNOSTIC_ASSERT(aFinalCallback); + MOZ_DIAGNOSTIC_ASSERT(!mFinalCallback); + MOZ_ASSERT(!mResultCallbackList.Contains(aFinalCallback)); + mFinalCallback = aFinalCallback; + + MOZ_DIAGNOSTIC_ASSERT(mState == State::Initial); + mState = State::Started; + + nsCOMPtr<nsIRunnable> runnable = + NewRunnableMethod(this, &ServiceWorkerJob::AsyncExecute); + + // We may have to wait for the PBackground actor to be initialized + // before proceeding. We should always be able to get a ServiceWorkerManager, + // however, since Start() should not be called during shutdown. + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return; + } + if (!swm->HasBackgroundActor()) { + // waiting to initialize + swm->AppendPendingOperation(runnable); + return; + } + + // Otherwise start asynchronously. We should never run a job synchronously. + MOZ_ALWAYS_TRUE(NS_SUCCEEDED( + NS_DispatchToMainThread(runnable.forget()))); +} + +void +ServiceWorkerJob::Cancel() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!mCanceled); + mCanceled = true; +} + +ServiceWorkerJob::ServiceWorkerJob(Type aType, + nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec) + : mType(aType) + , mPrincipal(aPrincipal) + , mScope(aScope) + , mScriptSpec(aScriptSpec) + , mState(State::Initial) + , mCanceled(false) + , mResultCallbacksInvoked(false) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mPrincipal); + MOZ_ASSERT(!mScope.IsEmpty()); + // Some job types may have an empty script spec +} + +ServiceWorkerJob::~ServiceWorkerJob() +{ + AssertIsOnMainThread(); + // Jobs must finish or never be started. Destroying an actively running + // job is an error. + MOZ_ASSERT(mState != State::Started); + MOZ_ASSERT_IF(mState == State::Finished, mResultCallbacksInvoked); +} + +void +ServiceWorkerJob::InvokeResultCallbacks(ErrorResult& aRv) +{ + AssertIsOnMainThread(); + MOZ_DIAGNOSTIC_ASSERT(mState == State::Started); + + MOZ_DIAGNOSTIC_ASSERT(!mResultCallbacksInvoked); + mResultCallbacksInvoked = true; + + nsTArray<RefPtr<Callback>> callbackList; + callbackList.SwapElements(mResultCallbackList); + + for (RefPtr<Callback>& callback : callbackList) { + // The callback might consume an exception on the ErrorResult, so we need + // to clone in order to maintain the error for the next callback. + ErrorResult rv; + aRv.CloneTo(rv); + + callback->JobFinished(this, rv); + + // The callback might not consume the error. + rv.SuppressException(); + } +} + +void +ServiceWorkerJob::InvokeResultCallbacks(nsresult aRv) +{ + ErrorResult converted(aRv); + InvokeResultCallbacks(converted); +} + +void +ServiceWorkerJob::Finish(ErrorResult& aRv) +{ + AssertIsOnMainThread(); + + // Avoid double-completion because it can result on operating on cleaned + // up data. This should not happen, though, so also assert to try to + // narrow down the causes. + MOZ_DIAGNOSTIC_ASSERT(mState == State::Started); + if (mState != State::Started) { + return; + } + + // Ensure that we only surface SecurityErr, TypeErr or InvalidStateErr to script. + if (aRv.Failed() && !aRv.ErrorCodeIs(NS_ERROR_DOM_SECURITY_ERR) && + !aRv.ErrorCodeIs(NS_ERROR_DOM_TYPE_ERR) && + !aRv.ErrorCodeIs(NS_ERROR_DOM_INVALID_STATE_ERR)) { + + // Remove the old error code so we can replace it with a TypeError. + aRv.SuppressException(); + + NS_ConvertUTF8toUTF16 scriptSpec(mScriptSpec); + NS_ConvertUTF8toUTF16 scope(mScope); + + // Throw the type error with a generic error message. + aRv.ThrowTypeError<MSG_SW_INSTALL_ERROR>(scriptSpec, scope); + } + + // The final callback may drop the last ref to this object. + RefPtr<ServiceWorkerJob> kungFuDeathGrip = this; + + if (!mResultCallbacksInvoked) { + InvokeResultCallbacks(aRv); + } + + mState = State::Finished; + + MOZ_DIAGNOSTIC_ASSERT(mFinalCallback); + if (mFinalCallback) { + mFinalCallback->JobFinished(this, aRv); + mFinalCallback = nullptr; + } + + // The callback might not consume the error. + aRv.SuppressException(); + + // Async release this object to ensure that our caller methods complete + // as well. + NS_ReleaseOnMainThread(kungFuDeathGrip.forget(), true /* always proxy */); +} + +void +ServiceWorkerJob::Finish(nsresult aRv) +{ + ErrorResult converted(aRv); + Finish(converted); +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerJob.h b/dom/workers/ServiceWorkerJob.h new file mode 100644 index 000000000..56802ed97 --- /dev/null +++ b/dom/workers/ServiceWorkerJob.h @@ -0,0 +1,155 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerjob_h +#define mozilla_dom_workers_serviceworkerjob_h + +#include "nsCOMPtr.h" +#include "nsString.h" +#include "nsTArray.h" + +class nsIPrincipal; + +namespace mozilla { + +class ErrorResult; + +namespace dom { +namespace workers { + +class ServiceWorkerJob +{ +public: + // Implement this interface to receive notification when a job completes. + class Callback + { + public: + // Called once when the job completes. If the job is started, then this + // will be called. If a job is never executed due to browser shutdown, + // then this method will never be called. This method is always called + // on the main thread asynchronously after Start() completes. + virtual void JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) = 0; + + NS_IMETHOD_(MozExternalRefCountType) + AddRef(void) = 0; + + NS_IMETHOD_(MozExternalRefCountType) + Release(void) = 0; + }; + + enum class Type + { + Register, + Update, + Unregister + }; + + enum class State + { + Initial, + Started, + Finished + }; + + Type + GetType() const; + + State + GetState() const; + + // Determine if the job has been canceled. This does not change the + // current State, but indicates that the job should progress to Finished + // as soon as possible. + bool + Canceled() const; + + // Determine if the result callbacks have already been called. This is + // equivalent to the spec checked to see if the job promise has settled. + bool + ResultCallbacksInvoked() const; + + bool + IsEquivalentTo(ServiceWorkerJob* aJob) const; + + // Add a callback that will be invoked when the job's result is available. + // Some job types will invoke this before the job is actually finished. + // If an early callback does not occur, then it will be called automatically + // when Finish() is called. These callbacks will be invoked while the job + // state is Started. + void + AppendResultCallback(Callback* aCallback); + + // This takes ownership of any result callbacks associated with the given job + // and then appends them to this job's callback list. + void + StealResultCallbacksFrom(ServiceWorkerJob* aJob); + + // Start the job. All work will be performed asynchronously on + // the main thread. The Finish() method must be called exactly + // once after this point. A final callback must be provided. It + // will be invoked after all other callbacks have been processed. + void + Start(Callback* aFinalCallback); + + // Set an internal flag indicating that a started job should finish as + // soon as possible. + void + Cancel(); + +protected: + ServiceWorkerJob(Type aType, + nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec); + + virtual ~ServiceWorkerJob(); + + // Invoke the result callbacks immediately. The job must be in the + // Started state. The callbacks are cleared after being invoked, + // so subsequent method calls have no effect. + void + InvokeResultCallbacks(ErrorResult& aRv); + + // Convenience method that converts to ErrorResult and calls real method. + void + InvokeResultCallbacks(nsresult aRv); + + // Indicate that the job has completed. The must be called exactly + // once after Start() has initiated job execution. It may not be + // called until Start() has returned. + void + Finish(ErrorResult& aRv); + + // Convenience method that converts to ErrorResult and calls real method. + void + Finish(nsresult aRv); + + // Specific job types should define AsyncExecute to begin their work. + // All errors and successes must result in Finish() being called. + virtual void + AsyncExecute() = 0; + + const Type mType; + nsCOMPtr<nsIPrincipal> mPrincipal; + const nsCString mScope; + const nsCString mScriptSpec; + +private: + RefPtr<Callback> mFinalCallback; + nsTArray<RefPtr<Callback>> mResultCallbackList; + State mState; + bool mCanceled; + bool mResultCallbacksInvoked; + +public: + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerJob) +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerjob_h diff --git a/dom/workers/ServiceWorkerJobQueue.cpp b/dom/workers/ServiceWorkerJobQueue.cpp new file mode 100644 index 000000000..15a798a4d --- /dev/null +++ b/dom/workers/ServiceWorkerJobQueue.cpp @@ -0,0 +1,134 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerJobQueue.h" + +#include "ServiceWorkerJob.h" +#include "Workers.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerJobQueue::Callback final : public ServiceWorkerJob::Callback +{ + RefPtr<ServiceWorkerJobQueue> mQueue; + + ~Callback() + { + } + +public: + explicit Callback(ServiceWorkerJobQueue* aQueue) + : mQueue(aQueue) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mQueue); + } + + virtual void + JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) override + { + AssertIsOnMainThread(); + mQueue->JobFinished(aJob); + } + + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerJobQueue::Callback, override) +}; + +ServiceWorkerJobQueue::~ServiceWorkerJobQueue() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mJobList.IsEmpty()); +} + +void +ServiceWorkerJobQueue::JobFinished(ServiceWorkerJob* aJob) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + + // XXX There are some corner cases where jobs can double-complete. Until + // we track all these down we do a non-fatal assert in debug builds and + // a runtime check to verify the queue is in the correct state. + NS_ASSERTION(!mJobList.IsEmpty(), + "Job queue should contain the job that just completed."); + NS_ASSERTION(mJobList.SafeElementAt(0, nullptr) == aJob, + "Job queue should contain the job that just completed."); + if (NS_WARN_IF(mJobList.SafeElementAt(0, nullptr) != aJob)) { + return; + } + + mJobList.RemoveElementAt(0); + + if (mJobList.IsEmpty()) { + return; + } + + RunJob(); +} + +void +ServiceWorkerJobQueue::RunJob() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!mJobList.IsEmpty()); + MOZ_ASSERT(mJobList[0]->GetState() == ServiceWorkerJob::State::Initial); + + RefPtr<Callback> callback = new Callback(this); + mJobList[0]->Start(callback); +} + +ServiceWorkerJobQueue::ServiceWorkerJobQueue() +{ + AssertIsOnMainThread(); +} + +void +ServiceWorkerJobQueue::ScheduleJob(ServiceWorkerJob* aJob) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + MOZ_ASSERT(!mJobList.Contains(aJob)); + + if (mJobList.IsEmpty()) { + mJobList.AppendElement(aJob); + RunJob(); + return; + } + + MOZ_ASSERT(mJobList[0]->GetState() == ServiceWorkerJob::State::Started); + + RefPtr<ServiceWorkerJob>& tailJob = mJobList[mJobList.Length() - 1]; + if (!tailJob->ResultCallbacksInvoked() && aJob->IsEquivalentTo(tailJob)) { + tailJob->StealResultCallbacksFrom(aJob); + return; + } + + mJobList.AppendElement(aJob); +} + +void +ServiceWorkerJobQueue::CancelAll() +{ + AssertIsOnMainThread(); + + for (RefPtr<ServiceWorkerJob>& job : mJobList) { + job->Cancel(); + } + + // Remove jobs that are queued but not started since they should never + // run after being canceled. This means throwing away all jobs except + // for the job at the front of the list. + if (!mJobList.IsEmpty()) { + MOZ_ASSERT(mJobList[0]->GetState() == ServiceWorkerJob::State::Started); + mJobList.TruncateLength(1); + } +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerJobQueue.h b/dom/workers/ServiceWorkerJobQueue.h new file mode 100644 index 000000000..2af8682b3 --- /dev/null +++ b/dom/workers/ServiceWorkerJobQueue.h @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerjobqueue_h +#define mozilla_dom_workers_serviceworkerjobqueue_h + +#include "mozilla/RefPtr.h" +#include "nsTArray.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerJob; + +class ServiceWorkerJobQueue final +{ + class Callback; + + nsTArray<RefPtr<ServiceWorkerJob>> mJobList; + + ~ServiceWorkerJobQueue(); + + void + JobFinished(ServiceWorkerJob* aJob); + + void + RunJob(); + +public: + ServiceWorkerJobQueue(); + + void + ScheduleJob(ServiceWorkerJob* aJob); + + void + CancelAll(); + + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerJobQueue) +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerjobqueue_h diff --git a/dom/workers/ServiceWorkerManager.cpp b/dom/workers/ServiceWorkerManager.cpp new file mode 100644 index 000000000..a66df0731 --- /dev/null +++ b/dom/workers/ServiceWorkerManager.cpp @@ -0,0 +1,3969 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerManager.h" + +#include "nsAutoPtr.h" +#include "nsIConsoleService.h" +#include "nsIDOMEventTarget.h" +#include "nsIDocument.h" +#include "nsIScriptSecurityManager.h" +#include "nsIStreamLoader.h" +#include "nsIHttpChannel.h" +#include "nsIHttpChannelInternal.h" +#include "nsIHttpHeaderVisitor.h" +#include "nsINetworkInterceptController.h" +#include "nsIMutableArray.h" +#include "nsIScriptError.h" +#include "nsISimpleEnumerator.h" +#include "nsITimer.h" +#include "nsIUploadChannel2.h" +#include "nsPIDOMWindow.h" +#include "nsScriptLoader.h" +#include "nsServiceManagerUtils.h" +#include "nsDebug.h" +#include "nsISupportsPrimitives.h" + +#include "jsapi.h" + +#include "mozilla/BasePrincipal.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/ErrorNames.h" +#include "mozilla/LoadContext.h" +#include "mozilla/Telemetry.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/DOMError.h" +#include "mozilla/dom/ErrorEvent.h" +#include "mozilla/dom/Headers.h" +#include "mozilla/dom/InternalHeaders.h" +#include "mozilla/dom/Navigator.h" +#include "mozilla/dom/NotificationEvent.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/Request.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "mozilla/Unused.h" +#include "mozilla/EnumSet.h" + +#include "nsContentPolicyUtils.h" +#include "nsContentSecurityManager.h" +#include "nsContentUtils.h" +#include "nsGlobalWindow.h" +#include "nsNetUtil.h" +#include "nsProxyRelease.h" +#include "nsQueryObject.h" +#include "nsTArray.h" + +#include "RuntimeService.h" +#include "ServiceWorker.h" +#include "ServiceWorkerClient.h" +#include "ServiceWorkerContainer.h" +#include "ServiceWorkerInfo.h" +#include "ServiceWorkerJobQueue.h" +#include "ServiceWorkerManagerChild.h" +#include "ServiceWorkerPrivate.h" +#include "ServiceWorkerRegisterJob.h" +#include "ServiceWorkerRegistrar.h" +#include "ServiceWorkerRegistration.h" +#include "ServiceWorkerScriptCache.h" +#include "ServiceWorkerEvents.h" +#include "ServiceWorkerUnregisterJob.h" +#include "ServiceWorkerUpdateJob.h" +#include "SharedWorker.h" +#include "WorkerInlines.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" + +#ifdef PostMessage +#undef PostMessage +#endif + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +BEGIN_WORKERS_NAMESPACE + +#define PURGE_DOMAIN_DATA "browser:purge-domain-data" +#define PURGE_SESSION_HISTORY "browser:purge-session-history" +#define CLEAR_ORIGIN_DATA "clear-origin-attributes-data" + +static_assert(nsIHttpChannelInternal::CORS_MODE_SAME_ORIGIN == static_cast<uint32_t>(RequestMode::Same_origin), + "RequestMode enumeration value should match Necko CORS mode value."); +static_assert(nsIHttpChannelInternal::CORS_MODE_NO_CORS == static_cast<uint32_t>(RequestMode::No_cors), + "RequestMode enumeration value should match Necko CORS mode value."); +static_assert(nsIHttpChannelInternal::CORS_MODE_CORS == static_cast<uint32_t>(RequestMode::Cors), + "RequestMode enumeration value should match Necko CORS mode value."); +static_assert(nsIHttpChannelInternal::CORS_MODE_NAVIGATE == static_cast<uint32_t>(RequestMode::Navigate), + "RequestMode enumeration value should match Necko CORS mode value."); + +static_assert(nsIHttpChannelInternal::REDIRECT_MODE_FOLLOW == static_cast<uint32_t>(RequestRedirect::Follow), + "RequestRedirect enumeration value should make Necko Redirect mode value."); +static_assert(nsIHttpChannelInternal::REDIRECT_MODE_ERROR == static_cast<uint32_t>(RequestRedirect::Error), + "RequestRedirect enumeration value should make Necko Redirect mode value."); +static_assert(nsIHttpChannelInternal::REDIRECT_MODE_MANUAL == static_cast<uint32_t>(RequestRedirect::Manual), + "RequestRedirect enumeration value should make Necko Redirect mode value."); +static_assert(3 == static_cast<uint32_t>(RequestRedirect::EndGuard_), + "RequestRedirect enumeration value should make Necko Redirect mode value."); + +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_DEFAULT == static_cast<uint32_t>(RequestCache::Default), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_NO_STORE == static_cast<uint32_t>(RequestCache::No_store), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_RELOAD == static_cast<uint32_t>(RequestCache::Reload), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_NO_CACHE == static_cast<uint32_t>(RequestCache::No_cache), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_FORCE_CACHE == static_cast<uint32_t>(RequestCache::Force_cache), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(nsIHttpChannelInternal::FETCH_CACHE_MODE_ONLY_IF_CACHED == static_cast<uint32_t>(RequestCache::Only_if_cached), + "RequestCache enumeration value should match Necko Cache mode value."); +static_assert(6 == static_cast<uint32_t>(RequestCache::EndGuard_), + "RequestCache enumeration value should match Necko Cache mode value."); + +static StaticRefPtr<ServiceWorkerManager> gInstance; + +struct ServiceWorkerManager::RegistrationDataPerPrincipal final +{ + // Ordered list of scopes for glob matching. + // Each entry is an absolute URL representing the scope. + // Each value of the hash table is an array of an absolute URLs representing + // the scopes. + // + // An array is used for now since the number of controlled scopes per + // domain is expected to be relatively low. If that assumption was proved + // wrong this should be replaced with a better structure to avoid the + // memmoves associated with inserting stuff in the middle of the array. + nsTArray<nsCString> mOrderedScopes; + + // Scope to registration. + // The scope should be a fully qualified valid URL. + nsRefPtrHashtable<nsCStringHashKey, ServiceWorkerRegistrationInfo> mInfos; + + // Maps scopes to job queues. + nsRefPtrHashtable<nsCStringHashKey, ServiceWorkerJobQueue> mJobQueues; + + // Map scopes to scheduled update timers. + nsInterfaceHashtable<nsCStringHashKey, nsITimer> mUpdateTimers; +}; + +namespace { + +nsresult +PopulateRegistrationData(nsIPrincipal* aPrincipal, + const ServiceWorkerRegistrationInfo* aRegistration, + ServiceWorkerRegistrationData& aData) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aRegistration); + + if (NS_WARN_IF(!BasePrincipal::Cast(aPrincipal)->IsCodebasePrincipal())) { + return NS_ERROR_FAILURE; + } + + nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &aData.principal()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + aData.scope() = aRegistration->mScope; + + RefPtr<ServiceWorkerInfo> newest = aRegistration->Newest(); + if (NS_WARN_IF(!newest)) { + return NS_ERROR_FAILURE; + } + + if (aRegistration->GetActive()) { + aData.currentWorkerURL() = aRegistration->GetActive()->ScriptSpec(); + aData.cacheName() = aRegistration->GetActive()->CacheName(); + } + + return NS_OK; +} + +class TeardownRunnable final : public Runnable +{ +public: + explicit TeardownRunnable(ServiceWorkerManagerChild* aActor) + : mActor(aActor) + { + MOZ_ASSERT(mActor); + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(mActor); + mActor->SendShutdown(); + return NS_OK; + } + +private: + ~TeardownRunnable() {} + + RefPtr<ServiceWorkerManagerChild> mActor; +}; + +} // namespace + +////////////////////////// +// ServiceWorkerManager // +////////////////////////// + +NS_IMPL_ADDREF(ServiceWorkerManager) +NS_IMPL_RELEASE(ServiceWorkerManager) + +NS_INTERFACE_MAP_BEGIN(ServiceWorkerManager) + NS_INTERFACE_MAP_ENTRY(nsIServiceWorkerManager) + NS_INTERFACE_MAP_ENTRY(nsIIPCBackgroundChildCreateCallback) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIServiceWorkerManager) +NS_INTERFACE_MAP_END + +ServiceWorkerManager::ServiceWorkerManager() + : mActor(nullptr) + , mShuttingDown(false) +{ +} + +ServiceWorkerManager::~ServiceWorkerManager() +{ + // The map will assert if it is not empty when destroyed. + mRegistrationInfos.Clear(); + MOZ_ASSERT(!mActor); +} + +void +ServiceWorkerManager::Init(ServiceWorkerRegistrar* aRegistrar) +{ + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + DebugOnly<nsresult> rv; + rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false /* ownsWeak */); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + + if (XRE_IsParentProcess()) { + MOZ_DIAGNOSTIC_ASSERT(aRegistrar); + + nsTArray<ServiceWorkerRegistrationData> data; + aRegistrar->GetRegistrations(data); + LoadRegistrations(data); + + if (obs) { + DebugOnly<nsresult> rv; + rv = obs->AddObserver(this, PURGE_SESSION_HISTORY, false /* ownsWeak */); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = obs->AddObserver(this, PURGE_DOMAIN_DATA, false /* ownsWeak */); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = obs->AddObserver(this, CLEAR_ORIGIN_DATA, false /* ownsWeak */); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + } + + if (!BackgroundChild::GetOrCreateForCurrentThread(this)) { + // Make sure to do this last as our failure cleanup expects Init() to have + // executed. + ActorFailed(); + } +} + +void +ServiceWorkerManager::MaybeStartShutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (mShuttingDown) { + return; + } + + mShuttingDown = true; + + for (auto it1 = mRegistrationInfos.Iter(); !it1.Done(); it1.Next()) { + for (auto it2 = it1.UserData()->mUpdateTimers.Iter(); !it2.Done(); it2.Next()) { + nsCOMPtr<nsITimer> timer = it2.UserData(); + timer->Cancel(); + } + it1.UserData()->mUpdateTimers.Clear(); + + for (auto it2 = it1.UserData()->mJobQueues.Iter(); !it2.Done(); it2.Next()) { + RefPtr<ServiceWorkerJobQueue> queue = it2.UserData(); + queue->CancelAll(); + } + it1.UserData()->mJobQueues.Clear(); + } + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + + if (XRE_IsParentProcess()) { + obs->RemoveObserver(this, PURGE_SESSION_HISTORY); + obs->RemoveObserver(this, PURGE_DOMAIN_DATA); + obs->RemoveObserver(this, CLEAR_ORIGIN_DATA); + } + } + + mPendingOperations.Clear(); + + if (!mActor) { + return; + } + + mActor->ManagerShuttingDown(); + + RefPtr<TeardownRunnable> runnable = new TeardownRunnable(mActor); + nsresult rv = NS_DispatchToMainThread(runnable); + Unused << NS_WARN_IF(NS_FAILED(rv)); + mActor = nullptr; +} + +class ServiceWorkerResolveWindowPromiseOnRegisterCallback final : public ServiceWorkerJob::Callback +{ + RefPtr<nsPIDOMWindowInner> mWindow; + // The promise "returned" by the call to Update up to + // navigator.serviceWorker.register(). + RefPtr<Promise> mPromise; + + ~ServiceWorkerResolveWindowPromiseOnRegisterCallback() + {} + + virtual void + JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) override + { + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + + if (aStatus.Failed()) { + mPromise->MaybeReject(aStatus); + return; + } + + MOZ_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Register); + RefPtr<ServiceWorkerRegisterJob> registerJob = + static_cast<ServiceWorkerRegisterJob*>(aJob); + RefPtr<ServiceWorkerRegistrationInfo> reg = registerJob->GetRegistration(); + + RefPtr<ServiceWorkerRegistration> swr = + mWindow->GetServiceWorkerRegistration(NS_ConvertUTF8toUTF16(reg->mScope)); + mPromise->MaybeResolve(swr); + } + +public: + ServiceWorkerResolveWindowPromiseOnRegisterCallback(nsPIDOMWindowInner* aWindow, + Promise* aPromise) + : mWindow(aWindow) + , mPromise(aPromise) + {} + + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerResolveWindowPromiseOnRegisterCallback, override) +}; + +namespace { + +class PropagateSoftUpdateRunnable final : public Runnable +{ +public: + PropagateSoftUpdateRunnable(const PrincipalOriginAttributes& aOriginAttributes, + const nsAString& aScope) + : mOriginAttributes(aOriginAttributes) + , mScope(aScope) + {} + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->PropagateSoftUpdate(mOriginAttributes, mScope); + } + + return NS_OK; + } + +private: + ~PropagateSoftUpdateRunnable() + {} + + const PrincipalOriginAttributes mOriginAttributes; + const nsString mScope; +}; + +class PropagateUnregisterRunnable final : public Runnable +{ +public: + PropagateUnregisterRunnable(nsIPrincipal* aPrincipal, + nsIServiceWorkerUnregisterCallback* aCallback, + const nsAString& aScope) + : mPrincipal(aPrincipal) + , mCallback(aCallback) + , mScope(aScope) + { + MOZ_ASSERT(aPrincipal); + } + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->PropagateUnregister(mPrincipal, mCallback, mScope); + } + + return NS_OK; + } + +private: + ~PropagateUnregisterRunnable() + {} + + nsCOMPtr<nsIPrincipal> mPrincipal; + nsCOMPtr<nsIServiceWorkerUnregisterCallback> mCallback; + const nsString mScope; +}; + +class RemoveRunnable final : public Runnable +{ +public: + explicit RemoveRunnable(const nsACString& aHost) + {} + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->Remove(mHost); + } + + return NS_OK; + } + +private: + ~RemoveRunnable() + {} + + const nsCString mHost; +}; + +class PropagateRemoveRunnable final : public Runnable +{ +public: + explicit PropagateRemoveRunnable(const nsACString& aHost) + {} + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->PropagateRemove(mHost); + } + + return NS_OK; + } + +private: + ~PropagateRemoveRunnable() + {} + + const nsCString mHost; +}; + +class PropagateRemoveAllRunnable final : public Runnable +{ +public: + PropagateRemoveAllRunnable() + {} + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->PropagateRemoveAll(); + } + + return NS_OK; + } + +private: + ~PropagateRemoveAllRunnable() + {} +}; + +} // namespace + +// This function implements parts of the step 3 of the following algorithm: +// https://w3c.github.io/webappsec/specs/powerfulfeatures/#settings-secure +static bool +IsFromAuthenticatedOrigin(nsIDocument* aDoc) +{ + MOZ_ASSERT(aDoc); + nsCOMPtr<nsIDocument> doc(aDoc); + nsCOMPtr<nsIContentSecurityManager> csm = do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID); + if (NS_WARN_IF(!csm)) { + return false; + } + + while (doc && !nsContentUtils::IsChromeDoc(doc)) { + bool trustworthyOrigin = false; + + // The origin of the document may be different from the document URI + // itself. Check the principal, not the document URI itself. + nsCOMPtr<nsIPrincipal> documentPrincipal = doc->NodePrincipal(); + + // The check for IsChromeDoc() above should mean we never see a system + // principal inside the loop. + MOZ_ASSERT(!nsContentUtils::IsSystemPrincipal(documentPrincipal)); + + csm->IsOriginPotentiallyTrustworthy(documentPrincipal, &trustworthyOrigin); + if (!trustworthyOrigin) { + return false; + } + + doc = doc->GetParentDocument(); + } + return true; +} + +// If we return an error code here, the ServiceWorkerContainer will +// automatically reject the Promise. +NS_IMETHODIMP +ServiceWorkerManager::Register(mozIDOMWindow* aWindow, + nsIURI* aScopeURI, + nsIURI* aScriptURI, + nsISupports** aPromise) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + auto* window = nsPIDOMWindowInner::From(aWindow); + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (!doc) { + return NS_ERROR_FAILURE; + } + + // Don't allow service workers to register when the *document* is chrome. + if (NS_WARN_IF(nsContentUtils::IsSystemPrincipal(doc->NodePrincipal()))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsCOMPtr<nsPIDOMWindowOuter> outerWindow = window->GetOuterWindow(); + bool serviceWorkersTestingEnabled = + outerWindow->GetServiceWorkersTestingEnabled(); + + bool authenticatedOrigin; + if (Preferences::GetBool("dom.serviceWorkers.testing.enabled") || + serviceWorkersTestingEnabled) { + authenticatedOrigin = true; + } else { + authenticatedOrigin = IsFromAuthenticatedOrigin(doc); + } + + if (!authenticatedOrigin) { + NS_WARNING("ServiceWorker registration from insecure websites is not allowed."); + return NS_ERROR_DOM_SECURITY_ERR; + } + + // Data URLs are not allowed. + nsCOMPtr<nsIPrincipal> documentPrincipal = doc->NodePrincipal(); + + nsresult rv = documentPrincipal->CheckMayLoad(aScriptURI, true /* report */, + false /* allowIfInheritsPrincipal */); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + // Check content policy. + int16_t decision = nsIContentPolicy::ACCEPT; + rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER, + aScriptURI, + documentPrincipal, + doc, + EmptyCString(), + nullptr, + &decision); + NS_ENSURE_SUCCESS(rv, rv); + if (NS_WARN_IF(decision != nsIContentPolicy::ACCEPT)) { + return NS_ERROR_CONTENT_BLOCKED; + } + + + rv = documentPrincipal->CheckMayLoad(aScopeURI, true /* report */, + false /* allowIfInheritsPrinciple */); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + // The IsOriginPotentiallyTrustworthy() check allows file:// and possibly other + // URI schemes. We need to explicitly only allows http and https schemes. + // Note, we just use the aScriptURI here for the check since its already + // been verified as same origin with the document principal. This also + // is a good block against accidentally allowing blob: script URIs which + // might inherit the origin. + bool isHttp = false; + bool isHttps = false; + aScriptURI->SchemeIs("http", &isHttp); + aScriptURI->SchemeIs("https", &isHttps); + if (NS_WARN_IF(!isHttp && !isHttps)) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsCString cleanedScope; + rv = aScopeURI->GetSpecIgnoringRef(cleanedScope); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + nsAutoCString spec; + rv = aScriptURI->GetSpecIgnoringRef(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIGlobalObject> sgo = do_QueryInterface(window); + ErrorResult result; + RefPtr<Promise> promise = Promise::Create(sgo, result); + if (result.Failed()) { + return result.StealNSResult(); + } + + nsAutoCString scopeKey; + rv = PrincipalToScopeKey(documentPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + AddRegisteringDocument(cleanedScope, doc); + + RefPtr<ServiceWorkerJobQueue> queue = GetOrCreateJobQueue(scopeKey, + cleanedScope); + + RefPtr<ServiceWorkerResolveWindowPromiseOnRegisterCallback> cb = + new ServiceWorkerResolveWindowPromiseOnRegisterCallback(window, promise); + + nsCOMPtr<nsILoadGroup> docLoadGroup = doc->GetDocumentLoadGroup(); + RefPtr<WorkerLoadInfo::InterfaceRequestor> ir = + new WorkerLoadInfo::InterfaceRequestor(documentPrincipal, docLoadGroup); + ir->MaybeAddTabChild(docLoadGroup); + + // Create a load group that is separate from, yet related to, the document's load group. + // This allows checks for interfaces like nsILoadContext to yield the values used by the + // the document, yet will not cancel the update job if the document's load group is cancelled. + nsCOMPtr<nsILoadGroup> loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID); + MOZ_ALWAYS_SUCCEEDS(loadGroup->SetNotificationCallbacks(ir)); + + RefPtr<ServiceWorkerRegisterJob> job = + new ServiceWorkerRegisterJob(documentPrincipal, cleanedScope, spec, + loadGroup); + job->AppendResultCallback(cb); + queue->ScheduleJob(job); + + AssertIsOnMainThread(); + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_REGISTRATIONS, 1); + + promise.forget(aPromise); + return NS_OK; +} + +void +ServiceWorkerManager::AppendPendingOperation(nsIRunnable* aRunnable) +{ + MOZ_ASSERT(!mActor); + MOZ_ASSERT(aRunnable); + + if (!mShuttingDown) { + mPendingOperations.AppendElement(aRunnable); + } +} + +/* + * Implements the async aspects of the getRegistrations algorithm. + */ +class GetRegistrationsRunnable final : public Runnable +{ + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<Promise> mPromise; +public: + GetRegistrationsRunnable(nsPIDOMWindowInner* aWindow, Promise* aPromise) + : mWindow(aWindow), mPromise(aPromise) + {} + + NS_IMETHOD + Run() override + { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsIDocument* doc = mWindow->GetExtantDoc(); + if (!doc) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsCOMPtr<nsIURI> docURI = doc->GetDocumentURI(); + if (!docURI) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal(); + if (!principal) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsTArray<RefPtr<ServiceWorkerRegistration>> array; + + if (NS_WARN_IF(!BasePrincipal::Cast(principal)->IsCodebasePrincipal())) { + return NS_OK; + } + + nsAutoCString scopeKey; + nsresult rv = swm->PrincipalToScopeKey(principal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + ServiceWorkerManager::RegistrationDataPerPrincipal* data; + if (!swm->mRegistrationInfos.Get(scopeKey, &data)) { + mPromise->MaybeResolve(array); + return NS_OK; + } + + for (uint32_t i = 0; i < data->mOrderedScopes.Length(); ++i) { + RefPtr<ServiceWorkerRegistrationInfo> info = + data->mInfos.GetWeak(data->mOrderedScopes[i]); + if (info->mPendingUninstall) { + continue; + } + + NS_ConvertUTF8toUTF16 scope(data->mOrderedScopes[i]); + + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), scope, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPromise->MaybeReject(rv); + break; + } + + rv = principal->CheckMayLoad(scopeURI, true /* report */, + false /* allowIfInheritsPrincipal */); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + RefPtr<ServiceWorkerRegistration> swr = + mWindow->GetServiceWorkerRegistration(scope); + + array.AppendElement(swr); + } + + mPromise->MaybeResolve(array); + return NS_OK; + } +}; + +// If we return an error code here, the ServiceWorkerContainer will +// automatically reject the Promise. +NS_IMETHODIMP +ServiceWorkerManager::GetRegistrations(mozIDOMWindow* aWindow, + nsISupports** aPromise) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + auto* window = nsPIDOMWindowInner::From(aWindow); + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (NS_WARN_IF(!doc)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + // Don't allow service workers to register when the *document* is chrome for + // now. + MOZ_ASSERT(!nsContentUtils::IsSystemPrincipal(doc->NodePrincipal())); + + nsCOMPtr<nsIGlobalObject> sgo = do_QueryInterface(window); + ErrorResult result; + RefPtr<Promise> promise = Promise::Create(sgo, result); + if (result.Failed()) { + return result.StealNSResult(); + } + + nsCOMPtr<nsIRunnable> runnable = + new GetRegistrationsRunnable(window, promise); + promise.forget(aPromise); + return NS_DispatchToCurrentThread(runnable); +} + +/* + * Implements the async aspects of the getRegistration algorithm. + */ +class GetRegistrationRunnable final : public Runnable +{ + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<Promise> mPromise; + nsString mDocumentURL; + +public: + GetRegistrationRunnable(nsPIDOMWindowInner* aWindow, Promise* aPromise, + const nsAString& aDocumentURL) + : mWindow(aWindow), mPromise(aPromise), mDocumentURL(aDocumentURL) + {} + + NS_IMETHOD + Run() override + { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsIDocument* doc = mWindow->GetExtantDoc(); + if (!doc) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsCOMPtr<nsIURI> docURI = doc->GetDocumentURI(); + if (!docURI) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), mDocumentURL, nullptr, docURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPromise->MaybeReject(rv); + return NS_OK; + } + + nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal(); + if (!principal) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + rv = principal->CheckMayLoad(uri, true /* report */, + false /* allowIfInheritsPrinciple */); + if (NS_FAILED(rv)) { + mPromise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR); + return NS_OK; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetServiceWorkerRegistrationInfo(principal, uri); + + if (!registration) { + mPromise->MaybeResolveWithUndefined(); + return NS_OK; + } + + NS_ConvertUTF8toUTF16 scope(registration->mScope); + RefPtr<ServiceWorkerRegistration> swr = + mWindow->GetServiceWorkerRegistration(scope); + mPromise->MaybeResolve(swr); + + return NS_OK; + } +}; + +// If we return an error code here, the ServiceWorkerContainer will +// automatically reject the Promise. +NS_IMETHODIMP +ServiceWorkerManager::GetRegistration(mozIDOMWindow* aWindow, + const nsAString& aDocumentURL, + nsISupports** aPromise) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + auto* window = nsPIDOMWindowInner::From(aWindow); + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (NS_WARN_IF(!doc)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + // Don't allow service workers to register when the *document* is chrome for + // now. + MOZ_ASSERT(!nsContentUtils::IsSystemPrincipal(doc->NodePrincipal())); + + nsCOMPtr<nsIGlobalObject> sgo = do_QueryInterface(window); + ErrorResult result; + RefPtr<Promise> promise = Promise::Create(sgo, result); + if (result.Failed()) { + return result.StealNSResult(); + } + + nsCOMPtr<nsIRunnable> runnable = + new GetRegistrationRunnable(window, promise, aDocumentURL); + promise.forget(aPromise); + return NS_DispatchToCurrentThread(runnable); +} + +class GetReadyPromiseRunnable final : public Runnable +{ + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<Promise> mPromise; + +public: + GetReadyPromiseRunnable(nsPIDOMWindowInner* aWindow, Promise* aPromise) + : mWindow(aWindow), mPromise(aPromise) + {} + + NS_IMETHOD + Run() override + { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsIDocument* doc = mWindow->GetExtantDoc(); + if (!doc) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + nsCOMPtr<nsIURI> docURI = doc->GetDocumentURI(); + if (!docURI) { + mPromise->MaybeReject(NS_ERROR_UNEXPECTED); + return NS_OK; + } + + if (!swm->CheckReadyPromise(mWindow, docURI, mPromise)) { + swm->StorePendingReadyPromise(mWindow, docURI, mPromise); + } + + return NS_OK; + } +}; + +NS_IMETHODIMP +ServiceWorkerManager::SendPushEvent(const nsACString& aOriginAttributes, + const nsACString& aScope, + uint32_t aDataLength, + uint8_t* aDataBytes, + uint8_t optional_argc) +{ + if (optional_argc == 2) { + nsTArray<uint8_t> data; + if (!data.InsertElementsAt(0, aDataBytes, aDataLength, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + return SendPushEvent(aOriginAttributes, aScope, EmptyString(), Some(data)); + } + MOZ_ASSERT(optional_argc == 0); + return SendPushEvent(aOriginAttributes, aScope, EmptyString(), Nothing()); +} + +nsresult +ServiceWorkerManager::SendPushEvent(const nsACString& aOriginAttributes, + const nsACString& aScope, + const nsAString& aMessageId, + const Maybe<nsTArray<uint8_t>>& aData) +{ + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(aOriginAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + ServiceWorkerInfo* serviceWorker = GetActiveWorkerInfoForScope(attrs, aScope); + if (NS_WARN_IF(!serviceWorker)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(serviceWorker->GetPrincipal(), aScope); + MOZ_DIAGNOSTIC_ASSERT(registration); + + return serviceWorker->WorkerPrivate()->SendPushEvent(aMessageId, aData, + registration); +} + +NS_IMETHODIMP +ServiceWorkerManager::SendPushSubscriptionChangeEvent(const nsACString& aOriginAttributes, + const nsACString& aScope) +{ + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(aOriginAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + ServiceWorkerInfo* info = GetActiveWorkerInfoForScope(attrs, aScope); + if (!info) { + return NS_ERROR_FAILURE; + } + return info->WorkerPrivate()->SendPushSubscriptionChangeEvent(); +} + +nsresult +ServiceWorkerManager::SendNotificationEvent(const nsAString& aEventName, + const nsACString& aOriginSuffix, + const nsACString& aScope, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior) +{ + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(aOriginSuffix)) { + return NS_ERROR_INVALID_ARG; + } + + ServiceWorkerInfo* info = GetActiveWorkerInfoForScope(attrs, aScope); + if (!info) { + return NS_ERROR_FAILURE; + } + + ServiceWorkerPrivate* workerPrivate = info->WorkerPrivate(); + return workerPrivate->SendNotificationEvent(aEventName, aID, aTitle, aDir, + aLang, aBody, aTag, + aIcon, aData, aBehavior, + NS_ConvertUTF8toUTF16(aScope)); +} + +NS_IMETHODIMP +ServiceWorkerManager::SendNotificationClickEvent(const nsACString& aOriginSuffix, + const nsACString& aScope, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior) +{ + return SendNotificationEvent(NS_LITERAL_STRING(NOTIFICATION_CLICK_EVENT_NAME), + aOriginSuffix, aScope, aID, aTitle, aDir, aLang, + aBody, aTag, aIcon, aData, aBehavior); +} + +NS_IMETHODIMP +ServiceWorkerManager::SendNotificationCloseEvent(const nsACString& aOriginSuffix, + const nsACString& aScope, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior) +{ + return SendNotificationEvent(NS_LITERAL_STRING(NOTIFICATION_CLOSE_EVENT_NAME), + aOriginSuffix, aScope, aID, aTitle, aDir, aLang, + aBody, aTag, aIcon, aData, aBehavior); +} + +NS_IMETHODIMP +ServiceWorkerManager::GetReadyPromise(mozIDOMWindow* aWindow, + nsISupports** aPromise) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + auto* window = nsPIDOMWindowInner::From(aWindow); + + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (NS_WARN_IF(!doc)) { + return NS_ERROR_FAILURE; + } + + // Don't allow service workers to register when the *document* is chrome for + // now. + MOZ_ASSERT(!nsContentUtils::IsSystemPrincipal(doc->NodePrincipal())); + + MOZ_ASSERT(!mPendingReadyPromises.Contains(window)); + + nsCOMPtr<nsIGlobalObject> sgo = do_QueryInterface(window); + ErrorResult result; + RefPtr<Promise> promise = Promise::Create(sgo, result); + if (result.Failed()) { + return result.StealNSResult(); + } + + nsCOMPtr<nsIRunnable> runnable = + new GetReadyPromiseRunnable(window, promise); + promise.forget(aPromise); + return NS_DispatchToCurrentThread(runnable); +} + +NS_IMETHODIMP +ServiceWorkerManager::RemoveReadyPromise(mozIDOMWindow* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + + if (!aWindow) { + return NS_ERROR_FAILURE; + } + + mPendingReadyPromises.Remove(aWindow); + return NS_OK; +} + +void +ServiceWorkerManager::StorePendingReadyPromise(nsPIDOMWindowInner* aWindow, + nsIURI* aURI, + Promise* aPromise) +{ + PendingReadyPromise* data; + + // We should not have 2 pending promises for the same window. + MOZ_ASSERT(!mPendingReadyPromises.Get(aWindow, &data)); + + data = new PendingReadyPromise(aURI, aPromise); + mPendingReadyPromises.Put(aWindow, data); +} + +void +ServiceWorkerManager::CheckPendingReadyPromises() +{ + for (auto iter = mPendingReadyPromises.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(iter.Key()); + MOZ_ASSERT(window); + + nsAutoPtr<PendingReadyPromise>& pendingReadyPromise = iter.Data(); + if (CheckReadyPromise(window, pendingReadyPromise->mURI, + pendingReadyPromise->mPromise)) { + iter.Remove(); + } + } +} + +bool +ServiceWorkerManager::CheckReadyPromise(nsPIDOMWindowInner* aWindow, + nsIURI* aURI, Promise* aPromise) +{ + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aURI); + + nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc(); + MOZ_ASSERT(doc); + + nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal(); + MOZ_ASSERT(principal); + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetServiceWorkerRegistrationInfo(principal, aURI); + + if (registration && registration->GetActive()) { + NS_ConvertUTF8toUTF16 scope(registration->mScope); + RefPtr<ServiceWorkerRegistration> swr = + aWindow->GetServiceWorkerRegistration(scope); + aPromise->MaybeResolve(swr); + return true; + } + + return false; +} + +ServiceWorkerInfo* +ServiceWorkerManager::GetActiveWorkerInfoForScope(const PrincipalOriginAttributes& aOriginAttributes, + const nsACString& aScope) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), aScope, nullptr, nullptr); + if (NS_FAILED(rv)) { + return nullptr; + } + nsCOMPtr<nsIPrincipal> principal = + BasePrincipal::CreateCodebasePrincipal(scopeURI, aOriginAttributes); + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetServiceWorkerRegistrationInfo(principal, scopeURI); + if (!registration) { + return nullptr; + } + + return registration->GetActive(); +} + +ServiceWorkerInfo* +ServiceWorkerManager::GetActiveWorkerInfoForDocument(nsIDocument* aDocument) +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerRegistrationInfo> registration; + GetDocumentRegistration(aDocument, getter_AddRefs(registration)); + + if (!registration) { + return nullptr; + } + + return registration->GetActive(); +} + +namespace { + +class UnregisterJobCallback final : public ServiceWorkerJob::Callback +{ + nsCOMPtr<nsIServiceWorkerUnregisterCallback> mCallback; + + ~UnregisterJobCallback() + { + } + +public: + explicit UnregisterJobCallback(nsIServiceWorkerUnregisterCallback* aCallback) + : mCallback(aCallback) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCallback); + } + + void + JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + + if (aStatus.Failed()) { + mCallback->UnregisterFailed(); + return; + } + + MOZ_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Unregister); + RefPtr<ServiceWorkerUnregisterJob> unregisterJob = + static_cast<ServiceWorkerUnregisterJob*>(aJob); + mCallback->UnregisterSucceeded(unregisterJob->GetResult()); + } + + NS_INLINE_DECL_REFCOUNTING(UnregisterJobCallback) +}; + +} // anonymous namespace + +NS_IMETHODIMP +ServiceWorkerManager::Unregister(nsIPrincipal* aPrincipal, + nsIServiceWorkerUnregisterCallback* aCallback, + const nsAString& aScope) +{ + AssertIsOnMainThread(); + + if (!aPrincipal) { + return NS_ERROR_FAILURE; + } + + nsresult rv; + +// This is not accessible by content, and callers should always ensure scope is +// a correct URI, so this is wrapped in DEBUG +#ifdef DEBUG + nsCOMPtr<nsIURI> scopeURI; + rv = NS_NewURI(getter_AddRefs(scopeURI), aScope, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_SECURITY_ERR; + } +#endif + + nsAutoCString scopeKey; + rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + NS_ConvertUTF16toUTF8 scope(aScope); + RefPtr<ServiceWorkerJobQueue> queue = GetOrCreateJobQueue(scopeKey, scope); + + RefPtr<ServiceWorkerUnregisterJob> job = + new ServiceWorkerUnregisterJob(aPrincipal, scope, true /* send to parent */); + + if (aCallback) { + RefPtr<UnregisterJobCallback> cb = new UnregisterJobCallback(aCallback); + job->AppendResultCallback(cb); + } + + queue->ScheduleJob(job); + return NS_OK; +} + +nsresult +ServiceWorkerManager::NotifyUnregister(nsIPrincipal* aPrincipal, + const nsAString& aScope) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + nsresult rv; + +// This is not accessible by content, and callers should always ensure scope is +// a correct URI, so this is wrapped in DEBUG +#ifdef DEBUG + nsCOMPtr<nsIURI> scopeURI; + rv = NS_NewURI(getter_AddRefs(scopeURI), aScope, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } +#endif + + nsAutoCString scopeKey; + rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + NS_ConvertUTF16toUTF8 scope(aScope); + RefPtr<ServiceWorkerJobQueue> queue = GetOrCreateJobQueue(scopeKey, scope); + + RefPtr<ServiceWorkerUnregisterJob> job = + new ServiceWorkerUnregisterJob(aPrincipal, scope, + false /* send to parent */); + + queue->ScheduleJob(job); + return NS_OK; +} + +void +ServiceWorkerManager::WorkerIsIdle(ServiceWorkerInfo* aWorker) +{ + AssertIsOnMainThread(); + MOZ_DIAGNOSTIC_ASSERT(aWorker); + + RefPtr<ServiceWorkerRegistrationInfo> reg = + GetRegistration(aWorker->GetPrincipal(), aWorker->Scope()); + if (!reg) { + return; + } + + if (reg->GetActive() != aWorker) { + return; + } + + if (!reg->IsControllingDocuments() && reg->mPendingUninstall) { + RemoveRegistration(reg); + return; + } + + reg->TryToActivateAsync(); +} + +already_AddRefed<ServiceWorkerJobQueue> +ServiceWorkerManager::GetOrCreateJobQueue(const nsACString& aKey, + const nsACString& aScope) +{ + MOZ_ASSERT(!aKey.IsEmpty()); + ServiceWorkerManager::RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(aKey, &data)) { + data = new RegistrationDataPerPrincipal(); + mRegistrationInfos.Put(aKey, data); + } + + RefPtr<ServiceWorkerJobQueue> queue; + if (!data->mJobQueues.Get(aScope, getter_AddRefs(queue))) { + RefPtr<ServiceWorkerJobQueue> newQueue = new ServiceWorkerJobQueue(); + queue = newQueue; + data->mJobQueues.Put(aScope, newQueue.forget()); + } + + return queue.forget(); +} + +/* static */ +already_AddRefed<ServiceWorkerManager> +ServiceWorkerManager::GetInstance() +{ + // Note: We don't simply check gInstance for null-ness here, since otherwise + // this can resurrect the ServiceWorkerManager pretty late during shutdown. + static bool firstTime = true; + if (firstTime) { + RefPtr<ServiceWorkerRegistrar> swr; + + // Don't create the ServiceWorkerManager until the ServiceWorkerRegistrar is + // initialized. + if (XRE_IsParentProcess()) { + swr = ServiceWorkerRegistrar::Get(); + if (!swr) { + return nullptr; + } + } + + firstTime = false; + + AssertIsOnMainThread(); + + gInstance = new ServiceWorkerManager(); + gInstance->Init(swr); + ClearOnShutdown(&gInstance); + } + RefPtr<ServiceWorkerManager> copy = gInstance.get(); + return copy.forget(); +} + +void +ServiceWorkerManager::FinishFetch(ServiceWorkerRegistrationInfo* aRegistration) +{ +} + +void +ServiceWorkerManager::ReportToAllClients(const nsCString& aScope, + const nsString& aMessage, + const nsString& aFilename, + const nsString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags) +{ + nsCOMPtr<nsIURI> uri; + nsresult rv; + + if (!aFilename.IsEmpty()) { + rv = NS_NewURI(getter_AddRefs(uri), aFilename); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } + + AutoTArray<uint64_t, 16> windows; + + // Report errors to every controlled document. + for (auto iter = mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + ServiceWorkerRegistrationInfo* reg = iter.UserData(); + MOZ_ASSERT(reg); + if (!reg->mScope.Equals(aScope)) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(iter.Key()); + if (!doc || !doc->IsCurrentActiveDocument() || !doc->GetWindow()) { + continue; + } + + windows.AppendElement(doc->InnerWindowID()); + + nsContentUtils::ReportToConsoleNonLocalized(aMessage, + aFlags, + NS_LITERAL_CSTRING("Service Workers"), + doc, + uri, + aLine, + aLineNumber, + aColumnNumber, + nsContentUtils::eOMIT_LOCATION); + } + + // Report to any documents that have called .register() for this scope. They + // may not be controlled, but will still want to see error reports. + WeakDocumentList* regList = mRegisteringDocuments.Get(aScope); + if (regList) { + for (int32_t i = regList->Length() - 1; i >= 0; --i) { + nsCOMPtr<nsIDocument> doc = do_QueryReferent(regList->ElementAt(i)); + if (!doc) { + regList->RemoveElementAt(i); + continue; + } + + if (!doc->IsCurrentActiveDocument()) { + continue; + } + + uint64_t innerWindowId = doc->InnerWindowID(); + if (windows.Contains(innerWindowId)) { + continue; + } + + windows.AppendElement(innerWindowId); + + nsContentUtils::ReportToConsoleNonLocalized(aMessage, + aFlags, + NS_LITERAL_CSTRING("Service Workers"), + doc, + uri, + aLine, + aLineNumber, + aColumnNumber, + nsContentUtils::eOMIT_LOCATION); + } + + if (regList->IsEmpty()) { + regList = nullptr; + nsAutoPtr<WeakDocumentList> doomed; + mRegisteringDocuments.RemoveAndForget(aScope, doomed); + } + } + + InterceptionList* intList = mNavigationInterceptions.Get(aScope); + if (intList) { + nsIConsoleService* consoleService = nullptr; + for (uint32_t i = 0; i < intList->Length(); ++i) { + nsCOMPtr<nsIInterceptedChannel> channel = intList->ElementAt(i); + + nsCOMPtr<nsIChannel> inner; + rv = channel->GetChannel(getter_AddRefs(inner)); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + uint64_t innerWindowId = nsContentUtils::GetInnerWindowID(inner); + if (innerWindowId == 0 || windows.Contains(innerWindowId)) { + continue; + } + + windows.AppendElement(innerWindowId); + + // Unfortunately the nsContentUtils helpers don't provide a convenient + // way to log to a window ID without a document. Use console service + // directly. + nsCOMPtr<nsIScriptError> errorObject = + do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + rv = errorObject->InitWithWindowID(aMessage, + aFilename, + aLine, + aLineNumber, + aColumnNumber, + aFlags, + NS_LITERAL_CSTRING("Service Workers"), + innerWindowId); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + if (!consoleService) { + rv = CallGetService(NS_CONSOLESERVICE_CONTRACTID, &consoleService); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } + + consoleService->LogMessage(errorObject); + } + } + + // If there are no documents to report to, at least report something to the + // browser console. + if (windows.IsEmpty()) { + nsContentUtils::ReportToConsoleNonLocalized(aMessage, + aFlags, + NS_LITERAL_CSTRING("Service Workers"), + nullptr, // document + uri, + aLine, + aLineNumber, + aColumnNumber, + nsContentUtils::eOMIT_LOCATION); + return; + } +} + +/* static */ +void +ServiceWorkerManager::LocalizeAndReportToAllClients( + const nsCString& aScope, + const char* aStringKey, + const nsTArray<nsString>& aParamArray, + uint32_t aFlags, + const nsString& aFilename, + const nsString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber) +{ + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + return; + } + + nsresult rv; + nsXPIDLString message; + rv = nsContentUtils::FormatLocalizedString(nsContentUtils::eDOM_PROPERTIES, + aStringKey, aParamArray, message); + if (NS_SUCCEEDED(rv)) { + swm->ReportToAllClients(aScope, message, + aFilename, aLine, aLineNumber, aColumnNumber, + aFlags); + } else { + NS_WARNING("Failed to format and therefore report localized error."); + } +} + +void +ServiceWorkerManager::FlushReportsToAllClients(const nsACString& aScope, + nsIConsoleReportCollector* aReporter) +{ + AutoTArray<uint64_t, 16> windows; + + // Report errors to every controlled document. + for (auto iter = mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + ServiceWorkerRegistrationInfo* reg = iter.UserData(); + MOZ_ASSERT(reg); + if (!reg->mScope.Equals(aScope)) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(iter.Key()); + if (!doc || !doc->IsCurrentActiveDocument() || !doc->GetWindow()) { + continue; + } + + windows.AppendElement(doc->InnerWindowID()); + + aReporter->FlushConsoleReports(doc, + nsIConsoleReportCollector::ReportAction::Save); + } + + // Report to any documents that have called .register() for this scope. They + // may not be controlled, but will still want to see error reports. + WeakDocumentList* regList = mRegisteringDocuments.Get(aScope); + if (regList) { + for (int32_t i = regList->Length() - 1; i >= 0; --i) { + nsCOMPtr<nsIDocument> doc = do_QueryReferent(regList->ElementAt(i)); + if (!doc) { + regList->RemoveElementAt(i); + continue; + } + + if (!doc->IsCurrentActiveDocument()) { + continue; + } + + uint64_t innerWindowId = doc->InnerWindowID(); + if (windows.Contains(innerWindowId)) { + continue; + } + + windows.AppendElement(innerWindowId); + + aReporter->FlushConsoleReports(doc, + nsIConsoleReportCollector::ReportAction::Save); + } + + if (regList->IsEmpty()) { + regList = nullptr; + nsAutoPtr<WeakDocumentList> doomed; + mRegisteringDocuments.RemoveAndForget(aScope, doomed); + } + } + + nsresult rv; + InterceptionList* intList = mNavigationInterceptions.Get(aScope); + if (intList) { + for (uint32_t i = 0; i < intList->Length(); ++i) { + nsCOMPtr<nsIInterceptedChannel> channel = intList->ElementAt(i); + + nsCOMPtr<nsIChannel> inner; + rv = channel->GetChannel(getter_AddRefs(inner)); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + uint64_t innerWindowId = nsContentUtils::GetInnerWindowID(inner); + if (innerWindowId == 0 || windows.Contains(innerWindowId)) { + continue; + } + + windows.AppendElement(innerWindowId); + + aReporter->FlushReportsByWindowId(innerWindowId, + nsIConsoleReportCollector::ReportAction::Save); + } + } + + // If there are no documents to report to, at least report something to the + // browser console. + if (windows.IsEmpty()) { + aReporter->FlushConsoleReports((nsIDocument*)nullptr); + return; + } + + aReporter->ClearConsoleReports(); +} + +void +ServiceWorkerManager::HandleError(JSContext* aCx, + nsIPrincipal* aPrincipal, + const nsCString& aScope, + const nsString& aWorkerURL, + const nsString& aMessage, + const nsString& aFilename, + const nsString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags, + JSExnType aExnType) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + ServiceWorkerManager::RegistrationDataPerPrincipal* data; + if (NS_WARN_IF(!mRegistrationInfos.Get(scopeKey, &data))) { + return; + } + + // Always report any uncaught exceptions or errors to the console of + // each client. + ReportToAllClients(aScope, aMessage, aFilename, aLine, aLineNumber, + aColumnNumber, aFlags); +} + +void +ServiceWorkerManager::LoadRegistration( + const ServiceWorkerRegistrationData& aRegistration) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIPrincipal> principal = + PrincipalInfoToPrincipal(aRegistration.principal()); + if (!principal) { + return; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(principal, aRegistration.scope()); + if (!registration) { + registration = CreateNewRegistration(aRegistration.scope(), principal); + } else { + // If active worker script matches our expectations for a "current worker", + // then we are done. + if (registration->GetActive() && + registration->GetActive()->ScriptSpec() == aRegistration.currentWorkerURL()) { + // No needs for updates. + return; + } + } + + const nsCString& currentWorkerURL = aRegistration.currentWorkerURL(); + if (!currentWorkerURL.IsEmpty()) { + registration->SetActive( + new ServiceWorkerInfo(registration->mPrincipal, registration->mScope, + currentWorkerURL, aRegistration.cacheName())); + registration->GetActive()->SetActivateStateUncheckedWithoutEvent(ServiceWorkerState::Activated); + } +} + +void +ServiceWorkerManager::LoadRegistrations( + const nsTArray<ServiceWorkerRegistrationData>& aRegistrations) +{ + AssertIsOnMainThread(); + + for (uint32_t i = 0, len = aRegistrations.Length(); i < len; ++i) { + LoadRegistration(aRegistrations[i]); + } +} + +void +ServiceWorkerManager::ActorFailed() +{ + MOZ_DIAGNOSTIC_ASSERT(!mActor); + MaybeStartShutdown(); +} + +void +ServiceWorkerManager::ActorCreated(mozilla::ipc::PBackgroundChild* aActor) +{ + MOZ_ASSERT(aActor); + MOZ_ASSERT(!mActor); + + if (mShuttingDown) { + MOZ_DIAGNOSTIC_ASSERT(mPendingOperations.IsEmpty()); + return; + } + + PServiceWorkerManagerChild* actor = + aActor->SendPServiceWorkerManagerConstructor(); + if (!actor) { + ActorFailed(); + return; + } + + mActor = static_cast<ServiceWorkerManagerChild*>(actor); + + // Flush the pending requests. + for (uint32_t i = 0, len = mPendingOperations.Length(); i < len; ++i) { + MOZ_ASSERT(mPendingOperations[i]); + nsresult rv = NS_DispatchToCurrentThread(mPendingOperations[i].forget()); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch a runnable."); + } + } + + mPendingOperations.Clear(); +} + +void +ServiceWorkerManager::StoreRegistration( + nsIPrincipal* aPrincipal, + ServiceWorkerRegistrationInfo* aRegistration) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aRegistration); + + if (mShuttingDown) { + return; + } + + MOZ_DIAGNOSTIC_ASSERT(mActor); + if (!mActor) { + return; + } + + ServiceWorkerRegistrationData data; + nsresult rv = PopulateRegistrationData(aPrincipal, aRegistration, data); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + PrincipalInfo principalInfo; + if (NS_WARN_IF(NS_FAILED(PrincipalToPrincipalInfo(aPrincipal, + &principalInfo)))) { + return; + } + + mActor->SendRegister(data); +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetServiceWorkerRegistrationInfo(nsPIDOMWindowInner* aWindow) +{ + MOZ_ASSERT(aWindow); + nsCOMPtr<nsIDocument> document = aWindow->GetExtantDoc(); + return GetServiceWorkerRegistrationInfo(document); +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetServiceWorkerRegistrationInfo(nsIDocument* aDoc) +{ + MOZ_ASSERT(aDoc); + nsCOMPtr<nsIURI> documentURI = aDoc->GetDocumentURI(); + nsCOMPtr<nsIPrincipal> principal = aDoc->NodePrincipal(); + return GetServiceWorkerRegistrationInfo(principal, documentURI); +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetServiceWorkerRegistrationInfo(nsIPrincipal* aPrincipal, + nsIURI* aURI) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aURI); + + //XXXnsm Temporary fix until Bug 1171432 is fixed. + if (NS_WARN_IF(BasePrincipal::Cast(aPrincipal)->AppId() == nsIScriptSecurityManager::UNKNOWN_APP_ID)) { + return nullptr; + } + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_FAILED(rv)) { + return nullptr; + } + + return GetServiceWorkerRegistrationInfo(scopeKey, aURI); +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetServiceWorkerRegistrationInfo(const nsACString& aScopeKey, + nsIURI* aURI) +{ + MOZ_ASSERT(aURI); + + nsAutoCString spec; + nsresult rv = aURI->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + nsAutoCString scope; + RegistrationDataPerPrincipal* data; + if (!FindScopeForPath(aScopeKey, spec, &data, scope)) { + return nullptr; + } + + MOZ_ASSERT(data); + + RefPtr<ServiceWorkerRegistrationInfo> registration; + data->mInfos.Get(scope, getter_AddRefs(registration)); + // ordered scopes and registrations better be in sync. + MOZ_ASSERT(registration); + +#ifdef DEBUG + nsAutoCString origin; + rv = registration->mPrincipal->GetOrigin(origin); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(origin.Equals(aScopeKey)); +#endif + + if (registration->mPendingUninstall) { + return nullptr; + } + return registration.forget(); +} + +/* static */ nsresult +ServiceWorkerManager::PrincipalToScopeKey(nsIPrincipal* aPrincipal, + nsACString& aKey) +{ + MOZ_ASSERT(aPrincipal); + + if (!BasePrincipal::Cast(aPrincipal)->IsCodebasePrincipal()) { + return NS_ERROR_FAILURE; + } + + nsresult rv = aPrincipal->GetOrigin(aKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +/* static */ void +ServiceWorkerManager::AddScopeAndRegistration(const nsACString& aScope, + ServiceWorkerRegistrationInfo* aInfo) +{ + MOZ_ASSERT(aInfo); + MOZ_ASSERT(aInfo->mPrincipal); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return; + } + + nsAutoCString scopeKey; + nsresult rv = swm->PrincipalToScopeKey(aInfo->mPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + MOZ_ASSERT(!scopeKey.IsEmpty()); + + RegistrationDataPerPrincipal* data; + if (!swm->mRegistrationInfos.Get(scopeKey, &data)) { + data = new RegistrationDataPerPrincipal(); + swm->mRegistrationInfos.Put(scopeKey, data); + } + + for (uint32_t i = 0; i < data->mOrderedScopes.Length(); ++i) { + const nsCString& current = data->mOrderedScopes[i]; + + // Perfect match! + if (aScope.Equals(current)) { + data->mInfos.Put(aScope, aInfo); + swm->NotifyListenersOnRegister(aInfo); + return; + } + + // Sort by length, with longest match first. + // /foo/bar should be before /foo/ + // Similarly /foo/b is between the two. + if (StringBeginsWith(aScope, current)) { + data->mOrderedScopes.InsertElementAt(i, aScope); + data->mInfos.Put(aScope, aInfo); + swm->NotifyListenersOnRegister(aInfo); + return; + } + } + + data->mOrderedScopes.AppendElement(aScope); + data->mInfos.Put(aScope, aInfo); + swm->NotifyListenersOnRegister(aInfo); +} + +/* static */ bool +ServiceWorkerManager::FindScopeForPath(const nsACString& aScopeKey, + const nsACString& aPath, + RegistrationDataPerPrincipal** aData, + nsACString& aMatch) +{ + MOZ_ASSERT(aData); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + + if (!swm || !swm->mRegistrationInfos.Get(aScopeKey, aData)) { + return false; + } + + for (uint32_t i = 0; i < (*aData)->mOrderedScopes.Length(); ++i) { + const nsCString& current = (*aData)->mOrderedScopes[i]; + if (StringBeginsWith(aPath, current)) { + aMatch = current; + return true; + } + } + + return false; +} + +/* static */ bool +ServiceWorkerManager::HasScope(nsIPrincipal* aPrincipal, + const nsACString& aScope) +{ + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + return false; + } + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + RegistrationDataPerPrincipal* data; + if (!swm->mRegistrationInfos.Get(scopeKey, &data)) { + return false; + } + + return data->mOrderedScopes.Contains(aScope); +} + +/* static */ void +ServiceWorkerManager::RemoveScopeAndRegistration(ServiceWorkerRegistrationInfo* aRegistration) +{ + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + return; + } + + nsAutoCString scopeKey; + nsresult rv = swm->PrincipalToScopeKey(aRegistration->mPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RegistrationDataPerPrincipal* data; + if (!swm->mRegistrationInfos.Get(scopeKey, &data)) { + return; + } + + nsCOMPtr<nsITimer> timer = data->mUpdateTimers.Get(aRegistration->mScope); + if (timer) { + timer->Cancel(); + data->mUpdateTimers.Remove(aRegistration->mScope); + } + + // The registration should generally only be removed if there are no controlled + // documents, but mControlledDocuments can contain references to potentially + // controlled docs. This happens when the service worker is not active yet. + // We must purge these references since we are evicting the registration. + for (auto iter = swm->mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + ServiceWorkerRegistrationInfo* reg = iter.UserData(); + MOZ_ASSERT(reg); + if (reg->mScope.Equals(aRegistration->mScope)) { + iter.Remove(); + } + } + + RefPtr<ServiceWorkerRegistrationInfo> info; + data->mInfos.Get(aRegistration->mScope, getter_AddRefs(info)); + + data->mInfos.Remove(aRegistration->mScope); + data->mOrderedScopes.RemoveElement(aRegistration->mScope); + swm->NotifyListenersOnUnregister(info); + + swm->MaybeRemoveRegistrationInfo(scopeKey); + swm->NotifyServiceWorkerRegistrationRemoved(aRegistration); +} + +void +ServiceWorkerManager::MaybeRemoveRegistrationInfo(const nsACString& aScopeKey) +{ + RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(aScopeKey, &data)) { + return; + } + + if (data->mOrderedScopes.IsEmpty() && data->mJobQueues.Count() == 0) { + mRegistrationInfos.Remove(aScopeKey); + } +} + +void +ServiceWorkerManager::MaybeStartControlling(nsIDocument* aDoc, + const nsAString& aDocumentId) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aDoc); + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetServiceWorkerRegistrationInfo(aDoc); + if (registration) { + MOZ_ASSERT(!mControlledDocuments.Contains(aDoc)); + StartControllingADocument(registration, aDoc, aDocumentId); + } +} + +void +ServiceWorkerManager::MaybeStopControlling(nsIDocument* aDoc) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aDoc); + RefPtr<ServiceWorkerRegistrationInfo> registration; + mControlledDocuments.Remove(aDoc, getter_AddRefs(registration)); + // A document which was uncontrolled does not maintain that state itself, so + // it will always call MaybeStopControlling() even if there isn't an + // associated registration. So this check is required. + if (registration) { + StopControllingADocument(registration); + } +} + +void +ServiceWorkerManager::MaybeCheckNavigationUpdate(nsIDocument* aDoc) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aDoc); + // We perform these success path navigation update steps when the + // document tells us its more or less done loading. This avoids + // slowing down page load and also lets pages consistently get + // updatefound events when they fire. + // + // 9.8.20 If respondWithEntered is false, then: + // 9.8.22 Else: (respondWith was entered and succeeded) + // If request is a non-subresource request, then: Invoke Soft Update + // algorithm. + RefPtr<ServiceWorkerRegistrationInfo> registration; + mControlledDocuments.Get(aDoc, getter_AddRefs(registration)); + if (registration) { + registration->MaybeScheduleUpdate(); + } +} + +void +ServiceWorkerManager::StartControllingADocument(ServiceWorkerRegistrationInfo* aRegistration, + nsIDocument* aDoc, + const nsAString& aDocumentId) +{ + MOZ_ASSERT(aRegistration); + MOZ_ASSERT(aDoc); + + aRegistration->StartControllingADocument(); + mControlledDocuments.Put(aDoc, aRegistration); + if (!aDocumentId.IsEmpty()) { + aDoc->SetId(aDocumentId); + } + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_CONTROLLED_DOCUMENTS, 1); +} + +void +ServiceWorkerManager::StopControllingADocument(ServiceWorkerRegistrationInfo* aRegistration) +{ + aRegistration->StopControllingADocument(); + if (aRegistration->IsControllingDocuments() || !aRegistration->IsIdle()) { + return; + } + + if (aRegistration->mPendingUninstall) { + RemoveRegistration(aRegistration); + return; + } + + // We use to aggressively terminate the worker at this point, but it + // caused problems. There are more uses for a service worker than actively + // controlled documents. We need to let the worker naturally terminate + // in case its handling push events, message events, etc. + aRegistration->TryToActivateAsync(); +} + +NS_IMETHODIMP +ServiceWorkerManager::GetScopeForUrl(nsIPrincipal* aPrincipal, + const nsAString& aUrl, nsAString& aScope) +{ + MOZ_ASSERT(aPrincipal); + + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), aUrl, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerRegistrationInfo> r = + GetServiceWorkerRegistrationInfo(aPrincipal, uri); + if (!r) { + return NS_ERROR_FAILURE; + } + + aScope = NS_ConvertUTF8toUTF16(r->mScope); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::AddRegistrationEventListener(const nsAString& aScope, + ServiceWorkerRegistrationListener* aListener) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aListener); +#ifdef DEBUG + // Ensure a registration is only listening for it's own scope. + nsAutoString regScope; + aListener->GetScope(regScope); + MOZ_ASSERT(!regScope.IsEmpty()); + MOZ_ASSERT(aScope.Equals(regScope)); +#endif + + MOZ_ASSERT(!mServiceWorkerRegistrationListeners.Contains(aListener)); + mServiceWorkerRegistrationListeners.AppendElement(aListener); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::RemoveRegistrationEventListener(const nsAString& aScope, + ServiceWorkerRegistrationListener* aListener) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aListener); +#ifdef DEBUG + // Ensure a registration is unregistering for it's own scope. + nsAutoString regScope; + aListener->GetScope(regScope); + MOZ_ASSERT(!regScope.IsEmpty()); + MOZ_ASSERT(aScope.Equals(regScope)); +#endif + + MOZ_ASSERT(mServiceWorkerRegistrationListeners.Contains(aListener)); + mServiceWorkerRegistrationListeners.RemoveElement(aListener); + return NS_OK; +} + +void +ServiceWorkerManager::FireUpdateFoundOnServiceWorkerRegistrations( + ServiceWorkerRegistrationInfo* aRegistration) +{ + AssertIsOnMainThread(); + + nsTObserverArray<ServiceWorkerRegistrationListener*>::ForwardIterator it(mServiceWorkerRegistrationListeners); + while (it.HasMore()) { + RefPtr<ServiceWorkerRegistrationListener> target = it.GetNext(); + nsAutoString regScope; + target->GetScope(regScope); + MOZ_ASSERT(!regScope.IsEmpty()); + + NS_ConvertUTF16toUTF8 utf8Scope(regScope); + if (utf8Scope.Equals(aRegistration->mScope)) { + target->UpdateFound(); + } + } +} + +/* + * This is used for installing, waiting and active. + */ +nsresult +ServiceWorkerManager::GetServiceWorkerForScope(nsPIDOMWindowInner* aWindow, + const nsAString& aScope, + WhichServiceWorker aWhichWorker, + nsISupports** aServiceWorker) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc(); + MOZ_ASSERT(doc); + + /////////////////////////////////////////// + // Security check + nsAutoCString scope = NS_ConvertUTF16toUTF8(aScope); + nsCOMPtr<nsIURI> scopeURI; + // We pass nullptr as the base URI since scopes obtained from + // ServiceWorkerRegistrations MUST be fully qualified URIs. + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), scope, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsCOMPtr<nsIPrincipal> documentPrincipal = doc->NodePrincipal(); + rv = documentPrincipal->CheckMayLoad(scopeURI, true /* report */, + false /* allowIfInheritsPrinciple */); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + //////////////////////////////////////////// + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(documentPrincipal, scope); + if (NS_WARN_IF(!registration)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerInfo> info; + if (aWhichWorker == WhichServiceWorker::INSTALLING_WORKER) { + info = registration->GetInstalling(); + } else if (aWhichWorker == WhichServiceWorker::WAITING_WORKER) { + info = registration->GetWaiting(); + } else if (aWhichWorker == WhichServiceWorker::ACTIVE_WORKER) { + info = registration->GetActive(); + } else { + MOZ_CRASH("Invalid worker type"); + } + + if (NS_WARN_IF(!info)) { + return NS_ERROR_DOM_NOT_FOUND_ERR; + } + + RefPtr<ServiceWorker> serviceWorker = info->GetOrCreateInstance(aWindow); + + serviceWorker->SetState(info->State()); + serviceWorker.forget(aServiceWorker); + return NS_OK; +} + +namespace { + +class ContinueDispatchFetchEventRunnable : public Runnable +{ + RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate; + nsCOMPtr<nsIInterceptedChannel> mChannel; + nsCOMPtr<nsILoadGroup> mLoadGroup; + nsString mDocumentId; + bool mIsReload; +public: + ContinueDispatchFetchEventRunnable(ServiceWorkerPrivate* aServiceWorkerPrivate, + nsIInterceptedChannel* aChannel, + nsILoadGroup* aLoadGroup, + const nsAString& aDocumentId, + bool aIsReload) + : mServiceWorkerPrivate(aServiceWorkerPrivate) + , mChannel(aChannel) + , mLoadGroup(aLoadGroup) + , mDocumentId(aDocumentId) + , mIsReload(aIsReload) + { + MOZ_ASSERT(aServiceWorkerPrivate); + MOZ_ASSERT(aChannel); + } + + void + HandleError() + { + AssertIsOnMainThread(); + NS_WARNING("Unexpected error while dispatching fetch event!"); + DebugOnly<nsresult> rv = mChannel->ResetInterception(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "Failed to resume intercepted network request"); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + nsCOMPtr<nsIChannel> channel; + nsresult rv = mChannel->GetChannel(getter_AddRefs(channel)); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleError(); + return NS_OK; + } + + // The channel might have encountered an unexpected error while ensuring + // the upload stream is cloneable. Check here and reset the interception + // if that happens. + nsresult status; + rv = channel->GetStatus(&status); + if (NS_WARN_IF(NS_FAILED(rv) || NS_FAILED(status))) { + HandleError(); + return NS_OK; + } + + rv = mServiceWorkerPrivate->SendFetchEvent(mChannel, mLoadGroup, + mDocumentId, mIsReload); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleError(); + } + + return NS_OK; + } +}; + +} // anonymous namespace + +void +ServiceWorkerManager::DispatchFetchEvent(const PrincipalOriginAttributes& aOriginAttributes, + nsIDocument* aDoc, + const nsAString& aDocumentIdForTopLevelNavigation, + nsIInterceptedChannel* aChannel, + bool aIsReload, + bool aIsSubresourceLoad, + ErrorResult& aRv) +{ + MOZ_ASSERT(aChannel); + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerInfo> serviceWorker; + nsCOMPtr<nsILoadGroup> loadGroup; + nsAutoString documentId; + + if (aIsSubresourceLoad) { + MOZ_ASSERT(aDoc); + + serviceWorker = GetActiveWorkerInfoForDocument(aDoc); + if (!serviceWorker) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + loadGroup = aDoc->GetDocumentLoadGroup(); + nsresult rv = aDoc->GetOrCreateId(documentId); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } else { + nsCOMPtr<nsIChannel> internalChannel; + aRv = aChannel->GetChannel(getter_AddRefs(internalChannel)); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + internalChannel->GetLoadGroup(getter_AddRefs(loadGroup)); + + // TODO: Use aDocumentIdForTopLevelNavigation for potentialClientId, pending + // the spec change. + + nsCOMPtr<nsIURI> uri; + aRv = aChannel->GetSecureUpgradedChannelURI(getter_AddRefs(uri)); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + // non-subresource request means the URI contains the principal + nsCOMPtr<nsIPrincipal> principal = + BasePrincipal::CreateCodebasePrincipal(uri, aOriginAttributes); + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetServiceWorkerRegistrationInfo(principal, uri); + if (!registration) { + NS_WARNING("No registration found when dispatching the fetch event"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + // While we only enter this method if IsAvailable() previously saw + // an active worker, it is possible for that worker to be removed + // before we get to this point. Therefore we must handle a nullptr + // active worker here. + serviceWorker = registration->GetActive(); + if (!serviceWorker) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + AddNavigationInterception(serviceWorker->Scope(), aChannel); + } + + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + MOZ_DIAGNOSTIC_ASSERT(serviceWorker); + + nsCOMPtr<nsIRunnable> continueRunnable = + new ContinueDispatchFetchEventRunnable(serviceWorker->WorkerPrivate(), + aChannel, loadGroup, + documentId, aIsReload); + + nsCOMPtr<nsIChannel> innerChannel; + aRv = aChannel->GetChannel(getter_AddRefs(innerChannel)); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(innerChannel); + + // If there is no upload stream, then continue immediately + if (!uploadChannel) { + MOZ_ALWAYS_SUCCEEDS(continueRunnable->Run()); + return; + } + // Otherwise, ensure the upload stream can be cloned directly. This may + // require some async copying, so provide a callback. + aRv = uploadChannel->EnsureUploadStreamIsCloneable(continueRunnable); +} + +bool +ServiceWorkerManager::IsAvailable(nsIPrincipal* aPrincipal, + nsIURI* aURI) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aURI); + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetServiceWorkerRegistrationInfo(aPrincipal, aURI); + return registration && registration->GetActive(); +} + +bool +ServiceWorkerManager::IsControlled(nsIDocument* aDoc, ErrorResult& aRv) +{ + MOZ_ASSERT(aDoc); + + if (nsContentUtils::IsInPrivateBrowsing(aDoc)) { + // Handle the case where a service worker was previously registered in + // a non-private window (bug 1255621). + return false; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration; + nsresult rv = GetDocumentRegistration(aDoc, getter_AddRefs(registration)); + if (NS_WARN_IF(NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE)) { + // It's OK to ignore the case where we don't have a registration. + aRv.Throw(rv); + return false; + } + + return !!registration; +} + +nsresult +ServiceWorkerManager::GetDocumentRegistration(nsIDocument* aDoc, + ServiceWorkerRegistrationInfo** aRegistrationInfo) +{ + RefPtr<ServiceWorkerRegistrationInfo> registration; + if (!mControlledDocuments.Get(aDoc, getter_AddRefs(registration))) { + return NS_ERROR_NOT_AVAILABLE; + } + + // If the document is controlled, the current worker MUST be non-null. + if (!registration->GetActive()) { + return NS_ERROR_NOT_AVAILABLE; + } + + registration.forget(aRegistrationInfo); + return NS_OK; +} + +/* + * The .controller is for the registration associated with the document when + * the document was loaded. + */ +NS_IMETHODIMP +ServiceWorkerManager::GetDocumentController(nsPIDOMWindowInner* aWindow, + nsISupports** aServiceWorker) +{ + if (NS_WARN_IF(!aWindow)) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc(); + if (!doc) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration; + nsresult rv = GetDocumentRegistration(doc, getter_AddRefs(registration)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + MOZ_ASSERT(registration->GetActive()); + RefPtr<ServiceWorker> serviceWorker = + registration->GetActive()->GetOrCreateInstance(aWindow); + + serviceWorker.forget(aServiceWorker); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::GetInstalling(nsPIDOMWindowInner* aWindow, + const nsAString& aScope, + nsISupports** aServiceWorker) +{ + return GetServiceWorkerForScope(aWindow, aScope, + WhichServiceWorker::INSTALLING_WORKER, + aServiceWorker); +} + +NS_IMETHODIMP +ServiceWorkerManager::GetWaiting(nsPIDOMWindowInner* aWindow, + const nsAString& aScope, + nsISupports** aServiceWorker) +{ + return GetServiceWorkerForScope(aWindow, aScope, + WhichServiceWorker::WAITING_WORKER, + aServiceWorker); +} + +NS_IMETHODIMP +ServiceWorkerManager::GetActive(nsPIDOMWindowInner* aWindow, + const nsAString& aScope, + nsISupports** aServiceWorker) +{ + return GetServiceWorkerForScope(aWindow, aScope, + WhichServiceWorker::ACTIVE_WORKER, + aServiceWorker); +} + +void +ServiceWorkerManager::InvalidateServiceWorkerRegistrationWorker(ServiceWorkerRegistrationInfo* aRegistration, + WhichServiceWorker aWhichOnes) +{ + AssertIsOnMainThread(); + nsTObserverArray<ServiceWorkerRegistrationListener*>::ForwardIterator it(mServiceWorkerRegistrationListeners); + while (it.HasMore()) { + RefPtr<ServiceWorkerRegistrationListener> target = it.GetNext(); + nsAutoString regScope; + target->GetScope(regScope); + MOZ_ASSERT(!regScope.IsEmpty()); + + NS_ConvertUTF16toUTF8 utf8Scope(regScope); + + if (utf8Scope.Equals(aRegistration->mScope)) { + target->InvalidateWorkers(aWhichOnes); + } + } +} + +void +ServiceWorkerManager::NotifyServiceWorkerRegistrationRemoved(ServiceWorkerRegistrationInfo* aRegistration) +{ + AssertIsOnMainThread(); + nsTObserverArray<ServiceWorkerRegistrationListener*>::ForwardIterator it(mServiceWorkerRegistrationListeners); + while (it.HasMore()) { + RefPtr<ServiceWorkerRegistrationListener> target = it.GetNext(); + nsAutoString regScope; + target->GetScope(regScope); + MOZ_ASSERT(!regScope.IsEmpty()); + + NS_ConvertUTF16toUTF8 utf8Scope(regScope); + + if (utf8Scope.Equals(aRegistration->mScope)) { + target->RegistrationRemoved(); + } + } +} + +void +ServiceWorkerManager::SoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsACString& aScope) +{ + AssertIsOnMainThread(); + + if (mShuttingDown) { + return; + } + + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), aScope); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsCOMPtr<nsIPrincipal> principal = + BasePrincipal::CreateCodebasePrincipal(scopeURI, aOriginAttributes); + if (NS_WARN_IF(!principal)) { + return; + } + + nsAutoCString scopeKey; + rv = PrincipalToScopeKey(principal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(scopeKey, aScope); + if (NS_WARN_IF(!registration)) { + return; + } + + // "If registration's uninstalling flag is set, abort these steps." + if (registration->mPendingUninstall) { + return; + } + + // "If registration's installing worker is not null, abort these steps." + if (registration->GetInstalling()) { + return; + } + + // "Let newestWorker be the result of running Get Newest Worker algorithm + // passing registration as its argument. + // If newestWorker is null, abort these steps." + RefPtr<ServiceWorkerInfo> newest = registration->Newest(); + if (!newest) { + return; + } + + // "If the registration queue for registration is empty, invoke Update algorithm, + // or its equivalent, with client, registration as its argument." + // TODO(catalinb): We don't implement the force bypass cache flag. + // See: https://github.com/slightlyoff/ServiceWorker/issues/759 + RefPtr<ServiceWorkerJobQueue> queue = GetOrCreateJobQueue(scopeKey, + aScope); + + RefPtr<ServiceWorkerUpdateJob> job = + new ServiceWorkerUpdateJob(principal, registration->mScope, + newest->ScriptSpec(), nullptr); + queue->ScheduleJob(job); +} + +namespace { + +class UpdateJobCallback final : public ServiceWorkerJob::Callback +{ + RefPtr<ServiceWorkerUpdateFinishCallback> mCallback; + + ~UpdateJobCallback() + { + } + +public: + explicit UpdateJobCallback(ServiceWorkerUpdateFinishCallback* aCallback) + : mCallback(aCallback) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCallback); + } + + void + JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aJob); + + if (aStatus.Failed()) { + mCallback->UpdateFailed(aStatus); + return; + } + + MOZ_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Update); + RefPtr<ServiceWorkerUpdateJob> updateJob = + static_cast<ServiceWorkerUpdateJob*>(aJob); + RefPtr<ServiceWorkerRegistrationInfo> reg = updateJob->GetRegistration(); + mCallback->UpdateSucceeded(reg); + } + + NS_INLINE_DECL_REFCOUNTING(UpdateJobCallback) +}; +} // anonymous namespace + +void +ServiceWorkerManager::Update(nsIPrincipal* aPrincipal, + const nsACString& aScope, + ServiceWorkerUpdateFinishCallback* aCallback) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aCallback); + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(scopeKey, aScope); + if (NS_WARN_IF(!registration)) { + return; + } + + // "Let newestWorker be the result of running Get Newest Worker algorithm + // passing registration as its argument. + // If newestWorker is null, return a promise rejected with "InvalidStateError" + RefPtr<ServiceWorkerInfo> newest = registration->Newest(); + if (!newest) { + ErrorResult error(NS_ERROR_DOM_INVALID_STATE_ERR); + aCallback->UpdateFailed(error); + + // In case the callback does not consume the exception + error.SuppressException(); + + return; + } + + RefPtr<ServiceWorkerJobQueue> queue = GetOrCreateJobQueue(scopeKey, aScope); + + // "Invoke Update algorithm, or its equivalent, with client, registration as + // its argument." + RefPtr<ServiceWorkerUpdateJob> job = + new ServiceWorkerUpdateJob(aPrincipal, registration->mScope, + newest->ScriptSpec(), nullptr); + + RefPtr<UpdateJobCallback> cb = new UpdateJobCallback(aCallback); + job->AppendResultCallback(cb); + + queue->ScheduleJob(job); +} + +namespace { + +static void +FireControllerChangeOnDocument(nsIDocument* aDocument) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aDocument); + + nsCOMPtr<nsPIDOMWindowInner> w = aDocument->GetInnerWindow(); + if (!w) { + NS_WARNING("Failed to dispatch controllerchange event"); + return; + } + + auto* window = nsGlobalWindow::Cast(w.get()); + ErrorResult result; + dom::Navigator* navigator = window->GetNavigator(result); + if (NS_WARN_IF(result.Failed())) { + result.SuppressException(); + return; + } + + RefPtr<ServiceWorkerContainer> container = navigator->ServiceWorker(); + container->ControllerChanged(result); + if (result.Failed()) { + NS_WARNING("Failed to dispatch controllerchange event"); + } +} + +} // anonymous namespace + +UniquePtr<ServiceWorkerClientInfo> +ServiceWorkerManager::GetClient(nsIPrincipal* aPrincipal, + const nsAString& aClientId, + ErrorResult& aRv) +{ + UniquePtr<ServiceWorkerClientInfo> clientInfo; + nsCOMPtr<nsISupportsInterfacePointer> ifptr = + do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID); + if (NS_WARN_IF(!ifptr)) { + return clientInfo; + } + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return clientInfo; + } + + nsresult rv = obs->NotifyObservers(ifptr, "service-worker-get-client", + PromiseFlatString(aClientId).get()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return clientInfo; + } + + nsCOMPtr<nsISupports> ptr; + ifptr->GetData(getter_AddRefs(ptr)); + nsCOMPtr<nsIDocument> doc = do_QueryInterface(ptr); + if (NS_WARN_IF(!doc)) { + return clientInfo; + } + + bool equals = false; + aPrincipal->Equals(doc->NodePrincipal(), &equals); + if (!equals) { + return clientInfo; + } + + if (!IsFromAuthenticatedOrigin(doc)) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return clientInfo; + } + + clientInfo.reset(new ServiceWorkerClientInfo(doc)); + return clientInfo; +} + +void +ServiceWorkerManager::GetAllClients(nsIPrincipal* aPrincipal, + const nsCString& aScope, + bool aIncludeUncontrolled, + nsTArray<ServiceWorkerClientInfo>& aDocuments) +{ + MOZ_ASSERT(aPrincipal); + + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(aPrincipal, aScope); + + if (!registration) { + // The registration was removed, leave the array empty. + return; + } + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return; + } + + nsCOMPtr<nsISimpleEnumerator> enumerator; + nsresult rv = obs->EnumerateObservers("service-worker-get-client", + getter_AddRefs(enumerator)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + auto ProcessDocument = [&aDocuments](nsIPrincipal* aPrincipal, nsIDocument* aDoc) { + if (!aDoc || !aDoc->GetWindow()) { + return; + } + + bool equals = false; + aPrincipal->Equals(aDoc->NodePrincipal(), &equals); + if (!equals) { + return; + } + + // Treat http windows with devtools opened as secure if the correct devtools + // setting is enabled. + if (!aDoc->GetWindow()->GetServiceWorkersTestingEnabled() && + !Preferences::GetBool("dom.serviceWorkers.testing.enabled") && + !IsFromAuthenticatedOrigin(aDoc)) { + return; + } + + ServiceWorkerClientInfo clientInfo(aDoc); + aDocuments.AppendElement(aDoc); + }; + + // Since it's not simple to check whether a document is in + // mControlledDocuments, we take different code paths depending on whether we + // need to look at all documents. The common parts of the two loops are + // factored out into the ProcessDocument lambda. + if (aIncludeUncontrolled) { + bool loop = true; + while (NS_SUCCEEDED(enumerator->HasMoreElements(&loop)) && loop) { + nsCOMPtr<nsISupports> ptr; + rv = enumerator->GetNext(getter_AddRefs(ptr)); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(ptr); + ProcessDocument(aPrincipal, doc); + } + } else { + for (auto iter = mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + ServiceWorkerRegistrationInfo* thisRegistration = iter.UserData(); + MOZ_ASSERT(thisRegistration); + if (!registration->mScope.Equals(thisRegistration->mScope)) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(iter.Key()); + + // All controlled documents must have an outer window. + MOZ_ASSERT(doc->GetWindow()); + + ProcessDocument(aPrincipal, doc); + } + } +} + +void +ServiceWorkerManager::MaybeClaimClient(nsIDocument* aDocument, + ServiceWorkerRegistrationInfo* aWorkerRegistration) +{ + MOZ_ASSERT(aWorkerRegistration); + MOZ_ASSERT(aWorkerRegistration->GetActive()); + + // Same origin check + if (!aWorkerRegistration->mPrincipal->Equals(aDocument->NodePrincipal())) { + return; + } + + // The registration that should be controlling the client + RefPtr<ServiceWorkerRegistrationInfo> matchingRegistration = + GetServiceWorkerRegistrationInfo(aDocument); + + // The registration currently controlling the client + RefPtr<ServiceWorkerRegistrationInfo> controllingRegistration; + GetDocumentRegistration(aDocument, getter_AddRefs(controllingRegistration)); + + if (aWorkerRegistration != matchingRegistration || + aWorkerRegistration == controllingRegistration) { + return; + } + + if (controllingRegistration) { + StopControllingADocument(controllingRegistration); + } + + StartControllingADocument(aWorkerRegistration, aDocument, NS_LITERAL_STRING("")); + FireControllerChangeOnDocument(aDocument); +} + +nsresult +ServiceWorkerManager::ClaimClients(nsIPrincipal* aPrincipal, + const nsCString& aScope, uint64_t aId) +{ + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(aPrincipal, aScope); + + if (!registration || !registration->GetActive() || + !(registration->GetActive()->ID() == aId)) { + // The worker is not active. + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsISimpleEnumerator> enumerator; + nsresult rv = obs->EnumerateObservers("service-worker-get-client", + getter_AddRefs(enumerator)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + bool loop = true; + while (NS_SUCCEEDED(enumerator->HasMoreElements(&loop)) && loop) { + nsCOMPtr<nsISupports> ptr; + rv = enumerator->GetNext(getter_AddRefs(ptr)); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(ptr); + MaybeClaimClient(doc, registration); + } + + return NS_OK; +} + +void +ServiceWorkerManager::SetSkipWaitingFlag(nsIPrincipal* aPrincipal, + const nsCString& aScope, + uint64_t aServiceWorkerID) +{ + RefPtr<ServiceWorkerRegistrationInfo> registration = + GetRegistration(aPrincipal, aScope); + if (NS_WARN_IF(!registration)) { + return; + } + + RefPtr<ServiceWorkerInfo> worker = + registration->GetServiceWorkerInfoById(aServiceWorkerID); + + if (NS_WARN_IF(!worker)) { + return; + } + + worker->SetSkipWaitingFlag(); + + if (worker->State() == ServiceWorkerState::Installed) { + registration->TryToActivateAsync(); + } +} + +void +ServiceWorkerManager::FireControllerChange(ServiceWorkerRegistrationInfo* aRegistration) +{ + AssertIsOnMainThread(); + for (auto iter = mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + if (iter.UserData() != aRegistration) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(iter.Key()); + if (NS_WARN_IF(!doc)) { + continue; + } + + FireControllerChangeOnDocument(doc); + } +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetRegistration(nsIPrincipal* aPrincipal, + const nsACString& aScope) const +{ + MOZ_ASSERT(aPrincipal); + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + return GetRegistration(scopeKey, aScope); +} + +NS_IMETHODIMP +ServiceWorkerManager::GetRegistrationByPrincipal(nsIPrincipal* aPrincipal, + const nsAString& aScope, + nsIServiceWorkerRegistrationInfo** aInfo) +{ + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aInfo); + + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), aScope, nullptr, nullptr); + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerRegistrationInfo> info = + GetServiceWorkerRegistrationInfo(aPrincipal, scopeURI); + if (!info) { + return NS_ERROR_FAILURE; + } + info.forget(aInfo); + + return NS_OK; +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::GetRegistration(const nsACString& aScopeKey, + const nsACString& aScope) const +{ + RefPtr<ServiceWorkerRegistrationInfo> reg; + + RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(aScopeKey, &data)) { + return reg.forget(); + } + + data->mInfos.Get(aScope, getter_AddRefs(reg)); + return reg.forget(); +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerManager::CreateNewRegistration(const nsCString& aScope, + nsIPrincipal* aPrincipal) +{ +#ifdef DEBUG + AssertIsOnMainThread(); + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), aScope, nullptr, nullptr); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + + RefPtr<ServiceWorkerRegistrationInfo> tmp = + GetRegistration(aPrincipal, aScope); + MOZ_ASSERT(!tmp); +#endif + + RefPtr<ServiceWorkerRegistrationInfo> registration = + new ServiceWorkerRegistrationInfo(aScope, aPrincipal); + // From now on ownership of registration is with + // mServiceWorkerRegistrationInfos. + AddScopeAndRegistration(aScope, registration); + return registration.forget(); +} + +void +ServiceWorkerManager::MaybeRemoveRegistration(ServiceWorkerRegistrationInfo* aRegistration) +{ + MOZ_ASSERT(aRegistration); + RefPtr<ServiceWorkerInfo> newest = aRegistration->Newest(); + if (!newest && HasScope(aRegistration->mPrincipal, aRegistration->mScope)) { + RemoveRegistration(aRegistration); + } +} + +void +ServiceWorkerManager::RemoveRegistration(ServiceWorkerRegistrationInfo* aRegistration) +{ + // Note, we do not need to call mActor->SendUnregister() here. There are a few + // ways we can get here: + // 1) Through a normal unregister which calls SendUnregister() in the unregister + // job Start() method. + // 2) Through origin storage being purged. These result in ForceUnregister() + // starting unregister jobs which in turn call SendUnregister(). + // 3) Through the failure to install a new service worker. Since we don't store + // the registration until install succeeds, we do not need to call + // SendUnregister here. + // Assert these conditions by testing for pending uninstall (cases 1 and 2) or + // null workers (case 3). +#ifdef DEBUG + RefPtr<ServiceWorkerInfo> newest = aRegistration->Newest(); + MOZ_ASSERT(aRegistration->mPendingUninstall || !newest); +#endif + + MOZ_ASSERT(HasScope(aRegistration->mPrincipal, aRegistration->mScope)); + + // When a registration is removed, we must clear its contents since the DOM + // object may be held by content script. + aRegistration->Clear(); + + RemoveScopeAndRegistration(aRegistration); +} + +namespace { +/** + * See toolkit/modules/sessionstore/Utils.jsm function hasRootDomain(). + * + * Returns true if the |url| passed in is part of the given root |domain|. + * For example, if |url| is "www.mozilla.org", and we pass in |domain| as + * "mozilla.org", this will return true. It would return false the other way + * around. + */ +bool +HasRootDomain(nsIURI* aURI, const nsACString& aDomain) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aURI); + + nsAutoCString host; + nsresult rv = aURI->GetHost(host); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + nsACString::const_iterator start, end; + host.BeginReading(start); + host.EndReading(end); + if (!FindInReadable(aDomain, start, end)) { + return false; + } + + if (host.Equals(aDomain)) { + return true; + } + + // Beginning of the string matches, can't look at the previous char. + if (start.get() == host.BeginReading()) { + // Equals failed so this is fine. + return false; + } + + char prevChar = *(--start); + return prevChar == '.'; +} + +} // namespace + +NS_IMETHODIMP +ServiceWorkerManager::GetAllRegistrations(nsIArray** aResult) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIMutableArray> array(do_CreateInstance(NS_ARRAY_CONTRACTID)); + if (!array) { + return NS_ERROR_OUT_OF_MEMORY; + } + + for (auto it1 = mRegistrationInfos.Iter(); !it1.Done(); it1.Next()) { + for (auto it2 = it1.UserData()->mInfos.Iter(); !it2.Done(); it2.Next()) { + ServiceWorkerRegistrationInfo* reg = it2.UserData(); + MOZ_ASSERT(reg); + + if (reg->mPendingUninstall) { + continue; + } + + array->AppendElement(reg, false); + } + } + + array.forget(aResult); + return NS_OK; +} + +// MUST ONLY BE CALLED FROM Remove(), RemoveAll() and RemoveAllRegistrations()! +void +ServiceWorkerManager::ForceUnregister(RegistrationDataPerPrincipal* aRegistrationData, + ServiceWorkerRegistrationInfo* aRegistration) +{ + MOZ_ASSERT(aRegistrationData); + MOZ_ASSERT(aRegistration); + + RefPtr<ServiceWorkerJobQueue> queue; + aRegistrationData->mJobQueues.Get(aRegistration->mScope, getter_AddRefs(queue)); + if (queue) { + queue->CancelAll(); + } + + nsCOMPtr<nsITimer> timer = + aRegistrationData->mUpdateTimers.Get(aRegistration->mScope); + if (timer) { + timer->Cancel(); + aRegistrationData->mUpdateTimers.Remove(aRegistration->mScope); + } + + // Since Unregister is async, it is ok to call it in an enumeration. + Unregister(aRegistration->mPrincipal, nullptr, NS_ConvertUTF8toUTF16(aRegistration->mScope)); +} + +NS_IMETHODIMP +ServiceWorkerManager::RemoveAndPropagate(const nsACString& aHost) +{ + Remove(aHost); + PropagateRemove(aHost); + return NS_OK; +} + +void +ServiceWorkerManager::Remove(const nsACString& aHost) +{ + AssertIsOnMainThread(); + + // We need to postpone this operation in case we don't have an actor because + // this is needed by the ForceUnregister. + if (!mActor) { + RefPtr<nsIRunnable> runnable = new RemoveRunnable(aHost); + AppendPendingOperation(runnable); + return; + } + + for (auto it1 = mRegistrationInfos.Iter(); !it1.Done(); it1.Next()) { + ServiceWorkerManager::RegistrationDataPerPrincipal* data = it1.UserData(); + for (auto it2 = data->mInfos.Iter(); !it2.Done(); it2.Next()) { + ServiceWorkerRegistrationInfo* reg = it2.UserData(); + nsCOMPtr<nsIURI> scopeURI; + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), it2.Key(), + nullptr, nullptr); + // This way subdomains are also cleared. + if (NS_SUCCEEDED(rv) && HasRootDomain(scopeURI, aHost)) { + ForceUnregister(data, reg); + } + } + } +} + +void +ServiceWorkerManager::PropagateRemove(const nsACString& aHost) +{ + AssertIsOnMainThread(); + + if (!mActor) { + RefPtr<nsIRunnable> runnable = new PropagateRemoveRunnable(aHost); + AppendPendingOperation(runnable); + return; + } + + mActor->SendPropagateRemove(nsCString(aHost)); +} + +void +ServiceWorkerManager::RemoveAll() +{ + AssertIsOnMainThread(); + + for (auto it1 = mRegistrationInfos.Iter(); !it1.Done(); it1.Next()) { + ServiceWorkerManager::RegistrationDataPerPrincipal* data = it1.UserData(); + for (auto it2 = data->mInfos.Iter(); !it2.Done(); it2.Next()) { + ServiceWorkerRegistrationInfo* reg = it2.UserData(); + ForceUnregister(data, reg); + } + } +} + +void +ServiceWorkerManager::PropagateRemoveAll() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(XRE_IsParentProcess()); + + if (!mActor) { + RefPtr<nsIRunnable> runnable = new PropagateRemoveAllRunnable(); + AppendPendingOperation(runnable); + return; + } + + mActor->SendPropagateRemoveAll(); +} + +void +ServiceWorkerManager::RemoveAllRegistrations(OriginAttributesPattern* aPattern) +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(aPattern); + + for (auto it1 = mRegistrationInfos.Iter(); !it1.Done(); it1.Next()) { + ServiceWorkerManager::RegistrationDataPerPrincipal* data = it1.UserData(); + + // We can use iteration because ForceUnregister (and Unregister) are + // async. Otherwise doing some R/W operations on an hashtable during + // iteration will crash. + for (auto it2 = data->mInfos.Iter(); !it2.Done(); it2.Next()) { + ServiceWorkerRegistrationInfo* reg = it2.UserData(); + + MOZ_ASSERT(reg); + MOZ_ASSERT(reg->mPrincipal); + + bool matches = + aPattern->Matches(BasePrincipal::Cast(reg->mPrincipal)->OriginAttributesRef()); + if (!matches) { + continue; + } + + ForceUnregister(data, reg); + } + } +} + +NS_IMETHODIMP +ServiceWorkerManager::AddListener(nsIServiceWorkerManagerListener* aListener) +{ + AssertIsOnMainThread(); + + if (!aListener || mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.AppendElement(aListener); + + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::RemoveListener(nsIServiceWorkerManagerListener* aListener) +{ + AssertIsOnMainThread(); + + if (!aListener || !mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.RemoveElement(aListener); + + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::ShouldReportToWindow(mozIDOMWindowProxy* aWindow, + const nsACString& aScope, + bool* aResult) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aResult); + + *aResult = false; + + // Get the inner window ID to compare to our document windows below. + nsCOMPtr<nsPIDOMWindowOuter> targetWin = nsPIDOMWindowOuter::From(aWindow); + if (NS_WARN_IF(!targetWin)) { + return NS_OK; + } + + targetWin = targetWin->GetScriptableTop(); + uint64_t winId = targetWin->WindowID(); + + // Check our weak registering document references first. This way we clear + // out as many dead weak references as possible when this method is called. + WeakDocumentList* list = mRegisteringDocuments.Get(aScope); + if (list) { + for (int32_t i = list->Length() - 1; i >= 0; --i) { + nsCOMPtr<nsIDocument> doc = do_QueryReferent(list->ElementAt(i)); + if (!doc) { + list->RemoveElementAt(i); + continue; + } + + if (!doc->IsCurrentActiveDocument()) { + continue; + } + + nsCOMPtr<nsPIDOMWindowOuter> win = doc->GetWindow(); + if (!win) { + continue; + } + + win = win->GetScriptableTop(); + + // Match. We should report to this window. + if (win && winId == win->WindowID()) { + *aResult = true; + return NS_OK; + } + } + + if (list->IsEmpty()) { + list = nullptr; + nsAutoPtr<WeakDocumentList> doomed; + mRegisteringDocuments.RemoveAndForget(aScope, doomed); + } + } + + // Examine any windows performing a navigation that we are currently + // intercepting. + InterceptionList* intList = mNavigationInterceptions.Get(aScope); + if (intList) { + for (uint32_t i = 0; i < intList->Length(); ++i) { + nsCOMPtr<nsIInterceptedChannel> channel = intList->ElementAt(i); + + nsCOMPtr<nsIChannel> inner; + nsresult rv = channel->GetChannel(getter_AddRefs(inner)); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + uint64_t id = nsContentUtils::GetInnerWindowID(inner); + if (id == 0) { + continue; + } + + nsCOMPtr<nsPIDOMWindowInner> win = nsGlobalWindow::GetInnerWindowWithId(id)->AsInner(); + if (!win) { + continue; + } + + nsCOMPtr<nsPIDOMWindowOuter> outer = win->GetScriptableTop(); + + // Match. We should report to this window. + if (outer && winId == outer->WindowID()) { + *aResult = true; + return NS_OK; + } + } + } + + // Next examine controlled documents to see if the windows match. + for (auto iter = mControlledDocuments.Iter(); !iter.Done(); iter.Next()) { + ServiceWorkerRegistrationInfo* reg = iter.UserData(); + MOZ_ASSERT(reg); + if (!reg->mScope.Equals(aScope)) { + continue; + } + + nsCOMPtr<nsIDocument> doc = do_QueryInterface(iter.Key()); + if (!doc || !doc->IsCurrentActiveDocument()) { + continue; + } + + nsCOMPtr<nsPIDOMWindowOuter> win = doc->GetWindow(); + if (!win) { + continue; + } + + win = win->GetScriptableTop(); + + // Match. We should report to this window. + if (win && winId == win->WindowID()) { + *aResult = true; + return NS_OK; + } + } + + // No match. We should not report to this window. + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + if (strcmp(aTopic, PURGE_SESSION_HISTORY) == 0) { + MOZ_ASSERT(XRE_IsParentProcess()); + RemoveAll(); + PropagateRemoveAll(); + return NS_OK; + } + + if (strcmp(aTopic, PURGE_DOMAIN_DATA) == 0) { + MOZ_ASSERT(XRE_IsParentProcess()); + nsAutoString domain(aData); + RemoveAndPropagate(NS_ConvertUTF16toUTF8(domain)); + return NS_OK; + } + + if (strcmp(aTopic, CLEAR_ORIGIN_DATA) == 0) { + MOZ_ASSERT(XRE_IsParentProcess()); + OriginAttributesPattern pattern; + MOZ_ALWAYS_TRUE(pattern.Init(nsAutoString(aData))); + + RemoveAllRegistrations(&pattern); + return NS_OK; + } + + if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { + MaybeStartShutdown(); + return NS_OK; + } + + MOZ_CRASH("Received message we aren't supposed to be registered for!"); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerManager::PropagateSoftUpdate(JS::Handle<JS::Value> aOriginAttributes, + const nsAString& aScope, + JSContext* aCx) +{ + AssertIsOnMainThread(); + + PrincipalOriginAttributes attrs; + if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + PropagateSoftUpdate(attrs, aScope); + return NS_OK; +} + +void +ServiceWorkerManager::PropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsAString& aScope) +{ + AssertIsOnMainThread(); + + if (!mActor) { + RefPtr<nsIRunnable> runnable = + new PropagateSoftUpdateRunnable(aOriginAttributes, aScope); + AppendPendingOperation(runnable); + return; + } + + mActor->SendPropagateSoftUpdate(aOriginAttributes, nsString(aScope)); +} + +NS_IMETHODIMP +ServiceWorkerManager::PropagateUnregister(nsIPrincipal* aPrincipal, + nsIServiceWorkerUnregisterCallback* aCallback, + const nsAString& aScope) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + if (!mActor) { + RefPtr<nsIRunnable> runnable = + new PropagateUnregisterRunnable(aPrincipal, aCallback, aScope); + AppendPendingOperation(runnable); + return NS_OK; + } + + PrincipalInfo principalInfo; + if (NS_WARN_IF(NS_FAILED(PrincipalToPrincipalInfo(aPrincipal, + &principalInfo)))) { + return NS_ERROR_FAILURE; + } + + mActor->SendPropagateUnregister(principalInfo, nsString(aScope)); + + nsresult rv = Unregister(aPrincipal, aCallback, aScope); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +void +ServiceWorkerManager::NotifyListenersOnRegister( + nsIServiceWorkerRegistrationInfo* aInfo) +{ + nsTArray<nsCOMPtr<nsIServiceWorkerManagerListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnRegister(aInfo); + } +} + +void +ServiceWorkerManager::NotifyListenersOnUnregister( + nsIServiceWorkerRegistrationInfo* aInfo) +{ + nsTArray<nsCOMPtr<nsIServiceWorkerManagerListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnUnregister(aInfo); + } +} + +void +ServiceWorkerManager::AddRegisteringDocument(const nsACString& aScope, + nsIDocument* aDoc) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!aScope.IsEmpty()); + MOZ_ASSERT(aDoc); + + WeakDocumentList* list = mRegisteringDocuments.LookupOrAdd(aScope); + MOZ_ASSERT(list); + + for (int32_t i = list->Length() - 1; i >= 0; --i) { + nsCOMPtr<nsIDocument> existing = do_QueryReferent(list->ElementAt(i)); + if (!existing) { + list->RemoveElementAt(i); + continue; + } + if (existing == aDoc) { + return; + } + } + + list->AppendElement(do_GetWeakReference(aDoc)); +} + +class ServiceWorkerManager::InterceptionReleaseHandle final : public nsISupports +{ + const nsCString mScope; + + // Weak reference to channel is safe, because the channel holds a + // reference to this object. Also, the pointer is only used for + // comparison purposes. + nsIInterceptedChannel* mChannel; + + ~InterceptionReleaseHandle() + { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->RemoveNavigationInterception(mScope, mChannel); + } + } + +public: + InterceptionReleaseHandle(const nsACString& aScope, + nsIInterceptedChannel* aChannel) + : mScope(aScope) + , mChannel(aChannel) + { + AssertIsOnMainThread(); + MOZ_ASSERT(!aScope.IsEmpty()); + MOZ_ASSERT(mChannel); + } + + NS_DECL_ISUPPORTS +}; + +NS_IMPL_ISUPPORTS0(ServiceWorkerManager::InterceptionReleaseHandle); + +void +ServiceWorkerManager::AddNavigationInterception(const nsACString& aScope, + nsIInterceptedChannel* aChannel) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!aScope.IsEmpty()); + MOZ_ASSERT(aChannel); + + InterceptionList* list = + mNavigationInterceptions.LookupOrAdd(aScope); + MOZ_ASSERT(list); + MOZ_ASSERT(!list->Contains(aChannel)); + + nsCOMPtr<nsISupports> releaseHandle = + new InterceptionReleaseHandle(aScope, aChannel); + aChannel->SetReleaseHandle(releaseHandle); + + list->AppendElement(aChannel); +} + +void +ServiceWorkerManager::RemoveNavigationInterception(const nsACString& aScope, + nsIInterceptedChannel* aChannel) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aChannel); + InterceptionList* list = + mNavigationInterceptions.Get(aScope); + if (list) { + MOZ_ALWAYS_TRUE(list->RemoveElement(aChannel)); + MOZ_ASSERT(!list->Contains(aChannel)); + if (list->IsEmpty()) { + list = nullptr; + nsAutoPtr<InterceptionList> doomed; + mNavigationInterceptions.RemoveAndForget(aScope, doomed); + } + } +} + +class UpdateTimerCallback final : public nsITimerCallback +{ + nsCOMPtr<nsIPrincipal> mPrincipal; + const nsCString mScope; + + ~UpdateTimerCallback() + { + } + +public: + UpdateTimerCallback(nsIPrincipal* aPrincipal, const nsACString& aScope) + : mPrincipal(aPrincipal) + , mScope(aScope) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mPrincipal); + MOZ_ASSERT(!mScope.IsEmpty()); + } + + NS_IMETHOD + Notify(nsITimer* aTimer) override + { + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // shutting down, do nothing + return NS_OK; + } + + swm->UpdateTimerFired(mPrincipal, mScope); + return NS_OK; + } + + NS_DECL_ISUPPORTS +}; + +NS_IMPL_ISUPPORTS(UpdateTimerCallback, nsITimerCallback) + +bool +ServiceWorkerManager::MayHaveActiveServiceWorkerInstance(ContentParent* aContent, + nsIPrincipal* aPrincipal) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + if (mShuttingDown) { + return false; + } + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(scopeKey, &data)) { + return false; + } + + return true; +} + +void +ServiceWorkerManager::ScheduleUpdateTimer(nsIPrincipal* aPrincipal, + const nsACString& aScope) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(!aScope.IsEmpty()); + + if (mShuttingDown) { + return; + } + + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(scopeKey, &data)) { + return; + } + + nsCOMPtr<nsITimer> timer = data->mUpdateTimers.Get(aScope); + if (timer) { + // There is already a timer scheduled. In this case just use the original + // schedule time. We don't want to push it out to a later time since that + // could allow updates to be starved forever if events are continuously + // fired. + return; + } + + timer = do_CreateInstance("@mozilla.org/timer;1", &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsCOMPtr<nsITimerCallback> callback = new UpdateTimerCallback(aPrincipal, + aScope); + + const uint32_t UPDATE_DELAY_MS = 1000; + + rv = timer->InitWithCallback(callback, UPDATE_DELAY_MS, + nsITimer::TYPE_ONE_SHOT); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + data->mUpdateTimers.Put(aScope, timer); +} + +void +ServiceWorkerManager::UpdateTimerFired(nsIPrincipal* aPrincipal, + const nsACString& aScope) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(!aScope.IsEmpty()); + + if (mShuttingDown) { + return; + } + + // First cleanup the timer. + nsAutoCString scopeKey; + nsresult rv = PrincipalToScopeKey(aPrincipal, scopeKey); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RegistrationDataPerPrincipal* data; + if (!mRegistrationInfos.Get(scopeKey, &data)) { + return; + } + + nsCOMPtr<nsITimer> timer = data->mUpdateTimers.Get(aScope); + if (timer) { + timer->Cancel(); + data->mUpdateTimers.Remove(aScope); + } + + RefPtr<ServiceWorkerRegistrationInfo> registration; + data->mInfos.Get(aScope, getter_AddRefs(registration)); + if (!registration) { + return; + } + + if (!registration->CheckAndClearIfUpdateNeeded()) { + return; + } + + PrincipalOriginAttributes attrs = + BasePrincipal::Cast(aPrincipal)->OriginAttributesRef(); + + SoftUpdate(attrs, aScope); +} + +void +ServiceWorkerManager::MaybeSendUnregister(nsIPrincipal* aPrincipal, + const nsACString& aScope) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(!aScope.IsEmpty()); + + if (!mActor) { + return; + } + + PrincipalInfo principalInfo; + nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + Unused << mActor->SendUnregister(principalInfo, NS_ConvertUTF8toUTF16(aScope)); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerManager.h b/dom/workers/ServiceWorkerManager.h new file mode 100644 index 000000000..f99bc4248 --- /dev/null +++ b/dom/workers/ServiceWorkerManager.h @@ -0,0 +1,521 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkermanager_h +#define mozilla_dom_workers_serviceworkermanager_h + +#include "nsIServiceWorkerManager.h" +#include "nsCOMPtr.h" + +#include "ipc/IPCMessageUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/ConsoleReportCollector.h" +#include "mozilla/LinkedList.h" +#include "mozilla/Preferences.h" +#include "mozilla/TypedEnumBits.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/WeakPtr.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/ServiceWorkerCommon.h" +#include "mozilla/dom/ServiceWorkerRegistrar.h" +#include "mozilla/dom/ServiceWorkerRegistrarTypes.h" +#include "mozilla/dom/workers/ServiceWorkerRegistrationInfo.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "nsClassHashtable.h" +#include "nsDataHashtable.h" +#include "nsIIPCBackgroundChildCreateCallback.h" +#include "nsRefPtrHashtable.h" +#include "nsTArrayForwardDeclare.h" +#include "nsTObserverArray.h" + +class mozIApplicationClearPrivateDataParams; +class nsIConsoleReportCollector; + +namespace mozilla { + +class PrincipalOriginAttributes; + +namespace dom { + +class ServiceWorkerRegistrar; +class ServiceWorkerRegistrationListener; + +namespace workers { + +class ServiceWorkerClientInfo; +class ServiceWorkerInfo; +class ServiceWorkerJobQueue; +class ServiceWorkerManagerChild; +class ServiceWorkerPrivate; + +class ServiceWorkerUpdateFinishCallback +{ +protected: + virtual ~ServiceWorkerUpdateFinishCallback() + {} + +public: + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerUpdateFinishCallback) + + virtual + void UpdateSucceeded(ServiceWorkerRegistrationInfo* aInfo) = 0; + + virtual + void UpdateFailed(ErrorResult& aStatus) = 0; +}; + +#define NS_SERVICEWORKERMANAGER_IMPL_IID \ +{ /* f4f8755a-69ca-46e8-a65d-775745535990 */ \ + 0xf4f8755a, \ + 0x69ca, \ + 0x46e8, \ + { 0xa6, 0x5d, 0x77, 0x57, 0x45, 0x53, 0x59, 0x90 } \ +} + +/* + * The ServiceWorkerManager is a per-process global that deals with the + * installation, querying and event dispatch of ServiceWorkers for all the + * origins in the process. + */ +class ServiceWorkerManager final + : public nsIServiceWorkerManager + , public nsIIPCBackgroundChildCreateCallback + , public nsIObserver +{ + friend class GetReadyPromiseRunnable; + friend class GetRegistrationsRunnable; + friend class GetRegistrationRunnable; + friend class ServiceWorkerJob; + friend class ServiceWorkerRegistrationInfo; + friend class ServiceWorkerUnregisterJob; + friend class ServiceWorkerUpdateJob; + friend class UpdateTimerCallback; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISERVICEWORKERMANAGER + NS_DECL_NSIIPCBACKGROUNDCHILDCREATECALLBACK + NS_DECL_NSIOBSERVER + + struct RegistrationDataPerPrincipal; + nsClassHashtable<nsCStringHashKey, RegistrationDataPerPrincipal> mRegistrationInfos; + + nsTObserverArray<ServiceWorkerRegistrationListener*> mServiceWorkerRegistrationListeners; + + nsRefPtrHashtable<nsISupportsHashKey, ServiceWorkerRegistrationInfo> mControlledDocuments; + + // Track all documents that have attempted to register a service worker for a + // given scope. + typedef nsTArray<nsCOMPtr<nsIWeakReference>> WeakDocumentList; + nsClassHashtable<nsCStringHashKey, WeakDocumentList> mRegisteringDocuments; + + // Track all intercepted navigation channels for a given scope. Channels are + // placed in the appropriate list before dispatch the FetchEvent to the worker + // thread and removed once FetchEvent processing dispatches back to the main + // thread. + // + // Note: Its safe to use weak references here because a RAII-style callback + // is registered with the channel before its added to this list. We + // are guaranteed the callback will fire before and remove the ref + // from this list before the channel is destroyed. + typedef nsTArray<nsIInterceptedChannel*> InterceptionList; + nsClassHashtable<nsCStringHashKey, InterceptionList> mNavigationInterceptions; + + bool + IsAvailable(nsIPrincipal* aPrincipal, nsIURI* aURI); + + bool + IsControlled(nsIDocument* aDocument, ErrorResult& aRv); + + // Return true if the given content process could potentially be executing + // service worker code with the given principal. At the current time, this + // just means that we have any registration for the origin, regardless of + // scope. This is a very weak guarantee but is the best we can do when push + // notifications can currently spin up a service worker in content processes + // without our involvement in the parent process. + // + // In the future when there is only a single ServiceWorkerManager in the + // parent process that is entirely in control of spawning and running service + // worker code, we will be able to authoritatively indicate whether there is + // an activate service worker in the given content process. At that time we + // will rename this method HasActiveServiceWorkerInstance and provide + // semantics that ensure this method returns true until the worker is known to + // have shut down in order to allow the caller to induce a crash for security + // reasons without having to worry about shutdown races with the worker. + bool + MayHaveActiveServiceWorkerInstance(ContentParent* aContent, + nsIPrincipal* aPrincipal); + + void + DispatchFetchEvent(const PrincipalOriginAttributes& aOriginAttributes, + nsIDocument* aDoc, + const nsAString& aDocumentIdForTopLevelNavigation, + nsIInterceptedChannel* aChannel, + bool aIsReload, + bool aIsSubresourceLoad, + ErrorResult& aRv); + + void + Update(nsIPrincipal* aPrincipal, + const nsACString& aScope, + ServiceWorkerUpdateFinishCallback* aCallback); + + void + SoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsACString& aScope); + + void + PropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsAString& aScope); + + void + PropagateRemove(const nsACString& aHost); + + void + Remove(const nsACString& aHost); + + void + PropagateRemoveAll(); + + void + RemoveAll(); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetRegistration(nsIPrincipal* aPrincipal, const nsACString& aScope) const; + + already_AddRefed<ServiceWorkerRegistrationInfo> + CreateNewRegistration(const nsCString& aScope, nsIPrincipal* aPrincipal); + + void + RemoveRegistration(ServiceWorkerRegistrationInfo* aRegistration); + + void StoreRegistration(nsIPrincipal* aPrincipal, + ServiceWorkerRegistrationInfo* aRegistration); + + void + FinishFetch(ServiceWorkerRegistrationInfo* aRegistration); + + /** + * Report an error for the given scope to any window we think might be + * interested, failing over to the Browser Console if we couldn't find any. + * + * Error messages should be localized, so you probably want to call + * LocalizeAndReportToAllClients instead, which in turn calls us after + * localizing the error. + */ + void + ReportToAllClients(const nsCString& aScope, + const nsString& aMessage, + const nsString& aFilename, + const nsString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags); + + /** + * Report a localized error for the given scope to any window we think might + * be interested. + * + * Note that this method takes an nsTArray<nsString> for the parameters, not + * bare chart16_t*[]. You can use a std::initializer_list constructor inline + * so that argument might look like: nsTArray<nsString> { some_nsString, + * PromiseFlatString(some_nsSubString_aka_nsAString), + * NS_ConvertUTF8toUTF16(some_nsCString_or_nsCSubString), + * NS_LITERAL_STRING("some literal") }. If you have anything else, like a + * number, you can use an nsAutoString with AppendInt/friends. + * + * @param [aFlags] + * The nsIScriptError flag, one of errorFlag (0x0), warningFlag (0x1), + * infoFlag (0x8). We default to error if omitted because usually we're + * logging exceptional and/or obvious breakage. + */ + static void + LocalizeAndReportToAllClients(const nsCString& aScope, + const char* aStringKey, + const nsTArray<nsString>& aParamArray, + uint32_t aFlags = 0x0, + const nsString& aFilename = EmptyString(), + const nsString& aLine = EmptyString(), + uint32_t aLineNumber = 0, + uint32_t aColumnNumber = 0); + + void + FlushReportsToAllClients(const nsACString& aScope, + nsIConsoleReportCollector* aReporter); + + // Always consumes the error by reporting to consoles of all controlled + // documents. + void + HandleError(JSContext* aCx, + nsIPrincipal* aPrincipal, + const nsCString& aScope, + const nsString& aWorkerURL, + const nsString& aMessage, + const nsString& aFilename, + const nsString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags, + JSExnType aExnType); + + UniquePtr<ServiceWorkerClientInfo> + GetClient(nsIPrincipal* aPrincipal, + const nsAString& aClientId, + ErrorResult& aRv); + + void + GetAllClients(nsIPrincipal* aPrincipal, + const nsCString& aScope, + bool aIncludeUncontrolled, + nsTArray<ServiceWorkerClientInfo>& aDocuments); + + void + MaybeClaimClient(nsIDocument* aDocument, + ServiceWorkerRegistrationInfo* aWorkerRegistration); + + nsresult + ClaimClients(nsIPrincipal* aPrincipal, const nsCString& aScope, uint64_t aId); + + void + SetSkipWaitingFlag(nsIPrincipal* aPrincipal, const nsCString& aScope, + uint64_t aServiceWorkerID); + + static already_AddRefed<ServiceWorkerManager> + GetInstance(); + + void + LoadRegistration(const ServiceWorkerRegistrationData& aRegistration); + + void + LoadRegistrations(const nsTArray<ServiceWorkerRegistrationData>& aRegistrations); + + // Used by remove() and removeAll() when clearing history. + // MUST ONLY BE CALLED FROM UnregisterIfMatchesHost! + void + ForceUnregister(RegistrationDataPerPrincipal* aRegistrationData, + ServiceWorkerRegistrationInfo* aRegistration); + + NS_IMETHOD + AddRegistrationEventListener(const nsAString& aScope, + ServiceWorkerRegistrationListener* aListener); + + NS_IMETHOD + RemoveRegistrationEventListener(const nsAString& aScope, + ServiceWorkerRegistrationListener* aListener); + + void + MaybeCheckNavigationUpdate(nsIDocument* aDoc); + + nsresult + SendPushEvent(const nsACString& aOriginAttributes, + const nsACString& aScope, + const nsAString& aMessageId, + const Maybe<nsTArray<uint8_t>>& aData); + + nsresult + NotifyUnregister(nsIPrincipal* aPrincipal, const nsAString& aScope); + + void + WorkerIsIdle(ServiceWorkerInfo* aWorker); + +private: + ServiceWorkerManager(); + ~ServiceWorkerManager(); + + void + Init(ServiceWorkerRegistrar* aRegistrar); + + void + MaybeStartShutdown(); + + already_AddRefed<ServiceWorkerJobQueue> + GetOrCreateJobQueue(const nsACString& aOriginSuffix, + const nsACString& aScope); + + void + MaybeRemoveRegistrationInfo(const nsACString& aScopeKey); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetRegistration(const nsACString& aScopeKey, + const nsACString& aScope) const; + + void + AbortCurrentUpdate(ServiceWorkerRegistrationInfo* aRegistration); + + nsresult + Update(ServiceWorkerRegistrationInfo* aRegistration); + + nsresult + GetDocumentRegistration(nsIDocument* aDoc, + ServiceWorkerRegistrationInfo** aRegistrationInfo); + + nsresult + GetServiceWorkerForScope(nsPIDOMWindowInner* aWindow, + const nsAString& aScope, + WhichServiceWorker aWhichWorker, + nsISupports** aServiceWorker); + + ServiceWorkerInfo* + GetActiveWorkerInfoForScope(const PrincipalOriginAttributes& aOriginAttributes, + const nsACString& aScope); + + ServiceWorkerInfo* + GetActiveWorkerInfoForDocument(nsIDocument* aDocument); + + void + InvalidateServiceWorkerRegistrationWorker(ServiceWorkerRegistrationInfo* aRegistration, + WhichServiceWorker aWhichOnes); + + void + NotifyServiceWorkerRegistrationRemoved(ServiceWorkerRegistrationInfo* aRegistration); + + void + StartControllingADocument(ServiceWorkerRegistrationInfo* aRegistration, + nsIDocument* aDoc, + const nsAString& aDocumentId); + + void + StopControllingADocument(ServiceWorkerRegistrationInfo* aRegistration); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetServiceWorkerRegistrationInfo(nsPIDOMWindowInner* aWindow); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetServiceWorkerRegistrationInfo(nsIDocument* aDoc); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetServiceWorkerRegistrationInfo(nsIPrincipal* aPrincipal, nsIURI* aURI); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetServiceWorkerRegistrationInfo(const nsACString& aScopeKey, + nsIURI* aURI); + + // This method generates a key using appId and isInElementBrowser from the + // principal. We don't use the origin because it can change during the + // loading. + static nsresult + PrincipalToScopeKey(nsIPrincipal* aPrincipal, nsACString& aKey); + + static void + AddScopeAndRegistration(const nsACString& aScope, + ServiceWorkerRegistrationInfo* aRegistation); + + static bool + FindScopeForPath(const nsACString& aScopeKey, + const nsACString& aPath, + RegistrationDataPerPrincipal** aData, nsACString& aMatch); + + static bool + HasScope(nsIPrincipal* aPrincipal, const nsACString& aScope); + + static void + RemoveScopeAndRegistration(ServiceWorkerRegistrationInfo* aRegistration); + + void + QueueFireEventOnServiceWorkerRegistrations(ServiceWorkerRegistrationInfo* aRegistration, + const nsAString& aName); + + void + FireUpdateFoundOnServiceWorkerRegistrations(ServiceWorkerRegistrationInfo* aRegistration); + + void + FireControllerChange(ServiceWorkerRegistrationInfo* aRegistration); + + void + StorePendingReadyPromise(nsPIDOMWindowInner* aWindow, nsIURI* aURI, + Promise* aPromise); + + void + CheckPendingReadyPromises(); + + bool + CheckReadyPromise(nsPIDOMWindowInner* aWindow, nsIURI* aURI, + Promise* aPromise); + + struct PendingReadyPromise final + { + PendingReadyPromise(nsIURI* aURI, Promise* aPromise) + : mURI(aURI), mPromise(aPromise) + {} + + nsCOMPtr<nsIURI> mURI; + RefPtr<Promise> mPromise; + }; + + void AppendPendingOperation(nsIRunnable* aRunnable); + + bool HasBackgroundActor() const + { + return !!mActor; + } + + nsClassHashtable<nsISupportsHashKey, PendingReadyPromise> mPendingReadyPromises; + + void + MaybeRemoveRegistration(ServiceWorkerRegistrationInfo* aRegistration); + + // Removes all service worker registrations that matches the given pattern. + void + RemoveAllRegistrations(OriginAttributesPattern* aPattern); + + RefPtr<ServiceWorkerManagerChild> mActor; + + nsTArray<nsCOMPtr<nsIRunnable>> mPendingOperations; + + bool mShuttingDown; + + nsTArray<nsCOMPtr<nsIServiceWorkerManagerListener>> mListeners; + + void + NotifyListenersOnRegister(nsIServiceWorkerRegistrationInfo* aRegistration); + + void + NotifyListenersOnUnregister(nsIServiceWorkerRegistrationInfo* aRegistration); + + void + AddRegisteringDocument(const nsACString& aScope, nsIDocument* aDoc); + + class InterceptionReleaseHandle; + + void + AddNavigationInterception(const nsACString& aScope, + nsIInterceptedChannel* aChannel); + + void + RemoveNavigationInterception(const nsACString& aScope, + nsIInterceptedChannel* aChannel); + + void + ScheduleUpdateTimer(nsIPrincipal* aPrincipal, const nsACString& aScope); + + void + UpdateTimerFired(nsIPrincipal* aPrincipal, const nsACString& aScope); + + void + MaybeSendUnregister(nsIPrincipal* aPrincipal, const nsACString& aScope); + + nsresult + SendNotificationEvent(const nsAString& aEventName, + const nsACString& aOriginSuffix, + const nsACString& aScope, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior); +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkermanager_h diff --git a/dom/workers/ServiceWorkerManagerChild.cpp b/dom/workers/ServiceWorkerManagerChild.cpp new file mode 100644 index 000000000..47a39d1c2 --- /dev/null +++ b/dom/workers/ServiceWorkerManagerChild.cpp @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerManagerChild.h" +#include "ServiceWorkerManager.h" +#include "mozilla/Unused.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { +namespace workers { + +bool +ServiceWorkerManagerChild::RecvNotifyRegister( + const ServiceWorkerRegistrationData& aData) +{ + if (mShuttingDown) { + return true; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->LoadRegistration(aData); + } + + return true; +} + +bool +ServiceWorkerManagerChild::RecvNotifySoftUpdate( + const PrincipalOriginAttributes& aOriginAttributes, + const nsString& aScope) +{ + if (mShuttingDown) { + return true; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->SoftUpdate(aOriginAttributes, NS_ConvertUTF16toUTF8(aScope)); + } + + return true; +} + +bool +ServiceWorkerManagerChild::RecvNotifyUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) +{ + if (mShuttingDown) { + return true; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return true; + } + + nsCOMPtr<nsIPrincipal> principal = PrincipalInfoToPrincipal(aPrincipalInfo); + if (NS_WARN_IF(!principal)) { + return true; + } + + nsresult rv = swm->NotifyUnregister(principal, aScope); + Unused << NS_WARN_IF(NS_FAILED(rv)); + return true; +} + +bool +ServiceWorkerManagerChild::RecvNotifyRemove(const nsCString& aHost) +{ + if (mShuttingDown) { + return true; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->Remove(aHost); + } + + return true; +} + +bool +ServiceWorkerManagerChild::RecvNotifyRemoveAll() +{ + if (mShuttingDown) { + return true; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->RemoveAll(); + } + + return true; +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerManagerChild.h b/dom/workers/ServiceWorkerManagerChild.h new file mode 100644 index 000000000..d32f3ed10 --- /dev/null +++ b/dom/workers/ServiceWorkerManagerChild.h @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ServiceWorkerManagerChild_h +#define mozilla_dom_ServiceWorkerManagerChild_h + +#include "mozilla/dom/PServiceWorkerManagerChild.h" +#include "mozilla/ipc/BackgroundUtils.h" + +namespace mozilla { + +class PrincipalOriginAttributes; + +namespace ipc { +class BackgroundChildImpl; +} // namespace ipc + +namespace dom { +namespace workers { + +class ServiceWorkerManagerChild final : public PServiceWorkerManagerChild +{ + friend class mozilla::ipc::BackgroundChildImpl; + +public: + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerManagerChild) + + void ManagerShuttingDown() + { + mShuttingDown = true; + } + + virtual bool RecvNotifyRegister(const ServiceWorkerRegistrationData& aData) + override; + + virtual bool RecvNotifySoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsString& aScope) override; + + virtual bool RecvNotifyUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) override; + + virtual bool RecvNotifyRemove(const nsCString& aHost) override; + + virtual bool RecvNotifyRemoveAll() override; + +private: + ServiceWorkerManagerChild() + : mShuttingDown(false) + {} + + ~ServiceWorkerManagerChild() {} + + bool mShuttingDown; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ServiceWorkerManagerChild_h diff --git a/dom/workers/ServiceWorkerManagerParent.cpp b/dom/workers/ServiceWorkerManagerParent.cpp new file mode 100644 index 000000000..bd9afad7a --- /dev/null +++ b/dom/workers/ServiceWorkerManagerParent.cpp @@ -0,0 +1,330 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerManagerParent.h" +#include "ServiceWorkerManagerService.h" +#include "mozilla/AppProcessChecker.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/ServiceWorkerRegistrar.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/Unused.h" +#include "nsThreadUtils.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { +namespace workers { + +namespace { + +uint64_t sServiceWorkerManagerParentID = 0; + +class RegisterServiceWorkerCallback final : public Runnable +{ +public: + RegisterServiceWorkerCallback(const ServiceWorkerRegistrationData& aData, + uint64_t aParentID) + : mData(aData) + , mParentID(aParentID) + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + } + + NS_IMETHOD + Run() override + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<dom::ServiceWorkerRegistrar> service = + dom::ServiceWorkerRegistrar::Get(); + + // Shutdown during the process of trying to update the registrar. Give + // up on this modification. + if (!service) { + return NS_OK; + } + + service->RegisterServiceWorker(mData); + + RefPtr<ServiceWorkerManagerService> managerService = + ServiceWorkerManagerService::Get(); + if (managerService) { + managerService->PropagateRegistration(mParentID, mData); + } + + return NS_OK; + } + +private: + ServiceWorkerRegistrationData mData; + const uint64_t mParentID; +}; + +class UnregisterServiceWorkerCallback final : public Runnable +{ +public: + UnregisterServiceWorkerCallback(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope, + uint64_t aParentID) + : mPrincipalInfo(aPrincipalInfo) + , mScope(aScope) + , mParentID(aParentID) + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + } + + NS_IMETHOD + Run() override + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<dom::ServiceWorkerRegistrar> service = + dom::ServiceWorkerRegistrar::Get(); + + // Shutdown during the process of trying to update the registrar. Give + // up on this modification. + if (!service) { + return NS_OK; + } + + service->UnregisterServiceWorker(mPrincipalInfo, + NS_ConvertUTF16toUTF8(mScope)); + + RefPtr<ServiceWorkerManagerService> managerService = + ServiceWorkerManagerService::Get(); + if (managerService) { + managerService->PropagateUnregister(mParentID, mPrincipalInfo, + mScope); + } + + return NS_OK; + } + +private: + const PrincipalInfo mPrincipalInfo; + nsString mScope; + uint64_t mParentID; +}; + +class CheckPrincipalWithCallbackRunnable final : public Runnable +{ +public: + CheckPrincipalWithCallbackRunnable(already_AddRefed<ContentParent> aParent, + const PrincipalInfo& aPrincipalInfo, + Runnable* aCallback) + : mContentParent(aParent) + , mPrincipalInfo(aPrincipalInfo) + , mCallback(aCallback) + , mBackgroundThread(NS_GetCurrentThread()) + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + MOZ_ASSERT(mContentParent); + MOZ_ASSERT(mCallback); + MOZ_ASSERT(mBackgroundThread); + } + + NS_IMETHOD Run() override + { + if (NS_IsMainThread()) { + nsCOMPtr<nsIPrincipal> principal = PrincipalInfoToPrincipal(mPrincipalInfo); + AssertAppPrincipal(mContentParent, principal); + mContentParent = nullptr; + + mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL); + return NS_OK; + } + + AssertIsOnBackgroundThread(); + mCallback->Run(); + mCallback = nullptr; + + return NS_OK; + } + +private: + RefPtr<ContentParent> mContentParent; + PrincipalInfo mPrincipalInfo; + RefPtr<Runnable> mCallback; + nsCOMPtr<nsIThread> mBackgroundThread; +}; + +} // namespace + +ServiceWorkerManagerParent::ServiceWorkerManagerParent() + : mService(ServiceWorkerManagerService::GetOrCreate()) + , mID(++sServiceWorkerManagerParentID) +{ + AssertIsOnBackgroundThread(); + mService->RegisterActor(this); +} + +ServiceWorkerManagerParent::~ServiceWorkerManagerParent() +{ + AssertIsOnBackgroundThread(); +} + +bool +ServiceWorkerManagerParent::RecvRegister( + const ServiceWorkerRegistrationData& aData) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + // Basic validation. + if (aData.scope().IsEmpty() || + aData.principal().type() == PrincipalInfo::TNullPrincipalInfo || + aData.principal().type() == PrincipalInfo::TSystemPrincipalInfo) { + return false; + } + + RefPtr<RegisterServiceWorkerCallback> callback = + new RegisterServiceWorkerCallback(aData, mID); + + RefPtr<ContentParent> parent = + BackgroundParent::GetContentParent(Manager()); + + // If the ContentParent is null we are dealing with a same-process actor. + if (!parent) { + callback->Run(); + return true; + } + + RefPtr<CheckPrincipalWithCallbackRunnable> runnable = + new CheckPrincipalWithCallbackRunnable(parent.forget(), aData.principal(), + callback); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable)); + + return true; +} + +bool +ServiceWorkerManagerParent::RecvUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + // Basic validation. + if (aScope.IsEmpty() || + aPrincipalInfo.type() == PrincipalInfo::TNullPrincipalInfo || + aPrincipalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) { + return false; + } + + RefPtr<UnregisterServiceWorkerCallback> callback = + new UnregisterServiceWorkerCallback(aPrincipalInfo, aScope, mID); + + RefPtr<ContentParent> parent = + BackgroundParent::GetContentParent(Manager()); + + // If the ContentParent is null we are dealing with a same-process actor. + if (!parent) { + callback->Run(); + return true; + } + + RefPtr<CheckPrincipalWithCallbackRunnable> runnable = + new CheckPrincipalWithCallbackRunnable(parent.forget(), aPrincipalInfo, + callback); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable)); + + return true; +} + +bool +ServiceWorkerManagerParent::RecvPropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsString& aScope) +{ + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(!mService)) { + return false; + } + + mService->PropagateSoftUpdate(mID, aOriginAttributes, aScope); + return true; +} + +bool +ServiceWorkerManagerParent::RecvPropagateUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) +{ + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(!mService)) { + return false; + } + + mService->PropagateUnregister(mID, aPrincipalInfo, aScope); + return true; +} + +bool +ServiceWorkerManagerParent::RecvPropagateRemove(const nsCString& aHost) +{ + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(!mService)) { + return false; + } + + mService->PropagateRemove(mID, aHost); + return true; +} + +bool +ServiceWorkerManagerParent::RecvPropagateRemoveAll() +{ + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(!mService)) { + return false; + } + + mService->PropagateRemoveAll(mID); + return true; +} + +bool +ServiceWorkerManagerParent::RecvShutdown() +{ + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(!mService)) { + return false; + } + + mService->UnregisterActor(this); + mService = nullptr; + + Unused << Send__delete__(this); + return true; +} + +void +ServiceWorkerManagerParent::ActorDestroy(ActorDestroyReason aWhy) +{ + AssertIsOnBackgroundThread(); + + if (mService) { + // This object is about to be released and with it, also mService will be + // released too. + mService->UnregisterActor(this); + } +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerManagerParent.h b/dom/workers/ServiceWorkerManagerParent.h new file mode 100644 index 000000000..83a0a97aa --- /dev/null +++ b/dom/workers/ServiceWorkerManagerParent.h @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ServiceWorkerManagerParent_h +#define mozilla_dom_ServiceWorkerManagerParent_h + +#include "mozilla/dom/PServiceWorkerManagerParent.h" + +namespace mozilla { + +class PrincipalOriginAttributes; + +namespace ipc { +class BackgroundParentImpl; +} // namespace ipc + +namespace dom { +namespace workers { + +class ServiceWorkerManagerService; + +class ServiceWorkerManagerParent final : public PServiceWorkerManagerParent +{ + friend class mozilla::ipc::BackgroundParentImpl; + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ServiceWorkerManagerParent) + + uint64_t ID() const + { + return mID; + } + +private: + ServiceWorkerManagerParent(); + ~ServiceWorkerManagerParent(); + + virtual bool RecvRegister( + const ServiceWorkerRegistrationData& aData) override; + + virtual bool RecvUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) override; + + virtual bool RecvPropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes, + const nsString& aScope) override; + + virtual bool RecvPropagateUnregister(const PrincipalInfo& aPrincipalInfo, + const nsString& aScope) override; + + virtual bool RecvPropagateRemove(const nsCString& aHost) override; + + virtual bool RecvPropagateRemoveAll() override; + + virtual bool RecvShutdown() override; + + virtual void ActorDestroy(ActorDestroyReason aWhy) override; + + RefPtr<ServiceWorkerManagerService> mService; + + // We use this ID in the Service in order to avoid the sending of messages to + // ourself. + uint64_t mID; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ServiceWorkerManagerParent_h diff --git a/dom/workers/ServiceWorkerManagerService.cpp b/dom/workers/ServiceWorkerManagerService.cpp new file mode 100644 index 000000000..983bd77db --- /dev/null +++ b/dom/workers/ServiceWorkerManagerService.cpp @@ -0,0 +1,237 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerManagerService.h" +#include "ServiceWorkerManagerParent.h" +#include "ServiceWorkerRegistrar.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/Unused.h" +#include "nsAutoPtr.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { +namespace workers { + +namespace { + +ServiceWorkerManagerService* sInstance = nullptr; + +} // namespace + +ServiceWorkerManagerService::ServiceWorkerManagerService() +{ + AssertIsOnBackgroundThread(); + + // sInstance is a raw ServiceWorkerManagerService*. + MOZ_ASSERT(!sInstance); + sInstance = this; +} + +ServiceWorkerManagerService::~ServiceWorkerManagerService() +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(sInstance == this); + MOZ_ASSERT(mAgents.Count() == 0); + + sInstance = nullptr; +} + +/* static */ already_AddRefed<ServiceWorkerManagerService> +ServiceWorkerManagerService::Get() +{ + AssertIsOnBackgroundThread(); + + RefPtr<ServiceWorkerManagerService> instance = sInstance; + return instance.forget(); +} + +/* static */ already_AddRefed<ServiceWorkerManagerService> +ServiceWorkerManagerService::GetOrCreate() +{ + AssertIsOnBackgroundThread(); + + RefPtr<ServiceWorkerManagerService> instance = sInstance; + if (!instance) { + instance = new ServiceWorkerManagerService(); + } + return instance.forget(); +} + +void +ServiceWorkerManagerService::RegisterActor(ServiceWorkerManagerParent* aParent) +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aParent); + MOZ_ASSERT(!mAgents.Contains(aParent)); + + mAgents.PutEntry(aParent); +} + +void +ServiceWorkerManagerService::UnregisterActor(ServiceWorkerManagerParent* aParent) +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aParent); + MOZ_ASSERT(mAgents.Contains(aParent)); + + mAgents.RemoveEntry(aParent); +} + +void +ServiceWorkerManagerService::PropagateRegistration( + uint64_t aParentID, + ServiceWorkerRegistrationData& aData) +{ + AssertIsOnBackgroundThread(); + + DebugOnly<bool> parentFound = false; + for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) { + RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey(); + MOZ_ASSERT(parent); + + if (parent->ID() != aParentID) { + Unused << parent->SendNotifyRegister(aData); +#ifdef DEBUG + } else { + parentFound = true; +#endif + } + } + +#ifdef DEBUG + MOZ_ASSERT(parentFound); +#endif +} + +void +ServiceWorkerManagerService::PropagateSoftUpdate( + uint64_t aParentID, + const PrincipalOriginAttributes& aOriginAttributes, + const nsAString& aScope) +{ + AssertIsOnBackgroundThread(); + + DebugOnly<bool> parentFound = false; + for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) { + RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey(); + MOZ_ASSERT(parent); + + nsString scope(aScope); + Unused << parent->SendNotifySoftUpdate(aOriginAttributes, + scope); + +#ifdef DEBUG + if (parent->ID() == aParentID) { + parentFound = true; + } +#endif + } + +#ifdef DEBUG + MOZ_ASSERT(parentFound); +#endif +} + +void +ServiceWorkerManagerService::PropagateUnregister( + uint64_t aParentID, + const PrincipalInfo& aPrincipalInfo, + const nsAString& aScope) +{ + AssertIsOnBackgroundThread(); + + RefPtr<dom::ServiceWorkerRegistrar> service = + dom::ServiceWorkerRegistrar::Get(); + MOZ_ASSERT(service); + + // It's possible that we don't have any ServiceWorkerManager managing this + // scope but we still need to unregister it from the ServiceWorkerRegistrar. + service->UnregisterServiceWorker(aPrincipalInfo, + NS_ConvertUTF16toUTF8(aScope)); + + DebugOnly<bool> parentFound = false; + for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) { + RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey(); + MOZ_ASSERT(parent); + + if (parent->ID() != aParentID) { + nsString scope(aScope); + Unused << parent->SendNotifyUnregister(aPrincipalInfo, scope); +#ifdef DEBUG + } else { + parentFound = true; +#endif + } + } + +#ifdef DEBUG + MOZ_ASSERT(parentFound); +#endif +} + +void +ServiceWorkerManagerService::PropagateRemove(uint64_t aParentID, + const nsACString& aHost) +{ + AssertIsOnBackgroundThread(); + + DebugOnly<bool> parentFound = false; + for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) { + RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey(); + MOZ_ASSERT(parent); + + if (parent->ID() != aParentID) { + nsCString host(aHost); + Unused << parent->SendNotifyRemove(host); +#ifdef DEBUG + } else { + parentFound = true; +#endif + } + } + +#ifdef DEBUG + MOZ_ASSERT(parentFound); +#endif +} + +void +ServiceWorkerManagerService::PropagateRemoveAll(uint64_t aParentID) +{ + AssertIsOnBackgroundThread(); + + RefPtr<dom::ServiceWorkerRegistrar> service = + dom::ServiceWorkerRegistrar::Get(); + MOZ_ASSERT(service); + + service->RemoveAll(); + + DebugOnly<bool> parentFound = false; + for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) { + RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey(); + MOZ_ASSERT(parent); + + if (parent->ID() != aParentID) { + Unused << parent->SendNotifyRemoveAll(); +#ifdef DEBUG + } else { + parentFound = true; +#endif + } + } + +#ifdef DEBUG + MOZ_ASSERT(parentFound); +#endif +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerManagerService.h b/dom/workers/ServiceWorkerManagerService.h new file mode 100644 index 000000000..3f3f760e4 --- /dev/null +++ b/dom/workers/ServiceWorkerManagerService.h @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ServiceWorkerManagerService_h +#define mozilla_dom_ServiceWorkerManagerService_h + +#include "nsISupportsImpl.h" +#include "nsHashKeys.h" +#include "nsTHashtable.h" + +namespace mozilla { + +class PrincipalOriginAttributes; + +namespace ipc { +class PrincipalInfo; +} // namespace ipc + +namespace dom { + +class ServiceWorkerRegistrationData; + +namespace workers { + +class ServiceWorkerManagerParent; + +class ServiceWorkerManagerService final +{ +public: + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerManagerService) + + static already_AddRefed<ServiceWorkerManagerService> Get(); + static already_AddRefed<ServiceWorkerManagerService> GetOrCreate(); + + void RegisterActor(ServiceWorkerManagerParent* aParent); + void UnregisterActor(ServiceWorkerManagerParent* aParent); + + void PropagateRegistration(uint64_t aParentID, + ServiceWorkerRegistrationData& aData); + + void PropagateSoftUpdate(uint64_t aParentID, + const PrincipalOriginAttributes& aOriginAttributes, + const nsAString& aScope); + + void PropagateUnregister(uint64_t aParentID, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo, + const nsAString& aScope); + + void PropagateRemove(uint64_t aParentID, const nsACString& aHost); + + void PropagateRemoveAll(uint64_t aParentID); + +private: + ServiceWorkerManagerService(); + ~ServiceWorkerManagerService(); + + nsTHashtable<nsPtrHashKey<ServiceWorkerManagerParent>> mAgents; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ServiceWorkerManagerService_h diff --git a/dom/workers/ServiceWorkerPrivate.cpp b/dom/workers/ServiceWorkerPrivate.cpp new file mode 100644 index 000000000..eaa548f95 --- /dev/null +++ b/dom/workers/ServiceWorkerPrivate.cpp @@ -0,0 +1,2088 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerPrivate.h" + +#include "ServiceWorkerManager.h" +#include "nsContentUtils.h" +#include "nsIHttpChannelInternal.h" +#include "nsIHttpHeaderVisitor.h" +#include "nsINetworkInterceptController.h" +#include "nsIPushErrorReporter.h" +#include "nsISupportsImpl.h" +#include "nsIUploadChannel2.h" +#include "nsNetUtil.h" +#include "nsProxyRelease.h" +#include "nsQueryObject.h" +#include "nsStreamUtils.h" +#include "nsStringStream.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" +#include "mozilla/Assertions.h" +#include "mozilla/dom/FetchUtil.h" +#include "mozilla/dom/IndexedDatabaseManager.h" +#include "mozilla/dom/InternalHeaders.h" +#include "mozilla/dom/NotificationEvent.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/PushEventBinding.h" +#include "mozilla/dom/RequestBinding.h" +#include "mozilla/Unused.h" + +using namespace mozilla; +using namespace mozilla::dom; + +BEGIN_WORKERS_NAMESPACE + +NS_IMPL_CYCLE_COLLECTING_ADDREF(ServiceWorkerPrivate) +NS_IMPL_CYCLE_COLLECTING_RELEASE(ServiceWorkerPrivate) +NS_IMPL_CYCLE_COLLECTION(ServiceWorkerPrivate, mSupportsArray) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServiceWorkerPrivate) + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) +NS_INTERFACE_MAP_END + +// Tracks the "dom.disable_open_click_delay" preference. Modified on main +// thread, read on worker threads. +// 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 prior to dispatching the runnable. +Atomic<uint32_t> gDOMDisableOpenClickDelay(0); + +// Used to keep track of pending waitUntil as well as in-flight extendable events. +// When the last token is released, we attempt to terminate the worker. +class KeepAliveToken final : public nsISupports +{ +public: + NS_DECL_ISUPPORTS + + explicit KeepAliveToken(ServiceWorkerPrivate* aPrivate) + : mPrivate(aPrivate) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aPrivate); + mPrivate->AddToken(); + } + +private: + ~KeepAliveToken() + { + AssertIsOnMainThread(); + mPrivate->ReleaseToken(); + } + + RefPtr<ServiceWorkerPrivate> mPrivate; +}; + +NS_IMPL_ISUPPORTS0(KeepAliveToken) + +ServiceWorkerPrivate::ServiceWorkerPrivate(ServiceWorkerInfo* aInfo) + : mInfo(aInfo) + , mDebuggerCount(0) + , mTokenCount(0) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aInfo); + + mIdleWorkerTimer = do_CreateInstance(NS_TIMER_CONTRACTID); + MOZ_ASSERT(mIdleWorkerTimer); +} + +ServiceWorkerPrivate::~ServiceWorkerPrivate() +{ + MOZ_ASSERT(!mWorkerPrivate); + MOZ_ASSERT(!mTokenCount); + MOZ_ASSERT(!mInfo); + MOZ_ASSERT(mSupportsArray.IsEmpty()); + + mIdleWorkerTimer->Cancel(); +} + +namespace { + +class MessageWaitUntilHandler final : public PromiseNativeHandler +{ + nsMainThreadPtrHandle<nsISupports> mKeepAliveToken; + + ~MessageWaitUntilHandler() + { + } + +public: + explicit MessageWaitUntilHandler(const nsMainThreadPtrHandle<nsISupports>& aKeepAliveToken) + : mKeepAliveToken(aKeepAliveToken) + { + MOZ_ASSERT(mKeepAliveToken); + } + + void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + mKeepAliveToken = nullptr; + } + + void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + mKeepAliveToken = nullptr; + } + + NS_DECL_THREADSAFE_ISUPPORTS +}; + +NS_IMPL_ISUPPORTS0(MessageWaitUntilHandler) + +} // anonymous namespace + +nsresult +ServiceWorkerPrivate::SendMessageEvent(JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo) +{ + ErrorResult rv(SpawnWorkerIfNeeded(MessageEvent, nullptr)); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + nsMainThreadPtrHandle<nsISupports> token( + new nsMainThreadPtrHolder<nsISupports>(CreateEventKeepAliveToken())); + + RefPtr<PromiseNativeHandler> handler = new MessageWaitUntilHandler(token); + + mWorkerPrivate->PostMessageToServiceWorker(aCx, aMessage, aTransferable, + Move(aClientInfo), handler, + rv); + return rv.StealNSResult(); +} + +namespace { + +class CheckScriptEvaluationWithCallback final : public WorkerRunnable +{ + nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken; + RefPtr<LifeCycleEventCallback> mCallback; +#ifdef DEBUG + bool mDone; +#endif + +public: + CheckScriptEvaluationWithCallback(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken, + LifeCycleEventCallback* aCallback) + : WorkerRunnable(aWorkerPrivate) + , mKeepAliveToken(new nsMainThreadPtrHolder<KeepAliveToken>(aKeepAliveToken)) + , mCallback(aCallback) +#ifdef DEBUG + , mDone(false) +#endif + { + AssertIsOnMainThread(); + } + + ~CheckScriptEvaluationWithCallback() + { + MOZ_ASSERT(mDone); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + Done(aWorkerPrivate->WorkerScriptExecutedSuccessfully()); + + return true; + } + + nsresult + Cancel() override + { + Done(false); + return WorkerRunnable::Cancel(); + } + +private: + void + Done(bool aResult) + { +#ifdef DEBUG + mDone = true; +#endif + mCallback->SetResult(aResult); + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(mCallback)); + } +}; + +} // anonymous namespace + +nsresult +ServiceWorkerPrivate::CheckScriptEvaluation(LifeCycleEventCallback* aCallback) +{ + nsresult rv = SpawnWorkerIfNeeded(LifeCycleEvent, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + RefPtr<WorkerRunnable> r = new CheckScriptEvaluationWithCallback(mWorkerPrivate, + token, + aCallback); + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +namespace { + +// Holds the worker alive until the waitUntil promise is resolved or +// rejected. +class KeepAliveHandler final +{ + // Use an internal class to listen for the promise resolve/reject + // callbacks. This class also registers a feature so that it can + // preemptively cleanup if the service worker is timed out and + // terminated. + class InternalHandler final : public PromiseNativeHandler + , public WorkerHolder + { + nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken; + + // Worker thread only + WorkerPrivate* mWorkerPrivate; + RefPtr<Promise> mPromise; + bool mWorkerHolderAdded; + + ~InternalHandler() + { + MaybeCleanup(); + } + + bool + UseWorkerHolder() + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!mWorkerHolderAdded); + mWorkerHolderAdded = HoldWorker(mWorkerPrivate, Terminating); + return mWorkerHolderAdded; + } + + void + MaybeCleanup() + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + if (!mPromise) { + return; + } + if (mWorkerHolderAdded) { + ReleaseWorker(); + } + mPromise = nullptr; + mKeepAliveToken = nullptr; + } + + void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + MaybeCleanup(); + } + + void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + MaybeCleanup(); + } + + bool + Notify(Status aStatus) override + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + if (aStatus < Terminating) { + return true; + } + MaybeCleanup(); + return true; + } + + InternalHandler(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken, + WorkerPrivate* aWorkerPrivate, + Promise* aPromise) + : mKeepAliveToken(aKeepAliveToken) + , mWorkerPrivate(aWorkerPrivate) + , mPromise(aPromise) + , mWorkerHolderAdded(false) + { + MOZ_ASSERT(mKeepAliveToken); + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(mPromise); + } + + public: + static already_AddRefed<InternalHandler> + Create(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken, + WorkerPrivate* aWorkerPrivate, + Promise* aPromise) + { + RefPtr<InternalHandler> ref = new InternalHandler(aKeepAliveToken, + aWorkerPrivate, + aPromise); + + if (NS_WARN_IF(!ref->UseWorkerHolder())) { + return nullptr; + } + + return ref.forget(); + } + + NS_DECL_ISUPPORTS + }; + + // This is really just a wrapper class to keep the InternalHandler + // private. We don't want any code to accidentally call + // Promise::AppendNativeHandler() without also referencing the promise. + // Therefore we force all code through the static CreateAndAttachToPromise() + // and use the private InternalHandler object. + KeepAliveHandler() = delete; + ~KeepAliveHandler() = delete; + +public: + // Create a private handler object and attach it to the given Promise. + // This will also create a strong ref to the Promise in a ref cycle. The + // ref cycle is broken when the Promise is fulfilled or the worker thread + // is Terminated. + static void + CreateAndAttachToPromise(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken, + Promise* aPromise) + { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(aKeepAliveToken); + MOZ_ASSERT(aPromise); + + // This creates a strong ref to the promise. + RefPtr<InternalHandler> handler = InternalHandler::Create(aKeepAliveToken, + workerPrivate, + aPromise); + if (NS_WARN_IF(!handler)) { + return; + } + + // This then creates a strong ref cycle between the promise and the + // handler. The cycle is broken when the Promise is fulfilled or + // the worker thread is Terminated. + aPromise->AppendNativeHandler(handler); + } +}; + +NS_IMPL_ISUPPORTS0(KeepAliveHandler::InternalHandler) + +class RegistrationUpdateRunnable : public Runnable +{ + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + const bool mNeedTimeCheck; + +public: + RegistrationUpdateRunnable(nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + bool aNeedTimeCheck) + : mRegistration(aRegistration) + , mNeedTimeCheck(aNeedTimeCheck) + { + MOZ_DIAGNOSTIC_ASSERT(mRegistration); + } + + NS_IMETHOD + Run() override + { + if (mNeedTimeCheck) { + mRegistration->MaybeScheduleTimeCheckAndUpdate(); + } else { + mRegistration->MaybeScheduleUpdate(); + } + return NS_OK; + } +}; + +class ExtendableEventWorkerRunnable : public WorkerRunnable +{ +protected: + nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken; + +public: + ExtendableEventWorkerRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken) + : WorkerRunnable(aWorkerPrivate) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aKeepAliveToken); + + mKeepAliveToken = + new nsMainThreadPtrHolder<KeepAliveToken>(aKeepAliveToken); + } + + bool + DispatchExtendableEventOnWorkerScope(JSContext* aCx, + WorkerGlobalScope* aWorkerScope, + ExtendableEvent* aEvent, + PromiseNativeHandler* aPromiseHandler) + { + MOZ_ASSERT(aWorkerScope); + MOZ_ASSERT(aEvent); + nsCOMPtr<nsIGlobalObject> sgo = aWorkerScope; + WidgetEvent* internalEvent = aEvent->WidgetEventPtr(); + + ErrorResult result; + result = aWorkerScope->DispatchDOMEvent(nullptr, aEvent, nullptr, nullptr); + if (NS_WARN_IF(result.Failed()) || internalEvent->mFlags.mExceptionWasRaised) { + result.SuppressException(); + return false; + } + + RefPtr<Promise> waitUntilPromise = aEvent->GetPromise(); + if (!waitUntilPromise) { + waitUntilPromise = + Promise::Resolve(sgo, aCx, JS::UndefinedHandleValue, result); + MOZ_RELEASE_ASSERT(!result.Failed()); + } + + MOZ_ASSERT(waitUntilPromise); + + // Make sure to append the caller's promise handler before attaching + // our keep alive handler. This can avoid terminating the worker + // before a success result is delivered to the caller in cases where + // the idle timeout has been set to zero. This low timeout value is + // sometimes set in tests. + if (aPromiseHandler) { + waitUntilPromise->AppendNativeHandler(aPromiseHandler); + } + + KeepAliveHandler::CreateAndAttachToPromise(mKeepAliveToken, + waitUntilPromise); + + return true; + } +}; + +// Handle functional event +// 9.9.7 If the time difference in seconds calculated by the current time minus +// registration's last update check time is greater than 86400, invoke Soft Update +// algorithm. +class ExtendableFunctionalEventWorkerRunnable : public ExtendableEventWorkerRunnable +{ +protected: + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; +public: + ExtendableFunctionalEventWorkerRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration) + : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken) + , mRegistration(aRegistration) + { + MOZ_DIAGNOSTIC_ASSERT(aRegistration); + } + + void + PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult) + { + // Sub-class PreRun() or WorkerRun() methods could clear our mRegistration. + if (mRegistration) { + nsCOMPtr<nsIRunnable> runnable = + new RegistrationUpdateRunnable(mRegistration, true /* time check */); + aWorkerPrivate->DispatchToMainThread(runnable.forget()); + } + + ExtendableEventWorkerRunnable::PostRun(aCx, aWorkerPrivate, aRunResult); + } +}; + +/* + * Fires 'install' event on the ServiceWorkerGlobalScope. Modifies busy count + * since it fires the event. This is ok since there can't be nested + * ServiceWorkers, so the parent thread -> worker thread requirement for + * runnables is satisfied. + */ +class LifecycleEventWorkerRunnable : public ExtendableEventWorkerRunnable +{ + nsString mEventName; + RefPtr<LifeCycleEventCallback> mCallback; + +public: + LifecycleEventWorkerRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aToken, + const nsAString& aEventName, + LifeCycleEventCallback* aCallback) + : ExtendableEventWorkerRunnable(aWorkerPrivate, aToken) + , mEventName(aEventName) + , mCallback(aCallback) + { + AssertIsOnMainThread(); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + return DispatchLifecycleEvent(aCx, aWorkerPrivate); + } + + nsresult + Cancel() override + { + mCallback->SetResult(false); + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(mCallback)); + + return WorkerRunnable::Cancel(); + } + +private: + bool + DispatchLifecycleEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate); + +}; + +/* + * Used to handle ExtendableEvent::waitUntil() and catch abnormal worker + * termination during the execution of life cycle events. It is responsible + * with advancing the job queue for install/activate tasks. + */ +class LifeCycleEventWatcher final : public PromiseNativeHandler, + public WorkerHolder +{ + WorkerPrivate* mWorkerPrivate; + RefPtr<LifeCycleEventCallback> mCallback; + bool mDone; + + ~LifeCycleEventWatcher() + { + if (mDone) { + return; + } + + MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate); + // XXXcatalinb: If all the promises passed to waitUntil go out of scope, + // the resulting Promise.all will be cycle collected and it will drop its + // native handlers (including this object). Instead of waiting for a timeout + // we report the failure now. + ReportResult(false); + } + +public: + NS_DECL_ISUPPORTS + + LifeCycleEventWatcher(WorkerPrivate* aWorkerPrivate, + LifeCycleEventCallback* aCallback) + : mWorkerPrivate(aWorkerPrivate) + , mCallback(aCallback) + , mDone(false) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + bool + Init() + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + + // We need to listen for worker termination in case the event handler + // never completes or never resolves the waitUntil promise. There are + // two possible scenarios: + // 1. The keepAlive token expires and the worker is terminated, in which + // case the registration/update promise will be rejected + // 2. A new service worker is registered which will terminate the current + // installing worker. + if (NS_WARN_IF(!HoldWorker(mWorkerPrivate, Terminating))) { + NS_WARNING("LifeCycleEventWatcher failed to add feature."); + ReportResult(false); + return false; + } + + return true; + } + + bool + Notify(Status aStatus) override + { + if (aStatus < Terminating) { + return true; + } + + MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate); + ReportResult(false); + + return true; + } + + void + ReportResult(bool aResult) + { + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (mDone) { + return; + } + mDone = true; + + mCallback->SetResult(aResult); + nsresult rv = mWorkerPrivate->DispatchToMainThread(mCallback); + if (NS_WARN_IF(NS_FAILED(rv))) { + NS_RUNTIMEABORT("Failed to dispatch life cycle event handler."); + } + + ReleaseWorker(); + } + + void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + + ReportResult(true); + } + + void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + + ReportResult(false); + + // Note, all WaitUntil() rejections are reported to client consoles + // by the WaitUntilHandler in ServiceWorkerEvents. This ensures that + // errors in non-lifecycle events like FetchEvent and PushEvent are + // reported properly. + } +}; + +NS_IMPL_ISUPPORTS0(LifeCycleEventWatcher) + +bool +LifecycleEventWorkerRunnable::DispatchLifecycleEvent(JSContext* aCx, + WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + + RefPtr<ExtendableEvent> event; + RefPtr<EventTarget> target = aWorkerPrivate->GlobalScope(); + + if (mEventName.EqualsASCII("install") || mEventName.EqualsASCII("activate")) { + ExtendableEventInit init; + init.mBubbles = false; + init.mCancelable = false; + event = ExtendableEvent::Constructor(target, mEventName, init); + } else { + MOZ_CRASH("Unexpected lifecycle event"); + } + + event->SetTrusted(true); + + // It is important to initialize the watcher before actually dispatching + // the event in order to catch worker termination while the event handler + // is still executing. This can happen with infinite loops, for example. + RefPtr<LifeCycleEventWatcher> watcher = + new LifeCycleEventWatcher(aWorkerPrivate, mCallback); + + if (!watcher->Init()) { + return true; + } + + if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(), + event, watcher)) { + watcher->ReportResult(false); + } + + return true; +} + +} // anonymous namespace + +nsresult +ServiceWorkerPrivate::SendLifeCycleEvent(const nsAString& aEventType, + LifeCycleEventCallback* aCallback, + nsIRunnable* aLoadFailure) +{ + nsresult rv = SpawnWorkerIfNeeded(LifeCycleEvent, aLoadFailure); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + RefPtr<WorkerRunnable> r = new LifecycleEventWorkerRunnable(mWorkerPrivate, + token, + aEventType, + aCallback); + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +namespace { + +class PushErrorReporter final : public PromiseNativeHandler +{ + WorkerPrivate* mWorkerPrivate; + nsString mMessageId; + + ~PushErrorReporter() + { + } + +public: + NS_DECL_THREADSAFE_ISUPPORTS + + PushErrorReporter(WorkerPrivate* aWorkerPrivate, + const nsAString& aMessageId) + : mWorkerPrivate(aWorkerPrivate) + , mMessageId(aMessageId) + { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate = nullptr; + // Do nothing; we only use this to report errors to the Push service. + } + + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + Report(nsIPushErrorReporter::DELIVERY_UNHANDLED_REJECTION); + } + + void Report(uint16_t aReason = nsIPushErrorReporter::DELIVERY_INTERNAL_ERROR) + { + WorkerPrivate* workerPrivate = mWorkerPrivate; + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate = nullptr; + + if (NS_WARN_IF(aReason > nsIPushErrorReporter::DELIVERY_INTERNAL_ERROR) || + mMessageId.IsEmpty()) { + return; + } + nsCOMPtr<nsIRunnable> runnable = + NewRunnableMethod<uint16_t>(this, + &PushErrorReporter::ReportOnMainThread, aReason); + MOZ_ALWAYS_TRUE(NS_SUCCEEDED( + workerPrivate->DispatchToMainThread(runnable.forget()))); + } + + void ReportOnMainThread(uint16_t aReason) + { + AssertIsOnMainThread(); + nsCOMPtr<nsIPushErrorReporter> reporter = + do_GetService("@mozilla.org/push/Service;1"); + if (reporter) { + nsresult rv = reporter->ReportDeliveryError(mMessageId, aReason); + Unused << NS_WARN_IF(NS_FAILED(rv)); + } + } +}; + +NS_IMPL_ISUPPORTS0(PushErrorReporter) + +class SendPushEventRunnable final : public ExtendableFunctionalEventWorkerRunnable +{ + nsString mMessageId; + Maybe<nsTArray<uint8_t>> mData; + +public: + SendPushEventRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken, + const nsAString& aMessageId, + const Maybe<nsTArray<uint8_t>>& aData, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> aRegistration) + : ExtendableFunctionalEventWorkerRunnable( + aWorkerPrivate, aKeepAliveToken, aRegistration) + , mMessageId(aMessageId) + , mData(aData) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper()); + + RefPtr<PushErrorReporter> errorReporter = + new PushErrorReporter(aWorkerPrivate, mMessageId); + + PushEventInit pei; + if (mData) { + const nsTArray<uint8_t>& bytes = mData.ref(); + JSObject* data = Uint8Array::Create(aCx, bytes.Length(), bytes.Elements()); + if (!data) { + errorReporter->Report(); + return false; + } + pei.mData.Construct().SetAsArrayBufferView().Init(data); + } + pei.mBubbles = false; + pei.mCancelable = false; + + ErrorResult result; + RefPtr<PushEvent> event = + PushEvent::Constructor(globalObj, NS_LITERAL_STRING("push"), pei, result); + if (NS_WARN_IF(result.Failed())) { + result.SuppressException(); + errorReporter->Report(); + return false; + } + event->SetTrusted(true); + + if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(), + event, errorReporter)) { + errorReporter->Report(nsIPushErrorReporter::DELIVERY_UNCAUGHT_EXCEPTION); + } + + return true; + } +}; + +class SendPushSubscriptionChangeEventRunnable final : public ExtendableEventWorkerRunnable +{ + +public: + explicit SendPushSubscriptionChangeEventRunnable( + WorkerPrivate* aWorkerPrivate, KeepAliveToken* aKeepAliveToken) + : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + + RefPtr<EventTarget> target = aWorkerPrivate->GlobalScope(); + + ExtendableEventInit init; + init.mBubbles = false; + init.mCancelable = false; + + RefPtr<ExtendableEvent> event = + ExtendableEvent::Constructor(target, + NS_LITERAL_STRING("pushsubscriptionchange"), + init); + + event->SetTrusted(true); + + DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(), + event, nullptr); + + return true; + } +}; + +} // anonymous namespace + +nsresult +ServiceWorkerPrivate::SendPushEvent(const nsAString& aMessageId, + const Maybe<nsTArray<uint8_t>>& aData, + ServiceWorkerRegistrationInfo* aRegistration) +{ + nsresult rv = SpawnWorkerIfNeeded(PushEvent, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> regInfo( + new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(aRegistration, false)); + + RefPtr<WorkerRunnable> r = new SendPushEventRunnable(mWorkerPrivate, + token, + aMessageId, + aData, + regInfo); + + if (mInfo->State() == ServiceWorkerState::Activating) { + mPendingFunctionalEvents.AppendElement(r.forget()); + return NS_OK; + } + + MOZ_ASSERT(mInfo->State() == ServiceWorkerState::Activated); + + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +nsresult +ServiceWorkerPrivate::SendPushSubscriptionChangeEvent() +{ + nsresult rv = SpawnWorkerIfNeeded(PushSubscriptionChangeEvent, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + RefPtr<WorkerRunnable> r = + new SendPushSubscriptionChangeEventRunnable(mWorkerPrivate, token); + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +namespace { + +static void +DummyNotificationTimerCallback(nsITimer* aTimer, void* aClosure) +{ + // Nothing. +} + +class AllowWindowInteractionHandler; + +class ClearWindowAllowedRunnable final : public WorkerRunnable +{ +public: + ClearWindowAllowedRunnable(WorkerPrivate* aWorkerPrivate, + AllowWindowInteractionHandler* aHandler) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + , mHandler(aHandler) + { } + +private: + bool + PreDispatch(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(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // Silence bad assertions. + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override; + + nsresult + Cancel() override + { + // Always ensure the handler is released on the worker thread, even if we + // are cancelled. + mHandler = nullptr; + return WorkerRunnable::Cancel(); + } + + RefPtr<AllowWindowInteractionHandler> mHandler; +}; + +class AllowWindowInteractionHandler final : public PromiseNativeHandler +{ + friend class ClearWindowAllowedRunnable; + nsCOMPtr<nsITimer> mTimer; + + ~AllowWindowInteractionHandler() + { + } + + void + ClearWindowAllowed(WorkerPrivate* aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mTimer) { + return; + } + + // XXXcatalinb: This *might* be executed after the global was unrooted, in + // which case GlobalScope() will return null. Making the check here just + // to be safe. + WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope(); + if (!globalScope) { + return; + } + + globalScope->ConsumeWindowInteraction(); + mTimer->Cancel(); + mTimer = nullptr; + MOZ_ALWAYS_TRUE(aWorkerPrivate->ModifyBusyCountFromWorker(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; + } + + RefPtr<ClearWindowAllowedRunnable> r = + new ClearWindowAllowedRunnable(aWorkerPrivate, this); + + RefPtr<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(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(DummyNotificationTimerCallback, nullptr, + gDOMDisableOpenClickDelay, + nsITimer::TYPE_ONE_SHOT); + if (NS_WARN_IF(NS_FAILED(rv))) { + ClearWindowAllowed(aWorkerPrivate); + return; + } + } + +public: + NS_DECL_ISUPPORTS + + explicit AllowWindowInteractionHandler(WorkerPrivate* aWorkerPrivate) + { + StartClearWindowTimer(aWorkerPrivate); + } + + void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx); + ClearWindowAllowed(workerPrivate); + } + + void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx); + ClearWindowAllowed(workerPrivate); + } +}; + +NS_IMPL_ISUPPORTS0(AllowWindowInteractionHandler) + +bool +ClearWindowAllowedRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) +{ + mHandler->ClearWindowAllowed(aWorkerPrivate); + mHandler = nullptr; + return true; +} + +class SendNotificationEventRunnable final : public ExtendableEventWorkerRunnable +{ + const nsString mEventName; + const nsString mID; + const nsString mTitle; + const nsString mDir; + const nsString mLang; + const nsString mBody; + const nsString mTag; + const nsString mIcon; + const nsString mData; + const nsString mBehavior; + const nsString mScope; + +public: + SendNotificationEventRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken, + const nsAString& aEventName, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior, + const nsAString& aScope) + : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken) + , mEventName(aEventName) + , mID(aID) + , mTitle(aTitle) + , mDir(aDir) + , mLang(aLang) + , mBody(aBody) + , mTag(aTag) + , mIcon(aIcon) + , mData(aData) + , mBehavior(aBehavior) + , mScope(aScope) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + + RefPtr<EventTarget> target = do_QueryObject(aWorkerPrivate->GlobalScope()); + + ErrorResult result; + RefPtr<Notification> notification = + Notification::ConstructFromFields(aWorkerPrivate->GlobalScope(), mID, + mTitle, mDir, mLang, mBody, mTag, mIcon, + mData, mScope, result); + if (NS_WARN_IF(result.Failed())) { + return false; + } + + NotificationEventInit nei; + nei.mNotification = notification; + nei.mBubbles = false; + nei.mCancelable = false; + + RefPtr<NotificationEvent> event = + NotificationEvent::Constructor(target, mEventName, + nei, result); + if (NS_WARN_IF(result.Failed())) { + return false; + } + + event->SetTrusted(true); + aWorkerPrivate->GlobalScope()->AllowWindowInteraction(); + RefPtr<AllowWindowInteractionHandler> allowWindowInteraction = + new AllowWindowInteractionHandler(aWorkerPrivate); + if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(), + event, allowWindowInteraction)) { + allowWindowInteraction->RejectedCallback(aCx, JS::UndefinedHandleValue); + } + aWorkerPrivate->GlobalScope()->ConsumeWindowInteraction(); + + return true; + } +}; + +} // namespace anonymous + +nsresult +ServiceWorkerPrivate::SendNotificationEvent(const nsAString& aEventName, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior, + const nsAString& aScope) +{ + WakeUpReason why; + if (aEventName.EqualsLiteral(NOTIFICATION_CLICK_EVENT_NAME)) { + why = NotificationClickEvent; + gDOMDisableOpenClickDelay = Preferences::GetInt("dom.disable_open_click_delay"); + } else if (aEventName.EqualsLiteral(NOTIFICATION_CLOSE_EVENT_NAME)) { + why = NotificationCloseEvent; + } else { + MOZ_ASSERT_UNREACHABLE("Invalid notification event name"); + return NS_ERROR_FAILURE; + } + + nsresult rv = SpawnWorkerIfNeeded(why, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + + RefPtr<WorkerRunnable> r = + new SendNotificationEventRunnable(mWorkerPrivate, token, + aEventName, aID, aTitle, aDir, aLang, + aBody, aTag, aIcon, aData, aBehavior, + aScope); + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +namespace { + +// Inheriting ExtendableEventWorkerRunnable so that the worker is not terminated +// while handling the fetch event, though that's very unlikely. +class FetchEventRunnable : public ExtendableFunctionalEventWorkerRunnable + , public nsIHttpHeaderVisitor { + nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel; + const nsCString mScriptSpec; + nsTArray<nsCString> mHeaderNames; + nsTArray<nsCString> mHeaderValues; + nsCString mSpec; + nsCString mFragment; + nsCString mMethod; + nsString mClientId; + bool mIsReload; + RequestCache mCacheMode; + RequestMode mRequestMode; + RequestRedirect mRequestRedirect; + RequestCredentials mRequestCredentials; + nsContentPolicyType mContentPolicyType; + nsCOMPtr<nsIInputStream> mUploadStream; + nsCString mReferrer; + ReferrerPolicy mReferrerPolicy; + nsString mIntegrity; +public: + FetchEventRunnable(WorkerPrivate* aWorkerPrivate, + KeepAliveToken* aKeepAliveToken, + nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel, + // CSP checks might require the worker script spec + // later on. + const nsACString& aScriptSpec, + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration, + const nsAString& aDocumentId, + bool aIsReload) + : ExtendableFunctionalEventWorkerRunnable( + aWorkerPrivate, aKeepAliveToken, aRegistration) + , mInterceptedChannel(aChannel) + , mScriptSpec(aScriptSpec) + , mClientId(aDocumentId) + , mIsReload(aIsReload) + , mCacheMode(RequestCache::Default) + , mRequestMode(RequestMode::No_cors) + , mRequestRedirect(RequestRedirect::Follow) + // By default we set it to same-origin since normal HTTP fetches always + // send credentials to same-origin websites unless explicitly forbidden. + , mRequestCredentials(RequestCredentials::Same_origin) + , mContentPolicyType(nsIContentPolicy::TYPE_INVALID) + , mReferrer(kFETCH_CLIENT_REFERRER_STR) + , mReferrerPolicy(ReferrerPolicy::_empty) + { + MOZ_ASSERT(aWorkerPrivate); + } + + NS_DECL_ISUPPORTS_INHERITED + + NS_IMETHOD + VisitHeader(const nsACString& aHeader, const nsACString& aValue) override + { + mHeaderNames.AppendElement(aHeader); + mHeaderValues.AppendElement(aValue); + return NS_OK; + } + + nsresult + Init() + { + AssertIsOnMainThread(); + nsCOMPtr<nsIChannel> channel; + nsresult rv = mInterceptedChannel->GetChannel(getter_AddRefs(channel)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIURI> uri; + rv = mInterceptedChannel->GetSecureUpgradedChannelURI(getter_AddRefs(uri)); + NS_ENSURE_SUCCESS(rv, rv); + + // Normally we rely on the Request constructor to strip the fragment, but + // when creating the FetchEvent we bypass the constructor. So strip the + // fragment manually here instead. We can't do it later when we create + // the Request because that code executes off the main thread. + nsCOMPtr<nsIURI> uriNoFragment; + rv = uri->CloneIgnoringRef(getter_AddRefs(uriNoFragment)); + NS_ENSURE_SUCCESS(rv, rv); + rv = uriNoFragment->GetSpec(mSpec); + NS_ENSURE_SUCCESS(rv, rv); + rv = uri->GetRef(mFragment); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t loadFlags; + rv = channel->GetLoadFlags(&loadFlags); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsILoadInfo> loadInfo; + rv = channel->GetLoadInfo(getter_AddRefs(loadInfo)); + NS_ENSURE_SUCCESS(rv, rv); + mContentPolicyType = loadInfo->InternalContentPolicyType(); + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel); + MOZ_ASSERT(httpChannel, "How come we don't have an HTTP channel?"); + + nsAutoCString referrer; + // Ignore the return value since the Referer header may not exist. + httpChannel->GetRequestHeader(NS_LITERAL_CSTRING("Referer"), referrer); + if (!referrer.IsEmpty()) { + mReferrer = referrer; + } + + uint32_t referrerPolicy = 0; + rv = httpChannel->GetReferrerPolicy(&referrerPolicy); + NS_ENSURE_SUCCESS(rv, rv); + switch (referrerPolicy) { + case nsIHttpChannel::REFERRER_POLICY_NO_REFERRER: + mReferrerPolicy = ReferrerPolicy::No_referrer; + break; + case nsIHttpChannel::REFERRER_POLICY_ORIGIN: + mReferrerPolicy = ReferrerPolicy::Origin; + break; + case nsIHttpChannel::REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE: + mReferrerPolicy = ReferrerPolicy::No_referrer_when_downgrade; + break; + case nsIHttpChannel::REFERRER_POLICY_ORIGIN_WHEN_XORIGIN: + mReferrerPolicy = ReferrerPolicy::Origin_when_cross_origin; + break; + case nsIHttpChannel::REFERRER_POLICY_UNSAFE_URL: + mReferrerPolicy = ReferrerPolicy::Unsafe_url; + break; + default: + MOZ_ASSERT_UNREACHABLE("Invalid Referrer Policy enum value?"); + break; + } + + rv = httpChannel->GetRequestMethod(mMethod); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIHttpChannelInternal> internalChannel = do_QueryInterface(httpChannel); + NS_ENSURE_TRUE(internalChannel, NS_ERROR_NOT_AVAILABLE); + + mRequestMode = InternalRequest::MapChannelToRequestMode(channel); + + // This is safe due to static_asserts in ServiceWorkerManager.cpp. + uint32_t redirectMode; + internalChannel->GetRedirectMode(&redirectMode); + mRequestRedirect = static_cast<RequestRedirect>(redirectMode); + + // This is safe due to static_asserts in ServiceWorkerManager.cpp. + uint32_t cacheMode; + internalChannel->GetFetchCacheMode(&cacheMode); + mCacheMode = static_cast<RequestCache>(cacheMode); + + internalChannel->GetIntegrityMetadata(mIntegrity); + + mRequestCredentials = InternalRequest::MapChannelToRequestCredentials(channel); + + rv = httpChannel->VisitNonDefaultRequestHeaders(this); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(httpChannel); + if (uploadChannel) { + MOZ_ASSERT(!mUploadStream); + bool bodyHasHeaders = false; + rv = uploadChannel->GetUploadStreamHasHeaders(&bodyHasHeaders); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIInputStream> uploadStream; + rv = uploadChannel->CloneUploadStream(getter_AddRefs(uploadStream)); + NS_ENSURE_SUCCESS(rv, rv); + if (bodyHasHeaders) { + HandleBodyWithHeaders(uploadStream); + } else { + mUploadStream = uploadStream; + } + } + + return NS_OK; + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + return DispatchFetchEvent(aCx, aWorkerPrivate); + } + + nsresult + Cancel() override + { + nsCOMPtr<nsIRunnable> runnable = new ResumeRequest(mInterceptedChannel); + if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable))) { + NS_WARNING("Failed to resume channel on FetchEventRunnable::Cancel()!\n"); + } + WorkerRunnable::Cancel(); + return NS_OK; + } + +private: + ~FetchEventRunnable() {} + + class ResumeRequest final : public Runnable { + nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel; + public: + explicit ResumeRequest(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel) + : mChannel(aChannel) + { + } + + NS_IMETHOD Run() override + { + AssertIsOnMainThread(); + nsresult rv = mChannel->ResetInterception(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "Failed to resume intercepted network request"); + return rv; + } + }; + + bool + DispatchFetchEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + MOZ_ASSERT(aCx); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper()); + + RefPtr<InternalHeaders> internalHeaders = new InternalHeaders(HeadersGuardEnum::Request); + MOZ_ASSERT(mHeaderNames.Length() == mHeaderValues.Length()); + for (uint32_t i = 0; i < mHeaderNames.Length(); i++) { + ErrorResult result; + internalHeaders->Set(mHeaderNames[i], mHeaderValues[i], result); + if (NS_WARN_IF(result.Failed())) { + result.SuppressException(); + return false; + } + } + + ErrorResult result; + internalHeaders->SetGuard(HeadersGuardEnum::Immutable, result); + if (NS_WARN_IF(result.Failed())) { + result.SuppressException(); + return false; + } + RefPtr<InternalRequest> internalReq = new InternalRequest(mSpec, + mFragment, + mMethod, + internalHeaders.forget(), + mCacheMode, + mRequestMode, + mRequestRedirect, + mRequestCredentials, + NS_ConvertUTF8toUTF16(mReferrer), + mReferrerPolicy, + mContentPolicyType, + mIntegrity); + internalReq->SetBody(mUploadStream); + // For Telemetry, note that this Request object was created by a Fetch event. + internalReq->SetCreatedByFetchEvent(); + + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(globalObj.GetAsSupports()); + if (NS_WARN_IF(!global)) { + return false; + } + RefPtr<Request> request = new Request(global, internalReq); + + MOZ_ASSERT_IF(internalReq->IsNavigationRequest(), + request->Redirect() == RequestRedirect::Manual); + + RootedDictionary<FetchEventInit> init(aCx); + init.mRequest = request; + init.mBubbles = false; + init.mCancelable = true; + if (!mClientId.IsEmpty()) { + init.mClientId = mClientId; + } + init.mIsReload = mIsReload; + RefPtr<FetchEvent> event = + FetchEvent::Constructor(globalObj, NS_LITERAL_STRING("fetch"), init, result); + if (NS_WARN_IF(result.Failed())) { + result.SuppressException(); + return false; + } + + event->PostInit(mInterceptedChannel, mRegistration, mScriptSpec); + event->SetTrusted(true); + + RefPtr<EventTarget> target = do_QueryObject(aWorkerPrivate->GlobalScope()); + nsresult rv2 = target->DispatchDOMEvent(nullptr, event, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv2)) || !event->WaitToRespond()) { + nsCOMPtr<nsIRunnable> runnable; + if (event->DefaultPrevented(aCx)) { + event->ReportCanceled(); + } else if (event->WidgetEventPtr()->mFlags.mExceptionWasRaised) { + // Exception logged via the WorkerPrivate ErrorReporter + } else { + runnable = new ResumeRequest(mInterceptedChannel); + } + + if (!runnable) { + runnable = new CancelChannelRunnable(mInterceptedChannel, + mRegistration, + NS_ERROR_INTERCEPTION_FAILED); + } + + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(runnable.forget())); + } + + RefPtr<Promise> waitUntilPromise = event->GetPromise(); + if (waitUntilPromise) { + KeepAliveHandler::CreateAndAttachToPromise(mKeepAliveToken, + waitUntilPromise); + } + + return true; + } + + nsresult + HandleBodyWithHeaders(nsIInputStream* aUploadStream) + { + // We are dealing with an nsMIMEInputStream which uses string input streams + // under the hood, so all of the data is available synchronously. + bool nonBlocking = false; + nsresult rv = aUploadStream->IsNonBlocking(&nonBlocking); + NS_ENSURE_SUCCESS(rv, rv); + if (NS_WARN_IF(!nonBlocking)) { + return NS_ERROR_NOT_AVAILABLE; + } + nsAutoCString body; + rv = NS_ConsumeStream(aUploadStream, UINT32_MAX, body); + NS_ENSURE_SUCCESS(rv, rv); + + // Extract the headers in the beginning of the buffer + nsAutoCString::const_iterator begin, end; + body.BeginReading(begin); + body.EndReading(end); + const nsAutoCString::const_iterator body_end = end; + nsAutoCString headerName, headerValue; + bool emptyHeader = false; + while (FetchUtil::ExtractHeader(begin, end, headerName, + headerValue, &emptyHeader) && + !emptyHeader) { + mHeaderNames.AppendElement(headerName); + mHeaderValues.AppendElement(headerValue); + headerName.Truncate(); + headerValue.Truncate(); + } + + // Replace the upload stream with one only containing the body text. + nsCOMPtr<nsIStringInputStream> strStream = + do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + // Skip past the "\r\n" that separates the headers and the body. + ++begin; + ++begin; + body.Assign(Substring(begin, body_end)); + rv = strStream->SetData(body.BeginReading(), body.Length()); + NS_ENSURE_SUCCESS(rv, rv); + mUploadStream = strStream; + + return NS_OK; + } +}; + +NS_IMPL_ISUPPORTS_INHERITED(FetchEventRunnable, WorkerRunnable, nsIHttpHeaderVisitor) + +} // anonymous namespace + +nsresult +ServiceWorkerPrivate::SendFetchEvent(nsIInterceptedChannel* aChannel, + nsILoadGroup* aLoadGroup, + const nsAString& aDocumentId, + bool aIsReload) +{ + AssertIsOnMainThread(); + + // if the ServiceWorker script fails to load for some reason, just resume + // the original channel. + nsCOMPtr<nsIRunnable> failRunnable = + NewRunnableMethod(aChannel, &nsIInterceptedChannel::ResetInterception); + + nsresult rv = SpawnWorkerIfNeeded(FetchEvent, failRunnable, aLoadGroup); + NS_ENSURE_SUCCESS(rv, rv); + + nsMainThreadPtrHandle<nsIInterceptedChannel> handle( + new nsMainThreadPtrHolder<nsIInterceptedChannel>(aChannel, false)); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (NS_WARN_IF(!mInfo || !swm)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(mInfo->GetPrincipal(), mInfo->Scope()); + + // Its possible the registration is removed between starting the interception + // and actually dispatching the fetch event. In these cases we simply + // want to restart the original network request. Since this is a normal + // condition we handle the reset here instead of returning an error which + // would in turn trigger a console report. + if (!registration) { + aChannel->ResetInterception(); + return NS_OK; + } + + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> regInfo( + new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(registration, false)); + + RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken(); + + RefPtr<FetchEventRunnable> r = + new FetchEventRunnable(mWorkerPrivate, token, handle, + mInfo->ScriptSpec(), regInfo, + aDocumentId, aIsReload); + rv = r->Init(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (mInfo->State() == ServiceWorkerState::Activating) { + mPendingFunctionalEvents.AppendElement(r.forget()); + return NS_OK; + } + + MOZ_ASSERT(mInfo->State() == ServiceWorkerState::Activated); + + if (NS_WARN_IF(!r->Dispatch())) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +nsresult +ServiceWorkerPrivate::SpawnWorkerIfNeeded(WakeUpReason aWhy, + nsIRunnable* aLoadFailedRunnable, + nsILoadGroup* aLoadGroup) +{ + AssertIsOnMainThread(); + + // XXXcatalinb: We need to have a separate load group that's linked to + // an existing tab child to pass security checks on b2g. + // This should be fixed in bug 1125961, but for now we enforce updating + // the overriden load group when intercepting a fetch. + MOZ_ASSERT_IF(aWhy == FetchEvent, aLoadGroup); + + if (mWorkerPrivate) { + mWorkerPrivate->UpdateOverridenLoadGroup(aLoadGroup); + RenewKeepAliveToken(aWhy); + + return NS_OK; + } + + // Sanity check: mSupportsArray should be empty if we're about to + // spin up a new worker. + MOZ_ASSERT(mSupportsArray.IsEmpty()); + + if (NS_WARN_IF(!mInfo)) { + NS_WARNING("Trying to wake up a dead service worker."); + return NS_ERROR_FAILURE; + } + + // TODO(catalinb): Bug 1192138 - Add telemetry for service worker wake-ups. + + // Ensure that the IndexedDatabaseManager is initialized + Unused << NS_WARN_IF(!IndexedDatabaseManager::GetOrCreate()); + + WorkerLoadInfo info; + nsresult rv = NS_NewURI(getter_AddRefs(info.mBaseURI), mInfo->ScriptSpec(), + nullptr, nullptr); + + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + info.mResolvedScriptURI = info.mBaseURI; + MOZ_ASSERT(!mInfo->CacheName().IsEmpty()); + info.mServiceWorkerCacheName = mInfo->CacheName(); + info.mServiceWorkerID = mInfo->ID(); + info.mLoadGroup = aLoadGroup; + info.mLoadFailedAsyncRunnable = aLoadFailedRunnable; + + rv = info.mBaseURI->GetHost(info.mDomain); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + info.mPrincipal = mInfo->GetPrincipal(); + + nsContentUtils::StorageAccess access = + nsContentUtils::StorageAllowedForPrincipal(info.mPrincipal); + info.mStorageAllowed = access > nsContentUtils::StorageAccess::ePrivateBrowsing; + info.mOriginAttributes = mInfo->GetOriginAttributes(); + + nsCOMPtr<nsIContentSecurityPolicy> csp; + rv = info.mPrincipal->GetCsp(getter_AddRefs(csp)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + info.mCSP = csp; + if (info.mCSP) { + rv = info.mCSP->GetAllowsEval(&info.mReportCSPViolations, + &info.mEvalAllowed); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } else { + info.mEvalAllowed = true; + info.mReportCSPViolations = false; + } + + WorkerPrivate::OverrideLoadInfoLoadGroup(info); + + AutoJSAPI jsapi; + jsapi.Init(); + ErrorResult error; + NS_ConvertUTF8toUTF16 scriptSpec(mInfo->ScriptSpec()); + + mWorkerPrivate = WorkerPrivate::Constructor(jsapi.cx(), + scriptSpec, + false, WorkerTypeService, + mInfo->Scope(), &info, error); + if (NS_WARN_IF(error.Failed())) { + return error.StealNSResult(); + } + + RenewKeepAliveToken(aWhy); + + return NS_OK; +} + +void +ServiceWorkerPrivate::StoreISupports(nsISupports* aSupports) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(!mSupportsArray.Contains(aSupports)); + + mSupportsArray.AppendElement(aSupports); +} + +void +ServiceWorkerPrivate::RemoveISupports(nsISupports* aSupports) +{ + AssertIsOnMainThread(); + mSupportsArray.RemoveElement(aSupports); +} + +void +ServiceWorkerPrivate::TerminateWorker() +{ + AssertIsOnMainThread(); + + mIdleWorkerTimer->Cancel(); + mIdleKeepAliveToken = nullptr; + if (mWorkerPrivate) { + if (Preferences::GetBool("dom.serviceWorkers.testing.enabled")) { + nsCOMPtr<nsIObserverService> os = services::GetObserverService(); + if (os) { + os->NotifyObservers(this, "service-worker-shutdown", nullptr); + } + } + + Unused << NS_WARN_IF(!mWorkerPrivate->Terminate()); + mWorkerPrivate = nullptr; + mSupportsArray.Clear(); + + // Any pending events are never going to fire on this worker. Cancel + // them so that intercepted channels can be reset and other resources + // cleaned up. + nsTArray<RefPtr<WorkerRunnable>> pendingEvents; + mPendingFunctionalEvents.SwapElements(pendingEvents); + for (uint32_t i = 0; i < pendingEvents.Length(); ++i) { + pendingEvents[i]->Cancel(); + } + } +} + +void +ServiceWorkerPrivate::NoteDeadServiceWorkerInfo() +{ + AssertIsOnMainThread(); + mInfo = nullptr; + TerminateWorker(); +} + +void +ServiceWorkerPrivate::Activated() +{ + AssertIsOnMainThread(); + + // If we had to queue up events due to the worker activating, that means + // the worker must be currently running. We should be called synchronously + // when the worker becomes activated. + MOZ_ASSERT_IF(!mPendingFunctionalEvents.IsEmpty(), mWorkerPrivate); + + nsTArray<RefPtr<WorkerRunnable>> pendingEvents; + mPendingFunctionalEvents.SwapElements(pendingEvents); + + for (uint32_t i = 0; i < pendingEvents.Length(); ++i) { + RefPtr<WorkerRunnable> r = pendingEvents[i].forget(); + if (NS_WARN_IF(!r->Dispatch())) { + NS_WARNING("Failed to dispatch pending functional event!"); + } + } +} + +nsresult +ServiceWorkerPrivate::GetDebugger(nsIWorkerDebugger** aResult) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aResult); + + if (!mDebuggerCount) { + return NS_OK; + } + + MOZ_ASSERT(mWorkerPrivate); + + nsCOMPtr<nsIWorkerDebugger> debugger = do_QueryInterface(mWorkerPrivate->Debugger()); + debugger.forget(aResult); + + return NS_OK; +} + +nsresult +ServiceWorkerPrivate::AttachDebugger() +{ + AssertIsOnMainThread(); + + // When the first debugger attaches to a worker, we spawn a worker if needed, + // and cancel the idle timeout. The idle timeout should not be reset until + // the last debugger detached from the worker. + if (!mDebuggerCount) { + nsresult rv = SpawnWorkerIfNeeded(AttachEvent, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + mIdleWorkerTimer->Cancel(); + } + + ++mDebuggerCount; + + return NS_OK; +} + +nsresult +ServiceWorkerPrivate::DetachDebugger() +{ + AssertIsOnMainThread(); + + if (!mDebuggerCount) { + return NS_ERROR_UNEXPECTED; + } + + --mDebuggerCount; + + // When the last debugger detaches from a worker, we either reset the idle + // timeout, or terminate the worker if there are no more active tokens. + if (!mDebuggerCount) { + if (mTokenCount) { + ResetIdleTimeout(); + } else { + TerminateWorker(); + } + } + + return NS_OK; +} + +bool +ServiceWorkerPrivate::IsIdle() const +{ + AssertIsOnMainThread(); + return mTokenCount == 0 || (mTokenCount == 1 && mIdleKeepAliveToken); +} + +namespace { + +class ServiceWorkerPrivateTimerCallback final : public nsITimerCallback +{ +public: + typedef void (ServiceWorkerPrivate::*Method)(nsITimer*); + + ServiceWorkerPrivateTimerCallback(ServiceWorkerPrivate* aServiceWorkerPrivate, + Method aMethod) + : mServiceWorkerPrivate(aServiceWorkerPrivate) + , mMethod(aMethod) + { + } + + NS_IMETHOD + Notify(nsITimer* aTimer) override + { + (mServiceWorkerPrivate->*mMethod)(aTimer); + mServiceWorkerPrivate = nullptr; + return NS_OK; + } + +private: + ~ServiceWorkerPrivateTimerCallback() = default; + + RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate; + Method mMethod; + + NS_DECL_THREADSAFE_ISUPPORTS +}; + +NS_IMPL_ISUPPORTS(ServiceWorkerPrivateTimerCallback, nsITimerCallback); + +} // anonymous namespace + +void +ServiceWorkerPrivate::NoteIdleWorkerCallback(nsITimer* aTimer) +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(aTimer == mIdleWorkerTimer, "Invalid timer!"); + + // Release ServiceWorkerPrivate's token, since the grace period has ended. + mIdleKeepAliveToken = nullptr; + + if (mWorkerPrivate) { + // If we still have a workerPrivate at this point it means there are pending + // waitUntil promises. Wait a bit more until we forcibly terminate the + // worker. + uint32_t timeout = Preferences::GetInt("dom.serviceWorkers.idle_extended_timeout"); + nsCOMPtr<nsITimerCallback> cb = new ServiceWorkerPrivateTimerCallback( + this, &ServiceWorkerPrivate::TerminateWorkerCallback); + DebugOnly<nsresult> rv = + mIdleWorkerTimer->InitWithCallback(cb, timeout, nsITimer::TYPE_ONE_SHOT); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } +} + +void +ServiceWorkerPrivate::TerminateWorkerCallback(nsITimer* aTimer) +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(aTimer == this->mIdleWorkerTimer, "Invalid timer!"); + + // mInfo must be non-null at this point because NoteDeadServiceWorkerInfo + // which zeroes it calls TerminateWorker which cancels our timer which will + // ensure we don't get invoked even if the nsTimerEvent is in the event queue. + ServiceWorkerManager::LocalizeAndReportToAllClients( + mInfo->Scope(), + "ServiceWorkerGraceTimeoutTermination", + nsTArray<nsString> { NS_ConvertUTF8toUTF16(mInfo->Scope()) }); + + TerminateWorker(); +} + +void +ServiceWorkerPrivate::RenewKeepAliveToken(WakeUpReason aWhy) +{ + // We should have an active worker if we're renewing the keep alive token. + MOZ_ASSERT(mWorkerPrivate); + + // If there is at least one debugger attached to the worker, the idle worker + // timeout was canceled when the first debugger attached to the worker. It + // should not be reset until the last debugger detaches from the worker. + if (!mDebuggerCount) { + ResetIdleTimeout(); + } + + if (!mIdleKeepAliveToken) { + mIdleKeepAliveToken = new KeepAliveToken(this); + } +} + +void +ServiceWorkerPrivate::ResetIdleTimeout() +{ + uint32_t timeout = Preferences::GetInt("dom.serviceWorkers.idle_timeout"); + nsCOMPtr<nsITimerCallback> cb = new ServiceWorkerPrivateTimerCallback( + this, &ServiceWorkerPrivate::NoteIdleWorkerCallback); + DebugOnly<nsresult> rv = + mIdleWorkerTimer->InitWithCallback(cb, timeout, nsITimer::TYPE_ONE_SHOT); + MOZ_ASSERT(NS_SUCCEEDED(rv)); +} + +void +ServiceWorkerPrivate::AddToken() +{ + AssertIsOnMainThread(); + ++mTokenCount; +} + +void +ServiceWorkerPrivate::ReleaseToken() +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(mTokenCount > 0); + --mTokenCount; + if (!mTokenCount) { + TerminateWorker(); + } + + // mInfo can be nullptr here if NoteDeadServiceWorkerInfo() is called while + // the KeepAliveToken is being proxy released as a runnable. + else if (mInfo && IsIdle()) { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->WorkerIsIdle(mInfo); + } + } +} + +already_AddRefed<KeepAliveToken> +ServiceWorkerPrivate::CreateEventKeepAliveToken() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(mIdleKeepAliveToken); + RefPtr<KeepAliveToken> ref = new KeepAliveToken(this); + return ref.forget(); +} + +void +ServiceWorkerPrivate::AddPendingWindow(Runnable* aPendingWindow) +{ + AssertIsOnMainThread(); + pendingWindows.AppendElement(aPendingWindow); +} + +nsresult +ServiceWorkerPrivate::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData) +{ + AssertIsOnMainThread(); + + nsCString topic(aTopic); + if (!topic.Equals(NS_LITERAL_CSTRING("BrowserChrome:Ready"))) { + MOZ_ASSERT(false, "Unexpected topic."); + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIObserverService> os = services::GetObserverService(); + NS_ENSURE_STATE(os); + os->RemoveObserver(static_cast<nsIObserver*>(this), "BrowserChrome:Ready"); + + size_t len = pendingWindows.Length(); + for (int i = len-1; i >= 0; i--) { + RefPtr<Runnable> runnable = pendingWindows[i]; + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable)); + pendingWindows.RemoveElementAt(i); + } + + return NS_OK; +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerPrivate.h b/dom/workers/ServiceWorkerPrivate.h new file mode 100644 index 000000000..8d59ea1d0 --- /dev/null +++ b/dom/workers/ServiceWorkerPrivate.h @@ -0,0 +1,236 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerprivate_h +#define mozilla_dom_workers_serviceworkerprivate_h + +#include "nsCOMPtr.h" + +#include "WorkerPrivate.h" + +#define NOTIFICATION_CLICK_EVENT_NAME "notificationclick" +#define NOTIFICATION_CLOSE_EVENT_NAME "notificationclose" + +class nsIInterceptedChannel; + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerInfo; +class ServiceWorkerRegistrationInfo; +class KeepAliveToken; + +class LifeCycleEventCallback : public Runnable +{ +public: + // Called on the worker thread. + virtual void + SetResult(bool aResult) = 0; +}; + +// ServiceWorkerPrivate is a wrapper for managing the on-demand aspect of +// service workers. It handles all event dispatching to the worker and ensures +// the worker thread is running when needed. +// +// Lifetime management: To spin up the worker thread we own a |WorkerPrivate| +// object which can be cancelled if no events are received for a certain +// amount of time. The worker is kept alive by holding a |KeepAliveToken| +// reference. +// +// Extendable events hold tokens for the duration of their handler execution +// and until their waitUntil promise is resolved, while ServiceWorkerPrivate +// will hold a token for |dom.serviceWorkers.idle_timeout| seconds after each +// new event. +// +// Note: All timer events must be handled on the main thread because the +// worker may block indefinitely the worker thread (e. g. infinite loop in the +// script). +// +// There are 3 cases where we may ignore keep alive tokens: +// 1. When ServiceWorkerPrivate's token expired, if there are still waitUntil +// handlers holding tokens, we wait another |dom.serviceWorkers.idle_extended_timeout| +// seconds before forcibly terminating the worker. +// 2. If the worker stopped controlling documents and it is not handling push +// events. +// 3. The content process is shutting down. +// +// Adding an API function for a new event requires calling |SpawnWorkerIfNeeded| +// with an appropriate reason before any runnable is dispatched to the worker. +// If the event is extendable then the runnable should inherit +// ExtendableEventWorkerRunnable. +class ServiceWorkerPrivate final : public nsIObserver +{ + friend class KeepAliveToken; + +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(ServiceWorkerPrivate) + NS_DECL_NSIOBSERVER + + explicit ServiceWorkerPrivate(ServiceWorkerInfo* aInfo); + + nsresult + SendMessageEvent(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo); + + // This is used to validate the worker script and continue the installation + // process. + nsresult + CheckScriptEvaluation(LifeCycleEventCallback* aCallback); + + nsresult + SendLifeCycleEvent(const nsAString& aEventType, + LifeCycleEventCallback* aCallback, + nsIRunnable* aLoadFailure); + + nsresult + SendPushEvent(const nsAString& aMessageId, + const Maybe<nsTArray<uint8_t>>& aData, + ServiceWorkerRegistrationInfo* aRegistration); + + nsresult + SendPushSubscriptionChangeEvent(); + + nsresult + SendNotificationEvent(const nsAString& aEventName, + const nsAString& aID, + const nsAString& aTitle, + const nsAString& aDir, + const nsAString& aLang, + const nsAString& aBody, + const nsAString& aTag, + const nsAString& aIcon, + const nsAString& aData, + const nsAString& aBehavior, + const nsAString& aScope); + + nsresult + SendFetchEvent(nsIInterceptedChannel* aChannel, + nsILoadGroup* aLoadGroup, + const nsAString& aDocumentId, + bool aIsReload); + + void + StoreISupports(nsISupports* aSupports); + + void + RemoveISupports(nsISupports* aSupports); + + // This will terminate the current running worker thread and drop the + // workerPrivate reference. + // Called by ServiceWorkerInfo when [[Clear Registration]] is invoked + // or whenever the spec mandates that we terminate the worker. + // This is a no-op if the worker has already been stopped. + void + TerminateWorker(); + + void + NoteDeadServiceWorkerInfo(); + + void + NoteStoppedControllingDocuments(); + + void + Activated(); + + nsresult + GetDebugger(nsIWorkerDebugger** aResult); + + nsresult + AttachDebugger(); + + nsresult + DetachDebugger(); + + bool + IsIdle() const; + + void + AddPendingWindow(Runnable* aPendingWindow); + +private: + enum WakeUpReason { + FetchEvent = 0, + PushEvent, + PushSubscriptionChangeEvent, + MessageEvent, + NotificationClickEvent, + NotificationCloseEvent, + LifeCycleEvent, + AttachEvent + }; + + // Timer callbacks + void + NoteIdleWorkerCallback(nsITimer* aTimer); + + void + TerminateWorkerCallback(nsITimer* aTimer); + + void + RenewKeepAliveToken(WakeUpReason aWhy); + + void + ResetIdleTimeout(); + + void + AddToken(); + + void + ReleaseToken(); + + // |aLoadFailedRunnable| is a runnable dispatched to the main thread + // if the script loader failed for some reason, but can be null. + nsresult + SpawnWorkerIfNeeded(WakeUpReason aWhy, + nsIRunnable* aLoadFailedRunnable, + nsILoadGroup* aLoadGroup = nullptr); + + ~ServiceWorkerPrivate(); + + already_AddRefed<KeepAliveToken> + CreateEventKeepAliveToken(); + + // The info object owns us. It is possible to outlive it for a brief period + // of time if there are pending waitUntil promises, in which case it + // will be null and |SpawnWorkerIfNeeded| will always fail. + ServiceWorkerInfo* MOZ_NON_OWNING_REF mInfo; + + // The WorkerPrivate object can only be closed by this class or by the + // RuntimeService class if gecko is shutting down. Closing the worker + // multiple times is OK, since the second attempt will be a no-op. + RefPtr<WorkerPrivate> mWorkerPrivate; + + nsCOMPtr<nsITimer> mIdleWorkerTimer; + + // We keep a token for |dom.serviceWorkers.idle_timeout| seconds to give the + // worker a grace period after each event. + RefPtr<KeepAliveToken> mIdleKeepAliveToken; + + uint64_t mDebuggerCount; + + uint64_t mTokenCount; + + // Meant for keeping objects alive while handling requests from the worker + // on the main thread. Access to this array is provided through + // |StoreISupports| and |RemoveISupports|. Note that the array is also + // cleared whenever the worker is terminated. + nsTArray<nsCOMPtr<nsISupports>> mSupportsArray; + + // Array of function event worker runnables that are pending due to + // the worker activating. Main thread only. + nsTArray<RefPtr<WorkerRunnable>> mPendingFunctionalEvents; + + nsTArray<Runnable*> pendingWindows; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerprivate_h diff --git a/dom/workers/ServiceWorkerRegisterJob.cpp b/dom/workers/ServiceWorkerRegisterJob.cpp new file mode 100644 index 000000000..8f771e762 --- /dev/null +++ b/dom/workers/ServiceWorkerRegisterJob.cpp @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerRegisterJob.h" + +#include "Workers.h" + +namespace mozilla { +namespace dom { +namespace workers { + +ServiceWorkerRegisterJob::ServiceWorkerRegisterJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup) + : ServiceWorkerUpdateJob(Type::Register, aPrincipal, aScope, aScriptSpec, + aLoadGroup) +{ +} + +void +ServiceWorkerRegisterJob::AsyncExecute() +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (Canceled() || !swm) { + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(mPrincipal, mScope); + + if (registration) { + // If we are resurrecting an uninstalling registration, then persist + // it to disk again. We preemptively removed it earlier during + // unregister so that closing the window by shutting down the browser + // results in the registration being gone on restart. + if (registration->mPendingUninstall) { + swm->StoreRegistration(mPrincipal, registration); + } + registration->mPendingUninstall = false; + RefPtr<ServiceWorkerInfo> newest = registration->Newest(); + if (newest && mScriptSpec.Equals(newest->ScriptSpec())) { + SetRegistration(registration); + Finish(NS_OK); + return; + } + } else { + registration = swm->CreateNewRegistration(mScope, mPrincipal); + } + + SetRegistration(registration); + Update(); +} + +ServiceWorkerRegisterJob::~ServiceWorkerRegisterJob() +{ +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerRegisterJob.h b/dom/workers/ServiceWorkerRegisterJob.h new file mode 100644 index 000000000..a459e25b6 --- /dev/null +++ b/dom/workers/ServiceWorkerRegisterJob.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerregisterjob_h +#define mozilla_dom_workers_serviceworkerregisterjob_h + +#include "ServiceWorkerUpdateJob.h" + +namespace mozilla { +namespace dom { +namespace workers { + +// The register job. This implements the steps in the spec Register algorithm, +// but then uses ServiceWorkerUpdateJob to implement the Update and Install +// spec algorithms. +class ServiceWorkerRegisterJob final : public ServiceWorkerUpdateJob +{ +public: + ServiceWorkerRegisterJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup); + +private: + // Implement the Register algorithm steps and then call the parent class + // Update() to complete the job execution. + virtual void + AsyncExecute() override; + + virtual ~ServiceWorkerRegisterJob(); +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerregisterjob_h diff --git a/dom/workers/ServiceWorkerRegistrar.cpp b/dom/workers/ServiceWorkerRegistrar.cpp new file mode 100644 index 000000000..a4757ea54 --- /dev/null +++ b/dom/workers/ServiceWorkerRegistrar.cpp @@ -0,0 +1,884 @@ + +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerRegistrar.h" +#include "mozilla/dom/ServiceWorkerRegistrarTypes.h" + +#include "nsIEventTarget.h" +#include "nsIInputStream.h" +#include "nsILineInputStream.h" +#include "nsIObserverService.h" +#include "nsIOutputStream.h" +#include "nsISafeOutputStream.h" + +#include "MainThreadUtils.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ModuleUtils.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPtr.h" +#include "nsAppDirectoryServiceDefs.h" +#include "nsContentUtils.h" +#include "nsDirectoryServiceUtils.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsThreadUtils.h" +#include "nsXULAppAPI.h" + +using namespace mozilla::ipc; + +namespace mozilla { +namespace dom { + +namespace { + +static const char* gSupportedRegistrarVersions[] = { + SERVICEWORKERREGISTRAR_VERSION, + "3", + "2" +}; + +StaticRefPtr<ServiceWorkerRegistrar> gServiceWorkerRegistrar; + +} // namespace + +NS_IMPL_ISUPPORTS(ServiceWorkerRegistrar, + nsIObserver) + +void +ServiceWorkerRegistrar::Initialize() +{ + MOZ_ASSERT(!gServiceWorkerRegistrar); + + if (!XRE_IsParentProcess()) { + return; + } + + gServiceWorkerRegistrar = new ServiceWorkerRegistrar(); + ClearOnShutdown(&gServiceWorkerRegistrar); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + DebugOnly<nsresult> rv = obs->AddObserver(gServiceWorkerRegistrar, + "profile-after-change", false); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + + rv = obs->AddObserver(gServiceWorkerRegistrar, "profile-before-change", + false); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } +} + +/* static */ already_AddRefed<ServiceWorkerRegistrar> +ServiceWorkerRegistrar::Get() +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + MOZ_ASSERT(gServiceWorkerRegistrar); + RefPtr<ServiceWorkerRegistrar> service = gServiceWorkerRegistrar.get(); + return service.forget(); +} + +ServiceWorkerRegistrar::ServiceWorkerRegistrar() + : mMonitor("ServiceWorkerRegistrar.mMonitor") + , mDataLoaded(false) + , mShuttingDown(false) + , mShutdownCompleteFlag(nullptr) + , mRunnableCounter(0) +{ + MOZ_ASSERT(NS_IsMainThread()); +} + +ServiceWorkerRegistrar::~ServiceWorkerRegistrar() +{ + MOZ_ASSERT(!mRunnableCounter); +} + +void +ServiceWorkerRegistrar::GetRegistrations( + nsTArray<ServiceWorkerRegistrationData>& aValues) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aValues.IsEmpty()); + + MonitorAutoLock lock(mMonitor); + + // If we don't have the profile directory, profile is not started yet (and + // probably we are in a utest). + if (!mProfileDir) { + return; + } + + // We care just about the first execution because this can be blocked by + // loading data from disk. + static bool firstTime = true; + TimeStamp startTime; + + if (firstTime) { + startTime = TimeStamp::NowLoRes(); + } + + // Waiting for data loaded. + mMonitor.AssertCurrentThreadOwns(); + while (!mDataLoaded) { + mMonitor.Wait(); + } + + aValues.AppendElements(mData); + + if (firstTime) { + firstTime = false; + Telemetry::AccumulateTimeDelta( + Telemetry::SERVICE_WORKER_REGISTRATION_LOADING, + startTime); + } +} + +namespace { + +bool Equivalent(const ServiceWorkerRegistrationData& aLeft, + const ServiceWorkerRegistrationData& aRight) +{ + MOZ_ASSERT(aLeft.principal().type() == + mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); + MOZ_ASSERT(aRight.principal().type() == + mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); + + const auto& leftPrincipal = aLeft.principal().get_ContentPrincipalInfo(); + const auto& rightPrincipal = aRight.principal().get_ContentPrincipalInfo(); + + // Only compare the attributes, not the spec part of the principal. + // The scope comparison above already covers the origin and codebase + // principals include the full path in their spec which is not what + // we want here. + return aLeft.scope() == aRight.scope() && + leftPrincipal.attrs() == rightPrincipal.attrs(); +} + +} // anonymous namespace + +void +ServiceWorkerRegistrar::RegisterServiceWorker( + const ServiceWorkerRegistrationData& aData) +{ + AssertIsOnBackgroundThread(); + + if (mShuttingDown) { + NS_WARNING("Failed to register a serviceWorker during shutting down."); + return; + } + + { + MonitorAutoLock lock(mMonitor); + MOZ_ASSERT(mDataLoaded); + RegisterServiceWorkerInternal(aData); + } + + ScheduleSaveData(); +} + +void +ServiceWorkerRegistrar::UnregisterServiceWorker( + const PrincipalInfo& aPrincipalInfo, + const nsACString& aScope) +{ + AssertIsOnBackgroundThread(); + + if (mShuttingDown) { + NS_WARNING("Failed to unregister a serviceWorker during shutting down."); + return; + } + + bool deleted = false; + + { + MonitorAutoLock lock(mMonitor); + MOZ_ASSERT(mDataLoaded); + + ServiceWorkerRegistrationData tmp; + tmp.principal() = aPrincipalInfo; + tmp.scope() = aScope; + + for (uint32_t i = 0; i < mData.Length(); ++i) { + if (Equivalent(tmp, mData[i])) { + mData.RemoveElementAt(i); + deleted = true; + break; + } + } + } + + if (deleted) { + ScheduleSaveData(); + } +} + +void +ServiceWorkerRegistrar::RemoveAll() +{ + AssertIsOnBackgroundThread(); + + if (mShuttingDown) { + NS_WARNING("Failed to remove all the serviceWorkers during shutting down."); + return; + } + + bool deleted = false; + + { + MonitorAutoLock lock(mMonitor); + MOZ_ASSERT(mDataLoaded); + + deleted = !mData.IsEmpty(); + mData.Clear(); + } + + if (deleted) { + ScheduleSaveData(); + } +} + +void +ServiceWorkerRegistrar::LoadData() +{ + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(!mDataLoaded); + + nsresult rv = ReadData(); + + if (NS_WARN_IF(NS_FAILED(rv))) { + DeleteData(); + // Also if the reading failed we have to notify what is waiting for data. + } + + MonitorAutoLock lock(mMonitor); + MOZ_ASSERT(!mDataLoaded); + mDataLoaded = true; + mMonitor.Notify(); +} + +nsresult +ServiceWorkerRegistrar::ReadData() +{ + // We cannot assert about the correct thread because normally this method + // runs on a IO thread, but in gTests we call it from the main-thread. + + nsCOMPtr<nsIFile> file; + + { + MonitorAutoLock lock(mMonitor); + + if (!mProfileDir) { + return NS_ERROR_FAILURE; + } + + nsresult rv = mProfileDir->Clone(getter_AddRefs(file)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + nsresult rv = file->Append(NS_LITERAL_STRING(SERVICEWORKERREGISTRAR_FILE)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + bool exists; + rv = file->Exists(&exists); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (!exists) { + return NS_OK; + } + + nsCOMPtr<nsIInputStream> stream; + rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsILineInputStream> lineInputStream = do_QueryInterface(stream); + MOZ_ASSERT(lineInputStream); + + nsAutoCString version; + bool hasMoreLines; + rv = lineInputStream->ReadLine(version, &hasMoreLines); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (!IsSupportedVersion(version)) { + nsContentUtils::LogMessageToConsole(nsPrintfCString( + "Unsupported service worker registrar version: %s", version.get()).get()); + return NS_ERROR_FAILURE; + } + + nsTArray<ServiceWorkerRegistrationData> tmpData; + + bool overwrite = false; + bool dedupe = false; + while (hasMoreLines) { + ServiceWorkerRegistrationData* entry = tmpData.AppendElement(); + +#define GET_LINE(x) \ + rv = lineInputStream->ReadLine(x, &hasMoreLines); \ + if (NS_WARN_IF(NS_FAILED(rv))) { \ + return rv; \ + } \ + if (NS_WARN_IF(!hasMoreLines)) { \ + return NS_ERROR_FAILURE; \ + } + + nsAutoCString line; + nsAutoCString unused; + if (version.EqualsLiteral(SERVICEWORKERREGISTRAR_VERSION)) { + nsAutoCString suffix; + GET_LINE(suffix); + + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(suffix)) { + return NS_ERROR_INVALID_ARG; + } + + GET_LINE(entry->scope()); + + entry->principal() = + mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope()); + + GET_LINE(entry->currentWorkerURL()); + + nsAutoCString cacheName; + GET_LINE(cacheName); + CopyUTF8toUTF16(cacheName, entry->cacheName()); + } else if (version.EqualsLiteral("3")) { + overwrite = true; + dedupe = true; + + nsAutoCString suffix; + GET_LINE(suffix); + + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(suffix)) { + return NS_ERROR_INVALID_ARG; + } + + // principal spec is no longer used; we use scope directly instead + GET_LINE(unused); + + GET_LINE(entry->scope()); + + entry->principal() = + mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope()); + + GET_LINE(entry->currentWorkerURL()); + + nsAutoCString cacheName; + GET_LINE(cacheName); + CopyUTF8toUTF16(cacheName, entry->cacheName()); + } else if (version.EqualsLiteral("2")) { + overwrite = true; + dedupe = true; + + nsAutoCString suffix; + GET_LINE(suffix); + + PrincipalOriginAttributes attrs; + if (!attrs.PopulateFromSuffix(suffix)) { + return NS_ERROR_INVALID_ARG; + } + + // principal spec is no longer used; we use scope directly instead + GET_LINE(unused); + + GET_LINE(entry->scope()); + + entry->principal() = + mozilla::ipc::ContentPrincipalInfo(attrs, void_t(), entry->scope()); + + // scriptSpec is no more used in latest version. + GET_LINE(unused); + + GET_LINE(entry->currentWorkerURL()); + + nsAutoCString cacheName; + GET_LINE(cacheName); + CopyUTF8toUTF16(cacheName, entry->cacheName()); + + // waitingCacheName is no more used in latest version. + GET_LINE(unused); + } else { + MOZ_ASSERT_UNREACHABLE("Should never get here!"); + } + +#undef GET_LINE + + rv = lineInputStream->ReadLine(line, &hasMoreLines); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (!line.EqualsLiteral(SERVICEWORKERREGISTRAR_TERMINATOR)) { + return NS_ERROR_FAILURE; + } + } + + stream->Close(); + + // Copy data over to mData. + for (uint32_t i = 0; i < tmpData.Length(); ++i) { + bool match = false; + if (dedupe) { + MOZ_ASSERT(overwrite); + // If this is an old profile, then we might need to deduplicate. In + // theory this can be removed in the future (Bug 1248449) + for (uint32_t j = 0; j < mData.Length(); ++j) { + // Use same comparison as RegisterServiceWorker. Scope contains + // basic origin information. Combine with any principal attributes. + if (Equivalent(tmpData[i], mData[j])) { + // Last match wins, just like legacy loading used to do in + // the ServiceWorkerManager. + mData[j] = tmpData[i]; + // Dupe found, so overwrite file with reduced list. + match = true; + break; + } + } + } else { +#ifdef DEBUG + // Otherwise assert no duplications in debug builds. + for (uint32_t j = 0; j < mData.Length(); ++j) { + MOZ_ASSERT(!Equivalent(tmpData[i], mData[j])); + } +#endif + } + if (!match) { + mData.AppendElement(tmpData[i]); + } + } + + // Overwrite previous version. + // Cannot call SaveData directly because gtest uses main-thread. + if (overwrite && NS_FAILED(WriteData())) { + NS_WARNING("Failed to write data for the ServiceWorker Registations."); + DeleteData(); + } + + return NS_OK; +} + +void +ServiceWorkerRegistrar::DeleteData() +{ + // We cannot assert about the correct thread because normally this method + // runs on a IO thread, but in gTests we call it from the main-thread. + + nsCOMPtr<nsIFile> file; + + { + MonitorAutoLock lock(mMonitor); + mData.Clear(); + + if (!mProfileDir) { + return; + } + + nsresult rv = mProfileDir->Clone(getter_AddRefs(file)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } + + nsresult rv = file->Append(NS_LITERAL_STRING(SERVICEWORKERREGISTRAR_FILE)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + rv = file->Remove(false); + if (rv == NS_ERROR_FILE_NOT_FOUND) { + return; + } + + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } +} + +void +ServiceWorkerRegistrar::RegisterServiceWorkerInternal(const ServiceWorkerRegistrationData& aData) +{ + bool found = false; + for (uint32_t i = 0, len = mData.Length(); i < len; ++i) { + if (Equivalent(aData, mData[i])) { + mData[i] = aData; + found = true; + break; + } + } + + if (!found) { + mData.AppendElement(aData); + } +} + +class ServiceWorkerRegistrarSaveDataRunnable final : public Runnable +{ +public: + ServiceWorkerRegistrarSaveDataRunnable() + : mThread(do_GetCurrentThread()) + { + AssertIsOnBackgroundThread(); + } + + NS_IMETHOD + Run() override + { + RefPtr<ServiceWorkerRegistrar> service = ServiceWorkerRegistrar::Get(); + MOZ_ASSERT(service); + + service->SaveData(); + + RefPtr<Runnable> runnable = + NewRunnableMethod(service, &ServiceWorkerRegistrar::DataSaved); + nsresult rv = mThread->Dispatch(runnable, NS_DISPATCH_NORMAL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; + } + +private: + nsCOMPtr<nsIThread> mThread; +}; + +void +ServiceWorkerRegistrar::ScheduleSaveData() +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(!mShuttingDown); + + nsCOMPtr<nsIEventTarget> target = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + MOZ_ASSERT(target, "Must have stream transport service"); + + RefPtr<Runnable> runnable = + new ServiceWorkerRegistrarSaveDataRunnable(); + nsresult rv = target->Dispatch(runnable, NS_DISPATCH_NORMAL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + ++mRunnableCounter; +} + +void +ServiceWorkerRegistrar::ShutdownCompleted() +{ + MOZ_ASSERT(NS_IsMainThread()); + + MOZ_ASSERT(mShutdownCompleteFlag && !*mShutdownCompleteFlag); + *mShutdownCompleteFlag = true; +} + +void +ServiceWorkerRegistrar::SaveData() +{ + MOZ_ASSERT(!NS_IsMainThread()); + + nsresult rv = WriteData(); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to write data for the ServiceWorker Registations."); + DeleteData(); + } +} + +void +ServiceWorkerRegistrar::DataSaved() +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mRunnableCounter); + + --mRunnableCounter; + MaybeScheduleShutdownCompleted(); +} + +void +ServiceWorkerRegistrar::MaybeScheduleShutdownCompleted() +{ + AssertIsOnBackgroundThread(); + + if (mRunnableCounter || !mShuttingDown) { + return; + } + + RefPtr<Runnable> runnable = + NewRunnableMethod(this, &ServiceWorkerRegistrar::ShutdownCompleted); + nsresult rv = NS_DispatchToMainThread(runnable); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } +} + +bool +ServiceWorkerRegistrar::IsSupportedVersion(const nsACString& aVersion) const +{ + uint32_t numVersions = ArrayLength(gSupportedRegistrarVersions); + for (uint32_t i = 0; i < numVersions; i++) { + if (aVersion.EqualsASCII(gSupportedRegistrarVersions[i])) { + return true; + } + } + return false; +} + +nsresult +ServiceWorkerRegistrar::WriteData() +{ + // We cannot assert about the correct thread because normally this method + // runs on a IO thread, but in gTests we call it from the main-thread. + + nsCOMPtr<nsIFile> file; + + { + MonitorAutoLock lock(mMonitor); + + if (!mProfileDir) { + return NS_ERROR_FAILURE; + } + + nsresult rv = mProfileDir->Clone(getter_AddRefs(file)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + nsresult rv = file->Append(NS_LITERAL_STRING(SERVICEWORKERREGISTRAR_FILE)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // We need a lock to take a snapshot of the data. + nsTArray<ServiceWorkerRegistrationData> data; + { + MonitorAutoLock lock(mMonitor); + data = mData; + } + + nsCOMPtr<nsIOutputStream> stream; + rv = NS_NewSafeLocalFileOutputStream(getter_AddRefs(stream), file); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsAutoCString buffer; + buffer.AppendLiteral(SERVICEWORKERREGISTRAR_VERSION); + buffer.Append('\n'); + + uint32_t count; + rv = stream->Write(buffer.Data(), buffer.Length(), &count); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (count != buffer.Length()) { + return NS_ERROR_UNEXPECTED; + } + + for (uint32_t i = 0, len = data.Length(); i < len; ++i) { + const mozilla::ipc::PrincipalInfo& info = data[i].principal(); + + MOZ_ASSERT(info.type() == mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); + + const mozilla::ipc::ContentPrincipalInfo& cInfo = + info.get_ContentPrincipalInfo(); + + nsAutoCString suffix; + cInfo.attrs().CreateSuffix(suffix); + + buffer.Truncate(); + buffer.Append(suffix.get()); + buffer.Append('\n'); + + buffer.Append(data[i].scope()); + buffer.Append('\n'); + + buffer.Append(data[i].currentWorkerURL()); + buffer.Append('\n'); + + buffer.Append(NS_ConvertUTF16toUTF8(data[i].cacheName())); + buffer.Append('\n'); + + buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR); + buffer.Append('\n'); + + rv = stream->Write(buffer.Data(), buffer.Length(), &count); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (count != buffer.Length()) { + return NS_ERROR_UNEXPECTED; + } + } + + nsCOMPtr<nsISafeOutputStream> safeStream = do_QueryInterface(stream); + MOZ_ASSERT(safeStream); + + rv = safeStream->Finish(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +void +ServiceWorkerRegistrar::ProfileStarted() +{ + MOZ_ASSERT(NS_IsMainThread()); + + MonitorAutoLock lock(mMonitor); + MOZ_DIAGNOSTIC_ASSERT(!mProfileDir); + + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(mProfileDir)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsCOMPtr<nsIEventTarget> target = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + MOZ_ASSERT(target, "Must have stream transport service"); + + nsCOMPtr<nsIRunnable> runnable = + NewRunnableMethod(this, &ServiceWorkerRegistrar::LoadData); + rv = target->Dispatch(runnable, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the LoadDataRunnable."); + } +} + +void +ServiceWorkerRegistrar::ProfileStopped() +{ + MOZ_ASSERT(NS_IsMainThread()); + + MonitorAutoLock lock(mMonitor); + + if (!mProfileDir) { + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(mProfileDir)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + } + + // We must set the pointer before potentially entering the fast-path shutdown + // below. + bool completed = false; + mShutdownCompleteFlag = &completed; + + PBackgroundChild* child = BackgroundChild::GetForCurrentThread(); + if (!child) { + // Mutations to the ServiceWorkerRegistrar happen on the PBackground thread, + // issued by the ServiceWorkerManagerService, so the appropriate place to + // trigger shutdown is on that thread. + // + // However, it's quite possible that the PBackground thread was not brought + // into existence for xpcshell tests. We don't cause it to be created + // ourselves for any reason, for example. + // + // In this scenario, we know that: + // - We will receive exactly one call to ourself from BlockShutdown() and + // BlockShutdown() will be called (at most) once. + // - The only way our Shutdown() method gets called is via + // BackgroundParentImpl::RecvShutdownServiceWorkerRegistrar() being + // invoked, which only happens if we get to that send below here that we + // can't get to. + // - All Shutdown() does is set mShuttingDown=true (essential for + // invariants) and invoke MaybeScheduleShutdownCompleted(). + // - Since there is no PBackground thread, mRunnableCounter must be 0 + // because only ScheduleSaveData() increments it and it only runs on the + // background thread, so it cannot have run. And so we would expect + // MaybeScheduleShutdownCompleted() to schedule an invocation of + // ShutdownCompleted on the main thread. + // + // So it's appropriate for us to set mShuttingDown=true (as Shutdown would + // do) and directly invoke ShutdownCompleted() (as Shutdown would indirectly + // do via MaybeScheduleShutdownCompleted). + mShuttingDown = true; + ShutdownCompleted(); + return; + } + + child->SendShutdownServiceWorkerRegistrar(); + + nsCOMPtr<nsIThread> thread(do_GetCurrentThread()); + while (true) { + MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(thread)); + if (completed) { + break; + } + } +} + +void +ServiceWorkerRegistrar::Shutdown() +{ + AssertIsOnBackgroundThread(); + MOZ_ASSERT(!mShuttingDown); + + mShuttingDown = true; + MaybeScheduleShutdownCompleted(); +} + +NS_IMETHODIMP +ServiceWorkerRegistrar::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (!strcmp(aTopic, "profile-after-change")) { + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + observerService->RemoveObserver(this, "profile-after-change"); + + // The profile is fully loaded, now we can proceed with the loading of data + // from disk. + ProfileStarted(); + + return NS_OK; + } + + if (!strcmp(aTopic, "profile-before-change")) { + // Hygiene; gServiceWorkerRegistrar should still be keeping a reference + // alive well past this phase of shutdown, but it's bad form to drop your + // last potentially owning reference and then make a call that requires you + // to still be alive, especially when you spin a nested event loop. + RefPtr<ServiceWorkerRegistrar> kungFuDeathGrip(this); + + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + observerService->RemoveObserver(this, "profile-before-change"); + + // Shutting down, let's sync the data. + ProfileStopped(); + + return NS_OK; + } + + MOZ_ASSERT(false, "ServiceWorkerRegistrar got unexpected topic!"); + return NS_ERROR_UNEXPECTED; +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerRegistrar.h b/dom/workers/ServiceWorkerRegistrar.h new file mode 100644 index 000000000..0c476ad9b --- /dev/null +++ b/dom/workers/ServiceWorkerRegistrar.h @@ -0,0 +1,101 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_ServiceWorkerRegistrar_h +#define mozilla_dom_workers_ServiceWorkerRegistrar_h + +#include "mozilla/Monitor.h" +#include "mozilla/Telemetry.h" +#include "nsClassHashtable.h" +#include "nsIObserver.h" +#include "nsCOMPtr.h" +#include "nsString.h" +#include "nsTArray.h" + +#define SERVICEWORKERREGISTRAR_FILE "serviceworker.txt" +#define SERVICEWORKERREGISTRAR_VERSION "4" +#define SERVICEWORKERREGISTRAR_TERMINATOR "#" +#define SERVICEWORKERREGISTRAR_TRUE "true" +#define SERVICEWORKERREGISTRAR_FALSE "false" + +class nsIFile; + +namespace mozilla { + +namespace ipc { +class PrincipalInfo; +} // namespace ipc + +namespace dom { + +class ServiceWorkerRegistrationData; + +class ServiceWorkerRegistrar : public nsIObserver +{ + friend class ServiceWorkerRegistrarSaveDataRunnable; + +public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOBSERVER + + static void Initialize(); + + void Shutdown(); + + void DataSaved(); + + static already_AddRefed<ServiceWorkerRegistrar> Get(); + + void GetRegistrations(nsTArray<ServiceWorkerRegistrationData>& aValues); + + void RegisterServiceWorker(const ServiceWorkerRegistrationData& aData); + void UnregisterServiceWorker(const mozilla::ipc::PrincipalInfo& aPrincipalInfo, + const nsACString& aScope); + void RemoveAll(); + +protected: + // These methods are protected because we test this class using gTest + // subclassing it. + void LoadData(); + void SaveData(); + + nsresult ReadData(); + nsresult WriteData(); + void DeleteData(); + + void RegisterServiceWorkerInternal(const ServiceWorkerRegistrationData& aData); + + ServiceWorkerRegistrar(); + virtual ~ServiceWorkerRegistrar(); + +private: + void ProfileStarted(); + void ProfileStopped(); + + void ScheduleSaveData(); + void ShutdownCompleted(); + void MaybeScheduleShutdownCompleted(); + + bool IsSupportedVersion(const nsACString& aVersion) const; + + mozilla::Monitor mMonitor; + +protected: + // protected by mMonitor. + nsCOMPtr<nsIFile> mProfileDir; + nsTArray<ServiceWorkerRegistrationData> mData; + bool mDataLoaded; + + // PBackground thread only + bool mShuttingDown; + bool* mShutdownCompleteFlag; + uint32_t mRunnableCounter; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_ServiceWorkerRegistrar_h diff --git a/dom/workers/ServiceWorkerRegistrarTypes.ipdlh b/dom/workers/ServiceWorkerRegistrarTypes.ipdlh new file mode 100644 index 000000000..7754a19e6 --- /dev/null +++ b/dom/workers/ServiceWorkerRegistrarTypes.ipdlh @@ -0,0 +1,23 @@ +/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */ +/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +include PBackgroundSharedTypes; + +namespace mozilla { +namespace dom { + +struct ServiceWorkerRegistrationData +{ + nsCString scope; + nsCString currentWorkerURL; + + nsString cacheName; + + PrincipalInfo principal; +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerRegistration.cpp b/dom/workers/ServiceWorkerRegistration.cpp new file mode 100644 index 000000000..451bd2be9 --- /dev/null +++ b/dom/workers/ServiceWorkerRegistration.cpp @@ -0,0 +1,1327 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerRegistration.h" + +#include "ipc/ErrorIPCUtils.h" +#include "mozilla/dom/Notification.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" +#include "mozilla/dom/PushManagerBinding.h" +#include "mozilla/dom/PushManager.h" +#include "mozilla/dom/ServiceWorkerRegistrationBinding.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "mozilla/Unused.h" +#include "nsCycleCollectionParticipant.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "ServiceWorker.h" +#include "ServiceWorkerManager.h" + +#include "nsIDocument.h" +#include "nsIServiceWorkerManager.h" +#include "nsISupportsPrimitives.h" +#include "nsPIDOMWindow.h" +#include "nsContentUtils.h" + +#include "WorkerPrivate.h" +#include "Workers.h" +#include "WorkerScope.h" + +using namespace mozilla::dom::workers; + +namespace mozilla { +namespace dom { + +/* static */ bool +ServiceWorkerRegistration::Visible(JSContext* aCx, JSObject* aObj) +{ + if (NS_IsMainThread()) { + return Preferences::GetBool("dom.serviceWorkers.enabled", false); + } + + // Otherwise check the pref via the work private helper + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx); + if (!workerPrivate) { + return false; + } + + return workerPrivate->ServiceWorkersEnabled(); +} + +/* static */ bool +ServiceWorkerRegistration::NotificationAPIVisible(JSContext* aCx, JSObject* aObj) +{ + if (NS_IsMainThread()) { + return Preferences::GetBool("dom.webnotifications.serviceworker.enabled", false); + } + + // Otherwise check the pref via the work private helper + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx); + if (!workerPrivate) { + return false; + } + + return workerPrivate->DOMServiceWorkerNotificationEnabled(); +} + +//////////////////////////////////////////////////// +// Main Thread implementation + +class ServiceWorkerRegistrationMainThread final : public ServiceWorkerRegistration, + public ServiceWorkerRegistrationListener +{ + friend nsPIDOMWindowInner; +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerRegistrationMainThread, + ServiceWorkerRegistration) + + ServiceWorkerRegistrationMainThread(nsPIDOMWindowInner* aWindow, + const nsAString& aScope); + + already_AddRefed<Promise> + Update(ErrorResult& aRv) override; + + already_AddRefed<Promise> + Unregister(ErrorResult& aRv) override; + + // Partial interface from Notification API. + already_AddRefed<Promise> + ShowNotification(JSContext* aCx, + const nsAString& aTitle, + const NotificationOptions& aOptions, + ErrorResult& aRv) override; + + already_AddRefed<Promise> + GetNotifications(const GetNotificationOptions& aOptions, + ErrorResult& aRv) override; + + already_AddRefed<ServiceWorker> + GetInstalling() override; + + already_AddRefed<ServiceWorker> + GetWaiting() override; + + already_AddRefed<ServiceWorker> + GetActive() override; + + already_AddRefed<PushManager> + GetPushManager(JSContext* aCx, ErrorResult& aRv) override; + + // DOMEventTargethelper + void DisconnectFromOwner() override + { + StopListeningForEvents(); + ServiceWorkerRegistration::DisconnectFromOwner(); + } + + // ServiceWorkerRegistrationListener + void + UpdateFound() override; + + void + InvalidateWorkers(WhichServiceWorker aWhichOnes) override; + + void + RegistrationRemoved() override; + + void + GetScope(nsAString& aScope) const override + { + aScope = mScope; + } + +private: + ~ServiceWorkerRegistrationMainThread(); + + already_AddRefed<ServiceWorker> + GetWorkerReference(WhichServiceWorker aWhichOne); + + void + StartListeningForEvents(); + + void + StopListeningForEvents(); + + bool mListeningForEvents; + + // The following properties are cached here to ensure JS equality is satisfied + // instead of acquiring a new worker instance from the ServiceWorkerManager + // for every access. A null value is considered a cache miss. + // These three may change to a new worker at any time. + RefPtr<ServiceWorker> mInstallingWorker; + RefPtr<ServiceWorker> mWaitingWorker; + RefPtr<ServiceWorker> mActiveWorker; + + RefPtr<PushManager> mPushManager; +}; + +NS_IMPL_ADDREF_INHERITED(ServiceWorkerRegistrationMainThread, ServiceWorkerRegistration) +NS_IMPL_RELEASE_INHERITED(ServiceWorkerRegistrationMainThread, ServiceWorkerRegistration) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorkerRegistrationMainThread) +NS_INTERFACE_MAP_END_INHERITING(ServiceWorkerRegistration) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(ServiceWorkerRegistrationMainThread, + ServiceWorkerRegistration, + mPushManager, + mInstallingWorker, mWaitingWorker, mActiveWorker); + +ServiceWorkerRegistrationMainThread::ServiceWorkerRegistrationMainThread(nsPIDOMWindowInner* aWindow, + const nsAString& aScope) + : ServiceWorkerRegistration(aWindow, aScope) + , mListeningForEvents(false) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aWindow->IsInnerWindow()); + StartListeningForEvents(); +} + +ServiceWorkerRegistrationMainThread::~ServiceWorkerRegistrationMainThread() +{ + StopListeningForEvents(); + MOZ_ASSERT(!mListeningForEvents); +} + + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationMainThread::GetWorkerReference(WhichServiceWorker aWhichOne) +{ + nsCOMPtr<nsPIDOMWindowInner> window = GetOwner(); + if (!window) { + return nullptr; + } + + nsresult rv; + nsCOMPtr<nsIServiceWorkerManager> swm = + do_GetService(SERVICEWORKERMANAGER_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + nsCOMPtr<nsISupports> serviceWorker; + switch(aWhichOne) { + case WhichServiceWorker::INSTALLING_WORKER: + rv = swm->GetInstalling(window, mScope, getter_AddRefs(serviceWorker)); + break; + case WhichServiceWorker::WAITING_WORKER: + rv = swm->GetWaiting(window, mScope, getter_AddRefs(serviceWorker)); + break; + case WhichServiceWorker::ACTIVE_WORKER: + rv = swm->GetActive(window, mScope, getter_AddRefs(serviceWorker)); + break; + default: + MOZ_CRASH("Invalid enum value"); + } + + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv) || rv == NS_ERROR_DOM_NOT_FOUND_ERR, + "Unexpected error getting service worker instance from " + "ServiceWorkerManager"); + if (NS_FAILED(rv)) { + return nullptr; + } + + RefPtr<ServiceWorker> ref = + static_cast<ServiceWorker*>(serviceWorker.get()); + return ref.forget(); +} + +// XXXnsm, maybe this can be optimized to only add when a event handler is +// registered. +void +ServiceWorkerRegistrationMainThread::StartListeningForEvents() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!mListeningForEvents); + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->AddRegistrationEventListener(mScope, this); + mListeningForEvents = true; + } +} + +void +ServiceWorkerRegistrationMainThread::StopListeningForEvents() +{ + AssertIsOnMainThread(); + if (!mListeningForEvents) { + return; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->RemoveRegistrationEventListener(mScope, this); + } + mListeningForEvents = false; +} + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationMainThread::GetInstalling() +{ + AssertIsOnMainThread(); + if (!mInstallingWorker) { + mInstallingWorker = GetWorkerReference(WhichServiceWorker::INSTALLING_WORKER); + } + + RefPtr<ServiceWorker> ret = mInstallingWorker; + return ret.forget(); +} + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationMainThread::GetWaiting() +{ + AssertIsOnMainThread(); + if (!mWaitingWorker) { + mWaitingWorker = GetWorkerReference(WhichServiceWorker::WAITING_WORKER); + } + + RefPtr<ServiceWorker> ret = mWaitingWorker; + return ret.forget(); +} + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationMainThread::GetActive() +{ + AssertIsOnMainThread(); + if (!mActiveWorker) { + mActiveWorker = GetWorkerReference(WhichServiceWorker::ACTIVE_WORKER); + } + + RefPtr<ServiceWorker> ret = mActiveWorker; + return ret.forget(); +} + +void +ServiceWorkerRegistrationMainThread::UpdateFound() +{ + DispatchTrustedEvent(NS_LITERAL_STRING("updatefound")); +} + +void +ServiceWorkerRegistrationMainThread::InvalidateWorkers(WhichServiceWorker aWhichOnes) +{ + AssertIsOnMainThread(); + if (aWhichOnes & WhichServiceWorker::INSTALLING_WORKER) { + mInstallingWorker = nullptr; + } + + if (aWhichOnes & WhichServiceWorker::WAITING_WORKER) { + mWaitingWorker = nullptr; + } + + if (aWhichOnes & WhichServiceWorker::ACTIVE_WORKER) { + mActiveWorker = nullptr; + } + +} + +void +ServiceWorkerRegistrationMainThread::RegistrationRemoved() +{ + // If the registration is being removed completely, remove it from the + // window registration hash table so that a new registration would get a new + // wrapper JS object. + if (nsCOMPtr<nsPIDOMWindowInner> window = GetOwner()) { + window->InvalidateServiceWorkerRegistration(mScope); + } +} + +namespace { + +void +UpdateInternal(nsIPrincipal* aPrincipal, + const nsAString& aScope, + ServiceWorkerUpdateFinishCallback* aCallback) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(aCallback); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown + return; + } + + swm->Update(aPrincipal, NS_ConvertUTF16toUTF8(aScope), aCallback); +} + +class MainThreadUpdateCallback final : public ServiceWorkerUpdateFinishCallback +{ + RefPtr<Promise> mPromise; + + ~MainThreadUpdateCallback() + { } + +public: + explicit MainThreadUpdateCallback(Promise* aPromise) + : mPromise(aPromise) + { + AssertIsOnMainThread(); + } + + void + UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override + { + mPromise->MaybeResolveWithUndefined(); + } + + void + UpdateFailed(ErrorResult& aStatus) override + { + mPromise->MaybeReject(aStatus); + } +}; + +class UpdateResultRunnable final : public WorkerRunnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + IPC::Message mSerializedErrorResult; + + ~UpdateResultRunnable() + {} + +public: + UpdateResultRunnable(PromiseWorkerProxy* aPromiseProxy, ErrorResult& aStatus) + : WorkerRunnable(aPromiseProxy->GetWorkerPrivate()) + , mPromiseProxy(aPromiseProxy) + { + // ErrorResult is not thread safe. Serialize it for transfer across + // threads. + IPC::WriteParam(&mSerializedErrorResult, aStatus); + aStatus.SuppressException(); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + // Deserialize the ErrorResult now that we are back in the worker + // thread. + ErrorResult status; + PickleIterator iter = PickleIterator(mSerializedErrorResult); + Unused << IPC::ReadParam(&mSerializedErrorResult, &iter, &status); + + Promise* promise = mPromiseProxy->WorkerPromise(); + if (status.Failed()) { + promise->MaybeReject(status); + } else { + promise->MaybeResolveWithUndefined(); + } + status.SuppressException(); + mPromiseProxy->CleanUp(); + return true; + } +}; + +class WorkerThreadUpdateCallback final : public ServiceWorkerUpdateFinishCallback +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + + ~WorkerThreadUpdateCallback() + { + } + +public: + explicit WorkerThreadUpdateCallback(PromiseWorkerProxy* aPromiseProxy) + : mPromiseProxy(aPromiseProxy) + { + AssertIsOnMainThread(); + } + + void + UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override + { + ErrorResult rv(NS_OK); + Finish(rv); + } + + void + UpdateFailed(ErrorResult& aStatus) override + { + Finish(aStatus); + } + + void + Finish(ErrorResult& aStatus) + { + if (!mPromiseProxy) { + return; + } + + RefPtr<PromiseWorkerProxy> proxy = mPromiseProxy.forget(); + + MutexAutoLock lock(proxy->Lock()); + if (proxy->CleanedUp()) { + return; + } + + RefPtr<UpdateResultRunnable> r = + new UpdateResultRunnable(proxy, aStatus); + r->Dispatch(); + } +}; + +class UpdateRunnable final : public Runnable +{ +public: + UpdateRunnable(PromiseWorkerProxy* aPromiseProxy, + const nsAString& aScope) + : mPromiseProxy(aPromiseProxy) + , mScope(aScope) + {} + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + ErrorResult result; + + nsCOMPtr<nsIPrincipal> principal; + // UpdateInternal may try to reject the promise synchronously leading + // to a deadlock. + { + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + principal = mPromiseProxy->GetWorkerPrivate()->GetPrincipal(); + } + MOZ_ASSERT(principal); + + RefPtr<WorkerThreadUpdateCallback> cb = + new WorkerThreadUpdateCallback(mPromiseProxy); + UpdateInternal(principal, mScope, cb); + return NS_OK; + } + +private: + ~UpdateRunnable() + {} + + RefPtr<PromiseWorkerProxy> mPromiseProxy; + const nsString mScope; +}; + +class UnregisterCallback final : public nsIServiceWorkerUnregisterCallback +{ + RefPtr<Promise> mPromise; + +public: + NS_DECL_ISUPPORTS + + explicit UnregisterCallback(Promise* aPromise) + : mPromise(aPromise) + { + MOZ_ASSERT(mPromise); + } + + NS_IMETHOD + UnregisterSucceeded(bool aState) override + { + AssertIsOnMainThread(); + mPromise->MaybeResolve(aState); + return NS_OK; + } + + NS_IMETHOD + UnregisterFailed() override + { + AssertIsOnMainThread(); + + mPromise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR); + return NS_OK; + } + +private: + ~UnregisterCallback() + { } +}; + +NS_IMPL_ISUPPORTS(UnregisterCallback, nsIServiceWorkerUnregisterCallback) + +class FulfillUnregisterPromiseRunnable final : public WorkerRunnable +{ + RefPtr<PromiseWorkerProxy> mPromiseWorkerProxy; + Maybe<bool> mState; +public: + FulfillUnregisterPromiseRunnable(PromiseWorkerProxy* aProxy, + Maybe<bool> aState) + : WorkerRunnable(aProxy->GetWorkerPrivate()) + , mPromiseWorkerProxy(aProxy) + , mState(aState) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mPromiseWorkerProxy); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + RefPtr<Promise> promise = mPromiseWorkerProxy->WorkerPromise(); + if (mState.isSome()) { + promise->MaybeResolve(mState.value()); + } else { + promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR); + } + + mPromiseWorkerProxy->CleanUp(); + return true; + } +}; + +class WorkerUnregisterCallback final : public nsIServiceWorkerUnregisterCallback +{ + RefPtr<PromiseWorkerProxy> mPromiseWorkerProxy; +public: + NS_DECL_ISUPPORTS + + explicit WorkerUnregisterCallback(PromiseWorkerProxy* aProxy) + : mPromiseWorkerProxy(aProxy) + { + MOZ_ASSERT(aProxy); + } + + NS_IMETHOD + UnregisterSucceeded(bool aState) override + { + AssertIsOnMainThread(); + Finish(Some(aState)); + return NS_OK; + } + + NS_IMETHOD + UnregisterFailed() override + { + AssertIsOnMainThread(); + Finish(Nothing()); + return NS_OK; + } + +private: + ~WorkerUnregisterCallback() + {} + + void + Finish(Maybe<bool> aState) + { + AssertIsOnMainThread(); + if (!mPromiseWorkerProxy) { + return; + } + + RefPtr<PromiseWorkerProxy> proxy = mPromiseWorkerProxy.forget(); + MutexAutoLock lock(proxy->Lock()); + if (proxy->CleanedUp()) { + return; + } + + RefPtr<WorkerRunnable> r = + new FulfillUnregisterPromiseRunnable(proxy, aState); + + r->Dispatch(); + } +}; + +NS_IMPL_ISUPPORTS(WorkerUnregisterCallback, nsIServiceWorkerUnregisterCallback); + +/* + * If the worker goes away, we still continue to unregister, but we don't try to + * resolve the worker Promise (which doesn't exist by that point). + */ +class StartUnregisterRunnable final : public Runnable +{ + RefPtr<PromiseWorkerProxy> mPromiseWorkerProxy; + const nsString mScope; + +public: + StartUnregisterRunnable(PromiseWorkerProxy* aProxy, + const nsAString& aScope) + : mPromiseWorkerProxy(aProxy) + , mScope(aScope) + { + MOZ_ASSERT(aProxy); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + // XXXnsm: There is a rare chance of this failing if the worker gets + // destroyed. In that case, unregister() called from a SW is no longer + // guaranteed to run. We should fix this by having a main thread proxy + // maintain a strongref to ServiceWorkerRegistrationInfo and use its + // principal. Can that be trusted? + nsCOMPtr<nsIPrincipal> principal; + { + MutexAutoLock lock(mPromiseWorkerProxy->Lock()); + if (mPromiseWorkerProxy->CleanedUp()) { + return NS_OK; + } + + WorkerPrivate* worker = mPromiseWorkerProxy->GetWorkerPrivate(); + MOZ_ASSERT(worker); + principal = worker->GetPrincipal(); + } + MOZ_ASSERT(principal); + + RefPtr<WorkerUnregisterCallback> cb = + new WorkerUnregisterCallback(mPromiseWorkerProxy); + nsCOMPtr<nsIServiceWorkerManager> swm = + mozilla::services::GetServiceWorkerManager(); + nsresult rv = swm->Unregister(principal, cb, mScope); + if (NS_WARN_IF(NS_FAILED(rv))) { + cb->UnregisterFailed(); + } + + return NS_OK; + } +}; +} // namespace + +already_AddRefed<Promise> +ServiceWorkerRegistrationMainThread::Update(ErrorResult& aRv) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner()); + if (!go) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + RefPtr<Promise> promise = Promise::Create(go, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc(); + MOZ_ASSERT(doc); + + RefPtr<MainThreadUpdateCallback> cb = + new MainThreadUpdateCallback(promise); + UpdateInternal(doc->NodePrincipal(), mScope, cb); + + return promise.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerRegistrationMainThread::Unregister(ErrorResult& aRv) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner()); + if (!go) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + // Although the spec says that the same-origin checks should also be done + // asynchronously, we do them in sync because the Promise created by the + // WebIDL infrastructure due to a returned error will be resolved + // asynchronously. We aren't making any internal state changes in these + // checks, so ordering of multiple calls is not affected. + nsCOMPtr<nsIDocument> document = GetOwner()->GetExtantDoc(); + if (!document) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsCOMPtr<nsIURI> scopeURI; + nsCOMPtr<nsIURI> baseURI = document->GetBaseURI(); + // "If the origin of scope is not client's origin..." + nsresult rv = NS_NewURI(getter_AddRefs(scopeURI), mScope, nullptr, baseURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + nsCOMPtr<nsIPrincipal> documentPrincipal = document->NodePrincipal(); + rv = documentPrincipal->CheckMayLoad(scopeURI, true /* report */, + false /* allowIfInheritsPrinciple */); + if (NS_FAILED(rv)) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + nsAutoCString uriSpec; + aRv = scopeURI->GetSpecIgnoringRef(uriSpec); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + nsCOMPtr<nsIServiceWorkerManager> swm = + mozilla::services::GetServiceWorkerManager(); + + RefPtr<Promise> promise = Promise::Create(go, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<UnregisterCallback> cb = new UnregisterCallback(promise); + + NS_ConvertUTF8toUTF16 scope(uriSpec); + aRv = swm->Unregister(documentPrincipal, cb, scope); + if (aRv.Failed()) { + return nullptr; + } + + return promise.forget(); +} + +// Notification API extension. +already_AddRefed<Promise> +ServiceWorkerRegistrationMainThread::ShowNotification(JSContext* aCx, + const nsAString& aTitle, + const NotificationOptions& aOptions, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsPIDOMWindowInner> window = GetOwner(); + if (NS_WARN_IF(!window)) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsCOMPtr<nsIDocument> doc = window->GetExtantDoc(); + if (NS_WARN_IF(!doc)) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + RefPtr<ServiceWorker> worker = GetActive(); + if (!worker) { + aRv.ThrowTypeError<MSG_NO_ACTIVE_WORKER>(mScope); + return nullptr; + } + + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(window); + RefPtr<Promise> p = + Notification::ShowPersistentNotification(aCx, global, mScope, aTitle, + aOptions, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return p.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerRegistrationMainThread::GetNotifications(const GetNotificationOptions& aOptions, ErrorResult& aRv) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsPIDOMWindowInner> window = GetOwner(); + if (NS_WARN_IF(!window)) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + return Notification::Get(window, aOptions, mScope, aRv); +} + +already_AddRefed<PushManager> +ServiceWorkerRegistrationMainThread::GetPushManager(JSContext* aCx, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + + if (!mPushManager) { + nsCOMPtr<nsIGlobalObject> globalObject = do_QueryInterface(GetOwner()); + + if (!globalObject) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + GlobalObject global(aCx, globalObject->GetGlobalJSObject()); + mPushManager = PushManager::Constructor(global, mScope, aRv); + if (aRv.Failed()) { + return nullptr; + } + } + + RefPtr<PushManager> ret = mPushManager; + return ret.forget(); +} + +//////////////////////////////////////////////////// +// Worker Thread implementation + +class ServiceWorkerRegistrationWorkerThread final : public ServiceWorkerRegistration + , public WorkerHolder +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerRegistrationWorkerThread, + ServiceWorkerRegistration) + + ServiceWorkerRegistrationWorkerThread(WorkerPrivate* aWorkerPrivate, + const nsAString& aScope); + + already_AddRefed<Promise> + Update(ErrorResult& aRv) override; + + already_AddRefed<Promise> + Unregister(ErrorResult& aRv) override; + + // Partial interface from Notification API. + already_AddRefed<Promise> + ShowNotification(JSContext* aCx, + const nsAString& aTitle, + const NotificationOptions& aOptions, + ErrorResult& aRv) override; + + already_AddRefed<Promise> + GetNotifications(const GetNotificationOptions& aOptions, + ErrorResult& aRv) override; + + already_AddRefed<ServiceWorker> + GetInstalling() override; + + already_AddRefed<ServiceWorker> + GetWaiting() override; + + already_AddRefed<ServiceWorker> + GetActive() override; + + void + GetScope(nsAString& aScope) const override + { + aScope = mScope; + } + + bool + Notify(Status aStatus) override; + + already_AddRefed<PushManager> + GetPushManager(JSContext* aCx, ErrorResult& aRv) override; + +private: + ~ServiceWorkerRegistrationWorkerThread(); + + void + InitListener(); + + void + ReleaseListener(); + + WorkerPrivate* mWorkerPrivate; + RefPtr<WorkerListener> mListener; + + RefPtr<PushManager> mPushManager; +}; + +class WorkerListener final : public ServiceWorkerRegistrationListener +{ + // Accessed on the main thread. + WorkerPrivate* mWorkerPrivate; + nsString mScope; + bool mListeningForEvents; + + // Accessed on the worker thread. + ServiceWorkerRegistrationWorkerThread* mRegistration; + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerListener, override) + + WorkerListener(WorkerPrivate* aWorkerPrivate, + ServiceWorkerRegistrationWorkerThread* aReg) + : mWorkerPrivate(aWorkerPrivate) + , mListeningForEvents(false) + , mRegistration(aReg) + { + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mRegistration); + // Copy scope so we can return it on the main thread. + mRegistration->GetScope(mScope); + } + + void + StartListeningForEvents() + { + AssertIsOnMainThread(); + MOZ_ASSERT(!mListeningForEvents); + MOZ_ASSERT(mWorkerPrivate); + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + // FIXME(nsm): Maybe the function shouldn't take an explicit scope. + swm->AddRegistrationEventListener(mScope, this); + mListeningForEvents = true; + } + } + + void + StopListeningForEvents() + { + AssertIsOnMainThread(); + + MOZ_ASSERT(mListeningForEvents); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + + // We aren't going to need this anymore and we shouldn't hold on since the + // worker will go away soon. + mWorkerPrivate = nullptr; + + if (swm) { + // FIXME(nsm): Maybe the function shouldn't take an explicit scope. + swm->RemoveRegistrationEventListener(mScope, this); + mListeningForEvents = false; + } + } + + // ServiceWorkerRegistrationListener + void + UpdateFound() override; + + void + InvalidateWorkers(WhichServiceWorker aWhichOnes) override + { + AssertIsOnMainThread(); + // FIXME(nsm); + } + + void + RegistrationRemoved() override + { + AssertIsOnMainThread(); + } + + void + GetScope(nsAString& aScope) const override + { + aScope = mScope; + } + + ServiceWorkerRegistrationWorkerThread* + GetRegistration() const + { + if (mWorkerPrivate) { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + return mRegistration; + } + + void + ClearRegistration() + { + if (mWorkerPrivate) { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + mRegistration = nullptr; + } + +private: + ~WorkerListener() + { + MOZ_ASSERT(!mListeningForEvents); + } +}; + +NS_IMPL_ADDREF_INHERITED(ServiceWorkerRegistrationWorkerThread, ServiceWorkerRegistration) +NS_IMPL_RELEASE_INHERITED(ServiceWorkerRegistrationWorkerThread, ServiceWorkerRegistration) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorkerRegistrationWorkerThread) +NS_INTERFACE_MAP_END_INHERITING(ServiceWorkerRegistration) + +// Expanded macros since we need special behaviour to release the proxy. +NS_IMPL_CYCLE_COLLECTION_CLASS(ServiceWorkerRegistrationWorkerThread) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ServiceWorkerRegistrationWorkerThread, + ServiceWorkerRegistration) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPushManager) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(ServiceWorkerRegistrationWorkerThread, + ServiceWorkerRegistration) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mPushManager) + tmp->ReleaseListener(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +ServiceWorkerRegistrationWorkerThread::ServiceWorkerRegistrationWorkerThread(WorkerPrivate* aWorkerPrivate, + const nsAString& aScope) + : ServiceWorkerRegistration(nullptr, aScope) + , mWorkerPrivate(aWorkerPrivate) +{ + InitListener(); +} + +ServiceWorkerRegistrationWorkerThread::~ServiceWorkerRegistrationWorkerThread() +{ + ReleaseListener(); + MOZ_ASSERT(!mListener); +} + +already_AddRefed<workers::ServiceWorker> +ServiceWorkerRegistrationWorkerThread::GetInstalling() +{ + // FIXME(nsm): Will be implemented after Bug 1113522. + return nullptr; +} + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationWorkerThread::GetWaiting() +{ + // FIXME(nsm): Will be implemented after Bug 1113522. + return nullptr; +} + +already_AddRefed<ServiceWorker> +ServiceWorkerRegistrationWorkerThread::GetActive() +{ + // FIXME(nsm): Will be implemented after Bug 1113522. + return nullptr; +} + +already_AddRefed<Promise> +ServiceWorkerRegistrationWorkerThread::Update(ErrorResult& aRv) +{ + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + + RefPtr<Promise> promise = Promise::Create(worker->GlobalScope(), aRv); + if (aRv.Failed()) { + return nullptr; + } + + // Avoid infinite update loops by ignoring update() calls during top + // level script evaluation. See: + // https://github.com/slightlyoff/ServiceWorker/issues/800 + if (worker->LoadScriptAsPartOfLoadingServiceWorkerScript()) { + promise->MaybeResolveWithUndefined(); + return promise.forget(); + } + + RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, promise); + if (!proxy) { + aRv.Throw(NS_ERROR_DOM_ABORT_ERR); + return nullptr; + } + + RefPtr<UpdateRunnable> r = new UpdateRunnable(proxy, mScope); + MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(r.forget())); + + return promise.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerRegistrationWorkerThread::Unregister(ErrorResult& aRv) +{ + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + + if (!worker->IsServiceWorker()) { + // For other workers, the registration probably originated from + // getRegistration(), so we may have to validate origin etc. Let's do this + // this later. + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + RefPtr<Promise> promise = Promise::Create(worker->GlobalScope(), aRv); + if (aRv.Failed()) { + return nullptr; + } + + RefPtr<PromiseWorkerProxy> proxy = PromiseWorkerProxy::Create(worker, promise); + if (!proxy) { + aRv.Throw(NS_ERROR_DOM_ABORT_ERR); + return nullptr; + } + + RefPtr<StartUnregisterRunnable> r = new StartUnregisterRunnable(proxy, mScope); + MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(r.forget())); + + return promise.forget(); +} + +void +ServiceWorkerRegistrationWorkerThread::InitListener() +{ + MOZ_ASSERT(!mListener); + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + + mListener = new WorkerListener(worker, this); + if (!HoldWorker(worker, Closing)) { + mListener = nullptr; + NS_WARNING("Could not add feature"); + return; + } + + nsCOMPtr<nsIRunnable> r = + NewRunnableMethod(mListener, &WorkerListener::StartListeningForEvents); + MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(r.forget())); +} + +void +ServiceWorkerRegistrationWorkerThread::ReleaseListener() +{ + if (!mListener) { + return; + } + + // We can assert worker here, because: + // 1) We always HoldWorker, so if the worker has shutdown already, we'll + // have received Notify and removed it. If HoldWorker had failed, + // mListener will be null and we won't reach here. + // 2) Otherwise, worker is still around even if we are going away. + mWorkerPrivate->AssertIsOnWorkerThread(); + ReleaseWorker(); + + mListener->ClearRegistration(); + + nsCOMPtr<nsIRunnable> r = + NewRunnableMethod(mListener, &WorkerListener::StopListeningForEvents); + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(r.forget())); + + mListener = nullptr; + mWorkerPrivate = nullptr; +} + +bool +ServiceWorkerRegistrationWorkerThread::Notify(Status aStatus) +{ + ReleaseListener(); + return true; +} + +class FireUpdateFoundRunnable final : public WorkerRunnable +{ + RefPtr<WorkerListener> mListener; +public: + FireUpdateFoundRunnable(WorkerPrivate* aWorkerPrivate, + WorkerListener* aListener) + : WorkerRunnable(aWorkerPrivate) + , mListener(aListener) + { + // Need this assertion for now since runnables which modify busy count can + // only be dispatched from parent thread to worker thread and we don't deal + // with nested workers. SW threads can't be nested. + MOZ_ASSERT(aWorkerPrivate->IsServiceWorker()); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + ServiceWorkerRegistrationWorkerThread* reg = mListener->GetRegistration(); + if (reg) { + reg->DispatchTrustedEvent(NS_LITERAL_STRING("updatefound")); + } + return true; + } +}; + +void +WorkerListener::UpdateFound() +{ + AssertIsOnMainThread(); + if (mWorkerPrivate) { + RefPtr<FireUpdateFoundRunnable> r = + new FireUpdateFoundRunnable(mWorkerPrivate, this); + Unused << NS_WARN_IF(!r->Dispatch()); + } +} + +// Notification API extension. +already_AddRefed<Promise> +ServiceWorkerRegistrationWorkerThread::ShowNotification(JSContext* aCx, + const nsAString& aTitle, + const NotificationOptions& aOptions, + ErrorResult& aRv) +{ + // Until Bug 1131324 exposes ServiceWorkerContainer on workers, + // ShowPersistentNotification() checks for valid active worker while it is + // also verifying scope so that we block the worker on the main thread only + // once. + RefPtr<Promise> p = + Notification::ShowPersistentNotification(aCx, mWorkerPrivate->GlobalScope(), + mScope, aTitle, aOptions, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + return p.forget(); +} + +already_AddRefed<Promise> +ServiceWorkerRegistrationWorkerThread::GetNotifications(const GetNotificationOptions& aOptions, + ErrorResult& aRv) +{ + return Notification::WorkerGet(mWorkerPrivate, aOptions, mScope, aRv); +} + +already_AddRefed<PushManager> +ServiceWorkerRegistrationWorkerThread::GetPushManager(JSContext* aCx, ErrorResult& aRv) +{ + if (!mPushManager) { + mPushManager = new PushManager(mScope); + } + + RefPtr<PushManager> ret = mPushManager; + return ret.forget(); +} + +//////////////////////////////////////////////////// +// Base class implementation + +NS_IMPL_ADDREF_INHERITED(ServiceWorkerRegistration, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(ServiceWorkerRegistration, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorkerRegistration) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +ServiceWorkerRegistration::ServiceWorkerRegistration(nsPIDOMWindowInner* aWindow, + const nsAString& aScope) + : DOMEventTargetHelper(aWindow) + , mScope(aScope) +{} + +JSObject* +ServiceWorkerRegistration::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) +{ + return ServiceWorkerRegistrationBinding::Wrap(aCx, this, aGivenProto); +} + +/* static */ already_AddRefed<ServiceWorkerRegistration> +ServiceWorkerRegistration::CreateForMainThread(nsPIDOMWindowInner* aWindow, + const nsAString& aScope) +{ + MOZ_ASSERT(aWindow); + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<ServiceWorkerRegistration> registration = + new ServiceWorkerRegistrationMainThread(aWindow, aScope); + + return registration.forget(); +} + +/* static */ already_AddRefed<ServiceWorkerRegistration> +ServiceWorkerRegistration::CreateForWorker(workers::WorkerPrivate* aWorkerPrivate, + const nsAString& aScope) +{ + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<ServiceWorkerRegistration> registration = + new ServiceWorkerRegistrationWorkerThread(aWorkerPrivate, aScope); + + return registration.forget(); +} + +} // dom namespace +} // mozilla namespace diff --git a/dom/workers/ServiceWorkerRegistration.h b/dom/workers/ServiceWorkerRegistration.h new file mode 100644 index 000000000..5b0847e7b --- /dev/null +++ b/dom/workers/ServiceWorkerRegistration.h @@ -0,0 +1,124 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ServiceWorkerRegistration_h +#define mozilla_dom_ServiceWorkerRegistration_h + +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/dom/ServiceWorkerBinding.h" +#include "mozilla/dom/ServiceWorkerCommon.h" +#include "mozilla/dom/workers/bindings/WorkerHolder.h" +#include "nsContentUtils.h" // Required for nsContentUtils::PushEnabled + +// Support for Notification API extension. +#include "mozilla/dom/NotificationBinding.h" + +class nsPIDOMWindowInner; + +namespace mozilla { +namespace dom { + +class Promise; +class PushManager; +class WorkerListener; + +namespace workers { +class ServiceWorker; +class WorkerPrivate; +} // namespace workers + +// Used by ServiceWorkerManager to notify ServiceWorkerRegistrations of +// updatefound event and invalidating ServiceWorker instances. +class ServiceWorkerRegistrationListener +{ +public: + NS_IMETHOD_(MozExternalRefCountType) AddRef() = 0; + NS_IMETHOD_(MozExternalRefCountType) Release() = 0; + + virtual void + UpdateFound() = 0; + + virtual void + InvalidateWorkers(WhichServiceWorker aWhichOnes) = 0; + + virtual void + RegistrationRemoved() = 0; + + virtual void + GetScope(nsAString& aScope) const = 0; +}; + +class ServiceWorkerRegistration : public DOMEventTargetHelper +{ +public: + NS_DECL_ISUPPORTS_INHERITED + + IMPL_EVENT_HANDLER(updatefound) + + static bool + Visible(JSContext* aCx, JSObject* aObj); + + static bool + NotificationAPIVisible(JSContext* aCx, JSObject* aObj); + + + static already_AddRefed<ServiceWorkerRegistration> + CreateForMainThread(nsPIDOMWindowInner* aWindow, + const nsAString& aScope); + + static already_AddRefed<ServiceWorkerRegistration> + CreateForWorker(workers::WorkerPrivate* aWorkerPrivate, + const nsAString& aScope); + + JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + virtual already_AddRefed<workers::ServiceWorker> + GetInstalling() = 0; + + virtual already_AddRefed<workers::ServiceWorker> + GetWaiting() = 0; + + virtual already_AddRefed<workers::ServiceWorker> + GetActive() = 0; + + virtual void + GetScope(nsAString& aScope) const = 0; + + virtual already_AddRefed<Promise> + Update(ErrorResult& aRv) = 0; + + virtual already_AddRefed<Promise> + Unregister(ErrorResult& aRv) = 0; + + virtual already_AddRefed<PushManager> + GetPushManager(JSContext* aCx, ErrorResult& aRv) = 0; + + virtual already_AddRefed<Promise> + ShowNotification(JSContext* aCx, + const nsAString& aTitle, + const NotificationOptions& aOptions, + ErrorResult& aRv) = 0; + + virtual already_AddRefed<Promise> + GetNotifications(const GetNotificationOptions& aOptions, + ErrorResult& aRv) = 0; + +protected: + ServiceWorkerRegistration(nsPIDOMWindowInner* aWindow, + const nsAString& aScope); + + virtual ~ServiceWorkerRegistration() + { } + + const nsString mScope; +}; + + +} // namespace dom +} // namespace mozilla + +#endif /* mozilla_dom_ServiceWorkerRegistration_h */ diff --git a/dom/workers/ServiceWorkerRegistrationInfo.cpp b/dom/workers/ServiceWorkerRegistrationInfo.cpp new file mode 100644 index 000000000..26ad74bda --- /dev/null +++ b/dom/workers/ServiceWorkerRegistrationInfo.cpp @@ -0,0 +1,546 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerRegistrationInfo.h" + +BEGIN_WORKERS_NAMESPACE + +namespace { + +class ContinueActivateRunnable final : public LifeCycleEventCallback +{ + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration; + bool mSuccess; + +public: + explicit ContinueActivateRunnable(const nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration) + : mRegistration(aRegistration) + , mSuccess(false) + { + AssertIsOnMainThread(); + } + + void + SetResult(bool aResult) override + { + mSuccess = aResult; + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + mRegistration->FinishActivate(mSuccess); + mRegistration = nullptr; + return NS_OK; + } +}; + +} // anonymous namespace + +void +ServiceWorkerRegistrationInfo::Clear() +{ + if (mEvaluatingWorker) { + mEvaluatingWorker = nullptr; + } + + if (mInstallingWorker) { + mInstallingWorker->UpdateState(ServiceWorkerState::Redundant); + mInstallingWorker->WorkerPrivate()->NoteDeadServiceWorkerInfo(); + mInstallingWorker = nullptr; + // FIXME(nsm): Abort any inflight requests from installing worker. + } + + if (mWaitingWorker) { + mWaitingWorker->UpdateState(ServiceWorkerState::Redundant); + mWaitingWorker->WorkerPrivate()->NoteDeadServiceWorkerInfo(); + mWaitingWorker = nullptr; + } + + if (mActiveWorker) { + mActiveWorker->UpdateState(ServiceWorkerState::Redundant); + mActiveWorker->WorkerPrivate()->NoteDeadServiceWorkerInfo(); + mActiveWorker = nullptr; + } + + NotifyListenersOnChange(WhichServiceWorker::INSTALLING_WORKER | + WhichServiceWorker::WAITING_WORKER | + WhichServiceWorker::ACTIVE_WORKER); +} + +ServiceWorkerRegistrationInfo::ServiceWorkerRegistrationInfo(const nsACString& aScope, + nsIPrincipal* aPrincipal) + : mControlledDocumentsCounter(0) + , mUpdateState(NoUpdate) + , mLastUpdateCheckTime(0) + , mScope(aScope) + , mPrincipal(aPrincipal) + , mPendingUninstall(false) +{} + +ServiceWorkerRegistrationInfo::~ServiceWorkerRegistrationInfo() +{ + if (IsControllingDocuments()) { + NS_WARNING("ServiceWorkerRegistrationInfo is still controlling documents. This can be a bug or a leak in ServiceWorker API or in any other API that takes the document alive."); + } +} + +NS_IMPL_ISUPPORTS(ServiceWorkerRegistrationInfo, nsIServiceWorkerRegistrationInfo) + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetPrincipal(nsIPrincipal** aPrincipal) +{ + AssertIsOnMainThread(); + NS_ADDREF(*aPrincipal = mPrincipal); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetScope(nsAString& aScope) +{ + AssertIsOnMainThread(); + CopyUTF8toUTF16(mScope, aScope); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetScriptSpec(nsAString& aScriptSpec) +{ + AssertIsOnMainThread(); + RefPtr<ServiceWorkerInfo> newest = Newest(); + if (newest) { + CopyUTF8toUTF16(newest->ScriptSpec(), aScriptSpec); + } + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetInstallingWorker(nsIServiceWorkerInfo **aResult) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsIServiceWorkerInfo> info = do_QueryInterface(mInstallingWorker); + info.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetWaitingWorker(nsIServiceWorkerInfo **aResult) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsIServiceWorkerInfo> info = do_QueryInterface(mWaitingWorker); + info.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetActiveWorker(nsIServiceWorkerInfo **aResult) +{ + AssertIsOnMainThread(); + nsCOMPtr<nsIServiceWorkerInfo> info = do_QueryInterface(mActiveWorker); + info.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::GetWorkerByID(uint64_t aID, nsIServiceWorkerInfo **aResult) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aResult); + + RefPtr<ServiceWorkerInfo> info = GetServiceWorkerInfoById(aID); + // It is ok to return null for a missing service worker info. + info.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::AddListener( + nsIServiceWorkerRegistrationInfoListener *aListener) +{ + AssertIsOnMainThread(); + + if (!aListener || mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.AppendElement(aListener); + + return NS_OK; +} + +NS_IMETHODIMP +ServiceWorkerRegistrationInfo::RemoveListener( + nsIServiceWorkerRegistrationInfoListener *aListener) +{ + AssertIsOnMainThread(); + + if (!aListener || !mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.RemoveElement(aListener); + + return NS_OK; +} + +already_AddRefed<ServiceWorkerInfo> +ServiceWorkerRegistrationInfo::GetServiceWorkerInfoById(uint64_t aId) +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerInfo> serviceWorker; + if (mEvaluatingWorker && mEvaluatingWorker->ID() == aId) { + serviceWorker = mEvaluatingWorker; + } else if (mInstallingWorker && mInstallingWorker->ID() == aId) { + serviceWorker = mInstallingWorker; + } else if (mWaitingWorker && mWaitingWorker->ID() == aId) { + serviceWorker = mWaitingWorker; + } else if (mActiveWorker && mActiveWorker->ID() == aId) { + serviceWorker = mActiveWorker; + } + + return serviceWorker.forget(); +} + +void +ServiceWorkerRegistrationInfo::TryToActivateAsync() +{ + MOZ_ALWAYS_SUCCEEDS( + NS_DispatchToMainThread(NewRunnableMethod(this, + &ServiceWorkerRegistrationInfo::TryToActivate))); +} + +/* + * TryToActivate should not be called directly, use TryToActivateAsync instead. + */ +void +ServiceWorkerRegistrationInfo::TryToActivate() +{ + AssertIsOnMainThread(); + bool controlling = IsControllingDocuments(); + bool skipWaiting = mWaitingWorker && mWaitingWorker->SkipWaitingFlag(); + bool idle = IsIdle(); + if (idle && (!controlling || skipWaiting)) { + Activate(); + } +} + +void +ServiceWorkerRegistrationInfo::Activate() +{ + if (!mWaitingWorker) { + return; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown began during async activation step + return; + } + + TransitionWaitingToActive(); + + // FIXME(nsm): Unlink appcache if there is one. + + swm->CheckPendingReadyPromises(); + + // "Queue a task to fire a simple event named controllerchange..." + nsCOMPtr<nsIRunnable> controllerChangeRunnable = + NewRunnableMethod<RefPtr<ServiceWorkerRegistrationInfo>>( + swm, &ServiceWorkerManager::FireControllerChange, this); + NS_DispatchToMainThread(controllerChangeRunnable); + + nsCOMPtr<nsIRunnable> failRunnable = + NewRunnableMethod<bool>(this, + &ServiceWorkerRegistrationInfo::FinishActivate, + false /* success */); + + nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> handle( + new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(this)); + RefPtr<LifeCycleEventCallback> callback = new ContinueActivateRunnable(handle); + + ServiceWorkerPrivate* workerPrivate = mActiveWorker->WorkerPrivate(); + MOZ_ASSERT(workerPrivate); + nsresult rv = workerPrivate->SendLifeCycleEvent(NS_LITERAL_STRING("activate"), + callback, failRunnable); + if (NS_WARN_IF(NS_FAILED(rv))) { + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(failRunnable)); + return; + } +} + +void +ServiceWorkerRegistrationInfo::FinishActivate(bool aSuccess) +{ + if (mPendingUninstall || !mActiveWorker || + mActiveWorker->State() != ServiceWorkerState::Activating) { + return; + } + + // Activation never fails, so aSuccess is ignored. + mActiveWorker->UpdateState(ServiceWorkerState::Activated); + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown started during async activation completion step + return; + } + swm->StoreRegistration(mPrincipal, this); +} + +void +ServiceWorkerRegistrationInfo::RefreshLastUpdateCheckTime() +{ + AssertIsOnMainThread(); + mLastUpdateCheckTime = PR_IntervalNow() / PR_MSEC_PER_SEC; +} + +bool +ServiceWorkerRegistrationInfo::IsLastUpdateCheckTimeOverOneDay() const +{ + AssertIsOnMainThread(); + + // For testing. + if (Preferences::GetBool("dom.serviceWorkers.testUpdateOverOneDay")) { + return true; + } + + const uint64_t kSecondsPerDay = 86400; + const uint64_t now = PR_IntervalNow() / PR_MSEC_PER_SEC; + + if ((now - mLastUpdateCheckTime) > kSecondsPerDay) { + return true; + } + return false; +} + +void +ServiceWorkerRegistrationInfo::NotifyListenersOnChange(WhichServiceWorker aChangedWorkers) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aChangedWorkers & (WhichServiceWorker::INSTALLING_WORKER | + WhichServiceWorker::WAITING_WORKER | + WhichServiceWorker::ACTIVE_WORKER)); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown started + return; + } + + swm->InvalidateServiceWorkerRegistrationWorker(this, aChangedWorkers); + + nsTArray<nsCOMPtr<nsIServiceWorkerRegistrationInfoListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnChange(); + } +} + +void +ServiceWorkerRegistrationInfo::MaybeScheduleTimeCheckAndUpdate() +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // shutting down, do nothing + return; + } + + if (mUpdateState == NoUpdate) { + mUpdateState = NeedTimeCheckAndUpdate; + } + + swm->ScheduleUpdateTimer(mPrincipal, mScope); +} + +void +ServiceWorkerRegistrationInfo::MaybeScheduleUpdate() +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // shutting down, do nothing + return; + } + + mUpdateState = NeedUpdate; + + swm->ScheduleUpdateTimer(mPrincipal, mScope); +} + +bool +ServiceWorkerRegistrationInfo::CheckAndClearIfUpdateNeeded() +{ + AssertIsOnMainThread(); + + bool result = mUpdateState == NeedUpdate || + (mUpdateState == NeedTimeCheckAndUpdate && + IsLastUpdateCheckTimeOverOneDay()); + + mUpdateState = NoUpdate; + + return result; +} + +ServiceWorkerInfo* +ServiceWorkerRegistrationInfo::GetEvaluating() const +{ + AssertIsOnMainThread(); + return mEvaluatingWorker; +} + +ServiceWorkerInfo* +ServiceWorkerRegistrationInfo::GetInstalling() const +{ + AssertIsOnMainThread(); + return mInstallingWorker; +} + +ServiceWorkerInfo* +ServiceWorkerRegistrationInfo::GetWaiting() const +{ + AssertIsOnMainThread(); + return mWaitingWorker; +} + +ServiceWorkerInfo* +ServiceWorkerRegistrationInfo::GetActive() const +{ + AssertIsOnMainThread(); + return mActiveWorker; +} + +void +ServiceWorkerRegistrationInfo::SetEvaluating(ServiceWorkerInfo* aServiceWorker) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aServiceWorker); + MOZ_ASSERT(!mEvaluatingWorker); + MOZ_ASSERT(!mInstallingWorker); + MOZ_ASSERT(mWaitingWorker != aServiceWorker); + MOZ_ASSERT(mActiveWorker != aServiceWorker); + + mEvaluatingWorker = aServiceWorker; +} + +void +ServiceWorkerRegistrationInfo::ClearEvaluating() +{ + AssertIsOnMainThread(); + + if (!mEvaluatingWorker) { + return; + } + + mEvaluatingWorker->UpdateState(ServiceWorkerState::Redundant); + mEvaluatingWorker = nullptr; +} + +void +ServiceWorkerRegistrationInfo::ClearInstalling() +{ + AssertIsOnMainThread(); + + if (!mInstallingWorker) { + return; + } + + mInstallingWorker->UpdateState(ServiceWorkerState::Redundant); + mInstallingWorker = nullptr; + NotifyListenersOnChange(WhichServiceWorker::INSTALLING_WORKER); +} + +void +ServiceWorkerRegistrationInfo::TransitionEvaluatingToInstalling() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mEvaluatingWorker); + MOZ_ASSERT(!mInstallingWorker); + + mInstallingWorker = mEvaluatingWorker.forget(); + mInstallingWorker->UpdateState(ServiceWorkerState::Installing); + NotifyListenersOnChange(WhichServiceWorker::INSTALLING_WORKER); +} + +void +ServiceWorkerRegistrationInfo::TransitionInstallingToWaiting() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mInstallingWorker); + + if (mWaitingWorker) { + MOZ_ASSERT(mInstallingWorker->CacheName() != mWaitingWorker->CacheName()); + mWaitingWorker->UpdateState(ServiceWorkerState::Redundant); + } + + mWaitingWorker = mInstallingWorker.forget(); + mWaitingWorker->UpdateState(ServiceWorkerState::Installed); + NotifyListenersOnChange(WhichServiceWorker::INSTALLING_WORKER | + WhichServiceWorker::WAITING_WORKER); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + // browser shutdown began + return; + } + swm->StoreRegistration(mPrincipal, this); +} + +void +ServiceWorkerRegistrationInfo::SetActive(ServiceWorkerInfo* aServiceWorker) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aServiceWorker); + + // TODO: Assert installing, waiting, and active are nullptr once the SWM + // moves to the parent process. After that happens this code will + // only run for browser initialization and not for cross-process + // overrides. + MOZ_ASSERT(mInstallingWorker != aServiceWorker); + MOZ_ASSERT(mWaitingWorker != aServiceWorker); + MOZ_ASSERT(mActiveWorker != aServiceWorker); + + if (mActiveWorker) { + MOZ_ASSERT(aServiceWorker->CacheName() != mActiveWorker->CacheName()); + mActiveWorker->UpdateState(ServiceWorkerState::Redundant); + } + + // The active worker is being overriden due to initial load or + // another process activating a worker. Move straight to the + // Activated state. + mActiveWorker = aServiceWorker; + mActiveWorker->SetActivateStateUncheckedWithoutEvent(ServiceWorkerState::Activated); + NotifyListenersOnChange(WhichServiceWorker::ACTIVE_WORKER); +} + +void +ServiceWorkerRegistrationInfo::TransitionWaitingToActive() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mWaitingWorker); + + if (mActiveWorker) { + MOZ_ASSERT(mWaitingWorker->CacheName() != mActiveWorker->CacheName()); + mActiveWorker->UpdateState(ServiceWorkerState::Redundant); + } + + // We are transitioning from waiting to active normally, so go to + // the activating state. + mActiveWorker = mWaitingWorker.forget(); + mActiveWorker->UpdateState(ServiceWorkerState::Activating); + NotifyListenersOnChange(WhichServiceWorker::WAITING_WORKER | + WhichServiceWorker::ACTIVE_WORKER); +} + +bool +ServiceWorkerRegistrationInfo::IsIdle() const +{ + return !mActiveWorker || mActiveWorker->WorkerPrivate()->IsIdle(); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerRegistrationInfo.h b/dom/workers/ServiceWorkerRegistrationInfo.h new file mode 100644 index 000000000..d2d217be0 --- /dev/null +++ b/dom/workers/ServiceWorkerRegistrationInfo.h @@ -0,0 +1,184 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerregistrationinfo_h +#define mozilla_dom_workers_serviceworkerregistrationinfo_h + +#include "mozilla/dom/workers/ServiceWorkerInfo.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerRegistrationInfo final + : public nsIServiceWorkerRegistrationInfo +{ + uint32_t mControlledDocumentsCounter; + + enum + { + NoUpdate, + NeedTimeCheckAndUpdate, + NeedUpdate + } mUpdateState; + + uint64_t mLastUpdateCheckTime; + + RefPtr<ServiceWorkerInfo> mEvaluatingWorker; + RefPtr<ServiceWorkerInfo> mActiveWorker; + RefPtr<ServiceWorkerInfo> mWaitingWorker; + RefPtr<ServiceWorkerInfo> mInstallingWorker; + + virtual ~ServiceWorkerRegistrationInfo(); + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISERVICEWORKERREGISTRATIONINFO + + const nsCString mScope; + + nsCOMPtr<nsIPrincipal> mPrincipal; + + nsTArray<nsCOMPtr<nsIServiceWorkerRegistrationInfoListener>> mListeners; + + // When unregister() is called on a registration, it is not immediately + // removed since documents may be controlled. It is marked as + // pendingUninstall and when all controlling documents go away, removed. + bool mPendingUninstall; + + ServiceWorkerRegistrationInfo(const nsACString& aScope, + nsIPrincipal* aPrincipal); + + already_AddRefed<ServiceWorkerInfo> + Newest() const + { + RefPtr<ServiceWorkerInfo> newest; + if (mInstallingWorker) { + newest = mInstallingWorker; + } else if (mWaitingWorker) { + newest = mWaitingWorker; + } else { + newest = mActiveWorker; + } + + return newest.forget(); + } + + already_AddRefed<ServiceWorkerInfo> + GetServiceWorkerInfoById(uint64_t aId); + + void + StartControllingADocument() + { + ++mControlledDocumentsCounter; + } + + void + StopControllingADocument() + { + MOZ_ASSERT(mControlledDocumentsCounter); + --mControlledDocumentsCounter; + } + + bool + IsControllingDocuments() const + { + return mActiveWorker && mControlledDocumentsCounter; + } + + void + Clear(); + + void + TryToActivateAsync(); + + void + TryToActivate(); + + void + Activate(); + + void + FinishActivate(bool aSuccess); + + void + RefreshLastUpdateCheckTime(); + + bool + IsLastUpdateCheckTimeOverOneDay() const; + + void + NotifyListenersOnChange(WhichServiceWorker aChangedWorkers); + + void + MaybeScheduleTimeCheckAndUpdate(); + + void + MaybeScheduleUpdate(); + + bool + CheckAndClearIfUpdateNeeded(); + + ServiceWorkerInfo* + GetEvaluating() const; + + ServiceWorkerInfo* + GetInstalling() const; + + ServiceWorkerInfo* + GetWaiting() const; + + ServiceWorkerInfo* + GetActive() const; + + // Set the given worker as the evaluating service worker. The worker + // state is not changed. + void + SetEvaluating(ServiceWorkerInfo* aServiceWorker); + + // Remove an existing evaluating worker, if present. The worker will + // be transitioned to the Redundant state. + void + ClearEvaluating(); + + // Remove an existing installing worker, if present. The worker will + // be transitioned to the Redundant state. + void + ClearInstalling(); + + // Transition the current evaluating worker to be the installing worker. The + // worker's state is update to Installing. + void + TransitionEvaluatingToInstalling(); + + // Transition the current installing worker to be the waiting worker. The + // worker's state is updated to Installed. + void + TransitionInstallingToWaiting(); + + // Override the current active worker. This is used during browser + // initialization to load persisted workers. Its also used to propagate + // active workers across child processes in e10s. This second use will + // go away once the ServiceWorkerManager moves to the parent process. + // The worker is transitioned to the Activated state. + void + SetActive(ServiceWorkerInfo* aServiceWorker); + + // Transition the current waiting worker to be the new active worker. The + // worker is updated to the Activating state. + void + TransitionWaitingToActive(); + + // Determine if the registration is actively performing work. + bool + IsIdle() const; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerregistrationinfo_h diff --git a/dom/workers/ServiceWorkerScriptCache.cpp b/dom/workers/ServiceWorkerScriptCache.cpp new file mode 100644 index 000000000..f44bb673c --- /dev/null +++ b/dom/workers/ServiceWorkerScriptCache.cpp @@ -0,0 +1,1060 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerScriptCache.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/CacheBinding.h" +#include "mozilla/dom/cache/CacheStorage.h" +#include "mozilla/dom/cache/Cache.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "nsICacheInfoChannel.h" +#include "nsIHttpChannelInternal.h" +#include "nsIStreamLoader.h" +#include "nsIThreadRetargetableRequest.h" + +#include "nsIInputStreamPump.h" +#include "nsIPrincipal.h" +#include "nsIScriptError.h" +#include "nsContentUtils.h" +#include "nsNetUtil.h" +#include "nsScriptLoader.h" +#include "ServiceWorkerManager.h" +#include "Workers.h" +#include "nsStringStream.h" + +using mozilla::dom::cache::Cache; +using mozilla::dom::cache::CacheStorage; + +BEGIN_WORKERS_NAMESPACE + +namespace serviceWorkerScriptCache { + +namespace { + +// XXX A sandbox nsIGlobalObject does not preserve its reflector, so |aSandbox| +// must be kept alive as long as the CacheStorage if you want to ensure that +// the CacheStorage will continue to work. Failures will manifest as errors +// like "JavaScript error: , line 0: TypeError: The expression cannot be +// converted to return the specified type." +already_AddRefed<CacheStorage> +CreateCacheStorage(JSContext* aCx, nsIPrincipal* aPrincipal, ErrorResult& aRv, + JS::MutableHandle<JSObject*> aSandbox) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + aRv = xpc->CreateSandbox(aCx, aPrincipal, aSandbox.address()); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + nsCOMPtr<nsIGlobalObject> sandboxGlobalObject = xpc::NativeGlobal(aSandbox); + if (!sandboxGlobalObject) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + // We assume private browsing is not enabled here. The ScriptLoader + // explicitly fails for private browsing so there should never be + // a service worker running in private browsing mode. Therefore if + // we are purging scripts or running a comparison algorithm we cannot + // be in private browing. + // + // Also, bypass the CacheStorage trusted origin checks. The ServiceWorker + // has validated the origin prior to this point. All the information + // to revalidate is not available now. + return CacheStorage::CreateOnMainThread(cache::CHROME_ONLY_NAMESPACE, + sandboxGlobalObject, aPrincipal, + false /* private browsing */, + true /* force trusted origin */, + aRv); +} + +class CompareManager; + +// This class downloads a URL from the network and then it calls +// NetworkFinished() in the CompareManager. +class CompareNetwork final : public nsIStreamLoaderObserver, + public nsIRequestObserver +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISTREAMLOADEROBSERVER + NS_DECL_NSIREQUESTOBSERVER + + explicit CompareNetwork(CompareManager* aManager) + : mManager(aManager) + { + MOZ_ASSERT(aManager); + AssertIsOnMainThread(); + } + + nsresult + Initialize(nsIPrincipal* aPrincipal, const nsAString& aURL, nsILoadGroup* aLoadGroup); + + void + Abort() + { + AssertIsOnMainThread(); + + MOZ_ASSERT(mChannel); + mChannel->Cancel(NS_BINDING_ABORTED); + mChannel = nullptr; + } + + const nsString& Buffer() const + { + AssertIsOnMainThread(); + return mBuffer; + } + +private: + ~CompareNetwork() + { + AssertIsOnMainThread(); + } + + RefPtr<CompareManager> mManager; + nsCOMPtr<nsIChannel> mChannel; + nsString mBuffer; +}; + +NS_IMPL_ISUPPORTS(CompareNetwork, nsIStreamLoaderObserver, + nsIRequestObserver) + +// This class gets a cached Response from the CacheStorage and then it calls +// CacheFinished() in the CompareManager. +class CompareCache final : public PromiseNativeHandler + , public nsIStreamLoaderObserver +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISTREAMLOADEROBSERVER + + explicit CompareCache(CompareManager* aManager) + : mManager(aManager) + , mState(WaitingForCache) + , mAborted(false) + { + MOZ_ASSERT(aManager); + AssertIsOnMainThread(); + } + + nsresult + Initialize(nsIPrincipal* aPrincipal, const nsAString& aURL, + const nsAString& aCacheName); + + void + Abort() + { + AssertIsOnMainThread(); + + MOZ_ASSERT(!mAborted); + mAborted = true; + + if (mPump) { + mPump->Cancel(NS_BINDING_ABORTED); + mPump = nullptr; + } + } + + // This class manages 2 promises: 1 is to retrieve cache object, and 2 is for + // the value from the cache. For this reason we have mState to know what + // reject/resolve callback we are handling. + + virtual void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + AssertIsOnMainThread(); + + if (mAborted) { + return; + } + + if (mState == WaitingForCache) { + ManageCacheResult(aCx, aValue); + return; + } + + MOZ_ASSERT(mState == WaitingForValue); + ManageValueResult(aCx, aValue); + } + + virtual void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override; + + const nsString& Buffer() const + { + AssertIsOnMainThread(); + return mBuffer; + } + + const nsString& URL() const + { + AssertIsOnMainThread(); + return mURL; + } + +private: + ~CompareCache() + { + AssertIsOnMainThread(); + } + + void + ManageCacheResult(JSContext* aCx, JS::Handle<JS::Value> aValue); + + void + ManageValueResult(JSContext* aCx, JS::Handle<JS::Value> aValue); + + RefPtr<CompareManager> mManager; + nsCOMPtr<nsIInputStreamPump> mPump; + + nsString mURL; + nsString mBuffer; + + enum { + WaitingForCache, + WaitingForValue + } mState; + + bool mAborted; +}; + +NS_IMPL_ISUPPORTS(CompareCache, nsIStreamLoaderObserver) + +class CompareManager final : public PromiseNativeHandler +{ +public: + NS_DECL_ISUPPORTS + + explicit CompareManager(ServiceWorkerRegistrationInfo* aRegistration, + CompareCallback* aCallback) + : mRegistration(aRegistration) + , mCallback(aCallback) + , mState(WaitingForOpen) + , mNetworkFinished(false) + , mCacheFinished(false) + , mInCache(false) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aRegistration); + } + + nsresult + Initialize(nsIPrincipal* aPrincipal, const nsAString& aURL, + const nsAString& aCacheName, nsILoadGroup* aLoadGroup) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + mURL = aURL; + + // Always create a CacheStorage since we want to write the network entry to + // the cache even if there isn't an existing one. + AutoJSAPI jsapi; + jsapi.Init(); + ErrorResult result; + mSandbox.init(jsapi.cx()); + mCacheStorage = CreateCacheStorage(jsapi.cx(), aPrincipal, result, &mSandbox); + if (NS_WARN_IF(result.Failed())) { + MOZ_ASSERT(!result.IsErrorWithMessage()); + Cleanup(); + return result.StealNSResult(); + } + + mCN = new CompareNetwork(this); + nsresult rv = mCN->Initialize(aPrincipal, aURL, aLoadGroup); + if (NS_WARN_IF(NS_FAILED(rv))) { + Cleanup(); + return rv; + } + + if (!aCacheName.IsEmpty()) { + mCC = new CompareCache(this); + rv = mCC->Initialize(aPrincipal, aURL, aCacheName); + if (NS_WARN_IF(NS_FAILED(rv))) { + mCN->Abort(); + Cleanup(); + return rv; + } + } + + return NS_OK; + } + + const nsString& + URL() const + { + AssertIsOnMainThread(); + return mURL; + } + + void + SetMaxScope(const nsACString& aMaxScope) + { + MOZ_ASSERT(!mNetworkFinished); + mMaxScope = aMaxScope; + } + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetRegistration() + { + RefPtr<ServiceWorkerRegistrationInfo> copy = mRegistration.get(); + return copy.forget(); + } + + void + NetworkFinished(nsresult aStatus) + { + AssertIsOnMainThread(); + + mNetworkFinished = true; + + if (NS_WARN_IF(NS_FAILED(aStatus))) { + if (mCC) { + mCC->Abort(); + } + + ComparisonFinished(aStatus, false); + return; + } + + MaybeCompare(); + } + + void + CacheFinished(nsresult aStatus, bool aInCache) + { + AssertIsOnMainThread(); + + mCacheFinished = true; + mInCache = aInCache; + + if (NS_WARN_IF(NS_FAILED(aStatus))) { + if (mCN) { + mCN->Abort(); + } + + ComparisonFinished(aStatus, false); + return; + } + + MaybeCompare(); + } + + void + MaybeCompare() + { + AssertIsOnMainThread(); + + if (!mNetworkFinished || (mCC && !mCacheFinished)) { + return; + } + + if (!mCC || !mInCache) { + ComparisonFinished(NS_OK, false); + return; + } + + ComparisonFinished(NS_OK, mCC->Buffer().Equals(mCN->Buffer())); + } + + // This class manages 2 promises: 1 is to retrieve Cache object, and 2 is to + // Put the value in the cache. For this reason we have mState to know what + // callback we are handling. + void + ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCallback); + + if (mState == WaitingForOpen) { + if (NS_WARN_IF(!aValue.isObject())) { + Fail(NS_ERROR_FAILURE); + return; + } + + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + if (NS_WARN_IF(!obj)) { + Fail(NS_ERROR_FAILURE); + return; + } + + RefPtr<Cache> cache; + nsresult rv = UNWRAP_OBJECT(Cache, obj, cache); + if (NS_WARN_IF(NS_FAILED(rv))) { + Fail(rv); + return; + } + + WriteToCache(cache); + return; + } + + MOZ_ASSERT(mState == WaitingForPut); + mCallback->ComparisonResult(NS_OK, false /* aIsEqual */, + mNewCacheName, mMaxScope); + Cleanup(); + } + + void + RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override + { + AssertIsOnMainThread(); + if (mState == WaitingForOpen) { + NS_WARNING("Could not open cache."); + } else { + NS_WARNING("Could not write to cache."); + } + Fail(NS_ERROR_FAILURE); + } + + CacheStorage* + CacheStorage_() + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCacheStorage); + return mCacheStorage; + } + + void + InitChannelInfo(nsIChannel* aChannel) + { + mChannelInfo.InitFromChannel(aChannel); + } + + nsresult + SetPrincipalInfo(nsIChannel* aChannel) + { + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + NS_ASSERTION(ssm, "Should never be null!"); + + nsCOMPtr<nsIPrincipal> channelPrincipal; + nsresult rv = ssm->GetChannelResultPrincipal(aChannel, getter_AddRefs(channelPrincipal)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(new mozilla::ipc::PrincipalInfo()); + rv = PrincipalToPrincipalInfo(channelPrincipal, principalInfo.get()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + mPrincipalInfo = Move(principalInfo); + return NS_OK; + } + +private: + ~CompareManager() + { + AssertIsOnMainThread(); + MOZ_ASSERT(!mCC); + MOZ_ASSERT(!mCN); + } + + void + Fail(nsresult aStatus) + { + AssertIsOnMainThread(); + mCallback->ComparisonResult(aStatus, false /* aIsEqual */, + EmptyString(), EmptyCString()); + Cleanup(); + } + + void + Cleanup() + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCallback); + mCallback = nullptr; + mCN = nullptr; + mCC = nullptr; + } + + void + ComparisonFinished(nsresult aStatus, bool aIsEqual) + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCallback); + + if (NS_WARN_IF(NS_FAILED(aStatus))) { + Fail(aStatus); + return; + } + + if (aIsEqual) { + mCallback->ComparisonResult(aStatus, aIsEqual, EmptyString(), mMaxScope); + Cleanup(); + return; + } + + // Write to Cache so ScriptLoader reads succeed. + WriteNetworkBufferToNewCache(); + } + + void + WriteNetworkBufferToNewCache() + { + AssertIsOnMainThread(); + MOZ_ASSERT(mCN); + MOZ_ASSERT(mCacheStorage); + MOZ_ASSERT(mNewCacheName.IsEmpty()); + + ErrorResult result; + result = serviceWorkerScriptCache::GenerateCacheName(mNewCacheName); + if (NS_WARN_IF(result.Failed())) { + MOZ_ASSERT(!result.IsErrorWithMessage()); + Fail(result.StealNSResult()); + return; + } + + RefPtr<Promise> cacheOpenPromise = mCacheStorage->Open(mNewCacheName, result); + if (NS_WARN_IF(result.Failed())) { + MOZ_ASSERT(!result.IsErrorWithMessage()); + Fail(result.StealNSResult()); + return; + } + + cacheOpenPromise->AppendNativeHandler(this); + } + + void + WriteToCache(Cache* aCache) + { + AssertIsOnMainThread(); + MOZ_ASSERT(aCache); + MOZ_ASSERT(mState == WaitingForOpen); + + ErrorResult result; + nsCOMPtr<nsIInputStream> body; + result = NS_NewCStringInputStream(getter_AddRefs(body), + NS_ConvertUTF16toUTF8(mCN->Buffer())); + if (NS_WARN_IF(result.Failed())) { + MOZ_ASSERT(!result.IsErrorWithMessage()); + Fail(result.StealNSResult()); + return; + } + + RefPtr<InternalResponse> ir = + new InternalResponse(200, NS_LITERAL_CSTRING("OK")); + ir->SetBody(body, mCN->Buffer().Length()); + + ir->InitChannelInfo(mChannelInfo); + if (mPrincipalInfo) { + ir->SetPrincipalInfo(Move(mPrincipalInfo)); + } + + RefPtr<Response> response = new Response(aCache->GetGlobalObject(), ir); + + RequestOrUSVString request; + request.SetAsUSVString().Rebind(URL().Data(), URL().Length()); + + // For now we have to wait until the Put Promise is fulfilled before we can + // continue since Cache does not yet support starting a read that is being + // written to. + RefPtr<Promise> cachePromise = aCache->Put(request, *response, result); + if (NS_WARN_IF(result.Failed())) { + MOZ_ASSERT(!result.IsErrorWithMessage()); + Fail(result.StealNSResult()); + return; + } + + mState = WaitingForPut; + cachePromise->AppendNativeHandler(this); + } + + RefPtr<ServiceWorkerRegistrationInfo> mRegistration; + RefPtr<CompareCallback> mCallback; + JS::PersistentRooted<JSObject*> mSandbox; + RefPtr<CacheStorage> mCacheStorage; + + RefPtr<CompareNetwork> mCN; + RefPtr<CompareCache> mCC; + + nsString mURL; + // Only used if the network script has changed and needs to be cached. + nsString mNewCacheName; + + ChannelInfo mChannelInfo; + + UniquePtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo; + + nsCString mMaxScope; + + enum { + WaitingForOpen, + WaitingForPut + } mState; + + bool mNetworkFinished; + bool mCacheFinished; + bool mInCache; +}; + +NS_IMPL_ISUPPORTS0(CompareManager) + +nsresult +CompareNetwork::Initialize(nsIPrincipal* aPrincipal, const nsAString& aURL, nsILoadGroup* aLoadGroup) +{ + MOZ_ASSERT(aPrincipal); + AssertIsOnMainThread(); + + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), aURL, nullptr, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsILoadGroup> loadGroup; + rv = NS_NewLoadGroup(getter_AddRefs(loadGroup), aPrincipal); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsLoadFlags flags = nsIChannel::LOAD_BYPASS_SERVICE_WORKER; + RefPtr<ServiceWorkerRegistrationInfo> registration = + mManager->GetRegistration(); + if (registration->IsLastUpdateCheckTimeOverOneDay()) { + flags |= nsIRequest::LOAD_BYPASS_CACHE; + } + + // Note that because there is no "serviceworker" RequestContext type, we can + // use the TYPE_INTERNAL_SCRIPT content policy types when loading a service + // worker. + rv = NS_NewChannel(getter_AddRefs(mChannel), + uri, aPrincipal, + nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED, + nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER, + loadGroup, + nullptr, // aCallbacks + flags); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel); + if (httpChannel) { + // Spec says no redirects allowed for SW scripts. + httpChannel->SetRedirectionLimit(0); + + httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Service-Worker"), + NS_LITERAL_CSTRING("script"), + /* merge */ false); + } + + nsCOMPtr<nsIStreamLoader> loader; + rv = NS_NewStreamLoader(getter_AddRefs(loader), this, this); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + rv = mChannel->AsyncOpen2(loader); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +NS_IMETHODIMP +CompareNetwork::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) +{ + AssertIsOnMainThread(); + + // If no channel, Abort() has been called. + if (!mChannel) { + return NS_OK; + } + +#ifdef DEBUG + nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); + MOZ_ASSERT(channel == mChannel); +#endif + + mManager->InitChannelInfo(mChannel); + nsresult rv = mManager->SetPrincipalInfo(mChannel); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +NS_IMETHODIMP +CompareNetwork::OnStopRequest(nsIRequest* aRequest, nsISupports* aContext, + nsresult aStatusCode) +{ + // Nothing to do here! + return NS_OK; +} + +NS_IMETHODIMP +CompareNetwork::OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aLen, + const uint8_t* aString) +{ + AssertIsOnMainThread(); + + // If no channel, Abort() has been called. + if (!mChannel) { + return NS_OK; + } + + if (NS_WARN_IF(NS_FAILED(aStatus))) { + if (aStatus == NS_ERROR_REDIRECT_LOOP) { + mManager->NetworkFinished(NS_ERROR_DOM_SECURITY_ERR); + } else { + mManager->NetworkFinished(aStatus); + } + return NS_OK; + } + + nsCOMPtr<nsIRequest> request; + nsresult rv = aLoader->GetRequest(getter_AddRefs(request)); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->NetworkFinished(rv); + return NS_OK; + } + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(request); + MOZ_ASSERT(httpChannel, "How come we don't have an HTTP channel?"); + + bool requestSucceeded; + rv = httpChannel->GetRequestSucceeded(&requestSucceeded); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->NetworkFinished(rv); + return NS_OK; + } + + if (NS_WARN_IF(!requestSucceeded)) { + // Get the stringified numeric status code, not statusText which could be + // something misleading like OK for a 404. + uint32_t status = 0; + httpChannel->GetResponseStatus(&status); // don't care if this fails, use 0. + nsAutoString statusAsText; + statusAsText.AppendInt(status); + + RefPtr<ServiceWorkerRegistrationInfo> registration = mManager->GetRegistration(); + ServiceWorkerManager::LocalizeAndReportToAllClients( + registration->mScope, "ServiceWorkerRegisterNetworkError", + nsTArray<nsString> { NS_ConvertUTF8toUTF16(registration->mScope), + statusAsText, mManager->URL() }); + mManager->NetworkFinished(NS_ERROR_FAILURE); + return NS_OK; + } + + nsAutoCString maxScope; + // Note: we explicitly don't check for the return value here, because the + // absence of the header is not an error condition. + Unused << httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("Service-Worker-Allowed"), + maxScope); + + mManager->SetMaxScope(maxScope); + + bool isFromCache = false; + nsCOMPtr<nsICacheInfoChannel> cacheChannel(do_QueryInterface(httpChannel)); + if (cacheChannel) { + cacheChannel->IsFromCache(&isFromCache); + } + + // [9.2 Update]4.13, If response's cache state is not "local", + // set registration's last update check time to the current time + if (!isFromCache) { + RefPtr<ServiceWorkerRegistrationInfo> registration = + mManager->GetRegistration(); + registration->RefreshLastUpdateCheckTime(); + } + + nsAutoCString mimeType; + rv = httpChannel->GetContentType(mimeType); + if (NS_WARN_IF(NS_FAILED(rv))) { + // We should only end up here if !mResponseHead in the channel. If headers + // were received but no content type was specified, we'll be given + // UNKNOWN_CONTENT_TYPE "application/x-unknown-content-type" and so fall + // into the next case with its better error message. + mManager->NetworkFinished(NS_ERROR_DOM_SECURITY_ERR); + return rv; + } + + if (!mimeType.LowerCaseEqualsLiteral("text/javascript") && + !mimeType.LowerCaseEqualsLiteral("application/x-javascript") && + !mimeType.LowerCaseEqualsLiteral("application/javascript")) { + RefPtr<ServiceWorkerRegistrationInfo> registration = mManager->GetRegistration(); + ServiceWorkerManager::LocalizeAndReportToAllClients( + registration->mScope, "ServiceWorkerRegisterMimeTypeError", + nsTArray<nsString> { NS_ConvertUTF8toUTF16(registration->mScope), + NS_ConvertUTF8toUTF16(mimeType), mManager->URL() }); + mManager->NetworkFinished(NS_ERROR_DOM_SECURITY_ERR); + return rv; + } + + char16_t* buffer = nullptr; + size_t len = 0; + + rv = nsScriptLoader::ConvertToUTF16(httpChannel, aString, aLen, + NS_LITERAL_STRING("UTF-8"), nullptr, + buffer, len); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->NetworkFinished(rv); + return rv; + } + + mBuffer.Adopt(buffer, len); + + mManager->NetworkFinished(NS_OK); + return NS_OK; +} + +nsresult +CompareCache::Initialize(nsIPrincipal* aPrincipal, const nsAString& aURL, + const nsAString& aCacheName) +{ + MOZ_ASSERT(aPrincipal); + AssertIsOnMainThread(); + + mURL = aURL; + + ErrorResult rv; + + RefPtr<Promise> promise = mManager->CacheStorage_()->Open(aCacheName, rv); + if (NS_WARN_IF(rv.Failed())) { + MOZ_ASSERT(!rv.IsErrorWithMessage()); + return rv.StealNSResult(); + } + + promise->AppendNativeHandler(this); + return NS_OK; +} + +NS_IMETHODIMP +CompareCache::OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aLen, + const uint8_t* aString) +{ + AssertIsOnMainThread(); + + if (mAborted) { + return aStatus; + } + + if (NS_WARN_IF(NS_FAILED(aStatus))) { + mManager->CacheFinished(aStatus, false); + return aStatus; + } + + char16_t* buffer = nullptr; + size_t len = 0; + + nsresult rv = nsScriptLoader::ConvertToUTF16(nullptr, aString, aLen, + NS_LITERAL_STRING("UTF-8"), + nullptr, buffer, len); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->CacheFinished(rv, false); + return rv; + } + + mBuffer.Adopt(buffer, len); + + mManager->CacheFinished(NS_OK, true); + return NS_OK; +} + +void +CompareCache::RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + + if (mAborted) { + return; + } + + mManager->CacheFinished(NS_ERROR_FAILURE, false); +} + +void +CompareCache::ManageCacheResult(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + + if (NS_WARN_IF(!aValue.isObject())) { + mManager->CacheFinished(NS_ERROR_FAILURE, false); + return; + } + + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + + Cache* cache = nullptr; + nsresult rv = UNWRAP_OBJECT(Cache, &obj, cache); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->CacheFinished(rv, false); + return; + } + + RequestOrUSVString request; + request.SetAsUSVString().Rebind(mURL.Data(), mURL.Length()); + ErrorResult error; + CacheQueryOptions params; + RefPtr<Promise> promise = cache->Match(request, params, error); + if (NS_WARN_IF(error.Failed())) { + mManager->CacheFinished(error.StealNSResult(), false); + return; + } + + promise->AppendNativeHandler(this); + mState = WaitingForValue; +} + +void +CompareCache::ManageValueResult(JSContext* aCx, JS::Handle<JS::Value> aValue) +{ + AssertIsOnMainThread(); + + // The cache returns undefined if the object is not stored. + if (aValue.isUndefined()) { + mManager->CacheFinished(NS_OK, false); + return; + } + + MOZ_ASSERT(aValue.isObject()); + + JS::Rooted<JSObject*> obj(aCx, &aValue.toObject()); + + Response* response = nullptr; + nsresult rv = UNWRAP_OBJECT(Response, &obj, response); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->CacheFinished(rv, false); + return; + } + + MOZ_ASSERT(response->Ok()); + + nsCOMPtr<nsIInputStream> inputStream; + response->GetBody(getter_AddRefs(inputStream)); + MOZ_ASSERT(inputStream); + + MOZ_ASSERT(!mPump); + rv = NS_NewInputStreamPump(getter_AddRefs(mPump), inputStream); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->CacheFinished(rv, false); + return; + } + + nsCOMPtr<nsIStreamLoader> loader; + rv = NS_NewStreamLoader(getter_AddRefs(loader), this); + if (NS_WARN_IF(NS_FAILED(rv))) { + mManager->CacheFinished(rv, false); + return; + } + + rv = mPump->AsyncRead(loader, nullptr); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPump = nullptr; + mManager->CacheFinished(rv, false); + return; + } + + nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(mPump); + if (rr) { + nsCOMPtr<nsIEventTarget> sts = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + rv = rr->RetargetDeliveryTo(sts); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPump = nullptr; + mManager->CacheFinished(rv, false); + return; + } + } +} + +} // namespace + +nsresult +PurgeCache(nsIPrincipal* aPrincipal, const nsAString& aCacheName) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + + if (aCacheName.IsEmpty()) { + return NS_OK; + } + + AutoJSAPI jsapi; + jsapi.Init(); + ErrorResult rv; + JS::Rooted<JSObject*> sandboxObject(jsapi.cx()); + RefPtr<CacheStorage> cacheStorage = CreateCacheStorage(jsapi.cx(), aPrincipal, rv, &sandboxObject); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + // We use the ServiceWorker scope as key for the cacheStorage. + RefPtr<Promise> promise = + cacheStorage->Delete(aCacheName, rv); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + // We don't actually care about the result of the delete operation. + return NS_OK; +} + +nsresult +GenerateCacheName(nsAString& aName) +{ + nsresult rv; + nsCOMPtr<nsIUUIDGenerator> uuidGenerator = + do_GetService("@mozilla.org/uuid-generator;1", &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsID id; + rv = uuidGenerator->GenerateUUIDInPlace(&id); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + char chars[NSID_LENGTH]; + id.ToProvidedString(chars); + + // NSID_LENGTH counts the null terminator. + aName.AssignASCII(chars, NSID_LENGTH - 1); + + return NS_OK; +} + +nsresult +Compare(ServiceWorkerRegistrationInfo* aRegistration, + nsIPrincipal* aPrincipal, const nsAString& aCacheName, + const nsAString& aURL, CompareCallback* aCallback, + nsILoadGroup* aLoadGroup) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aRegistration); + MOZ_ASSERT(aPrincipal); + MOZ_ASSERT(!aURL.IsEmpty()); + MOZ_ASSERT(aCallback); + + RefPtr<CompareManager> cm = new CompareManager(aRegistration, aCallback); + + nsresult rv = cm->Initialize(aPrincipal, aURL, aCacheName, aLoadGroup); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +} // namespace serviceWorkerScriptCache + +END_WORKERS_NAMESPACE diff --git a/dom/workers/ServiceWorkerScriptCache.h b/dom/workers/ServiceWorkerScriptCache.h new file mode 100644 index 000000000..113ed0983 --- /dev/null +++ b/dom/workers/ServiceWorkerScriptCache.h @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_ServiceWorkerScriptCache_h +#define mozilla_dom_workers_ServiceWorkerScriptCache_h + +#include "nsString.h" + +class nsILoadGroup; +class nsIPrincipal; + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerRegistrationInfo; + +namespace serviceWorkerScriptCache { + +nsresult +PurgeCache(nsIPrincipal* aPrincipal, const nsAString& aCacheName); + +nsresult +GenerateCacheName(nsAString& aName); + +class CompareCallback +{ +public: + /* + * If there is an error, ignore aInCacheAndEqual and aNewCacheName. + * On success, if the cached result and network result matched, + * aInCacheAndEqual will be true and no new cache name is passed, otherwise + * use the new cache name to load the ServiceWorker. + */ + virtual void + ComparisonResult(nsresult aStatus, + bool aInCacheAndEqual, + const nsAString& aNewCacheName, + const nsACString& aMaxScope) = 0; + + NS_IMETHOD_(MozExternalRefCountType) AddRef() = 0; + NS_IMETHOD_(MozExternalRefCountType) Release() = 0; +}; + +nsresult +Compare(ServiceWorkerRegistrationInfo* aRegistration, + nsIPrincipal* aPrincipal, const nsAString& aCacheName, + const nsAString& aURL, CompareCallback* aCallback, nsILoadGroup* aLoadGroup); + +} // namespace serviceWorkerScriptCache + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_ServiceWorkerScriptCache_h diff --git a/dom/workers/ServiceWorkerUnregisterJob.cpp b/dom/workers/ServiceWorkerUnregisterJob.cpp new file mode 100644 index 000000000..8fd76b63d --- /dev/null +++ b/dom/workers/ServiceWorkerUnregisterJob.cpp @@ -0,0 +1,151 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerUnregisterJob.h" + +#include "nsIPushService.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerUnregisterJob::PushUnsubscribeCallback final : + public nsIUnsubscribeResultCallback +{ +public: + NS_DECL_ISUPPORTS + + explicit PushUnsubscribeCallback(ServiceWorkerUnregisterJob* aJob) + : mJob(aJob) + { + AssertIsOnMainThread(); + } + + NS_IMETHOD + OnUnsubscribe(nsresult aStatus, bool) override + { + // Warn if unsubscribing fails, but don't prevent the worker from + // unregistering. + Unused << NS_WARN_IF(NS_FAILED(aStatus)); + mJob->Unregister(); + return NS_OK; + } + +private: + ~PushUnsubscribeCallback() + { + } + + RefPtr<ServiceWorkerUnregisterJob> mJob; +}; + +NS_IMPL_ISUPPORTS(ServiceWorkerUnregisterJob::PushUnsubscribeCallback, + nsIUnsubscribeResultCallback) + +ServiceWorkerUnregisterJob::ServiceWorkerUnregisterJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + bool aSendToParent) + : ServiceWorkerJob(Type::Unregister, aPrincipal, aScope, EmptyCString()) + , mResult(false) + , mSendToParent(aSendToParent) +{ +} + +bool +ServiceWorkerUnregisterJob::GetResult() const +{ + AssertIsOnMainThread(); + return mResult; +} + +ServiceWorkerUnregisterJob::~ServiceWorkerUnregisterJob() +{ +} + +void +ServiceWorkerUnregisterJob::AsyncExecute() +{ + AssertIsOnMainThread(); + + if (Canceled()) { + Finish(NS_ERROR_DOM_ABORT_ERR); + return; + } + + // Push API, section 5: "When a service worker registration is unregistered, + // any associated push subscription must be deactivated." To ensure the + // service worker registration isn't cleared as we're unregistering, we + // unsubscribe first. + nsCOMPtr<nsIPushService> pushService = + do_GetService("@mozilla.org/push/Service;1"); + if (NS_WARN_IF(!pushService)) { + Unregister(); + return; + } + nsCOMPtr<nsIUnsubscribeResultCallback> unsubscribeCallback = + new PushUnsubscribeCallback(this); + nsresult rv = pushService->Unsubscribe(NS_ConvertUTF8toUTF16(mScope), + mPrincipal, unsubscribeCallback); + if (NS_WARN_IF(NS_FAILED(rv))) { + Unregister(); + } +} + +void +ServiceWorkerUnregisterJob::Unregister() +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (Canceled() || !swm) { + Finish(NS_ERROR_DOM_ABORT_ERR); + return; + } + + // Step 1 of the Unregister algorithm requires checking that the + // client origin matches the scope's origin. We perform this in + // registration->update() method directly since we don't have that + // client information available here. + + // "Let registration be the result of running [[Get Registration]] + // algorithm passing scope as the argument." + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(mPrincipal, mScope); + if (!registration) { + // "If registration is null, then, resolve promise with false." + Finish(NS_OK); + return; + } + + // Note, we send the message to remove the registration from disk now even + // though we may only set the mPendingUninstall flag below. This is + // necessary to ensure the registration is removed if the controlled + // clients are closed by shutting down the browser. If the registration + // is resurrected by clearing mPendingUninstall then it should be saved + // to disk again. + if (mSendToParent && !registration->mPendingUninstall) { + swm->MaybeSendUnregister(mPrincipal, mScope); + } + + // "Set registration's uninstalling flag." + registration->mPendingUninstall = true; + + // "Resolve promise with true" + mResult = true; + InvokeResultCallbacks(NS_OK); + + // "If no service worker client is using registration..." + if (!registration->IsControllingDocuments() && registration->IsIdle()) { + // "Invoke [[Clear Registration]]..." + swm->RemoveRegistration(registration); + } + + Finish(NS_OK); +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerUnregisterJob.h b/dom/workers/ServiceWorkerUnregisterJob.h new file mode 100644 index 000000000..976f15a2c --- /dev/null +++ b/dom/workers/ServiceWorkerUnregisterJob.h @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerunregisterjob_h +#define mozilla_dom_workers_serviceworkerunregisterjob_h + +#include "ServiceWorkerJob.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerUnregisterJob final : public ServiceWorkerJob +{ +public: + ServiceWorkerUnregisterJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + bool aSendToParent); + + bool + GetResult() const; + +private: + class PushUnsubscribeCallback; + + virtual ~ServiceWorkerUnregisterJob(); + + virtual void + AsyncExecute() override; + + void + Unregister(); + + bool mResult; + bool mSendToParent; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerunregisterjob_h diff --git a/dom/workers/ServiceWorkerUpdateJob.cpp b/dom/workers/ServiceWorkerUpdateJob.cpp new file mode 100644 index 000000000..614fe4de5 --- /dev/null +++ b/dom/workers/ServiceWorkerUpdateJob.cpp @@ -0,0 +1,552 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ServiceWorkerUpdateJob.h" + +#include "nsIScriptError.h" +#include "nsIURL.h" +#include "ServiceWorkerScriptCache.h" +#include "Workers.h" + +namespace mozilla { +namespace dom { +namespace workers { + +namespace { + +/** + * The spec mandates slightly different behaviors for computing the scope + * prefix string in case a Service-Worker-Allowed header is specified versus + * when it's not available. + * + * With the header: + * "Set maxScopeString to "/" concatenated with the strings in maxScope's + * path (including empty strings), separated from each other by "/"." + * Without the header: + * "Set maxScopeString to "/" concatenated with the strings, except the last + * string that denotes the script's file name, in registration's registering + * script url's path (including empty strings), separated from each other by + * "/"." + * + * In simpler terms, if the header is not present, we should only use the + * "directory" part of the pathname, and otherwise the entire pathname should be + * used. ScopeStringPrefixMode allows the caller to specify the desired + * behavior. + */ +enum ScopeStringPrefixMode { + eUseDirectory, + eUsePath +}; + +nsresult +GetRequiredScopeStringPrefix(nsIURI* aScriptURI, nsACString& aPrefix, + ScopeStringPrefixMode aPrefixMode) +{ + nsresult rv = aScriptURI->GetPrePath(aPrefix); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (aPrefixMode == eUseDirectory) { + nsCOMPtr<nsIURL> scriptURL(do_QueryInterface(aScriptURI)); + if (NS_WARN_IF(!scriptURL)) { + return NS_ERROR_FAILURE; + } + + nsAutoCString dir; + rv = scriptURL->GetDirectory(dir); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + aPrefix.Append(dir); + } else if (aPrefixMode == eUsePath) { + nsAutoCString path; + rv = aScriptURI->GetPath(path); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + aPrefix.Append(path); + } else { + MOZ_ASSERT_UNREACHABLE("Invalid value for aPrefixMode"); + } + return NS_OK; +} + +} // anonymous namespace + +class ServiceWorkerUpdateJob::CompareCallback final : public serviceWorkerScriptCache::CompareCallback +{ + RefPtr<ServiceWorkerUpdateJob> mJob; + + ~CompareCallback() + { + } + +public: + explicit CompareCallback(ServiceWorkerUpdateJob* aJob) + : mJob(aJob) + { + MOZ_ASSERT(mJob); + } + + virtual void + ComparisonResult(nsresult aStatus, + bool aInCacheAndEqual, + const nsAString& aNewCacheName, + const nsACString& aMaxScope) override + { + mJob->ComparisonResult(aStatus, aInCacheAndEqual, aNewCacheName, aMaxScope); + } + + NS_INLINE_DECL_REFCOUNTING(ServiceWorkerUpdateJob::CompareCallback, override) +}; + +class ServiceWorkerUpdateJob::ContinueUpdateRunnable final : public LifeCycleEventCallback +{ + nsMainThreadPtrHandle<ServiceWorkerUpdateJob> mJob; + bool mSuccess; + +public: + explicit ContinueUpdateRunnable(const nsMainThreadPtrHandle<ServiceWorkerUpdateJob>& aJob) + : mJob(aJob) + , mSuccess(false) + { + AssertIsOnMainThread(); + } + + void + SetResult(bool aResult) override + { + mSuccess = aResult; + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + mJob->ContinueUpdateAfterScriptEval(mSuccess); + mJob = nullptr; + return NS_OK; + } +}; + +class ServiceWorkerUpdateJob::ContinueInstallRunnable final : public LifeCycleEventCallback +{ + nsMainThreadPtrHandle<ServiceWorkerUpdateJob> mJob; + bool mSuccess; + +public: + explicit ContinueInstallRunnable(const nsMainThreadPtrHandle<ServiceWorkerUpdateJob>& aJob) + : mJob(aJob) + , mSuccess(false) + { + AssertIsOnMainThread(); + } + + void + SetResult(bool aResult) override + { + mSuccess = aResult; + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + mJob->ContinueAfterInstallEvent(mSuccess); + mJob = nullptr; + return NS_OK; + } +}; + +ServiceWorkerUpdateJob::ServiceWorkerUpdateJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup) + : ServiceWorkerJob(Type::Update, aPrincipal, aScope, aScriptSpec) + , mLoadGroup(aLoadGroup) +{ +} + +already_AddRefed<ServiceWorkerRegistrationInfo> +ServiceWorkerUpdateJob::GetRegistration() const +{ + AssertIsOnMainThread(); + RefPtr<ServiceWorkerRegistrationInfo> ref = mRegistration; + return ref.forget(); +} + +ServiceWorkerUpdateJob::ServiceWorkerUpdateJob(Type aType, + nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup) + : ServiceWorkerJob(aType, aPrincipal, aScope, aScriptSpec) + , mLoadGroup(aLoadGroup) +{ +} + +ServiceWorkerUpdateJob::~ServiceWorkerUpdateJob() +{ +} + +void +ServiceWorkerUpdateJob::FailUpdateJob(ErrorResult& aRv) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aRv.Failed()); + + // Cleanup after a failed installation. This essentially implements + // step 12 of the Install algorithm. + // + // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#installation-algorithm + // + // The spec currently only runs this after an install event fails, + // but we must handle many more internal errors. So we check for + // cleanup on every non-successful exit. + if (mRegistration) { + mRegistration->ClearEvaluating(); + mRegistration->ClearInstalling(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->MaybeRemoveRegistration(mRegistration); + } + } + + mRegistration = nullptr; + + Finish(aRv); +} + +void +ServiceWorkerUpdateJob::FailUpdateJob(nsresult aRv) +{ + ErrorResult rv(aRv); + FailUpdateJob(rv); +} + +void +ServiceWorkerUpdateJob::AsyncExecute() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(GetType() == Type::Update); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (Canceled() || !swm) { + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } + + // Begin step 1 of the Update algorithm. + // + // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#update-algorithm + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(mPrincipal, mScope); + + if (!registration || registration->mPendingUninstall) { + ErrorResult rv; + rv.ThrowTypeError<MSG_SW_UPDATE_BAD_REGISTRATION>(NS_ConvertUTF8toUTF16(mScope), + NS_LITERAL_STRING("uninstalled")); + FailUpdateJob(rv); + return; + } + + // If a Register job with a new script executed ahead of us in the job queue, + // then our update for the old script no longer makes sense. Simply abort + // in this case. + RefPtr<ServiceWorkerInfo> newest = registration->Newest(); + if (newest && !mScriptSpec.Equals(newest->ScriptSpec())) { + ErrorResult rv; + rv.ThrowTypeError<MSG_SW_UPDATE_BAD_REGISTRATION>(NS_ConvertUTF8toUTF16(mScope), + NS_LITERAL_STRING("changed")); + FailUpdateJob(rv); + return; + } + + SetRegistration(registration); + Update(); +} + +void +ServiceWorkerUpdateJob::SetRegistration(ServiceWorkerRegistrationInfo* aRegistration) +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(!mRegistration); + MOZ_ASSERT(aRegistration); + mRegistration = aRegistration; +} + +void +ServiceWorkerUpdateJob::Update() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!Canceled()); + + // SetRegistration() must be called before Update(). + MOZ_ASSERT(mRegistration); + MOZ_ASSERT(!mRegistration->GetInstalling()); + + // Begin the script download and comparison steps starting at step 5 + // of the Update algorithm. + + RefPtr<ServiceWorkerInfo> workerInfo = mRegistration->Newest(); + nsAutoString cacheName; + + // If the script has not changed, we need to perform a byte-for-byte + // comparison. + if (workerInfo && workerInfo->ScriptSpec().Equals(mScriptSpec)) { + cacheName = workerInfo->CacheName(); + } + + RefPtr<CompareCallback> callback = new CompareCallback(this); + + nsresult rv = + serviceWorkerScriptCache::Compare(mRegistration, mPrincipal, cacheName, + NS_ConvertUTF8toUTF16(mScriptSpec), + callback, mLoadGroup); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(rv); + return; + } +} + +void +ServiceWorkerUpdateJob::ComparisonResult(nsresult aStatus, + bool aInCacheAndEqual, + const nsAString& aNewCacheName, + const nsACString& aMaxScope) +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (NS_WARN_IF(Canceled() || !swm)) { + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } + + // Handle failure of the download or comparison. This is part of Update + // step 5 as "If the algorithm asynchronously completes with null, then:". + if (NS_WARN_IF(NS_FAILED(aStatus))) { + FailUpdateJob(aStatus); + return; + } + + // The spec validates the response before performing the byte-for-byte check. + // Here we perform the comparison in another module and then validate the + // script URL and scope. Make sure to do this validation before accepting + // an byte-for-byte match since the service-worker-allowed header might have + // changed since the last time it was installed. + + // This is step 2 the "validate response" section of Update algorithm step 5. + // Step 1 is performed in the serviceWorkerScriptCache code. + + nsCOMPtr<nsIURI> scriptURI; + nsresult rv = NS_NewURI(getter_AddRefs(scriptURI), mScriptSpec); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR); + return; + } + + nsCOMPtr<nsIURI> maxScopeURI; + if (!aMaxScope.IsEmpty()) { + rv = NS_NewURI(getter_AddRefs(maxScopeURI), aMaxScope, + nullptr, scriptURI); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR); + return; + } + } + + nsAutoCString defaultAllowedPrefix; + rv = GetRequiredScopeStringPrefix(scriptURI, defaultAllowedPrefix, + eUseDirectory); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR); + return; + } + + nsAutoCString maxPrefix(defaultAllowedPrefix); + if (maxScopeURI) { + rv = GetRequiredScopeStringPrefix(maxScopeURI, maxPrefix, eUsePath); + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR); + return; + } + } + + if (!StringBeginsWith(mRegistration->mScope, maxPrefix)) { + nsXPIDLString message; + NS_ConvertUTF8toUTF16 reportScope(mRegistration->mScope); + NS_ConvertUTF8toUTF16 reportMaxPrefix(maxPrefix); + const char16_t* params[] = { reportScope.get(), reportMaxPrefix.get() }; + + rv = nsContentUtils::FormatLocalizedString(nsContentUtils::eDOM_PROPERTIES, + "ServiceWorkerScopePathMismatch", + params, message); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to format localized string"); + swm->ReportToAllClients(mScope, + message, + EmptyString(), + EmptyString(), 0, 0, + nsIScriptError::errorFlag); + FailUpdateJob(NS_ERROR_DOM_SECURITY_ERR); + return; + } + + // The response has been validated, so now we can consider if its a + // byte-for-byte match. This is step 6 of the Update algorithm. + if (aInCacheAndEqual) { + Finish(NS_OK); + return; + } + + Telemetry::Accumulate(Telemetry::SERVICE_WORKER_UPDATED, 1); + + // Begin step 7 of the Update algorithm to evaluate the new script. + + RefPtr<ServiceWorkerInfo> sw = + new ServiceWorkerInfo(mRegistration->mPrincipal, + mRegistration->mScope, + mScriptSpec, aNewCacheName); + + mRegistration->SetEvaluating(sw); + + nsMainThreadPtrHandle<ServiceWorkerUpdateJob> handle( + new nsMainThreadPtrHolder<ServiceWorkerUpdateJob>(this)); + RefPtr<LifeCycleEventCallback> callback = new ContinueUpdateRunnable(handle); + + ServiceWorkerPrivate* workerPrivate = sw->WorkerPrivate(); + MOZ_ASSERT(workerPrivate); + rv = workerPrivate->CheckScriptEvaluation(callback); + + if (NS_WARN_IF(NS_FAILED(rv))) { + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } +} + +void +ServiceWorkerUpdateJob::ContinueUpdateAfterScriptEval(bool aScriptEvaluationResult) +{ + AssertIsOnMainThread(); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (Canceled() || !swm) { + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } + + // Step 7.5 of the Update algorithm verifying that the script evaluated + // successfully. + + if (NS_WARN_IF(!aScriptEvaluationResult)) { + ErrorResult error; + + NS_ConvertUTF8toUTF16 scriptSpec(mScriptSpec); + NS_ConvertUTF8toUTF16 scope(mRegistration->mScope); + error.ThrowTypeError<MSG_SW_SCRIPT_THREW>(scriptSpec, scope); + FailUpdateJob(error); + return; + } + + Install(swm); +} + +void +ServiceWorkerUpdateJob::Install(ServiceWorkerManager* aSWM) +{ + AssertIsOnMainThread(); + MOZ_DIAGNOSTIC_ASSERT(!Canceled()); + MOZ_DIAGNOSTIC_ASSERT(aSWM); + + MOZ_ASSERT(!mRegistration->GetInstalling()); + + // Begin step 2 of the Install algorithm. + // + // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#installation-algorithm + + mRegistration->TransitionEvaluatingToInstalling(); + + // Step 6 of the Install algorithm resolving the job promise. + InvokeResultCallbacks(NS_OK); + + // The job promise cannot be rejected after this point, but the job can + // still fail; e.g. if the install event handler throws, etc. + + // fire the updatefound event + nsCOMPtr<nsIRunnable> upr = + NewRunnableMethod<RefPtr<ServiceWorkerRegistrationInfo>>( + aSWM, + &ServiceWorkerManager::FireUpdateFoundOnServiceWorkerRegistrations, + mRegistration); + NS_DispatchToMainThread(upr); + + // Call ContinueAfterInstallEvent(false) on main thread if the SW + // script fails to load. + nsCOMPtr<nsIRunnable> failRunnable = NewRunnableMethod<bool> + (this, &ServiceWorkerUpdateJob::ContinueAfterInstallEvent, false); + + nsMainThreadPtrHandle<ServiceWorkerUpdateJob> handle( + new nsMainThreadPtrHolder<ServiceWorkerUpdateJob>(this)); + RefPtr<LifeCycleEventCallback> callback = new ContinueInstallRunnable(handle); + + // Send the install event to the worker thread + ServiceWorkerPrivate* workerPrivate = + mRegistration->GetInstalling()->WorkerPrivate(); + nsresult rv = workerPrivate->SendLifeCycleEvent(NS_LITERAL_STRING("install"), + callback, failRunnable); + if (NS_WARN_IF(NS_FAILED(rv))) { + ContinueAfterInstallEvent(false /* aSuccess */); + } +} + +void +ServiceWorkerUpdateJob::ContinueAfterInstallEvent(bool aInstallEventSuccess) +{ + if (Canceled()) { + return FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + } + + // If we haven't been canceled we should have a registration. There appears + // to be a path where it gets cleared before we call into here. Assert + // to try to catch this condition, but don't crash in release. + MOZ_DIAGNOSTIC_ASSERT(mRegistration); + if (!mRegistration) { + return FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + } + + // Continue executing the Install algorithm at step 12. + + // "If installFailed is true" + if (NS_WARN_IF(!aInstallEventSuccess)) { + // The installing worker is cleaned up by FailUpdateJob(). + FailUpdateJob(NS_ERROR_DOM_ABORT_ERR); + return; + } + + MOZ_DIAGNOSTIC_ASSERT(mRegistration->GetInstalling()); + mRegistration->TransitionInstallingToWaiting(); + + Finish(NS_OK); + + // Step 20 calls for explicitly waiting for queued event tasks to fire. Instead, + // we simply queue a runnable to execute Activate. This ensures the events are + // flushed from the queue before proceeding. + + // Step 22 of the Install algorithm. Activate is executed after the completion + // of this job. The controlling client and skipWaiting checks are performed + // in TryToActivate(). + mRegistration->TryToActivateAsync(); +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/ServiceWorkerUpdateJob.h b/dom/workers/ServiceWorkerUpdateJob.h new file mode 100644 index 000000000..77adb2212 --- /dev/null +++ b/dom/workers/ServiceWorkerUpdateJob.h @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_serviceworkerupdatejob_h +#define mozilla_dom_workers_serviceworkerupdatejob_h + +#include "ServiceWorkerJob.h" + +namespace mozilla { +namespace dom { +namespace workers { + +class ServiceWorkerManager; + +// A job class that performs the Update and Install algorithms from the +// service worker spec. This class is designed to be inherited and customized +// as a different job type. This is necessary because the register job +// performs largely the same operations as the update job, but has a few +// different starting steps. +class ServiceWorkerUpdateJob : public ServiceWorkerJob +{ +public: + // Construct an update job to be used only for updates. + ServiceWorkerUpdateJob(nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup); + + already_AddRefed<ServiceWorkerRegistrationInfo> + GetRegistration() const; + +protected: + // Construct an update job that is overriden as another job type. + ServiceWorkerUpdateJob(Type aType, + nsIPrincipal* aPrincipal, + const nsACString& aScope, + const nsACString& aScriptSpec, + nsILoadGroup* aLoadGroup); + + virtual ~ServiceWorkerUpdateJob(); + + // FailUpdateJob() must be called if an update job needs Finish() with + // an error. + void + FailUpdateJob(ErrorResult& aRv); + + void + FailUpdateJob(nsresult aRv); + + // The entry point when the update job is being used directly. Job + // types overriding this class should override this method to + // customize behavior. + virtual void + AsyncExecute() override; + + // Set the registration to be operated on by Update() or to be immediately + // returned as a result of the job. This must be called before Update(). + void + SetRegistration(ServiceWorkerRegistrationInfo* aRegistration); + + // Execute the bulk of the update job logic using the registration defined + // by a previous SetRegistration() call. This can be called by the overriden + // AsyncExecute() to complete the job. The Update() method will always call + // Finish(). This method corresponds to the spec Update algorithm. + void + Update(); + +private: + class CompareCallback; + class ContinueUpdateRunnable; + class ContinueInstallRunnable; + + // Utility method called after a script is loaded and compared to + // our current cached script. + void + ComparisonResult(nsresult aStatus, + bool aInCacheAndEqual, + const nsAString& aNewCacheName, + const nsACString& aMaxScope); + + // Utility method called after evaluating the worker script. + void + ContinueUpdateAfterScriptEval(bool aScriptEvaluationResult); + + // Utility method corresponding to the spec Install algorithm. + void + Install(ServiceWorkerManager* aSWM); + + // Utility method called after the install event is handled. + void + ContinueAfterInstallEvent(bool aInstallEventSuccess); + + nsCOMPtr<nsILoadGroup> mLoadGroup; + RefPtr<ServiceWorkerRegistrationInfo> mRegistration; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerupdatejob_h diff --git a/dom/workers/ServiceWorkerWindowClient.cpp b/dom/workers/ServiceWorkerWindowClient.cpp new file mode 100644 index 000000000..2ce0603cf --- /dev/null +++ b/dom/workers/ServiceWorkerWindowClient.cpp @@ -0,0 +1,558 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "ServiceWorkerWindowClient.h" + +#include "js/Value.h" +#include "mozilla/Mutex.h" +#include "mozilla/dom/ClientBinding.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" +#include "mozilla/UniquePtr.h" +#include "nsContentUtils.h" +#include "nsGlobalWindow.h" +#include "nsIDocShell.h" +#include "nsIDocShellLoadInfo.h" +#include "nsIDocument.h" +#include "nsIGlobalObject.h" +#include "nsIPrincipal.h" +#include "nsIScriptSecurityManager.h" +#include "nsIWebNavigation.h" +#include "nsIWebProgress.h" +#include "nsIWebProgressListener.h" +#include "nsString.h" +#include "nsWeakReference.h" +#include "ServiceWorker.h" +#include "ServiceWorkerInfo.h" +#include "ServiceWorkerManager.h" +#include "WorkerPrivate.h" +#include "WorkerScope.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::dom::workers; + +using mozilla::UniquePtr; + +JSObject* +ServiceWorkerWindowClient::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return WindowClientBinding::Wrap(aCx, this, aGivenProto); +} + +namespace { + +class ResolveOrRejectPromiseRunnable final : public WorkerRunnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + UniquePtr<ServiceWorkerClientInfo> mClientInfo; + nsresult mRv; + +public: + // Passing a null clientInfo will resolve the promise with a null value. + ResolveOrRejectPromiseRunnable( + WorkerPrivate* aWorkerPrivate, PromiseWorkerProxy* aPromiseProxy, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo) + : WorkerRunnable(aWorkerPrivate) + , mPromiseProxy(aPromiseProxy) + , mClientInfo(Move(aClientInfo)) + , mRv(NS_OK) + { + AssertIsOnMainThread(); + } + + // Reject the promise with passed nsresult. + ResolveOrRejectPromiseRunnable(WorkerPrivate* aWorkerPrivate, + PromiseWorkerProxy* aPromiseProxy, + nsresult aRv) + : WorkerRunnable(aWorkerPrivate) + , mPromiseProxy(aPromiseProxy) + , mClientInfo(nullptr) + , mRv(aRv) + { + MOZ_ASSERT(NS_FAILED(aRv)); + AssertIsOnMainThread(); + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<Promise> promise = mPromiseProxy->WorkerPromise(); + MOZ_ASSERT(promise); + + if (NS_WARN_IF(NS_FAILED(mRv))) { + promise->MaybeReject(mRv); + } else if (mClientInfo) { + RefPtr<ServiceWorkerWindowClient> client = + new ServiceWorkerWindowClient(promise->GetParentObject(), *mClientInfo); + promise->MaybeResolve(client); + } else { + promise->MaybeResolve(JS::NullHandleValue); + } + + // Release the reference on the worker thread. + mPromiseProxy->CleanUp(); + + return true; + } +}; + +class ClientFocusRunnable final : public Runnable +{ + uint64_t mWindowId; + RefPtr<PromiseWorkerProxy> mPromiseProxy; + +public: + ClientFocusRunnable(uint64_t aWindowId, PromiseWorkerProxy* aPromiseProxy) + : mWindowId(aWindowId) + , mPromiseProxy(aPromiseProxy) + { + MOZ_ASSERT(mPromiseProxy); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + nsGlobalWindow* window = nsGlobalWindow::GetInnerWindowWithId(mWindowId); + UniquePtr<ServiceWorkerClientInfo> clientInfo; + + if (window) { + nsCOMPtr<nsIDocument> doc = window->GetDocument(); + if (doc) { + nsContentUtils::DispatchFocusChromeEvent(window->GetOuterWindow()); + clientInfo.reset(new ServiceWorkerClientInfo(doc)); + } + } + + DispatchResult(Move(clientInfo)); + return NS_OK; + } + +private: + void + DispatchResult(UniquePtr<ServiceWorkerClientInfo>&& aClientInfo) + { + AssertIsOnMainThread(); + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return; + } + + RefPtr<ResolveOrRejectPromiseRunnable> resolveRunnable; + if (aClientInfo) { + resolveRunnable = new ResolveOrRejectPromiseRunnable( + mPromiseProxy->GetWorkerPrivate(), mPromiseProxy, Move(aClientInfo)); + } else { + resolveRunnable = new ResolveOrRejectPromiseRunnable( + mPromiseProxy->GetWorkerPrivate(), mPromiseProxy, + NS_ERROR_DOM_INVALID_ACCESS_ERR); + } + + resolveRunnable->Dispatch(); + } +}; + +} // namespace + +already_AddRefed<Promise> +ServiceWorkerWindowClient::Focus(ErrorResult& aRv) const +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject()); + MOZ_ASSERT(global); + + RefPtr<Promise> promise = Promise::Create(global, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + if (workerPrivate->GlobalScope()->WindowInteractionAllowed()) { + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + if (promiseProxy) { + RefPtr<ClientFocusRunnable> r = new ClientFocusRunnable(mWindowId, + promiseProxy); + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(r.forget())); + } else { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + } + + } else { + promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR); + } + + return promise.forget(); +} + +class WebProgressListener final : public nsIWebProgressListener, + public nsSupportsWeakReference +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(WebProgressListener, + nsIWebProgressListener) + + WebProgressListener(PromiseWorkerProxy* aPromiseProxy, + ServiceWorkerPrivate* aServiceWorkerPrivate, + nsPIDOMWindowOuter* aWindow, nsIURI* aBaseURI) + : mPromiseProxy(aPromiseProxy) + , mServiceWorkerPrivate(aServiceWorkerPrivate) + , mWindow(aWindow) + , mBaseURI(aBaseURI) + { + MOZ_ASSERT(aPromiseProxy); + MOZ_ASSERT(aServiceWorkerPrivate); + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aWindow->IsOuterWindow()); + MOZ_ASSERT(aBaseURI); + AssertIsOnMainThread(); + + mServiceWorkerPrivate->StoreISupports(static_cast<nsIWebProgressListener*>(this)); + } + + NS_IMETHOD + OnStateChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest, + uint32_t aStateFlags, nsresult aStatus) override + { + if (!(aStateFlags & STATE_IS_DOCUMENT) || + !(aStateFlags & (STATE_STOP | STATE_TRANSFERRING))) { + return NS_OK; + } + + // This is safe because our caller holds a strong ref. + mServiceWorkerPrivate->RemoveISupports(static_cast<nsIWebProgressListener*>(this)); + aWebProgress->RemoveProgressListener(this); + + WorkerPrivate* workerPrivate; + + { + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + workerPrivate = mPromiseProxy->GetWorkerPrivate(); + } + + nsCOMPtr<nsIDocument> doc = mWindow->GetExtantDoc(); + + RefPtr<ResolveOrRejectPromiseRunnable> resolveRunnable; + UniquePtr<ServiceWorkerClientInfo> clientInfo; + if (!doc) { + resolveRunnable = new ResolveOrRejectPromiseRunnable( + workerPrivate, mPromiseProxy, NS_ERROR_TYPE_ERR); + resolveRunnable->Dispatch(); + + return NS_OK; + } + + // Check same origin. + nsCOMPtr<nsIScriptSecurityManager> securityManager = + nsContentUtils::GetSecurityManager(); + nsresult rv = securityManager->CheckSameOriginURI(doc->GetOriginalURI(), + mBaseURI, false); + + if (NS_SUCCEEDED(rv)) { + nsContentUtils::DispatchFocusChromeEvent(mWindow->GetOuterWindow()); + clientInfo.reset(new ServiceWorkerClientInfo(doc)); + } + + resolveRunnable = new ResolveOrRejectPromiseRunnable( + workerPrivate, mPromiseProxy, Move(clientInfo)); + resolveRunnable->Dispatch(); + + return NS_OK; + } + + NS_IMETHOD + OnProgressChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest, + int32_t aCurSelfProgress, int32_t aMaxSelfProgress, + int32_t aCurTotalProgress, + int32_t aMaxTotalProgress) override + { + MOZ_CRASH("Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnLocationChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest, + nsIURI* aLocation, uint32_t aFlags) override + { + MOZ_CRASH("Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnStatusChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest, + nsresult aStatus, const char16_t* aMessage) override + { + MOZ_CRASH("Unexpected notification."); + return NS_OK; + } + + NS_IMETHOD + OnSecurityChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest, + uint32_t aState) override + { + MOZ_CRASH("Unexpected notification."); + return NS_OK; + } + +private: + ~WebProgressListener() {} + + RefPtr<PromiseWorkerProxy> mPromiseProxy; + RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate; + nsCOMPtr<nsPIDOMWindowOuter> mWindow; + nsCOMPtr<nsIURI> mBaseURI; +}; + +NS_IMPL_CYCLE_COLLECTING_ADDREF(WebProgressListener) +NS_IMPL_CYCLE_COLLECTING_RELEASE(WebProgressListener) +NS_IMPL_CYCLE_COLLECTION(WebProgressListener, mPromiseProxy, + mServiceWorkerPrivate, mWindow) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END + +class ClientNavigateRunnable final : public Runnable +{ + uint64_t mWindowId; + nsString mUrl; + nsCString mBaseUrl; + nsString mScope; + RefPtr<PromiseWorkerProxy> mPromiseProxy; + MOZ_INIT_OUTSIDE_CTOR WorkerPrivate* mWorkerPrivate; + +public: + ClientNavigateRunnable(uint64_t aWindowId, const nsAString& aUrl, + const nsAString& aScope, + PromiseWorkerProxy* aPromiseProxy) + : mWindowId(aWindowId) + , mUrl(aUrl) + , mScope(aScope) + , mPromiseProxy(aPromiseProxy) + , mWorkerPrivate(nullptr) + { + MOZ_ASSERT(aPromiseProxy); + MOZ_ASSERT(aPromiseProxy->GetWorkerPrivate()); + aPromiseProxy->GetWorkerPrivate()->AssertIsOnWorkerThread(); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + nsCOMPtr<nsIPrincipal> principal; + + { + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + mWorkerPrivate = mPromiseProxy->GetWorkerPrivate(); + WorkerPrivate::LocationInfo& info = mWorkerPrivate->GetLocationInfo(); + mBaseUrl = info.mHref; + principal = mWorkerPrivate->GetPrincipal(); + MOZ_DIAGNOSTIC_ASSERT(principal); + } + + nsCOMPtr<nsIURI> baseUrl; + nsCOMPtr<nsIURI> url; + nsresult rv = ParseUrl(getter_AddRefs(baseUrl), getter_AddRefs(url)); + + if (NS_WARN_IF(NS_FAILED(rv))) { + return RejectPromise(NS_ERROR_TYPE_ERR); + } + + rv = principal->CheckMayLoad(url, true, false); + if (NS_WARN_IF(NS_FAILED(rv))) { + return RejectPromise(rv); + } + + nsGlobalWindow* window; + rv = Navigate(url, principal, &window); + if (NS_WARN_IF(NS_FAILED(rv))) { + return RejectPromise(rv); + } + + nsCOMPtr<nsIDocShell> docShell = window->GetDocShell(); + nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell); + if (NS_WARN_IF(!webProgress)) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (!swm) { + return NS_ERROR_FAILURE; + } + + RefPtr<ServiceWorkerRegistrationInfo> registration = + swm->GetRegistration(principal, NS_ConvertUTF16toUTF8(mScope)); + if (NS_WARN_IF(!registration)) { + return NS_ERROR_FAILURE; + } + RefPtr<ServiceWorkerInfo> serviceWorkerInfo = + registration->GetServiceWorkerInfoById(mWorkerPrivate->ServiceWorkerID()); + if (NS_WARN_IF(!serviceWorkerInfo)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIWebProgressListener> listener = + new WebProgressListener(mPromiseProxy, serviceWorkerInfo->WorkerPrivate(), + window->GetOuterWindow(), baseUrl); + + rv = webProgress->AddProgressListener( + listener, nsIWebProgress::NOTIFY_STATE_DOCUMENT); + + if (NS_WARN_IF(NS_FAILED(rv))) { + return RejectPromise(rv); + } + + return NS_OK; + } + +private: + nsresult + RejectPromise(nsresult aRv) + { + MOZ_ASSERT(mWorkerPrivate); + RefPtr<ResolveOrRejectPromiseRunnable> resolveRunnable = + new ResolveOrRejectPromiseRunnable(mWorkerPrivate, mPromiseProxy, aRv); + + resolveRunnable->Dispatch(); + return NS_OK; + } + + nsresult + ResolvePromise(UniquePtr<ServiceWorkerClientInfo>&& aClientInfo) + { + MOZ_ASSERT(mWorkerPrivate); + RefPtr<ResolveOrRejectPromiseRunnable> resolveRunnable = + new ResolveOrRejectPromiseRunnable(mWorkerPrivate, mPromiseProxy, + Move(aClientInfo)); + + resolveRunnable->Dispatch(); + return NS_OK; + } + + nsresult + ParseUrl(nsIURI** aBaseUrl, nsIURI** aUrl) + { + MOZ_ASSERT(aBaseUrl); + MOZ_ASSERT(aUrl); + AssertIsOnMainThread(); + + nsCOMPtr<nsIURI> baseUrl; + nsresult rv = NS_NewURI(getter_AddRefs(baseUrl), mBaseUrl); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIURI> url; + rv = NS_NewURI(getter_AddRefs(url), mUrl, nullptr, baseUrl); + NS_ENSURE_SUCCESS(rv, rv); + + baseUrl.forget(aBaseUrl); + url.forget(aUrl); + + return NS_OK; + } + + nsresult + Navigate(nsIURI* aUrl, nsIPrincipal* aPrincipal, nsGlobalWindow** aWindow) + { + MOZ_ASSERT(aWindow); + + nsGlobalWindow* window = nsGlobalWindow::GetInnerWindowWithId(mWindowId); + if (NS_WARN_IF(!window)) { + return NS_ERROR_TYPE_ERR; + } + + nsCOMPtr<nsIDocument> doc = window->GetDocument(); + if (NS_WARN_IF(!doc)) { + return NS_ERROR_TYPE_ERR; + } + + if (NS_WARN_IF(!doc->IsActive())) { + return NS_ERROR_TYPE_ERR; + } + + nsCOMPtr<nsIDocShell> docShell = window->GetDocShell(); + if (NS_WARN_IF(!docShell)) { + return NS_ERROR_TYPE_ERR; + } + + nsCOMPtr<nsIDocShellLoadInfo> loadInfo; + nsresult rv = docShell->CreateLoadInfo(getter_AddRefs(loadInfo)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + loadInfo->SetTriggeringPrincipal(aPrincipal); + loadInfo->SetReferrer(doc->GetOriginalURI()); + loadInfo->SetReferrerPolicy(doc->GetReferrerPolicy()); + loadInfo->SetLoadType(nsIDocShellLoadInfo::loadStopContentAndReplace); + loadInfo->SetSourceDocShell(docShell); + rv = + docShell->LoadURI(aUrl, loadInfo, nsIWebNavigation::LOAD_FLAGS_NONE, true); + + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + *aWindow = window; + return NS_OK; + } +}; + +already_AddRefed<Promise> +ServiceWorkerWindowClient::Navigate(const nsAString& aUrl, ErrorResult& aRv) +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); + + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject()); + MOZ_ASSERT(global); + + RefPtr<Promise> promise = Promise::Create(global, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + if (aUrl.EqualsLiteral("about:blank")) { + promise->MaybeReject(NS_ERROR_TYPE_ERR); + return promise.forget(); + } + + ServiceWorkerGlobalScope* globalScope = + static_cast<ServiceWorkerGlobalScope*>(workerPrivate->GlobalScope()); + nsString scope; + globalScope->GetScope(scope); + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(workerPrivate, promise); + if (promiseProxy) { + RefPtr<ClientNavigateRunnable> r = + new ClientNavigateRunnable(mWindowId, aUrl, scope, promiseProxy); + MOZ_ALWAYS_SUCCEEDS(workerPrivate->DispatchToMainThread(r.forget())); + } else { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + } + + return promise.forget(); +} diff --git a/dom/workers/ServiceWorkerWindowClient.h b/dom/workers/ServiceWorkerWindowClient.h new file mode 100644 index 000000000..0e2441294 --- /dev/null +++ b/dom/workers/ServiceWorkerWindowClient.h @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef mozilla_dom_workers_serviceworkerwindowclient_h +#define mozilla_dom_workers_serviceworkerwindowclient_h + +#include "ServiceWorkerClient.h" + +namespace mozilla { +namespace dom { + +class Promise; + +namespace workers { + +class ServiceWorkerWindowClient final : public ServiceWorkerClient +{ +public: + ServiceWorkerWindowClient(nsISupports* aOwner, + const ServiceWorkerClientInfo& aClientInfo) + : ServiceWorkerClient(aOwner, aClientInfo), + mVisibilityState(aClientInfo.mVisibilityState), + mFocused(aClientInfo.mFocused) + { + } + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + mozilla::dom::VisibilityState + VisibilityState() const + { + return mVisibilityState; + } + + bool + Focused() const + { + return mFocused; + } + + already_AddRefed<Promise> + Focus(ErrorResult& aRv) const; + + already_AddRefed<Promise> + Navigate(const nsAString& aUrl, ErrorResult& aRv); + +private: + ~ServiceWorkerWindowClient() + { } + + mozilla::dom::VisibilityState mVisibilityState; + bool mFocused; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_serviceworkerwindowclient_h diff --git a/dom/workers/SharedWorker.cpp b/dom/workers/SharedWorker.cpp new file mode 100644 index 000000000..b0eed2def --- /dev/null +++ b/dom/workers/SharedWorker.cpp @@ -0,0 +1,207 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "SharedWorker.h" + +#include "nsPIDOMWindow.h" + +#include "mozilla/EventDispatcher.h" +#include "mozilla/Preferences.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/SharedWorkerBinding.h" +#include "mozilla/Telemetry.h" +#include "nsContentUtils.h" +#include "nsIClassInfoImpl.h" +#include "nsIDOMEvent.h" + +#include "RuntimeService.h" +#include "WorkerPrivate.h" + +using mozilla::dom::Optional; +using mozilla::dom::Sequence; +using mozilla::dom::MessagePort; +using namespace mozilla; + +USING_WORKERS_NAMESPACE + +SharedWorker::SharedWorker(nsPIDOMWindowInner* aWindow, + WorkerPrivate* aWorkerPrivate, + MessagePort* aMessagePort) + : DOMEventTargetHelper(aWindow) + , mWorkerPrivate(aWorkerPrivate) + , mMessagePort(aMessagePort) + , mFrozen(false) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aMessagePort); +} + +SharedWorker::~SharedWorker() +{ + AssertIsOnMainThread(); +} + +// static +already_AddRefed<SharedWorker> +SharedWorker::Constructor(const GlobalObject& aGlobal, JSContext* aCx, + const nsAString& aScriptURL, + const mozilla::dom::Optional<nsAString>& aName, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + + RuntimeService* rts = RuntimeService::GetOrCreateService(); + if (!rts) { + aRv = NS_ERROR_NOT_AVAILABLE; + return nullptr; + } + + nsCString name; + if (aName.WasPassed()) { + name = NS_ConvertUTF16toUTF8(aName.Value()); + } + + RefPtr<SharedWorker> sharedWorker; + nsresult rv = rts->CreateSharedWorker(aGlobal, aScriptURL, name, + getter_AddRefs(sharedWorker)); + if (NS_FAILED(rv)) { + aRv = rv; + return nullptr; + } + + Telemetry::Accumulate(Telemetry::SHARED_WORKER_COUNT, 1); + + return sharedWorker.forget(); +} + +MessagePort* +SharedWorker::Port() +{ + AssertIsOnMainThread(); + return mMessagePort; +} + +void +SharedWorker::Freeze() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(!IsFrozen()); + + mFrozen = true; +} + +void +SharedWorker::Thaw() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(IsFrozen()); + + mFrozen = false; + + if (!mFrozenEvents.IsEmpty()) { + nsTArray<nsCOMPtr<nsIDOMEvent>> events; + mFrozenEvents.SwapElements(events); + + for (uint32_t index = 0; index < events.Length(); index++) { + nsCOMPtr<nsIDOMEvent>& event = events[index]; + MOZ_ASSERT(event); + + nsCOMPtr<nsIDOMEventTarget> target; + if (NS_SUCCEEDED(event->GetTarget(getter_AddRefs(target)))) { + bool ignored; + if (NS_FAILED(target->DispatchEvent(event, &ignored))) { + NS_WARNING("Failed to dispatch event!"); + } + } else { + NS_WARNING("Failed to get target!"); + } + } + } +} + +void +SharedWorker::QueueEvent(nsIDOMEvent* aEvent) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aEvent); + MOZ_ASSERT(IsFrozen()); + + mFrozenEvents.AppendElement(aEvent); +} + +void +SharedWorker::Close() +{ + AssertIsOnMainThread(); + + if (mMessagePort) { + mMessagePort->Close(); + } +} + +void +SharedWorker::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(mMessagePort); + + mMessagePort->PostMessage(aCx, aMessage, aTransferable, aRv); +} + +NS_IMPL_ADDREF_INHERITED(SharedWorker, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(SharedWorker, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(SharedWorker) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_CYCLE_COLLECTION_CLASS(SharedWorker) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SharedWorker, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrozenEvents) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SharedWorker, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrozenEvents) +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +JSObject* +SharedWorker::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + AssertIsOnMainThread(); + + return SharedWorkerBinding::Wrap(aCx, this, aGivenProto); +} + +nsresult +SharedWorker::PreHandleEvent(EventChainPreVisitor& aVisitor) +{ + AssertIsOnMainThread(); + + if (IsFrozen()) { + nsCOMPtr<nsIDOMEvent> event = aVisitor.mDOMEvent; + if (!event) { + event = EventDispatcher::CreateEvent(aVisitor.mEvent->mOriginalTarget, + aVisitor.mPresContext, + aVisitor.mEvent, EmptyString()); + } + + QueueEvent(event); + + aVisitor.mCanHandle = false; + aVisitor.mParentTarget = nullptr; + return NS_OK; + } + + return DOMEventTargetHelper::PreHandleEvent(aVisitor); +} diff --git a/dom/workers/SharedWorker.h b/dom/workers/SharedWorker.h new file mode 100644 index 000000000..220436e4d --- /dev/null +++ b/dom/workers/SharedWorker.h @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_sharedworker_h__ +#define mozilla_dom_workers_sharedworker_h__ + +#include "Workers.h" + +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/DOMEventTargetHelper.h" + +class nsIDOMEvent; +class nsPIDOMWindowInner; + +namespace mozilla { +class EventChainPreVisitor; + +namespace dom { +class MessagePort; +} +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +class RuntimeService; +class WorkerPrivate; + +class SharedWorker final : public DOMEventTargetHelper +{ + friend class RuntimeService; + + typedef mozilla::ErrorResult ErrorResult; + typedef mozilla::dom::GlobalObject GlobalObject; + + RefPtr<WorkerPrivate> mWorkerPrivate; + RefPtr<MessagePort> mMessagePort; + nsTArray<nsCOMPtr<nsIDOMEvent>> mFrozenEvents; + bool mFrozen; + +public: + static already_AddRefed<SharedWorker> + Constructor(const GlobalObject& aGlobal, JSContext* aCx, + const nsAString& aScriptURL, const Optional<nsAString>& aName, + ErrorResult& aRv); + + MessagePort* + Port(); + + bool + IsFrozen() const + { + return mFrozen; + } + + void + Freeze(); + + void + Thaw(); + + void + QueueEvent(nsIDOMEvent* aEvent); + + void + Close(); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(SharedWorker, DOMEventTargetHelper) + + IMPL_EVENT_HANDLER(error) + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + virtual nsresult + PreHandleEvent(EventChainPreVisitor& aVisitor) override; + + WorkerPrivate* + GetWorkerPrivate() const + { + return mWorkerPrivate; + } + +private: + // This class can only be created from the RuntimeService. + SharedWorker(nsPIDOMWindowInner* aWindow, + WorkerPrivate* aWorkerPrivate, + MessagePort* aMessagePort); + + // This class is reference-counted and will be destroyed from Release(). + ~SharedWorker(); + + // Only called by MessagePort. + void + PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); +}; + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_sharedworker_h__ diff --git a/dom/workers/WorkerDebuggerManager.cpp b/dom/workers/WorkerDebuggerManager.cpp new file mode 100644 index 000000000..dfd7e5acc --- /dev/null +++ b/dom/workers/WorkerDebuggerManager.cpp @@ -0,0 +1,361 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerDebuggerManager.h" + +#include "nsISimpleEnumerator.h" + +#include "mozilla/ClearOnShutdown.h" + +#include "WorkerPrivate.h" + +USING_WORKERS_NAMESPACE + +namespace { + +class RegisterDebuggerMainThreadRunnable final : public mozilla::Runnable +{ + WorkerPrivate* mWorkerPrivate; + bool mNotifyListeners; + +public: + RegisterDebuggerMainThreadRunnable(WorkerPrivate* aWorkerPrivate, + bool aNotifyListeners) + : mWorkerPrivate(aWorkerPrivate), + mNotifyListeners(aNotifyListeners) + { } + +private: + ~RegisterDebuggerMainThreadRunnable() + { } + + NS_IMETHOD + Run() override + { + WorkerDebuggerManager* manager = WorkerDebuggerManager::Get(); + MOZ_ASSERT(manager); + + manager->RegisterDebuggerMainThread(mWorkerPrivate, mNotifyListeners); + return NS_OK; + } +}; + +class UnregisterDebuggerMainThreadRunnable final : public mozilla::Runnable +{ + WorkerPrivate* mWorkerPrivate; + +public: + explicit UnregisterDebuggerMainThreadRunnable(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) + { } + +private: + ~UnregisterDebuggerMainThreadRunnable() + { } + + NS_IMETHOD + Run() override + { + WorkerDebuggerManager* manager = WorkerDebuggerManager::Get(); + MOZ_ASSERT(manager); + + manager->UnregisterDebuggerMainThread(mWorkerPrivate); + return NS_OK; + } +}; + +// Does not hold an owning reference. +static WorkerDebuggerManager* gWorkerDebuggerManager; + +} /* anonymous namespace */ + +BEGIN_WORKERS_NAMESPACE + +class WorkerDebuggerEnumerator final : public nsISimpleEnumerator +{ + nsTArray<RefPtr<WorkerDebugger>> mDebuggers; + uint32_t mIndex; + +public: + explicit WorkerDebuggerEnumerator( + const nsTArray<RefPtr<WorkerDebugger>>& aDebuggers) + : mDebuggers(aDebuggers), mIndex(0) + { + } + + NS_DECL_ISUPPORTS + NS_DECL_NSISIMPLEENUMERATOR + +private: + ~WorkerDebuggerEnumerator() {} +}; + +NS_IMPL_ISUPPORTS(WorkerDebuggerEnumerator, nsISimpleEnumerator); + +NS_IMETHODIMP +WorkerDebuggerEnumerator::HasMoreElements(bool* aResult) +{ + *aResult = mIndex < mDebuggers.Length(); + return NS_OK; +}; + +NS_IMETHODIMP +WorkerDebuggerEnumerator::GetNext(nsISupports** aResult) +{ + if (mIndex == mDebuggers.Length()) { + return NS_ERROR_FAILURE; + } + + mDebuggers.ElementAt(mIndex++).forget(aResult); + return NS_OK; +}; + +WorkerDebuggerManager::WorkerDebuggerManager() +: mMutex("WorkerDebuggerManager::mMutex") +{ + AssertIsOnMainThread(); +} + +WorkerDebuggerManager::~WorkerDebuggerManager() +{ + AssertIsOnMainThread(); +} + +// static +already_AddRefed<WorkerDebuggerManager> +WorkerDebuggerManager::GetInstance() +{ + RefPtr<WorkerDebuggerManager> manager = WorkerDebuggerManager::GetOrCreate(); + return manager.forget(); +} + +// static +WorkerDebuggerManager* +WorkerDebuggerManager::GetOrCreate() +{ + AssertIsOnMainThread(); + + if (!gWorkerDebuggerManager) { + // The observer service now owns us until shutdown. + gWorkerDebuggerManager = new WorkerDebuggerManager(); + if (NS_FAILED(gWorkerDebuggerManager->Init())) { + NS_WARNING("Failed to initialize worker debugger manager!"); + gWorkerDebuggerManager = nullptr; + return nullptr; + } + } + + return gWorkerDebuggerManager; +} + +WorkerDebuggerManager* +WorkerDebuggerManager::Get() +{ + MOZ_ASSERT(gWorkerDebuggerManager); + return gWorkerDebuggerManager; +} + +NS_IMPL_ISUPPORTS(WorkerDebuggerManager, nsIObserver, nsIWorkerDebuggerManager); + +NS_IMETHODIMP +WorkerDebuggerManager::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + Shutdown(); + return NS_OK; + } + + NS_NOTREACHED("Unknown observer topic!"); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebuggerManager::GetWorkerDebuggerEnumerator( + nsISimpleEnumerator** aResult) +{ + AssertIsOnMainThread(); + + RefPtr<WorkerDebuggerEnumerator> enumerator = + new WorkerDebuggerEnumerator(mDebuggers); + enumerator.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebuggerManager::AddListener(nsIWorkerDebuggerManagerListener* aListener) +{ + AssertIsOnMainThread(); + + MutexAutoLock lock(mMutex); + + if (mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.AppendElement(aListener); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebuggerManager::RemoveListener( + nsIWorkerDebuggerManagerListener* aListener) +{ + AssertIsOnMainThread(); + + MutexAutoLock lock(mMutex); + + if (!mListeners.Contains(aListener)) { + return NS_OK; + } + + mListeners.RemoveElement(aListener); + return NS_OK; +} + +nsresult +WorkerDebuggerManager::Init() +{ + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE); + + nsresult rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +void +WorkerDebuggerManager::Shutdown() +{ + AssertIsOnMainThread(); + + MutexAutoLock lock(mMutex); + + mListeners.Clear(); +} + +void +WorkerDebuggerManager::RegisterDebugger(WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnParentThread(); + + if (NS_IsMainThread()) { + // When the parent thread is the main thread, it will always block until all + // register liseners have been called, since it cannot continue until the + // call to RegisterDebuggerMainThread returns. + // + // In this case, it is always safe to notify all listeners on the main + // thread, even if there were no listeners at the time this method was + // called, so we can always pass true for the value of aNotifyListeners. + // This avoids having to lock mMutex to check whether mListeners is empty. + RegisterDebuggerMainThread(aWorkerPrivate, true); + } else { + // We guarantee that if any register listeners are called, the worker does + // not start running until all register listeners have been called. To + // guarantee this, the parent thread should block until all register + // listeners have been called. + // + // However, to avoid overhead when the debugger is not being used, the + // parent thread will only block if there were any listeners at the time + // this method was called. As a result, we should not notify any listeners + // on the main thread if there were no listeners at the time this method was + // called, because the parent will not be blocking in that case. + bool hasListeners = false; + { + MutexAutoLock lock(mMutex); + + hasListeners = !mListeners.IsEmpty(); + } + + nsCOMPtr<nsIRunnable> runnable = + new RegisterDebuggerMainThreadRunnable(aWorkerPrivate, hasListeners); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL)); + + if (hasListeners) { + aWorkerPrivate->WaitForIsDebuggerRegistered(true); + } + } +} + +void +WorkerDebuggerManager::UnregisterDebugger(WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnParentThread(); + + if (NS_IsMainThread()) { + UnregisterDebuggerMainThread(aWorkerPrivate); + } else { + nsCOMPtr<nsIRunnable> runnable = + new UnregisterDebuggerMainThreadRunnable(aWorkerPrivate); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL)); + + aWorkerPrivate->WaitForIsDebuggerRegistered(false); + } +} + +void +WorkerDebuggerManager::RegisterDebuggerMainThread(WorkerPrivate* aWorkerPrivate, + bool aNotifyListeners) +{ + AssertIsOnMainThread(); + + RefPtr<WorkerDebugger> debugger = new WorkerDebugger(aWorkerPrivate); + mDebuggers.AppendElement(debugger); + + aWorkerPrivate->SetDebugger(debugger); + + if (aNotifyListeners) { + nsTArray<nsCOMPtr<nsIWorkerDebuggerManagerListener>> listeners; + { + MutexAutoLock lock(mMutex); + + listeners = mListeners; + } + + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnRegister(debugger); + } + } + + aWorkerPrivate->SetIsDebuggerRegistered(true); +} + +void +WorkerDebuggerManager::UnregisterDebuggerMainThread( + WorkerPrivate* aWorkerPrivate) +{ + AssertIsOnMainThread(); + + // There is nothing to do here if the debugger was never succesfully + // registered. We need to check this on the main thread because the worker + // does not wait for the registration to complete if there were no listeners + // installed when it started. + if (!aWorkerPrivate->IsDebuggerRegistered()) { + return; + } + + RefPtr<WorkerDebugger> debugger = aWorkerPrivate->Debugger(); + mDebuggers.RemoveElement(debugger); + + aWorkerPrivate->SetDebugger(nullptr); + + nsTArray<nsCOMPtr<nsIWorkerDebuggerManagerListener>> listeners; + { + MutexAutoLock lock(mMutex); + + listeners = mListeners; + } + + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnUnregister(debugger); + } + + debugger->Close(); + aWorkerPrivate->SetIsDebuggerRegistered(false); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/WorkerDebuggerManager.h b/dom/workers/WorkerDebuggerManager.h new file mode 100644 index 000000000..6c4c943b1 --- /dev/null +++ b/dom/workers/WorkerDebuggerManager.h @@ -0,0 +1,121 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_workerdebuggermanager_h +#define mozilla_dom_workers_workerdebuggermanager_h + +#include "Workers.h" + +#include "nsIObserver.h" +#include "nsIWorkerDebuggerManager.h" + +#include "nsServiceManagerUtils.h" +#include "nsTArray.h" +#include "nsThreadUtils.h" + +#define WORKERDEBUGGERMANAGER_CID \ + { 0x62ec8731, 0x55ad, 0x4246, \ + { 0xb2, 0xea, 0xf2, 0x6c, 0x1f, 0xe1, 0x9d, 0x2d } } +#define WORKERDEBUGGERMANAGER_CONTRACTID \ + "@mozilla.org/dom/workers/workerdebuggermanager;1" + +BEGIN_WORKERS_NAMESPACE + +class WorkerDebugger; + +class WorkerDebuggerManager final : public nsIObserver, + public nsIWorkerDebuggerManager +{ + Mutex mMutex; + + // Protected by mMutex. + nsTArray<nsCOMPtr<nsIWorkerDebuggerManagerListener>> mListeners; + + // Only touched on the main thread. + nsTArray<RefPtr<WorkerDebugger>> mDebuggers; + +public: + static already_AddRefed<WorkerDebuggerManager> + GetInstance(); + + static WorkerDebuggerManager* + GetOrCreate(); + + static WorkerDebuggerManager* + Get(); + + WorkerDebuggerManager(); + + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSIWORKERDEBUGGERMANAGER + + nsresult + Init(); + + void + Shutdown(); + + void + RegisterDebugger(WorkerPrivate* aWorkerPrivate); + + void + RegisterDebuggerMainThread(WorkerPrivate* aWorkerPrivate, + bool aNotifyListeners); + + void + UnregisterDebugger(WorkerPrivate* aWorkerPrivate); + + void + UnregisterDebuggerMainThread(WorkerPrivate* aWorkerPrivate); + +private: + virtual ~WorkerDebuggerManager(); +}; + +inline nsresult +RegisterWorkerDebugger(WorkerPrivate* aWorkerPrivate) +{ + WorkerDebuggerManager* manager; + + if (NS_IsMainThread()) { + manager = WorkerDebuggerManager::GetOrCreate(); + if (!manager) { + NS_WARNING("Failed to create worker debugger manager!"); + return NS_ERROR_FAILURE; + } + } + else { + manager = WorkerDebuggerManager::Get(); + } + + manager->RegisterDebugger(aWorkerPrivate); + return NS_OK; +} + +inline nsresult +UnregisterWorkerDebugger(WorkerPrivate* aWorkerPrivate) +{ + WorkerDebuggerManager* manager; + + if (NS_IsMainThread()) { + manager = WorkerDebuggerManager::GetOrCreate(); + if (!manager) { + NS_WARNING("Failed to create worker debugger manager!"); + return NS_ERROR_FAILURE; + } + } + else { + manager = WorkerDebuggerManager::Get(); + } + + manager->UnregisterDebugger(aWorkerPrivate); + return NS_OK; +} + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_workerdebuggermanager_h diff --git a/dom/workers/WorkerHolder.cpp b/dom/workers/WorkerHolder.cpp new file mode 100644 index 000000000..6383ae5a1 --- /dev/null +++ b/dom/workers/WorkerHolder.cpp @@ -0,0 +1,60 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerHolder.h" +#include "WorkerPrivate.h" + +BEGIN_WORKERS_NAMESPACE + +WorkerHolder::WorkerHolder() + : mWorkerPrivate(nullptr) +{ +} + +WorkerHolder::~WorkerHolder() +{ + NS_ASSERT_OWNINGTHREAD(WorkerHolder); + ReleaseWorkerInternal(); + MOZ_ASSERT(mWorkerPrivate == nullptr); +} + +bool +WorkerHolder::HoldWorker(WorkerPrivate* aWorkerPrivate, Status aFailStatus) +{ + NS_ASSERT_OWNINGTHREAD(WorkerHolder); + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + if (!aWorkerPrivate->AddHolder(this, aFailStatus)) { + return false; + } + + mWorkerPrivate = aWorkerPrivate; + return true; +} + +void +WorkerHolder::ReleaseWorker() +{ + NS_ASSERT_OWNINGTHREAD(WorkerHolder); + MOZ_ASSERT(mWorkerPrivate); + + ReleaseWorkerInternal(); +} + +void +WorkerHolder::ReleaseWorkerInternal() +{ + NS_ASSERT_OWNINGTHREAD(WorkerHolder); + + if (mWorkerPrivate) { + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate->RemoveHolder(this); + mWorkerPrivate = nullptr; + } +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/WorkerHolder.h b/dom/workers/WorkerHolder.h new file mode 100644 index 000000000..d0eb22f29 --- /dev/null +++ b/dom/workers/WorkerHolder.h @@ -0,0 +1,96 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_WorkerHolder_h +#define mozilla_dom_workers_WorkerHolder_h + +#include "mozilla/dom/workers/Workers.h" + +BEGIN_WORKERS_NAMESPACE + +/** + * Use this chart to help figure out behavior during each of the closing + * statuses. Details below. + * + * +==============================================================+ + * | Closing Statuses | + * +=============+=============+=================+================+ + * | status | clear queue | abort execution | close handler | + * +=============+=============+=================+================+ + * | Closing | yes | no | no timeout | + * +-------------+-------------+-----------------+----------------+ + * | Terminating | yes | yes | no timeout | + * +-------------+-------------+-----------------+----------------+ + * | Canceling | yes | yes | short duration | + * +-------------+-------------+-----------------+----------------+ + * | Killing | yes | yes | doesn't run | + * +-------------+-------------+-----------------+----------------+ + */ + +#ifdef Status +/* Xlib headers insist on this for some reason... Nuke it because + it'll override our member name */ +#undef Status +#endif +enum Status +{ + // Not yet scheduled. + Pending = 0, + + // This status means that the close handler has not yet been scheduled. + Running, + + // Inner script called close() on the worker global scope. Setting this + // status causes the worker to clear its queue of events but does not abort + // the currently running script. The close handler is also scheduled with + // no expiration time. + Closing, + + // Outer script called terminate() on the worker or the worker object was + // garbage collected in its outer script. Setting this status causes the + // worker to abort immediately, clear its queue of events, and schedules the + // close handler with no expiration time. + Terminating, + + // Either the user navigated away from the owning page or the owning page fell + // out of bfcache. Setting this status causes the worker to abort immediately + // and schedules the close handler with a short expiration time. Since the + // page has gone away the worker may not post any messages. + Canceling, + + // The application is shutting down. Setting this status causes the worker to + // abort immediately and the close handler is never scheduled. + Killing, + + // The close handler has run and the worker is effectively dead. + Dead +}; + +class WorkerHolder +{ +public: + NS_DECL_OWNINGTHREAD + + WorkerHolder(); + virtual ~WorkerHolder(); + + bool HoldWorker(WorkerPrivate* aWorkerPrivate, Status aFailStatus); + void ReleaseWorker(); + + virtual bool Notify(Status aStatus) = 0; + +protected: + void ReleaseWorkerInternal(); + + WorkerPrivate* MOZ_NON_OWNING_REF mWorkerPrivate; + +private: + void AssertIsOwningThread() const; +}; + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_WorkerHolder_h */ diff --git a/dom/workers/WorkerInlines.h b/dom/workers/WorkerInlines.h new file mode 100644 index 000000000..4fd7fd9a4 --- /dev/null +++ b/dom/workers/WorkerInlines.h @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +BEGIN_WORKERS_NAMESPACE + +inline +void +SetJSPrivateSafeish(JSObject* aObj, PrivatizableBase* aBase) +{ + JS_SetPrivate(aObj, aBase); +} + +template <class Derived> +inline +Derived* +GetJSPrivateSafeish(JSObject* aObj) +{ + return static_cast<Derived*>( + static_cast<PrivatizableBase*>(JS_GetPrivate(aObj))); +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/WorkerLocation.cpp b/dom/workers/WorkerLocation.cpp new file mode 100644 index 000000000..469bf84bf --- /dev/null +++ b/dom/workers/WorkerLocation.cpp @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/WorkerLocation.h" + +#include "mozilla/dom/WorkerLocationBinding.h" + +namespace mozilla { +namespace dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WorkerLocation) + +NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WorkerLocation, AddRef) +NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WorkerLocation, Release) + +/* static */ already_AddRefed<WorkerLocation> +WorkerLocation::Create(workers::WorkerPrivate::LocationInfo& aInfo) +{ + RefPtr<WorkerLocation> location = + new WorkerLocation(NS_ConvertUTF8toUTF16(aInfo.mHref), + NS_ConvertUTF8toUTF16(aInfo.mProtocol), + NS_ConvertUTF8toUTF16(aInfo.mHost), + NS_ConvertUTF8toUTF16(aInfo.mHostname), + NS_ConvertUTF8toUTF16(aInfo.mPort), + NS_ConvertUTF8toUTF16(aInfo.mPathname), + NS_ConvertUTF8toUTF16(aInfo.mSearch), + NS_ConvertUTF8toUTF16(aInfo.mHash), + aInfo.mOrigin); + + return location.forget(); +} + +JSObject* +WorkerLocation::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return WorkerLocationBinding::Wrap(aCx, this, aGivenProto); +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/WorkerLocation.h b/dom/workers/WorkerLocation.h new file mode 100644 index 000000000..73137efff --- /dev/null +++ b/dom/workers/WorkerLocation.h @@ -0,0 +1,116 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_location_h__ +#define mozilla_dom_location_h__ + +#include "Workers.h" +#include "WorkerPrivate.h" +#include "nsWrapperCache.h" + +namespace mozilla { +namespace dom { + +class WorkerLocation final : public nsWrapperCache +{ + nsString mHref; + nsString mProtocol; + nsString mHost; + nsString mHostname; + nsString mPort; + nsString mPathname; + nsString mSearch; + nsString mHash; + nsString mOrigin; + + WorkerLocation(const nsAString& aHref, + const nsAString& aProtocol, + const nsAString& aHost, + const nsAString& aHostname, + const nsAString& aPort, + const nsAString& aPathname, + const nsAString& aSearch, + const nsAString& aHash, + const nsAString& aOrigin) + : mHref(aHref) + , mProtocol(aProtocol) + , mHost(aHost) + , mHostname(aHostname) + , mPort(aPort) + , mPathname(aPathname) + , mSearch(aSearch) + , mHash(aHash) + , mOrigin(aOrigin) + { + MOZ_COUNT_CTOR(WorkerLocation); + } + + ~WorkerLocation() + { + MOZ_COUNT_DTOR(WorkerLocation); + } + +public: + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WorkerLocation) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WorkerLocation) + + static already_AddRefed<WorkerLocation> + Create(workers::WorkerPrivate::LocationInfo& aInfo); + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + nsISupports* GetParentObject() const { + return nullptr; + } + + void Stringify(nsString& aHref) const + { + aHref = mHref; + } + void GetHref(nsString& aHref) const + { + aHref = mHref; + } + void GetProtocol(nsString& aProtocol) const + { + aProtocol = mProtocol; + } + void GetHost(nsString& aHost) const + { + aHost = mHost; + } + void GetHostname(nsString& aHostname) const + { + aHostname = mHostname; + } + void GetPort(nsString& aPort) const + { + aPort = mPort; + } + void GetPathname(nsString& aPathname) const + { + aPathname = mPathname; + } + void GetSearch(nsString& aSearch) const + { + aSearch = mSearch; + } + void GetHash(nsString& aHash) const + { + aHash = mHash; + } + void GetOrigin(nsString& aOrigin) const + { + aOrigin = mOrigin; + } +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_location_h__ diff --git a/dom/workers/WorkerNavigator.cpp b/dom/workers/WorkerNavigator.cpp new file mode 100644 index 000000000..682c7a22c --- /dev/null +++ b/dom/workers/WorkerNavigator.cpp @@ -0,0 +1,184 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" +#include "mozilla/dom/StorageManager.h" +#include "mozilla/dom/WorkerNavigator.h" +#include "mozilla/dom/WorkerNavigatorBinding.h" + +#include "nsProxyRelease.h" +#include "RuntimeService.h" + +#include "nsIDocument.h" + +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" + +#include "mozilla/dom/Navigator.h" + +namespace mozilla { +namespace dom { + +using namespace mozilla::dom::workers; + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WorkerNavigator, mStorageManager); +NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WorkerNavigator, AddRef) +NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WorkerNavigator, Release) + +/* static */ already_AddRefed<WorkerNavigator> +WorkerNavigator::Create(bool aOnLine) +{ + RuntimeService* rts = RuntimeService::GetService(); + MOZ_ASSERT(rts); + + const RuntimeService::NavigatorProperties& properties = + rts->GetNavigatorProperties(); + + RefPtr<WorkerNavigator> navigator = + new WorkerNavigator(properties, aOnLine); + + return navigator.forget(); +} + +JSObject* +WorkerNavigator::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return WorkerNavigatorBinding::Wrap(aCx, this, aGivenProto); +} + +void +WorkerNavigator::SetLanguages(const nsTArray<nsString>& aLanguages) +{ + WorkerNavigatorBinding::ClearCachedLanguagesValue(this); + mProperties.mLanguages = aLanguages; +} + +void +WorkerNavigator::GetAppName(nsString& aAppName) const +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + if (!mProperties.mAppNameOverridden.IsEmpty() && + !workerPrivate->UsesSystemPrincipal()) { + aAppName = mProperties.mAppNameOverridden; + } else { + aAppName = mProperties.mAppName; + } +} + +void +WorkerNavigator::GetAppVersion(nsString& aAppVersion) const +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + if (!mProperties.mAppVersionOverridden.IsEmpty() && + !workerPrivate->UsesSystemPrincipal()) { + aAppVersion = mProperties.mAppVersionOverridden; + } else { + aAppVersion = mProperties.mAppVersion; + } +} + +void +WorkerNavigator::GetPlatform(nsString& aPlatform) const +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + if (!mProperties.mPlatformOverridden.IsEmpty() && + !workerPrivate->UsesSystemPrincipal()) { + aPlatform = mProperties.mPlatformOverridden; + } else { + aPlatform = mProperties.mPlatform; + } +} + +namespace { + +class GetUserAgentRunnable final : public WorkerMainThreadRunnable +{ + nsString& mUA; + +public: + GetUserAgentRunnable(WorkerPrivate* aWorkerPrivate, nsString& aUA) + : WorkerMainThreadRunnable(aWorkerPrivate, + NS_LITERAL_CSTRING("UserAgent getter")) + , mUA(aUA) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + virtual bool MainThreadRun() override + { + AssertIsOnMainThread(); + + nsCOMPtr<nsPIDOMWindowInner> window = mWorkerPrivate->GetWindow(); + nsCOMPtr<nsIURI> uri; + if (window && window->GetDocShell()) { + nsIDocument* doc = window->GetExtantDoc(); + if (doc) { + doc->NodePrincipal()->GetURI(getter_AddRefs(uri)); + } + } + + bool isCallerChrome = mWorkerPrivate->UsesSystemPrincipal(); + nsresult rv = dom::Navigator::GetUserAgent(window, uri, + isCallerChrome, mUA); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to retrieve user-agent from the worker thread."); + } + + return true; + } +}; + +} // namespace + +void +WorkerNavigator::GetUserAgent(nsString& aUserAgent, ErrorResult& aRv) const +{ + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + RefPtr<GetUserAgentRunnable> runnable = + new GetUserAgentRunnable(workerPrivate, aUserAgent); + + runnable->Dispatch(aRv); +} + +uint64_t +WorkerNavigator::HardwareConcurrency() const +{ + RuntimeService* rts = RuntimeService::GetService(); + MOZ_ASSERT(rts); + + return rts->ClampedHardwareConcurrency(); +} + +StorageManager* +WorkerNavigator::Storage() +{ + if (!mStorageManager) { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + + RefPtr<nsIGlobalObject> global = workerPrivate->GlobalScope(); + MOZ_ASSERT(global); + + mStorageManager = new StorageManager(global); + } + + return mStorageManager; +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/WorkerNavigator.h b/dom/workers/WorkerNavigator.h new file mode 100644 index 000000000..64338e46b --- /dev/null +++ b/dom/workers/WorkerNavigator.h @@ -0,0 +1,114 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workernavigator_h__ +#define mozilla_dom_workernavigator_h__ + +#include "Workers.h" +#include "RuntimeService.h" +#include "nsString.h" +#include "nsWrapperCache.h" +#include "mozilla/dom/StorageManager.h" + +namespace mozilla { +namespace dom { +class Promise; +class StorageManager; + +class WorkerNavigator final : public nsWrapperCache +{ + typedef struct workers::RuntimeService::NavigatorProperties NavigatorProperties; + + NavigatorProperties mProperties; + RefPtr<StorageManager> mStorageManager; + bool mOnline; + + WorkerNavigator(const NavigatorProperties& aProperties, + bool aOnline) + : mProperties(aProperties) + , mOnline(aOnline) + { + MOZ_COUNT_CTOR(WorkerNavigator); + } + + ~WorkerNavigator() + { + MOZ_COUNT_DTOR(WorkerNavigator); + } + +public: + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WorkerNavigator) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WorkerNavigator) + + static already_AddRefed<WorkerNavigator> + Create(bool aOnLine); + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + nsISupports* GetParentObject() const { + return nullptr; + } + + void GetAppCodeName(nsString& aAppCodeName) const + { + aAppCodeName.AssignLiteral("Mozilla"); + } + void GetAppName(nsString& aAppName) const; + + void GetAppVersion(nsString& aAppVersion) const; + + void GetPlatform(nsString& aPlatform) const; + + void GetProduct(nsString& aProduct) const + { + aProduct.AssignLiteral("Gecko"); + } + + bool TaintEnabled() const + { + return false; + } + + void GetLanguage(nsString& aLanguage) const + { + if (mProperties.mLanguages.Length() >= 1) { + aLanguage.Assign(mProperties.mLanguages[0]); + } else { + aLanguage.Truncate(); + } + } + + void GetLanguages(nsTArray<nsString>& aLanguages) const + { + aLanguages = mProperties.mLanguages; + } + + void GetUserAgent(nsString& aUserAgent, ErrorResult& aRv) const; + + bool OnLine() const + { + return mOnline; + } + + // Worker thread only! + void SetOnLine(bool aOnline) + { + mOnline = aOnline; + } + + void SetLanguages(const nsTArray<nsString>& aLanguages); + + uint64_t HardwareConcurrency() const; + + StorageManager* Storage(); +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workernavigator_h__ diff --git a/dom/workers/WorkerPrefs.h b/dom/workers/WorkerPrefs.h new file mode 100644 index 000000000..c9b605a84 --- /dev/null +++ b/dom/workers/WorkerPrefs.h @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// This is the list of the preferences that are exposed to workers. +// The format is as follows: +// +// WORKER_SIMPLE_PREF("foo.bar", FooBar, FOO_BAR, UpdaterFunction) +// +// * First argument is the name of the pref. +// * The name of the getter function. This defines a FindName() +// function that returns the value of the pref on WorkerPrivate. +// * The macro version of the name. This defines a WORKERPREF_FOO_BAR +// macro in Workers.h. +// * The name of the function that updates the new value of a pref. +// +// WORKER_PREF("foo.bar", UpdaterFunction) +// +// * First argument is the name of the pref. +// * The name of the function that updates the new value of a pref. + +#if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP)) +WORKER_SIMPLE_PREF("browser.dom.window.dump.enabled", DumpEnabled, DUMP) +#endif +WORKER_SIMPLE_PREF("canvas.imagebitmap_extensions.enabled", ImageBitmapExtensionsEnabled, IMAGEBITMAP_EXTENSIONS_ENABLED) +WORKER_SIMPLE_PREF("dom.caches.enabled", DOMCachesEnabled, DOM_CACHES) +WORKER_SIMPLE_PREF("dom.caches.testing.enabled", DOMCachesTestingEnabled, DOM_CACHES_TESTING) +WORKER_SIMPLE_PREF("dom.performance.enable_user_timing_logging", PerformanceLoggingEnabled, PERFORMANCE_LOGGING_ENABLED) +WORKER_SIMPLE_PREF("dom.webnotifications.enabled", DOMWorkerNotificationEnabled, DOM_WORKERNOTIFICATION) +WORKER_SIMPLE_PREF("dom.webnotifications.serviceworker.enabled", DOMServiceWorkerNotificationEnabled, DOM_SERVICEWORKERNOTIFICATION) +WORKER_SIMPLE_PREF("dom.webnotifications.requireinteraction.enabled", DOMWorkerNotificationRIEnabled, DOM_WORKERNOTIFICATIONRI) +WORKER_SIMPLE_PREF("dom.serviceWorkers.enabled", ServiceWorkersEnabled, SERVICEWORKERS_ENABLED) +WORKER_SIMPLE_PREF("dom.serviceWorkers.testing.enabled", ServiceWorkersTestingEnabled, SERVICEWORKERS_TESTING_ENABLED) +WORKER_SIMPLE_PREF("dom.serviceWorkers.openWindow.enabled", OpenWindowEnabled, OPEN_WINDOW_ENABLED) +WORKER_SIMPLE_PREF("dom.storageManager.enabled", StorageManagerEnabled, STORAGEMANAGER_ENABLED) +WORKER_SIMPLE_PREF("dom.push.enabled", PushEnabled, PUSH_ENABLED) +WORKER_SIMPLE_PREF("dom.requestcontext.enabled", RequestContextEnabled, REQUESTCONTEXT_ENABLED) +WORKER_SIMPLE_PREF("gfx.offscreencanvas.enabled", OffscreenCanvasEnabled, OFFSCREENCANVAS_ENABLED) +WORKER_SIMPLE_PREF("dom.webkitBlink.dirPicker.enabled", WebkitBlinkDirectoryPickerEnabled, DOM_WEBKITBLINK_DIRPICKER_WEBKITBLINK) +WORKER_PREF("dom.workers.latestJSVersion", JSVersionChanged) +WORKER_PREF("intl.accept_languages", PrefLanguagesChanged) +WORKER_PREF("general.appname.override", AppNameOverrideChanged) +WORKER_PREF("general.appversion.override", AppVersionOverrideChanged) +WORKER_PREF("general.platform.override", PlatformOverrideChanged) +#ifdef JS_GC_ZEAL +WORKER_PREF("dom.workers.options.gcZeal", LoadGCZealOptions) +#endif diff --git a/dom/workers/WorkerPrivate.cpp b/dom/workers/WorkerPrivate.cpp new file mode 100644 index 000000000..1df4e5551 --- /dev/null +++ b/dom/workers/WorkerPrivate.cpp @@ -0,0 +1,6752 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerPrivate.h" + +#include "amIAddonManager.h" +#include "nsIClassInfo.h" +#include "nsIContentSecurityPolicy.h" +#include "nsIConsoleService.h" +#include "nsIDOMDOMException.h" +#include "nsIDOMEvent.h" +#include "nsIDocument.h" +#include "nsIDocShell.h" +#include "nsIInterfaceRequestor.h" +#include "nsIMemoryReporter.h" +#include "nsINetworkInterceptController.h" +#include "nsIPermissionManager.h" +#include "nsIScriptError.h" +#include "nsIScriptGlobalObject.h" +#include "nsIScriptSecurityManager.h" +#include "nsIScriptTimeoutHandler.h" +#include "nsITabChild.h" +#include "nsITextToSubURI.h" +#include "nsIThreadInternal.h" +#include "nsITimer.h" +#include "nsIURI.h" +#include "nsIURL.h" +#include "nsIWeakReferenceUtils.h" +#include "nsIWorkerDebugger.h" +#include "nsIXPConnect.h" +#include "nsPIDOMWindow.h" +#include "nsGlobalWindow.h" + +#include <algorithm> +#include "ImageContainer.h" +#include "jsfriendapi.h" +#include "js/MemoryMetrics.h" +#include "mozilla/Assertions.h" +#include "mozilla/Attributes.h" +#include "mozilla/ContentEvents.h" +#include "mozilla/EventDispatcher.h" +#include "mozilla/Likely.h" +#include "mozilla/LoadContext.h" +#include "mozilla/Move.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/Console.h" +#include "mozilla/dom/DocGroup.h" +#include "mozilla/dom/ErrorEvent.h" +#include "mozilla/dom/ErrorEventBinding.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/ExtendableMessageEventBinding.h" +#include "mozilla/dom/FunctionBinding.h" +#include "mozilla/dom/IndexedDatabaseManager.h" +#include "mozilla/dom/MessageEvent.h" +#include "mozilla/dom/MessageEventBinding.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/MessagePortBinding.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/PMessagePort.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseDebugging.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/SimpleGlobalObject.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "mozilla/dom/TabChild.h" +#include "mozilla/dom/WorkerBinding.h" +#include "mozilla/dom/WorkerDebuggerGlobalScopeBinding.h" +#include "mozilla/dom/WorkerGlobalScopeBinding.h" +#include "mozilla/Preferences.h" +#include "mozilla/ThrottledEventQueue.h" +#include "mozilla/TimelineConsumers.h" +#include "mozilla/WorkerTimelineMarker.h" +#include "nsAlgorithm.h" +#include "nsContentUtils.h" +#include "nsCycleCollector.h" +#include "nsError.h" +#include "nsDOMJSUtils.h" +#include "nsHostObjectProtocolHandler.h" +#include "nsJSEnvironment.h" +#include "nsJSUtils.h" +#include "nsNetUtil.h" +#include "nsPrintfCString.h" +#include "nsProxyRelease.h" +#include "nsQueryObject.h" +#include "nsSandboxFlags.h" +#include "nsUTF8Utils.h" +#include "prthread.h" +#include "xpcpublic.h" + +#ifdef ANDROID +#include <android/log.h> +#endif + +#ifdef DEBUG +#include "nsThreadManager.h" +#endif + +#include "Navigator.h" +#include "Principal.h" +#include "RuntimeService.h" +#include "ScriptLoader.h" +#include "ServiceWorkerEvents.h" +#include "ServiceWorkerManager.h" +#include "ServiceWorkerWindowClient.h" +#include "SharedWorker.h" +#include "WorkerDebuggerManager.h" +#include "WorkerHolder.h" +#include "WorkerNavigator.h" +#include "WorkerRunnable.h" +#include "WorkerScope.h" +#include "WorkerThread.h" + +// JS_MaybeGC will run once every second during normal execution. +#define PERIODIC_GC_TIMER_DELAY_SEC 1 + +// A shrinking GC will run five seconds after the last event is processed. +#define IDLE_GC_TIMER_DELAY_SEC 5 + +#define PREF_WORKERS_ENABLED "dom.workers.enabled" + +static mozilla::LazyLogModule sWorkerPrivateLog("WorkerPrivate"); +static mozilla::LazyLogModule sWorkerTimeoutsLog("WorkerTimeouts"); + +mozilla::LogModule* +WorkerLog() +{ + return sWorkerPrivateLog; +} + +mozilla::LogModule* +TimeoutsLog() +{ + return sWorkerTimeoutsLog; +} + +#define LOG(log, _args) MOZ_LOG(log, LogLevel::Debug, _args); + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +USING_WORKERS_NAMESPACE + +MOZ_DEFINE_MALLOC_SIZE_OF(JsWorkerMallocSizeOf) + +#ifdef DEBUG + +BEGIN_WORKERS_NAMESPACE + +void +AssertIsOnMainThread() +{ + MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!"); +} + +END_WORKERS_NAMESPACE + +#endif + +namespace { + +#ifdef DEBUG + +const nsIID kDEBUGWorkerEventTargetIID = { + 0xccaba3fa, 0x5be2, 0x4de2, { 0xba, 0x87, 0x3b, 0x3b, 0x5b, 0x1d, 0x5, 0xfb } +}; + +#endif + +template <class T> +class AutoPtrComparator +{ + typedef nsAutoPtr<T> A; + typedef T* B; + +public: + bool Equals(const A& a, const B& b) const { + return a && b ? *a == *b : !a && !b ? true : false; + } + bool LessThan(const A& a, const B& b) const { + return a && b ? *a < *b : b ? true : false; + } +}; + +template <class T> +inline AutoPtrComparator<T> +GetAutoPtrComparator(const nsTArray<nsAutoPtr<T> >&) +{ + return AutoPtrComparator<T>(); +} + +// Specialize this if there's some class that has multiple nsISupports bases. +template <class T> +struct ISupportsBaseInfo +{ + typedef T ISupportsBase; +}; + +template <template <class> class SmartPtr, class T> +inline void +SwapToISupportsArray(SmartPtr<T>& aSrc, + nsTArray<nsCOMPtr<nsISupports> >& aDest) +{ + nsCOMPtr<nsISupports>* dest = aDest.AppendElement(); + + T* raw = nullptr; + aSrc.swap(raw); + + nsISupports* rawSupports = + static_cast<typename ISupportsBaseInfo<T>::ISupportsBase*>(raw); + dest->swap(rawSupports); +} + +// This class is used to wrap any runnables that the worker receives via the +// nsIEventTarget::Dispatch() method (either from NS_DispatchToCurrentThread or +// from the worker's EventTarget). +class ExternalRunnableWrapper final : public WorkerRunnable +{ + nsCOMPtr<nsIRunnable> mWrappedRunnable; + +public: + ExternalRunnableWrapper(WorkerPrivate* aWorkerPrivate, + nsIRunnable* aWrappedRunnable) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mWrappedRunnable(aWrappedRunnable) + { + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWrappedRunnable); + } + + NS_DECL_ISUPPORTS_INHERITED + +private: + ~ExternalRunnableWrapper() + { } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + nsresult rv = mWrappedRunnable->Run(); + if (NS_FAILED(rv)) { + if (!JS_IsExceptionPending(aCx)) { + Throw(aCx, rv); + } + return false; + } + return true; + } + + nsresult + Cancel() override + { + nsresult rv; + nsCOMPtr<nsICancelableRunnable> cancelable = + do_QueryInterface(mWrappedRunnable); + MOZ_ASSERT(cancelable); // We checked this earlier! + rv = cancelable->Cancel(); + nsresult rv2 = WorkerRunnable::Cancel(); + return NS_FAILED(rv) ? rv : rv2; + } +}; + +struct WindowAction +{ + nsPIDOMWindowInner* mWindow; + bool mDefaultAction; + + MOZ_IMPLICIT WindowAction(nsPIDOMWindowInner* aWindow) + : mWindow(aWindow), mDefaultAction(true) + { } + + bool + operator==(const WindowAction& aOther) const + { + return mWindow == aOther.mWindow; + } +}; + +void +LogErrorToConsole(const nsAString& aMessage, + const nsAString& aFilename, + const nsAString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags, + uint64_t aInnerWindowId) +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIScriptError> scriptError = + do_CreateInstance(NS_SCRIPTERROR_CONTRACTID); + NS_WARNING_ASSERTION(scriptError, "Failed to create script error!"); + + if (scriptError) { + if (NS_FAILED(scriptError->InitWithWindowID(aMessage, aFilename, aLine, + aLineNumber, aColumnNumber, + aFlags, "Web Worker", + aInnerWindowId))) { + NS_WARNING("Failed to init script error!"); + scriptError = nullptr; + } + } + + nsCOMPtr<nsIConsoleService> consoleService = + do_GetService(NS_CONSOLESERVICE_CONTRACTID); + NS_WARNING_ASSERTION(consoleService, "Failed to get console service!"); + + if (consoleService) { + if (scriptError) { + if (NS_SUCCEEDED(consoleService->LogMessage(scriptError))) { + return; + } + NS_WARNING("LogMessage failed!"); + } else if (NS_SUCCEEDED(consoleService->LogStringMessage( + aMessage.BeginReading()))) { + return; + } + NS_WARNING("LogStringMessage failed!"); + } + + NS_ConvertUTF16toUTF8 msg(aMessage); + NS_ConvertUTF16toUTF8 filename(aFilename); + + static const char kErrorString[] = "JS error in Web Worker: %s [%s:%u]"; + +#ifdef ANDROID + __android_log_print(ANDROID_LOG_INFO, "Gecko", kErrorString, msg.get(), + filename.get(), aLineNumber); +#endif + + fprintf(stderr, kErrorString, msg.get(), filename.get(), aLineNumber); + fflush(stderr); +} + +class MainThreadReleaseRunnable final : public Runnable +{ + nsTArray<nsCOMPtr<nsISupports>> mDoomed; + nsCOMPtr<nsILoadGroup> mLoadGroupToCancel; + +public: + MainThreadReleaseRunnable(nsTArray<nsCOMPtr<nsISupports>>& aDoomed, + nsCOMPtr<nsILoadGroup>& aLoadGroupToCancel) + { + mDoomed.SwapElements(aDoomed); + mLoadGroupToCancel.swap(aLoadGroupToCancel); + } + + NS_DECL_ISUPPORTS_INHERITED + + NS_IMETHOD + Run() override + { + if (mLoadGroupToCancel) { + mLoadGroupToCancel->Cancel(NS_BINDING_ABORTED); + mLoadGroupToCancel = nullptr; + } + + mDoomed.Clear(); + return NS_OK; + } + +private: + ~MainThreadReleaseRunnable() + { } +}; + +class WorkerFinishedRunnable final : public WorkerControlRunnable +{ + WorkerPrivate* mFinishedWorker; + +public: + WorkerFinishedRunnable(WorkerPrivate* aWorkerPrivate, + WorkerPrivate* aFinishedWorker) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mFinishedWorker(aFinishedWorker) + { } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // Silence bad assertions. + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // Silence bad assertions. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + nsCOMPtr<nsILoadGroup> loadGroupToCancel; + mFinishedWorker->ForgetOverridenLoadGroup(loadGroupToCancel); + + nsTArray<nsCOMPtr<nsISupports>> doomed; + mFinishedWorker->ForgetMainThreadObjects(doomed); + + RefPtr<MainThreadReleaseRunnable> runnable = + new MainThreadReleaseRunnable(doomed, loadGroupToCancel); + if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable.forget()))) { + NS_WARNING("Failed to dispatch, going to leak!"); + } + + RuntimeService* runtime = RuntimeService::GetService(); + NS_ASSERTION(runtime, "This should never be null!"); + + mFinishedWorker->DisableDebugger(); + + runtime->UnregisterWorker(mFinishedWorker); + + mFinishedWorker->ClearSelfRef(); + return true; + } +}; + +class TopLevelWorkerFinishedRunnable final : public Runnable +{ + WorkerPrivate* mFinishedWorker; + +public: + explicit TopLevelWorkerFinishedRunnable(WorkerPrivate* aFinishedWorker) + : mFinishedWorker(aFinishedWorker) + { + aFinishedWorker->AssertIsOnWorkerThread(); + } + + NS_DECL_ISUPPORTS_INHERITED + +private: + ~TopLevelWorkerFinishedRunnable() {} + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + RuntimeService* runtime = RuntimeService::GetService(); + MOZ_ASSERT(runtime); + + mFinishedWorker->DisableDebugger(); + + runtime->UnregisterWorker(mFinishedWorker); + + nsCOMPtr<nsILoadGroup> loadGroupToCancel; + mFinishedWorker->ForgetOverridenLoadGroup(loadGroupToCancel); + + nsTArray<nsCOMPtr<nsISupports> > doomed; + mFinishedWorker->ForgetMainThreadObjects(doomed); + + RefPtr<MainThreadReleaseRunnable> runnable = + new MainThreadReleaseRunnable(doomed, loadGroupToCancel); + if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) { + NS_WARNING("Failed to dispatch, going to leak!"); + } + + mFinishedWorker->ClearSelfRef(); + return NS_OK; + } +}; + +class ModifyBusyCountRunnable final : public WorkerControlRunnable +{ + bool mIncrease; + +public: + ModifyBusyCountRunnable(WorkerPrivate* aWorkerPrivate, bool aIncrease) + : WorkerControlRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount), + mIncrease(aIncrease) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->ModifyBusyCount(mIncrease); + } + + virtual void + PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult) + override + { + if (mIncrease) { + WorkerControlRunnable::PostRun(aCx, aWorkerPrivate, aRunResult); + return; + } + // Don't do anything here as it's possible that aWorkerPrivate has been + // deleted. + } +}; + +class CompileScriptRunnable final : public WorkerRunnable +{ + nsString mScriptURL; + +public: + explicit CompileScriptRunnable(WorkerPrivate* aWorkerPrivate, + const nsAString& aScriptURL) + : WorkerRunnable(aWorkerPrivate), + mScriptURL(aScriptURL) + { } + +private: + // We can't implement PreRun effectively, because at the point when that would + // run we have not yet done our load so don't know things like our final + // principal and whatnot. + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + + ErrorResult rv; + scriptloader::LoadMainScript(aWorkerPrivate, mScriptURL, WorkerScript, rv); + rv.WouldReportJSException(); + // Explicitly ignore NS_BINDING_ABORTED on rv. Or more precisely, still + // return false and don't SetWorkerScriptExecutedSuccessfully() in that + // case, but don't throw anything on aCx. The idea is to not dispatch error + // events if our load is canceled with that error code. + if (rv.ErrorCodeIs(NS_BINDING_ABORTED)) { + rv.SuppressException(); + return false; + } + + WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope(); + if (NS_WARN_IF(!globalScope)) { + // We never got as far as calling GetOrCreateGlobalScope, or it failed. + // We have no way to enter a compartment, hence no sane way to report this + // error. :( + rv.SuppressException(); + return false; + } + + // Make sure to propagate exceptions from rv onto aCx, so that they will get + // reported after we return. We do this for all failures on rv, because now + // we're using rv to track all the state we care about. + // + // This is a little dumb, but aCx is in the null compartment here because we + // set it up that way in our Run(), since we had not created the global at + // that point yet. So we need to enter the compartment of our global, + // because setting a pending exception on aCx involves wrapping into its + // current compartment. Luckily we have a global now. + JSAutoCompartment ac(aCx, globalScope->GetGlobalJSObject()); + if (rv.MaybeSetPendingException(aCx)) { + return false; + } + + aWorkerPrivate->SetWorkerScriptExecutedSuccessfully(); + return true; + } +}; + +class CompileDebuggerScriptRunnable final : public WorkerDebuggerRunnable +{ + nsString mScriptURL; + +public: + CompileDebuggerScriptRunnable(WorkerPrivate* aWorkerPrivate, + const nsAString& aScriptURL) + : WorkerDebuggerRunnable(aWorkerPrivate), + mScriptURL(aScriptURL) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + + WorkerDebuggerGlobalScope* globalScope = + aWorkerPrivate->CreateDebuggerGlobalScope(aCx); + if (!globalScope) { + NS_WARNING("Failed to make global!"); + return false; + } + + JS::Rooted<JSObject*> global(aCx, globalScope->GetWrapper()); + + ErrorResult rv; + JSAutoCompartment ac(aCx, global); + scriptloader::LoadMainScript(aWorkerPrivate, mScriptURL, + DebuggerScript, rv); + rv.WouldReportJSException(); + // Explicitly ignore NS_BINDING_ABORTED on rv. Or more precisely, still + // return false and don't SetWorkerScriptExecutedSuccessfully() in that + // case, but don't throw anything on aCx. The idea is to not dispatch error + // events if our load is canceled with that error code. + if (rv.ErrorCodeIs(NS_BINDING_ABORTED)) { + rv.SuppressException(); + return false; + } + // Make sure to propagate exceptions from rv onto aCx, so that they will get + // reported after we return. We do this for all failures on rv, because now + // we're using rv to track all the state we care about. + if (rv.MaybeSetPendingException(aCx)) { + return false; + } + + return true; + } +}; + +class MessageEventRunnable final : public WorkerRunnable + , public StructuredCloneHolder +{ + // This is only used for messages dispatched to a service worker. + UniquePtr<ServiceWorkerClientInfo> mEventSource; + + RefPtr<PromiseNativeHandler> mHandler; + +public: + MessageEventRunnable(WorkerPrivate* aWorkerPrivate, + TargetAndBusyBehavior aBehavior) + : WorkerRunnable(aWorkerPrivate, aBehavior) + , StructuredCloneHolder(CloningSupported, TransferringSupported, + StructuredCloneScope::SameProcessDifferentThread) + { + } + + void + SetServiceWorkerData(UniquePtr<ServiceWorkerClientInfo>&& aSource, + PromiseNativeHandler* aHandler) + { + mEventSource = Move(aSource); + mHandler = aHandler; + } + + bool + DispatchDOMEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate, + DOMEventTargetHelper* aTarget, bool aIsMainThread) + { + nsCOMPtr<nsIGlobalObject> parent = do_QueryInterface(aTarget->GetParentObject()); + + // For some workers without window, parent is null and we try to find it + // from the JS Context. + if (!parent) { + JS::Rooted<JSObject*> globalObject(aCx, JS::CurrentGlobalOrNull(aCx)); + if (NS_WARN_IF(!globalObject)) { + return false; + } + + parent = xpc::NativeGlobal(globalObject); + if (NS_WARN_IF(!parent)) { + return false; + } + } + + MOZ_ASSERT(parent); + + JS::Rooted<JS::Value> messageData(aCx); + ErrorResult rv; + + UniquePtr<AbstractTimelineMarker> start; + UniquePtr<AbstractTimelineMarker> end; + RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get(); + bool isTimelineRecording = timelines && !timelines->IsEmpty(); + + if (isTimelineRecording) { + start = MakeUnique<WorkerTimelineMarker>(aIsMainThread + ? ProfileTimelineWorkerOperationType::DeserializeDataOnMainThread + : ProfileTimelineWorkerOperationType::DeserializeDataOffMainThread, + MarkerTracingType::START); + } + + Read(parent, aCx, &messageData, rv); + + if (isTimelineRecording) { + end = MakeUnique<WorkerTimelineMarker>(aIsMainThread + ? ProfileTimelineWorkerOperationType::DeserializeDataOnMainThread + : ProfileTimelineWorkerOperationType::DeserializeDataOffMainThread, + MarkerTracingType::END); + timelines->AddMarkerForAllObservedDocShells(start); + timelines->AddMarkerForAllObservedDocShells(end); + } + + if (NS_WARN_IF(rv.Failed())) { + xpc::Throw(aCx, rv.StealNSResult()); + return false; + } + + Sequence<OwningNonNull<MessagePort>> ports; + if (!TakeTransferredPortsAsSequence(ports)) { + return false; + } + + nsCOMPtr<nsIDOMEvent> domEvent; + RefPtr<ExtendableMessageEvent> extendableEvent; + // For messages dispatched to service worker, use ExtendableMessageEvent + // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#extendablemessage-event-section + if (mEventSource) { + RefPtr<ServiceWorkerClient> client = + new ServiceWorkerWindowClient(aTarget, *mEventSource); + + RootedDictionary<ExtendableMessageEventInit> init(aCx); + + init.mBubbles = false; + init.mCancelable = false; + + init.mData = messageData; + init.mPorts = ports; + init.mSource.SetValue().SetAsClient() = client; + + ErrorResult rv; + extendableEvent = ExtendableMessageEvent::Constructor( + aTarget, NS_LITERAL_STRING("message"), init, rv); + if (NS_WARN_IF(rv.Failed())) { + rv.SuppressException(); + return false; + } + + domEvent = do_QueryObject(extendableEvent); + } else { + RefPtr<MessageEvent> event = new MessageEvent(aTarget, nullptr, nullptr); + event->InitMessageEvent(nullptr, + NS_LITERAL_STRING("message"), + false /* non-bubbling */, + false /* cancelable */, + messageData, + EmptyString(), + EmptyString(), + nullptr, + ports); + domEvent = do_QueryObject(event); + } + + domEvent->SetTrusted(true); + + nsEventStatus dummy = nsEventStatus_eIgnore; + aTarget->DispatchDOMEvent(nullptr, domEvent, nullptr, &dummy); + + if (extendableEvent && mHandler) { + RefPtr<Promise> waitUntilPromise = extendableEvent->GetPromise(); + if (!waitUntilPromise) { + waitUntilPromise = Promise::Resolve(parent, aCx, + JS::UndefinedHandleValue, rv); + MOZ_RELEASE_ASSERT(!rv.Failed()); + } + + MOZ_ASSERT(waitUntilPromise); + + waitUntilPromise->AppendNativeHandler(mHandler); + } + + return true; + } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + if (mBehavior == ParentThreadUnchangedBusyCount) { + // Don't fire this event if the JS object has been disconnected from the + // private object. + if (!aWorkerPrivate->IsAcceptingEvents()) { + return true; + } + + if (aWorkerPrivate->IsFrozen() || + aWorkerPrivate->IsParentWindowPaused()) { + MOZ_ASSERT(!IsDebuggerRunnable()); + aWorkerPrivate->QueueRunnable(this); + return true; + } + + aWorkerPrivate->AssertInnerWindowIsCorrect(); + + return DispatchDOMEvent(aCx, aWorkerPrivate, aWorkerPrivate, + !aWorkerPrivate->GetParent()); + } + + MOZ_ASSERT(aWorkerPrivate == GetWorkerPrivateFromContext(aCx)); + + return DispatchDOMEvent(aCx, aWorkerPrivate, aWorkerPrivate->GlobalScope(), + false); + } +}; + +class DebuggerMessageEventRunnable : public WorkerDebuggerRunnable { + nsString mMessage; + +public: + DebuggerMessageEventRunnable(WorkerPrivate* aWorkerPrivate, + const nsAString& aMessage) + : WorkerDebuggerRunnable(aWorkerPrivate), + mMessage(aMessage) + { + } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + WorkerDebuggerGlobalScope* globalScope = aWorkerPrivate->DebuggerGlobalScope(); + MOZ_ASSERT(globalScope); + + JS::Rooted<JSString*> message(aCx, JS_NewUCStringCopyN(aCx, mMessage.get(), + mMessage.Length())); + if (!message) { + return false; + } + JS::Rooted<JS::Value> data(aCx, JS::StringValue(message)); + + RefPtr<MessageEvent> event = new MessageEvent(globalScope, nullptr, + nullptr); + event->InitMessageEvent(nullptr, + NS_LITERAL_STRING("message"), + false, // canBubble + true, // cancelable + data, + EmptyString(), + EmptyString(), + nullptr, + Sequence<OwningNonNull<MessagePort>>()); + event->SetTrusted(true); + + nsCOMPtr<nsIDOMEvent> domEvent = do_QueryObject(event); + nsEventStatus status = nsEventStatus_eIgnore; + globalScope->DispatchDOMEvent(nullptr, domEvent, nullptr, &status); + return true; + } +}; + +class NotifyRunnable final : public WorkerControlRunnable +{ + Status mStatus; + +public: + NotifyRunnable(WorkerPrivate* aWorkerPrivate, Status aStatus) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mStatus(aStatus) + { + MOZ_ASSERT(aStatus == Closing || aStatus == Terminating || + aStatus == Canceling || aStatus == Killing); + } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->AssertIsOnParentThread(); + return aWorkerPrivate->ModifyBusyCount(true); + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + aWorkerPrivate->AssertIsOnParentThread(); + if (!aDispatchResult) { + // We couldn't dispatch to the worker, which means it's already dead. + // Undo the busy count modification. + aWorkerPrivate->ModifyBusyCount(false); + } + } + + virtual void + PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult) + override + { + aWorkerPrivate->ModifyBusyCountFromWorker(false); + return; + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + bool ok = aWorkerPrivate->NotifyInternal(aCx, mStatus); + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + return ok; + } +}; + +class CloseRunnable final : public WorkerControlRunnable +{ +public: + explicit CloseRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerControlRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->Close(); + } +}; + +class FreezeRunnable final : public WorkerControlRunnable +{ +public: + explicit FreezeRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->FreezeInternal(); + } +}; + +class ThawRunnable final : public WorkerControlRunnable +{ +public: + explicit ThawRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->ThawInternal(); + } +}; + +class ReportErrorToConsoleRunnable final : public WorkerRunnable +{ + const char* mMessage; + +public: + // aWorkerPrivate is the worker thread we're on (or the main thread, if null) + static void + Report(WorkerPrivate* aWorkerPrivate, const char* aMessage) + { + if (aWorkerPrivate) { + aWorkerPrivate->AssertIsOnWorkerThread(); + } else { + AssertIsOnMainThread(); + } + + // Now fire a runnable to do the same on the parent's thread if we can. + if (aWorkerPrivate) { + RefPtr<ReportErrorToConsoleRunnable> runnable = + new ReportErrorToConsoleRunnable(aWorkerPrivate, aMessage); + runnable->Dispatch(); + return; + } + + // Log a warning to the console. + nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, + NS_LITERAL_CSTRING("DOM"), + nullptr, + nsContentUtils::eDOM_PROPERTIES, + aMessage); + } + +private: + ReportErrorToConsoleRunnable(WorkerPrivate* aWorkerPrivate, const char* aMessage) + : WorkerRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount), + mMessage(aMessage) + { } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + + // Dispatch may fail if the worker was canceled, no need to report that as + // an error, so don't call base class PostDispatch. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + WorkerPrivate* parent = aWorkerPrivate->GetParent(); + MOZ_ASSERT_IF(!parent, NS_IsMainThread()); + Report(parent, mMessage); + return true; + } +}; + +class ReportErrorRunnable final : public WorkerRunnable +{ + nsString mMessage; + nsString mFilename; + nsString mLine; + uint32_t mLineNumber; + uint32_t mColumnNumber; + uint32_t mFlags; + uint32_t mErrorNumber; + JSExnType mExnType; + bool mMutedError; + +public: + // aWorkerPrivate is the worker thread we're on (or the main thread, if null) + // aTarget is the worker object that we are going to fire an error at + // (if any). + static void + ReportError(JSContext* aCx, WorkerPrivate* aWorkerPrivate, + bool aFireAtScope, WorkerPrivate* aTarget, + const nsString& aMessage, const nsString& aFilename, + const nsString& aLine, uint32_t aLineNumber, + uint32_t aColumnNumber, uint32_t aFlags, + uint32_t aErrorNumber, JSExnType aExnType, + bool aMutedError, uint64_t aInnerWindowId, + JS::Handle<JS::Value> aException = JS::NullHandleValue) + { + if (aWorkerPrivate) { + aWorkerPrivate->AssertIsOnWorkerThread(); + } else { + AssertIsOnMainThread(); + } + + // We should not fire error events for warnings but instead make sure that + // they show up in the error console. + if (!JSREPORT_IS_WARNING(aFlags)) { + // First fire an ErrorEvent at the worker. + RootedDictionary<ErrorEventInit> init(aCx); + + if (aMutedError) { + init.mMessage.AssignLiteral("Script error."); + } else { + init.mMessage = aMessage; + init.mFilename = aFilename; + init.mLineno = aLineNumber; + init.mError = aException; + } + + init.mCancelable = true; + init.mBubbles = false; + + if (aTarget) { + RefPtr<ErrorEvent> event = + ErrorEvent::Constructor(aTarget, NS_LITERAL_STRING("error"), init); + event->SetTrusted(true); + + nsEventStatus status = nsEventStatus_eIgnore; + aTarget->DispatchDOMEvent(nullptr, event, nullptr, &status); + + if (status == nsEventStatus_eConsumeNoDefault) { + return; + } + } + + // Now fire an event at the global object, but don't do that if the error + // code is too much recursion and this is the same script threw the error. + // XXXbz the interaction of this with worker errors seems kinda broken. + // An overrecursion in the debugger or debugger sandbox will get turned + // into an error event on our parent worker! + // https://bugzilla.mozilla.org/show_bug.cgi?id=1271441 tracks making this + // better. + if (aFireAtScope && (aTarget || aErrorNumber != JSMSG_OVER_RECURSED)) { + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + NS_ASSERTION(global, "This should never be null!"); + + nsEventStatus status = nsEventStatus_eIgnore; + nsIScriptGlobalObject* sgo; + + if (aWorkerPrivate) { + WorkerGlobalScope* globalScope = nullptr; + UNWRAP_OBJECT(WorkerGlobalScope, &global, globalScope); + + if (!globalScope) { + WorkerDebuggerGlobalScope* globalScope = nullptr; + UNWRAP_OBJECT(WorkerDebuggerGlobalScope, &global, globalScope); + + MOZ_ASSERT_IF(globalScope, globalScope->GetWrapperPreserveColor() == global); + if (globalScope || IsDebuggerSandbox(global)) { + aWorkerPrivate->ReportErrorToDebugger(aFilename, aLineNumber, + aMessage); + return; + } + + MOZ_ASSERT(SimpleGlobalObject::SimpleGlobalType(global) == + SimpleGlobalObject::GlobalType::BindingDetail); + // XXXbz We should really log this to console, but unwinding out of + // this stuff without ending up firing any events is ... hard. Just + // return for now. + // https://bugzilla.mozilla.org/show_bug.cgi?id=1271441 tracks + // making this better. + return; + } + + MOZ_ASSERT(globalScope->GetWrapperPreserveColor() == global); + nsIDOMEventTarget* target = static_cast<nsIDOMEventTarget*>(globalScope); + + RefPtr<ErrorEvent> event = + ErrorEvent::Constructor(aTarget, NS_LITERAL_STRING("error"), init); + event->SetTrusted(true); + + if (NS_FAILED(EventDispatcher::DispatchDOMEvent(target, nullptr, + event, nullptr, + &status))) { + NS_WARNING("Failed to dispatch worker thread error event!"); + status = nsEventStatus_eIgnore; + } + } + else if ((sgo = nsJSUtils::GetStaticScriptGlobal(global))) { + MOZ_ASSERT(NS_IsMainThread()); + + if (NS_FAILED(sgo->HandleScriptError(init, &status))) { + NS_WARNING("Failed to dispatch main thread error event!"); + status = nsEventStatus_eIgnore; + } + } + + // Was preventDefault() called? + if (status == nsEventStatus_eConsumeNoDefault) { + return; + } + } + } + + // Now fire a runnable to do the same on the parent's thread if we can. + if (aWorkerPrivate) { + RefPtr<ReportErrorRunnable> runnable = + new ReportErrorRunnable(aWorkerPrivate, aMessage, aFilename, aLine, + aLineNumber, aColumnNumber, aFlags, + aErrorNumber, aExnType, aMutedError); + runnable->Dispatch(); + return; + } + + // Otherwise log an error to the error console. + LogErrorToConsole(aMessage, aFilename, aLine, aLineNumber, aColumnNumber, + aFlags, aInnerWindowId); + } + +private: + ReportErrorRunnable(WorkerPrivate* aWorkerPrivate, const nsString& aMessage, + const nsString& aFilename, const nsString& aLine, + uint32_t aLineNumber, uint32_t aColumnNumber, + uint32_t aFlags, uint32_t aErrorNumber, + JSExnType aExnType, bool aMutedError) + : WorkerRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount), + mMessage(aMessage), mFilename(aFilename), mLine(aLine), + mLineNumber(aLineNumber), mColumnNumber(aColumnNumber), mFlags(aFlags), + mErrorNumber(aErrorNumber), mExnType(aExnType), mMutedError(aMutedError) + { } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + + // Dispatch may fail if the worker was canceled, no need to report that as + // an error, so don't call base class PostDispatch. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + JS::Rooted<JSObject*> target(aCx, aWorkerPrivate->GetWrapper()); + + uint64_t innerWindowId; + bool fireAtScope = true; + + bool workerIsAcceptingEvents = aWorkerPrivate->IsAcceptingEvents(); + + WorkerPrivate* parent = aWorkerPrivate->GetParent(); + if (parent) { + innerWindowId = 0; + } + else { + AssertIsOnMainThread(); + + if (aWorkerPrivate->IsFrozen() || + aWorkerPrivate->IsParentWindowPaused()) { + MOZ_ASSERT(!IsDebuggerRunnable()); + aWorkerPrivate->QueueRunnable(this); + return true; + } + + if (aWorkerPrivate->IsSharedWorker()) { + aWorkerPrivate->BroadcastErrorToSharedWorkers(aCx, mMessage, mFilename, + mLine, mLineNumber, + mColumnNumber, mFlags); + return true; + } + + // Service workers do not have a main thread parent global, so normal + // worker error reporting will crash. Instead, pass the error to + // the ServiceWorkerManager to report on any controlled documents. + if (aWorkerPrivate->IsServiceWorker()) { + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->HandleError(aCx, aWorkerPrivate->GetPrincipal(), + aWorkerPrivate->WorkerName(), + aWorkerPrivate->ScriptURL(), + mMessage, + mFilename, mLine, mLineNumber, + mColumnNumber, mFlags, mExnType); + } + return true; + } + + // The innerWindowId is only required if we are going to ReportError + // below, which is gated on this condition. The inner window correctness + // check is only going to succeed when the worker is accepting events. + if (workerIsAcceptingEvents) { + aWorkerPrivate->AssertInnerWindowIsCorrect(); + innerWindowId = aWorkerPrivate->WindowID(); + } + } + + // Don't fire this event if the JS object has been disconnected from the + // private object. + if (!workerIsAcceptingEvents) { + return true; + } + + ReportError(aCx, parent, fireAtScope, aWorkerPrivate, mMessage, + mFilename, mLine, mLineNumber, mColumnNumber, mFlags, + mErrorNumber, mExnType, mMutedError, innerWindowId); + return true; + } +}; + +class TimerRunnable final : public WorkerRunnable, + public nsITimerCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + + explicit TimerRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { } + +private: + ~TimerRunnable() {} + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // Silence bad assertions. + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // Silence bad assertions. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->RunExpiredTimeouts(aCx); + } + + NS_IMETHOD + Notify(nsITimer* aTimer) override + { + return Run(); + } +}; + +NS_IMPL_ISUPPORTS_INHERITED(TimerRunnable, WorkerRunnable, nsITimerCallback) + +class DebuggerImmediateRunnable : public WorkerRunnable +{ + RefPtr<dom::Function> mHandler; + +public: + explicit DebuggerImmediateRunnable(WorkerPrivate* aWorkerPrivate, + dom::Function& aHandler) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mHandler(&aHandler) + { } + +private: + virtual bool + IsDebuggerRunnable() const override + { + return true; + } + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // Silence bad assertions. + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // Silence bad assertions. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + JS::Rooted<JS::Value> callable(aCx, JS::ObjectValue(*mHandler->Callable())); + JS::HandleValueArray args = JS::HandleValueArray::empty(); + JS::Rooted<JS::Value> rval(aCx); + if (!JS_CallFunctionValue(aCx, global, callable, args, &rval)) { + // Just return false; WorkerRunnable::Run will report the exception. + return false; + } + + return true; + } +}; + +void +DummyCallback(nsITimer* aTimer, void* aClosure) +{ + // Nothing! +} + +class UpdateContextOptionsRunnable final : public WorkerControlRunnable +{ + JS::ContextOptions mContextOptions; + +public: + UpdateContextOptionsRunnable(WorkerPrivate* aWorkerPrivate, + const JS::ContextOptions& aContextOptions) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mContextOptions(aContextOptions) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->UpdateContextOptionsInternal(aCx, mContextOptions); + return true; + } +}; + +class UpdatePreferenceRunnable final : public WorkerControlRunnable +{ + WorkerPreference mPref; + bool mValue; + +public: + UpdatePreferenceRunnable(WorkerPrivate* aWorkerPrivate, + WorkerPreference aPref, + bool aValue) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mPref(aPref), + mValue(aValue) + { } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->UpdatePreferenceInternal(mPref, mValue); + return true; + } +}; + +class UpdateLanguagesRunnable final : public WorkerRunnable +{ + nsTArray<nsString> mLanguages; + +public: + UpdateLanguagesRunnable(WorkerPrivate* aWorkerPrivate, + const nsTArray<nsString>& aLanguages) + : WorkerRunnable(aWorkerPrivate), + mLanguages(aLanguages) + { } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->UpdateLanguagesInternal(mLanguages); + return true; + } +}; + +class UpdateJSWorkerMemoryParameterRunnable final : + public WorkerControlRunnable +{ + uint32_t mValue; + JSGCParamKey mKey; + +public: + UpdateJSWorkerMemoryParameterRunnable(WorkerPrivate* aWorkerPrivate, + JSGCParamKey aKey, + uint32_t aValue) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mValue(aValue), mKey(aKey) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->UpdateJSWorkerMemoryParameterInternal(aCx, mKey, mValue); + return true; + } +}; + +#ifdef JS_GC_ZEAL +class UpdateGCZealRunnable final : public WorkerControlRunnable +{ + uint8_t mGCZeal; + uint32_t mFrequency; + +public: + UpdateGCZealRunnable(WorkerPrivate* aWorkerPrivate, + uint8_t aGCZeal, + uint32_t aFrequency) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mGCZeal(aGCZeal), mFrequency(aFrequency) + { } + +private: + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->UpdateGCZealInternal(aCx, mGCZeal, mFrequency); + return true; + } +}; +#endif + +class GarbageCollectRunnable final : public WorkerControlRunnable +{ + bool mShrinking; + bool mCollectChildren; + +public: + GarbageCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aShrinking, + bool aCollectChildren) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mShrinking(aShrinking), mCollectChildren(aCollectChildren) + { } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // Silence bad assertions, this can be dispatched from either the main + // thread or the timer thread.. + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + // Silence bad assertions, this can be dispatched from either the main + // thread or the timer thread.. + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->GarbageCollectInternal(aCx, mShrinking, mCollectChildren); + return true; + } +}; + +class CycleCollectRunnable : public WorkerControlRunnable +{ + bool mCollectChildren; + +public: + CycleCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aCollectChildren) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mCollectChildren(aCollectChildren) + { } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + aWorkerPrivate->CycleCollectInternal(mCollectChildren); + return true; + } +}; + +class OfflineStatusChangeRunnable : public WorkerRunnable +{ +public: + OfflineStatusChangeRunnable(WorkerPrivate* aWorkerPrivate, bool aIsOffline) + : WorkerRunnable(aWorkerPrivate), + mIsOffline(aIsOffline) + { + } + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + aWorkerPrivate->OfflineStatusChangeEventInternal(mIsOffline); + return true; + } + +private: + bool mIsOffline; +}; + +class MemoryPressureRunnable : public WorkerControlRunnable +{ +public: + explicit MemoryPressureRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + {} + + bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) + { + aWorkerPrivate->MemoryPressureInternal(); + return true; + } +}; + +#ifdef DEBUG +static bool +StartsWithExplicit(nsACString& s) +{ + return StringBeginsWith(s, NS_LITERAL_CSTRING("explicit/")); +} +#endif + +class MessagePortRunnable final : public WorkerRunnable +{ + MessagePortIdentifier mPortIdentifier; + +public: + MessagePortRunnable(WorkerPrivate* aWorkerPrivate, MessagePort* aPort) + : WorkerRunnable(aWorkerPrivate) + { + MOZ_ASSERT(aPort); + // In order to move the port from one thread to another one, we have to + // close and disentangle it. The output will be a MessagePortIdentifier that + // will be used to recreate a new MessagePort on the other thread. + aPort->CloneAndDisentangle(mPortIdentifier); + } + +private: + ~MessagePortRunnable() + { } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + return aWorkerPrivate->ConnectMessagePort(aCx, mPortIdentifier); + } + + nsresult + Cancel() override + { + MessagePort::ForceClose(mPortIdentifier); + return WorkerRunnable::Cancel(); + } +}; + +class DummyRunnable final + : public WorkerRunnable +{ +public: + explicit + DummyRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { + aWorkerPrivate->AssertIsOnWorkerThread(); + } + +private: + ~DummyRunnable() + { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT_UNREACHABLE("Should never call Dispatch on this!"); + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + MOZ_ASSERT_UNREACHABLE("Should never call Dispatch on this!"); + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + // Do nothing. + return true; + } +}; + +PRThread* +PRThreadFromThread(nsIThread* aThread) +{ + MOZ_ASSERT(aThread); + + PRThread* result; + MOZ_ALWAYS_SUCCEEDS(aThread->GetPRThread(&result)); + MOZ_ASSERT(result); + + return result; +} + +class SimpleWorkerHolder final : public WorkerHolder +{ +public: + virtual bool Notify(Status aStatus) { return true; } +}; + +} /* anonymous namespace */ + +NS_IMPL_ISUPPORTS_INHERITED0(MainThreadReleaseRunnable, Runnable) + +NS_IMPL_ISUPPORTS_INHERITED0(TopLevelWorkerFinishedRunnable, Runnable) + +TimerThreadEventTarget::TimerThreadEventTarget(WorkerPrivate* aWorkerPrivate, + WorkerRunnable* aWorkerRunnable) + : mWorkerPrivate(aWorkerPrivate), mWorkerRunnable(aWorkerRunnable) +{ + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aWorkerRunnable); +} + +TimerThreadEventTarget::~TimerThreadEventTarget() +{ +} + +NS_IMETHODIMP +TimerThreadEventTarget::DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) +{ + nsCOMPtr<nsIRunnable> runnable(aRunnable); + return Dispatch(runnable.forget(), aFlags); +} + +NS_IMETHODIMP +TimerThreadEventTarget::Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) +{ + // This should only happen on the timer thread. + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(aFlags == nsIEventTarget::DISPATCH_NORMAL); + + RefPtr<TimerThreadEventTarget> kungFuDeathGrip = this; + + // Run the runnable we're given now (should just call DummyCallback()), + // otherwise the timer thread will leak it... If we run this after + // dispatch running the event can race against resetting the timer. + nsCOMPtr<nsIRunnable> runnable(aRunnable); + runnable->Run(); + + // This can fail if we're racing to terminate or cancel, should be handled + // by the terminate or cancel code. + mWorkerRunnable->Dispatch(); + + return NS_OK; +} + +NS_IMETHODIMP +TimerThreadEventTarget::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TimerThreadEventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread) +{ + MOZ_ASSERT(aIsOnCurrentThread); + + nsresult rv = mWorkerPrivate->IsOnCurrentThread(aIsOnCurrentThread); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +NS_IMPL_ISUPPORTS(TimerThreadEventTarget, nsIEventTarget) + +WorkerLoadInfo::WorkerLoadInfo() + : mWindowID(UINT64_MAX) + , mServiceWorkerID(0) + , mReferrerPolicy(net::RP_Default) + , mFromWindow(false) + , mEvalAllowed(false) + , mReportCSPViolations(false) + , mXHRParamsAllowed(false) + , mPrincipalIsSystem(false) + , mStorageAllowed(false) + , mServiceWorkersTestingInWindow(false) +{ + MOZ_COUNT_CTOR(WorkerLoadInfo); +} + +WorkerLoadInfo::~WorkerLoadInfo() +{ + MOZ_COUNT_DTOR(WorkerLoadInfo); +} + +void +WorkerLoadInfo::StealFrom(WorkerLoadInfo& aOther) +{ + MOZ_ASSERT(!mBaseURI); + aOther.mBaseURI.swap(mBaseURI); + + MOZ_ASSERT(!mResolvedScriptURI); + aOther.mResolvedScriptURI.swap(mResolvedScriptURI); + + MOZ_ASSERT(!mPrincipal); + aOther.mPrincipal.swap(mPrincipal); + + MOZ_ASSERT(!mScriptContext); + aOther.mScriptContext.swap(mScriptContext); + + MOZ_ASSERT(!mWindow); + aOther.mWindow.swap(mWindow); + + MOZ_ASSERT(!mCSP); + aOther.mCSP.swap(mCSP); + + MOZ_ASSERT(!mChannel); + aOther.mChannel.swap(mChannel); + + MOZ_ASSERT(!mLoadGroup); + aOther.mLoadGroup.swap(mLoadGroup); + + MOZ_ASSERT(!mLoadFailedAsyncRunnable); + aOther.mLoadFailedAsyncRunnable.swap(mLoadFailedAsyncRunnable); + + MOZ_ASSERT(!mInterfaceRequestor); + aOther.mInterfaceRequestor.swap(mInterfaceRequestor); + + MOZ_ASSERT(!mPrincipalInfo); + mPrincipalInfo = aOther.mPrincipalInfo.forget(); + + mDomain = aOther.mDomain; + mServiceWorkerCacheName = aOther.mServiceWorkerCacheName; + mWindowID = aOther.mWindowID; + mServiceWorkerID = aOther.mServiceWorkerID; + mReferrerPolicy = aOther.mReferrerPolicy; + mFromWindow = aOther.mFromWindow; + mEvalAllowed = aOther.mEvalAllowed; + mReportCSPViolations = aOther.mReportCSPViolations; + mXHRParamsAllowed = aOther.mXHRParamsAllowed; + mPrincipalIsSystem = aOther.mPrincipalIsSystem; + mStorageAllowed = aOther.mStorageAllowed; + mServiceWorkersTestingInWindow = aOther.mServiceWorkersTestingInWindow; + mOriginAttributes = aOther.mOriginAttributes; +} + +template <class Derived> +class WorkerPrivateParent<Derived>::EventTarget final + : public nsIEventTarget +{ + // This mutex protects mWorkerPrivate and must be acquired *before* the + // WorkerPrivate's mutex whenever they must both be held. + mozilla::Mutex mMutex; + WorkerPrivate* mWorkerPrivate; + nsIEventTarget* mWeakNestedEventTarget; + nsCOMPtr<nsIEventTarget> mNestedEventTarget; + +public: + explicit EventTarget(WorkerPrivate* aWorkerPrivate) + : mMutex("WorkerPrivateParent::EventTarget::mMutex"), + mWorkerPrivate(aWorkerPrivate), mWeakNestedEventTarget(nullptr) + { + MOZ_ASSERT(aWorkerPrivate); + } + + EventTarget(WorkerPrivate* aWorkerPrivate, nsIEventTarget* aNestedEventTarget) + : mMutex("WorkerPrivateParent::EventTarget::mMutex"), + mWorkerPrivate(aWorkerPrivate), mWeakNestedEventTarget(aNestedEventTarget), + mNestedEventTarget(aNestedEventTarget) + { + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aNestedEventTarget); + } + + void + Disable() + { + nsCOMPtr<nsIEventTarget> nestedEventTarget; + { + MutexAutoLock lock(mMutex); + + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate = nullptr; + mNestedEventTarget.swap(nestedEventTarget); + } + } + + nsIEventTarget* + GetWeakNestedEventTarget() const + { + MOZ_ASSERT(mWeakNestedEventTarget); + return mWeakNestedEventTarget; + } + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIEVENTTARGET + +private: + ~EventTarget() + { } +}; + +WorkerLoadInfo:: +InterfaceRequestor::InterfaceRequestor(nsIPrincipal* aPrincipal, + nsILoadGroup* aLoadGroup) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aPrincipal); + + // Look for an existing LoadContext. This is optional and it's ok if + // we don't find one. + nsCOMPtr<nsILoadContext> baseContext; + if (aLoadGroup) { + nsCOMPtr<nsIInterfaceRequestor> callbacks; + aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (callbacks) { + callbacks->GetInterface(NS_GET_IID(nsILoadContext), + getter_AddRefs(baseContext)); + } + mOuterRequestor = callbacks; + } + + mLoadContext = new LoadContext(aPrincipal, baseContext); +} + +void +WorkerLoadInfo:: +InterfaceRequestor::MaybeAddTabChild(nsILoadGroup* aLoadGroup) +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (!aLoadGroup) { + return; + } + + nsCOMPtr<nsIInterfaceRequestor> callbacks; + aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (!callbacks) { + return; + } + + nsCOMPtr<nsITabChild> tabChild; + callbacks->GetInterface(NS_GET_IID(nsITabChild), getter_AddRefs(tabChild)); + if (!tabChild) { + return; + } + + // Use weak references to the tab child. Holding a strong reference will + // not prevent an ActorDestroy() from being called on the TabChild. + // Therefore, we should let the TabChild destroy itself as soon as possible. + mTabChildList.AppendElement(do_GetWeakReference(tabChild)); +} + +NS_IMETHODIMP +WorkerLoadInfo:: +InterfaceRequestor::GetInterface(const nsIID& aIID, void** aSink) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mLoadContext); + + if (aIID.Equals(NS_GET_IID(nsILoadContext))) { + nsCOMPtr<nsILoadContext> ref = mLoadContext; + ref.forget(aSink); + return NS_OK; + } + + // If we still have an active nsITabChild, then return it. Its possible, + // though, that all of the TabChild objects have been destroyed. In that + // case we return NS_NOINTERFACE. + if (aIID.Equals(NS_GET_IID(nsITabChild))) { + nsCOMPtr<nsITabChild> tabChild = GetAnyLiveTabChild(); + if (!tabChild) { + return NS_NOINTERFACE; + } + tabChild.forget(aSink); + return NS_OK; + } + + if (aIID.Equals(NS_GET_IID(nsINetworkInterceptController)) && + mOuterRequestor) { + // If asked for the network intercept controller, ask the outer requestor, + // which could be the docshell. + return mOuterRequestor->GetInterface(aIID, aSink); + } + + return NS_NOINTERFACE; +} + +already_AddRefed<nsITabChild> +WorkerLoadInfo:: +InterfaceRequestor::GetAnyLiveTabChild() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Search our list of known TabChild objects for one that still exists. + while (!mTabChildList.IsEmpty()) { + nsCOMPtr<nsITabChild> tabChild = + do_QueryReferent(mTabChildList.LastElement()); + + // Does this tab child still exist? If so, return it. We are done. If the + // PBrowser actor is no longer useful, don't bother returning this tab. + if (tabChild && !static_cast<TabChild*>(tabChild.get())->IsDestroyed()) { + return tabChild.forget(); + } + + // Otherwise remove the stale weak reference and check the next one + mTabChildList.RemoveElementAt(mTabChildList.Length() - 1); + } + + return nullptr; +} + +NS_IMPL_ADDREF(WorkerLoadInfo::InterfaceRequestor) +NS_IMPL_RELEASE(WorkerLoadInfo::InterfaceRequestor) +NS_IMPL_QUERY_INTERFACE(WorkerLoadInfo::InterfaceRequestor, nsIInterfaceRequestor) + +struct WorkerPrivate::TimeoutInfo +{ + TimeoutInfo() + : mId(0), mIsInterval(false), mCanceled(false) + { + MOZ_COUNT_CTOR(mozilla::dom::workers::WorkerPrivate::TimeoutInfo); + } + + ~TimeoutInfo() + { + MOZ_COUNT_DTOR(mozilla::dom::workers::WorkerPrivate::TimeoutInfo); + } + + bool operator==(const TimeoutInfo& aOther) + { + return mTargetTime == aOther.mTargetTime; + } + + bool operator<(const TimeoutInfo& aOther) + { + return mTargetTime < aOther.mTargetTime; + } + + nsCOMPtr<nsIScriptTimeoutHandler> mHandler; + mozilla::TimeStamp mTargetTime; + mozilla::TimeDuration mInterval; + int32_t mId; + bool mIsInterval; + bool mCanceled; +}; + +class WorkerJSContextStats final : public JS::RuntimeStats +{ + const nsCString mRtPath; + +public: + explicit WorkerJSContextStats(const nsACString& aRtPath) + : JS::RuntimeStats(JsWorkerMallocSizeOf), mRtPath(aRtPath) + { } + + ~WorkerJSContextStats() + { + for (size_t i = 0; i != zoneStatsVector.length(); i++) { + delete static_cast<xpc::ZoneStatsExtras*>(zoneStatsVector[i].extra); + } + + for (size_t i = 0; i != compartmentStatsVector.length(); i++) { + delete static_cast<xpc::CompartmentStatsExtras*>(compartmentStatsVector[i].extra); + } + } + + const nsCString& Path() const + { + return mRtPath; + } + + virtual void + initExtraZoneStats(JS::Zone* aZone, + JS::ZoneStats* aZoneStats) + override + { + MOZ_ASSERT(!aZoneStats->extra); + + // ReportJSRuntimeExplicitTreeStats expects that + // aZoneStats->extra is a xpc::ZoneStatsExtras pointer. + xpc::ZoneStatsExtras* extras = new xpc::ZoneStatsExtras; + extras->pathPrefix = mRtPath; + extras->pathPrefix += nsPrintfCString("zone(0x%p)/", (void *)aZone); + + MOZ_ASSERT(StartsWithExplicit(extras->pathPrefix)); + + aZoneStats->extra = extras; + } + + virtual void + initExtraCompartmentStats(JSCompartment* aCompartment, + JS::CompartmentStats* aCompartmentStats) + override + { + MOZ_ASSERT(!aCompartmentStats->extra); + + // ReportJSRuntimeExplicitTreeStats expects that + // aCompartmentStats->extra is a xpc::CompartmentStatsExtras pointer. + xpc::CompartmentStatsExtras* extras = new xpc::CompartmentStatsExtras; + + // This is the |jsPathPrefix|. Each worker has exactly two compartments: + // one for atoms, and one for everything else. + extras->jsPathPrefix.Assign(mRtPath); + extras->jsPathPrefix += nsPrintfCString("zone(0x%p)/", + (void *)js::GetCompartmentZone(aCompartment)); + extras->jsPathPrefix += js::IsAtomsCompartment(aCompartment) + ? NS_LITERAL_CSTRING("compartment(web-worker-atoms)/") + : NS_LITERAL_CSTRING("compartment(web-worker)/"); + + // This should never be used when reporting with workers (hence the "?!"). + extras->domPathPrefix.AssignLiteral("explicit/workers/?!/"); + + MOZ_ASSERT(StartsWithExplicit(extras->jsPathPrefix)); + MOZ_ASSERT(StartsWithExplicit(extras->domPathPrefix)); + + extras->location = nullptr; + + aCompartmentStats->extra = extras; + } +}; + +class WorkerPrivate::MemoryReporter final : public nsIMemoryReporter +{ + NS_DECL_THREADSAFE_ISUPPORTS + + friend class WorkerPrivate; + + SharedMutex mMutex; + WorkerPrivate* mWorkerPrivate; + bool mAlreadyMappedToAddon; + +public: + explicit MemoryReporter(WorkerPrivate* aWorkerPrivate) + : mMutex(aWorkerPrivate->mMutex), mWorkerPrivate(aWorkerPrivate), + mAlreadyMappedToAddon(false) + { + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + NS_IMETHOD + CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) override; + +private: + class FinishCollectRunnable; + + class CollectReportsRunnable final : public MainThreadWorkerControlRunnable + { + RefPtr<FinishCollectRunnable> mFinishCollectRunnable; + const bool mAnonymize; + + public: + CollectReportsRunnable( + WorkerPrivate* aWorkerPrivate, + nsIHandleReportCallback* aHandleReport, + nsISupports* aHandlerData, + bool aAnonymize, + const nsACString& aPath); + + private: + bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override; + + ~CollectReportsRunnable() + { + if (NS_IsMainThread()) { + mFinishCollectRunnable->Run(); + return; + } + + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(workerPrivate); + MOZ_ALWAYS_SUCCEEDS( + workerPrivate->DispatchToMainThread(mFinishCollectRunnable.forget())); + } + }; + + class FinishCollectRunnable final : public Runnable + { + nsCOMPtr<nsIHandleReportCallback> mHandleReport; + nsCOMPtr<nsISupports> mHandlerData; + const bool mAnonymize; + bool mSuccess; + + public: + WorkerJSContextStats mCxStats; + + explicit FinishCollectRunnable( + nsIHandleReportCallback* aHandleReport, + nsISupports* aHandlerData, + bool aAnonymize, + const nsACString& aPath); + + NS_IMETHOD Run() override; + + void SetSuccess(bool success) + { + mSuccess = success; + } + + private: + ~FinishCollectRunnable() + { + // mHandleReport and mHandlerData are released on the main thread. + AssertIsOnMainThread(); + } + + FinishCollectRunnable(const FinishCollectRunnable&) = delete; + FinishCollectRunnable& operator=(const FinishCollectRunnable&) = delete; + FinishCollectRunnable& operator=(const FinishCollectRunnable&&) = delete; + }; + + ~MemoryReporter() + { + } + + void + Disable() + { + // Called from WorkerPrivate::DisableMemoryReporter. + mMutex.AssertCurrentThreadOwns(); + + NS_ASSERTION(mWorkerPrivate, "Disabled more than once!"); + mWorkerPrivate = nullptr; + } + + // Only call this from the main thread and under mMutex lock. + void + TryToMapAddon(nsACString &path); +}; + +NS_IMPL_ISUPPORTS(WorkerPrivate::MemoryReporter, nsIMemoryReporter) + +NS_IMETHODIMP +WorkerPrivate::MemoryReporter::CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, + bool aAnonymize) +{ + AssertIsOnMainThread(); + + RefPtr<CollectReportsRunnable> runnable; + + { + MutexAutoLock lock(mMutex); + + if (!mWorkerPrivate) { + // This will effectively report 0 memory. + nsCOMPtr<nsIMemoryReporterManager> manager = + do_GetService("@mozilla.org/memory-reporter-manager;1"); + if (manager) { + manager->EndReport(); + } + return NS_OK; + } + + nsAutoCString path; + path.AppendLiteral("explicit/workers/workers("); + if (aAnonymize && !mWorkerPrivate->Domain().IsEmpty()) { + path.AppendLiteral("<anonymized-domain>)/worker(<anonymized-url>"); + } else { + nsAutoCString escapedDomain(mWorkerPrivate->Domain()); + if (escapedDomain.IsEmpty()) { + escapedDomain += "chrome"; + } else { + escapedDomain.ReplaceChar('/', '\\'); + } + path.Append(escapedDomain); + path.AppendLiteral(")/worker("); + NS_ConvertUTF16toUTF8 escapedURL(mWorkerPrivate->ScriptURL()); + escapedURL.ReplaceChar('/', '\\'); + path.Append(escapedURL); + } + path.AppendPrintf(", 0x%p)/", static_cast<void*>(mWorkerPrivate)); + + TryToMapAddon(path); + + runnable = + new CollectReportsRunnable(mWorkerPrivate, aHandleReport, aData, aAnonymize, path); + } + + if (!runnable->Dispatch()) { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +void +WorkerPrivate::MemoryReporter::TryToMapAddon(nsACString &path) +{ + AssertIsOnMainThread(); + mMutex.AssertCurrentThreadOwns(); + + if (mAlreadyMappedToAddon || !mWorkerPrivate) { + return; + } + + nsCOMPtr<nsIURI> scriptURI; + if (NS_FAILED(NS_NewURI(getter_AddRefs(scriptURI), + mWorkerPrivate->ScriptURL()))) { + return; + } + + mAlreadyMappedToAddon = true; + + if (!XRE_IsParentProcess()) { + // Only try to access the service from the main process. + return; + } + + nsAutoCString addonId; + bool ok; + nsCOMPtr<amIAddonManager> addonManager = + do_GetService("@mozilla.org/addons/integration;1"); + + if (!addonManager || + NS_FAILED(addonManager->MapURIToAddonID(scriptURI, addonId, &ok)) || + !ok) { + return; + } + + static const size_t explicitLength = strlen("explicit/"); + addonId.Insert(NS_LITERAL_CSTRING("add-ons/"), 0); + addonId += "/"; + path.Insert(addonId, explicitLength); +} + +WorkerPrivate::MemoryReporter::CollectReportsRunnable::CollectReportsRunnable( + WorkerPrivate* aWorkerPrivate, + nsIHandleReportCallback* aHandleReport, + nsISupports* aHandlerData, + bool aAnonymize, + const nsACString& aPath) + : MainThreadWorkerControlRunnable(aWorkerPrivate), + mFinishCollectRunnable( + new FinishCollectRunnable(aHandleReport, aHandlerData, aAnonymize, aPath)), + mAnonymize(aAnonymize) +{ } + +bool +WorkerPrivate::MemoryReporter::CollectReportsRunnable::WorkerRun(JSContext* aCx, + WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + + mFinishCollectRunnable->SetSuccess( + aWorkerPrivate->CollectRuntimeStats(&mFinishCollectRunnable->mCxStats, mAnonymize)); + + return true; +} + +WorkerPrivate::MemoryReporter::FinishCollectRunnable::FinishCollectRunnable( + nsIHandleReportCallback* aHandleReport, + nsISupports* aHandlerData, + bool aAnonymize, + const nsACString& aPath) + : mHandleReport(aHandleReport), + mHandlerData(aHandlerData), + mAnonymize(aAnonymize), + mSuccess(false), + mCxStats(aPath) +{ } + +NS_IMETHODIMP +WorkerPrivate::MemoryReporter::FinishCollectRunnable::Run() +{ + AssertIsOnMainThread(); + + nsCOMPtr<nsIMemoryReporterManager> manager = + do_GetService("@mozilla.org/memory-reporter-manager;1"); + + if (!manager) + return NS_OK; + + if (mSuccess) { + xpc::ReportJSRuntimeExplicitTreeStats(mCxStats, mCxStats.Path(), + mHandleReport, mHandlerData, + mAnonymize); + } + + manager->EndReport(); + + return NS_OK; +} + +WorkerPrivate::SyncLoopInfo::SyncLoopInfo(EventTarget* aEventTarget) +: mEventTarget(aEventTarget), mCompleted(false), mResult(false) +#ifdef DEBUG + , mHasRun(false) +#endif +{ +} + +template <class Derived> +nsIDocument* +WorkerPrivateParent<Derived>::GetDocument() const +{ + AssertIsOnMainThread(); + if (mLoadInfo.mWindow) { + return mLoadInfo.mWindow->GetExtantDoc(); + } + // if we don't have a document, we should query the document + // from the parent in case of a nested worker + WorkerPrivate* parent = mParent; + while (parent) { + if (parent->mLoadInfo.mWindow) { + return parent->mLoadInfo.mWindow->GetExtantDoc(); + } + parent = parent->GetParent(); + } + // couldn't query a document, give up and return nullptr + return nullptr; +} + + +// Can't use NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerPrivateParent) because of the +// templates. +template <class Derived> +typename WorkerPrivateParent<Derived>::cycleCollection + WorkerPrivateParent<Derived>::_cycleCollectorGlobal = + WorkerPrivateParent<Derived>::cycleCollection(); + +template <class Derived> +WorkerPrivateParent<Derived>::WorkerPrivateParent( + WorkerPrivate* aParent, + const nsAString& aScriptURL, + bool aIsChromeWorker, + WorkerType aWorkerType, + const nsACString& aWorkerName, + WorkerLoadInfo& aLoadInfo) +: mMutex("WorkerPrivateParent Mutex"), + mCondVar(mMutex, "WorkerPrivateParent CondVar"), + mParent(aParent), mScriptURL(aScriptURL), + mWorkerName(aWorkerName), mLoadingWorkerScript(false), + mBusyCount(0), mParentWindowPausedDepth(0), mParentStatus(Pending), + mParentFrozen(false), mIsChromeWorker(aIsChromeWorker), + mMainThreadObjectsForgotten(false), mIsSecureContext(false), + mWorkerType(aWorkerType), + mCreationTimeStamp(TimeStamp::Now()), + mCreationTimeHighRes((double)PR_Now() / PR_USEC_PER_MSEC) +{ + MOZ_ASSERT_IF(!IsDedicatedWorker(), + !aWorkerName.IsVoid() && NS_IsMainThread()); + MOZ_ASSERT_IF(IsDedicatedWorker(), aWorkerName.IsEmpty()); + + if (aLoadInfo.mWindow) { + AssertIsOnMainThread(); + MOZ_ASSERT(aLoadInfo.mWindow->IsInnerWindow(), + "Should have inner window here!"); + BindToOwner(aLoadInfo.mWindow); + } + + mLoadInfo.StealFrom(aLoadInfo); + + if (aParent) { + aParent->AssertIsOnWorkerThread(); + + // Note that this copies our parent's secure context state into mJSSettings. + aParent->CopyJSSettings(mJSSettings); + + // And manually set our mIsSecureContext, though it's not really relevant to + // dedicated workers... + mIsSecureContext = aParent->IsSecureContext(); + MOZ_ASSERT_IF(mIsChromeWorker, mIsSecureContext); + + MOZ_ASSERT(IsDedicatedWorker()); + mNowBaseTimeStamp = aParent->NowBaseTimeStamp(); + mNowBaseTimeHighRes = aParent->NowBaseTime(); + + if (aParent->mParentFrozen) { + Freeze(nullptr); + } + } + else { + AssertIsOnMainThread(); + + RuntimeService::GetDefaultJSSettings(mJSSettings); + + // Our secure context state depends on the kind of worker we have. + if (UsesSystemPrincipal() || IsServiceWorker()) { + mIsSecureContext = true; + } else if (mLoadInfo.mWindow) { + // Shared and dedicated workers both inherit the loading window's secure + // context state. Shared workers then prevent windows with a different + // secure context state from attaching to them. + mIsSecureContext = mLoadInfo.mWindow->IsSecureContext(); + } else { + MOZ_ASSERT_UNREACHABLE("non-chrome worker that is not a service worker " + "that has no parent and no associated window"); + } + + if (mIsSecureContext) { + mJSSettings.chrome.compartmentOptions + .creationOptions().setSecureContext(true); + mJSSettings.content.compartmentOptions + .creationOptions().setSecureContext(true); + } + + if (IsDedicatedWorker() && mLoadInfo.mWindow && + mLoadInfo.mWindow->GetPerformance()) { + mNowBaseTimeStamp = mLoadInfo.mWindow->GetPerformance()->GetDOMTiming()-> + GetNavigationStartTimeStamp(); + mNowBaseTimeHighRes = + mLoadInfo.mWindow->GetPerformance()->GetDOMTiming()-> + GetNavigationStartHighRes(); + } else { + mNowBaseTimeStamp = CreationTimeStamp(); + mNowBaseTimeHighRes = CreationTime(); + } + + // Our parent can get suspended after it initiates the async creation + // of a new worker thread. In this case suspend the new worker as well. + if (mLoadInfo.mWindow && mLoadInfo.mWindow->IsSuspended()) { + ParentWindowPaused(); + } + + if (mLoadInfo.mWindow && mLoadInfo.mWindow->IsFrozen()) { + Freeze(mLoadInfo.mWindow); + } + } +} + +template <class Derived> +WorkerPrivateParent<Derived>::~WorkerPrivateParent() +{ + DropJSObjects(this); +} + +template <class Derived> +JSObject* +WorkerPrivateParent<Derived>::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + MOZ_ASSERT(!IsSharedWorker(), + "We should never wrap a WorkerPrivate for a SharedWorker"); + + AssertIsOnParentThread(); + + // XXXkhuey this should not need to be rooted, the analysis is dumb. + // See bug 980181. + JS::Rooted<JSObject*> wrapper(aCx, + WorkerBinding::Wrap(aCx, ParentAsWorkerPrivate(), aGivenProto)); + if (wrapper) { + MOZ_ALWAYS_TRUE(TryPreserveWrapper(wrapper)); + } + + return wrapper; +} + +template <class Derived> +nsresult +WorkerPrivateParent<Derived>::DispatchPrivate(already_AddRefed<WorkerRunnable> aRunnable, + nsIEventTarget* aSyncLoopTarget) +{ + // May be called on any thread! + RefPtr<WorkerRunnable> runnable(aRunnable); + + WorkerPrivate* self = ParentAsWorkerPrivate(); + + { + MutexAutoLock lock(mMutex); + + MOZ_ASSERT_IF(aSyncLoopTarget, self->mThread); + + if (!self->mThread) { + if (ParentStatus() == Pending || self->mStatus == Pending) { + mPreStartRunnables.AppendElement(runnable); + return NS_OK; + } + + NS_WARNING("Using a worker event target after the thread has already" + "been released!"); + return NS_ERROR_UNEXPECTED; + } + + if (self->mStatus == Dead || + (!aSyncLoopTarget && ParentStatus() > Running)) { + NS_WARNING("A runnable was posted to a worker that is already shutting " + "down!"); + return NS_ERROR_UNEXPECTED; + } + + nsresult rv; + if (aSyncLoopTarget) { + rv = aSyncLoopTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); + } else { + rv = self->mThread->DispatchAnyThread(WorkerThreadFriendKey(), runnable.forget()); + } + + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + mCondVar.Notify(); + } + + return NS_OK; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::EnableDebugger() +{ + AssertIsOnParentThread(); + + WorkerPrivate* self = ParentAsWorkerPrivate(); + + if (NS_FAILED(RegisterWorkerDebugger(self))) { + NS_WARNING("Failed to register worker debugger!"); + return; + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::DisableDebugger() +{ + AssertIsOnParentThread(); + + WorkerPrivate* self = ParentAsWorkerPrivate(); + + if (NS_FAILED(UnregisterWorkerDebugger(self))) { + NS_WARNING("Failed to unregister worker debugger!"); + } +} + +template <class Derived> +nsresult +WorkerPrivateParent<Derived>::DispatchControlRunnable( + already_AddRefed<WorkerControlRunnable> aWorkerControlRunnable) +{ + // May be called on any thread! + RefPtr<WorkerControlRunnable> runnable(aWorkerControlRunnable); + MOZ_ASSERT(runnable); + + WorkerPrivate* self = ParentAsWorkerPrivate(); + + { + MutexAutoLock lock(mMutex); + + if (self->mStatus == Dead) { + return NS_ERROR_UNEXPECTED; + } + + // Transfer ownership to the control queue. + self->mControlQueue.Push(runnable.forget().take()); + + if (JSContext* cx = self->mJSContext) { + MOZ_ASSERT(self->mThread); + JS_RequestInterruptCallback(cx); + } + + mCondVar.Notify(); + } + + return NS_OK; +} + +template <class Derived> +nsresult +WorkerPrivateParent<Derived>::DispatchDebuggerRunnable( + already_AddRefed<WorkerRunnable> aDebuggerRunnable) +{ + // May be called on any thread! + + RefPtr<WorkerRunnable> runnable(aDebuggerRunnable); + + MOZ_ASSERT(runnable); + + WorkerPrivate* self = ParentAsWorkerPrivate(); + + { + MutexAutoLock lock(mMutex); + + if (self->mStatus == Dead) { + NS_WARNING("A debugger runnable was posted to a worker that is already " + "shutting down!"); + return NS_ERROR_UNEXPECTED; + } + + // Transfer ownership to the debugger queue. + self->mDebuggerQueue.Push(runnable.forget().take()); + + mCondVar.Notify(); + } + + return NS_OK; +} + +template <class Derived> +already_AddRefed<WorkerRunnable> +WorkerPrivateParent<Derived>::MaybeWrapAsWorkerRunnable(already_AddRefed<nsIRunnable> aRunnable) +{ + // May be called on any thread! + + nsCOMPtr<nsIRunnable> runnable(aRunnable); + MOZ_ASSERT(runnable); + + RefPtr<WorkerRunnable> workerRunnable = + WorkerRunnable::FromRunnable(runnable); + if (workerRunnable) { + return workerRunnable.forget(); + } + + nsCOMPtr<nsICancelableRunnable> cancelable = do_QueryInterface(runnable); + if (!cancelable) { + MOZ_CRASH("All runnables destined for a worker thread must be cancelable!"); + } + + workerRunnable = + new ExternalRunnableWrapper(ParentAsWorkerPrivate(), runnable); + return workerRunnable.forget(); +} + +template <class Derived> +already_AddRefed<nsIEventTarget> +WorkerPrivateParent<Derived>::GetEventTarget() +{ + WorkerPrivate* self = ParentAsWorkerPrivate(); + + nsCOMPtr<nsIEventTarget> target; + + { + MutexAutoLock lock(mMutex); + + if (!mEventTarget && + ParentStatus() <= Running && + self->mStatus <= Running) { + mEventTarget = new EventTarget(self); + } + + target = mEventTarget; + } + + NS_WARNING_ASSERTION( + target, + "Requested event target for a worker that is already shutting down!"); + + return target.forget(); +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::Start() +{ + // May be called on any thread! + { + MutexAutoLock lock(mMutex); + + NS_ASSERTION(mParentStatus != Running, "How can this be?!"); + + if (mParentStatus == Pending) { + mParentStatus = Running; + return true; + } + } + + return false; +} + +// aCx is null when called from the finalizer +template <class Derived> +bool +WorkerPrivateParent<Derived>::NotifyPrivate(Status aStatus) +{ + AssertIsOnParentThread(); + + bool pending; + { + MutexAutoLock lock(mMutex); + + if (mParentStatus >= aStatus) { + return true; + } + + pending = mParentStatus == Pending; + mParentStatus = aStatus; + } + + if (IsSharedWorker()) { + RuntimeService* runtime = RuntimeService::GetService(); + MOZ_ASSERT(runtime); + + runtime->ForgetSharedWorker(ParentAsWorkerPrivate()); + } + + if (pending) { + WorkerPrivate* self = ParentAsWorkerPrivate(); + +#ifdef DEBUG + { + // Fake a thread here just so that our assertions don't go off for no + // reason. + nsIThread* currentThread = NS_GetCurrentThread(); + MOZ_ASSERT(currentThread); + + MOZ_ASSERT(!self->mPRThread); + self->mPRThread = PRThreadFromThread(currentThread); + MOZ_ASSERT(self->mPRThread); + } +#endif + + // Worker never got a chance to run, go ahead and delete it. + self->ScheduleDeletion(WorkerPrivate::WorkerNeverRan); + return true; + } + + NS_ASSERTION(aStatus != Terminating || mQueuedRunnables.IsEmpty(), + "Shouldn't have anything queued!"); + + // Anything queued will be discarded. + mQueuedRunnables.Clear(); + + RefPtr<NotifyRunnable> runnable = + new NotifyRunnable(ParentAsWorkerPrivate(), aStatus); + return runnable->Dispatch(); +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::Freeze(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnParentThread(); + + // Shared workers are only frozen if all of their owning documents are + // frozen. It can happen that mSharedWorkers is empty but this thread has + // not been unregistered yet. + if ((IsSharedWorker() || IsServiceWorker()) && !mSharedWorkers.IsEmpty()) { + AssertIsOnMainThread(); + + bool allFrozen = true; + + for (uint32_t i = 0; i < mSharedWorkers.Length(); ++i) { + if (aWindow && mSharedWorkers[i]->GetOwner() == aWindow) { + // Calling Freeze() may change the refcount, ensure that the worker + // outlives this call. + RefPtr<SharedWorker> kungFuDeathGrip = mSharedWorkers[i]; + + kungFuDeathGrip->Freeze(); + } else { + MOZ_ASSERT_IF(mSharedWorkers[i]->GetOwner() && aWindow, + !SameCOMIdentity(mSharedWorkers[i]->GetOwner(), + aWindow)); + if (!mSharedWorkers[i]->IsFrozen()) { + allFrozen = false; + } + } + } + + if (!allFrozen || mParentFrozen) { + return true; + } + } + + mParentFrozen = true; + + { + MutexAutoLock lock(mMutex); + + if (mParentStatus >= Terminating) { + return true; + } + } + + DisableDebugger(); + + RefPtr<FreezeRunnable> runnable = + new FreezeRunnable(ParentAsWorkerPrivate()); + if (!runnable->Dispatch()) { + return false; + } + + return true; +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::Thaw(nsPIDOMWindowInner* aWindow) +{ + AssertIsOnParentThread(); + + MOZ_ASSERT(mParentFrozen); + + // Shared workers are resumed if any of their owning documents are thawed. + // It can happen that mSharedWorkers is empty but this thread has not been + // unregistered yet. + if ((IsSharedWorker() || IsServiceWorker()) && !mSharedWorkers.IsEmpty()) { + AssertIsOnMainThread(); + + bool anyRunning = false; + + for (uint32_t i = 0; i < mSharedWorkers.Length(); ++i) { + if (aWindow && mSharedWorkers[i]->GetOwner() == aWindow) { + // Calling Thaw() may change the refcount, ensure that the worker + // outlives this call. + RefPtr<SharedWorker> kungFuDeathGrip = mSharedWorkers[i]; + + kungFuDeathGrip->Thaw(); + anyRunning = true; + } else { + MOZ_ASSERT_IF(mSharedWorkers[i]->GetOwner() && aWindow, + !SameCOMIdentity(mSharedWorkers[i]->GetOwner(), + aWindow)); + if (!mSharedWorkers[i]->IsFrozen()) { + anyRunning = true; + } + } + } + + if (!anyRunning || !mParentFrozen) { + return true; + } + } + + MOZ_ASSERT(mParentFrozen); + + mParentFrozen = false; + + { + MutexAutoLock lock(mMutex); + + if (mParentStatus >= Terminating) { + return true; + } + } + + EnableDebugger(); + + // Execute queued runnables before waking up the worker, otherwise the worker + // could post new messages before we run those that have been queued. + if (!IsParentWindowPaused() && !mQueuedRunnables.IsEmpty()) { + MOZ_ASSERT(IsDedicatedWorker()); + + nsTArray<nsCOMPtr<nsIRunnable>> runnables; + mQueuedRunnables.SwapElements(runnables); + + for (uint32_t index = 0; index < runnables.Length(); index++) { + runnables[index]->Run(); + } + } + + RefPtr<ThawRunnable> runnable = + new ThawRunnable(ParentAsWorkerPrivate()); + if (!runnable->Dispatch()) { + return false; + } + + return true; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::ParentWindowPaused() +{ + AssertIsOnMainThread(); + MOZ_ASSERT_IF(IsDedicatedWorker(), mParentWindowPausedDepth == 0); + mParentWindowPausedDepth += 1; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::ParentWindowResumed() +{ + AssertIsOnMainThread(); + + MOZ_ASSERT(mParentWindowPausedDepth > 0); + MOZ_ASSERT_IF(IsDedicatedWorker(), mParentWindowPausedDepth == 1); + mParentWindowPausedDepth -= 1; + if (mParentWindowPausedDepth > 0) { + return; + } + + { + MutexAutoLock lock(mMutex); + + if (mParentStatus >= Terminating) { + return; + } + } + + // Execute queued runnables before waking up, otherwise the worker could post + // new messages before we run those that have been queued. + if (!IsFrozen() && !mQueuedRunnables.IsEmpty()) { + MOZ_ASSERT(IsDedicatedWorker()); + + nsTArray<nsCOMPtr<nsIRunnable>> runnables; + mQueuedRunnables.SwapElements(runnables); + + for (uint32_t index = 0; index < runnables.Length(); index++) { + runnables[index]->Run(); + } + } +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::Close() +{ + AssertIsOnParentThread(); + + { + MutexAutoLock lock(mMutex); + + if (mParentStatus < Closing) { + mParentStatus = Closing; + } + } + + return true; +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::ModifyBusyCount(bool aIncrease) +{ + AssertIsOnParentThread(); + + NS_ASSERTION(aIncrease || mBusyCount, "Mismatched busy count mods!"); + + if (aIncrease) { + mBusyCount++; + return true; + } + + if (--mBusyCount == 0) { + + bool shouldCancel; + { + MutexAutoLock lock(mMutex); + shouldCancel = mParentStatus == Terminating; + } + + if (shouldCancel && !Cancel()) { + return false; + } + } + + return true; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::ForgetOverridenLoadGroup( + nsCOMPtr<nsILoadGroup>& aLoadGroupOut) +{ + AssertIsOnParentThread(); + + // If we're not overriden, then do nothing here. Let the load group get + // handled in ForgetMainThreadObjects(). + if (!mLoadInfo.mInterfaceRequestor) { + return; + } + + mLoadInfo.mLoadGroup.swap(aLoadGroupOut); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::ForgetMainThreadObjects( + nsTArray<nsCOMPtr<nsISupports> >& aDoomed) +{ + AssertIsOnParentThread(); + MOZ_ASSERT(!mMainThreadObjectsForgotten); + + static const uint32_t kDoomedCount = 10; + + aDoomed.SetCapacity(kDoomedCount); + + SwapToISupportsArray(mLoadInfo.mWindow, aDoomed); + SwapToISupportsArray(mLoadInfo.mScriptContext, aDoomed); + SwapToISupportsArray(mLoadInfo.mBaseURI, aDoomed); + SwapToISupportsArray(mLoadInfo.mResolvedScriptURI, aDoomed); + SwapToISupportsArray(mLoadInfo.mPrincipal, aDoomed); + SwapToISupportsArray(mLoadInfo.mChannel, aDoomed); + SwapToISupportsArray(mLoadInfo.mCSP, aDoomed); + SwapToISupportsArray(mLoadInfo.mLoadGroup, aDoomed); + SwapToISupportsArray(mLoadInfo.mLoadFailedAsyncRunnable, aDoomed); + SwapToISupportsArray(mLoadInfo.mInterfaceRequestor, aDoomed); + // Before adding anything here update kDoomedCount above! + + MOZ_ASSERT(aDoomed.Length() == kDoomedCount); + + mMainThreadObjectsForgotten = true; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::PostMessageInternal( + JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo, + PromiseNativeHandler* aHandler, + ErrorResult& aRv) +{ + AssertIsOnParentThread(); + + { + MutexAutoLock lock(mMutex); + if (mParentStatus > Running) { + return; + } + } + + JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue()); + if (aTransferable.WasPassed()) { + const Sequence<JS::Value>& realTransferable = aTransferable.Value(); + + // The input sequence only comes from the generated bindings code, which + // ensures it is rooted. + JS::HandleValueArray elements = + JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(), + realTransferable.Elements()); + + JSObject* array = + JS_NewArrayObject(aCx, elements); + if (!array) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + transferable.setObject(*array); + } + + RefPtr<MessageEventRunnable> runnable = + new MessageEventRunnable(ParentAsWorkerPrivate(), + WorkerRunnable::WorkerThreadModifyBusyCount); + + UniquePtr<AbstractTimelineMarker> start; + UniquePtr<AbstractTimelineMarker> end; + RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get(); + bool isTimelineRecording = timelines && !timelines->IsEmpty(); + + if (isTimelineRecording) { + start = MakeUnique<WorkerTimelineMarker>(NS_IsMainThread() + ? ProfileTimelineWorkerOperationType::SerializeDataOnMainThread + : ProfileTimelineWorkerOperationType::SerializeDataOffMainThread, + MarkerTracingType::START); + } + + runnable->Write(aCx, aMessage, transferable, JS::CloneDataPolicy(), aRv); + + if (isTimelineRecording) { + end = MakeUnique<WorkerTimelineMarker>(NS_IsMainThread() + ? ProfileTimelineWorkerOperationType::SerializeDataOnMainThread + : ProfileTimelineWorkerOperationType::SerializeDataOffMainThread, + MarkerTracingType::END); + timelines->AddMarkerForAllObservedDocShells(start); + timelines->AddMarkerForAllObservedDocShells(end); + } + + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + runnable->SetServiceWorkerData(Move(aClientInfo), aHandler); + + if (!runnable->Dispatch()) { + aRv.Throw(NS_ERROR_FAILURE); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::PostMessage( + JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + PostMessageInternal(aCx, aMessage, aTransferable, nullptr, nullptr, aRv); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::PostMessageToServiceWorker( + JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo, + PromiseNativeHandler* aHandler, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + PostMessageInternal(aCx, aMessage, aTransferable, Move(aClientInfo), + aHandler, aRv); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdateContextOptions( + const JS::ContextOptions& aContextOptions) +{ + AssertIsOnParentThread(); + + { + MutexAutoLock lock(mMutex); + mJSSettings.contextOptions = aContextOptions; + } + + RefPtr<UpdateContextOptionsRunnable> runnable = + new UpdateContextOptionsRunnable(ParentAsWorkerPrivate(), aContextOptions); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to update worker context options!"); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdatePreference(WorkerPreference aPref, bool aValue) +{ + AssertIsOnParentThread(); + MOZ_ASSERT(aPref >= 0 && aPref < WORKERPREF_COUNT); + + RefPtr<UpdatePreferenceRunnable> runnable = + new UpdatePreferenceRunnable(ParentAsWorkerPrivate(), aPref, aValue); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to update worker preferences!"); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdateLanguages(const nsTArray<nsString>& aLanguages) +{ + AssertIsOnParentThread(); + + RefPtr<UpdateLanguagesRunnable> runnable = + new UpdateLanguagesRunnable(ParentAsWorkerPrivate(), aLanguages); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to update worker languages!"); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdateJSWorkerMemoryParameter(JSGCParamKey aKey, + uint32_t aValue) +{ + AssertIsOnParentThread(); + + bool found = false; + + { + MutexAutoLock lock(mMutex); + found = mJSSettings.ApplyGCSetting(aKey, aValue); + } + + if (found) { + RefPtr<UpdateJSWorkerMemoryParameterRunnable> runnable = + new UpdateJSWorkerMemoryParameterRunnable(ParentAsWorkerPrivate(), aKey, + aValue); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to update memory parameter!"); + } + } +} + +#ifdef JS_GC_ZEAL +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdateGCZeal(uint8_t aGCZeal, uint32_t aFrequency) +{ + AssertIsOnParentThread(); + + { + MutexAutoLock lock(mMutex); + mJSSettings.gcZeal = aGCZeal; + mJSSettings.gcZealFrequency = aFrequency; + } + + RefPtr<UpdateGCZealRunnable> runnable = + new UpdateGCZealRunnable(ParentAsWorkerPrivate(), aGCZeal, aFrequency); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to update worker gczeal!"); + } +} +#endif + +template <class Derived> +void +WorkerPrivateParent<Derived>::GarbageCollect(bool aShrinking) +{ + AssertIsOnParentThread(); + + RefPtr<GarbageCollectRunnable> runnable = + new GarbageCollectRunnable(ParentAsWorkerPrivate(), aShrinking, + /* collectChildren = */ true); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to GC worker!"); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::CycleCollect(bool aDummy) +{ + AssertIsOnParentThread(); + + RefPtr<CycleCollectRunnable> runnable = + new CycleCollectRunnable(ParentAsWorkerPrivate(), + /* collectChildren = */ true); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to CC worker!"); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::OfflineStatusChangeEvent(bool aIsOffline) +{ + AssertIsOnParentThread(); + + RefPtr<OfflineStatusChangeRunnable> runnable = + new OfflineStatusChangeRunnable(ParentAsWorkerPrivate(), aIsOffline); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to dispatch offline status change event!"); + } +} + +void +WorkerPrivate::OfflineStatusChangeEventInternal(bool aIsOffline) +{ + AssertIsOnWorkerThread(); + + // The worker is already in this state. No need to dispatch an event. + if (mOnLine == !aIsOffline) { + return; + } + + for (uint32_t index = 0; index < mChildWorkers.Length(); ++index) { + mChildWorkers[index]->OfflineStatusChangeEvent(aIsOffline); + } + + mOnLine = !aIsOffline; + WorkerGlobalScope* globalScope = GlobalScope(); + RefPtr<WorkerNavigator> nav = globalScope->GetExistingNavigator(); + if (nav) { + nav->SetOnLine(mOnLine); + } + + nsString eventType; + if (aIsOffline) { + eventType.AssignLiteral("offline"); + } else { + eventType.AssignLiteral("online"); + } + + RefPtr<Event> event = NS_NewDOMEvent(globalScope, nullptr, nullptr); + + event->InitEvent(eventType, false, false); + event->SetTrusted(true); + + globalScope->DispatchDOMEvent(nullptr, event, nullptr, nullptr); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::MemoryPressure(bool aDummy) +{ + AssertIsOnParentThread(); + + RefPtr<MemoryPressureRunnable> runnable = + new MemoryPressureRunnable(ParentAsWorkerPrivate()); + Unused << NS_WARN_IF(!runnable->Dispatch()); +} + +template <class Derived> +bool +WorkerPrivateParent<Derived>::RegisterSharedWorker(SharedWorker* aSharedWorker, + MessagePort* aPort) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aSharedWorker); + MOZ_ASSERT(IsSharedWorker()); + MOZ_ASSERT(!mSharedWorkers.Contains(aSharedWorker)); + + if (IsSharedWorker()) { + RefPtr<MessagePortRunnable> runnable = + new MessagePortRunnable(ParentAsWorkerPrivate(), aPort); + if (!runnable->Dispatch()) { + return false; + } + } + + mSharedWorkers.AppendElement(aSharedWorker); + + // If there were other SharedWorker objects attached to this worker then they + // may all have been frozen and this worker would need to be thawed. + if (mSharedWorkers.Length() > 1 && IsFrozen() && !Thaw(nullptr)) { + return false; + } + + return true; +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::BroadcastErrorToSharedWorkers( + JSContext* aCx, + const nsAString& aMessage, + const nsAString& aFilename, + const nsAString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags) +{ + AssertIsOnMainThread(); + + if (JSREPORT_IS_WARNING(aFlags)) { + // Don't fire any events anywhere. Just log to console. + // XXXbz should we log to all the consoles of all the relevant windows? + LogErrorToConsole(aMessage, aFilename, aLine, aLineNumber, aColumnNumber, + aFlags, 0); + return; + } + + AutoTArray<RefPtr<SharedWorker>, 10> sharedWorkers; + GetAllSharedWorkers(sharedWorkers); + + if (sharedWorkers.IsEmpty()) { + return; + } + + AutoTArray<WindowAction, 10> windowActions; + nsresult rv; + + // First fire the error event at all SharedWorker objects. This may include + // multiple objects in a single window as well as objects in different + // windows. + for (size_t index = 0; index < sharedWorkers.Length(); index++) { + RefPtr<SharedWorker>& sharedWorker = sharedWorkers[index]; + + // May be null. + nsPIDOMWindowInner* window = sharedWorker->GetOwner(); + + RootedDictionary<ErrorEventInit> errorInit(aCx); + errorInit.mBubbles = false; + errorInit.mCancelable = true; + errorInit.mMessage = aMessage; + errorInit.mFilename = aFilename; + errorInit.mLineno = aLineNumber; + errorInit.mColno = aColumnNumber; + + RefPtr<ErrorEvent> errorEvent = + ErrorEvent::Constructor(sharedWorker, NS_LITERAL_STRING("error"), + errorInit); + if (!errorEvent) { + ThrowAndReport(window, NS_ERROR_UNEXPECTED); + continue; + } + + errorEvent->SetTrusted(true); + + bool defaultActionEnabled; + nsresult rv = sharedWorker->DispatchEvent(errorEvent, &defaultActionEnabled); + if (NS_FAILED(rv)) { + ThrowAndReport(window, rv); + continue; + } + + if (defaultActionEnabled) { + // Add the owning window to our list so that we will fire an error event + // at it later. + if (!windowActions.Contains(window)) { + windowActions.AppendElement(WindowAction(window)); + } + } else { + size_t actionsIndex = windowActions.LastIndexOf(WindowAction(window)); + if (actionsIndex != windowActions.NoIndex) { + // Any listener that calls preventDefault() will prevent the window from + // receiving the error event. + windowActions[actionsIndex].mDefaultAction = false; + } + } + } + + // If there are no windows to consider further then we're done. + if (windowActions.IsEmpty()) { + return; + } + + bool shouldLogErrorToConsole = true; + + // Now fire error events at all the windows remaining. + for (uint32_t index = 0; index < windowActions.Length(); index++) { + WindowAction& windowAction = windowActions[index]; + + // If there is no window or the script already called preventDefault then + // skip this window. + if (!windowAction.mWindow || !windowAction.mDefaultAction) { + continue; + } + + nsCOMPtr<nsIScriptGlobalObject> sgo = + do_QueryInterface(windowAction.mWindow); + MOZ_ASSERT(sgo); + + MOZ_ASSERT(NS_IsMainThread()); + RootedDictionary<ErrorEventInit> init(aCx); + init.mLineno = aLineNumber; + init.mFilename = aFilename; + init.mMessage = aMessage; + init.mCancelable = true; + init.mBubbles = true; + + nsEventStatus status = nsEventStatus_eIgnore; + rv = sgo->HandleScriptError(init, &status); + if (NS_FAILED(rv)) { + ThrowAndReport(windowAction.mWindow, rv); + continue; + } + + if (status == nsEventStatus_eConsumeNoDefault) { + shouldLogErrorToConsole = false; + } + } + + // Finally log a warning in the console if no window tried to prevent it. + if (shouldLogErrorToConsole) { + LogErrorToConsole(aMessage, aFilename, aLine, aLineNumber, aColumnNumber, + aFlags, 0); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::GetAllSharedWorkers( + nsTArray<RefPtr<SharedWorker>>& aSharedWorkers) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(IsSharedWorker() || IsServiceWorker()); + + if (!aSharedWorkers.IsEmpty()) { + aSharedWorkers.Clear(); + } + + for (uint32_t i = 0; i < mSharedWorkers.Length(); ++i) { + aSharedWorkers.AppendElement(mSharedWorkers[i]); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::CloseSharedWorkersForWindow( + nsPIDOMWindowInner* aWindow) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(IsSharedWorker() || IsServiceWorker()); + MOZ_ASSERT(aWindow); + + bool someRemoved = false; + + for (uint32_t i = 0; i < mSharedWorkers.Length();) { + if (mSharedWorkers[i]->GetOwner() == aWindow) { + mSharedWorkers[i]->Close(); + mSharedWorkers.RemoveElementAt(i); + someRemoved = true; + } else { + MOZ_ASSERT(!SameCOMIdentity(mSharedWorkers[i]->GetOwner(), + aWindow)); + ++i; + } + } + + if (!someRemoved) { + return; + } + + // If there are still SharedWorker objects attached to this worker then they + // may all be frozen and this worker would need to be frozen. Otherwise, + // if that was the last SharedWorker then it's time to cancel this worker. + + if (!mSharedWorkers.IsEmpty()) { + Freeze(nullptr); + } else { + Cancel(); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::CloseAllSharedWorkers() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(IsSharedWorker() || IsServiceWorker()); + + for (uint32_t i = 0; i < mSharedWorkers.Length(); ++i) { + mSharedWorkers[i]->Close(); + } + + mSharedWorkers.Clear(); + + Cancel(); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::WorkerScriptLoaded() +{ + AssertIsOnMainThread(); + + if (IsSharedWorker() || IsServiceWorker()) { + // No longer need to hold references to the window or document we came from. + mLoadInfo.mWindow = nullptr; + mLoadInfo.mScriptContext = nullptr; + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::SetBaseURI(nsIURI* aBaseURI) +{ + AssertIsOnMainThread(); + + if (!mLoadInfo.mBaseURI) { + NS_ASSERTION(GetParent(), "Shouldn't happen without a parent!"); + mLoadInfo.mResolvedScriptURI = aBaseURI; + } + + mLoadInfo.mBaseURI = aBaseURI; + + if (NS_FAILED(aBaseURI->GetSpec(mLocationInfo.mHref))) { + mLocationInfo.mHref.Truncate(); + } + + mLocationInfo.mHostname.Truncate(); + nsContentUtils::GetHostOrIPv6WithBrackets(aBaseURI, mLocationInfo.mHostname); + + nsCOMPtr<nsIURL> url(do_QueryInterface(aBaseURI)); + if (!url || NS_FAILED(url->GetFilePath(mLocationInfo.mPathname))) { + mLocationInfo.mPathname.Truncate(); + } + + nsCString temp; + + if (url && NS_SUCCEEDED(url->GetQuery(temp)) && !temp.IsEmpty()) { + mLocationInfo.mSearch.Assign('?'); + mLocationInfo.mSearch.Append(temp); + } + + if (NS_SUCCEEDED(aBaseURI->GetRef(temp)) && !temp.IsEmpty()) { + nsCOMPtr<nsITextToSubURI> converter = + do_GetService(NS_ITEXTTOSUBURI_CONTRACTID); + if (converter && nsContentUtils::GettersDecodeURLHash()) { + nsCString charset; + nsAutoString unicodeRef; + if (NS_SUCCEEDED(aBaseURI->GetOriginCharset(charset)) && + NS_SUCCEEDED(converter->UnEscapeURIForUI(charset, temp, + unicodeRef))) { + mLocationInfo.mHash.Assign('#'); + mLocationInfo.mHash.Append(NS_ConvertUTF16toUTF8(unicodeRef)); + } + } + + if (mLocationInfo.mHash.IsEmpty()) { + mLocationInfo.mHash.Assign('#'); + mLocationInfo.mHash.Append(temp); + } + } + + if (NS_SUCCEEDED(aBaseURI->GetScheme(mLocationInfo.mProtocol))) { + mLocationInfo.mProtocol.Append(':'); + } + else { + mLocationInfo.mProtocol.Truncate(); + } + + int32_t port; + if (NS_SUCCEEDED(aBaseURI->GetPort(&port)) && port != -1) { + mLocationInfo.mPort.AppendInt(port); + + nsAutoCString host(mLocationInfo.mHostname); + host.Append(':'); + host.Append(mLocationInfo.mPort); + + mLocationInfo.mHost.Assign(host); + } + else { + mLocationInfo.mHost.Assign(mLocationInfo.mHostname); + } + + nsContentUtils::GetUTFOrigin(aBaseURI, mLocationInfo.mOrigin); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::SetPrincipal(nsIPrincipal* aPrincipal, + nsILoadGroup* aLoadGroup) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(aLoadGroup, aPrincipal)); + MOZ_ASSERT(!mLoadInfo.mPrincipalInfo); + + mLoadInfo.mPrincipal = aPrincipal; + mLoadInfo.mPrincipalIsSystem = nsContentUtils::IsSystemPrincipal(aPrincipal); + + aPrincipal->GetCsp(getter_AddRefs(mLoadInfo.mCSP)); + + if (mLoadInfo.mCSP) { + mLoadInfo.mCSP->GetAllowsEval(&mLoadInfo.mReportCSPViolations, + &mLoadInfo.mEvalAllowed); + // Set ReferrerPolicy + bool hasReferrerPolicy = false; + uint32_t rp = mozilla::net::RP_Default; + + nsresult rv = mLoadInfo.mCSP->GetReferrerPolicy(&rp, &hasReferrerPolicy); + NS_ENSURE_SUCCESS_VOID(rv); + + if (hasReferrerPolicy) { + mLoadInfo.mReferrerPolicy = static_cast<net::ReferrerPolicy>(rp); + } + } else { + mLoadInfo.mEvalAllowed = true; + mLoadInfo.mReportCSPViolations = false; + } + + mLoadInfo.mLoadGroup = aLoadGroup; + + mLoadInfo.mPrincipalInfo = new PrincipalInfo(); + mLoadInfo.mOriginAttributes = nsContentUtils::GetOriginAttributes(aLoadGroup); + + MOZ_ALWAYS_SUCCEEDS( + PrincipalToPrincipalInfo(aPrincipal, mLoadInfo.mPrincipalInfo)); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::UpdateOverridenLoadGroup(nsILoadGroup* aBaseLoadGroup) +{ + AssertIsOnMainThread(); + + // The load group should have been overriden at init time. + mLoadInfo.mInterfaceRequestor->MaybeAddTabChild(aBaseLoadGroup); +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::FlushReportsToSharedWorkers( + nsIConsoleReportCollector* aReporter) +{ + AssertIsOnMainThread(); + + AutoTArray<RefPtr<SharedWorker>, 10> sharedWorkers; + AutoTArray<WindowAction, 10> windowActions; + GetAllSharedWorkers(sharedWorkers); + + // First find out all the shared workers' window. + for (size_t index = 0; index < sharedWorkers.Length(); index++) { + RefPtr<SharedWorker>& sharedWorker = sharedWorkers[index]; + + // May be null. + nsPIDOMWindowInner* window = sharedWorker->GetOwner(); + + // Add the owning window to our list so that we will flush the reports later. + if (window && !windowActions.Contains(window)) { + windowActions.AppendElement(WindowAction(window)); + } + } + + bool reportErrorToBrowserConsole = true; + + // Flush the reports. + for (uint32_t index = 0; index < windowActions.Length(); index++) { + WindowAction& windowAction = windowActions[index]; + + aReporter->FlushConsoleReports(windowAction.mWindow->GetExtantDoc(), + nsIConsoleReportCollector::ReportAction::Save); + reportErrorToBrowserConsole = false; + } + + // Finally report to broswer console if there is no any window or shared + // worker. + if (reportErrorToBrowserConsole) { + aReporter->FlushConsoleReports((nsIDocument*)nullptr); + return; + } + + aReporter->ClearConsoleReports(); +} + +template <class Derived> +NS_IMPL_ADDREF_INHERITED(WorkerPrivateParent<Derived>, DOMEventTargetHelper) + +template <class Derived> +NS_IMPL_RELEASE_INHERITED(WorkerPrivateParent<Derived>, DOMEventTargetHelper) + +template <class Derived> +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(WorkerPrivateParent<Derived>) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +template <class Derived> +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerPrivateParent<Derived>, + DOMEventTargetHelper) + tmp->AssertIsOnParentThread(); + + // The WorkerPrivate::mSelfRef has a reference to itself, which is really + // held by the worker thread. We traverse this reference if and only if our + // busy count is zero and we have not released the main thread reference. + // We do not unlink it. This allows the CC to break cycles involving the + // WorkerPrivate and begin shutting it down (which does happen in unlink) but + // ensures that the WorkerPrivate won't be deleted before we're done shutting + // down the thread. + + if (!tmp->mBusyCount && !tmp->mMainThreadObjectsForgotten) { + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelfRef) + } + + // The various strong references in LoadInfo are managed manually and cannot + // be cycle collected. +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +template <class Derived> +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerPrivateParent<Derived>, + DOMEventTargetHelper) + tmp->Terminate(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +template <class Derived> +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerPrivateParent<Derived>, + DOMEventTargetHelper) + tmp->AssertIsOnParentThread(); +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +#ifdef DEBUG + +template <class Derived> +void +WorkerPrivateParent<Derived>::AssertIsOnParentThread() const +{ + if (GetParent()) { + GetParent()->AssertIsOnWorkerThread(); + } + else { + AssertIsOnMainThread(); + } +} + +template <class Derived> +void +WorkerPrivateParent<Derived>::AssertInnerWindowIsCorrect() const +{ + AssertIsOnParentThread(); + + // Only care about top level workers from windows. + if (mParent || !mLoadInfo.mWindow) { + return; + } + + AssertIsOnMainThread(); + + nsPIDOMWindowOuter* outer = mLoadInfo.mWindow->GetOuterWindow(); + NS_ASSERTION(outer && outer->GetCurrentInnerWindow() == mLoadInfo.mWindow, + "Inner window no longer correct!"); +} + +#endif + +class PostDebuggerMessageRunnable final : public Runnable +{ + WorkerDebugger *mDebugger; + nsString mMessage; + +public: + PostDebuggerMessageRunnable(WorkerDebugger* aDebugger, + const nsAString& aMessage) + : mDebugger(aDebugger), + mMessage(aMessage) + { + } + +private: + ~PostDebuggerMessageRunnable() + { } + + NS_IMETHOD + Run() override + { + mDebugger->PostMessageToDebuggerOnMainThread(mMessage); + + return NS_OK; + } +}; + +class ReportDebuggerErrorRunnable final : public Runnable +{ + WorkerDebugger *mDebugger; + nsString mFilename; + uint32_t mLineno; + nsString mMessage; + +public: + ReportDebuggerErrorRunnable(WorkerDebugger* aDebugger, + const nsAString& aFilename, uint32_t aLineno, + const nsAString& aMessage) + : mDebugger(aDebugger), + mFilename(aFilename), + mLineno(aLineno), + mMessage(aMessage) + { + } + +private: + ~ReportDebuggerErrorRunnable() + { } + + NS_IMETHOD + Run() override + { + mDebugger->ReportErrorToDebuggerOnMainThread(mFilename, mLineno, mMessage); + + return NS_OK; + } +}; + +WorkerDebugger::WorkerDebugger(WorkerPrivate* aWorkerPrivate) +: mWorkerPrivate(aWorkerPrivate), + mIsInitialized(false) +{ + AssertIsOnMainThread(); +} + +WorkerDebugger::~WorkerDebugger() +{ + MOZ_ASSERT(!mWorkerPrivate); + + if (!NS_IsMainThread()) { + for (size_t index = 0; index < mListeners.Length(); ++index) { + NS_ReleaseOnMainThread(mListeners[index].forget()); + } + } +} + +NS_IMPL_ISUPPORTS(WorkerDebugger, nsIWorkerDebugger) + +NS_IMETHODIMP +WorkerDebugger::GetIsClosed(bool* aResult) +{ + AssertIsOnMainThread(); + + *aResult = !mWorkerPrivate; + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetIsChrome(bool* aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + *aResult = mWorkerPrivate->IsChromeWorker(); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetIsInitialized(bool* aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + *aResult = mIsInitialized; + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetParent(nsIWorkerDebugger** aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + WorkerPrivate* parent = mWorkerPrivate->GetParent(); + if (!parent) { + *aResult = nullptr; + return NS_OK; + } + + MOZ_ASSERT(mWorkerPrivate->IsDedicatedWorker()); + + nsCOMPtr<nsIWorkerDebugger> debugger = parent->Debugger(); + debugger.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetType(uint32_t* aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + *aResult = mWorkerPrivate->Type(); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetUrl(nsAString& aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + aResult = mWorkerPrivate->ScriptURL(); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetWindow(mozIDOMWindow** aResult) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + if (mWorkerPrivate->GetParent() || !mWorkerPrivate->IsDedicatedWorker()) { + *aResult = nullptr; + return NS_OK; + } + + nsCOMPtr<nsPIDOMWindowInner> window = mWorkerPrivate->GetWindow(); + window.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetPrincipal(nsIPrincipal** aResult) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aResult); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + nsCOMPtr<nsIPrincipal> prin = mWorkerPrivate->GetPrincipal(); + prin.forget(aResult); + + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::GetServiceWorkerID(uint32_t* aResult) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aResult); + + if (!mWorkerPrivate || !mWorkerPrivate->IsServiceWorker()) { + return NS_ERROR_UNEXPECTED; + } + + *aResult = mWorkerPrivate->ServiceWorkerID(); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::Initialize(const nsAString& aURL) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate) { + return NS_ERROR_UNEXPECTED; + } + + if (!mIsInitialized) { + RefPtr<CompileDebuggerScriptRunnable> runnable = + new CompileDebuggerScriptRunnable(mWorkerPrivate, aURL); + if (!runnable->Dispatch()) { + return NS_ERROR_FAILURE; + } + + mIsInitialized = true; + } + + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::PostMessageMoz(const nsAString& aMessage) +{ + AssertIsOnMainThread(); + + if (!mWorkerPrivate || !mIsInitialized) { + return NS_ERROR_UNEXPECTED; + } + + RefPtr<DebuggerMessageEventRunnable> runnable = + new DebuggerMessageEventRunnable(mWorkerPrivate, aMessage); + if (!runnable->Dispatch()) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::AddListener(nsIWorkerDebuggerListener* aListener) +{ + AssertIsOnMainThread(); + + if (mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.AppendElement(aListener); + return NS_OK; +} + +NS_IMETHODIMP +WorkerDebugger::RemoveListener(nsIWorkerDebuggerListener* aListener) +{ + AssertIsOnMainThread(); + + if (!mListeners.Contains(aListener)) { + return NS_ERROR_INVALID_ARG; + } + + mListeners.RemoveElement(aListener); + return NS_OK; +} + +void +WorkerDebugger::Close() +{ + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate = nullptr; + + nsTArray<nsCOMPtr<nsIWorkerDebuggerListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnClose(); + } +} + +void +WorkerDebugger::PostMessageToDebugger(const nsAString& aMessage) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<PostDebuggerMessageRunnable> runnable = + new PostDebuggerMessageRunnable(this, aMessage); + if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable.forget()))) { + NS_WARNING("Failed to post message to debugger on main thread!"); + } +} + +void +WorkerDebugger::PostMessageToDebuggerOnMainThread(const nsAString& aMessage) +{ + AssertIsOnMainThread(); + + nsTArray<nsCOMPtr<nsIWorkerDebuggerListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnMessage(aMessage); + } +} + +void +WorkerDebugger::ReportErrorToDebugger(const nsAString& aFilename, + uint32_t aLineno, + const nsAString& aMessage) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<ReportDebuggerErrorRunnable> runnable = + new ReportDebuggerErrorRunnable(this, aFilename, aLineno, aMessage); + if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable.forget()))) { + NS_WARNING("Failed to report error to debugger on main thread!"); + } +} + +void +WorkerDebugger::ReportErrorToDebuggerOnMainThread(const nsAString& aFilename, + uint32_t aLineno, + const nsAString& aMessage) +{ + AssertIsOnMainThread(); + + nsTArray<nsCOMPtr<nsIWorkerDebuggerListener>> listeners(mListeners); + for (size_t index = 0; index < listeners.Length(); ++index) { + listeners[index]->OnError(aFilename, aLineno, aMessage); + } + + LogErrorToConsole(aMessage, aFilename, nsString(), aLineno, 0, 0, 0); +} + +WorkerPrivate::WorkerPrivate(WorkerPrivate* aParent, + const nsAString& aScriptURL, + bool aIsChromeWorker, WorkerType aWorkerType, + const nsACString& aWorkerName, + WorkerLoadInfo& aLoadInfo) + : WorkerPrivateParent<WorkerPrivate>(aParent, aScriptURL, + aIsChromeWorker, aWorkerType, + aWorkerName, aLoadInfo) + , mDebuggerRegistered(false) + , mDebugger(nullptr) + , mJSContext(nullptr) + , mPRThread(nullptr) + , mDebuggerEventLoopLevel(0) + , mMainThreadEventTarget(do_GetMainThread()) + , mErrorHandlerRecursionCount(0) + , mNextTimeoutId(1) + , mStatus(Pending) + , mFrozen(false) + , mTimerRunning(false) + , mRunningExpiredTimeouts(false) + , mPendingEventQueueClearing(false) + , mCancelAllPendingRunnables(false) + , mPeriodicGCTimerRunning(false) + , mIdleGCTimerRunning(false) + , mWorkerScriptExecutedSuccessfully(false) + , mOnLine(false) +{ + MOZ_ASSERT_IF(!IsDedicatedWorker(), !aWorkerName.IsVoid()); + MOZ_ASSERT_IF(IsDedicatedWorker(), aWorkerName.IsEmpty()); + + if (aParent) { + aParent->AssertIsOnWorkerThread(); + aParent->GetAllPreferences(mPreferences); + mOnLine = aParent->OnLine(); + } + else { + AssertIsOnMainThread(); + RuntimeService::GetDefaultPreferences(mPreferences); + mOnLine = !NS_IsOffline(); + } + + nsCOMPtr<nsIEventTarget> target; + + // A child worker just inherits the parent workers ThrottledEventQueue + // and main thread target for now. This is mainly due to the restriction + // that ThrottledEventQueue can only be created on the main thread at the + // moment. + if (aParent) { + mMainThreadThrottledEventQueue = aParent->mMainThreadThrottledEventQueue; + mMainThreadEventTarget = aParent->mMainThreadEventTarget; + return; + } + + MOZ_ASSERT(NS_IsMainThread()); + target = GetWindow() ? GetWindow()->GetThrottledEventQueue() : nullptr; + + if (!target) { + nsCOMPtr<nsIThread> mainThread; + NS_GetMainThread(getter_AddRefs(mainThread)); + MOZ_DIAGNOSTIC_ASSERT(mainThread); + target = mainThread; + } + + // Throttle events to the main thread using a ThrottledEventQueue specific to + // this worker thread. This may return nullptr during shutdown. + mMainThreadThrottledEventQueue = ThrottledEventQueue::Create(target); + + // If we were able to creat the throttled event queue, then use it for + // dispatching our main thread runnables. Otherwise use our underlying + // base target. + if (mMainThreadThrottledEventQueue) { + mMainThreadEventTarget = mMainThreadThrottledEventQueue; + } else { + mMainThreadEventTarget = target.forget(); + } +} + +WorkerPrivate::~WorkerPrivate() +{ +} + +// static +already_AddRefed<WorkerPrivate> +WorkerPrivate::Constructor(const GlobalObject& aGlobal, + const nsAString& aScriptURL, + ErrorResult& aRv) +{ + return WorkerPrivate::Constructor(aGlobal, aScriptURL, false, + WorkerTypeDedicated, EmptyCString(), + nullptr, aRv); +} + +// static +bool +WorkerPrivate::WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */) +{ + // If we're already on a worker workers are clearly enabled. + if (!NS_IsMainThread()) { + return true; + } + + // If our caller is chrome, workers are always available. + if (nsContentUtils::IsCallerChrome()) { + return true; + } + + // Else check the pref. + return Preferences::GetBool(PREF_WORKERS_ENABLED); +} + +// static +already_AddRefed<ChromeWorkerPrivate> +ChromeWorkerPrivate::Constructor(const GlobalObject& aGlobal, + const nsAString& aScriptURL, + ErrorResult& aRv) +{ + return WorkerPrivate::Constructor(aGlobal, aScriptURL, true, + WorkerTypeDedicated, EmptyCString(), + nullptr, aRv) + .downcast<ChromeWorkerPrivate>(); +} + +// static +bool +ChromeWorkerPrivate::WorkerAvailable(JSContext* aCx, JSObject* /* unused */) +{ + // Chrome is always allowed to use workers, and content is never + // allowed to use ChromeWorker, so all we have to check is the + // caller. However, chrome workers apparently might not have a + // system principal, so we have to check for them manually. + if (NS_IsMainThread()) { + return nsContentUtils::IsCallerChrome(); + } + + return GetWorkerPrivateFromContext(aCx)->IsChromeWorker(); +} + +// static +already_AddRefed<WorkerPrivate> +WorkerPrivate::Constructor(const GlobalObject& aGlobal, + const nsAString& aScriptURL, + bool aIsChromeWorker, WorkerType aWorkerType, + const nsACString& aWorkerName, + WorkerLoadInfo* aLoadInfo, ErrorResult& aRv) +{ + JSContext* cx = aGlobal.Context(); + return Constructor(cx, aScriptURL, aIsChromeWorker, aWorkerType, + aWorkerName, aLoadInfo, aRv); +} + +// static +already_AddRefed<WorkerPrivate> +WorkerPrivate::Constructor(JSContext* aCx, + const nsAString& aScriptURL, + bool aIsChromeWorker, WorkerType aWorkerType, + const nsACString& aWorkerName, + WorkerLoadInfo* aLoadInfo, ErrorResult& aRv) +{ + // If this is a sub-worker, we need to keep the parent worker alive until this + // one is registered. + UniquePtr<SimpleWorkerHolder> holder; + + WorkerPrivate* parent = NS_IsMainThread() ? + nullptr : + GetCurrentThreadWorkerPrivate(); + if (parent) { + parent->AssertIsOnWorkerThread(); + + holder.reset(new SimpleWorkerHolder()); + if (!holder->HoldWorker(parent, Canceling)) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + } else { + AssertIsOnMainThread(); + } + + // Only service and shared workers can have names. + MOZ_ASSERT_IF(aWorkerType != WorkerTypeDedicated, + !aWorkerName.IsVoid()); + MOZ_ASSERT_IF(aWorkerType == WorkerTypeDedicated, + aWorkerName.IsEmpty()); + + Maybe<WorkerLoadInfo> stackLoadInfo; + if (!aLoadInfo) { + stackLoadInfo.emplace(); + + nsresult rv = GetLoadInfo(aCx, nullptr, parent, aScriptURL, + aIsChromeWorker, InheritLoadGroup, + aWorkerType, stackLoadInfo.ptr()); + aRv.MightThrowJSException(); + if (NS_FAILED(rv)) { + scriptloader::ReportLoadError(aRv, rv, aScriptURL); + return nullptr; + } + + aLoadInfo = stackLoadInfo.ptr(); + } + + // NB: This has to be done before creating the WorkerPrivate, because it will + // attempt to use static variables that are initialized in the RuntimeService + // constructor. + RuntimeService* runtimeService; + + if (!parent) { + runtimeService = RuntimeService::GetOrCreateService(); + if (!runtimeService) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + } + else { + runtimeService = RuntimeService::GetService(); + } + + MOZ_ASSERT(runtimeService); + + RefPtr<WorkerPrivate> worker = + new WorkerPrivate(parent, aScriptURL, aIsChromeWorker, + aWorkerType, aWorkerName, *aLoadInfo); + + // Gecko contexts always have an explicitly-set default locale (set by + // XPJSRuntime::Initialize for the main thread, set by + // WorkerThreadPrimaryRunnable::Run for workers just before running worker + // code), so this is never SpiderMonkey's builtin default locale. + JS::UniqueChars defaultLocale = JS_GetDefaultLocale(aCx); + if (NS_WARN_IF(!defaultLocale)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + worker->mDefaultLocale = Move(defaultLocale); + + if (!runtimeService->RegisterWorker(worker)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + worker->EnableDebugger(); + + RefPtr<CompileScriptRunnable> compiler = + new CompileScriptRunnable(worker, aScriptURL); + if (!compiler->Dispatch()) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + worker->mSelfRef = worker; + + return worker.forget(); +} + +// static +nsresult +WorkerPrivate::GetLoadInfo(JSContext* aCx, nsPIDOMWindowInner* aWindow, + WorkerPrivate* aParent, const nsAString& aScriptURL, + bool aIsChromeWorker, + LoadGroupBehavior aLoadGroupBehavior, + WorkerType aWorkerType, + WorkerLoadInfo* aLoadInfo) +{ + using namespace mozilla::dom::workers::scriptloader; + + MOZ_ASSERT(aCx); + MOZ_ASSERT_IF(NS_IsMainThread(), aCx == nsContentUtils::GetCurrentJSContext()); + + if (aWindow) { + AssertIsOnMainThread(); + } + + WorkerLoadInfo loadInfo; + nsresult rv; + + if (aParent) { + aParent->AssertIsOnWorkerThread(); + + // If the parent is going away give up now. + Status parentStatus; + { + MutexAutoLock lock(aParent->mMutex); + parentStatus = aParent->mStatus; + } + + if (parentStatus > Running) { + return NS_ERROR_FAILURE; + } + + // StartAssignment() is used instead getter_AddRefs because, getter_AddRefs + // does QI in debug build and, if this worker runs in a child process, + // HttpChannelChild will crash because it's not thread-safe. + rv = ChannelFromScriptURLWorkerThread(aCx, aParent, aScriptURL, + loadInfo.mChannel.StartAssignment()); + NS_ENSURE_SUCCESS(rv, rv); + + // Now that we've spun the loop there's no guarantee that our parent is + // still alive. We may have received control messages initiating shutdown. + { + MutexAutoLock lock(aParent->mMutex); + parentStatus = aParent->mStatus; + } + + if (parentStatus > Running) { + NS_ReleaseOnMainThread(loadInfo.mChannel.forget()); + return NS_ERROR_FAILURE; + } + + loadInfo.mDomain = aParent->Domain(); + loadInfo.mFromWindow = aParent->IsFromWindow(); + loadInfo.mWindowID = aParent->WindowID(); + loadInfo.mStorageAllowed = aParent->IsStorageAllowed(); + loadInfo.mOriginAttributes = aParent->GetOriginAttributes(); + loadInfo.mServiceWorkersTestingInWindow = + aParent->ServiceWorkersTestingInWindow(); + } else { + AssertIsOnMainThread(); + + // Make sure that the IndexedDatabaseManager is set up + Unused << NS_WARN_IF(!IndexedDatabaseManager::GetOrCreate()); + + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + MOZ_ASSERT(ssm); + + bool isChrome = nsContentUtils::IsCallerChrome(); + + // First check to make sure the caller has permission to make a privileged + // worker if they called the ChromeWorker/ChromeSharedWorker constructor. + if (aIsChromeWorker && !isChrome) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + // Chrome callers (whether creating a ChromeWorker or Worker) always get the + // system principal here as they're allowed to load anything. The script + // loader will refuse to run any script that does not also have the system + // principal. + if (isChrome) { + rv = ssm->GetSystemPrincipal(getter_AddRefs(loadInfo.mPrincipal)); + NS_ENSURE_SUCCESS(rv, rv); + + loadInfo.mPrincipalIsSystem = true; + } + + // See if we're being called from a window. + nsCOMPtr<nsPIDOMWindowInner> globalWindow = aWindow; + if (!globalWindow) { + nsCOMPtr<nsIScriptGlobalObject> scriptGlobal = + nsJSUtils::GetStaticScriptGlobal(JS::CurrentGlobalOrNull(aCx)); + if (scriptGlobal) { + globalWindow = do_QueryInterface(scriptGlobal); + MOZ_ASSERT(globalWindow); + } + } + + nsCOMPtr<nsIDocument> document; + + if (globalWindow) { + // Only use the current inner window, and only use it if the caller can + // access it. + if (nsPIDOMWindowOuter* outerWindow = globalWindow->GetOuterWindow()) { + loadInfo.mWindow = outerWindow->GetCurrentInnerWindow(); + // TODO: fix this for SharedWorkers with multiple documents (bug 1177935) + loadInfo.mServiceWorkersTestingInWindow = + outerWindow->GetServiceWorkersTestingEnabled(); + } + + if (!loadInfo.mWindow || + (globalWindow != loadInfo.mWindow && + !nsContentUtils::CanCallerAccess(loadInfo.mWindow))) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(loadInfo.mWindow); + MOZ_ASSERT(sgo); + + loadInfo.mScriptContext = sgo->GetContext(); + NS_ENSURE_TRUE(loadInfo.mScriptContext, NS_ERROR_FAILURE); + + // If we're called from a window then we can dig out the principal and URI + // from the document. + document = loadInfo.mWindow->GetExtantDoc(); + NS_ENSURE_TRUE(document, NS_ERROR_FAILURE); + + loadInfo.mBaseURI = document->GetDocBaseURI(); + loadInfo.mLoadGroup = document->GetDocumentLoadGroup(); + + // Use the document's NodePrincipal as our principal if we're not being + // called from chrome. + if (!loadInfo.mPrincipal) { + loadInfo.mPrincipal = document->NodePrincipal(); + NS_ENSURE_TRUE(loadInfo.mPrincipal, NS_ERROR_FAILURE); + + // We use the document's base domain to limit the number of workers + // each domain can create. For sandboxed documents, we use the domain + // of their first non-sandboxed document, walking up until we find + // one. If we can't find one, we fall back to using the GUID of the + // null principal as the base domain. + if (document->GetSandboxFlags() & SANDBOXED_ORIGIN) { + nsCOMPtr<nsIDocument> tmpDoc = document; + do { + tmpDoc = tmpDoc->GetParentDocument(); + } while (tmpDoc && tmpDoc->GetSandboxFlags() & SANDBOXED_ORIGIN); + + if (tmpDoc) { + // There was an unsandboxed ancestor, yay! + nsCOMPtr<nsIPrincipal> tmpPrincipal = tmpDoc->NodePrincipal(); + rv = tmpPrincipal->GetBaseDomain(loadInfo.mDomain); + NS_ENSURE_SUCCESS(rv, rv); + } else { + // No unsandboxed ancestor, use our GUID. + rv = loadInfo.mPrincipal->GetBaseDomain(loadInfo.mDomain); + NS_ENSURE_SUCCESS(rv, rv); + } + } else { + // Document creating the worker is not sandboxed. + rv = loadInfo.mPrincipal->GetBaseDomain(loadInfo.mDomain); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + nsCOMPtr<nsIPermissionManager> permMgr = + do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t perm; + rv = permMgr->TestPermissionFromPrincipal(loadInfo.mPrincipal, "systemXHR", + &perm); + NS_ENSURE_SUCCESS(rv, rv); + + loadInfo.mXHRParamsAllowed = perm == nsIPermissionManager::ALLOW_ACTION; + + loadInfo.mFromWindow = true; + loadInfo.mWindowID = globalWindow->WindowID(); + nsContentUtils::StorageAccess access = + nsContentUtils::StorageAllowedForWindow(globalWindow); + loadInfo.mStorageAllowed = access > nsContentUtils::StorageAccess::eDeny; + loadInfo.mOriginAttributes = nsContentUtils::GetOriginAttributes(document); + } else { + // Not a window + MOZ_ASSERT(isChrome); + + // We're being created outside of a window. Need to figure out the script + // that is creating us in order for us to use relative URIs later on. + JS::AutoFilename fileName; + if (JS::DescribeScriptedCaller(aCx, &fileName)) { + // In most cases, fileName is URI. In a few other cases + // (e.g. xpcshell), fileName is a file path. Ideally, we would + // prefer testing whether fileName parses as an URI and fallback + // to file path in case of error, but Windows file paths have + // the interesting property that they can be parsed as bogus + // URIs (e.g. C:/Windows/Tmp is interpreted as scheme "C", + // hostname "Windows", path "Tmp"), which defeats this algorithm. + // Therefore, we adopt the opposite convention. + nsCOMPtr<nsIFile> scriptFile = + do_CreateInstance("@mozilla.org/file/local;1", &rv); + if (NS_FAILED(rv)) { + return rv; + } + + rv = scriptFile->InitWithPath(NS_ConvertUTF8toUTF16(fileName.get())); + if (NS_SUCCEEDED(rv)) { + rv = NS_NewFileURI(getter_AddRefs(loadInfo.mBaseURI), + scriptFile); + } + if (NS_FAILED(rv)) { + // As expected, fileName is not a path, so proceed with + // a uri. + rv = NS_NewURI(getter_AddRefs(loadInfo.mBaseURI), + fileName.get()); + } + if (NS_FAILED(rv)) { + return rv; + } + } + loadInfo.mXHRParamsAllowed = true; + loadInfo.mFromWindow = false; + loadInfo.mWindowID = UINT64_MAX; + loadInfo.mStorageAllowed = true; + loadInfo.mOriginAttributes = PrincipalOriginAttributes(); + } + + MOZ_ASSERT(loadInfo.mPrincipal); + MOZ_ASSERT(isChrome || !loadInfo.mDomain.IsEmpty()); + + if (!loadInfo.mLoadGroup || aLoadGroupBehavior == OverrideLoadGroup) { + OverrideLoadInfoLoadGroup(loadInfo); + } + MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(loadInfo.mLoadGroup, + loadInfo.mPrincipal)); + + // Top level workers' main script use the document charset for the script + // uri encoding. + bool useDefaultEncoding = false; + rv = ChannelFromScriptURLMainThread(loadInfo.mPrincipal, loadInfo.mBaseURI, + document, loadInfo.mLoadGroup, + aScriptURL, + ContentPolicyType(aWorkerType), + useDefaultEncoding, + getter_AddRefs(loadInfo.mChannel)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_GetFinalChannelURI(loadInfo.mChannel, + getter_AddRefs(loadInfo.mResolvedScriptURI)); + NS_ENSURE_SUCCESS(rv, rv); + } + + aLoadInfo->StealFrom(loadInfo); + return NS_OK; +} + +// static +void +WorkerPrivate::OverrideLoadInfoLoadGroup(WorkerLoadInfo& aLoadInfo) +{ + MOZ_ASSERT(!aLoadInfo.mInterfaceRequestor); + + aLoadInfo.mInterfaceRequestor = + new WorkerLoadInfo::InterfaceRequestor(aLoadInfo.mPrincipal, + aLoadInfo.mLoadGroup); + aLoadInfo.mInterfaceRequestor->MaybeAddTabChild(aLoadInfo.mLoadGroup); + + // NOTE: this defaults the load context to: + // - private browsing = false + // - content = true + // - use remote tabs = false + nsCOMPtr<nsILoadGroup> loadGroup = + do_CreateInstance(NS_LOADGROUP_CONTRACTID); + + nsresult rv = + loadGroup->SetNotificationCallbacks(aLoadInfo.mInterfaceRequestor); + MOZ_ALWAYS_SUCCEEDS(rv); + + aLoadInfo.mLoadGroup = loadGroup.forget(); +} + +void +WorkerPrivate::DoRunLoop(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(mThread); + + { + MutexAutoLock lock(mMutex); + mJSContext = aCx; + + MOZ_ASSERT(mStatus == Pending); + mStatus = Running; + } + + // Now that we've done that, we can go ahead and set up our AutoJSAPI. We + // can't before this point, because it can't find the right JSContext before + // then, since it gets it from our mJSContext. + AutoJSAPI jsapi; + jsapi.Init(); + MOZ_ASSERT(jsapi.cx() == aCx); + + EnableMemoryReporter(); + + InitializeGCTimers(); + + Maybe<JSAutoCompartment> workerCompartment; + + for (;;) { + Status currentStatus, previousStatus; + bool debuggerRunnablesPending = false; + bool normalRunnablesPending = false; + + { + MutexAutoLock lock(mMutex); + previousStatus = mStatus; + + while (mControlQueue.IsEmpty() && + !(debuggerRunnablesPending = !mDebuggerQueue.IsEmpty()) && + !(normalRunnablesPending = NS_HasPendingEvents(mThread))) { + WaitForWorkerEvents(); + } + + auto result = ProcessAllControlRunnablesLocked(); + if (result != ProcessAllControlRunnablesResult::Nothing) { + // NB: There's no JS on the stack here, so Abort vs MayContinue is + // irrelevant + + // The state of the world may have changed, recheck it. + normalRunnablesPending = NS_HasPendingEvents(mThread); + // The debugger queue doesn't get cleared, so we can ignore that. + } + + currentStatus = mStatus; + } + + // if all holders are done then we can kill this thread. + if (currentStatus != Running && !HasActiveHolders()) { + + // If we just changed status, we must schedule the current runnables. + if (previousStatus != Running && currentStatus != Killing) { + NotifyInternal(aCx, Killing); + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + +#ifdef DEBUG + { + MutexAutoLock lock(mMutex); + currentStatus = mStatus; + } + MOZ_ASSERT(currentStatus == Killing); +#else + currentStatus = Killing; +#endif + } + + // If we're supposed to die then we should exit the loop. + if (currentStatus == Killing) { + // Flush uncaught rejections immediately, without + // waiting for a next tick. + PromiseDebugging::FlushUncaughtRejections(); + + ShutdownGCTimers(); + + DisableMemoryReporter(); + + { + MutexAutoLock lock(mMutex); + + mStatus = Dead; + mJSContext = nullptr; + } + + // After mStatus is set to Dead there can be no more + // WorkerControlRunnables so no need to lock here. + if (!mControlQueue.IsEmpty()) { + WorkerControlRunnable* runnable; + while (mControlQueue.Pop(runnable)) { + runnable->Cancel(); + runnable->Release(); + } + } + + // Unroot the globals + mScope = nullptr; + mDebuggerScope = nullptr; + + return; + } + } + + if (debuggerRunnablesPending || normalRunnablesPending) { + // Start the periodic GC timer if it is not already running. + SetGCTimerMode(PeriodicTimer); + } + + if (debuggerRunnablesPending) { + WorkerRunnable* runnable; + + { + MutexAutoLock lock(mMutex); + + mDebuggerQueue.Pop(runnable); + debuggerRunnablesPending = !mDebuggerQueue.IsEmpty(); + } + + MOZ_ASSERT(runnable); + static_cast<nsIRunnable*>(runnable)->Run(); + runnable->Release(); + + // Flush the promise queue. + Promise::PerformWorkerDebuggerMicroTaskCheckpoint(); + + if (debuggerRunnablesPending) { + WorkerDebuggerGlobalScope* globalScope = DebuggerGlobalScope(); + MOZ_ASSERT(globalScope); + + // Now *might* be a good time to GC. Let the JS engine make the decision. + JSAutoCompartment ac(aCx, globalScope->GetGlobalJSObject()); + JS_MaybeGC(aCx); + } + } else if (normalRunnablesPending) { + // Process a single runnable from the main queue. + NS_ProcessNextEvent(mThread, false); + + normalRunnablesPending = NS_HasPendingEvents(mThread); + if (normalRunnablesPending && GlobalScope()) { + // Now *might* be a good time to GC. Let the JS engine make the decision. + JSAutoCompartment ac(aCx, GlobalScope()->GetGlobalJSObject()); + JS_MaybeGC(aCx); + } + } + + if (!debuggerRunnablesPending && !normalRunnablesPending) { + // Both the debugger event queue and the normal event queue has been + // exhausted, cancel the periodic GC timer and schedule the idle GC timer. + SetGCTimerMode(IdleTimer); + } + + // If the worker thread is spamming the main thread faster than it can + // process the work, then pause the worker thread until the MT catches + // up. + if (mMainThreadThrottledEventQueue && + mMainThreadThrottledEventQueue->Length() > 5000) { + mMainThreadThrottledEventQueue->AwaitIdle(); + } + } + + MOZ_CRASH("Shouldn't get here!"); +} + +void +WorkerPrivate::OnProcessNextEvent() +{ + AssertIsOnWorkerThread(); + + uint32_t recursionDepth = CycleCollectedJSContext::Get()->RecursionDepth(); + MOZ_ASSERT(recursionDepth); + + // Normally we process control runnables in DoRunLoop or RunCurrentSyncLoop. + // However, it's possible that non-worker C++ could spin its own nested event + // loop, and in that case we must ensure that we continue to process control + // runnables here. + if (recursionDepth > 1 && + mSyncLoopStack.Length() < recursionDepth - 1) { + Unused << ProcessAllControlRunnables(); + // There's no running JS, and no state to revalidate, so we can ignore the + // return value. + } +} + +void +WorkerPrivate::AfterProcessNextEvent() +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(CycleCollectedJSContext::Get()->RecursionDepth()); +} + +void +WorkerPrivate::MaybeDispatchLoadFailedRunnable() +{ + AssertIsOnWorkerThread(); + + nsCOMPtr<nsIRunnable> runnable = StealLoadFailedAsyncRunnable(); + if (!runnable) { + return; + } + + MOZ_ALWAYS_SUCCEEDS(DispatchToMainThread(runnable.forget())); +} + +nsIEventTarget* +WorkerPrivate::MainThreadEventTarget() +{ + return mMainThreadEventTarget; +} + +nsresult +WorkerPrivate::DispatchToMainThread(nsIRunnable* aRunnable, uint32_t aFlags) +{ + nsCOMPtr<nsIRunnable> r = aRunnable; + return DispatchToMainThread(r.forget(), aFlags); +} + +nsresult +WorkerPrivate::DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable, + uint32_t aFlags) +{ + return mMainThreadEventTarget->Dispatch(Move(aRunnable), aFlags); +} + +void +WorkerPrivate::InitializeGCTimers() +{ + AssertIsOnWorkerThread(); + + // We need a timer for GC. The basic plan is to run a non-shrinking GC + // periodically (PERIODIC_GC_TIMER_DELAY_SEC) while the worker is running. + // Once the worker goes idle we set a short (IDLE_GC_TIMER_DELAY_SEC) timer to + // run a shrinking GC. If the worker receives more messages then the short + // timer is canceled and the periodic timer resumes. + mGCTimer = do_CreateInstance(NS_TIMER_CONTRACTID); + MOZ_ASSERT(mGCTimer); + + RefPtr<GarbageCollectRunnable> runnable = + new GarbageCollectRunnable(this, false, false); + mPeriodicGCTimerTarget = new TimerThreadEventTarget(this, runnable); + + runnable = new GarbageCollectRunnable(this, true, false); + mIdleGCTimerTarget = new TimerThreadEventTarget(this, runnable); + + mPeriodicGCTimerRunning = false; + mIdleGCTimerRunning = false; +} + +void +WorkerPrivate::SetGCTimerMode(GCTimerMode aMode) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(mGCTimer); + MOZ_ASSERT(mPeriodicGCTimerTarget); + MOZ_ASSERT(mIdleGCTimerTarget); + + if ((aMode == PeriodicTimer && mPeriodicGCTimerRunning) || + (aMode == IdleTimer && mIdleGCTimerRunning)) { + return; + } + + MOZ_ALWAYS_SUCCEEDS(mGCTimer->Cancel()); + + mPeriodicGCTimerRunning = false; + mIdleGCTimerRunning = false; + LOG(WorkerLog(), + ("Worker %p canceled GC timer because %s\n", this, + aMode == PeriodicTimer ? + "periodic" : + aMode == IdleTimer ? "idle" : "none")); + + if (aMode == NoTimer) { + return; + } + + MOZ_ASSERT(aMode == PeriodicTimer || aMode == IdleTimer); + + nsIEventTarget* target; + uint32_t delay; + int16_t type; + + if (aMode == PeriodicTimer) { + target = mPeriodicGCTimerTarget; + delay = PERIODIC_GC_TIMER_DELAY_SEC * 1000; + type = nsITimer::TYPE_REPEATING_SLACK; + } + else { + target = mIdleGCTimerTarget; + delay = IDLE_GC_TIMER_DELAY_SEC * 1000; + type = nsITimer::TYPE_ONE_SHOT; + } + + MOZ_ALWAYS_SUCCEEDS(mGCTimer->SetTarget(target)); + MOZ_ALWAYS_SUCCEEDS( + mGCTimer->InitWithNamedFuncCallback(DummyCallback, nullptr, delay, type, + "dom::workers::DummyCallback(2)")); + + if (aMode == PeriodicTimer) { + LOG(WorkerLog(), ("Worker %p scheduled periodic GC timer\n", this)); + mPeriodicGCTimerRunning = true; + } + else { + LOG(WorkerLog(), ("Worker %p scheduled idle GC timer\n", this)); + mIdleGCTimerRunning = true; + } +} + +void +WorkerPrivate::ShutdownGCTimers() +{ + AssertIsOnWorkerThread(); + + MOZ_ASSERT(mGCTimer); + + // Always make sure the timer is canceled. + MOZ_ALWAYS_SUCCEEDS(mGCTimer->Cancel()); + + LOG(WorkerLog(), ("Worker %p killed the GC timer\n", this)); + + mGCTimer = nullptr; + mPeriodicGCTimerTarget = nullptr; + mIdleGCTimerTarget = nullptr; + mPeriodicGCTimerRunning = false; + mIdleGCTimerRunning = false; +} + +bool +WorkerPrivate::InterruptCallback(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + + bool mayContinue = true; + bool scheduledIdleGC = false; + + for (;;) { + // Run all control events now. + auto result = ProcessAllControlRunnables(); + if (result == ProcessAllControlRunnablesResult::Abort) { + mayContinue = false; + } + + bool mayFreeze = mFrozen; + if (mayFreeze) { + MutexAutoLock lock(mMutex); + mayFreeze = mStatus <= Running; + } + + if (!mayContinue || !mayFreeze) { + break; + } + + // Cancel the periodic GC timer here before freezing. The idle GC timer + // will clean everything up once it runs. + if (!scheduledIdleGC) { + SetGCTimerMode(IdleTimer); + scheduledIdleGC = true; + } + + while ((mayContinue = MayContinueRunning())) { + MutexAutoLock lock(mMutex); + if (!mControlQueue.IsEmpty()) { + break; + } + + WaitForWorkerEvents(PR_MillisecondsToInterval(UINT32_MAX)); + } + } + + if (!mayContinue) { + // We want only uncatchable exceptions here. + NS_ASSERTION(!JS_IsExceptionPending(aCx), + "Should not have an exception set here!"); + return false; + } + + // Make sure the periodic timer gets turned back on here. + SetGCTimerMode(PeriodicTimer); + + return true; +} + +nsresult +WorkerPrivate::IsOnCurrentThread(bool* aIsOnCurrentThread) +{ + // May be called on any thread! + + MOZ_ASSERT(aIsOnCurrentThread); + MOZ_ASSERT(mPRThread); + + *aIsOnCurrentThread = PR_GetCurrentThread() == mPRThread; + return NS_OK; +} + +void +WorkerPrivate::ScheduleDeletion(WorkerRanOrNot aRanOrNot) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(mChildWorkers.IsEmpty()); + MOZ_ASSERT(mSyncLoopStack.IsEmpty()); + MOZ_ASSERT(!mPendingEventQueueClearing); + + ClearMainEventQueue(aRanOrNot); +#ifdef DEBUG + if (WorkerRan == aRanOrNot) { + nsIThread* currentThread = NS_GetCurrentThread(); + MOZ_ASSERT(currentThread); + MOZ_ASSERT(!NS_HasPendingEvents(currentThread)); + } +#endif + + if (WorkerPrivate* parent = GetParent()) { + RefPtr<WorkerFinishedRunnable> runnable = + new WorkerFinishedRunnable(parent, this); + if (!runnable->Dispatch()) { + NS_WARNING("Failed to dispatch runnable!"); + } + } + else { + RefPtr<TopLevelWorkerFinishedRunnable> runnable = + new TopLevelWorkerFinishedRunnable(this); + if (NS_FAILED(DispatchToMainThread(runnable.forget()))) { + NS_WARNING("Failed to dispatch runnable!"); + } + } +} + +bool +WorkerPrivate::CollectRuntimeStats(JS::RuntimeStats* aRtStats, + bool aAnonymize) +{ + AssertIsOnWorkerThread(); + NS_ASSERTION(aRtStats, "Null RuntimeStats!"); + NS_ASSERTION(mJSContext, "This must never be null!"); + + return JS::CollectRuntimeStats(mJSContext, aRtStats, nullptr, aAnonymize); +} + +void +WorkerPrivate::EnableMemoryReporter() +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(!mMemoryReporter); + + // No need to lock here since the main thread can't race until we've + // successfully registered the reporter. + mMemoryReporter = new MemoryReporter(this); + + if (NS_FAILED(RegisterWeakAsyncMemoryReporter(mMemoryReporter))) { + NS_WARNING("Failed to register memory reporter!"); + // No need to lock here since a failed registration means our memory + // reporter can't start running. Just clean up. + mMemoryReporter = nullptr; + } +} + +void +WorkerPrivate::DisableMemoryReporter() +{ + AssertIsOnWorkerThread(); + + RefPtr<MemoryReporter> memoryReporter; + { + // Mutex protectes MemoryReporter::mWorkerPrivate which is cleared by + // MemoryReporter::Disable() below. + MutexAutoLock lock(mMutex); + + // There is nothing to do here if the memory reporter was never successfully + // registered. + if (!mMemoryReporter) { + return; + } + + // We don't need this set any longer. Swap it out so that we can unregister + // below. + mMemoryReporter.swap(memoryReporter); + + // Next disable the memory reporter so that the main thread stops trying to + // signal us. + memoryReporter->Disable(); + } + + // Finally unregister the memory reporter. + if (NS_FAILED(UnregisterWeakMemoryReporter(memoryReporter))) { + NS_WARNING("Failed to unregister memory reporter!"); + } +} + +void +WorkerPrivate::WaitForWorkerEvents(PRIntervalTime aInterval) +{ + AssertIsOnWorkerThread(); + mMutex.AssertCurrentThreadOwns(); + + // Wait for a worker event. + mCondVar.Wait(aInterval); +} + +WorkerPrivate::ProcessAllControlRunnablesResult +WorkerPrivate::ProcessAllControlRunnablesLocked() +{ + AssertIsOnWorkerThread(); + mMutex.AssertCurrentThreadOwns(); + + auto result = ProcessAllControlRunnablesResult::Nothing; + + for (;;) { + WorkerControlRunnable* event; + if (!mControlQueue.Pop(event)) { + break; + } + + MutexAutoUnlock unlock(mMutex); + + MOZ_ASSERT(event); + if (NS_FAILED(static_cast<nsIRunnable*>(event)->Run())) { + result = ProcessAllControlRunnablesResult::Abort; + } + + if (result == ProcessAllControlRunnablesResult::Nothing) { + // We ran at least one thing. + result = ProcessAllControlRunnablesResult::MayContinue; + } + event->Release(); + } + + return result; +} + +void +WorkerPrivate::ClearMainEventQueue(WorkerRanOrNot aRanOrNot) +{ + AssertIsOnWorkerThread(); + + MOZ_ASSERT(mSyncLoopStack.IsEmpty()); + MOZ_ASSERT(!mCancelAllPendingRunnables); + mCancelAllPendingRunnables = true; + + if (WorkerNeverRan == aRanOrNot) { + for (uint32_t count = mPreStartRunnables.Length(), index = 0; + index < count; + index++) { + RefPtr<WorkerRunnable> runnable = mPreStartRunnables[index].forget(); + static_cast<nsIRunnable*>(runnable.get())->Run(); + } + } else { + nsIThread* currentThread = NS_GetCurrentThread(); + MOZ_ASSERT(currentThread); + + NS_ProcessPendingEvents(currentThread); + } + + MOZ_ASSERT(mCancelAllPendingRunnables); + mCancelAllPendingRunnables = false; +} + +void +WorkerPrivate::ClearDebuggerEventQueue() +{ + while (!mDebuggerQueue.IsEmpty()) { + WorkerRunnable* runnable; + mDebuggerQueue.Pop(runnable); + // It should be ok to simply release the runnable, without running it. + runnable->Release(); + } +} + +bool +WorkerPrivate::FreezeInternal() +{ + AssertIsOnWorkerThread(); + + NS_ASSERTION(!mFrozen, "Already frozen!"); + + mFrozen = true; + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->Freeze(nullptr); + } + + return true; +} + +bool +WorkerPrivate::ThawInternal() +{ + AssertIsOnWorkerThread(); + + NS_ASSERTION(mFrozen, "Not yet frozen!"); + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->Thaw(nullptr); + } + + mFrozen = false; + return true; +} + +void +WorkerPrivate::TraverseTimeouts(nsCycleCollectionTraversalCallback& cb) +{ + for (uint32_t i = 0; i < mTimeouts.Length(); ++i) { + TimeoutInfo* tmp = mTimeouts[i]; + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHandler) + } +} + +void +WorkerPrivate::UnlinkTimeouts() +{ + mTimeouts.Clear(); +} + +bool +WorkerPrivate::ModifyBusyCountFromWorker(bool aIncrease) +{ + AssertIsOnWorkerThread(); + + { + MutexAutoLock lock(mMutex); + + // If we're in shutdown then the busy count is no longer being considered so + // just return now. + if (mStatus >= Killing) { + return true; + } + } + + RefPtr<ModifyBusyCountRunnable> runnable = + new ModifyBusyCountRunnable(this, aIncrease); + return runnable->Dispatch(); +} + +bool +WorkerPrivate::AddChildWorker(ParentType* aChildWorker) +{ + AssertIsOnWorkerThread(); + +#ifdef DEBUG + { + Status currentStatus; + { + MutexAutoLock lock(mMutex); + currentStatus = mStatus; + } + + MOZ_ASSERT(currentStatus == Running); + } +#endif + + NS_ASSERTION(!mChildWorkers.Contains(aChildWorker), + "Already know about this one!"); + mChildWorkers.AppendElement(aChildWorker); + + return mChildWorkers.Length() == 1 ? + ModifyBusyCountFromWorker(true) : + true; +} + +void +WorkerPrivate::RemoveChildWorker(ParentType* aChildWorker) +{ + AssertIsOnWorkerThread(); + + NS_ASSERTION(mChildWorkers.Contains(aChildWorker), + "Didn't know about this one!"); + mChildWorkers.RemoveElement(aChildWorker); + + if (mChildWorkers.IsEmpty() && !ModifyBusyCountFromWorker(false)) { + NS_WARNING("Failed to modify busy count!"); + } +} + +bool +WorkerPrivate::AddHolder(WorkerHolder* aHolder, Status aFailStatus) +{ + AssertIsOnWorkerThread(); + + { + MutexAutoLock lock(mMutex); + + if (mStatus >= aFailStatus) { + return false; + } + } + + MOZ_ASSERT(!mHolders.Contains(aHolder), "Already know about this one!"); + + if (mHolders.IsEmpty() && !ModifyBusyCountFromWorker(true)) { + return false; + } + + mHolders.AppendElement(aHolder); + return true; +} + +void +WorkerPrivate::RemoveHolder(WorkerHolder* aHolder) +{ + AssertIsOnWorkerThread(); + + MOZ_ASSERT(mHolders.Contains(aHolder), "Didn't know about this one!"); + mHolders.RemoveElement(aHolder); + + if (mHolders.IsEmpty() && !ModifyBusyCountFromWorker(false)) { + NS_WARNING("Failed to modify busy count!"); + } +} + +void +WorkerPrivate::NotifyHolders(JSContext* aCx, Status aStatus) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + + NS_ASSERTION(aStatus > Running, "Bad status!"); + + if (aStatus >= Closing) { + CancelAllTimeouts(); + } + + nsTObserverArray<WorkerHolder*>::ForwardIterator iter(mHolders); + while (iter.HasMore()) { + WorkerHolder* holder = iter.GetNext(); + if (!holder->Notify(aStatus)) { + NS_WARNING("Failed to notify holder!"); + } + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + } + + AutoTArray<ParentType*, 10> children; + children.AppendElements(mChildWorkers); + + for (uint32_t index = 0; index < children.Length(); index++) { + if (!children[index]->Notify(aStatus)) { + NS_WARNING("Failed to notify child worker!"); + } + } +} + +void +WorkerPrivate::CancelAllTimeouts() +{ + AssertIsOnWorkerThread(); + + LOG(TimeoutsLog(), ("Worker %p CancelAllTimeouts.\n", this)); + + if (mTimerRunning) { + NS_ASSERTION(mTimer && mTimerRunnable, "Huh?!"); + NS_ASSERTION(!mTimeouts.IsEmpty(), "Huh?!"); + + if (NS_FAILED(mTimer->Cancel())) { + NS_WARNING("Failed to cancel timer!"); + } + + for (uint32_t index = 0; index < mTimeouts.Length(); index++) { + mTimeouts[index]->mCanceled = true; + } + + // If mRunningExpiredTimeouts, then the fact that they are all canceled now + // means that the currently executing RunExpiredTimeouts will deal with + // them. Otherwise, we need to clean them up ourselves. + if (!mRunningExpiredTimeouts) { + mTimeouts.Clear(); + ModifyBusyCountFromWorker(false); + } + + // Set mTimerRunning false even if mRunningExpiredTimeouts is true, so that + // if we get reentered under this same RunExpiredTimeouts call we don't + // assert above that !mTimeouts().IsEmpty(), because that's clearly false + // now. + mTimerRunning = false; + } +#ifdef DEBUG + else if (!mRunningExpiredTimeouts) { + NS_ASSERTION(mTimeouts.IsEmpty(), "Huh?!"); + } +#endif + + mTimer = nullptr; + mTimerRunnable = nullptr; +} + +already_AddRefed<nsIEventTarget> +WorkerPrivate::CreateNewSyncLoop() +{ + AssertIsOnWorkerThread(); + + nsCOMPtr<nsIThreadInternal> thread = do_QueryInterface(NS_GetCurrentThread()); + MOZ_ASSERT(thread); + + nsCOMPtr<nsIEventTarget> realEventTarget; + MOZ_ALWAYS_SUCCEEDS(thread->PushEventQueue(getter_AddRefs(realEventTarget))); + + RefPtr<EventTarget> workerEventTarget = + new EventTarget(this, realEventTarget); + + { + // Modifications must be protected by mMutex in DEBUG builds, see comment + // about mSyncLoopStack in WorkerPrivate.h. +#ifdef DEBUG + MutexAutoLock lock(mMutex); +#endif + + mSyncLoopStack.AppendElement(new SyncLoopInfo(workerEventTarget)); + } + + return workerEventTarget.forget(); +} + +bool +WorkerPrivate::RunCurrentSyncLoop() +{ + AssertIsOnWorkerThread(); + + JSContext* cx = GetJSContext(); + MOZ_ASSERT(cx); + + // This should not change between now and the time we finish running this sync + // loop. + uint32_t currentLoopIndex = mSyncLoopStack.Length() - 1; + + SyncLoopInfo* loopInfo = mSyncLoopStack[currentLoopIndex]; + + MOZ_ASSERT(loopInfo); + MOZ_ASSERT(!loopInfo->mHasRun); + MOZ_ASSERT(!loopInfo->mCompleted); + +#ifdef DEBUG + loopInfo->mHasRun = true; +#endif + + while (!loopInfo->mCompleted) { + bool normalRunnablesPending = false; + + // Don't block with the periodic GC timer running. + if (!NS_HasPendingEvents(mThread)) { + SetGCTimerMode(IdleTimer); + } + + // Wait for something to do. + { + MutexAutoLock lock(mMutex); + + for (;;) { + while (mControlQueue.IsEmpty() && + !normalRunnablesPending && + !(normalRunnablesPending = NS_HasPendingEvents(mThread))) { + WaitForWorkerEvents(); + } + + auto result = ProcessAllControlRunnablesLocked(); + if (result != ProcessAllControlRunnablesResult::Nothing) { + // XXXkhuey how should we handle Abort here? See Bug 1003730. + + // The state of the world may have changed. Recheck it. + normalRunnablesPending = NS_HasPendingEvents(mThread); + + // NB: If we processed a NotifyRunnable, we might have run + // non-control runnables, one of which may have shut down the + // sync loop. + if (loopInfo->mCompleted) { + break; + } + } + + // If we *didn't* run any control runnables, this should be unchanged. + MOZ_ASSERT(!loopInfo->mCompleted); + + if (normalRunnablesPending) { + break; + } + } + } + + if (normalRunnablesPending) { + // Make sure the periodic timer is running before we continue. + SetGCTimerMode(PeriodicTimer); + + MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(mThread, false)); + + // Now *might* be a good time to GC. Let the JS engine make the decision. + if (JS::CurrentGlobalOrNull(cx)) { + JS_MaybeGC(cx); + } + } + } + + // Make sure that the stack didn't change underneath us. + MOZ_ASSERT(mSyncLoopStack[currentLoopIndex] == loopInfo); + + return DestroySyncLoop(currentLoopIndex); +} + +bool +WorkerPrivate::DestroySyncLoop(uint32_t aLoopIndex, nsIThreadInternal* aThread) +{ + MOZ_ASSERT(!mSyncLoopStack.IsEmpty()); + MOZ_ASSERT(mSyncLoopStack.Length() - 1 == aLoopIndex); + + if (!aThread) { + aThread = mThread; + } + + // We're about to delete the loop, stash its event target and result. + SyncLoopInfo* loopInfo = mSyncLoopStack[aLoopIndex]; + nsIEventTarget* nestedEventTarget = + loopInfo->mEventTarget->GetWeakNestedEventTarget(); + MOZ_ASSERT(nestedEventTarget); + + bool result = loopInfo->mResult; + + { + // Modifications must be protected by mMutex in DEBUG builds, see comment + // about mSyncLoopStack in WorkerPrivate.h. +#ifdef DEBUG + MutexAutoLock lock(mMutex); +#endif + + // This will delete |loopInfo|! + mSyncLoopStack.RemoveElementAt(aLoopIndex); + } + + MOZ_ALWAYS_SUCCEEDS(aThread->PopEventQueue(nestedEventTarget)); + + if (mSyncLoopStack.IsEmpty() && mPendingEventQueueClearing) { + mPendingEventQueueClearing = false; + ClearMainEventQueue(WorkerRan); + } + + return result; +} + +void +WorkerPrivate::StopSyncLoop(nsIEventTarget* aSyncLoopTarget, bool aResult) +{ + AssertIsOnWorkerThread(); + AssertValidSyncLoop(aSyncLoopTarget); + + MOZ_ASSERT(!mSyncLoopStack.IsEmpty()); + + for (uint32_t index = mSyncLoopStack.Length(); index > 0; index--) { + nsAutoPtr<SyncLoopInfo>& loopInfo = mSyncLoopStack[index - 1]; + MOZ_ASSERT(loopInfo); + MOZ_ASSERT(loopInfo->mEventTarget); + + if (loopInfo->mEventTarget == aSyncLoopTarget) { + // Can't assert |loop->mHasRun| here because dispatch failures can cause + // us to bail out early. + MOZ_ASSERT(!loopInfo->mCompleted); + + loopInfo->mResult = aResult; + loopInfo->mCompleted = true; + + loopInfo->mEventTarget->Disable(); + + return; + } + + MOZ_ASSERT(!SameCOMIdentity(loopInfo->mEventTarget, aSyncLoopTarget)); + } + + MOZ_CRASH("Unknown sync loop!"); +} + +#ifdef DEBUG +void +WorkerPrivate::AssertValidSyncLoop(nsIEventTarget* aSyncLoopTarget) +{ + MOZ_ASSERT(aSyncLoopTarget); + + EventTarget* workerTarget; + nsresult rv = + aSyncLoopTarget->QueryInterface(kDEBUGWorkerEventTargetIID, + reinterpret_cast<void**>(&workerTarget)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(workerTarget); + + bool valid = false; + + { + MutexAutoLock lock(mMutex); + + for (uint32_t index = 0; index < mSyncLoopStack.Length(); index++) { + nsAutoPtr<SyncLoopInfo>& loopInfo = mSyncLoopStack[index]; + MOZ_ASSERT(loopInfo); + MOZ_ASSERT(loopInfo->mEventTarget); + + if (loopInfo->mEventTarget == aSyncLoopTarget) { + valid = true; + break; + } + + MOZ_ASSERT(!SameCOMIdentity(loopInfo->mEventTarget, aSyncLoopTarget)); + } + } + + MOZ_ASSERT(valid); +} +#endif + +void +WorkerPrivate::PostMessageToParentInternal( + JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + AssertIsOnWorkerThread(); + + JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue()); + if (aTransferable.WasPassed()) { + const Sequence<JS::Value>& realTransferable = aTransferable.Value(); + + // The input sequence only comes from the generated bindings code, which + // ensures it is rooted. + JS::HandleValueArray elements = + JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(), + realTransferable.Elements()); + + JSObject* array = JS_NewArrayObject(aCx, elements); + if (!array) { + aRv = NS_ERROR_OUT_OF_MEMORY; + return; + } + transferable.setObject(*array); + } + + RefPtr<MessageEventRunnable> runnable = + new MessageEventRunnable(this, + WorkerRunnable::ParentThreadUnchangedBusyCount); + + UniquePtr<AbstractTimelineMarker> start; + UniquePtr<AbstractTimelineMarker> end; + RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get(); + bool isTimelineRecording = timelines && !timelines->IsEmpty(); + + if (isTimelineRecording) { + start = MakeUnique<WorkerTimelineMarker>(NS_IsMainThread() + ? ProfileTimelineWorkerOperationType::SerializeDataOnMainThread + : ProfileTimelineWorkerOperationType::SerializeDataOffMainThread, + MarkerTracingType::START); + } + + runnable->Write(aCx, aMessage, transferable, JS::CloneDataPolicy(), aRv); + + if (isTimelineRecording) { + end = MakeUnique<WorkerTimelineMarker>(NS_IsMainThread() + ? ProfileTimelineWorkerOperationType::SerializeDataOnMainThread + : ProfileTimelineWorkerOperationType::SerializeDataOffMainThread, + MarkerTracingType::END); + timelines->AddMarkerForAllObservedDocShells(start); + timelines->AddMarkerForAllObservedDocShells(end); + } + + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + if (!runnable->Dispatch()) { + aRv = NS_ERROR_FAILURE; + } +} + +void +WorkerPrivate::EnterDebuggerEventLoop() +{ + AssertIsOnWorkerThread(); + + JSContext* cx = GetJSContext(); + MOZ_ASSERT(cx); + + uint32_t currentEventLoopLevel = ++mDebuggerEventLoopLevel; + + while (currentEventLoopLevel <= mDebuggerEventLoopLevel) { + bool debuggerRunnablesPending = false; + + { + MutexAutoLock lock(mMutex); + + debuggerRunnablesPending = !mDebuggerQueue.IsEmpty(); + } + + // Don't block with the periodic GC timer running. + if (!debuggerRunnablesPending) { + SetGCTimerMode(IdleTimer); + } + + // Wait for something to do + { + MutexAutoLock lock(mMutex); + + while (mControlQueue.IsEmpty() && + !(debuggerRunnablesPending = !mDebuggerQueue.IsEmpty())) { + WaitForWorkerEvents(); + } + + ProcessAllControlRunnablesLocked(); + + // XXXkhuey should we abort JS on the stack here if we got Abort above? + } + + if (debuggerRunnablesPending) { + // Start the periodic GC timer if it is not already running. + SetGCTimerMode(PeriodicTimer); + + WorkerRunnable* runnable; + + { + MutexAutoLock lock(mMutex); + + mDebuggerQueue.Pop(runnable); + } + + MOZ_ASSERT(runnable); + static_cast<nsIRunnable*>(runnable)->Run(); + runnable->Release(); + + // Flush the promise queue. + Promise::PerformWorkerDebuggerMicroTaskCheckpoint(); + + // Now *might* be a good time to GC. Let the JS engine make the decision. + if (JS::CurrentGlobalOrNull(cx)) { + JS_MaybeGC(cx); + } + } + } +} + +void +WorkerPrivate::LeaveDebuggerEventLoop() +{ + AssertIsOnWorkerThread(); + + MutexAutoLock lock(mMutex); + + if (mDebuggerEventLoopLevel > 0) { + --mDebuggerEventLoopLevel; + } +} + +void +WorkerPrivate::PostMessageToDebugger(const nsAString& aMessage) +{ + mDebugger->PostMessageToDebugger(aMessage); +} + +void +WorkerPrivate::SetDebuggerImmediate(dom::Function& aHandler, ErrorResult& aRv) +{ + AssertIsOnWorkerThread(); + + RefPtr<DebuggerImmediateRunnable> runnable = + new DebuggerImmediateRunnable(this, aHandler); + if (!runnable->Dispatch()) { + aRv.Throw(NS_ERROR_FAILURE); + } +} + +void +WorkerPrivate::ReportErrorToDebugger(const nsAString& aFilename, + uint32_t aLineno, + const nsAString& aMessage) +{ + mDebugger->ReportErrorToDebugger(aFilename, aLineno, aMessage); +} + +bool +WorkerPrivate::NotifyInternal(JSContext* aCx, Status aStatus) +{ + AssertIsOnWorkerThread(); + + NS_ASSERTION(aStatus > Running && aStatus < Dead, "Bad status!"); + + RefPtr<EventTarget> eventTarget; + + // Save the old status and set the new status. + Status previousStatus; + { + MutexAutoLock lock(mMutex); + + if (mStatus >= aStatus) { + MOZ_ASSERT(!mEventTarget); + return true; + } + + previousStatus = mStatus; + mStatus = aStatus; + + mEventTarget.swap(eventTarget); + } + + // Now that mStatus > Running, no-one can create a new WorkerEventTarget or + // WorkerCrossThreadDispatcher if we don't already have one. + if (eventTarget) { + // Since we'll no longer process events, make sure we no longer allow anyone + // to post them. We have to do this without mMutex held, since our mutex + // must be acquired *after* the WorkerEventTarget's mutex when they're both + // held. + eventTarget->Disable(); + eventTarget = nullptr; + } + + if (mCrossThreadDispatcher) { + // Since we'll no longer process events, make sure we no longer allow + // anyone to post them. We have to do this without mMutex held, since our + // mutex must be acquired *after* mCrossThreadDispatcher's mutex when + // they're both held. + mCrossThreadDispatcher->Forget(); + mCrossThreadDispatcher = nullptr; + } + + MOZ_ASSERT(previousStatus != Pending); + + // Let all our holders know the new status. + NotifyHolders(aCx, aStatus); + MOZ_ASSERT(!JS_IsExceptionPending(aCx)); + + // If this is the first time our status has changed then we need to clear the + // main event queue. + if (previousStatus == Running) { + // NB: If we're in a sync loop, we can't clear the queue immediately, + // because this is the wrong queue. So we have to defer it until later. + if (!mSyncLoopStack.IsEmpty()) { + mPendingEventQueueClearing = true; + } else { + ClearMainEventQueue(WorkerRan); + } + } + + // If the worker script never ran, or failed to compile, we don't need to do + // anything else. + if (!GlobalScope()) { + return true; + } + + if (aStatus == Closing) { + // Notify parent to stop sending us messages and balance our busy count. + RefPtr<CloseRunnable> runnable = new CloseRunnable(this); + if (!runnable->Dispatch()) { + return false; + } + + // Don't abort the script. + return true; + } + + MOZ_ASSERT(aStatus == Terminating || + aStatus == Canceling || + aStatus == Killing); + + // Always abort the script. + return false; +} + +void +WorkerPrivate::ReportError(JSContext* aCx, JS::ConstUTF8CharsZ aToStringResult, + JSErrorReport* aReport) +{ + AssertIsOnWorkerThread(); + + if (!MayContinueRunning() || mErrorHandlerRecursionCount == 2) { + return; + } + + NS_ASSERTION(mErrorHandlerRecursionCount == 0 || + mErrorHandlerRecursionCount == 1, + "Bad recursion logic!"); + + JS::Rooted<JS::Value> exn(aCx); + if (!JS_GetPendingException(aCx, &exn)) { + // Probably shouldn't actually happen? But let's go ahead and just use null + // for lack of anything better. + exn.setNull(); + } + JS_ClearPendingException(aCx); + + nsString message, filename, line; + uint32_t lineNumber, columnNumber, flags, errorNumber; + JSExnType exnType = JSEXN_ERR; + bool mutedError = aReport && aReport->isMuted; + + if (aReport) { + // We want the same behavior here as xpc::ErrorReport::init here. + xpc::ErrorReport::ErrorReportToMessageString(aReport, message); + + filename = NS_ConvertUTF8toUTF16(aReport->filename); + line.Assign(aReport->linebuf(), aReport->linebufLength()); + lineNumber = aReport->lineno; + columnNumber = aReport->tokenOffset(); + flags = aReport->flags; + errorNumber = aReport->errorNumber; + MOZ_ASSERT(aReport->exnType >= JSEXN_FIRST && aReport->exnType < JSEXN_LIMIT); + exnType = JSExnType(aReport->exnType); + } + else { + lineNumber = columnNumber = errorNumber = 0; + flags = nsIScriptError::errorFlag | nsIScriptError::exceptionFlag; + } + + if (message.IsEmpty() && aToStringResult) { + nsDependentCString toStringResult(aToStringResult.c_str()); + if (!AppendUTF8toUTF16(toStringResult, message, mozilla::fallible)) { + // Try again, with only a 1 KB string. Do this infallibly this time. + // If the user doesn't have 1 KB to spare we're done anyways. + uint32_t index = std::min(uint32_t(1024), toStringResult.Length()); + + // Drop the last code point that may be cropped. + index = RewindToPriorUTF8Codepoint(toStringResult.BeginReading(), index); + + nsDependentCString truncatedToStringResult(aToStringResult.c_str(), + index); + AppendUTF8toUTF16(truncatedToStringResult, message); + } + } + + mErrorHandlerRecursionCount++; + + // Don't want to run the scope's error handler if this is a recursive error or + // if we ran out of memory. + bool fireAtScope = mErrorHandlerRecursionCount == 1 && + errorNumber != JSMSG_OUT_OF_MEMORY && + JS::CurrentGlobalOrNull(aCx); + + ReportErrorRunnable::ReportError(aCx, this, fireAtScope, nullptr, message, + filename, line, lineNumber, + columnNumber, flags, errorNumber, exnType, + mutedError, 0, exn); + + mErrorHandlerRecursionCount--; +} + +// static +void +WorkerPrivate::ReportErrorToConsole(const char* aMessage) +{ + WorkerPrivate* wp = nullptr; + if (!NS_IsMainThread()) { + wp = GetCurrentThreadWorkerPrivate(); + } + + ReportErrorToConsoleRunnable::Report(wp, aMessage); +} + +int32_t +WorkerPrivate::SetTimeout(JSContext* aCx, + nsIScriptTimeoutHandler* aHandler, + int32_t aTimeout, bool aIsInterval, + ErrorResult& aRv) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(aHandler); + + const int32_t timerId = mNextTimeoutId++; + + Status currentStatus; + { + MutexAutoLock lock(mMutex); + currentStatus = mStatus; + } + + // If the worker is trying to call setTimeout/setInterval and the parent + // thread has initiated the close process then just silently fail. + if (currentStatus >= Closing) { + aRv.Throw(NS_ERROR_FAILURE); + return 0; + } + + nsAutoPtr<TimeoutInfo> newInfo(new TimeoutInfo()); + newInfo->mIsInterval = aIsInterval; + newInfo->mId = timerId; + + if (MOZ_UNLIKELY(timerId == INT32_MAX)) { + NS_WARNING("Timeout ids overflowed!"); + mNextTimeoutId = 1; + } + + newInfo->mHandler = aHandler; + + // See if any of the optional arguments were passed. + aTimeout = std::max(0, aTimeout); + newInfo->mInterval = TimeDuration::FromMilliseconds(aTimeout); + + newInfo->mTargetTime = TimeStamp::Now() + newInfo->mInterval; + + nsAutoPtr<TimeoutInfo>* insertedInfo = + mTimeouts.InsertElementSorted(newInfo.forget(), GetAutoPtrComparator(mTimeouts)); + + LOG(TimeoutsLog(), ("Worker %p has new timeout: delay=%d interval=%s\n", + this, aTimeout, aIsInterval ? "yes" : "no")); + + // If the timeout we just made is set to fire next then we need to update the + // timer, unless we're currently running timeouts. + if (insertedInfo == mTimeouts.Elements() && !mRunningExpiredTimeouts) { + nsresult rv; + + if (!mTimer) { + mTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv); + if (NS_FAILED(rv)) { + aRv.Throw(rv); + return 0; + } + + mTimerRunnable = new TimerRunnable(this); + } + + if (!mTimerRunning) { + if (!ModifyBusyCountFromWorker(true)) { + aRv.Throw(NS_ERROR_FAILURE); + return 0; + } + mTimerRunning = true; + } + + if (!RescheduleTimeoutTimer(aCx)) { + aRv.Throw(NS_ERROR_FAILURE); + return 0; + } + } + + return timerId; +} + +void +WorkerPrivate::ClearTimeout(int32_t aId) +{ + AssertIsOnWorkerThread(); + + if (!mTimeouts.IsEmpty()) { + NS_ASSERTION(mTimerRunning, "Huh?!"); + + for (uint32_t index = 0; index < mTimeouts.Length(); index++) { + nsAutoPtr<TimeoutInfo>& info = mTimeouts[index]; + if (info->mId == aId) { + info->mCanceled = true; + break; + } + } + } +} + +bool +WorkerPrivate::RunExpiredTimeouts(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + + // We may be called recursively (e.g. close() inside a timeout) or we could + // have been canceled while this event was pending, bail out if there is + // nothing to do. + if (mRunningExpiredTimeouts || !mTimerRunning) { + return true; + } + + NS_ASSERTION(mTimer && mTimerRunnable, "Must have a timer!"); + NS_ASSERTION(!mTimeouts.IsEmpty(), "Should have some work to do!"); + + bool retval = true; + + AutoPtrComparator<TimeoutInfo> comparator = GetAutoPtrComparator(mTimeouts); + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + + // We want to make sure to run *something*, even if the timer fired a little + // early. Fudge the value of now to at least include the first timeout. + const TimeStamp actual_now = TimeStamp::Now(); + const TimeStamp now = std::max(actual_now, mTimeouts[0]->mTargetTime); + + if (now != actual_now) { + LOG(TimeoutsLog(), ("Worker %p fudged timeout by %f ms.\n", this, + (now - actual_now).ToMilliseconds())); + } + + AutoTArray<TimeoutInfo*, 10> expiredTimeouts; + for (uint32_t index = 0; index < mTimeouts.Length(); index++) { + nsAutoPtr<TimeoutInfo>& info = mTimeouts[index]; + if (info->mTargetTime > now) { + break; + } + expiredTimeouts.AppendElement(info); + } + + // Guard against recursion. + mRunningExpiredTimeouts = true; + + // Run expired timeouts. + for (uint32_t index = 0; index < expiredTimeouts.Length(); index++) { + TimeoutInfo*& info = expiredTimeouts[index]; + + if (info->mCanceled) { + continue; + } + + LOG(TimeoutsLog(), ("Worker %p executing timeout with original delay %f ms.\n", + this, info->mInterval.ToMilliseconds())); + + // Always check JS_IsExceptionPending if something fails, and if + // JS_IsExceptionPending returns false (i.e. uncatchable exception) then + // break out of the loop. + const char *reason; + if (info->mIsInterval) { + reason = "setInterval handler"; + } else { + reason = "setTimeout handler"; + } + + RefPtr<Function> callback = info->mHandler->GetCallback(); + if (!callback) { + // scope for the AutoEntryScript, so it comes off the stack before we do + // Promise::PerformMicroTaskCheckpoint. + AutoEntryScript aes(global, reason, false); + + // Evaluate the timeout expression. + const nsAString& script = info->mHandler->GetHandlerText(); + + const char* filename = nullptr; + uint32_t lineNo = 0, dummyColumn = 0; + info->mHandler->GetLocation(&filename, &lineNo, &dummyColumn); + + JS::CompileOptions options(aes.cx()); + options.setFileAndLine(filename, lineNo).setNoScriptRval(true); + + JS::Rooted<JS::Value> unused(aes.cx()); + + if (!JS::Evaluate(aes.cx(), options, script.BeginReading(), + script.Length(), &unused) && + !JS_IsExceptionPending(aCx)) { + retval = false; + break; + } + } else { + ErrorResult rv; + JS::Rooted<JS::Value> ignoredVal(aCx); + callback->Call(GlobalScope(), info->mHandler->GetArgs(), &ignoredVal, rv, + reason); + if (rv.IsUncatchableException()) { + rv.SuppressException(); + retval = false; + break; + } + + rv.SuppressException(); + } + + // Since we might be processing more timeouts, go ahead and flush + // the promise queue now before we do that. + Promise::PerformWorkerMicroTaskCheckpoint(); + + NS_ASSERTION(mRunningExpiredTimeouts, "Someone changed this!"); + } + + // No longer possible to be called recursively. + mRunningExpiredTimeouts = false; + + // Now remove canceled and expired timeouts from the main list. + // NB: The timeouts present in expiredTimeouts must have the same order + // with respect to each other in mTimeouts. That is, mTimeouts is just + // expiredTimeouts with extra elements inserted. There may be unexpired + // timeouts that have been inserted between the expired timeouts if the + // timeout event handler called setTimeout/setInterval. + for (uint32_t index = 0, expiredTimeoutIndex = 0, + expiredTimeoutLength = expiredTimeouts.Length(); + index < mTimeouts.Length(); ) { + nsAutoPtr<TimeoutInfo>& info = mTimeouts[index]; + if ((expiredTimeoutIndex < expiredTimeoutLength && + info == expiredTimeouts[expiredTimeoutIndex] && + ++expiredTimeoutIndex) || + info->mCanceled) { + if (info->mIsInterval && !info->mCanceled) { + // Reschedule intervals. + info->mTargetTime = info->mTargetTime + info->mInterval; + // Don't resort the list here, we'll do that at the end. + ++index; + } + else { + mTimeouts.RemoveElement(info); + } + } + else { + // If info did not match the current entry in expiredTimeouts, it + // shouldn't be there at all. + NS_ASSERTION(!expiredTimeouts.Contains(info), + "Our timeouts are out of order!"); + ++index; + } + } + + mTimeouts.Sort(comparator); + + // Either signal the parent that we're no longer using timeouts or reschedule + // the timer. + if (mTimeouts.IsEmpty()) { + if (!ModifyBusyCountFromWorker(false)) { + retval = false; + } + mTimerRunning = false; + } + else if (retval && !RescheduleTimeoutTimer(aCx)) { + retval = false; + } + + return retval; +} + +bool +WorkerPrivate::RescheduleTimeoutTimer(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(!mRunningExpiredTimeouts); + NS_ASSERTION(!mTimeouts.IsEmpty(), "Should have some timeouts!"); + NS_ASSERTION(mTimer && mTimerRunnable, "Should have a timer!"); + + // NB: This is important! The timer may have already fired, e.g. if a timeout + // callback itself calls setTimeout for a short duration and then takes longer + // than that to finish executing. If that has happened, it's very important + // that we don't execute the event that is now pending in our event queue, or + // our code in RunExpiredTimeouts to "fudge" the timeout value will unleash an + // early timeout when we execute the event we're about to queue. + mTimer->Cancel(); + + double delta = + (mTimeouts[0]->mTargetTime - TimeStamp::Now()).ToMilliseconds(); + uint32_t delay = delta > 0 ? std::min(delta, double(UINT32_MAX)) : 0; + + LOG(TimeoutsLog(), ("Worker %p scheduled timer for %d ms, %d pending timeouts\n", + this, delay, mTimeouts.Length())); + + nsresult rv = mTimer->InitWithCallback(mTimerRunnable, delay, nsITimer::TYPE_ONE_SHOT); + if (NS_FAILED(rv)) { + JS_ReportErrorASCII(aCx, "Failed to start timer!"); + return false; + } + + return true; +} + +void +WorkerPrivate::UpdateContextOptionsInternal( + JSContext* aCx, + const JS::ContextOptions& aContextOptions) +{ + AssertIsOnWorkerThread(); + + JS::ContextOptionsRef(aCx) = aContextOptions; + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->UpdateContextOptions(aContextOptions); + } +} + +void +WorkerPrivate::UpdateLanguagesInternal(const nsTArray<nsString>& aLanguages) +{ + WorkerGlobalScope* globalScope = GlobalScope(); + if (globalScope) { + RefPtr<WorkerNavigator> nav = globalScope->GetExistingNavigator(); + if (nav) { + nav->SetLanguages(aLanguages); + } + } + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->UpdateLanguages(aLanguages); + } +} + +void +WorkerPrivate::UpdatePreferenceInternal(WorkerPreference aPref, bool aValue) +{ + AssertIsOnWorkerThread(); + MOZ_ASSERT(aPref >= 0 && aPref < WORKERPREF_COUNT); + + mPreferences[aPref] = aValue; + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->UpdatePreference(aPref, aValue); + } +} + +void +WorkerPrivate::UpdateJSWorkerMemoryParameterInternal(JSContext* aCx, + JSGCParamKey aKey, + uint32_t aValue) +{ + AssertIsOnWorkerThread(); + + // XXX aValue might be 0 here (telling us to unset a previous value for child + // workers). Calling JS_SetGCParameter with a value of 0 isn't actually + // supported though. We really need some way to revert to a default value + // here. + if (aValue) { + JS_SetGCParameter(aCx, aKey, aValue); + } + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->UpdateJSWorkerMemoryParameter(aKey, aValue); + } +} + +#ifdef JS_GC_ZEAL +void +WorkerPrivate::UpdateGCZealInternal(JSContext* aCx, uint8_t aGCZeal, + uint32_t aFrequency) +{ + AssertIsOnWorkerThread(); + + JS_SetGCZeal(aCx, aGCZeal, aFrequency); + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->UpdateGCZeal(aGCZeal, aFrequency); + } +} +#endif + +void +WorkerPrivate::GarbageCollectInternal(JSContext* aCx, bool aShrinking, + bool aCollectChildren) +{ + AssertIsOnWorkerThread(); + + if (!GlobalScope()) { + // We haven't compiled anything yet. Just bail out. + return; + } + + if (aShrinking || aCollectChildren) { + JS::PrepareForFullGC(aCx); + + if (aShrinking) { + JS::GCForReason(aCx, GC_SHRINK, JS::gcreason::DOM_WORKER); + + if (!aCollectChildren) { + LOG(WorkerLog(), ("Worker %p collected idle garbage\n", this)); + } + } + else { + JS::GCForReason(aCx, GC_NORMAL, JS::gcreason::DOM_WORKER); + LOG(WorkerLog(), ("Worker %p collected garbage\n", this)); + } + } + else { + JS_MaybeGC(aCx); + LOG(WorkerLog(), ("Worker %p collected periodic garbage\n", this)); + } + + if (aCollectChildren) { + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->GarbageCollect(aShrinking); + } + } +} + +void +WorkerPrivate::CycleCollectInternal(bool aCollectChildren) +{ + AssertIsOnWorkerThread(); + + nsCycleCollector_collect(nullptr); + + if (aCollectChildren) { + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->CycleCollect(/* dummy = */ false); + } + } +} + +void +WorkerPrivate::MemoryPressureInternal() +{ + AssertIsOnWorkerThread(); + + RefPtr<Console> console = mScope ? mScope->GetConsoleIfExists() : nullptr; + if (console) { + console->ClearStorage(); + } + + console = mDebuggerScope ? mDebuggerScope->GetConsoleIfExists() : nullptr; + if (console) { + console->ClearStorage(); + } + + for (uint32_t index = 0; index < mChildWorkers.Length(); index++) { + mChildWorkers[index]->MemoryPressure(false); + } +} + +void +WorkerPrivate::SetThread(WorkerThread* aThread) +{ + if (aThread) { +#ifdef DEBUG + { + bool isOnCurrentThread; + MOZ_ASSERT(NS_SUCCEEDED(aThread->IsOnCurrentThread(&isOnCurrentThread))); + MOZ_ASSERT(isOnCurrentThread); + } +#endif + + MOZ_ASSERT(!mPRThread); + mPRThread = PRThreadFromThread(aThread); + MOZ_ASSERT(mPRThread); + } + else { + MOZ_ASSERT(mPRThread); + } + + const WorkerThreadFriendKey friendKey; + + RefPtr<WorkerThread> doomedThread; + + { // Scope so that |doomedThread| is released without holding the lock. + MutexAutoLock lock(mMutex); + + if (aThread) { + MOZ_ASSERT(!mThread); + MOZ_ASSERT(mStatus == Pending); + + mThread = aThread; + mThread->SetWorker(friendKey, this); + + if (!mPreStartRunnables.IsEmpty()) { + for (uint32_t index = 0; index < mPreStartRunnables.Length(); index++) { + MOZ_ALWAYS_SUCCEEDS( + mThread->DispatchAnyThread(friendKey, mPreStartRunnables[index].forget())); + } + mPreStartRunnables.Clear(); + } + } + else { + MOZ_ASSERT(mThread); + + mThread->SetWorker(friendKey, nullptr); + + mThread.swap(doomedThread); + } + } +} + +WorkerCrossThreadDispatcher* +WorkerPrivate::GetCrossThreadDispatcher() +{ + MutexAutoLock lock(mMutex); + + if (!mCrossThreadDispatcher && mStatus <= Running) { + mCrossThreadDispatcher = new WorkerCrossThreadDispatcher(this); + } + + return mCrossThreadDispatcher; +} + +void +WorkerPrivate::BeginCTypesCall() +{ + AssertIsOnWorkerThread(); + + // Don't try to GC while we're blocked in a ctypes call. + SetGCTimerMode(NoTimer); +} + +void +WorkerPrivate::EndCTypesCall() +{ + AssertIsOnWorkerThread(); + + // Make sure the periodic timer is running before we start running JS again. + SetGCTimerMode(PeriodicTimer); +} + +bool +WorkerPrivate::ConnectMessagePort(JSContext* aCx, + MessagePortIdentifier& aIdentifier) +{ + AssertIsOnWorkerThread(); + + WorkerGlobalScope* globalScope = GlobalScope(); + + JS::Rooted<JSObject*> jsGlobal(aCx, globalScope->GetWrapper()); + MOZ_ASSERT(jsGlobal); + + // This MessagePortIdentifier is used to create a new port, still connected + // with the other one, but in the worker thread. + ErrorResult rv; + RefPtr<MessagePort> port = MessagePort::Create(globalScope, aIdentifier, rv); + if (NS_WARN_IF(rv.Failed())) { + rv.SuppressException(); + return false; + } + + GlobalObject globalObject(aCx, jsGlobal); + if (globalObject.Failed()) { + return false; + } + + RootedDictionary<MessageEventInit> init(aCx); + init.mBubbles = false; + init.mCancelable = false; + init.mSource.SetValue().SetAsMessagePort() = port; + if (!init.mPorts.AppendElement(port.forget(), fallible)) { + return false; + } + + RefPtr<MessageEvent> event = + MessageEvent::Constructor(globalObject, + NS_LITERAL_STRING("connect"), init, rv); + + event->SetTrusted(true); + + nsCOMPtr<nsIDOMEvent> domEvent = do_QueryObject(event); + + nsEventStatus dummy = nsEventStatus_eIgnore; + globalScope->DispatchDOMEvent(nullptr, domEvent, nullptr, &dummy); + + return true; +} + +WorkerGlobalScope* +WorkerPrivate::GetOrCreateGlobalScope(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + + if (!mScope) { + RefPtr<WorkerGlobalScope> globalScope; + if (IsSharedWorker()) { + globalScope = new SharedWorkerGlobalScope(this, WorkerName()); + } else if (IsServiceWorker()) { + globalScope = new ServiceWorkerGlobalScope(this, WorkerName()); + } else { + globalScope = new DedicatedWorkerGlobalScope(this); + } + + JS::Rooted<JSObject*> global(aCx); + NS_ENSURE_TRUE(globalScope->WrapGlobalObject(aCx, &global), nullptr); + + JSAutoCompartment ac(aCx, global); + + // RegisterBindings() can spin a nested event loop so we have to set mScope + // before calling it, and we have to make sure to unset mScope if it fails. + mScope = Move(globalScope); + + if (!RegisterBindings(aCx, global)) { + mScope = nullptr; + return nullptr; + } + + JS_FireOnNewGlobalObject(aCx, global); + } + + return mScope; +} + +WorkerDebuggerGlobalScope* +WorkerPrivate::CreateDebuggerGlobalScope(JSContext* aCx) +{ + AssertIsOnWorkerThread(); + + MOZ_ASSERT(!mDebuggerScope); + + RefPtr<WorkerDebuggerGlobalScope> globalScope = + new WorkerDebuggerGlobalScope(this); + + JS::Rooted<JSObject*> global(aCx); + NS_ENSURE_TRUE(globalScope->WrapGlobalObject(aCx, &global), nullptr); + + JSAutoCompartment ac(aCx, global); + + // RegisterDebuggerBindings() can spin a nested event loop so we have to set + // mDebuggerScope before calling it, and we have to make sure to unset + // mDebuggerScope if it fails. + mDebuggerScope = Move(globalScope); + + if (!RegisterDebuggerBindings(aCx, global)) { + mDebuggerScope = nullptr; + return nullptr; + } + + JS_FireOnNewGlobalObject(aCx, global); + + return mDebuggerScope; +} + +#ifdef DEBUG + +void +WorkerPrivate::AssertIsOnWorkerThread() const +{ + // This is much more complicated than it needs to be but we can't use mThread + // because it must be protected by mMutex and sometimes this method is called + // when mMutex is already locked. This method should always work. + MOZ_ASSERT(mPRThread, + "AssertIsOnWorkerThread() called before a thread was assigned!"); + + nsCOMPtr<nsIThread> thread; + nsresult rv = + nsThreadManager::get().GetThreadFromPRThread(mPRThread, + getter_AddRefs(thread)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(thread); + + bool current; + rv = thread->IsOnCurrentThread(¤t); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(current, "Wrong thread!"); +} + +#endif // DEBUG + +NS_IMPL_ISUPPORTS_INHERITED0(ExternalRunnableWrapper, WorkerRunnable) + +template <class Derived> +NS_IMPL_ADDREF(WorkerPrivateParent<Derived>::EventTarget) + +template <class Derived> +NS_IMPL_RELEASE(WorkerPrivateParent<Derived>::EventTarget) + +template <class Derived> +NS_INTERFACE_MAP_BEGIN(WorkerPrivateParent<Derived>::EventTarget) + NS_INTERFACE_MAP_ENTRY(nsIEventTarget) + NS_INTERFACE_MAP_ENTRY(nsISupports) +#ifdef DEBUG + // kDEBUGWorkerEventTargetIID is special in that it does not AddRef its + // result. + if (aIID.Equals(kDEBUGWorkerEventTargetIID)) { + *aInstancePtr = this; + return NS_OK; + } + else +#endif +NS_INTERFACE_MAP_END + +template <class Derived> +NS_IMETHODIMP +WorkerPrivateParent<Derived>:: +EventTarget::DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) +{ + nsCOMPtr<nsIRunnable> event(aRunnable); + return Dispatch(event.forget(), aFlags); +} + +template <class Derived> +NS_IMETHODIMP +WorkerPrivateParent<Derived>:: +EventTarget::Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) +{ + // May be called on any thread! + nsCOMPtr<nsIRunnable> event(aRunnable); + + // Workers only support asynchronous dispatch for now. + if (NS_WARN_IF(aFlags != NS_DISPATCH_NORMAL)) { + return NS_ERROR_UNEXPECTED; + } + + RefPtr<WorkerRunnable> workerRunnable; + + MutexAutoLock lock(mMutex); + + if (!mWorkerPrivate) { + NS_WARNING("A runnable was posted to a worker that is already shutting " + "down!"); + return NS_ERROR_UNEXPECTED; + } + + if (event) { + workerRunnable = mWorkerPrivate->MaybeWrapAsWorkerRunnable(event.forget()); + } + + nsresult rv = + mWorkerPrivate->DispatchPrivate(workerRunnable.forget(), mNestedEventTarget); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +template <class Derived> +NS_IMETHODIMP +WorkerPrivateParent<Derived>:: +EventTarget::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +template <class Derived> +NS_IMETHODIMP +WorkerPrivateParent<Derived>:: +EventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread) +{ + // May be called on any thread! + + MOZ_ASSERT(aIsOnCurrentThread); + + MutexAutoLock lock(mMutex); + + if (!mWorkerPrivate) { + NS_WARNING("A worker's event target was used after the worker has !"); + return NS_ERROR_UNEXPECTED; + } + + nsresult rv = mWorkerPrivate->IsOnCurrentThread(aIsOnCurrentThread); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +BEGIN_WORKERS_NAMESPACE + +WorkerCrossThreadDispatcher* +GetWorkerCrossThreadDispatcher(JSContext* aCx, const JS::Value& aWorker) +{ + if (!aWorker.isObject()) { + return nullptr; + } + + JS::Rooted<JSObject*> obj(aCx, &aWorker.toObject()); + WorkerPrivate* w = nullptr; + UNWRAP_OBJECT(Worker, &obj, w); + MOZ_ASSERT(w); + return w->GetCrossThreadDispatcher(); +} + +// Force instantiation. +template class WorkerPrivateParent<WorkerPrivate>; + +END_WORKERS_NAMESPACE diff --git a/dom/workers/WorkerPrivate.h b/dom/workers/WorkerPrivate.h new file mode 100644 index 000000000..ad906b054 --- /dev/null +++ b/dom/workers/WorkerPrivate.h @@ -0,0 +1,1594 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_workerprivate_h__ +#define mozilla_dom_workers_workerprivate_h__ + +#include "Workers.h" + +#include "js/CharacterEncoding.h" +#include "nsIContentPolicy.h" +#include "nsIContentSecurityPolicy.h" +#include "nsILoadGroup.h" +#include "nsIWorkerDebugger.h" +#include "nsPIDOMWindow.h" + +#include "mozilla/Assertions.h" +#include "mozilla/Attributes.h" +#include "mozilla/CondVar.h" +#include "mozilla/ConsoleReportCollector.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/Move.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "nsAutoPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsDataHashtable.h" +#include "nsHashKeys.h" +#include "nsRefPtrHashtable.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsThreadUtils.h" +#include "nsTObserverArray.h" + +#include "Queue.h" +#include "WorkerHolder.h" + +#ifdef XP_WIN +#undef PostMessage +#endif + +class nsIChannel; +class nsIConsoleReportCollector; +class nsIDocument; +class nsIEventTarget; +class nsIPrincipal; +class nsIScriptContext; +class nsIScriptTimeoutHandler; +class nsISerializable; +class nsIThread; +class nsIThreadInternal; +class nsITimer; +class nsIURI; +template<class T> class nsMainThreadPtrHandle; + +namespace JS { +struct RuntimeStats; +} // namespace JS + +namespace mozilla { +class ThrottledEventQueue; +namespace dom { +class Function; +class MessagePort; +class MessagePortIdentifier; +class PromiseNativeHandler; +class StructuredCloneHolder; +class WorkerDebuggerGlobalScope; +class WorkerGlobalScope; +} // namespace dom +namespace ipc { +class PrincipalInfo; +} // namespace ipc +} // namespace mozilla + +struct PRThread; + +class ReportDebuggerErrorRunnable; +class PostDebuggerMessageRunnable; + +BEGIN_WORKERS_NAMESPACE + +class AutoSyncLoopHolder; +class SharedWorker; +class ServiceWorkerClientInfo; +class WorkerControlRunnable; +class WorkerDebugger; +class WorkerPrivate; +class WorkerRunnable; +class WorkerThread; + +// SharedMutex is a small wrapper around an (internal) reference-counted Mutex +// object. It exists to avoid changing a lot of code to use Mutex* instead of +// Mutex&. +class SharedMutex +{ + typedef mozilla::Mutex Mutex; + + class RefCountedMutex final : public Mutex + { + public: + explicit RefCountedMutex(const char* aName) + : Mutex(aName) + { } + + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RefCountedMutex) + + private: + ~RefCountedMutex() + { } + }; + + RefPtr<RefCountedMutex> mMutex; + +public: + explicit SharedMutex(const char* aName) + : mMutex(new RefCountedMutex(aName)) + { } + + SharedMutex(SharedMutex& aOther) + : mMutex(aOther.mMutex) + { } + + operator Mutex&() + { + return *mMutex; + } + + operator const Mutex&() const + { + return *mMutex; + } + + void + AssertCurrentThreadOwns() const + { + mMutex->AssertCurrentThreadOwns(); + } +}; + +template <class Derived> +class WorkerPrivateParent : public DOMEventTargetHelper +{ +protected: + class EventTarget; + friend class EventTarget; + + typedef mozilla::ipc::PrincipalInfo PrincipalInfo; + +public: + struct LocationInfo + { + nsCString mHref; + nsCString mProtocol; + nsCString mHost; + nsCString mHostname; + nsCString mPort; + nsCString mPathname; + nsCString mSearch; + nsCString mHash; + nsString mOrigin; + }; + +protected: + typedef mozilla::ErrorResult ErrorResult; + + SharedMutex mMutex; + mozilla::CondVar mCondVar; + + // Protected by mMutex. + RefPtr<EventTarget> mEventTarget; + nsTArray<RefPtr<WorkerRunnable>> mPreStartRunnables; + +private: + WorkerPrivate* mParent; + nsString mScriptURL; + // This is the worker name for shared workers or the worker scope + // for service workers. + nsCString mWorkerName; + LocationInfo mLocationInfo; + // The lifetime of these objects within LoadInfo is managed explicitly; + // they do not need to be cycle collected. + WorkerLoadInfo mLoadInfo; + + Atomic<bool> mLoadingWorkerScript; + + // Only used for top level workers. + nsTArray<nsCOMPtr<nsIRunnable>> mQueuedRunnables; + + // Protected by mMutex. + JSSettings mJSSettings; + + // Only touched on the parent thread (currently this is always the main + // thread as SharedWorkers are always top-level). + nsTArray<RefPtr<SharedWorker>> mSharedWorkers; + + uint64_t mBusyCount; + // SharedWorkers may have multiple windows paused, so this must be + // a count instead of just a boolean. + uint32_t mParentWindowPausedDepth; + Status mParentStatus; + bool mParentFrozen; + bool mIsChromeWorker; + bool mMainThreadObjectsForgotten; + // mIsSecureContext is set once in our constructor; after that it can be read + // from various threads. We could make this const if we were OK with setting + // it in the initializer list via calling some function that takes all sorts + // of state (loadinfo, worker type, parent). + // + // It's a bit unfortunate that we have to have an out-of-band boolean for + // this, but we need access to this state from the parent thread, and we can't + // use our global object's secure state there. + bool mIsSecureContext; + WorkerType mWorkerType; + TimeStamp mCreationTimeStamp; + DOMHighResTimeStamp mCreationTimeHighRes; + TimeStamp mNowBaseTimeStamp; + DOMHighResTimeStamp mNowBaseTimeHighRes; + +protected: + // The worker is owned by its thread, which is represented here. This is set + // in Construct() and emptied by WorkerFinishedRunnable, and conditionally + // traversed by the cycle collector if the busy count is zero. + RefPtr<WorkerPrivate> mSelfRef; + + WorkerPrivateParent(WorkerPrivate* aParent, + const nsAString& aScriptURL, bool aIsChromeWorker, + WorkerType aWorkerType, + const nsACString& aSharedWorkerName, + WorkerLoadInfo& aLoadInfo); + + ~WorkerPrivateParent(); + +private: + Derived* + ParentAsWorkerPrivate() const + { + return static_cast<Derived*>(const_cast<WorkerPrivateParent*>(this)); + } + + bool + NotifyPrivate(Status aStatus); + + bool + TerminatePrivate() + { + return NotifyPrivate(Terminating); + } + + void + PostMessageInternal(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo, + PromiseNativeHandler* aHandler, + ErrorResult& aRv); + + nsresult + DispatchPrivate(already_AddRefed<WorkerRunnable> aRunnable, nsIEventTarget* aSyncLoopTarget); + +public: + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerPrivateParent, + DOMEventTargetHelper) + + void + EnableDebugger(); + + void + DisableDebugger(); + + void + ClearSelfRef() + { + AssertIsOnParentThread(); + MOZ_ASSERT(mSelfRef); + mSelfRef = nullptr; + } + + nsresult + Dispatch(already_AddRefed<WorkerRunnable> aRunnable) + { + return DispatchPrivate(Move(aRunnable), nullptr); + } + + nsresult + DispatchControlRunnable(already_AddRefed<WorkerControlRunnable> aWorkerControlRunnable); + + nsresult + DispatchDebuggerRunnable(already_AddRefed<WorkerRunnable> aDebuggerRunnable); + + already_AddRefed<WorkerRunnable> + MaybeWrapAsWorkerRunnable(already_AddRefed<nsIRunnable> aRunnable); + + already_AddRefed<nsIEventTarget> + GetEventTarget(); + + // May be called on any thread... + bool + Start(); + + // Called on the parent thread. + bool + Notify(Status aStatus) + { + return NotifyPrivate(aStatus); + } + + bool + Cancel() + { + return Notify(Canceling); + } + + bool + Kill() + { + return Notify(Killing); + } + + // We can assume that an nsPIDOMWindow will be available for Freeze, Thaw + // as these are only used for globals going in and out of the bfcache. + // + // XXXbz: This is a bald-faced lie given the uses in RegisterSharedWorker and + // CloseSharedWorkersForWindow, which pass null for aWindow to Thaw and Freeze + // respectively. See bug 1251722. + bool + Freeze(nsPIDOMWindowInner* aWindow); + + bool + Thaw(nsPIDOMWindowInner* aWindow); + + // When we debug a worker, we want to disconnect the window and the worker + // communication. This happens calling this method. + // Note: this method doesn't suspend the worker! Use Freeze/Thaw instead. + void + ParentWindowPaused(); + + void + ParentWindowResumed(); + + bool + Terminate() + { + AssertIsOnParentThread(); + return TerminatePrivate(); + } + + bool + Close(); + + bool + ModifyBusyCount(bool aIncrease); + + void + ForgetOverridenLoadGroup(nsCOMPtr<nsILoadGroup>& aLoadGroupOut); + + void + ForgetMainThreadObjects(nsTArray<nsCOMPtr<nsISupports> >& aDoomed); + + void + PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + + void + PostMessageToServiceWorker(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + UniquePtr<ServiceWorkerClientInfo>&& aClientInfo, + PromiseNativeHandler* aHandler, + ErrorResult& aRv); + + void + UpdateContextOptions(const JS::ContextOptions& aContextOptions); + + void + UpdateLanguages(const nsTArray<nsString>& aLanguages); + + void + UpdatePreference(WorkerPreference aPref, bool aValue); + + void + UpdateJSWorkerMemoryParameter(JSGCParamKey key, uint32_t value); + +#ifdef JS_GC_ZEAL + void + UpdateGCZeal(uint8_t aGCZeal, uint32_t aFrequency); +#endif + + void + GarbageCollect(bool aShrinking); + + void + CycleCollect(bool aDummy); + + void + OfflineStatusChangeEvent(bool aIsOffline); + + void + MemoryPressure(bool aDummy); + + bool + RegisterSharedWorker(SharedWorker* aSharedWorker, MessagePort* aPort); + + void + BroadcastErrorToSharedWorkers(JSContext* aCx, + const nsAString& aMessage, + const nsAString& aFilename, + const nsAString& aLine, + uint32_t aLineNumber, + uint32_t aColumnNumber, + uint32_t aFlags); + + void + WorkerScriptLoaded(); + + void + QueueRunnable(nsIRunnable* aRunnable) + { + AssertIsOnParentThread(); + mQueuedRunnables.AppendElement(aRunnable); + } + + WorkerPrivate* + GetParent() const + { + return mParent; + } + + bool + IsFrozen() const + { + AssertIsOnParentThread(); + return mParentFrozen; + } + + bool + IsParentWindowPaused() const + { + AssertIsOnParentThread(); + return mParentWindowPausedDepth > 0; + } + + bool + IsAcceptingEvents() + { + AssertIsOnParentThread(); + + MutexAutoLock lock(mMutex); + return mParentStatus < Terminating; + } + + Status + ParentStatus() const + { + mMutex.AssertCurrentThreadOwns(); + return mParentStatus; + } + + nsIScriptContext* + GetScriptContext() const + { + AssertIsOnMainThread(); + return mLoadInfo.mScriptContext; + } + + const nsString& + ScriptURL() const + { + return mScriptURL; + } + + const nsCString& + Domain() const + { + return mLoadInfo.mDomain; + } + + bool + IsFromWindow() const + { + return mLoadInfo.mFromWindow; + } + + uint64_t + WindowID() const + { + return mLoadInfo.mWindowID; + } + + uint64_t + ServiceWorkerID() const + { + return mLoadInfo.mServiceWorkerID; + } + + nsIURI* + GetBaseURI() const + { + AssertIsOnMainThread(); + return mLoadInfo.mBaseURI; + } + + void + SetBaseURI(nsIURI* aBaseURI); + + nsIURI* + GetResolvedScriptURI() const + { + AssertIsOnMainThread(); + return mLoadInfo.mResolvedScriptURI; + } + + const nsString& + ServiceWorkerCacheName() const + { + MOZ_ASSERT(IsServiceWorker()); + AssertIsOnMainThread(); + return mLoadInfo.mServiceWorkerCacheName; + } + + const ChannelInfo& + GetChannelInfo() const + { + return mLoadInfo.mChannelInfo; + } + + void + SetChannelInfo(const ChannelInfo& aChannelInfo) + { + AssertIsOnMainThread(); + MOZ_ASSERT(!mLoadInfo.mChannelInfo.IsInitialized()); + MOZ_ASSERT(aChannelInfo.IsInitialized()); + mLoadInfo.mChannelInfo = aChannelInfo; + } + + void + InitChannelInfo(nsIChannel* aChannel) + { + mLoadInfo.mChannelInfo.InitFromChannel(aChannel); + } + + void + InitChannelInfo(const ChannelInfo& aChannelInfo) + { + mLoadInfo.mChannelInfo = aChannelInfo; + } + + // This is used to handle importScripts(). When the worker is first loaded + // and executed, it happens in a sync loop. At this point it sets + // mLoadingWorkerScript to true. importScripts() calls that occur during the + // execution run in nested sync loops and so this continues to return true, + // leading to these scripts being cached offline. + // mLoadingWorkerScript is set to false when the top level loop ends. + // importScripts() in function calls or event handlers are always fetched + // from the network. + bool + LoadScriptAsPartOfLoadingServiceWorkerScript() + { + MOZ_ASSERT(IsServiceWorker()); + return mLoadingWorkerScript; + } + + void + SetLoadingWorkerScript(bool aLoadingWorkerScript) + { + // any thread + MOZ_ASSERT(IsServiceWorker()); + mLoadingWorkerScript = aLoadingWorkerScript; + } + + TimeStamp CreationTimeStamp() const + { + return mCreationTimeStamp; + } + + DOMHighResTimeStamp CreationTime() const + { + return mCreationTimeHighRes; + } + + TimeStamp NowBaseTimeStamp() const + { + return mNowBaseTimeStamp; + } + + DOMHighResTimeStamp NowBaseTime() const + { + return mNowBaseTimeHighRes; + } + + nsIPrincipal* + GetPrincipal() const + { + AssertIsOnMainThread(); + return mLoadInfo.mPrincipal; + } + + nsILoadGroup* + GetLoadGroup() const + { + AssertIsOnMainThread(); + return mLoadInfo.mLoadGroup; + } + + // This method allows the principal to be retrieved off the main thread. + // Principals are main-thread objects so the caller must ensure that all + // access occurs on the main thread. + nsIPrincipal* + GetPrincipalDontAssertMainThread() const + { + return mLoadInfo.mPrincipal; + } + + void + SetPrincipal(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup); + + bool + UsesSystemPrincipal() const + { + return mLoadInfo.mPrincipalIsSystem; + } + + const PrincipalInfo& + GetPrincipalInfo() const + { + return *mLoadInfo.mPrincipalInfo; + } + + already_AddRefed<nsIChannel> + ForgetWorkerChannel() + { + AssertIsOnMainThread(); + return mLoadInfo.mChannel.forget(); + } + + nsIDocument* GetDocument() const; + + nsPIDOMWindowInner* + GetWindow() + { + AssertIsOnMainThread(); + return mLoadInfo.mWindow; + } + + nsIContentSecurityPolicy* + GetCSP() const + { + AssertIsOnMainThread(); + return mLoadInfo.mCSP; + } + + void + SetCSP(nsIContentSecurityPolicy* aCSP) + { + AssertIsOnMainThread(); + mLoadInfo.mCSP = aCSP; + } + + net::ReferrerPolicy + GetReferrerPolicy() const + { + return mLoadInfo.mReferrerPolicy; + } + + void + SetReferrerPolicy(net::ReferrerPolicy aReferrerPolicy) + { + mLoadInfo.mReferrerPolicy = aReferrerPolicy; + } + + bool + IsEvalAllowed() const + { + return mLoadInfo.mEvalAllowed; + } + + void + SetEvalAllowed(bool aEvalAllowed) + { + mLoadInfo.mEvalAllowed = aEvalAllowed; + } + + bool + GetReportCSPViolations() const + { + return mLoadInfo.mReportCSPViolations; + } + + void + SetReportCSPViolations(bool aReport) + { + mLoadInfo.mReportCSPViolations = aReport; + } + + bool + XHRParamsAllowed() const + { + return mLoadInfo.mXHRParamsAllowed; + } + + void + SetXHRParamsAllowed(bool aAllowed) + { + mLoadInfo.mXHRParamsAllowed = aAllowed; + } + + LocationInfo& + GetLocationInfo() + { + return mLocationInfo; + } + + void + CopyJSSettings(JSSettings& aSettings) + { + mozilla::MutexAutoLock lock(mMutex); + aSettings = mJSSettings; + } + + void + CopyJSCompartmentOptions(JS::CompartmentOptions& aOptions) + { + mozilla::MutexAutoLock lock(mMutex); + aOptions = IsChromeWorker() ? mJSSettings.chrome.compartmentOptions + : mJSSettings.content.compartmentOptions; + } + + // The ability to be a chrome worker is orthogonal to the type of + // worker [Dedicated|Shared|Service]. + bool + IsChromeWorker() const + { + return mIsChromeWorker; + } + + WorkerType + Type() const + { + return mWorkerType; + } + + bool + IsDedicatedWorker() const + { + return mWorkerType == WorkerTypeDedicated; + } + + bool + IsSharedWorker() const + { + return mWorkerType == WorkerTypeShared; + } + + bool + IsServiceWorker() const + { + return mWorkerType == WorkerTypeService; + } + + nsContentPolicyType + ContentPolicyType() const + { + return ContentPolicyType(mWorkerType); + } + + static nsContentPolicyType + ContentPolicyType(WorkerType aWorkerType) + { + switch (aWorkerType) { + case WorkerTypeDedicated: + return nsIContentPolicy::TYPE_INTERNAL_WORKER; + case WorkerTypeShared: + return nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER; + case WorkerTypeService: + return nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER; + default: + MOZ_ASSERT_UNREACHABLE("Invalid worker type"); + return nsIContentPolicy::TYPE_INVALID; + } + } + + const nsCString& + WorkerName() const + { + MOZ_ASSERT(IsServiceWorker() || IsSharedWorker()); + return mWorkerName; + } + + bool + IsStorageAllowed() const + { + return mLoadInfo.mStorageAllowed; + } + + const PrincipalOriginAttributes& + GetOriginAttributes() const + { + return mLoadInfo.mOriginAttributes; + } + + // Determine if the SW testing per-window flag is set by devtools + bool + ServiceWorkersTestingInWindow() const + { + return mLoadInfo.mServiceWorkersTestingInWindow; + } + + void + GetAllSharedWorkers(nsTArray<RefPtr<SharedWorker>>& aSharedWorkers); + + void + CloseSharedWorkersForWindow(nsPIDOMWindowInner* aWindow); + + void + CloseAllSharedWorkers(); + + void + UpdateOverridenLoadGroup(nsILoadGroup* aBaseLoadGroup); + + already_AddRefed<nsIRunnable> + StealLoadFailedAsyncRunnable() + { + return mLoadInfo.mLoadFailedAsyncRunnable.forget(); + } + + void + FlushReportsToSharedWorkers(nsIConsoleReportCollector* aReporter); + + IMPL_EVENT_HANDLER(message) + IMPL_EVENT_HANDLER(error) + + // Check whether this worker is a secure context. For use from the parent + // thread only; the canonical "is secure context" boolean is stored on the + // compartment of the worker global. The only reason we don't + // AssertIsOnParentThread() here is so we can assert that this value matches + // the one on the compartment, which has to be done from the worker thread. + bool IsSecureContext() const + { + return mIsSecureContext; + } + +#ifdef DEBUG + void + AssertIsOnParentThread() const; + + void + AssertInnerWindowIsCorrect() const; +#else + void + AssertIsOnParentThread() const + { } + + void + AssertInnerWindowIsCorrect() const + { } +#endif +}; + +class WorkerDebugger : public nsIWorkerDebugger { + friend class ::ReportDebuggerErrorRunnable; + friend class ::PostDebuggerMessageRunnable; + + WorkerPrivate* mWorkerPrivate; + bool mIsInitialized; + nsTArray<nsCOMPtr<nsIWorkerDebuggerListener>> mListeners; + +public: + explicit WorkerDebugger(WorkerPrivate* aWorkerPrivate); + + NS_DECL_ISUPPORTS + NS_DECL_NSIWORKERDEBUGGER + + void + AssertIsOnParentThread(); + + void + Close(); + + void + PostMessageToDebugger(const nsAString& aMessage); + + void + ReportErrorToDebugger(const nsAString& aFilename, uint32_t aLineno, + const nsAString& aMessage); + +private: + virtual + ~WorkerDebugger(); + + void + PostMessageToDebuggerOnMainThread(const nsAString& aMessage); + + void + ReportErrorToDebuggerOnMainThread(const nsAString& aFilename, + uint32_t aLineno, + const nsAString& aMessage); +}; + +class WorkerPrivate : public WorkerPrivateParent<WorkerPrivate> +{ + friend class WorkerHolder; + friend class WorkerPrivateParent<WorkerPrivate>; + typedef WorkerPrivateParent<WorkerPrivate> ParentType; + friend class AutoSyncLoopHolder; + + struct TimeoutInfo; + + class MemoryReporter; + friend class MemoryReporter; + + friend class WorkerThread; + + enum GCTimerMode + { + PeriodicTimer = 0, + IdleTimer, + NoTimer + }; + + bool mDebuggerRegistered; + WorkerDebugger* mDebugger; + + Queue<WorkerControlRunnable*, 4> mControlQueue; + Queue<WorkerRunnable*, 4> mDebuggerQueue; + + // Touched on multiple threads, protected with mMutex. + JSContext* mJSContext; + RefPtr<WorkerCrossThreadDispatcher> mCrossThreadDispatcher; + nsTArray<nsCOMPtr<nsIRunnable>> mUndispatchedRunnablesForSyncLoop; + RefPtr<WorkerThread> mThread; + PRThread* mPRThread; + + // Things touched on worker thread only. + RefPtr<WorkerGlobalScope> mScope; + RefPtr<WorkerDebuggerGlobalScope> mDebuggerScope; + nsTArray<ParentType*> mChildWorkers; + nsTObserverArray<WorkerHolder*> mHolders; + nsTArray<nsAutoPtr<TimeoutInfo>> mTimeouts; + uint32_t mDebuggerEventLoopLevel; + RefPtr<ThrottledEventQueue> mMainThreadThrottledEventQueue; + nsCOMPtr<nsIEventTarget> mMainThreadEventTarget; + + struct SyncLoopInfo + { + explicit SyncLoopInfo(EventTarget* aEventTarget); + + RefPtr<EventTarget> mEventTarget; + bool mCompleted; + bool mResult; +#ifdef DEBUG + bool mHasRun; +#endif + }; + + // This is only modified on the worker thread, but in DEBUG builds + // AssertValidSyncLoop function iterates it on other threads. Therefore + // modifications are done with mMutex held *only* in DEBUG builds. + nsTArray<nsAutoPtr<SyncLoopInfo>> mSyncLoopStack; + + nsCOMPtr<nsITimer> mTimer; + nsCOMPtr<nsITimerCallback> mTimerRunnable; + + nsCOMPtr<nsITimer> mGCTimer; + nsCOMPtr<nsIEventTarget> mPeriodicGCTimerTarget; + nsCOMPtr<nsIEventTarget> mIdleGCTimerTarget; + + RefPtr<MemoryReporter> mMemoryReporter; + + // fired on the main thread if the worker script fails to load + nsCOMPtr<nsIRunnable> mLoadFailedRunnable; + + JS::UniqueChars mDefaultLocale; // nulled during worker JSContext init + TimeStamp mKillTime; + uint32_t mErrorHandlerRecursionCount; + uint32_t mNextTimeoutId; + Status mStatus; + bool mFrozen; + bool mTimerRunning; + bool mRunningExpiredTimeouts; + bool mPendingEventQueueClearing; + bool mCancelAllPendingRunnables; + bool mPeriodicGCTimerRunning; + bool mIdleGCTimerRunning; + bool mWorkerScriptExecutedSuccessfully; + bool mPreferences[WORKERPREF_COUNT]; + bool mOnLine; + +protected: + ~WorkerPrivate(); + +public: + static already_AddRefed<WorkerPrivate> + Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL, + ErrorResult& aRv); + + static already_AddRefed<WorkerPrivate> + Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL, + bool aIsChromeWorker, WorkerType aWorkerType, + const nsACString& aSharedWorkerName, + WorkerLoadInfo* aLoadInfo, ErrorResult& aRv); + + static already_AddRefed<WorkerPrivate> + Constructor(JSContext* aCx, const nsAString& aScriptURL, bool aIsChromeWorker, + WorkerType aWorkerType, const nsACString& aSharedWorkerName, + WorkerLoadInfo* aLoadInfo, ErrorResult& aRv); + + static bool + WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */); + + enum LoadGroupBehavior + { + InheritLoadGroup, + OverrideLoadGroup + }; + + static nsresult + GetLoadInfo(JSContext* aCx, nsPIDOMWindowInner* aWindow, + WorkerPrivate* aParent, + const nsAString& aScriptURL, bool aIsChromeWorker, + LoadGroupBehavior aLoadGroupBehavior, WorkerType aWorkerType, + WorkerLoadInfo* aLoadInfo); + + static void + OverrideLoadInfoLoadGroup(WorkerLoadInfo& aLoadInfo); + + bool + IsDebuggerRegistered() + { + AssertIsOnMainThread(); + + // No need to lock here since this is only ever modified by the same thread. + return mDebuggerRegistered; + } + + void + SetIsDebuggerRegistered(bool aDebuggerRegistered) + { + AssertIsOnMainThread(); + + MutexAutoLock lock(mMutex); + + MOZ_ASSERT(mDebuggerRegistered != aDebuggerRegistered); + mDebuggerRegistered = aDebuggerRegistered; + + mCondVar.Notify(); + } + + void + WaitForIsDebuggerRegistered(bool aDebuggerRegistered) + { + AssertIsOnParentThread(); + + MOZ_ASSERT(!NS_IsMainThread()); + + MutexAutoLock lock(mMutex); + + while (mDebuggerRegistered != aDebuggerRegistered) { + mCondVar.Wait(); + } + } + + WorkerDebugger* + Debugger() const + { + AssertIsOnMainThread(); + + MOZ_ASSERT(mDebugger); + return mDebugger; + } + + void + SetDebugger(WorkerDebugger* aDebugger) + { + AssertIsOnMainThread(); + + MOZ_ASSERT(mDebugger != aDebugger); + mDebugger = aDebugger; + } + + JS::UniqueChars + AdoptDefaultLocale() + { + MOZ_ASSERT(mDefaultLocale, + "the default locale must have been successfully set for anyone " + "to be trying to adopt it"); + return Move(mDefaultLocale); + } + + void + DoRunLoop(JSContext* aCx); + + bool + InterruptCallback(JSContext* aCx); + + nsresult + IsOnCurrentThread(bool* aIsOnCurrentThread); + + bool + CloseInternal(JSContext* aCx) + { + AssertIsOnWorkerThread(); + return NotifyInternal(aCx, Closing); + } + + bool + FreezeInternal(); + + bool + ThawInternal(); + + void + TraverseTimeouts(nsCycleCollectionTraversalCallback& aCallback); + + void + UnlinkTimeouts(); + + bool + ModifyBusyCountFromWorker(bool aIncrease); + + bool + AddChildWorker(ParentType* aChildWorker); + + void + RemoveChildWorker(ParentType* aChildWorker); + + void + PostMessageToParent(JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) + { + PostMessageToParentInternal(aCx, aMessage, aTransferable, aRv); + } + + void + PostMessageToParentMessagePort( + JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + + void + EnterDebuggerEventLoop(); + + void + LeaveDebuggerEventLoop(); + + void + PostMessageToDebugger(const nsAString& aMessage); + + void + SetDebuggerImmediate(Function& aHandler, ErrorResult& aRv); + + void + ReportErrorToDebugger(const nsAString& aFilename, uint32_t aLineno, + const nsAString& aMessage); + + bool + NotifyInternal(JSContext* aCx, Status aStatus); + + void + ReportError(JSContext* aCx, JS::ConstUTF8CharsZ aToStringResult, + JSErrorReport* aReport); + + static void + ReportErrorToConsole(const char* aMessage); + + int32_t + SetTimeout(JSContext* aCx, nsIScriptTimeoutHandler* aHandler, + int32_t aTimeout, bool aIsInterval, + ErrorResult& aRv); + + void + ClearTimeout(int32_t aId); + + bool + RunExpiredTimeouts(JSContext* aCx); + + bool + RescheduleTimeoutTimer(JSContext* aCx); + + void + UpdateContextOptionsInternal(JSContext* aCx, const JS::ContextOptions& aContextOptions); + + void + UpdateLanguagesInternal(const nsTArray<nsString>& aLanguages); + + void + UpdatePreferenceInternal(WorkerPreference aPref, bool aValue); + + void + UpdateJSWorkerMemoryParameterInternal(JSContext* aCx, JSGCParamKey key, uint32_t aValue); + + enum WorkerRanOrNot { + WorkerNeverRan = 0, + WorkerRan + }; + + void + ScheduleDeletion(WorkerRanOrNot aRanOrNot); + + bool + CollectRuntimeStats(JS::RuntimeStats* aRtStats, bool aAnonymize); + +#ifdef JS_GC_ZEAL + void + UpdateGCZealInternal(JSContext* aCx, uint8_t aGCZeal, uint32_t aFrequency); +#endif + + void + GarbageCollectInternal(JSContext* aCx, bool aShrinking, + bool aCollectChildren); + + void + CycleCollectInternal(bool aCollectChildren); + + void + OfflineStatusChangeEventInternal(bool aIsOffline); + + void + MemoryPressureInternal(); + + JSContext* + GetJSContext() const + { + AssertIsOnWorkerThread(); + return mJSContext; + } + + WorkerGlobalScope* + GlobalScope() const + { + AssertIsOnWorkerThread(); + return mScope; + } + + WorkerDebuggerGlobalScope* + DebuggerGlobalScope() const + { + AssertIsOnWorkerThread(); + return mDebuggerScope; + } + + void + SetThread(WorkerThread* aThread); + + void + AssertIsOnWorkerThread() const +#ifdef DEBUG + ; +#else + { } +#endif + + WorkerCrossThreadDispatcher* + GetCrossThreadDispatcher(); + + // This may block! + void + BeginCTypesCall(); + + // This may block! + void + EndCTypesCall(); + + void + BeginCTypesCallback() + { + // If a callback is beginning then we need to do the exact same thing as + // when a ctypes call ends. + EndCTypesCall(); + } + + void + EndCTypesCallback() + { + // If a callback is ending then we need to do the exact same thing as + // when a ctypes call begins. + BeginCTypesCall(); + } + + bool + ConnectMessagePort(JSContext* aCx, MessagePortIdentifier& aIdentifier); + + WorkerGlobalScope* + GetOrCreateGlobalScope(JSContext* aCx); + + WorkerDebuggerGlobalScope* + CreateDebuggerGlobalScope(JSContext* aCx); + + bool + RegisterBindings(JSContext* aCx, JS::Handle<JSObject*> aGlobal); + + bool + RegisterDebuggerBindings(JSContext* aCx, JS::Handle<JSObject*> aGlobal); + +#define WORKER_SIMPLE_PREF(name, getter, NAME) \ + bool \ + getter() const \ + { \ + AssertIsOnWorkerThread(); \ + return mPreferences[WORKERPREF_##NAME]; \ + } +#define WORKER_PREF(name, callback) +#include "WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + + bool + OnLine() const + { + AssertIsOnWorkerThread(); + return mOnLine; + } + + void + StopSyncLoop(nsIEventTarget* aSyncLoopTarget, bool aResult); + + bool + AllPendingRunnablesShouldBeCanceled() const + { + return mCancelAllPendingRunnables; + } + + void + ClearMainEventQueue(WorkerRanOrNot aRanOrNot); + + void + ClearDebuggerEventQueue(); + + void + OnProcessNextEvent(); + + void + AfterProcessNextEvent(); + + void + AssertValidSyncLoop(nsIEventTarget* aSyncLoopTarget) +#ifdef DEBUG + ; +#else + { } +#endif + + void + SetWorkerScriptExecutedSuccessfully() + { + AssertIsOnWorkerThread(); + // Should only be called once! + MOZ_ASSERT(!mWorkerScriptExecutedSuccessfully); + mWorkerScriptExecutedSuccessfully = true; + } + + // Only valid after CompileScriptRunnable has finished running! + bool + WorkerScriptExecutedSuccessfully() const + { + AssertIsOnWorkerThread(); + return mWorkerScriptExecutedSuccessfully; + } + + void + MaybeDispatchLoadFailedRunnable(); + + // Get the event target to use when dispatching to the main thread + // from this Worker thread. This may be the main thread itself or + // a ThrottledEventQueue to the main thread. + nsIEventTarget* + MainThreadEventTarget(); + + nsresult + DispatchToMainThread(nsIRunnable* aRunnable, + uint32_t aFlags = NS_DISPATCH_NORMAL); + + nsresult + DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable, + uint32_t aFlags = NS_DISPATCH_NORMAL); + +private: + WorkerPrivate(WorkerPrivate* aParent, + const nsAString& aScriptURL, bool aIsChromeWorker, + WorkerType aWorkerType, const nsACString& aSharedWorkerName, + WorkerLoadInfo& aLoadInfo); + + bool + MayContinueRunning() + { + AssertIsOnWorkerThread(); + + Status status; + { + MutexAutoLock lock(mMutex); + status = mStatus; + } + + if (status < Terminating) { + return true; + } + + return false; + } + + void + CancelAllTimeouts(); + + enum class ProcessAllControlRunnablesResult + { + // We did not process anything. + Nothing, + // We did process something, states may have changed, but we can keep + // executing script. + MayContinue, + // We did process something, and should not continue executing script. + Abort + }; + + ProcessAllControlRunnablesResult + ProcessAllControlRunnables() + { + MutexAutoLock lock(mMutex); + return ProcessAllControlRunnablesLocked(); + } + + ProcessAllControlRunnablesResult + ProcessAllControlRunnablesLocked(); + + void + EnableMemoryReporter(); + + void + DisableMemoryReporter(); + + void + WaitForWorkerEvents(PRIntervalTime interval = PR_INTERVAL_NO_TIMEOUT); + + void + PostMessageToParentInternal(JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + + void + GetAllPreferences(bool aPreferences[WORKERPREF_COUNT]) const + { + AssertIsOnWorkerThread(); + memcpy(aPreferences, mPreferences, WORKERPREF_COUNT * sizeof(bool)); + } + + already_AddRefed<nsIEventTarget> + CreateNewSyncLoop(); + + bool + RunCurrentSyncLoop(); + + bool + DestroySyncLoop(uint32_t aLoopIndex, nsIThreadInternal* aThread = nullptr); + + void + InitializeGCTimers(); + + void + SetGCTimerMode(GCTimerMode aMode); + + void + ShutdownGCTimers(); + + bool + AddHolder(WorkerHolder* aHolder, Status aFailStatus); + + void + RemoveHolder(WorkerHolder* aHolder); + + void + NotifyHolders(JSContext* aCx, Status aStatus); + + bool + HasActiveHolders() + { + return !(mChildWorkers.IsEmpty() && mTimeouts.IsEmpty() && + mHolders.IsEmpty()); + } +}; + +// This class is only used to trick the DOM bindings. We never create +// instances of it, and static_casting to it is fine since it doesn't add +// anything to WorkerPrivate. +class ChromeWorkerPrivate : public WorkerPrivate +{ +public: + static already_AddRefed<ChromeWorkerPrivate> + Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL, + ErrorResult& rv); + + static bool + WorkerAvailable(JSContext* aCx, JSObject* /* unused */); + +private: + ChromeWorkerPrivate() = delete; + ChromeWorkerPrivate(const ChromeWorkerPrivate& aRHS) = delete; + ChromeWorkerPrivate& operator =(const ChromeWorkerPrivate& aRHS) = delete; +}; + +WorkerPrivate* +GetWorkerPrivateFromContext(JSContext* aCx); + +WorkerPrivate* +GetCurrentThreadWorkerPrivate(); + +bool +IsCurrentThreadRunningChromeWorker(); + +JSContext* +GetCurrentThreadJSContext(); + +JSObject* +GetCurrentThreadWorkerGlobal(); + +class AutoSyncLoopHolder +{ + WorkerPrivate* mWorkerPrivate; + nsCOMPtr<nsIEventTarget> mTarget; + uint32_t mIndex; + +public: + explicit AutoSyncLoopHolder(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) + , mTarget(aWorkerPrivate->CreateNewSyncLoop()) + , mIndex(aWorkerPrivate->mSyncLoopStack.Length() - 1) + { + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + ~AutoSyncLoopHolder() + { + if (mWorkerPrivate) { + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate->StopSyncLoop(mTarget, false); + mWorkerPrivate->DestroySyncLoop(mIndex); + } + } + + bool + Run() + { + WorkerPrivate* workerPrivate = mWorkerPrivate; + mWorkerPrivate = nullptr; + + workerPrivate->AssertIsOnWorkerThread(); + + return workerPrivate->RunCurrentSyncLoop(); + } + + nsIEventTarget* + EventTarget() const + { + return mTarget; + } +}; + +class TimerThreadEventTarget final : public nsIEventTarget +{ + ~TimerThreadEventTarget(); + + WorkerPrivate* mWorkerPrivate; + RefPtr<WorkerRunnable> mWorkerRunnable; +public: + NS_DECL_THREADSAFE_ISUPPORTS + + TimerThreadEventTarget(WorkerPrivate* aWorkerPrivate, + WorkerRunnable* aWorkerRunnable); + +protected: + NS_IMETHOD + DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) override; + + + NS_IMETHOD + Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) override; + + NS_IMETHOD + DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) override; + + NS_IMETHOD + IsOnCurrentThread(bool* aIsOnCurrentThread) override; +}; + +END_WORKERS_NAMESPACE + +#endif /* mozilla_dom_workers_workerprivate_h__ */ diff --git a/dom/workers/WorkerRunnable.cpp b/dom/workers/WorkerRunnable.cpp new file mode 100644 index 000000000..1e16d7254 --- /dev/null +++ b/dom/workers/WorkerRunnable.cpp @@ -0,0 +1,777 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerRunnable.h" + +#include "nsGlobalWindow.h" +#include "nsIEventTarget.h" +#include "nsIGlobalObject.h" +#include "nsIRunnable.h" +#include "nsThreadUtils.h" + +#include "mozilla/DebugOnly.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/Telemetry.h" + +#include "js/RootingAPI.h" +#include "js/Value.h" + +#include "WorkerPrivate.h" +#include "WorkerScope.h" + +USING_WORKERS_NAMESPACE + +namespace { + +const nsIID kWorkerRunnableIID = { + 0x320cc0b5, 0xef12, 0x4084, { 0x88, 0x6e, 0xca, 0x6a, 0x81, 0xe4, 0x1d, 0x68 } +}; + +} // namespace + +#ifdef DEBUG +WorkerRunnable::WorkerRunnable(WorkerPrivate* aWorkerPrivate, + TargetAndBusyBehavior aBehavior) +: mWorkerPrivate(aWorkerPrivate), mBehavior(aBehavior), mCanceled(0), + mCallingCancelWithinRun(false) +{ + MOZ_ASSERT(aWorkerPrivate); +} +#endif + +bool +WorkerRunnable::IsDebuggerRunnable() const +{ + return false; +} + +nsIGlobalObject* +WorkerRunnable::DefaultGlobalObject() const +{ + if (IsDebuggerRunnable()) { + return mWorkerPrivate->DebuggerGlobalScope(); + } else { + return mWorkerPrivate->GlobalScope(); + } +} + +bool +WorkerRunnable::PreDispatch(WorkerPrivate* aWorkerPrivate) +{ +#ifdef DEBUG + MOZ_ASSERT(aWorkerPrivate); + + switch (mBehavior) { + case ParentThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnWorkerThread(); + break; + + case WorkerThreadModifyBusyCount: + case WorkerThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnParentThread(); + break; + + default: + MOZ_ASSERT_UNREACHABLE("Unknown behavior!"); + } +#endif + + if (mBehavior == WorkerThreadModifyBusyCount) { + return aWorkerPrivate->ModifyBusyCount(true); + } + + return true; +} + +bool +WorkerRunnable::Dispatch() +{ + bool ok = PreDispatch(mWorkerPrivate); + if (ok) { + ok = DispatchInternal(); + } + PostDispatch(mWorkerPrivate, ok); + return ok; +} + +bool +WorkerRunnable::DispatchInternal() +{ + RefPtr<WorkerRunnable> runnable(this); + + if (mBehavior == WorkerThreadModifyBusyCount || + mBehavior == WorkerThreadUnchangedBusyCount) { + if (IsDebuggerRunnable()) { + return NS_SUCCEEDED(mWorkerPrivate->DispatchDebuggerRunnable(runnable.forget())); + } else { + return NS_SUCCEEDED(mWorkerPrivate->Dispatch(runnable.forget())); + } + } + + MOZ_ASSERT(mBehavior == ParentThreadUnchangedBusyCount); + + if (WorkerPrivate* parent = mWorkerPrivate->GetParent()) { + return NS_SUCCEEDED(parent->Dispatch(runnable.forget())); + } + + return NS_SUCCEEDED(mWorkerPrivate->DispatchToMainThread(runnable.forget())); +} + +void +WorkerRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) +{ + MOZ_ASSERT(aWorkerPrivate); + +#ifdef DEBUG + switch (mBehavior) { + case ParentThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnWorkerThread(); + break; + + case WorkerThreadModifyBusyCount: + aWorkerPrivate->AssertIsOnParentThread(); + break; + + case WorkerThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnParentThread(); + break; + + default: + MOZ_ASSERT_UNREACHABLE("Unknown behavior!"); + } +#endif + + if (!aDispatchResult) { + if (mBehavior == WorkerThreadModifyBusyCount) { + aWorkerPrivate->ModifyBusyCount(false); + } + } +} + +bool +WorkerRunnable::PreRun(WorkerPrivate* aWorkerPrivate) +{ + return true; +} + +void +WorkerRunnable::PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, + bool aRunResult) +{ + MOZ_ASSERT(aCx); + MOZ_ASSERT(aWorkerPrivate); + +#ifdef DEBUG + switch (mBehavior) { + case ParentThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnParentThread(); + break; + + case WorkerThreadModifyBusyCount: + aWorkerPrivate->AssertIsOnWorkerThread(); + break; + + case WorkerThreadUnchangedBusyCount: + aWorkerPrivate->AssertIsOnWorkerThread(); + break; + + default: + MOZ_ASSERT_UNREACHABLE("Unknown behavior!"); + } +#endif + + if (mBehavior == WorkerThreadModifyBusyCount) { + aWorkerPrivate->ModifyBusyCountFromWorker(false); + } +} + +// static +WorkerRunnable* +WorkerRunnable::FromRunnable(nsIRunnable* aRunnable) +{ + MOZ_ASSERT(aRunnable); + + WorkerRunnable* runnable; + nsresult rv = aRunnable->QueryInterface(kWorkerRunnableIID, + reinterpret_cast<void**>(&runnable)); + if (NS_FAILED(rv)) { + return nullptr; + } + + MOZ_ASSERT(runnable); + return runnable; +} + +NS_IMPL_ADDREF(WorkerRunnable) +NS_IMPL_RELEASE(WorkerRunnable) + +NS_INTERFACE_MAP_BEGIN(WorkerRunnable) + NS_INTERFACE_MAP_ENTRY(nsIRunnable) + NS_INTERFACE_MAP_ENTRY(nsICancelableRunnable) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRunnable) + // kWorkerRunnableIID is special in that it does not AddRef its result. + if (aIID.Equals(kWorkerRunnableIID)) { + *aInstancePtr = this; + return NS_OK; + } + else +NS_INTERFACE_MAP_END + +NS_IMETHODIMP +WorkerRunnable::Run() +{ + bool targetIsWorkerThread = mBehavior == WorkerThreadModifyBusyCount || + mBehavior == WorkerThreadUnchangedBusyCount; + +#ifdef DEBUG + MOZ_ASSERT_IF(mCallingCancelWithinRun, targetIsWorkerThread); + if (targetIsWorkerThread) { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + else { + MOZ_ASSERT(mBehavior == ParentThreadUnchangedBusyCount); + mWorkerPrivate->AssertIsOnParentThread(); + } +#endif + + if (IsCanceled() && !mCallingCancelWithinRun) { + return NS_OK; + } + + if (targetIsWorkerThread && + mWorkerPrivate->AllPendingRunnablesShouldBeCanceled() && + !IsCanceled() && !mCallingCancelWithinRun) { + + // Prevent recursion. + mCallingCancelWithinRun = true; + + Cancel(); + + MOZ_ASSERT(mCallingCancelWithinRun); + mCallingCancelWithinRun = false; + + MOZ_ASSERT(IsCanceled(), "Subclass Cancel() didn't set IsCanceled()!"); + + if (mBehavior == WorkerThreadModifyBusyCount) { + mWorkerPrivate->ModifyBusyCountFromWorker(false); + } + + return NS_OK; + } + + bool result = PreRun(mWorkerPrivate); + if (!result) { + MOZ_ASSERT(targetIsWorkerThread, + "The only PreRun implementation that can fail is " + "ScriptExecutorRunnable"); + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!JS_IsExceptionPending(mWorkerPrivate->GetJSContext())); + // We can't enter a useful compartment on the JSContext here; just pass it + // in as-is. + PostRun(mWorkerPrivate->GetJSContext(), mWorkerPrivate, false); + return NS_ERROR_FAILURE; + } + + // Track down the appropriate global, if any, to use for the AutoEntryScript. + nsCOMPtr<nsIGlobalObject> globalObject; + bool isMainThread = !targetIsWorkerThread && !mWorkerPrivate->GetParent(); + MOZ_ASSERT(isMainThread == NS_IsMainThread()); + RefPtr<WorkerPrivate> kungFuDeathGrip; + if (targetIsWorkerThread) { + JSContext* cx = GetCurrentThreadJSContext(); + if (NS_WARN_IF(!cx)) { + return NS_ERROR_FAILURE; + } + + JSObject* global = JS::CurrentGlobalOrNull(cx); + if (global) { + globalObject = xpc::NativeGlobal(global); + } else { + globalObject = DefaultGlobalObject(); + } + + // We may still not have a globalObject here: in the case of + // CompileScriptRunnable, we don't actually create the global object until + // we have the script data, which happens in a syncloop under + // CompileScriptRunnable::WorkerRun, so we can't assert that it got created + // in the PreRun call above. + } else { + kungFuDeathGrip = mWorkerPrivate; + if (isMainThread) { + globalObject = nsGlobalWindow::Cast(mWorkerPrivate->GetWindow()); + } else { + globalObject = mWorkerPrivate->GetParent()->GlobalScope(); + } + } + + // We might run script as part of WorkerRun, so we need an AutoEntryScript. + // This is part of the HTML spec for workers at: + // http://www.whatwg.org/specs/web-apps/current-work/#run-a-worker + // If we don't have a globalObject we have to use an AutoJSAPI instead, but + // this is OK as we won't be running script in these circumstances. + Maybe<mozilla::dom::AutoJSAPI> maybeJSAPI; + Maybe<mozilla::dom::AutoEntryScript> aes; + JSContext* cx; + AutoJSAPI* jsapi; + if (globalObject) { + aes.emplace(globalObject, "Worker runnable", isMainThread); + jsapi = aes.ptr(); + cx = aes->cx(); + } else { + maybeJSAPI.emplace(); + maybeJSAPI->Init(); + jsapi = maybeJSAPI.ptr(); + cx = jsapi->cx(); + } + + // Note that we can't assert anything about mWorkerPrivate->GetWrapper() + // existing, since it may in fact have been GCed (and we may be one of the + // runnables cleaning up the worker as a result). + + // If we are on the parent thread and that thread is not the main thread, + // then we must be a dedicated worker (because there are no + // Shared/ServiceWorkers whose parent is itself a worker) and then we + // definitely have a globalObject. If it _is_ the main thread, globalObject + // can be null for workers started from JSMs or other non-window contexts, + // sadly. + MOZ_ASSERT_IF(!targetIsWorkerThread && !isMainThread, + mWorkerPrivate->IsDedicatedWorker() && globalObject); + + // If we're on the parent thread we might be in a null compartment in the + // situation described above when globalObject is null. Make sure to enter + // the compartment of the worker's reflector if there is one. There might + // not be one if we're just starting to compile the script for this worker. + Maybe<JSAutoCompartment> ac; + if (!targetIsWorkerThread && mWorkerPrivate->GetWrapper()) { + // If we're on the parent thread and have a reflector and a globalObject, + // then the compartments of cx, globalObject, and the worker's reflector + // should all match. + MOZ_ASSERT_IF(globalObject, + js::GetObjectCompartment(mWorkerPrivate->GetWrapper()) == + js::GetContextCompartment(cx)); + MOZ_ASSERT_IF(globalObject, + js::GetObjectCompartment(mWorkerPrivate->GetWrapper()) == + js::GetObjectCompartment(globalObject->GetGlobalJSObject())); + + // If we're on the parent thread and have a reflector, then our + // JSContext had better be either in the null compartment (and hence + // have no globalObject) or in the compartment of our reflector. + MOZ_ASSERT(!js::GetContextCompartment(cx) || + js::GetObjectCompartment(mWorkerPrivate->GetWrapper()) == + js::GetContextCompartment(cx), + "Must either be in the null compartment or in our reflector " + "compartment"); + + ac.emplace(cx, mWorkerPrivate->GetWrapper()); + } + + MOZ_ASSERT(!jsapi->HasException()); + result = WorkerRun(cx, mWorkerPrivate); + MOZ_ASSERT_IF(result, !jsapi->HasException()); + jsapi->ReportException(); + + // We can't even assert that this didn't create our global, since in the case + // of CompileScriptRunnable it _does_. + + // It would be nice to avoid passing a JSContext to PostRun, but in the case + // of ScriptExecutorRunnable we need to know the current compartment on the + // JSContext (the one we set up based on the global returned from PreRun) so + // that we can sanely do exception reporting. In particular, we want to make + // sure that we do our JS_SetPendingException while still in that compartment, + // because otherwise we might end up trying to create a cross-compartment + // wrapper when we try to move the JS exception from our runnable's + // ErrorResult to the JSContext, and that's not desirable in this case. + // + // We _could_ skip passing a JSContext here and then in + // ScriptExecutorRunnable::PostRun end up grabbing it from the WorkerPrivate + // and looking at its current compartment. But that seems like slightly weird + // action-at-a-distance... + // + // In any case, we do NOT try to change the compartment on the JSContext at + // this point; in the one case in which we could do that + // (CompileScriptRunnable) it actually doesn't matter which compartment we're + // in for PostRun. + PostRun(cx, mWorkerPrivate, result); + MOZ_ASSERT(!jsapi->HasException()); + + return result ? NS_OK : NS_ERROR_FAILURE; +} + +nsresult +WorkerRunnable::Cancel() +{ + uint32_t canceledCount = ++mCanceled; + + MOZ_ASSERT(canceledCount, "Cancel() overflow!"); + + // The docs say that Cancel() should not be called more than once and that we + // should throw NS_ERROR_UNEXPECTED if it is. + return (canceledCount == 1) ? NS_OK : NS_ERROR_UNEXPECTED; +} + +void +WorkerDebuggerRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) +{ +} + +WorkerSyncRunnable::WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, + nsIEventTarget* aSyncLoopTarget) +: WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mSyncLoopTarget(aSyncLoopTarget) +{ +#ifdef DEBUG + if (mSyncLoopTarget) { + mWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget); + } +#endif +} + +WorkerSyncRunnable::WorkerSyncRunnable( + WorkerPrivate* aWorkerPrivate, + already_AddRefed<nsIEventTarget>&& aSyncLoopTarget) +: WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount), + mSyncLoopTarget(aSyncLoopTarget) +{ +#ifdef DEBUG + if (mSyncLoopTarget) { + mWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget); + } +#endif +} + +WorkerSyncRunnable::~WorkerSyncRunnable() +{ +} + +bool +WorkerSyncRunnable::DispatchInternal() +{ + if (mSyncLoopTarget) { + RefPtr<WorkerSyncRunnable> runnable(this); + return NS_SUCCEEDED(mSyncLoopTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL)); + } + + return WorkerRunnable::DispatchInternal(); +} + +void +MainThreadWorkerSyncRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) +{ +} + +MainThreadStopSyncLoopRunnable::MainThreadStopSyncLoopRunnable( + WorkerPrivate* aWorkerPrivate, + already_AddRefed<nsIEventTarget>&& aSyncLoopTarget, + bool aResult) +: WorkerSyncRunnable(aWorkerPrivate, Move(aSyncLoopTarget)), mResult(aResult) +{ + AssertIsOnMainThread(); +#ifdef DEBUG + mWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget); +#endif +} + +nsresult +MainThreadStopSyncLoopRunnable::Cancel() +{ + nsresult rv = Run(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Run() failed"); + + nsresult rv2 = WorkerSyncRunnable::Cancel(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2), "Cancel() failed"); + + return NS_FAILED(rv) ? rv : rv2; +} + +bool +MainThreadStopSyncLoopRunnable::WorkerRun(JSContext* aCx, + WorkerPrivate* aWorkerPrivate) +{ + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mSyncLoopTarget); + + nsCOMPtr<nsIEventTarget> syncLoopTarget; + mSyncLoopTarget.swap(syncLoopTarget); + + aWorkerPrivate->StopSyncLoop(syncLoopTarget, mResult); + return true; +} + +bool +MainThreadStopSyncLoopRunnable::DispatchInternal() +{ + MOZ_ASSERT(mSyncLoopTarget); + + RefPtr<MainThreadStopSyncLoopRunnable> runnable(this); + return NS_SUCCEEDED(mSyncLoopTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL)); +} + +void +MainThreadStopSyncLoopRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) +{ +} + +#ifdef DEBUG +WorkerControlRunnable::WorkerControlRunnable(WorkerPrivate* aWorkerPrivate, + TargetAndBusyBehavior aBehavior) +: WorkerRunnable(aWorkerPrivate, aBehavior) +{ + MOZ_ASSERT(aWorkerPrivate); + MOZ_ASSERT(aBehavior == ParentThreadUnchangedBusyCount || + aBehavior == WorkerThreadUnchangedBusyCount, + "WorkerControlRunnables should not modify the busy count"); +} +#endif + +nsresult +WorkerControlRunnable::Cancel() +{ + if (NS_FAILED(Run())) { + NS_WARNING("WorkerControlRunnable::Run() failed."); + } + + return WorkerRunnable::Cancel(); +} + +bool +WorkerControlRunnable::DispatchInternal() +{ + RefPtr<WorkerControlRunnable> runnable(this); + + if (mBehavior == WorkerThreadUnchangedBusyCount) { + return NS_SUCCEEDED(mWorkerPrivate->DispatchControlRunnable(runnable.forget())); + } + + if (WorkerPrivate* parent = mWorkerPrivate->GetParent()) { + return NS_SUCCEEDED(parent->DispatchControlRunnable(runnable.forget())); + } + + return NS_SUCCEEDED(mWorkerPrivate->DispatchToMainThread(runnable.forget())); +} + +NS_IMPL_ISUPPORTS_INHERITED0(WorkerControlRunnable, WorkerRunnable) + +WorkerMainThreadRunnable::WorkerMainThreadRunnable(WorkerPrivate* aWorkerPrivate, + const nsACString& aTelemetryKey) +: mWorkerPrivate(aWorkerPrivate) +, mTelemetryKey(aTelemetryKey) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +void +WorkerMainThreadRunnable::Dispatch(ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + TimeStamp startTime = TimeStamp::NowLoRes(); + + AutoSyncLoopHolder syncLoop(mWorkerPrivate); + + mSyncLoopTarget = syncLoop.EventTarget(); + + DebugOnly<nsresult> rv = mWorkerPrivate->DispatchToMainThread(this); + MOZ_ASSERT(NS_SUCCEEDED(rv), + "Should only fail after xpcom-shutdown-threads and we're gone by then"); + + if (!syncLoop.Run()) { + aRv.ThrowUncatchableException(); + } + + Telemetry::Accumulate(Telemetry::SYNC_WORKER_OPERATION, mTelemetryKey, + static_cast<uint32_t>((TimeStamp::NowLoRes() - startTime) + .ToMilliseconds())); + Unused << startTime; // Shut the compiler up. +} + +NS_IMETHODIMP +WorkerMainThreadRunnable::Run() +{ + AssertIsOnMainThread(); + + bool runResult = MainThreadRun(); + + RefPtr<MainThreadStopSyncLoopRunnable> response = + new MainThreadStopSyncLoopRunnable(mWorkerPrivate, + mSyncLoopTarget.forget(), + runResult); + + MOZ_ALWAYS_TRUE(response->Dispatch()); + + return NS_OK; +} + +WorkerCheckAPIExposureOnMainThreadRunnable::WorkerCheckAPIExposureOnMainThreadRunnable(WorkerPrivate* aWorkerPrivate): + WorkerMainThreadRunnable(aWorkerPrivate, + NS_LITERAL_CSTRING("WorkerCheckAPIExposureOnMainThread")) +{} + +WorkerCheckAPIExposureOnMainThreadRunnable::~WorkerCheckAPIExposureOnMainThreadRunnable() +{} + +bool +WorkerCheckAPIExposureOnMainThreadRunnable::Dispatch() +{ + ErrorResult rv; + WorkerMainThreadRunnable::Dispatch(rv); + bool ok = !rv.Failed(); + rv.SuppressException(); + return ok; +} + +bool +WorkerSameThreadRunnable::PreDispatch(WorkerPrivate* aWorkerPrivate) +{ + // We don't call WorkerRunnable::PreDispatch, because we're using + // WorkerThreadModifyBusyCount for mBehavior, and WorkerRunnable will assert + // that PreDispatch is on the parent thread in that case. + aWorkerPrivate->AssertIsOnWorkerThread(); + return true; +} + +void +WorkerSameThreadRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) +{ + // We don't call WorkerRunnable::PostDispatch, because we're using + // WorkerThreadModifyBusyCount for mBehavior, and WorkerRunnable will assert + // that PostDispatch is on the parent thread in that case. + aWorkerPrivate->AssertIsOnWorkerThread(); + if (aDispatchResult) { + DebugOnly<bool> willIncrement = aWorkerPrivate->ModifyBusyCountFromWorker(true); + // Should never fail since if this thread is still running, so should the + // parent and it should be able to process a control runnable. + MOZ_ASSERT(willIncrement); + } +} + +WorkerProxyToMainThreadRunnable::WorkerProxyToMainThreadRunnable(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) +{ + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +WorkerProxyToMainThreadRunnable::~WorkerProxyToMainThreadRunnable() +{} + +bool +WorkerProxyToMainThreadRunnable::Dispatch() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (NS_WARN_IF(!HoldWorker())) { + RunBackOnWorkerThread(); + return false; + } + + if (NS_WARN_IF(NS_FAILED(mWorkerPrivate->DispatchToMainThread(this)))) { + ReleaseWorker(); + RunBackOnWorkerThread(); + return false; + } + + return true; +} + +NS_IMETHODIMP +WorkerProxyToMainThreadRunnable::Run() +{ + AssertIsOnMainThread(); + RunOnMainThread(); + PostDispatchOnMainThread(); + return NS_OK; +} + +void +WorkerProxyToMainThreadRunnable::PostDispatchOnMainThread() +{ + class ReleaseRunnable final : public MainThreadWorkerControlRunnable + { + RefPtr<WorkerProxyToMainThreadRunnable> mRunnable; + + public: + ReleaseRunnable(WorkerPrivate* aWorkerPrivate, + WorkerProxyToMainThreadRunnable* aRunnable) + : MainThreadWorkerControlRunnable(aWorkerPrivate) + , mRunnable(aRunnable) + { + MOZ_ASSERT(aRunnable); + } + + // We must call RunBackOnWorkerThread() also if the runnable is canceled. + nsresult + Cancel() override + { + WorkerRun(nullptr, mWorkerPrivate); + return MainThreadWorkerControlRunnable::Cancel(); + } + + virtual bool + WorkerRun(JSContext* aCx, workers::WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + if (mRunnable) { + mRunnable->RunBackOnWorkerThread(); + + // Let's release the worker thread. + mRunnable->ReleaseWorker(); + mRunnable = nullptr; + } + + return true; + } + + private: + ~ReleaseRunnable() + {} + }; + + RefPtr<WorkerControlRunnable> runnable = + new ReleaseRunnable(mWorkerPrivate, this); + Unused << NS_WARN_IF(!runnable->Dispatch()); +} + +bool +WorkerProxyToMainThreadRunnable::HoldWorker() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!mWorkerHolder); + + class SimpleWorkerHolder final : public WorkerHolder + { + public: + bool Notify(Status aStatus) override + { + // We don't care about the notification. We just want to keep the + // mWorkerPrivate alive. + return true; + } + }; + + UniquePtr<WorkerHolder> workerHolder(new SimpleWorkerHolder()); + if (NS_WARN_IF(!workerHolder->HoldWorker(mWorkerPrivate, Canceling))) { + return false; + } + + mWorkerHolder = Move(workerHolder); + return true; +} + +void +WorkerProxyToMainThreadRunnable::ReleaseWorker() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mWorkerHolder); + mWorkerHolder = nullptr; +} diff --git a/dom/workers/WorkerRunnable.h b/dom/workers/WorkerRunnable.h new file mode 100644 index 000000000..c65060f44 --- /dev/null +++ b/dom/workers/WorkerRunnable.h @@ -0,0 +1,509 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_workerrunnable_h__ +#define mozilla_dom_workers_workerrunnable_h__ + +#include "Workers.h" + +#include "nsICancelableRunnable.h" + +#include "mozilla/Atomics.h" +#include "nsISupportsImpl.h" +#include "nsThreadUtils.h" /* nsRunnable */ + +struct JSContext; +class nsIEventTarget; + +namespace mozilla { +class ErrorResult; +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +class WorkerPrivate; + +// Use this runnable to communicate from the worker to its parent or vice-versa. +// The busy count must be taken into consideration and declared at construction +// time. +class WorkerRunnable : public nsIRunnable, + public nsICancelableRunnable +{ +public: + enum TargetAndBusyBehavior { + // Target the main thread for top-level workers, otherwise target the + // WorkerThread of the worker's parent. No change to the busy count. + ParentThreadUnchangedBusyCount, + + // Target the thread where the worker event loop runs. The busy count will + // be incremented before dispatching and decremented (asynchronously) after + // running. + WorkerThreadModifyBusyCount, + + // Target the thread where the worker event loop runs. The busy count will + // not be modified in any way. Besides worker-internal runnables this is + // almost always the wrong choice. + WorkerThreadUnchangedBusyCount + }; + +protected: + // The WorkerPrivate that this runnable is associated with. + WorkerPrivate* mWorkerPrivate; + + // See above. + TargetAndBusyBehavior mBehavior; + + // It's unclear whether or not Cancel() is supposed to work when called on any + // thread. To be safe we're using an atomic but it's likely overkill. + Atomic<uint32_t> mCanceled; + +private: + // Whether or not Cancel() is currently being called from inside the Run() + // method. Avoids infinite recursion when a subclass calls Run() from inside + // Cancel(). Only checked and modified on the target thread. + bool mCallingCancelWithinRun; + +public: + NS_DECL_THREADSAFE_ISUPPORTS + + // If you override Cancel() then you'll need to either call the base class + // Cancel() method or override IsCanceled() so that the Run() method bails out + // appropriately. + nsresult + Cancel() override; + + // The return value is true if and only if both PreDispatch and + // DispatchInternal return true. + bool + Dispatch(); + + // See above note about Cancel(). + virtual bool + IsCanceled() const + { + return mCanceled != 0; + } + + static WorkerRunnable* + FromRunnable(nsIRunnable* aRunnable); + +protected: + WorkerRunnable(WorkerPrivate* aWorkerPrivate, + TargetAndBusyBehavior aBehavior = WorkerThreadModifyBusyCount) +#ifdef DEBUG + ; +#else + : mWorkerPrivate(aWorkerPrivate), mBehavior(aBehavior), mCanceled(0), + mCallingCancelWithinRun(false) + { } +#endif + + // This class is reference counted. + virtual ~WorkerRunnable() + { } + + // Returns true if this runnable should be dispatched to the debugger queue, + // and false otherwise. + virtual bool + IsDebuggerRunnable() const; + + nsIGlobalObject* + DefaultGlobalObject() const; + + // By default asserts that Dispatch() is being called on the right thread + // (ParentThread if |mTarget| is WorkerThread, or WorkerThread otherwise). + // Also increments the busy count of |mWorkerPrivate| if targeting the + // WorkerThread. + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate); + + // By default asserts that Dispatch() is being called on the right thread + // (ParentThread if |mTarget| is WorkerThread, or WorkerThread otherwise). + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult); + + // May be implemented by subclasses if desired if they need to do some sort of + // setup before we try to set up our JSContext and compartment for real. + // Typically the only thing that should go in here is creation of the worker's + // global. + // + // If false is returned, WorkerRun will not be called at all. PostRun will + // still be called, with false passed for aRunResult. + virtual bool + PreRun(WorkerPrivate* aWorkerPrivate); + + // Must be implemented by subclasses. Called on the target thread. The return + // value will be passed to PostRun(). The JSContext passed in here comes from + // an AutoJSAPI (or AutoEntryScript) that we set up on the stack. If + // mBehavior is ParentThreadUnchangedBusyCount, it is in the compartment of + // mWorkerPrivate's reflector (i.e. the worker object in the parent thread), + // unless that reflector is null, in which case it's in the compartment of the + // parent global (which is the compartment reflector would have been in), or + // in the null compartment if there is no parent global. For other mBehavior + // values, we're running on the worker thread and aCx is in whatever + // compartment GetCurrentThreadJSContext() was in when nsIRunnable::Run() got + // called. This is actually important for cases when a runnable spins a + // syncloop and wants everything that happens during the syncloop to happen in + // the compartment that runnable set up (which may, for example, be a debugger + // sandbox compartment!). If aCx wasn't in a compartment to start with, aCx + // will be in either the debugger global's compartment or the worker's + // global's compartment depending on whether IsDebuggerRunnable() is true. + // + // Immediately after WorkerRun returns, the caller will assert that either it + // returns false or there is no exception pending on aCx. Then it will report + // any pending exceptions on aCx. + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) = 0; + + // By default asserts that Run() (and WorkerRun()) were called on the correct + // thread. Also sends an asynchronous message to the ParentThread if the + // busy count was previously modified in PreDispatch(). + // + // The aCx passed here is the same one as was passed to WorkerRun and is + // still in the same compartment. PostRun implementations must NOT leave an + // exception on the JSContext and must not run script, because the incoming + // JSContext may be in the null compartment. + virtual void + PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult); + + virtual bool + DispatchInternal(); + + // Calling Run() directly is not supported. Just call Dispatch() and + // WorkerRun() will be called on the correct thread automatically. + NS_DECL_NSIRUNNABLE +}; + +// This runnable is used to send a message to a worker debugger. +class WorkerDebuggerRunnable : public WorkerRunnable +{ +protected: + explicit WorkerDebuggerRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { + } + + virtual ~WorkerDebuggerRunnable() + { } + +private: + virtual bool + IsDebuggerRunnable() const override + { + return true; + } + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override final + { + AssertIsOnMainThread(); + + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override; +}; + +// This runnable is used to send a message directly to a worker's sync loop. +class WorkerSyncRunnable : public WorkerRunnable +{ +protected: + nsCOMPtr<nsIEventTarget> mSyncLoopTarget; + + // Passing null for aSyncLoopTarget is allowed and will result in the behavior + // of a normal WorkerRunnable. + WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, + nsIEventTarget* aSyncLoopTarget); + + WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, + already_AddRefed<nsIEventTarget>&& aSyncLoopTarget); + + virtual ~WorkerSyncRunnable(); + + virtual bool + DispatchInternal() override; +}; + +// This runnable is identical to WorkerSyncRunnable except it is meant to be +// created on and dispatched from the main thread only. Its WorkerRun/PostRun +// will run on the worker thread. +class MainThreadWorkerSyncRunnable : public WorkerSyncRunnable +{ +protected: + // Passing null for aSyncLoopTarget is allowed and will result in the behavior + // of a normal WorkerRunnable. + MainThreadWorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, + nsIEventTarget* aSyncLoopTarget) + : WorkerSyncRunnable(aWorkerPrivate, aSyncLoopTarget) + { + AssertIsOnMainThread(); + } + + MainThreadWorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, + already_AddRefed<nsIEventTarget>&& aSyncLoopTarget) + : WorkerSyncRunnable(aWorkerPrivate, Move(aSyncLoopTarget)) + { + AssertIsOnMainThread(); + } + + virtual ~MainThreadWorkerSyncRunnable() + { } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + AssertIsOnMainThread(); + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override; +}; + +// This runnable is processed as soon as it is received by the worker, +// potentially running before previously queued runnables and perhaps even with +// other JS code executing on the stack. These runnables must not alter the +// state of the JS runtime and should only twiddle state values. The busy count +// is never modified. +class WorkerControlRunnable : public WorkerRunnable +{ + friend class WorkerPrivate; + +protected: + WorkerControlRunnable(WorkerPrivate* aWorkerPrivate, + TargetAndBusyBehavior aBehavior = WorkerThreadModifyBusyCount) +#ifdef DEBUG + ; +#else + : WorkerRunnable(aWorkerPrivate, aBehavior) + { } +#endif + + virtual ~WorkerControlRunnable() + { } + + nsresult + Cancel() override; + +public: + NS_DECL_ISUPPORTS_INHERITED + +private: + virtual bool + DispatchInternal() override; + + // Should only be called by WorkerPrivate::DoRunLoop. + using WorkerRunnable::Cancel; +}; + +// A convenience class for WorkerRunnables that are originated on the main +// thread. +class MainThreadWorkerRunnable : public WorkerRunnable +{ +protected: + explicit MainThreadWorkerRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { + AssertIsOnMainThread(); + } + + virtual ~MainThreadWorkerRunnable() + {} + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + AssertIsOnMainThread(); + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) override + { + AssertIsOnMainThread(); + } +}; + +// A convenience class for WorkerControlRunnables that originate on the main +// thread. +class MainThreadWorkerControlRunnable : public WorkerControlRunnable +{ +protected: + explicit MainThreadWorkerControlRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + { } + + virtual ~MainThreadWorkerControlRunnable() + { } + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + AssertIsOnMainThread(); + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override + { + AssertIsOnMainThread(); + } +}; + +// A WorkerRunnable that should be dispatched from the worker to itself for +// async tasks. This will increment the busy count PostDispatch() (only if +// dispatch was successful) and decrement it in PostRun(). +// +// Async tasks will almost always want to use this since +// a WorkerSameThreadRunnable keeps the Worker from being GCed. +class WorkerSameThreadRunnable : public WorkerRunnable +{ +protected: + explicit WorkerSameThreadRunnable(WorkerPrivate* aWorkerPrivate) + : WorkerRunnable(aWorkerPrivate, WorkerThreadModifyBusyCount) + { } + + virtual ~WorkerSameThreadRunnable() + { } + + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override; + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override; + + // We just delegate PostRun to WorkerRunnable, since it does exactly + // what we want. +}; + +// Base class for the runnable objects, which makes a synchronous call to +// dispatch the tasks from the worker thread to the main thread. +// +// Note that the derived class must override MainThreadRun. +class WorkerMainThreadRunnable : public Runnable +{ +protected: + WorkerPrivate* mWorkerPrivate; + nsCOMPtr<nsIEventTarget> mSyncLoopTarget; + const nsCString mTelemetryKey; + + explicit WorkerMainThreadRunnable(WorkerPrivate* aWorkerPrivate, + const nsACString& aTelemetryKey); + ~WorkerMainThreadRunnable() {} + + virtual bool MainThreadRun() = 0; + +public: + // Dispatch the runnable to the main thread. If dispatch to main thread + // fails, or if the worker is shut down while dispatching, an error will be + // reported on aRv. In that case the error MUST be propagated out to script. + void Dispatch(ErrorResult& aRv); + +private: + NS_IMETHOD Run() override; +}; + +// This runnable is an helper class for dispatching something from a worker +// thread to the main-thread and back to the worker-thread. During this +// operation, this class will keep the worker alive. +class WorkerProxyToMainThreadRunnable : public Runnable +{ +protected: + explicit WorkerProxyToMainThreadRunnable(WorkerPrivate* aWorkerPrivate); + + virtual ~WorkerProxyToMainThreadRunnable(); + + // First this method is called on the main-thread. + virtual void RunOnMainThread() = 0; + + // After this second method is called on the worker-thread. + virtual void RunBackOnWorkerThread() = 0; + +public: + bool Dispatch(); + +private: + NS_IMETHOD Run() override; + + void PostDispatchOnMainThread(); + + bool HoldWorker(); + void ReleaseWorker(); + +protected: + WorkerPrivate* mWorkerPrivate; + UniquePtr<WorkerHolder> mWorkerHolder; +}; + +// Class for checking API exposure. This totally violates the "MUST" in the +// comments on WorkerMainThreadRunnable::Dispatch, because API exposure checks +// can't throw. Maybe we should change it so they _could_ throw. But for now +// we are bad people and should be ashamed of ourselves. Let's hope none of +// them happen while a worker is shutting down. +// +// Do NOT copy what this class is doing elsewhere. Just don't. +class WorkerCheckAPIExposureOnMainThreadRunnable + : public WorkerMainThreadRunnable +{ +public: + explicit + WorkerCheckAPIExposureOnMainThreadRunnable(WorkerPrivate* aWorkerPrivate); + virtual + ~WorkerCheckAPIExposureOnMainThreadRunnable(); + + // Returns whether the dispatch succeeded. If this returns false, the API + // should not be exposed. + bool Dispatch(); +}; + +// This runnable is used to stop a sync loop and it's meant to be used on the +// main-thread only. As sync loops keep the busy count incremented as long as +// they run this runnable does not modify the busy count +// in any way. +class MainThreadStopSyncLoopRunnable : public WorkerSyncRunnable +{ + bool mResult; + +public: + // Passing null for aSyncLoopTarget is not allowed. + MainThreadStopSyncLoopRunnable( + WorkerPrivate* aWorkerPrivate, + already_AddRefed<nsIEventTarget>&& aSyncLoopTarget, + bool aResult); + + // By default StopSyncLoopRunnables cannot be canceled since they could leave + // a sync loop spinning forever. + nsresult + Cancel() override; + +protected: + virtual ~MainThreadStopSyncLoopRunnable() + { } + +private: + virtual bool + PreDispatch(WorkerPrivate* aWorkerPrivate) override final + { + AssertIsOnMainThread(); + return true; + } + + virtual void + PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override; + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override; + + virtual bool + DispatchInternal() override final; +}; + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_workerrunnable_h__ diff --git a/dom/workers/WorkerScope.cpp b/dom/workers/WorkerScope.cpp new file mode 100644 index 000000000..d9a987b62 --- /dev/null +++ b/dom/workers/WorkerScope.cpp @@ -0,0 +1,978 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerScope.h" + +#include "jsapi.h" +#include "mozilla/EventListenerManager.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/Console.h" +#include "mozilla/dom/DedicatedWorkerGlobalScopeBinding.h" +#include "mozilla/dom/Fetch.h" +#include "mozilla/dom/FunctionBinding.h" +#include "mozilla/dom/IDBFactory.h" +#include "mozilla/dom/ImageBitmap.h" +#include "mozilla/dom/ImageBitmapBinding.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseWorkerProxy.h" +#include "mozilla/dom/ServiceWorkerGlobalScopeBinding.h" +#include "mozilla/dom/SharedWorkerGlobalScopeBinding.h" +#include "mozilla/dom/SimpleGlobalObject.h" +#include "mozilla/dom/WorkerDebuggerGlobalScopeBinding.h" +#include "mozilla/dom/WorkerGlobalScopeBinding.h" +#include "mozilla/dom/WorkerLocation.h" +#include "mozilla/dom/WorkerNavigator.h" +#include "mozilla/dom/cache/CacheStorage.h" +#include "mozilla/Services.h" +#include "nsServiceManagerUtils.h" + +#include "nsIDocument.h" +#include "nsIServiceWorkerManager.h" +#include "nsIScriptTimeoutHandler.h" + +#ifdef ANDROID +#include <android/log.h> +#endif + +#include "Crypto.h" +#include "Principal.h" +#include "RuntimeService.h" +#include "ScriptLoader.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" +#include "ServiceWorkerClients.h" +#include "ServiceWorkerManager.h" +#include "ServiceWorkerRegistration.h" + +#ifdef XP_WIN +#undef PostMessage +#endif + +extern already_AddRefed<nsIScriptTimeoutHandler> +NS_CreateJSTimeoutHandler(JSContext* aCx, + mozilla::dom::workers::WorkerPrivate* aWorkerPrivate, + mozilla::dom::Function& aFunction, + const mozilla::dom::Sequence<JS::Value>& aArguments, + mozilla::ErrorResult& aError); + +extern already_AddRefed<nsIScriptTimeoutHandler> +NS_CreateJSTimeoutHandler(JSContext* aCx, + mozilla::dom::workers::WorkerPrivate* aWorkerPrivate, + const nsAString& aExpression); + +using namespace mozilla; +using namespace mozilla::dom; +USING_WORKERS_NAMESPACE + +using mozilla::dom::cache::CacheStorage; +using mozilla::ipc::PrincipalInfo; + +WorkerGlobalScope::WorkerGlobalScope(WorkerPrivate* aWorkerPrivate) +: mWindowInteractionsAllowed(0) +, mWorkerPrivate(aWorkerPrivate) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +WorkerGlobalScope::~WorkerGlobalScope() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerGlobalScope) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsole) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCrypto) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPerformance) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocation) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNavigator) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIndexedDB) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCacheStorage) + tmp->TraverseHostObjectURIs(cb); + tmp->mWorkerPrivate->TraverseTimeouts(cb); +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsole) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mCrypto) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mPerformance) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocation) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mNavigator) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mIndexedDB) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mCacheStorage) + tmp->UnlinkHostObjectURIs(); + tmp->mWorkerPrivate->UnlinkTimeouts(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ADDREF_INHERITED(WorkerGlobalScope, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(WorkerGlobalScope, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkerGlobalScope) + NS_INTERFACE_MAP_ENTRY(nsIGlobalObject) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +JSObject* +WorkerGlobalScope::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + MOZ_CRASH("We should never get here!"); +} + +Console* +WorkerGlobalScope::GetConsole(ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mConsole) { + mConsole = Console::Create(nullptr, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + } + + return mConsole; +} + +Crypto* +WorkerGlobalScope::GetCrypto(ErrorResult& aError) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mCrypto) { + mCrypto = new Crypto(); + mCrypto->Init(this); + } + + return mCrypto; +} + +already_AddRefed<CacheStorage> +WorkerGlobalScope::GetCaches(ErrorResult& aRv) +{ + if (!mCacheStorage) { + MOZ_ASSERT(mWorkerPrivate); + mCacheStorage = CacheStorage::CreateOnWorker(cache::DEFAULT_NAMESPACE, this, + mWorkerPrivate, aRv); + } + + RefPtr<CacheStorage> ref = mCacheStorage; + return ref.forget(); +} + +bool +WorkerGlobalScope::IsSecureContext() const +{ + bool globalSecure = + JS_GetIsSecureContext(js::GetObjectCompartment(GetWrapperPreserveColor())); + MOZ_ASSERT(globalSecure == mWorkerPrivate->IsSecureContext()); + return globalSecure; +} + +already_AddRefed<WorkerLocation> +WorkerGlobalScope::Location() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mLocation) { + WorkerPrivate::LocationInfo& info = mWorkerPrivate->GetLocationInfo(); + + mLocation = WorkerLocation::Create(info); + MOZ_ASSERT(mLocation); + } + + RefPtr<WorkerLocation> location = mLocation; + return location.forget(); +} + +already_AddRefed<WorkerNavigator> +WorkerGlobalScope::Navigator() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mNavigator) { + mNavigator = WorkerNavigator::Create(mWorkerPrivate->OnLine()); + MOZ_ASSERT(mNavigator); + } + + RefPtr<WorkerNavigator> navigator = mNavigator; + return navigator.forget(); +} + +already_AddRefed<WorkerNavigator> +WorkerGlobalScope::GetExistingNavigator() const +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<WorkerNavigator> navigator = mNavigator; + return navigator.forget(); +} + +void +WorkerGlobalScope::Close(JSContext* aCx, ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (mWorkerPrivate->IsServiceWorker()) { + aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR); + } else { + mWorkerPrivate->CloseInternal(aCx); + } +} + +OnErrorEventHandlerNonNull* +WorkerGlobalScope::GetOnerror() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + EventListenerManager* elm = GetExistingListenerManager(); + return elm ? elm->GetOnErrorEventHandler() : nullptr; +} + +void +WorkerGlobalScope::SetOnerror(OnErrorEventHandlerNonNull* aHandler) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + EventListenerManager* elm = GetOrCreateListenerManager(); + if (elm) { + elm->SetEventHandler(aHandler); + } +} + +void +WorkerGlobalScope::ImportScripts(const Sequence<nsString>& aScriptURLs, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + scriptloader::Load(mWorkerPrivate, aScriptURLs, WorkerScript, aRv); +} + +int32_t +WorkerGlobalScope::SetTimeout(JSContext* aCx, + Function& aHandler, + const int32_t aTimeout, + const Sequence<JS::Value>& aArguments, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + nsCOMPtr<nsIScriptTimeoutHandler> handler = + NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler, aArguments, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return 0; + } + + return mWorkerPrivate->SetTimeout(aCx, handler, aTimeout, false, aRv); +} + +int32_t +WorkerGlobalScope::SetTimeout(JSContext* aCx, + const nsAString& aHandler, + const int32_t aTimeout, + const Sequence<JS::Value>& /* unused */, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + nsCOMPtr<nsIScriptTimeoutHandler> handler = + NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler); + return mWorkerPrivate->SetTimeout(aCx, handler, aTimeout, false, aRv); +} + +void +WorkerGlobalScope::ClearTimeout(int32_t aHandle) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate->ClearTimeout(aHandle); +} + +int32_t +WorkerGlobalScope::SetInterval(JSContext* aCx, + Function& aHandler, + const Optional<int32_t>& aTimeout, + const Sequence<JS::Value>& aArguments, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + bool isInterval = aTimeout.WasPassed(); + int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; + + nsCOMPtr<nsIScriptTimeoutHandler> handler = + NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler, aArguments, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return 0; + } + + return mWorkerPrivate->SetTimeout(aCx, handler, timeout, isInterval, aRv); +} + +int32_t +WorkerGlobalScope::SetInterval(JSContext* aCx, + const nsAString& aHandler, + const Optional<int32_t>& aTimeout, + const Sequence<JS::Value>& /* unused */, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + Sequence<JS::Value> dummy; + + bool isInterval = aTimeout.WasPassed(); + int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; + + nsCOMPtr<nsIScriptTimeoutHandler> handler = + NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler); + return mWorkerPrivate->SetTimeout(aCx, handler, timeout, isInterval, aRv); +} + +void +WorkerGlobalScope::ClearInterval(int32_t aHandle) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate->ClearTimeout(aHandle); +} + +void +WorkerGlobalScope::Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + aRv = nsContentUtils::Atob(aAtob, aOutput); +} + +void +WorkerGlobalScope::Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + aRv = nsContentUtils::Btoa(aBtoa, aOutput); +} + +void +WorkerGlobalScope::Dump(const Optional<nsAString>& aString) const +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!aString.WasPassed()) { + return; + } + +#if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP)) + if (!mWorkerPrivate->DumpEnabled()) { + return; + } +#endif + + NS_ConvertUTF16toUTF8 str(aString.Value()); + + MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug, ("[Worker.Dump] %s", str.get())); +#ifdef ANDROID + __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); +#endif + fputs(str.get(), stdout); + fflush(stdout); +} + +Performance* +WorkerGlobalScope::GetPerformance() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + if (!mPerformance) { + mPerformance = Performance::CreateForWorker(mWorkerPrivate); + } + + return mPerformance; +} + +already_AddRefed<Promise> +WorkerGlobalScope::Fetch(const RequestOrUSVString& aInput, + const RequestInit& aInit, ErrorResult& aRv) +{ + return FetchRequest(this, aInput, aInit, aRv); +} + +already_AddRefed<IDBFactory> +WorkerGlobalScope::GetIndexedDB(ErrorResult& aErrorResult) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<IDBFactory> indexedDB = mIndexedDB; + + if (!indexedDB) { + if (!mWorkerPrivate->IsStorageAllowed()) { + NS_WARNING("IndexedDB is not allowed in this worker!"); + aErrorResult = NS_ERROR_DOM_SECURITY_ERR; + return nullptr; + } + + JSContext* cx = mWorkerPrivate->GetJSContext(); + MOZ_ASSERT(cx); + + JS::Rooted<JSObject*> owningObject(cx, GetGlobalJSObject()); + MOZ_ASSERT(owningObject); + + const PrincipalInfo& principalInfo = mWorkerPrivate->GetPrincipalInfo(); + + nsresult rv = + IDBFactory::CreateForWorker(cx, + owningObject, + principalInfo, + mWorkerPrivate->WindowID(), + getter_AddRefs(indexedDB)); + if (NS_WARN_IF(NS_FAILED(rv))) { + aErrorResult = rv; + return nullptr; + } + + mIndexedDB = indexedDB; + } + + return indexedDB.forget(); +} + +already_AddRefed<Promise> +WorkerGlobalScope::CreateImageBitmap(const ImageBitmapSource& aImage, + ErrorResult& aRv) +{ + if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) { + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); + return nullptr; + } + + return ImageBitmap::Create(this, aImage, Nothing(), aRv); +} + +already_AddRefed<Promise> +WorkerGlobalScope::CreateImageBitmap(const ImageBitmapSource& aImage, + int32_t aSx, int32_t aSy, int32_t aSw, int32_t aSh, + ErrorResult& aRv) +{ + if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) { + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); + return nullptr; + } + + return ImageBitmap::Create(this, aImage, Some(gfx::IntRect(aSx, aSy, aSw, aSh)), aRv); +} + +already_AddRefed<mozilla::dom::Promise> +WorkerGlobalScope::CreateImageBitmap(const ImageBitmapSource& aImage, + int32_t aOffset, int32_t aLength, + ImageBitmapFormat aFormat, + const Sequence<ChannelPixelLayout>& aLayout, + ErrorResult& aRv) +{ + JSContext* cx = GetCurrentThreadJSContext(); + MOZ_ASSERT(cx); + + if (!ImageBitmap::ExtensionsEnabled(cx, nullptr)) { + aRv.Throw(NS_ERROR_TYPE_ERR); + return nullptr; + } + + if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) { + return ImageBitmap::Create(this, aImage, aOffset, aLength, aFormat, aLayout, + aRv); + } else { + aRv.Throw(NS_ERROR_TYPE_ERR); + return nullptr; + } +} + +DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate) +: WorkerGlobalScope(aWorkerPrivate) +{ +} + +bool +DedicatedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!mWorkerPrivate->IsSharedWorker()); + + JS::CompartmentOptions options; + mWorkerPrivate->CopyJSCompartmentOptions(options); + + const bool usesSystemPrincipal = mWorkerPrivate->UsesSystemPrincipal(); + + // Note that xpc::ShouldDiscardSystemSource() and + // xpc::ExtraWarningsForSystemJS() read prefs that are cached on the main + // thread. This is benignly racey. + const bool discardSource = usesSystemPrincipal && + xpc::ShouldDiscardSystemSource(); + const bool extraWarnings = usesSystemPrincipal && + xpc::ExtraWarningsForSystemJS(); + + JS::CompartmentBehaviors& behaviors = options.behaviors(); + behaviors.setDiscardSource(discardSource) + .extraWarningsOverride().set(extraWarnings); + + const bool sharedMemoryEnabled = xpc::SharedMemoryEnabled(); + + JS::CompartmentCreationOptions& creationOptions = options.creationOptions(); + creationOptions.setSharedMemoryAndAtomicsEnabled(sharedMemoryEnabled); + + return DedicatedWorkerGlobalScopeBinding::Wrap(aCx, this, this, + options, + GetWorkerPrincipal(), + true, aReflector); +} + +void +DedicatedWorkerGlobalScope::PostMessage(JSContext* aCx, + JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + mWorkerPrivate->PostMessageToParent(aCx, aMessage, aTransferable, aRv); +} + +SharedWorkerGlobalScope::SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate, + const nsCString& aName) +: WorkerGlobalScope(aWorkerPrivate), mName(aName) +{ +} + +bool +SharedWorkerGlobalScope::WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mWorkerPrivate->IsSharedWorker()); + + JS::CompartmentOptions options; + mWorkerPrivate->CopyJSCompartmentOptions(options); + + return SharedWorkerGlobalScopeBinding::Wrap(aCx, this, this, options, + GetWorkerPrincipal(), + true, aReflector); +} + +NS_IMPL_CYCLE_COLLECTION_INHERITED(ServiceWorkerGlobalScope, WorkerGlobalScope, + mClients, mRegistration) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ServiceWorkerGlobalScope) +NS_INTERFACE_MAP_END_INHERITING(WorkerGlobalScope) + +NS_IMPL_ADDREF_INHERITED(ServiceWorkerGlobalScope, WorkerGlobalScope) +NS_IMPL_RELEASE_INHERITED(ServiceWorkerGlobalScope, WorkerGlobalScope) + +ServiceWorkerGlobalScope::ServiceWorkerGlobalScope(WorkerPrivate* aWorkerPrivate, + const nsACString& aScope) + : WorkerGlobalScope(aWorkerPrivate), + mScope(NS_ConvertUTF8toUTF16(aScope)) +{ +} + +ServiceWorkerGlobalScope::~ServiceWorkerGlobalScope() +{ +} + +bool +ServiceWorkerGlobalScope::WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mWorkerPrivate->IsServiceWorker()); + + JS::CompartmentOptions options; + mWorkerPrivate->CopyJSCompartmentOptions(options); + + return ServiceWorkerGlobalScopeBinding::Wrap(aCx, this, this, options, + GetWorkerPrincipal(), + true, aReflector); +} + +ServiceWorkerClients* +ServiceWorkerGlobalScope::Clients() +{ + if (!mClients) { + mClients = new ServiceWorkerClients(this); + } + + return mClients; +} + +ServiceWorkerRegistration* +ServiceWorkerGlobalScope::Registration() +{ + if (!mRegistration) { + mRegistration = + ServiceWorkerRegistration::CreateForWorker(mWorkerPrivate, mScope); + } + + return mRegistration; +} + +namespace { + +class SkipWaitingResultRunnable final : public WorkerRunnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + +public: + SkipWaitingResultRunnable(WorkerPrivate* aWorkerPrivate, + PromiseWorkerProxy* aPromiseProxy) + : WorkerRunnable(aWorkerPrivate) + , mPromiseProxy(aPromiseProxy) + { + AssertIsOnMainThread(); + } + + virtual bool + WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<Promise> promise = mPromiseProxy->WorkerPromise(); + promise->MaybeResolveWithUndefined(); + + // Release the reference on the worker thread. + mPromiseProxy->CleanUp(); + + return true; + } +}; + +class WorkerScopeSkipWaitingRunnable final : public Runnable +{ + RefPtr<PromiseWorkerProxy> mPromiseProxy; + nsCString mScope; + +public: + WorkerScopeSkipWaitingRunnable(PromiseWorkerProxy* aPromiseProxy, + const nsCString& aScope) + : mPromiseProxy(aPromiseProxy) + , mScope(aScope) + { + MOZ_ASSERT(aPromiseProxy); + } + + NS_IMETHOD + Run() override + { + AssertIsOnMainThread(); + + MutexAutoLock lock(mPromiseProxy->Lock()); + if (mPromiseProxy->CleanedUp()) { + return NS_OK; + } + + WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + + RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance(); + if (swm) { + swm->SetSkipWaitingFlag(workerPrivate->GetPrincipal(), mScope, + workerPrivate->ServiceWorkerID()); + } + + RefPtr<SkipWaitingResultRunnable> runnable = + new SkipWaitingResultRunnable(workerPrivate, mPromiseProxy); + + if (!runnable->Dispatch()) { + NS_WARNING("Failed to dispatch SkipWaitingResultRunnable to the worker."); + } + return NS_OK; + } +}; + +} // namespace + +already_AddRefed<Promise> +ServiceWorkerGlobalScope::SkipWaiting(ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(mWorkerPrivate->IsServiceWorker()); + + RefPtr<Promise> promise = Promise::Create(this, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + RefPtr<PromiseWorkerProxy> promiseProxy = + PromiseWorkerProxy::Create(mWorkerPrivate, promise); + if (!promiseProxy) { + promise->MaybeResolveWithUndefined(); + return promise.forget(); + } + + RefPtr<WorkerScopeSkipWaitingRunnable> runnable = + new WorkerScopeSkipWaitingRunnable(promiseProxy, + NS_ConvertUTF16toUTF8(mScope)); + + MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(runnable.forget())); + return promise.forget(); +} + +bool +ServiceWorkerGlobalScope::OpenWindowEnabled(JSContext* aCx, JSObject* aObj) +{ + WorkerPrivate* worker = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(worker); + worker->AssertIsOnWorkerThread(); + return worker->OpenWindowEnabled(); +} + +WorkerDebuggerGlobalScope::WorkerDebuggerGlobalScope( + WorkerPrivate* aWorkerPrivate) +: mWorkerPrivate(aWorkerPrivate) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +WorkerDebuggerGlobalScope::~WorkerDebuggerGlobalScope() +{ + mWorkerPrivate->AssertIsOnWorkerThread(); +} + +NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerDebuggerGlobalScope) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerDebuggerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsole) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerDebuggerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsole) +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerDebuggerGlobalScope, + DOMEventTargetHelper) + tmp->mWorkerPrivate->AssertIsOnWorkerThread(); +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ADDREF_INHERITED(WorkerDebuggerGlobalScope, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(WorkerDebuggerGlobalScope, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkerDebuggerGlobalScope) + NS_INTERFACE_MAP_ENTRY(nsIGlobalObject) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +bool +WorkerDebuggerGlobalScope::WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + JS::CompartmentOptions options; + mWorkerPrivate->CopyJSCompartmentOptions(options); + + return WorkerDebuggerGlobalScopeBinding::Wrap(aCx, this, this, options, + GetWorkerPrincipal(), true, + aReflector); +} + +void +WorkerDebuggerGlobalScope::GetGlobal(JSContext* aCx, + JS::MutableHandle<JSObject*> aGlobal, + ErrorResult& aRv) +{ + WorkerGlobalScope* scope = mWorkerPrivate->GetOrCreateGlobalScope(aCx); + if (!scope) { + aRv.Throw(NS_ERROR_FAILURE); + } + + aGlobal.set(scope->GetWrapper()); +} + +void +WorkerDebuggerGlobalScope::CreateSandbox(JSContext* aCx, const nsAString& aName, + JS::Handle<JSObject*> aPrototype, + JS::MutableHandle<JSObject*> aResult, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + aResult.set(nullptr); + + JS::Rooted<JS::Value> protoVal(aCx); + protoVal.setObjectOrNull(aPrototype); + JS::Rooted<JSObject*> sandbox(aCx, + SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::WorkerDebuggerSandbox, + protoVal)); + + if (!sandbox) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + if (!JS_WrapObject(aCx, &sandbox)) { + aRv.NoteJSContextException(aCx); + return; + } + + aResult.set(sandbox); +} + +void +WorkerDebuggerGlobalScope::LoadSubScript(JSContext* aCx, + const nsAString& aURL, + const Optional<JS::Handle<JSObject*>>& aSandbox, + ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + Maybe<JSAutoCompartment> ac; + if (aSandbox.WasPassed()) { + JS::Rooted<JSObject*> sandbox(aCx, js::CheckedUnwrap(aSandbox.Value())); + if (!IsDebuggerSandbox(sandbox)) { + aRv.Throw(NS_ERROR_INVALID_ARG); + return; + } + + ac.emplace(aCx, sandbox); + } + + nsTArray<nsString> urls; + urls.AppendElement(aURL); + scriptloader::Load(mWorkerPrivate, urls, DebuggerScript, aRv); +} + +void +WorkerDebuggerGlobalScope::EnterEventLoop() +{ + mWorkerPrivate->EnterDebuggerEventLoop(); +} + +void +WorkerDebuggerGlobalScope::LeaveEventLoop() +{ + mWorkerPrivate->LeaveDebuggerEventLoop(); +} + +void +WorkerDebuggerGlobalScope::PostMessage(const nsAString& aMessage) +{ + mWorkerPrivate->PostMessageToDebugger(aMessage); +} + +void +WorkerDebuggerGlobalScope::SetImmediate(Function& aHandler, ErrorResult& aRv) +{ + mWorkerPrivate->SetDebuggerImmediate(aHandler, aRv); +} + +void +WorkerDebuggerGlobalScope::ReportError(JSContext* aCx, + const nsAString& aMessage) +{ + JS::AutoFilename chars; + uint32_t lineno = 0; + JS::DescribeScriptedCaller(aCx, &chars, &lineno); + nsString filename(NS_ConvertUTF8toUTF16(chars.get())); + mWorkerPrivate->ReportErrorToDebugger(filename, lineno, aMessage); +} + +void +WorkerDebuggerGlobalScope::RetrieveConsoleEvents(JSContext* aCx, + nsTArray<JS::Value>& aEvents, + ErrorResult& aRv) +{ + WorkerGlobalScope* scope = mWorkerPrivate->GetOrCreateGlobalScope(aCx); + if (!scope) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + RefPtr<Console> console = scope->GetConsole(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + console->RetrieveConsoleEvents(aCx, aEvents, aRv); +} + +void +WorkerDebuggerGlobalScope::SetConsoleEventHandler(JSContext* aCx, + AnyCallback* aHandler, + ErrorResult& aRv) +{ + WorkerGlobalScope* scope = mWorkerPrivate->GetOrCreateGlobalScope(aCx); + if (!scope) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + RefPtr<Console> console = scope->GetConsole(aRv); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + + console->SetConsoleEventHandler(aHandler); +} + +Console* +WorkerDebuggerGlobalScope::GetConsole(ErrorResult& aRv) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + // Debugger console has its own console object. + if (!mConsole) { + mConsole = Console::Create(nullptr, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + } + + return mConsole; +} + +void +WorkerDebuggerGlobalScope::Dump(JSContext* aCx, + const Optional<nsAString>& aString) const +{ + WorkerGlobalScope* scope = mWorkerPrivate->GetOrCreateGlobalScope(aCx); + if (scope) { + scope->Dump(aString); + } +} + +BEGIN_WORKERS_NAMESPACE + +bool +IsWorkerGlobal(JSObject* object) +{ + return IS_INSTANCE_OF(WorkerGlobalScope, object); +} + +bool +IsDebuggerGlobal(JSObject* object) +{ + return IS_INSTANCE_OF(WorkerDebuggerGlobalScope, object); +} + +bool +IsDebuggerSandbox(JSObject* object) +{ + return SimpleGlobalObject::SimpleGlobalType(object) == + SimpleGlobalObject::GlobalType::WorkerDebuggerSandbox; +} + +bool +GetterOnlyJSNative(JSContext* aCx, unsigned aArgc, JS::Value* aVp) +{ + JS_ReportErrorNumberASCII(aCx, js::GetErrorMessage, nullptr, JSMSG_GETTER_ONLY); + return false; +} + +END_WORKERS_NAMESPACE diff --git a/dom/workers/WorkerScope.h b/dom/workers/WorkerScope.h new file mode 100644 index 000000000..53d0a578e --- /dev/null +++ b/dom/workers/WorkerScope.h @@ -0,0 +1,389 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workerscope_h__ +#define mozilla_dom_workerscope_h__ + +#include "Workers.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/dom/Headers.h" +#include "mozilla/dom/RequestBinding.h" +#include "nsWeakReference.h" +#include "mozilla/dom/ImageBitmapSource.h" + +namespace mozilla { +namespace dom { + +class AnyCallback; +struct ChannelPixelLayout; +class Console; +class Crypto; +class Function; +class IDBFactory; +enum class ImageBitmapFormat : uint32_t; +class Performance; +class Promise; +class RequestOrUSVString; +class ServiceWorkerRegistration; +class WorkerLocation; +class WorkerNavigator; + +namespace cache { + +class CacheStorage; + +} // namespace cache + +namespace workers { + +class ServiceWorkerClients; +class WorkerPrivate; + +} // namespace workers + +class WorkerGlobalScope : public DOMEventTargetHelper, + public nsIGlobalObject, + public nsSupportsWeakReference +{ + typedef mozilla::dom::IDBFactory IDBFactory; + + RefPtr<Console> mConsole; + RefPtr<Crypto> mCrypto; + RefPtr<WorkerLocation> mLocation; + RefPtr<WorkerNavigator> mNavigator; + RefPtr<Performance> mPerformance; + RefPtr<IDBFactory> mIndexedDB; + RefPtr<cache::CacheStorage> mCacheStorage; + + uint32_t mWindowInteractionsAllowed; + +protected: + typedef mozilla::dom::workers::WorkerPrivate WorkerPrivate; + WorkerPrivate* mWorkerPrivate; + + explicit WorkerGlobalScope(WorkerPrivate* aWorkerPrivate); + virtual ~WorkerGlobalScope(); + +public: + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + + virtual bool + WrapGlobalObject(JSContext* aCx, JS::MutableHandle<JSObject*> aReflector) = 0; + + virtual JSObject* + GetGlobalJSObject(void) override + { + return GetWrapper(); + } + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerGlobalScope, + DOMEventTargetHelper) + + WorkerGlobalScope* + Self() + { + return this; + } + + Console* + GetConsole(ErrorResult& aRv); + + Console* + GetConsoleIfExists() const + { + return mConsole; + } + + Crypto* + GetCrypto(ErrorResult& aError); + + already_AddRefed<WorkerLocation> + Location(); + + already_AddRefed<WorkerNavigator> + Navigator(); + + already_AddRefed<WorkerNavigator> + GetExistingNavigator() const; + + void + Close(JSContext* aCx, ErrorResult& aRv); + + OnErrorEventHandlerNonNull* + GetOnerror(); + void + SetOnerror(OnErrorEventHandlerNonNull* aHandler); + + void + ImportScripts(const Sequence<nsString>& aScriptURLs, ErrorResult& aRv); + + int32_t + SetTimeout(JSContext* aCx, Function& aHandler, const int32_t aTimeout, + const Sequence<JS::Value>& aArguments, ErrorResult& aRv); + int32_t + SetTimeout(JSContext* aCx, const nsAString& aHandler, const int32_t aTimeout, + const Sequence<JS::Value>& /* unused */, ErrorResult& aRv); + void + ClearTimeout(int32_t aHandle); + int32_t + SetInterval(JSContext* aCx, Function& aHandler, + const Optional<int32_t>& aTimeout, + const Sequence<JS::Value>& aArguments, ErrorResult& aRv); + int32_t + SetInterval(JSContext* aCx, const nsAString& aHandler, + const Optional<int32_t>& aTimeout, + const Sequence<JS::Value>& /* unused */, ErrorResult& aRv); + void + ClearInterval(int32_t aHandle); + + void + Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const; + void + Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const; + + IMPL_EVENT_HANDLER(online) + IMPL_EVENT_HANDLER(offline) + + void + Dump(const Optional<nsAString>& aString) const; + + Performance* GetPerformance(); + + already_AddRefed<Promise> + Fetch(const RequestOrUSVString& aInput, const RequestInit& aInit, ErrorResult& aRv); + + already_AddRefed<IDBFactory> + GetIndexedDB(ErrorResult& aErrorResult); + + already_AddRefed<cache::CacheStorage> + GetCaches(ErrorResult& aRv); + + bool IsSecureContext() const; + + already_AddRefed<Promise> + CreateImageBitmap(const ImageBitmapSource& aImage, ErrorResult& aRv); + + already_AddRefed<Promise> + CreateImageBitmap(const ImageBitmapSource& aImage, + int32_t aSx, int32_t aSy, int32_t aSw, int32_t aSh, + ErrorResult& aRv); + + already_AddRefed<mozilla::dom::Promise> + CreateImageBitmap(const ImageBitmapSource& aImage, + int32_t aOffset, int32_t aLength, + mozilla::dom::ImageBitmapFormat aFormat, + const mozilla::dom::Sequence<mozilla::dom::ChannelPixelLayout>& aLayout, + mozilla::ErrorResult& aRv); + + bool + WindowInteractionAllowed() const + { + return mWindowInteractionsAllowed > 0; + } + + void + AllowWindowInteraction() + { + mWindowInteractionsAllowed++; + } + + void + ConsumeWindowInteraction() + { + MOZ_ASSERT(mWindowInteractionsAllowed > 0); + mWindowInteractionsAllowed--; + } +}; + +class DedicatedWorkerGlobalScope final : public WorkerGlobalScope +{ + ~DedicatedWorkerGlobalScope() { } + +public: + explicit DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate); + + virtual bool + WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) override; + + void + PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const Optional<Sequence<JS::Value>>& aTransferable, + ErrorResult& aRv); + + IMPL_EVENT_HANDLER(message) +}; + +class SharedWorkerGlobalScope final : public WorkerGlobalScope +{ + const nsCString mName; + + ~SharedWorkerGlobalScope() { } + +public: + SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate, + const nsCString& aName); + + virtual bool + WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) override; + + void GetName(DOMString& aName) const + { + aName.AsAString() = NS_ConvertUTF8toUTF16(mName); + } + + IMPL_EVENT_HANDLER(connect) +}; + +class ServiceWorkerGlobalScope final : public WorkerGlobalScope +{ + const nsString mScope; + RefPtr<workers::ServiceWorkerClients> mClients; + RefPtr<ServiceWorkerRegistration> mRegistration; + + ~ServiceWorkerGlobalScope(); + +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerGlobalScope, + WorkerGlobalScope) + IMPL_EVENT_HANDLER(notificationclick) + IMPL_EVENT_HANDLER(notificationclose) + + ServiceWorkerGlobalScope(WorkerPrivate* aWorkerPrivate, const nsACString& aScope); + + virtual bool + WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) override; + + static bool + OpenWindowEnabled(JSContext* aCx, JSObject* aObj); + + void + GetScope(nsString& aScope) const + { + aScope = mScope; + } + + workers::ServiceWorkerClients* + Clients(); + + ServiceWorkerRegistration* + Registration(); + + already_AddRefed<Promise> + SkipWaiting(ErrorResult& aRv); + + IMPL_EVENT_HANDLER(activate) + IMPL_EVENT_HANDLER(fetch) + IMPL_EVENT_HANDLER(install) + IMPL_EVENT_HANDLER(message) + + IMPL_EVENT_HANDLER(push) + IMPL_EVENT_HANDLER(pushsubscriptionchange) + +}; + +class WorkerDebuggerGlobalScope final : public DOMEventTargetHelper, + public nsIGlobalObject +{ + typedef mozilla::dom::workers::WorkerPrivate WorkerPrivate; + + WorkerPrivate* mWorkerPrivate; + RefPtr<Console> mConsole; + +public: + explicit WorkerDebuggerGlobalScope(WorkerPrivate* aWorkerPrivate); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerDebuggerGlobalScope, + DOMEventTargetHelper) + + virtual JSObject* + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override + { + MOZ_CRASH("Shouldn't get here!"); + } + + virtual bool + WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector); + + virtual JSObject* + GetGlobalJSObject(void) override + { + return GetWrapper(); + } + + void + GetGlobal(JSContext* aCx, JS::MutableHandle<JSObject*> aGlobal, + ErrorResult& aRv); + + void + CreateSandbox(JSContext* aCx, const nsAString& aName, + JS::Handle<JSObject*> aPrototype, + JS::MutableHandle<JSObject*> aResult, + ErrorResult& aRv); + + void + LoadSubScript(JSContext* aCx, const nsAString& aURL, + const Optional<JS::Handle<JSObject*>>& aSandbox, + ErrorResult& aRv); + + void + EnterEventLoop(); + + void + LeaveEventLoop(); + + void + PostMessage(const nsAString& aMessage); + + IMPL_EVENT_HANDLER(message) + + void + SetImmediate(Function& aHandler, ErrorResult& aRv); + + void + ReportError(JSContext* aCx, const nsAString& aMessage); + + void + RetrieveConsoleEvents(JSContext* aCx, nsTArray<JS::Value>& aEvents, + ErrorResult& aRv); + + void + SetConsoleEventHandler(JSContext* aCx, AnyCallback* aHandler, + ErrorResult& aRv); + + Console* + GetConsole(ErrorResult& aRv); + + Console* + GetConsoleIfExists() const + { + return mConsole; + } + + void + Dump(JSContext* aCx, const Optional<nsAString>& aString) const; + +private: + virtual ~WorkerDebuggerGlobalScope(); +}; + +} // namespace dom +} // namespace mozilla + +inline nsISupports* +ToSupports(mozilla::dom::WorkerGlobalScope* aScope) +{ + return static_cast<nsIDOMEventTarget*>(aScope); +} + +#endif /* mozilla_dom_workerscope_h__ */ diff --git a/dom/workers/WorkerThread.cpp b/dom/workers/WorkerThread.cpp new file mode 100644 index 000000000..7a7cb7ac3 --- /dev/null +++ b/dom/workers/WorkerThread.cpp @@ -0,0 +1,355 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WorkerThread.h" + +#include "mozilla/Assertions.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "nsIThreadInternal.h" +#include "WorkerPrivate.h" +#include "WorkerRunnable.h" + +#ifdef DEBUG +#include "nsThreadManager.h" +#endif + +namespace mozilla { +namespace dom { +namespace workers { + +using namespace mozilla::ipc; + +namespace { + +// The C stack size. We use the same stack size on all platforms for +// consistency. +const uint32_t kWorkerStackSize = 256 * sizeof(size_t) * 1024; + +} // namespace + +WorkerThreadFriendKey::WorkerThreadFriendKey() +{ + MOZ_COUNT_CTOR(WorkerThreadFriendKey); +} + +WorkerThreadFriendKey::~WorkerThreadFriendKey() +{ + MOZ_COUNT_DTOR(WorkerThreadFriendKey); +} + +class WorkerThread::Observer final + : public nsIThreadObserver +{ + WorkerPrivate* mWorkerPrivate; + +public: + explicit Observer(WorkerPrivate* aWorkerPrivate) + : mWorkerPrivate(aWorkerPrivate) + { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + } + + NS_DECL_THREADSAFE_ISUPPORTS + +private: + ~Observer() + { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + + NS_DECL_NSITHREADOBSERVER +}; + +WorkerThread::WorkerThread() + : nsThread(nsThread::NOT_MAIN_THREAD, kWorkerStackSize) + , mWorkerPrivateCondVar(mLock, "WorkerThread::mWorkerPrivateCondVar") + , mWorkerPrivate(nullptr) + , mOtherThreadsDispatchingViaEventTarget(0) +#ifdef DEBUG + , mAcceptingNonWorkerRunnables(true) +#endif +{ +} + +WorkerThread::~WorkerThread() +{ + MOZ_ASSERT(!mWorkerPrivate); + MOZ_ASSERT(!mOtherThreadsDispatchingViaEventTarget); + MOZ_ASSERT(mAcceptingNonWorkerRunnables); +} + +// static +already_AddRefed<WorkerThread> +WorkerThread::Create(const WorkerThreadFriendKey& /* aKey */) +{ + RefPtr<WorkerThread> thread = new WorkerThread(); + if (NS_FAILED(thread->Init())) { + NS_WARNING("Failed to create new thread!"); + return nullptr; + } + + return thread.forget(); +} + +void +WorkerThread::SetWorker(const WorkerThreadFriendKey& /* aKey */, + WorkerPrivate* aWorkerPrivate) +{ + MOZ_ASSERT(PR_GetCurrentThread() == mThread); + + if (aWorkerPrivate) { + { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(!mWorkerPrivate); + MOZ_ASSERT(mAcceptingNonWorkerRunnables); + + mWorkerPrivate = aWorkerPrivate; +#ifdef DEBUG + mAcceptingNonWorkerRunnables = false; +#endif + } + + mObserver = new Observer(aWorkerPrivate); + MOZ_ALWAYS_SUCCEEDS(AddObserver(mObserver)); + } else { + MOZ_ALWAYS_SUCCEEDS(RemoveObserver(mObserver)); + mObserver = nullptr; + + { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(!mAcceptingNonWorkerRunnables); + MOZ_ASSERT(!mOtherThreadsDispatchingViaEventTarget, + "XPCOM Dispatch hapenning at the same time our thread is " + "being unset! This should not be possible!"); + + while (mOtherThreadsDispatchingViaEventTarget) { + mWorkerPrivateCondVar.Wait(); + } + +#ifdef DEBUG + mAcceptingNonWorkerRunnables = true; +#endif + mWorkerPrivate = nullptr; + } + } +} + +nsresult +WorkerThread::DispatchPrimaryRunnable(const WorkerThreadFriendKey& /* aKey */, + already_AddRefed<nsIRunnable> aRunnable) +{ + nsCOMPtr<nsIRunnable> runnable(aRunnable); + +#ifdef DEBUG + MOZ_ASSERT(PR_GetCurrentThread() != mThread); + MOZ_ASSERT(runnable); + { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(!mWorkerPrivate); + MOZ_ASSERT(mAcceptingNonWorkerRunnables); + } +#endif + + nsresult rv = nsThread::Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +nsresult +WorkerThread::DispatchAnyThread(const WorkerThreadFriendKey& /* aKey */, + already_AddRefed<WorkerRunnable> aWorkerRunnable) +{ + // May be called on any thread! + +#ifdef DEBUG + { + const bool onWorkerThread = PR_GetCurrentThread() == mThread; + { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(mWorkerPrivate); + MOZ_ASSERT(!mAcceptingNonWorkerRunnables); + + if (onWorkerThread) { + mWorkerPrivate->AssertIsOnWorkerThread(); + } + } + } +#endif + nsCOMPtr<nsIRunnable> runnable(aWorkerRunnable); + + nsresult rv = nsThread::Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // We don't need to notify the worker's condition variable here because we're + // being called from worker-controlled code and it will make sure to wake up + // the worker thread if needed. + + return NS_OK; +} + +NS_IMPL_ISUPPORTS_INHERITED0(WorkerThread, nsThread) + +NS_IMETHODIMP +WorkerThread::DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) +{ + nsCOMPtr<nsIRunnable> runnable(aRunnable); + return Dispatch(runnable.forget(), aFlags); +} + +NS_IMETHODIMP +WorkerThread::Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) +{ + // May be called on any thread! + nsCOMPtr<nsIRunnable> runnable(aRunnable); // in case we exit early + + // Workers only support asynchronous dispatch. + if (NS_WARN_IF(aFlags != NS_DISPATCH_NORMAL)) { + return NS_ERROR_UNEXPECTED; + } + + const bool onWorkerThread = PR_GetCurrentThread() == mThread; + +#ifdef DEBUG + if (runnable && !onWorkerThread) { + nsCOMPtr<nsICancelableRunnable> cancelable = do_QueryInterface(runnable); + + { + MutexAutoLock lock(mLock); + + // Only enforce cancelable runnables after we've started the worker loop. + if (!mAcceptingNonWorkerRunnables) { + MOZ_ASSERT(cancelable, + "Only nsICancelableRunnable may be dispatched to a worker!"); + } + } + } +#endif + + WorkerPrivate* workerPrivate = nullptr; + if (onWorkerThread) { + // No need to lock here because it is only modified on this thread. + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + + workerPrivate = mWorkerPrivate; + } else { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(mOtherThreadsDispatchingViaEventTarget < UINT32_MAX); + + if (mWorkerPrivate) { + workerPrivate = mWorkerPrivate; + + // Incrementing this counter will make the worker thread sleep if it + // somehow tries to unset mWorkerPrivate while we're using it. + mOtherThreadsDispatchingViaEventTarget++; + } + } + + nsresult rv; + if (runnable && onWorkerThread) { + RefPtr<WorkerRunnable> workerRunnable = workerPrivate->MaybeWrapAsWorkerRunnable(runnable.forget()); + rv = nsThread::Dispatch(workerRunnable.forget(), NS_DISPATCH_NORMAL); + } else { + rv = nsThread::Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); + } + + if (!onWorkerThread && workerPrivate) { + // We need to wake the worker thread if we're not already on the right + // thread and the dispatch succeeded. + if (NS_SUCCEEDED(rv)) { + MutexAutoLock workerLock(workerPrivate->mMutex); + + workerPrivate->mCondVar.Notify(); + } + + // Now unset our waiting flag. + { + MutexAutoLock lock(mLock); + + MOZ_ASSERT(mOtherThreadsDispatchingViaEventTarget); + + if (!--mOtherThreadsDispatchingViaEventTarget) { + mWorkerPrivateCondVar.Notify(); + } + } + } + + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +NS_IMETHODIMP +WorkerThread::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +uint32_t +WorkerThread::RecursionDepth(const WorkerThreadFriendKey& /* aKey */) const +{ + MOZ_ASSERT(PR_GetCurrentThread() == mThread); + + return mNestedEventLoopDepth; +} + +NS_IMPL_ISUPPORTS(WorkerThread::Observer, nsIThreadObserver) + +NS_IMETHODIMP +WorkerThread::Observer::OnDispatchedEvent(nsIThreadInternal* /* aThread */) +{ + MOZ_CRASH("OnDispatchedEvent() should never be called!"); +} + +NS_IMETHODIMP +WorkerThread::Observer::OnProcessNextEvent(nsIThreadInternal* /* aThread */, + bool aMayWait) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + // If the PBackground child is not created yet, then we must permit + // blocking event processing to support + // BackgroundChild::SynchronouslyCreateForCurrentThread(). If this occurs + // then we are spinning on the event queue at the start of + // PrimaryWorkerRunnable::Run() and don't want to process the event in + // mWorkerPrivate yet. + if (aMayWait) { + MOZ_ASSERT(CycleCollectedJSContext::Get()->RecursionDepth() == 2); + MOZ_ASSERT(!BackgroundChild::GetForCurrentThread()); + return NS_OK; + } + + mWorkerPrivate->OnProcessNextEvent(); + return NS_OK; +} + +NS_IMETHODIMP +WorkerThread::Observer::AfterProcessNextEvent(nsIThreadInternal* /* aThread */, + bool /* aEventWasProcessed */) +{ + mWorkerPrivate->AssertIsOnWorkerThread(); + + mWorkerPrivate->AfterProcessNextEvent(); + return NS_OK; +} + +} // namespace workers +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/WorkerThread.h b/dom/workers/WorkerThread.h new file mode 100644 index 000000000..f1287023d --- /dev/null +++ b/dom/workers/WorkerThread.h @@ -0,0 +1,110 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_WorkerThread_h__ +#define mozilla_dom_workers_WorkerThread_h__ + +#include "mozilla/Attributes.h" +#include "mozilla/CondVar.h" +#include "mozilla/DebugOnly.h" +#include "nsISupportsImpl.h" +#include "mozilla/RefPtr.h" +#include "nsThread.h" + +class nsIRunnable; + +namespace mozilla { +namespace dom { +namespace workers { + +class RuntimeService; +class WorkerPrivate; +template <class> class WorkerPrivateParent; +class WorkerRunnable; + +// This class lets us restrict the public methods that can be called on +// WorkerThread to RuntimeService and WorkerPrivate without letting them gain +// full access to private methods (as would happen if they were simply friends). +class WorkerThreadFriendKey +{ + friend class RuntimeService; + friend class WorkerPrivate; + friend class WorkerPrivateParent<WorkerPrivate>; + + WorkerThreadFriendKey(); + ~WorkerThreadFriendKey(); +}; + +class WorkerThread final + : public nsThread +{ + class Observer; + + CondVar mWorkerPrivateCondVar; + + // Protected by nsThread::mLock. + WorkerPrivate* mWorkerPrivate; + + // Only touched on the target thread. + RefPtr<Observer> mObserver; + + // Protected by nsThread::mLock and waited on with mWorkerPrivateCondVar. + uint32_t mOtherThreadsDispatchingViaEventTarget; + +#ifdef DEBUG + // Protected by nsThread::mLock. + bool mAcceptingNonWorkerRunnables; +#endif + +public: + static already_AddRefed<WorkerThread> + Create(const WorkerThreadFriendKey& aKey); + + void + SetWorker(const WorkerThreadFriendKey& aKey, WorkerPrivate* aWorkerPrivate); + + nsresult + DispatchPrimaryRunnable(const WorkerThreadFriendKey& aKey, + already_AddRefed<nsIRunnable> aRunnable); + + nsresult + DispatchAnyThread(const WorkerThreadFriendKey& aKey, + already_AddRefed<WorkerRunnable> aWorkerRunnable); + + uint32_t + RecursionDepth(const WorkerThreadFriendKey& aKey) const; + + // Required for MinGW build #1336527 to handle compiler bug: + // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79582 + NS_IMETHOD + RegisterIdlePeriod(already_AddRefed<nsIIdlePeriod> aIdlePeriod) override + { + return nsThread::RegisterIdlePeriod(already_AddRefed<nsIIdlePeriod>(aIdlePeriod.take())); + } + + NS_DECL_ISUPPORTS_INHERITED + +private: + WorkerThread(); + ~WorkerThread(); + + // This should only be called by consumers that have an + // nsIEventTarget/nsIThread pointer. + NS_IMETHOD + Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) override; + + NS_IMETHOD + DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) override; + + NS_IMETHOD + DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) override; +}; + +} // namespace workers +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_WorkerThread_h__ diff --git a/dom/workers/Workers.h b/dom/workers/Workers.h new file mode 100644 index 000000000..89e2ccfca --- /dev/null +++ b/dom/workers/Workers.h @@ -0,0 +1,383 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_workers_h__ +#define mozilla_dom_workers_workers_h__ + +#include "jsapi.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" +#include <stdint.h> +#include "nsAutoPtr.h" +#include "nsCOMPtr.h" +#include "nsDebug.h" +#include "nsString.h" +#include "nsTArray.h" + +#include "nsILoadContext.h" +#include "nsIWeakReferenceUtils.h" +#include "nsIInterfaceRequestor.h" +#include "mozilla/dom/ChannelInfo.h" +#include "mozilla/net/ReferrerPolicy.h" + +#define BEGIN_WORKERS_NAMESPACE \ + namespace mozilla { namespace dom { namespace workers { +#define END_WORKERS_NAMESPACE \ + } /* namespace workers */ } /* namespace dom */ } /* namespace mozilla */ +#define USING_WORKERS_NAMESPACE \ + using namespace mozilla::dom::workers; + +#define WORKERS_SHUTDOWN_TOPIC "web-workers-shutdown" + +class nsIContentSecurityPolicy; +class nsIScriptContext; +class nsIGlobalObject; +class nsPIDOMWindowInner; +class nsIPrincipal; +class nsILoadGroup; +class nsITabChild; +class nsIChannel; +class nsIRunnable; +class nsIURI; + +namespace mozilla { +namespace ipc { +class PrincipalInfo; +} // namespace ipc + +namespace dom { +// If you change this, the corresponding list in nsIWorkerDebugger.idl needs to +// be updated too. +enum WorkerType +{ + WorkerTypeDedicated, + WorkerTypeShared, + WorkerTypeService +}; + +} // namespace dom +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +class WorkerPrivate; + +struct PrivatizableBase +{ }; + +#ifdef DEBUG +void +AssertIsOnMainThread(); +#else +inline void +AssertIsOnMainThread() +{ } +#endif + +struct JSSettings +{ + enum { + // All the GC parameters that we support. + JSSettings_JSGC_MAX_BYTES = 0, + JSSettings_JSGC_MAX_MALLOC_BYTES, + JSSettings_JSGC_HIGH_FREQUENCY_TIME_LIMIT, + JSSettings_JSGC_LOW_FREQUENCY_HEAP_GROWTH, + JSSettings_JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN, + JSSettings_JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX, + JSSettings_JSGC_HIGH_FREQUENCY_LOW_LIMIT, + JSSettings_JSGC_HIGH_FREQUENCY_HIGH_LIMIT, + JSSettings_JSGC_ALLOCATION_THRESHOLD, + JSSettings_JSGC_SLICE_TIME_BUDGET, + JSSettings_JSGC_DYNAMIC_HEAP_GROWTH, + JSSettings_JSGC_DYNAMIC_MARK_SLICE, + JSSettings_JSGC_REFRESH_FRAME_SLICES, + // JSGC_MODE not supported + + // This must be last so that we get an accurate count. + kGCSettingsArraySize + }; + + struct JSGCSetting + { + JSGCParamKey key; + uint32_t value; + + JSGCSetting() + : key(static_cast<JSGCParamKey>(-1)), value(0) + { } + + bool + IsSet() const + { + return key != static_cast<JSGCParamKey>(-1); + } + + void + Unset() + { + key = static_cast<JSGCParamKey>(-1); + value = 0; + } + }; + + // There are several settings that we know we need so it makes sense to + // preallocate here. + typedef JSGCSetting JSGCSettingsArray[kGCSettingsArraySize]; + + // Settings that change based on chrome/content context. + struct JSContentChromeSettings + { + JS::CompartmentOptions compartmentOptions; + int32_t maxScriptRuntime; + + JSContentChromeSettings() + : compartmentOptions(), maxScriptRuntime(0) + { } + }; + + JSContentChromeSettings chrome; + JSContentChromeSettings content; + JSGCSettingsArray gcSettings; + JS::ContextOptions contextOptions; + +#ifdef JS_GC_ZEAL + uint8_t gcZeal; + uint32_t gcZealFrequency; +#endif + + JSSettings() +#ifdef JS_GC_ZEAL + : gcZeal(0), gcZealFrequency(0) +#endif + { + for (uint32_t index = 0; index < ArrayLength(gcSettings); index++) { + new (gcSettings + index) JSGCSetting(); + } + } + + bool + ApplyGCSetting(JSGCParamKey aKey, uint32_t aValue) + { + JSSettings::JSGCSetting* firstEmptySetting = nullptr; + JSSettings::JSGCSetting* foundSetting = nullptr; + + for (uint32_t index = 0; index < ArrayLength(gcSettings); index++) { + JSSettings::JSGCSetting& setting = gcSettings[index]; + if (setting.key == aKey) { + foundSetting = &setting; + break; + } + if (!firstEmptySetting && !setting.IsSet()) { + firstEmptySetting = &setting; + } + } + + if (aValue) { + if (!foundSetting) { + foundSetting = firstEmptySetting; + if (!foundSetting) { + NS_ERROR("Not enough space for this value!"); + return false; + } + } + foundSetting->key = aKey; + foundSetting->value = aValue; + return true; + } + + if (foundSetting) { + foundSetting->Unset(); + return true; + } + + return false; + } +}; + +enum WorkerPreference +{ +#define WORKER_SIMPLE_PREF(name, getter, NAME) WORKERPREF_ ## NAME, +#define WORKER_PREF(name, callback) +#include "mozilla/dom/WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + WORKERPREF_COUNT +}; + +// Implemented in WorkerPrivate.cpp + +struct WorkerLoadInfo +{ + // All of these should be released in WorkerPrivateParent::ForgetMainThreadObjects. + nsCOMPtr<nsIURI> mBaseURI; + nsCOMPtr<nsIURI> mResolvedScriptURI; + nsCOMPtr<nsIPrincipal> mPrincipal; + nsCOMPtr<nsIScriptContext> mScriptContext; + nsCOMPtr<nsPIDOMWindowInner> mWindow; + nsCOMPtr<nsIContentSecurityPolicy> mCSP; + nsCOMPtr<nsIChannel> mChannel; + nsCOMPtr<nsILoadGroup> mLoadGroup; + + // mLoadFailedAsyncRunnable will execute on main thread if script loading + // fails during script loading. If script loading is never started due to + // a synchronous error, then the runnable is never executed. The runnable + // is guaranteed to be released on the main thread. + nsCOMPtr<nsIRunnable> mLoadFailedAsyncRunnable; + + class InterfaceRequestor final : public nsIInterfaceRequestor + { + NS_DECL_ISUPPORTS + + public: + InterfaceRequestor(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup); + void MaybeAddTabChild(nsILoadGroup* aLoadGroup); + NS_IMETHOD GetInterface(const nsIID& aIID, void** aSink) override; + + private: + ~InterfaceRequestor() { } + + already_AddRefed<nsITabChild> GetAnyLiveTabChild(); + + nsCOMPtr<nsILoadContext> mLoadContext; + nsCOMPtr<nsIInterfaceRequestor> mOuterRequestor; + + // Array of weak references to nsITabChild. We do not want to keep TabChild + // actors alive for long after their ActorDestroy() methods are called. + nsTArray<nsWeakPtr> mTabChildList; + }; + + // Only set if we have a custom overriden load group + RefPtr<InterfaceRequestor> mInterfaceRequestor; + + nsAutoPtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo; + nsCString mDomain; + + nsString mServiceWorkerCacheName; + + ChannelInfo mChannelInfo; + + uint64_t mWindowID; + uint64_t mServiceWorkerID; + + net::ReferrerPolicy mReferrerPolicy; + bool mFromWindow; + bool mEvalAllowed; + bool mReportCSPViolations; + bool mXHRParamsAllowed; + bool mPrincipalIsSystem; + bool mStorageAllowed; + bool mServiceWorkersTestingInWindow; + PrincipalOriginAttributes mOriginAttributes; + + WorkerLoadInfo(); + ~WorkerLoadInfo(); + + void StealFrom(WorkerLoadInfo& aOther); +}; + +// All of these are implemented in RuntimeService.cpp + +void +CancelWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +FreezeWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +ThawWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +SuspendWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +ResumeWorkersForWindow(nsPIDOMWindowInner* aWindow); + +// A class that can be used with WorkerCrossThreadDispatcher to run a +// bit of C++ code on the worker thread. +class WorkerTask +{ +protected: + WorkerTask() + { } + + virtual ~WorkerTask() + { } + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerTask) + + // The return value here has the same semantics as the return value + // of WorkerRunnable::WorkerRun. + virtual bool + RunTask(JSContext* aCx) = 0; +}; + +class WorkerCrossThreadDispatcher +{ + friend class WorkerPrivate; + + // Must be acquired *before* the WorkerPrivate's mutex, when they're both + // held. + Mutex mMutex; + WorkerPrivate* mWorkerPrivate; + +private: + // Only created by WorkerPrivate. + explicit WorkerCrossThreadDispatcher(WorkerPrivate* aWorkerPrivate); + + // Only called by WorkerPrivate. + void + Forget() + { + MutexAutoLock lock(mMutex); + mWorkerPrivate = nullptr; + } + + ~WorkerCrossThreadDispatcher() {} + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerCrossThreadDispatcher) + + // Generically useful function for running a bit of C++ code on the worker + // thread. + bool + PostTask(WorkerTask* aTask); +}; + +WorkerCrossThreadDispatcher* +GetWorkerCrossThreadDispatcher(JSContext* aCx, const JS::Value& aWorker); + +// Random unique constant to facilitate JSPrincipal debugging +const uint32_t kJSPrincipalsDebugToken = 0x7e2df9d2; + +namespace exceptions { + +// Implemented in Exceptions.cpp +void +ThrowDOMExceptionForNSResult(JSContext* aCx, nsresult aNSResult); + +} // namespace exceptions + +bool +IsWorkerGlobal(JSObject* global); + +bool +IsDebuggerGlobal(JSObject* global); + +bool +IsDebuggerSandbox(JSObject* object); + +// Throws the JSMSG_GETTER_ONLY exception. This shouldn't be used going +// forward -- getter-only properties should just use JS_PSG for the setter +// (implying no setter at all), which will not throw when set in non-strict +// code but will in strict code. Old code should use this only for temporary +// compatibility reasons. +extern bool +GetterOnlyJSNative(JSContext* aCx, unsigned aArgc, JS::Value* aVp); + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_workers_h__ diff --git a/dom/workers/moz.build b/dom/workers/moz.build new file mode 100644 index 000000000..4f4b52e4a --- /dev/null +++ b/dom/workers/moz.build @@ -0,0 +1,131 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +# Public stuff. +EXPORTS.mozilla.dom += [ + 'FileReaderSync.h', + 'ServiceWorkerCommon.h', + 'ServiceWorkerContainer.h', + 'ServiceWorkerEvents.h', + 'ServiceWorkerRegistrar.h', + 'ServiceWorkerRegistration.h', + 'WorkerLocation.h', + 'WorkerNavigator.h', + 'WorkerPrefs.h', + 'WorkerPrivate.h', + 'WorkerRunnable.h', + 'WorkerScope.h', +] + +EXPORTS.mozilla.dom.workers += [ + 'RuntimeService.h', + 'ServiceWorkerInfo.h', + 'ServiceWorkerManager.h', + 'ServiceWorkerRegistrationInfo.h', + 'WorkerDebuggerManager.h', + 'Workers.h', +] + +# Stuff needed for the bindings, not really public though. +EXPORTS.mozilla.dom.workers.bindings += [ + 'ServiceWorker.h', + 'ServiceWorkerClient.h', + 'ServiceWorkerClients.h', + 'ServiceWorkerWindowClient.h', + 'SharedWorker.h', + 'WorkerHolder.h', +] + +XPIDL_MODULE = 'dom_workers' + +XPIDL_SOURCES += [ + 'nsIWorkerDebugger.idl', + 'nsIWorkerDebuggerManager.idl', +] + +UNIFIED_SOURCES += [ + 'ChromeWorkerScope.cpp', + 'FileReaderSync.cpp', + 'Principal.cpp', + 'RegisterBindings.cpp', + 'RuntimeService.cpp', + 'ScriptLoader.cpp', + 'ServiceWorker.cpp', + 'ServiceWorkerClient.cpp', + 'ServiceWorkerClients.cpp', + 'ServiceWorkerContainer.cpp', + 'ServiceWorkerEvents.cpp', + 'ServiceWorkerInfo.cpp', + 'ServiceWorkerJob.cpp', + 'ServiceWorkerJobQueue.cpp', + 'ServiceWorkerManager.cpp', + 'ServiceWorkerManagerChild.cpp', + 'ServiceWorkerManagerParent.cpp', + 'ServiceWorkerManagerService.cpp', + 'ServiceWorkerPrivate.cpp', + 'ServiceWorkerRegisterJob.cpp', + 'ServiceWorkerRegistrar.cpp', + 'ServiceWorkerRegistration.cpp', + 'ServiceWorkerRegistrationInfo.cpp', + 'ServiceWorkerScriptCache.cpp', + 'ServiceWorkerUnregisterJob.cpp', + 'ServiceWorkerUpdateJob.cpp', + 'ServiceWorkerWindowClient.cpp', + 'SharedWorker.cpp', + 'WorkerDebuggerManager.cpp', + 'WorkerHolder.cpp', + 'WorkerLocation.cpp', + 'WorkerNavigator.cpp', + 'WorkerPrivate.cpp', + 'WorkerRunnable.cpp', + 'WorkerScope.cpp', + 'WorkerThread.cpp', +] + +IPDL_SOURCES += [ + 'PServiceWorkerManager.ipdl', + 'ServiceWorkerRegistrarTypes.ipdlh', +] + +LOCAL_INCLUDES += [ + '../base', + '../system', + '/dom/base', + '/xpcom/build', + '/xpcom/threads', +] + +include('/ipc/chromium/chromium-config.mozbuild') + +FINAL_LIBRARY = 'xul' + +TEST_DIRS += [ + 'test/extensions/bootstrap', + 'test/extensions/traditional', +] + +MOCHITEST_MANIFESTS += [ + 'test/mochitest.ini', + 'test/serviceworkers/mochitest.ini', +] + +MOCHITEST_CHROME_MANIFESTS += [ + 'test/chrome.ini', + 'test/serviceworkers/chrome.ini' +] + +BROWSER_CHROME_MANIFESTS += [ + 'test/serviceworkers/browser.ini', +] + +XPCSHELL_TESTS_MANIFESTS += ['test/xpcshell/xpcshell.ini'] + +BROWSER_CHROME_MANIFESTS += ['test/browser.ini'] + +TEST_DIRS += ['test/gtest'] + +if CONFIG['GNU_CXX']: + CXXFLAGS += ['-Wno-error=shadow'] diff --git a/dom/workers/nsIWorkerDebugger.idl b/dom/workers/nsIWorkerDebugger.idl new file mode 100644 index 000000000..f8144f3da --- /dev/null +++ b/dom/workers/nsIWorkerDebugger.idl @@ -0,0 +1,50 @@ +#include "nsISupports.idl" + +interface mozIDOMWindow; +interface nsIPrincipal; + +[scriptable, uuid(9cf3b48e-361d-486a-8917-55cf8d00bb41)] +interface nsIWorkerDebuggerListener : nsISupports +{ + void onClose(); + + void onError(in DOMString filename, in unsigned long lineno, + in DOMString message); + + void onMessage(in DOMString message); +}; + +[scriptable, builtinclass, uuid(22f93aa3-8a05-46be-87e0-fa93bf8a8eff)] +interface nsIWorkerDebugger : nsISupports +{ + const unsigned long TYPE_DEDICATED = 0; + const unsigned long TYPE_SHARED = 1; + const unsigned long TYPE_SERVICE = 2; + + readonly attribute bool isClosed; + + readonly attribute bool isChrome; + + readonly attribute bool isInitialized; + + readonly attribute nsIWorkerDebugger parent; + + readonly attribute unsigned long type; + + readonly attribute DOMString url; + + readonly attribute mozIDOMWindow window; + + readonly attribute nsIPrincipal principal; + + readonly attribute unsigned long serviceWorkerID; + + void initialize(in DOMString url); + + [binaryname(PostMessageMoz)] + void postMessage(in DOMString message); + + void addListener(in nsIWorkerDebuggerListener listener); + + void removeListener(in nsIWorkerDebuggerListener listener); +}; diff --git a/dom/workers/nsIWorkerDebuggerManager.idl b/dom/workers/nsIWorkerDebuggerManager.idl new file mode 100644 index 000000000..f7a0fb309 --- /dev/null +++ b/dom/workers/nsIWorkerDebuggerManager.idl @@ -0,0 +1,22 @@ +#include "nsISupports.idl" + +interface nsISimpleEnumerator; +interface nsIWorkerDebugger; + +[scriptable, uuid(d2aa74ee-6b98-4d5d-8173-4e23422daf1e)] +interface nsIWorkerDebuggerManagerListener : nsISupports +{ + void onRegister(in nsIWorkerDebugger debugger); + + void onUnregister(in nsIWorkerDebugger debugger); +}; + +[scriptable, builtinclass, uuid(056d7918-dc86-452a-b4e6-86da3405f015)] +interface nsIWorkerDebuggerManager : nsISupports +{ + nsISimpleEnumerator getWorkerDebuggerEnumerator(); + + void addListener(in nsIWorkerDebuggerManagerListener listener); + + void removeListener(in nsIWorkerDebuggerManagerListener listener); +}; diff --git a/dom/workers/test/404_server.sjs b/dom/workers/test/404_server.sjs new file mode 100644 index 000000000..f5dff1abb --- /dev/null +++ b/dom/workers/test/404_server.sjs @@ -0,0 +1,10 @@ +function handleRequest(request, response) +{ + response.setStatusLine(request.httpVersion, 404, "Not found"); + + // Any valid JS. + if (request.queryString == 'js') { + response.setHeader("Content-Type", "text/javascript", false); + response.write('4 + 4'); + } +} diff --git a/dom/workers/test/WorkerDebugger.console_childWorker.js b/dom/workers/test/WorkerDebugger.console_childWorker.js new file mode 100644 index 000000000..8cee6809e --- /dev/null +++ b/dom/workers/test/WorkerDebugger.console_childWorker.js @@ -0,0 +1,3 @@ +"use strict"; + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebugger.console_debugger.js b/dom/workers/test/WorkerDebugger.console_debugger.js new file mode 100644 index 000000000..662bd3520 --- /dev/null +++ b/dom/workers/test/WorkerDebugger.console_debugger.js @@ -0,0 +1,41 @@ +"use strict" + +function ok(a, msg) { + postMessage(JSON.stringify({ type: 'status', what: !!a, msg: msg })); +} + +function is(a, b, msg) { + ok(a === b, msg); +} + +function finish() { + postMessage(JSON.stringify({ type: 'finish' })); +} + +function magic() { + console.log("Hello from the debugger script!"); + + var foo = retrieveConsoleEvents(); + ok(Array.isArray(foo), "We received an array."); + ok(foo.length >= 2, "At least 2 messages."); + + is(foo[0].arguments[0], "Can you see this console message?", "First message ok."); + is(foo[1].arguments[0], "Can you see this second console message?", "Second message ok."); + + setConsoleEventHandler(function(consoleData) { + is(consoleData.arguments[0], "Random message.", "Random message ok!"); + + // The consoleEventHandler can be null. + setConsoleEventHandler(null); + + finish(); + }); +} + +this.onmessage = function (event) { + switch (event.data) { + case "do magic": + magic(); + break; + } +}; diff --git a/dom/workers/test/WorkerDebugger.console_worker.js b/dom/workers/test/WorkerDebugger.console_worker.js new file mode 100644 index 000000000..2db43a3d7 --- /dev/null +++ b/dom/workers/test/WorkerDebugger.console_worker.js @@ -0,0 +1,10 @@ +"use strict"; + +console.log("Can you see this console message?"); +console.warn("Can you see this second console message?"); + +var worker = new Worker("WorkerDebugger.console_childWorker.js"); + +setInterval(function() { + console.log("Random message."); +}, 200); diff --git a/dom/workers/test/WorkerDebugger.initialize_childWorker.js b/dom/workers/test/WorkerDebugger.initialize_childWorker.js new file mode 100644 index 000000000..a85764bd9 --- /dev/null +++ b/dom/workers/test/WorkerDebugger.initialize_childWorker.js @@ -0,0 +1,6 @@ +"use strict"; + +self.onmessage = function () {}; + +debugger; +postMessage("worker"); diff --git a/dom/workers/test/WorkerDebugger.initialize_debugger.js b/dom/workers/test/WorkerDebugger.initialize_debugger.js new file mode 100644 index 000000000..f52e95b15 --- /dev/null +++ b/dom/workers/test/WorkerDebugger.initialize_debugger.js @@ -0,0 +1,6 @@ +"use strict"; + +var dbg = new Debugger(global); +dbg.onDebuggerStatement = function (frame) { + frame.eval("postMessage('debugger');"); +}; diff --git a/dom/workers/test/WorkerDebugger.initialize_worker.js b/dom/workers/test/WorkerDebugger.initialize_worker.js new file mode 100644 index 000000000..5a24efd3a --- /dev/null +++ b/dom/workers/test/WorkerDebugger.initialize_worker.js @@ -0,0 +1,9 @@ +"use strict"; + +var worker = new Worker("WorkerDebugger.initialize_childWorker.js"); +worker.onmessage = function (event) { + postMessage("child:" + event.data); +}; + +debugger; +postMessage("worker"); diff --git a/dom/workers/test/WorkerDebugger.postMessage_childWorker.js b/dom/workers/test/WorkerDebugger.postMessage_childWorker.js new file mode 100644 index 000000000..8cee6809e --- /dev/null +++ b/dom/workers/test/WorkerDebugger.postMessage_childWorker.js @@ -0,0 +1,3 @@ +"use strict"; + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebugger.postMessage_debugger.js b/dom/workers/test/WorkerDebugger.postMessage_debugger.js new file mode 100644 index 000000000..4a231b7ab --- /dev/null +++ b/dom/workers/test/WorkerDebugger.postMessage_debugger.js @@ -0,0 +1,9 @@ +"use strict" + +this.onmessage = function (event) { + switch (event.data) { + case "ping": + postMessage("pong"); + break; + } +}; diff --git a/dom/workers/test/WorkerDebugger.postMessage_worker.js b/dom/workers/test/WorkerDebugger.postMessage_worker.js new file mode 100644 index 000000000..8ddf6cf86 --- /dev/null +++ b/dom/workers/test/WorkerDebugger.postMessage_worker.js @@ -0,0 +1,3 @@ +"use strict"; + +var worker = new Worker("WorkerDebugger.postMessage_childWorker.js"); diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_debugger.js b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_debugger.js new file mode 100644 index 000000000..908c9f316 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_debugger.js @@ -0,0 +1,9 @@ +"use strict"; + +const SANDBOX_URL = "WorkerDebuggerGlobalScope.createSandbox_sandbox.js"; + +var prototype = { + self: this, +}; +var sandbox = createSandbox(SANDBOX_URL, prototype); +loadSubScript(SANDBOX_URL, sandbox); diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_sandbox.js b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_sandbox.js new file mode 100644 index 000000000..f94d65062 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_sandbox.js @@ -0,0 +1,9 @@ +"use strict"; + +self.addEventListener("message", function(event) { + switch (event.data) { + case "ping": + self.postMessage("pong"); + break; + } +}); diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_worker.js b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_worker.js new file mode 100644 index 000000000..8cee6809e --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.createSandbox_worker.js @@ -0,0 +1,3 @@ +"use strict"; + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js new file mode 100644 index 000000000..b76f45a4d --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js @@ -0,0 +1,14 @@ +"use strict"; + +function f() { + debugger; +} + +self.onmessage = function (event) { + switch (event.data) { + case "ping": + debugger; + postMessage("pong"); + break; + }; +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_debugger.js b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_debugger.js new file mode 100644 index 000000000..dcd4dbecd --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_debugger.js @@ -0,0 +1,29 @@ +"use strict"; + +var frames = []; + +var dbg = new Debugger(global); +dbg.onDebuggerStatement = function (frame) { + frames.push(frame); + postMessage("paused"); + enterEventLoop(); + frames.pop(); + postMessage("resumed"); +}; + +this.onmessage = function (event) { + switch (event.data) { + case "eval": + frames[frames.length - 1].eval("f()"); + postMessage("evalled"); + break; + + case "ping": + postMessage("pong"); + break; + + case "resume": + leaveEventLoop(); + break; + }; +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_worker.js b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_worker.js new file mode 100644 index 000000000..c43738516 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.enterEventLoop_worker.js @@ -0,0 +1,25 @@ +"use strict"; + +function f() { + debugger; +} + +var worker = new Worker("WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js"); + +worker.onmessage = function (event) { + postMessage("child:" + event.data); +}; + +self.onmessage = function (event) { + var message = event.data; + if (message.indexOf(":") >= 0) { + worker.postMessage(message.split(":")[1]); + return; + } + switch (message) { + case "ping": + debugger; + postMessage("pong"); + break; + }; +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.reportError_childWorker.js b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_childWorker.js new file mode 100644 index 000000000..823e7c477 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_childWorker.js @@ -0,0 +1,5 @@ +"use strict"; + +self.onerror = function () { + postMessage("error"); +} diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.reportError_debugger.js b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_debugger.js new file mode 100644 index 000000000..67ea08de5 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_debugger.js @@ -0,0 +1,12 @@ +"use strict"; + +this.onmessage = function (event) { + switch (event.data) { + case "report": + reportError("reported"); + break; + case "throw": + throw new Error("thrown"); + break; + } +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.reportError_worker.js b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_worker.js new file mode 100644 index 000000000..67ccfc2ca --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.reportError_worker.js @@ -0,0 +1,11 @@ +"use strict"; + +var worker = new Worker("WorkerDebuggerGlobalScope.reportError_childWorker.js"); + +worker.onmessage = function (event) { + postMessage("child:" + event.data); +}; + +self.onerror = function () { + postMessage("error"); +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_debugger.js b/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_debugger.js new file mode 100644 index 000000000..b5075c70f --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_debugger.js @@ -0,0 +1,12 @@ +"use strict"; + +this.onmessage = function (event) { + switch (event.data) { + case "ping": + setImmediate(function () { + postMessage("pong1"); + }); + postMessage("pong2"); + break; + } +}; diff --git a/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_worker.js b/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_worker.js new file mode 100644 index 000000000..5a72b0f24 --- /dev/null +++ b/dom/workers/test/WorkerDebuggerGlobalScope.setImmediate_worker.js @@ -0,0 +1,3 @@ +"use strict" + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebuggerManager_childWorker.js b/dom/workers/test/WorkerDebuggerManager_childWorker.js new file mode 100644 index 000000000..8cee6809e --- /dev/null +++ b/dom/workers/test/WorkerDebuggerManager_childWorker.js @@ -0,0 +1,3 @@ +"use strict"; + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebuggerManager_worker.js b/dom/workers/test/WorkerDebuggerManager_worker.js new file mode 100644 index 000000000..0737d17eb --- /dev/null +++ b/dom/workers/test/WorkerDebuggerManager_worker.js @@ -0,0 +1,3 @@ +"use strict"; + +var worker = new Worker("WorkerDebuggerManager_childWorker.js"); diff --git a/dom/workers/test/WorkerDebugger_childWorker.js b/dom/workers/test/WorkerDebugger_childWorker.js new file mode 100644 index 000000000..8cee6809e --- /dev/null +++ b/dom/workers/test/WorkerDebugger_childWorker.js @@ -0,0 +1,3 @@ +"use strict"; + +self.onmessage = function () {}; diff --git a/dom/workers/test/WorkerDebugger_frozen_iframe1.html b/dom/workers/test/WorkerDebugger_frozen_iframe1.html new file mode 100644 index 000000000..591923121 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_frozen_iframe1.html @@ -0,0 +1,15 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + var worker = new Worker("WorkerDebugger_frozen_worker1.js"); + worker.onmessage = function () { + parent.postMessage("ready", "*"); + }; + </script> + </head> + <body> + This is page 1. + </body> +<html> diff --git a/dom/workers/test/WorkerDebugger_frozen_iframe2.html b/dom/workers/test/WorkerDebugger_frozen_iframe2.html new file mode 100644 index 000000000..96d5c56eb --- /dev/null +++ b/dom/workers/test/WorkerDebugger_frozen_iframe2.html @@ -0,0 +1,15 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + var worker = new Worker("WorkerDebugger_frozen_worker2.js"); + worker.onmessage = function () { + parent.postMessage("ready", "*"); + }; + </script> + </head> + <body> + This is page 2. + </body> +<html> diff --git a/dom/workers/test/WorkerDebugger_frozen_worker1.js b/dom/workers/test/WorkerDebugger_frozen_worker1.js new file mode 100644 index 000000000..371d2c064 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_frozen_worker1.js @@ -0,0 +1,5 @@ +"use strict"; + +onmessage = function () {}; + +postMessage("ready"); diff --git a/dom/workers/test/WorkerDebugger_frozen_worker2.js b/dom/workers/test/WorkerDebugger_frozen_worker2.js new file mode 100644 index 000000000..371d2c064 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_frozen_worker2.js @@ -0,0 +1,5 @@ +"use strict"; + +onmessage = function () {}; + +postMessage("ready"); diff --git a/dom/workers/test/WorkerDebugger_promise_debugger.js b/dom/workers/test/WorkerDebugger_promise_debugger.js new file mode 100644 index 000000000..7d7eaf532 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_promise_debugger.js @@ -0,0 +1,30 @@ +"use strict"; + +var self = this; + +self.onmessage = function (event) { + if (event.data !== "resolve") { + return; + } + // This then-handler should be executed inside the top-level event loop, + // within the context of the debugger's global. + Promise.resolve().then(function () { + var dbg = new Debugger(global); + dbg.onDebuggerStatement = function () { + self.onmessage = function (event) { + if (event.data !== "resume") { + return; + } + // This then-handler should be executed inside the nested event loop, + // within the context of the debugger's global. + Promise.resolve().then(function () { + postMessage("resumed"); + leaveEventLoop(); + }); + }; + postMessage("paused"); + enterEventLoop(); + }; + postMessage("resolved"); + }); +}; diff --git a/dom/workers/test/WorkerDebugger_promise_worker.js b/dom/workers/test/WorkerDebugger_promise_worker.js new file mode 100644 index 000000000..a77737af5 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_promise_worker.js @@ -0,0 +1,25 @@ +"use strict"; + +self.onmessage = function (event) { + if (event.data !== "resolve") { + return; + } + // This then-handler should be executed inside the top-level event loop, + // within the context of the worker's global. + Promise.resolve().then(function () { + self.onmessage = function (event) { + if (event.data !== "pause") { + return; + } + // This then-handler should be executed inside the top-level event loop, + // within the context of the worker's global. Because the debugger + // statement here below enters a nested event loop, the then-handler + // should not be executed until the debugger statement returns. + Promise.resolve().then(function () { + postMessage("resumed"); + }); + debugger; + } + postMessage("resolved"); + }); +}; diff --git a/dom/workers/test/WorkerDebugger_sharedWorker.js b/dom/workers/test/WorkerDebugger_sharedWorker.js new file mode 100644 index 000000000..5ad97d4c5 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_sharedWorker.js @@ -0,0 +1,11 @@ +"use strict"; + +self.onconnect = function (event) { + event.ports[0].onmessage = function (event) { + switch (event.data) { + case "close": + close(); + break; + } + }; +}; diff --git a/dom/workers/test/WorkerDebugger_suspended_debugger.js b/dom/workers/test/WorkerDebugger_suspended_debugger.js new file mode 100644 index 000000000..2ed4e16c4 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_suspended_debugger.js @@ -0,0 +1,6 @@ +"use strict"; + +var dbg = new Debugger(global); +dbg.onDebuggerStatement = function (frame) { + postMessage("debugger"); +}; diff --git a/dom/workers/test/WorkerDebugger_suspended_worker.js b/dom/workers/test/WorkerDebugger_suspended_worker.js new file mode 100644 index 000000000..c096be7e4 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_suspended_worker.js @@ -0,0 +1,6 @@ +"use strict"; + +self.onmessage = function () { + postMessage("worker"); + debugger; +}; diff --git a/dom/workers/test/WorkerDebugger_worker.js b/dom/workers/test/WorkerDebugger_worker.js new file mode 100644 index 000000000..f301ac1e8 --- /dev/null +++ b/dom/workers/test/WorkerDebugger_worker.js @@ -0,0 +1,8 @@ +"use strict"; + +var worker = new Worker("WorkerDebugger_childWorker.js"); +self.onmessage = function (event) { + postMessage("child:" + event.data); +}; +debugger; +postMessage("worker"); diff --git a/dom/workers/test/WorkerTest.jsm b/dom/workers/test/WorkerTest.jsm new file mode 100644 index 000000000..86431b7f8 --- /dev/null +++ b/dom/workers/test/WorkerTest.jsm @@ -0,0 +1,17 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +this.EXPORTED_SYMBOLS = [ + "WorkerTest" +]; + +this.WorkerTest = { + go: function(message, messageCallback, errorCallback) { + let worker = new ChromeWorker("WorkerTest_worker.js"); + worker.onmessage = messageCallback; + worker.onerror = errorCallback; + worker.postMessage(message); + return worker; + } +}; diff --git a/dom/workers/test/WorkerTest_badworker.js b/dom/workers/test/WorkerTest_badworker.js new file mode 100644 index 000000000..7a1df54bd --- /dev/null +++ b/dom/workers/test/WorkerTest_badworker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + throw "Shouldn't be able to read this!"; +} diff --git a/dom/workers/test/WorkerTest_subworker.js b/dom/workers/test/WorkerTest_subworker.js new file mode 100644 index 000000000..3e9242ed6 --- /dev/null +++ b/dom/workers/test/WorkerTest_subworker.js @@ -0,0 +1,43 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + let chromeURL = event.data.replace("test_chromeWorkerJSM.xul", + "WorkerTest_badworker.js"); + + let mochitestURL = event.data.replace("test_chromeWorkerJSM.xul", + "WorkerTest_badworker.js") + .replace("chrome://mochitests/content/chrome", + "http://mochi.test:8888/tests"); + + // We should be able to XHR to anything we want, including a chrome URL. + let xhr = new XMLHttpRequest(); + xhr.open("GET", mochitestURL, false); + xhr.send(); + + if (!xhr.responseText) { + throw "Can't load script file via XHR!"; + } + + // We shouldn't be able to make a ChromeWorker to a non-chrome URL. + let worker = new ChromeWorker(mochitestURL); + worker.onmessage = function(event) { + throw event.data; + }; + worker.onerror = function(event) { + event.preventDefault(); + + // And we shouldn't be able to make a regular Worker to a non-chrome URL. + worker = new Worker(mochitestURL); + worker.onmessage = function(event) { + throw event.data; + }; + worker.onerror = function(event) { + event.preventDefault(); + postMessage("Done"); + }; + worker.postMessage("Hi"); + }; + worker.postMessage("Hi"); +}; diff --git a/dom/workers/test/WorkerTest_worker.js b/dom/workers/test/WorkerTest_worker.js new file mode 100644 index 000000000..445408f8f --- /dev/null +++ b/dom/workers/test/WorkerTest_worker.js @@ -0,0 +1,11 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + let worker = new ChromeWorker("WorkerTest_subworker.js"); + worker.onmessage = function(event) { + postMessage(event.data); + } + worker.postMessage(event.data); +} diff --git a/dom/workers/test/atob_worker.js b/dom/workers/test/atob_worker.js new file mode 100644 index 000000000..680ca904b --- /dev/null +++ b/dom/workers/test/atob_worker.js @@ -0,0 +1,46 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var data = [ -1, 0, 1, 1.5, /* null ,*/ undefined, true, false, "foo", + "123456789012345", "1234567890123456", "12345678901234567"]; + +var str = ""; +for (var i = 0; i < 30; i++) { + data.push(str); + str += i % 2 ? "b" : "a"; +} + +onmessage = function(event) { + data.forEach(function(string) { + var encoded = btoa(string); + postMessage({ type: "btoa", value: encoded }); + postMessage({ type: "atob", value: atob(encoded) }); + }); + + var threw; + try { + atob(); + } + catch(e) { + threw = true; + } + + if (!threw) { + throw "atob didn't throw when called without an argument!"; + } + threw = false; + + try { + btoa(); + } + catch(e) { + threw = true; + } + + if (!threw) { + throw "btoa didn't throw when called without an argument!"; + } + + postMessage({ type: "done" }); +} diff --git a/dom/workers/test/browser.ini b/dom/workers/test/browser.ini new file mode 100644 index 000000000..ae1e27d13 --- /dev/null +++ b/dom/workers/test/browser.ini @@ -0,0 +1,12 @@ +[DEFAULT] +support-files = + bug1047663_tab.html + bug1047663_worker.sjs + frame_script.js + head.js + !/dom/base/test/file_empty.html + !/dom/base/test/file_bug945152.jar + +[browser_bug1047663.js] +[browser_bug1104623.js] +run-if = buildapp == 'browser' diff --git a/dom/workers/test/browser_bug1047663.js b/dom/workers/test/browser_bug1047663.js new file mode 100644 index 000000000..8fa2c5358 --- /dev/null +++ b/dom/workers/test/browser_bug1047663.js @@ -0,0 +1,50 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const TAB_URL = EXAMPLE_URL + "bug1047663_tab.html"; +const WORKER_URL = EXAMPLE_URL + "bug1047663_worker.sjs"; + +function test() { + waitForExplicitFinish(); + + Task.spawn(function* () { + let tab = yield addTab(TAB_URL); + + // Create a worker. Post a message to it, and check the reply. Since the + // server side JavaScript file returns the first source for the first + // request, the reply should be "one". If the reply is correct, terminate + // the worker. + yield createWorkerInTab(tab, WORKER_URL); + let message = yield postMessageToWorkerInTab(tab, WORKER_URL, "ping"); + is(message, "one"); + yield terminateWorkerInTab(tab, WORKER_URL); + + // Create a second worker with the same URL. Post a message to it, and check + // the reply. The server side JavaScript file returns the second source for + // all subsequent requests, but since the cache is still enabled, the reply + // should still be "one". If the reply is correct, terminate the worker. + yield createWorkerInTab(tab, WORKER_URL); + message = yield postMessageToWorkerInTab(tab, WORKER_URL, "ping"); + is(message, "one"); + yield terminateWorkerInTab(tab, WORKER_URL); + + // Disable the cache in this tab. This should also disable the cache for all + // workers in this tab. + yield disableCacheInTab(tab); + + // Create a third worker with the same URL. Post a message to it, and check + // the reply. Since the server side JavaScript file returns the second + // source for all subsequent requests, and the cache is now disabled, the + // reply should now be "two". If the reply is correct, terminate the worker. + yield createWorkerInTab(tab, WORKER_URL); + message = yield postMessageToWorkerInTab(tab, WORKER_URL, "ping"); + is(message, "two"); + yield terminateWorkerInTab(tab, WORKER_URL); + + removeTab(tab); + + finish(); + }); +} diff --git a/dom/workers/test/browser_bug1104623.js b/dom/workers/test/browser_bug1104623.js new file mode 100644 index 000000000..64a8eeb9c --- /dev/null +++ b/dom/workers/test/browser_bug1104623.js @@ -0,0 +1,53 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +function whenBrowserLoaded(aBrowser, aCallback) { + aBrowser.addEventListener("load", function onLoad(event) { + if (event.target == aBrowser.contentDocument) { + aBrowser.removeEventListener("load", onLoad, true); + executeSoon(aCallback); + } + }, true); +} + +function test() { + waitForExplicitFinish(); + + let testURL = "chrome://mochitests/content/chrome/dom/base/test/file_empty.html"; + + let tab = gBrowser.addTab(testURL); + gBrowser.selectedTab = tab; + + whenBrowserLoaded(tab.linkedBrowser, function() { + let doc = tab.linkedBrowser.contentDocument; + let contentWin = tab.linkedBrowser.contentWindow; + + let blob = new contentWin.Blob(['onmessage = function() { postMessage(true); }']); + ok(blob, "Blob has been created"); + + let blobURL = contentWin.URL.createObjectURL(blob); + ok(blobURL, "Blob URL has been created"); + + let worker = new contentWin.Worker(blobURL); + ok(worker, "Worker has been created"); + + worker.onerror = function(error) { + ok(false, "Worker.onerror:" + error.message); + worker.terminate(); + contentWin.URL.revokeObjectURL(blob); + gBrowser.removeTab(tab); + executeSoon(finish); + } + + worker.onmessage = function() { + ok(true, "Worker.onmessage"); + worker.terminate(); + contentWin.URL.revokeObjectURL(blob); + gBrowser.removeTab(tab); + executeSoon(finish); + } + + worker.postMessage(true); + }); +} diff --git a/dom/workers/test/bug1014466_data1.txt b/dom/workers/test/bug1014466_data1.txt new file mode 100644 index 000000000..a32a4347a --- /dev/null +++ b/dom/workers/test/bug1014466_data1.txt @@ -0,0 +1 @@ +1234567890 diff --git a/dom/workers/test/bug1014466_data2.txt b/dom/workers/test/bug1014466_data2.txt new file mode 100644 index 000000000..4d40154ce --- /dev/null +++ b/dom/workers/test/bug1014466_data2.txt @@ -0,0 +1 @@ +ABCDEFGH diff --git a/dom/workers/test/bug1014466_worker.js b/dom/workers/test/bug1014466_worker.js new file mode 100644 index 000000000..beb324f0f --- /dev/null +++ b/dom/workers/test/bug1014466_worker.js @@ -0,0 +1,64 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function ok(a, msg) { + postMessage({type: "status", status: !!a, msg: msg }); +} + +onmessage = function(event) { + + function getResponse(url) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.send(); + return xhr.responseText; + } + + const testFile1 = "bug1014466_data1.txt"; + const testFile2 = "bug1014466_data2.txt"; + const testData1 = getResponse(testFile1); + const testData2 = getResponse(testFile2); + + var response_count = 0; + var xhr = new XMLHttpRequest(); + xhr.onreadystatechange = function() { + if (xhr.readyState == xhr.DONE && xhr.status == 200) { + response_count++; + switch (response_count) { + case 1: + ok(xhr.responseText == testData1, "Check data 1"); + test_data2(); + break; + case 2: + ok(xhr.responseText == testData2, "Check data 2"); + postMessage({type: "finish" }); + break; + default: + ok(false, "Unexpected response received"); + postMessage({type: "finish" }); + break; + } + } + } + xhr.onerror = function(event) { + ok(false, "Got an error event: " + event); + postMessage({type: "finish" }); + } + + function test_data1() { + xhr.open("GET", testFile1, true); + xhr.responseType = "text"; + xhr.send(); + } + + function test_data2() { + xhr.abort(); + xhr.open("GET", testFile2, true); + xhr.responseType = "text"; + xhr.send(); + } + + test_data1(); +} diff --git a/dom/workers/test/bug1020226_frame.html b/dom/workers/test/bug1020226_frame.html new file mode 100644 index 000000000..7f810d893 --- /dev/null +++ b/dom/workers/test/bug1020226_frame.html @@ -0,0 +1,20 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1020226 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1020226</title> +</head> +<body> + +<script type="application/javascript"> + var worker = new Worker("bug1020226_worker.js"); + worker.onmessage = function(e) { + window.parent.postMessage("loaded", "*"); + } +</script> +</body> +</html> + diff --git a/dom/workers/test/bug1020226_worker.js b/dom/workers/test/bug1020226_worker.js new file mode 100644 index 000000000..868b1a2f2 --- /dev/null +++ b/dom/workers/test/bug1020226_worker.js @@ -0,0 +1,12 @@ +var p = new Promise(function(resolve, reject) { + // This causes a runnable to be queued. + reject(new Error()); + postMessage("loaded"); + + // This prevents that runnable from running until the window calls terminate(), + // at which point the worker goes into the Canceling state and then an + // HoldWorker() is attempted, which fails, which used to result in + // multiple calls to the error reporter, one after the worker's context had + // been GCed. + while (true); +}); diff --git a/dom/workers/test/bug1047663_tab.html b/dom/workers/test/bug1047663_tab.html new file mode 100644 index 000000000..62ab9be7d --- /dev/null +++ b/dom/workers/test/bug1047663_tab.html @@ -0,0 +1,8 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"/> + </head> + <body> + </body> +</html> diff --git a/dom/workers/test/bug1047663_worker.sjs b/dom/workers/test/bug1047663_worker.sjs new file mode 100644 index 000000000..a39bf4474 --- /dev/null +++ b/dom/workers/test/bug1047663_worker.sjs @@ -0,0 +1,40 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const WORKER_1 = ` + "use strict"; + + self.onmessage = function () { + postMessage("one"); + }; +`; + +const WORKER_2 = ` + "use strict"; + + self.onmessage = function () { + postMessage("two"); + }; +`; + +function handleRequest(request, response) { + let count = getState("count"); + if (count === "") { + count = "1"; + } + + // This header is necessary for the cache to trigger. + response.setHeader("Cache-control", "max-age=3600"); + + // If this is the first request, return the first source. + if (count === "1") { + response.write(WORKER_1); + setState("count", "2"); + } + // For all subsequent requests, return the second source. + else { + response.write(WORKER_2); + } +} diff --git a/dom/workers/test/bug1060621_worker.js b/dom/workers/test/bug1060621_worker.js new file mode 100644 index 000000000..a0fcd3f60 --- /dev/null +++ b/dom/workers/test/bug1060621_worker.js @@ -0,0 +1,2 @@ +navigator.foobar = 42; +postMessage('done'); diff --git a/dom/workers/test/bug1062920_worker.js b/dom/workers/test/bug1062920_worker.js new file mode 100644 index 000000000..d3df38870 --- /dev/null +++ b/dom/workers/test/bug1062920_worker.js @@ -0,0 +1,6 @@ +postMessage({ appCodeName: navigator.appCodeName, + appName: navigator.appName, + appVersion: navigator.appVersion, + platform: navigator.platform, + userAgent: navigator.userAgent, + product: navigator.product }); diff --git a/dom/workers/test/bug1063538_worker.js b/dom/workers/test/bug1063538_worker.js new file mode 100644 index 000000000..dc53dd289 --- /dev/null +++ b/dom/workers/test/bug1063538_worker.js @@ -0,0 +1,25 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var gJar = "jar:http://example.org/tests/dom/base/test/file_bug945152.jar!/data_big.txt"; +var xhr = new XMLHttpRequest({mozAnon: true, mozSystem: true}); +var progressFired = false; + +xhr.onloadend = function(e) { + postMessage({type: 'finish', progressFired: progressFired }); + self.close(); +}; + +xhr.onprogress = function(e) { + if (e.loaded > 0) { + progressFired = true; + xhr.abort(); + } +}; + +onmessage = function(e) { + xhr.open("GET", gJar, true); + xhr.send(); +} diff --git a/dom/workers/test/bug1104064_worker.js b/dom/workers/test/bug1104064_worker.js new file mode 100644 index 000000000..5e627c86f --- /dev/null +++ b/dom/workers/test/bug1104064_worker.js @@ -0,0 +1,10 @@ +onmessage = function() { + var counter = 0; + var id = setInterval(function() { + ++counter; + if (counter == 2) { + clearInterval(id); + postMessage('done'); + } + }, 0); +} diff --git a/dom/workers/test/bug1132395_sharedWorker.js b/dom/workers/test/bug1132395_sharedWorker.js new file mode 100644 index 000000000..988eea106 --- /dev/null +++ b/dom/workers/test/bug1132395_sharedWorker.js @@ -0,0 +1,12 @@ +dump("SW created\n"); +onconnect = function(evt) { + dump("SW onconnect\n"); + evt.ports[0].onmessage = function(e) { + dump("SW onmessage\n"); + var blob = new Blob(['123'], { type: 'text/plain' }); + dump("SW blob created\n"); + var url = URL.createObjectURL(blob); + dump("SW url created: " + url + "\n"); + evt.ports[0].postMessage('alive \\o/'); + }; +} diff --git a/dom/workers/test/bug1132924_worker.js b/dom/workers/test/bug1132924_worker.js new file mode 100644 index 000000000..cabd40686 --- /dev/null +++ b/dom/workers/test/bug1132924_worker.js @@ -0,0 +1,10 @@ +onmessage = function() { + var a = new XMLHttpRequest(); + a.open('GET', 'empty.html', false); + a.onreadystatechange = function() { + if (a.readyState == 4) { + postMessage(a.response); + } + } + a.send(null); +} diff --git a/dom/workers/test/bug978260_worker.js b/dom/workers/test/bug978260_worker.js new file mode 100644 index 000000000..126b9c901 --- /dev/null +++ b/dom/workers/test/bug978260_worker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +// Tell the main thread we're here. +postMessage("loaded"); diff --git a/dom/workers/test/bug998474_worker.js b/dom/workers/test/bug998474_worker.js new file mode 100644 index 000000000..a14ed2810 --- /dev/null +++ b/dom/workers/test/bug998474_worker.js @@ -0,0 +1,6 @@ +self.addEventListener("connect", function(e) { + var port = e.ports[0]; + port.onmessage = function(e) { + port.postMessage(eval(e.data)); + }; +}); diff --git a/dom/workers/test/chrome.ini b/dom/workers/test/chrome.ini new file mode 100644 index 000000000..c01a20b2b --- /dev/null +++ b/dom/workers/test/chrome.ini @@ -0,0 +1,86 @@ +[DEFAULT] +skip-if = os == 'android' +support-files = + WorkerDebugger.console_childWorker.js + WorkerDebugger.console_debugger.js + WorkerDebugger.console_worker.js + WorkerDebugger.initialize_childWorker.js + WorkerDebugger.initialize_debugger.js + WorkerDebugger.initialize_worker.js + WorkerDebugger.postMessage_childWorker.js + WorkerDebugger.postMessage_debugger.js + WorkerDebugger.postMessage_worker.js + WorkerDebuggerGlobalScope.createSandbox_debugger.js + WorkerDebuggerGlobalScope.createSandbox_sandbox.js + WorkerDebuggerGlobalScope.createSandbox_worker.js + WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js + WorkerDebuggerGlobalScope.enterEventLoop_debugger.js + WorkerDebuggerGlobalScope.enterEventLoop_worker.js + WorkerDebuggerGlobalScope.reportError_childWorker.js + WorkerDebuggerGlobalScope.reportError_debugger.js + WorkerDebuggerGlobalScope.reportError_worker.js + WorkerDebuggerGlobalScope.setImmediate_debugger.js + WorkerDebuggerGlobalScope.setImmediate_worker.js + WorkerDebuggerManager_childWorker.js + WorkerDebuggerManager_worker.js + WorkerDebugger_childWorker.js + WorkerDebugger_frozen_iframe1.html + WorkerDebugger_frozen_iframe2.html + WorkerDebugger_frozen_worker1.js + WorkerDebugger_frozen_worker2.js + WorkerDebugger_promise_debugger.js + WorkerDebugger_promise_worker.js + WorkerDebugger_sharedWorker.js + WorkerDebugger_suspended_debugger.js + WorkerDebugger_suspended_worker.js + WorkerDebugger_worker.js + WorkerTest.jsm + WorkerTest_subworker.js + WorkerTest_worker.js + bug1062920_worker.js + chromeWorker_subworker.js + chromeWorker_worker.js + dom_worker_helper.js + empty.html + fileBlobSubWorker_worker.js + fileBlob_worker.js + filePosting_worker.js + fileReadSlice_worker.js + fileReaderSyncErrors_worker.js + fileReaderSync_worker.js + fileSlice_worker.js + fileSubWorker_worker.js + file_worker.js + sharedWorker_privateBrowsing.js + workersDisabled_worker.js + +[test_WorkerDebugger.initialize.xul] +[test_WorkerDebugger.postMessage.xul] +[test_WorkerDebugger.xul] +[test_WorkerDebuggerGlobalScope.createSandbox.xul] +[test_WorkerDebuggerGlobalScope.enterEventLoop.xul] +[test_WorkerDebuggerGlobalScope.reportError.xul] +skip-if = (os == 'linux') # Bug 1244697 +[test_WorkerDebuggerGlobalScope.setImmediate.xul] +[test_WorkerDebuggerManager.xul] +skip-if = (os == 'linux') # Bug 1244409 +[test_WorkerDebugger_console.xul] +[test_WorkerDebugger_frozen.xul] +[test_WorkerDebugger_promise.xul] +[test_WorkerDebugger_suspended.xul] +[test_chromeWorker.xul] +[test_chromeWorkerJSM.xul] +[test_extension.xul] +[test_extensionBootstrap.xul] +[test_file.xul] +[test_fileBlobPosting.xul] +[test_fileBlobSubWorker.xul] +[test_filePosting.xul] +[test_fileReadSlice.xul] +[test_fileReaderSync.xul] +[test_fileReaderSyncErrors.xul] +[test_fileSlice.xul] +[test_fileSubWorker.xul] +[test_workersDisabled.xul] +[test_bug1062920.xul] +[test_sharedWorker_privateBrowsing.html] diff --git a/dom/workers/test/chromeWorker_subworker.js b/dom/workers/test/chromeWorker_subworker.js new file mode 100644 index 000000000..5ad1a9923 --- /dev/null +++ b/dom/workers/test/chromeWorker_subworker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + postMessage("Done!"); +}; diff --git a/dom/workers/test/chromeWorker_worker.js b/dom/workers/test/chromeWorker_worker.js new file mode 100644 index 000000000..5738a9ae5 --- /dev/null +++ b/dom/workers/test/chromeWorker_worker.js @@ -0,0 +1,20 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +if (!("ctypes" in self)) { + throw "No ctypes!"; +} + +// Go ahead and verify that the ctypes lazy getter actually works. +if (ctypes.toString() != "[object ctypes]") { + throw "Bad ctypes object: " + ctypes.toString(); +} + +onmessage = function(event) { + let worker = new ChromeWorker("chromeWorker_subworker.js"); + worker.onmessage = function(event) { + postMessage(event.data); + } + worker.postMessage(event.data); +} diff --git a/dom/workers/test/clearTimeouts_worker.js b/dom/workers/test/clearTimeouts_worker.js new file mode 100644 index 000000000..b471515b3 --- /dev/null +++ b/dom/workers/test/clearTimeouts_worker.js @@ -0,0 +1,12 @@ +var count = 0; +function timerFunction() { + if (++count == 30) { + close(); + postMessage("ready"); + while (true) { } + } +} + +for (var i = 0; i < 10; i++) { + setInterval(timerFunction, 500); +} diff --git a/dom/workers/test/consoleReplaceable_worker.js b/dom/workers/test/consoleReplaceable_worker.js new file mode 100644 index 000000000..aaf104af1 --- /dev/null +++ b/dom/workers/test/consoleReplaceable_worker.js @@ -0,0 +1,16 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +onmessage = function(event) { + postMessage({event: 'console exists', status: !!console, last : false}); + var logCalled = false; + console.log = function() { + logCalled = true; + } + console.log("foo"); + postMessage({event: 'console.log is replaceable', status: logCalled, last: false}); + console = 42; + postMessage({event: 'console is replaceable', status: console === 42, last : true}); +} diff --git a/dom/workers/test/console_worker.js b/dom/workers/test/console_worker.js new file mode 100644 index 000000000..6b5f9d8a1 --- /dev/null +++ b/dom/workers/test/console_worker.js @@ -0,0 +1,109 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +onmessage = function(event) { + // TEST: does console exist? + postMessage({event: 'console exists', status: !!console, last : false}); + + postMessage({event: 'console is the same object', status: console === console, last: false}); + + postMessage({event: 'trace without function', status: true, last : false}); + + for (var i = 0; i < 10; ++i) { + console.log(i, i, i); + } + + function trace1() { + function trace2() { + function trace3() { + console.trace("trace " + i); + } + trace3(); + } + trace2(); + } + trace1(); + + foobar585956c = function(a) { + console.trace(); + return a+"c"; + }; + + function foobar585956b(a) { + return foobar585956c(a+"b"); + } + + function foobar585956a(omg) { + return foobar585956b(omg + "a"); + } + + function foobar646025(omg) { + console.log(omg, "o", "d"); + } + + function startTimer(timer) { + console.time(timer); + } + + function stopTimer(timer) { + console.timeEnd(timer); + } + + function timeStamp(label) { + console.timeStamp(label); + } + + function testGroups() { + console.groupCollapsed("a", "group"); + console.group("b", "group"); + console.groupEnd("b", "group"); + } + + foobar585956a('omg'); + foobar646025('omg'); + timeStamp(); + timeStamp('foo'); + testGroups(); + startTimer('foo'); + setTimeout(function() { + stopTimer('foo'); + nextSteps(event); + }, 10); +} + +function nextSteps(event) { + + function namelessTimer() { + console.time(); + console.timeEnd(); + } + + namelessTimer(); + + var str = "Test Message." + console.log(str); + console.info(str); + console.warn(str); + console.error(str); + console.exception(str); + console.assert(true, str); + console.assert(false, str); + console.profile(str); + console.profileEnd(str); + console.timeStamp(); + console.clear(); + postMessage({event: '4 messages', status: true, last : false}); + + // Recursive: + if (event.data == true) { + var worker = new Worker('console_worker.js'); + worker.onmessage = function(event) { + postMessage(event.data); + } + worker.postMessage(false); + } else { + postMessage({event: 'bye bye', status: true, last : true}); + } +} diff --git a/dom/workers/test/content_worker.js b/dom/workers/test/content_worker.js new file mode 100644 index 000000000..7e092ec8c --- /dev/null +++ b/dom/workers/test/content_worker.js @@ -0,0 +1,12 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var props = { + 'ctypes': 1, + 'OS': 1 +}; +for (var prop in props) { + postMessage({ "prop": prop, "value": self[prop] }); +} +postMessage({ "testfinished": 1 }); diff --git a/dom/workers/test/crashtests/1153636.html b/dom/workers/test/crashtests/1153636.html new file mode 100644 index 000000000..6ad0d550f --- /dev/null +++ b/dom/workers/test/crashtests/1153636.html @@ -0,0 +1,5 @@ +<script> + +new Worker("data:text/javascript;charset=UTF-8,self.addEventListener('',function(){},false);"); + +</script> diff --git a/dom/workers/test/crashtests/1158031.html b/dom/workers/test/crashtests/1158031.html new file mode 100644 index 000000000..6d896bc46 --- /dev/null +++ b/dom/workers/test/crashtests/1158031.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<script> + +function boom() +{ + var w = new Worker("data:text/javascript;charset=UTF-8,"); + w.postMessage(new Blob([], {})); +} + +</script> +<body onload="boom();"></body> diff --git a/dom/workers/test/crashtests/1228456.html b/dom/workers/test/crashtests/1228456.html new file mode 100644 index 000000000..6d1f0f0a7 --- /dev/null +++ b/dom/workers/test/crashtests/1228456.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + +function boom() +{ + var w; + for (var i = 0; i < 99; ++i) { + w = new SharedWorker("data:text/javascript;charset=UTF-8," + encodeURIComponent(i + ";")); + } + w.port.postMessage(""); +} + +</script> +<body onload="boom();"></body> diff --git a/dom/workers/test/crashtests/779707.html b/dom/workers/test/crashtests/779707.html new file mode 100644 index 000000000..97a8113da --- /dev/null +++ b/dom/workers/test/crashtests/779707.html @@ -0,0 +1,19 @@ +<!DOCTYPE html> +<html> +<head> +<script> + +function boom() +{ + var x = new XMLHttpRequest(); + x.open('GET', "data:text/plain,2", false); + x.send(); + + new Worker("data:text/javascript,3"); +} + +</script> +</head> + +<body onload="boom();"></body> +</html> diff --git a/dom/workers/test/crashtests/943516.html b/dom/workers/test/crashtests/943516.html new file mode 100644 index 000000000..5f4667850 --- /dev/null +++ b/dom/workers/test/crashtests/943516.html @@ -0,0 +1,10 @@ +<!-- +Any copyright is dedicated to the Public Domain. +http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<script> +// Using a DOM bindings object as a weak map key should not crash when attempting to +// call the preserve wrapper callback. +new Worker("data:text/javascript;charset=UTF-8,(new WeakMap()).set(self, 0);") +</script> diff --git a/dom/workers/test/crashtests/crashtests.list b/dom/workers/test/crashtests/crashtests.list new file mode 100644 index 000000000..a7518d3c2 --- /dev/null +++ b/dom/workers/test/crashtests/crashtests.list @@ -0,0 +1,5 @@ +load 779707.html +load 943516.html +load 1153636.html +load 1158031.html +load 1228456.html diff --git a/dom/workers/test/csp_worker.js b/dom/workers/test/csp_worker.js new file mode 100644 index 000000000..63b3adeaf --- /dev/null +++ b/dom/workers/test/csp_worker.js @@ -0,0 +1,28 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + if (event.data.do == "eval") { + var res; + try { + res = eval("40+2"); + } + catch(ex) { + res = ex+""; + } + postMessage(res); + } + else if (event.data.do == "nest") { + var worker = new Worker(event.data.uri); + if (--event.data.level) { + worker.postMessage(event.data); + } + else { + worker.postMessage({ do: "eval" }); + } + worker.onmessage = (e) => { + postMessage(e.data); + } + } +} diff --git a/dom/workers/test/csp_worker.js^headers^ b/dom/workers/test/csp_worker.js^headers^ new file mode 100644 index 000000000..7b835bf2a --- /dev/null +++ b/dom/workers/test/csp_worker.js^headers^ @@ -0,0 +1 @@ +Content-Security-Policy: default-src 'self' blob: ; script-src 'unsafe-eval' diff --git a/dom/workers/test/dom_worker_helper.js b/dom/workers/test/dom_worker_helper.js new file mode 100644 index 000000000..52e802ac7 --- /dev/null +++ b/dom/workers/test/dom_worker_helper.js @@ -0,0 +1,176 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +Cu.import("resource://gre/modules/AddonManager.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Task.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +const wdm = Cc["@mozilla.org/dom/workers/workerdebuggermanager;1"]. + getService(Ci.nsIWorkerDebuggerManager); + +const BASE_URL = "chrome://mochitests/content/chrome/dom/workers/test/"; + +var gRemainingTests = 0; + +function waitForWorkerFinish() { + if (gRemainingTests == 0) { + SimpleTest.waitForExplicitFinish(); + } + ++gRemainingTests; +} + +function finish() { + --gRemainingTests; + if (gRemainingTests == 0) { + SimpleTest.finish(); + } +} + +function assertThrows(fun, message) { + let throws = false; + try { + fun(); + } catch (e) { + throws = true; + } + ok(throws, message); +} + +function* generateDebuggers() { + let e = wdm.getWorkerDebuggerEnumerator(); + while (e.hasMoreElements()) { + let dbg = e.getNext().QueryInterface(Ci.nsIWorkerDebugger); + yield dbg; + } +} + +function findDebugger(url) { + for (let dbg of generateDebuggers()) { + if (dbg.url === url) { + return dbg; + } + } + return null; +} + +function waitForRegister(url, dbgUrl) { + return new Promise(function (resolve) { + wdm.addListener({ + onRegister: function (dbg) { + dump("FAK " + dbg.url + "\n"); + if (dbg.url !== url) { + return; + } + ok(true, "Debugger with url " + url + " should be registered."); + wdm.removeListener(this); + if (dbgUrl) { + info("Initializing worker debugger with url " + url + "."); + dbg.initialize(dbgUrl); + } + resolve(dbg); + } + }); + }); +} + +function waitForUnregister(url) { + return new Promise(function (resolve) { + wdm.addListener({ + onUnregister: function (dbg) { + if (dbg.url !== url) { + return; + } + ok(true, "Debugger with url " + url + " should be unregistered."); + wdm.removeListener(this); + resolve(); + } + }); + }); +} + +function waitForDebuggerClose(dbg) { + return new Promise(function (resolve) { + dbg.addListener({ + onClose: function () { + ok(true, "Debugger should be closed."); + dbg.removeListener(this); + resolve(); + } + }); + }); +} + +function waitForDebuggerError(dbg) { + return new Promise(function (resolve) { + dbg.addListener({ + onError: function (filename, lineno, message) { + dbg.removeListener(this); + resolve(new Error(message, filename, lineno)); + } + }); + }); +} + +function waitForDebuggerMessage(dbg, message) { + return new Promise(function (resolve) { + dbg.addListener({ + onMessage: function (message1) { + if (message !== message1) { + return; + } + ok(true, "Should receive " + message + " message from debugger."); + dbg.removeListener(this); + resolve(); + } + }); + }); +} + +function waitForWindowMessage(window, message) { + return new Promise(function (resolve) { + let onmessage = function (event) { + if (event.data !== event.data) { + return; + } + window.removeEventListener("message", onmessage, false); + resolve(); + }; + window.addEventListener("message", onmessage, false); + }); +} + +function waitForWorkerMessage(worker, message) { + return new Promise(function (resolve) { + worker.addEventListener("message", function onmessage(event) { + if (event.data !== message) { + return; + } + ok(true, "Should receive " + message + " message from worker."); + worker.removeEventListener("message", onmessage); + resolve(); + }); + }); +} + +function waitForMultiple(promises) { + return new Promise(function (resolve) { + let values = []; + for (let i = 0; i < promises.length; ++i) { + let index = i; + promises[i].then(function (value) { + is(index + 1, values.length + 1, + "Promise " + (values.length + 1) + " out of " + promises.length + + " should be resolved."); + values.push(value); + if (values.length === promises.length) { + resolve(values); + } + }); + } + }); +}; diff --git a/dom/workers/test/empty.html b/dom/workers/test/empty.html new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/empty.html diff --git a/dom/workers/test/errorPropagation_iframe.html b/dom/workers/test/errorPropagation_iframe.html new file mode 100644 index 000000000..c5f688487 --- /dev/null +++ b/dom/workers/test/errorPropagation_iframe.html @@ -0,0 +1,55 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <meta charset="utf-8"> + <body> + <script type="text/javascript"> + var worker; + + function start(workerCount, messageCallback) { + var seenWindowError; + window.onerror = function(message, filename, lineno) { + if (!seenWindowError) { + seenWindowError = true; + messageCallback({ + type: "window", + data: { message: message, filename: filename, lineno: lineno } + }); + return true; + } + }; + + worker = new Worker("errorPropagation_worker.js"); + + worker.onmessage = function(event) { + messageCallback(event.data); + }; + + var seenWorkerError; + worker.onerror = function(event) { + if (!seenWorkerError) { + seenWorkerError = true; + messageCallback({ + type: "worker", + data: { + message: event.message, + filename: event.filename, + lineno: event.lineno + } + }); + event.preventDefault(); + } + }; + + worker.postMessage(workerCount); + } + + function stop() { + worker.terminate(); + } + </script> + </body> +</html> diff --git a/dom/workers/test/errorPropagation_worker.js b/dom/workers/test/errorPropagation_worker.js new file mode 100644 index 000000000..84f5916e0 --- /dev/null +++ b/dom/workers/test/errorPropagation_worker.js @@ -0,0 +1,50 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var seenScopeError; +onerror = function(message, filename, lineno) { + if (!seenScopeError) { + seenScopeError = true; + postMessage({ + type: "scope", + data: { message: message, filename: filename, lineno: lineno } + }); + return true; + } +}; + +onmessage = function(event) { + var workerId = parseInt(event.data); + + if (workerId > 1) { + var worker = new Worker("errorPropagation_worker.js"); + + worker.onmessage = function(event) { + postMessage(event.data); + }; + + var seenWorkerError; + worker.onerror = function(event) { + if (!seenWorkerError) { + seenWorkerError = true; + postMessage({ + type: "worker", + data: { + message: event.message, + filename: event.filename, + lineno: event.lineno + } + }); + event.preventDefault(); + } + }; + + worker.postMessage(workerId - 1); + return; + } + + var interval = setInterval(function() { + throw new Error("expectedError"); + }, 100); +}; diff --git a/dom/workers/test/errorwarning_worker.js b/dom/workers/test/errorwarning_worker.js new file mode 100644 index 000000000..1c372104c --- /dev/null +++ b/dom/workers/test/errorwarning_worker.js @@ -0,0 +1,42 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function errorHandler() { + postMessage({ type: 'error' }); +} + +onmessage = function(event) { + if (event.data.errors) { + try { + // This is an error: + postMessage({ type: 'ignore', value: b.aaa }); + } catch(e) { + errorHandler(); + } + } else { + var a = {}; + // This is a warning: + postMessage({ type: 'ignore', value: a.foo }); + } + + if (event.data.loop != 0) { + var worker = new Worker('errorwarning_worker.js'); + worker.onerror = errorHandler; + worker.postMessage({ loop: event.data.loop - 1, errors: event.data.errors }); + + worker.onmessage = function(e) { + postMessage(e.data); + } + + } else { + postMessage({ type: 'finish' }); + } +} + +onerror = errorHandler; +onerror = onerror; +if (!onerror || onerror != onerror) { + throw "onerror wasn't set properly"; +} diff --git a/dom/workers/test/eventDispatch_worker.js b/dom/workers/test/eventDispatch_worker.js new file mode 100644 index 000000000..915f60c93 --- /dev/null +++ b/dom/workers/test/eventDispatch_worker.js @@ -0,0 +1,67 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +const fakeEventType = "foo"; + +function testEventTarget(event) { + if (event.target !== self) { + throw new Error("Event has a bad target!"); + } + if (event.currentTarget) { + throw new Error("Event has a bad currentTarget!"); + } + postMessage(event.data); +} + +addEventListener(fakeEventType, function(event) { + throw new Error("Trusted event listener received untrusted event!"); +}, false, false); + +addEventListener(fakeEventType, function(event) { + if (event.target !== self || event.currentTarget !== self) { + throw new Error("Fake event has bad target!"); + } + if (event.isTrusted) { + throw new Error("Event should be untrusted!"); + } + event.stopImmediatePropagation(); + postMessage(event.data); +}, false, true); + +addEventListener(fakeEventType, function(event) { + throw new Error("This shouldn't get called because of stopImmediatePropagation."); +}, false, true); + +var count = 0; +onmessage = function(event) { + if (event.target !== self || event.currentTarget !== self) { + throw new Error("Event has bad target!"); + } + + if (!count++) { + var exception; + try { + self.dispatchEvent(event); + } + catch(e) { + exception = e; + } + + if (!exception) { + throw new Error("Recursive dispatch didn't fail!"); + } + + event = new MessageEvent(fakeEventType, { bubbles: event.bubbles, + cancelable: event.cancelable, + data: event.data, + origin: "*", + source: null + }); + self.dispatchEvent(event); + + return; + } + + setTimeout(testEventTarget, 0, event); +}; diff --git a/dom/workers/test/extensions/bootstrap/bootstrap.js b/dom/workers/test/extensions/bootstrap/bootstrap.js new file mode 100644 index 000000000..acb0a204b --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/bootstrap.js @@ -0,0 +1,141 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var Ci = Components.interfaces; +var Cu = Components.utils; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +function testForExpectedSymbols(stage, data) { + const expectedSymbols = [ "Worker", "ChromeWorker" ]; + for (var symbol of expectedSymbols) { + Services.prefs.setBoolPref("workertest.bootstrap." + stage + "." + symbol, + symbol in this); + } +} + +var gWorkerAndCallback = { + _ensureStarted: function() { + if (!this._worker) { + throw new Error("Not yet started!"); + } + }, + + start: function(data) { + if (!this._worker) { + this._worker = new Worker("chrome://workerbootstrap/content/worker.js"); + this._worker.onerror = function(event) { + Cu.reportError(event.message); + event.preventDefault(); + }; + } + }, + + stop: function() { + if (this._worker) { + this._worker.terminate(); + delete this._worker; + } + }, + + set callback(val) { + this._ensureStarted(); + var callback = val.QueryInterface(Ci.nsIObserver); + if (this._callback != callback) { + if (callback) { + this._worker.onmessage = function(event) { + callback.observe(this, event.type, event.data); + }; + this._worker.onerror = function(event) { + callback.observe(this, event.type, event.message); + event.preventDefault(); + }; + } + else { + this._worker.onmessage = null; + this._worker.onerror = null; + } + this._callback = callback; + } + }, + + get callback() { + return this._callback; + }, + + postMessage: function(data) { + this._ensureStarted(); + this._worker.postMessage(data); + }, + + terminate: function() { + this._ensureStarted(); + this._worker.terminate(); + delete this._callback; + } +}; + +function WorkerTestBootstrap() { +} +WorkerTestBootstrap.prototype = { + observe: function(subject, topic, data) { + + gWorkerAndCallback.callback = subject; + + switch (topic) { + case "postMessage": + gWorkerAndCallback.postMessage(data); + break; + + case "terminate": + gWorkerAndCallback.terminate(); + break; + + default: + throw new Error("Unknown worker command"); + } + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]) +}; + +var gFactory = { + register: function() { + var registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar); + + var classID = Components.ID("{36b5df0b-8dcf-4aa2-9c45-c51d871295f9}"); + var description = "WorkerTestBootstrap"; + var contractID = "@mozilla.org/test/workertestbootstrap;1"; + var factory = XPCOMUtils._getFactory(WorkerTestBootstrap); + + registrar.registerFactory(classID, description, contractID, factory); + + this.unregister = function() { + registrar.unregisterFactory(classID, factory); + delete this.unregister; + }; + } +}; + +function install(data, reason) { + testForExpectedSymbols("install"); +} + +function startup(data, reason) { + testForExpectedSymbols("startup"); + gFactory.register(); + gWorkerAndCallback.start(data); +} + +function shutdown(data, reason) { + testForExpectedSymbols("shutdown"); + gWorkerAndCallback.stop(); + gFactory.unregister(); +} + +function uninstall(data, reason) { + testForExpectedSymbols("uninstall"); +} diff --git a/dom/workers/test/extensions/bootstrap/install.rdf b/dom/workers/test/extensions/bootstrap/install.rdf new file mode 100644 index 000000000..fdd9638cd --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/install.rdf @@ -0,0 +1,31 @@ +<?xml version="1.0"?> + +<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:em="http://www.mozilla.org/2004/em-rdf#"> + + <Description about="urn:mozilla:install-manifest"> + <em:name>WorkerTestBootstrap</em:name> + <em:description>Worker functions for use in testing.</em:description> + <em:creator>Mozilla</em:creator> + <em:version>2016.03.09</em:version> + <em:id>workerbootstrap-test@mozilla.org</em:id> + <em:type>2</em:type> + <em:bootstrap>true</em:bootstrap> + <em:targetApplication> + <Description> + <!-- Firefox --> + <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> + <em:minVersion>45.0</em:minVersion> + <em:maxVersion>*</em:maxVersion> + </Description> + </em:targetApplication> + <em:targetApplication> + <Description> + <!-- Fennec --> + <em:id>{aa3c5121-dab2-40e2-81ca-7ea25febc110}</em:id> + <em:minVersion>45.0</em:minVersion> + <em:maxVersion>*</em:maxVersion> + </Description> + </em:targetApplication> + </Description> +</RDF> diff --git a/dom/workers/test/extensions/bootstrap/jar.mn b/dom/workers/test/extensions/bootstrap/jar.mn new file mode 100644 index 000000000..a9c625103 --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/jar.mn @@ -0,0 +1,3 @@ +workerbootstrap.jar: +% content workerbootstrap %content/ + content/worker.js (worker.js) diff --git a/dom/workers/test/extensions/bootstrap/moz.build b/dom/workers/test/extensions/bootstrap/moz.build new file mode 100644 index 000000000..aec5c249c --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/moz.build @@ -0,0 +1,20 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +XPI_NAME = 'workerbootstrap' + +JAR_MANIFESTS += ['jar.mn'] +USE_EXTENSION_MANIFEST = True +NO_JS_MANIFEST = True + +FINAL_TARGET_FILES += [ + 'bootstrap.js', + 'install.rdf', +] + +TEST_HARNESS_FILES.testing.mochitest.extensions += [ + 'workerbootstrap-test@mozilla.org.xpi', +] diff --git a/dom/workers/test/extensions/bootstrap/worker.js b/dom/workers/test/extensions/bootstrap/worker.js new file mode 100644 index 000000000..7346fc142 --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/worker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + postMessage(event.data); +} diff --git a/dom/workers/test/extensions/bootstrap/workerbootstrap-test@mozilla.org.xpi b/dom/workers/test/extensions/bootstrap/workerbootstrap-test@mozilla.org.xpi Binary files differnew file mode 100644 index 000000000..2dab975db --- /dev/null +++ b/dom/workers/test/extensions/bootstrap/workerbootstrap-test@mozilla.org.xpi diff --git a/dom/workers/test/extensions/moz.build b/dom/workers/test/extensions/moz.build new file mode 100644 index 000000000..51cf80fa2 --- /dev/null +++ b/dom/workers/test/extensions/moz.build @@ -0,0 +1,7 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +DIRS += ['bootstrap', 'traditional'] diff --git a/dom/workers/test/extensions/traditional/WorkerTest.js b/dom/workers/test/extensions/traditional/WorkerTest.js new file mode 100644 index 000000000..5890c0d4c --- /dev/null +++ b/dom/workers/test/extensions/traditional/WorkerTest.js @@ -0,0 +1,122 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cu = Components.utils; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +var gWorkerAndCallback = { + _worker: null, + _callback: null, + + _ensureStarted: function() { + if (!this._worker) { + throw new Error("Not yet started!"); + } + }, + + start: function() { + if (!this._worker) { + var worker = new Worker("chrome://worker/content/worker.js"); + worker.onerror = function(event) { + Cu.reportError(event.message); + event.preventDefault(); + }; + + this._worker = worker; + } + }, + + stop: function() { + if (this._worker) { + try { + this.terminate(); + } + catch(e) { + Cu.reportError(e); + } + this._worker = null; + } + }, + + set callback(val) { + this._ensureStarted(); + if (val) { + var callback = val.QueryInterface(Ci.nsIWorkerTestCallback); + if (this.callback != callback) { + this._worker.onmessage = function(event) { + callback.onmessage(event.data); + }; + this._worker.onerror = function(event) { + callback.onerror(event.message); + event.preventDefault(); + }; + this._callback = callback; + } + } + else { + this._worker.onmessage = null; + this._worker.onerror = null; + this._callback = null; + } + }, + + get callback() { + return this._callback; + }, + + postMessage: function(data) { + this._ensureStarted(); + this._worker.postMessage(data); + }, + + terminate: function() { + this._ensureStarted(); + this._worker.terminate(); + this.callback = null; + } +}; + +function WorkerTest() { +} +WorkerTest.prototype = { + observe: function(subject, topic, data) { + switch(topic) { + case "profile-after-change": + gWorkerAndCallback.start(); + Services.obs.addObserver(this, "profile-before-change", false); + break; + case "profile-before-change": + gWorkerAndCallback.stop(); + break; + default: + Cu.reportError("Unknown topic: " + topic); + } + }, + + set callback(val) { + gWorkerAndCallback.callback = val; + }, + + get callback() { + return gWorkerAndCallback.callback; + }, + + postMessage: function(message) { + gWorkerAndCallback.postMessage(message); + }, + + terminate: function() { + gWorkerAndCallback.terminate(); + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsIWorkerTest]), + classID: Components.ID("{3b52b935-551f-4606-ba4c-decc18b67bfd}") +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([WorkerTest]); diff --git a/dom/workers/test/extensions/traditional/WorkerTest.manifest b/dom/workers/test/extensions/traditional/WorkerTest.manifest new file mode 100644 index 000000000..a5a32fb06 --- /dev/null +++ b/dom/workers/test/extensions/traditional/WorkerTest.manifest @@ -0,0 +1,3 @@ +component {3b52b935-551f-4606-ba4c-decc18b67bfd} WorkerTest.js +contract @mozilla.org/test/workertest;1 {3b52b935-551f-4606-ba4c-decc18b67bfd} +category profile-after-change WorkerTest @mozilla.org/test/workertest;1 diff --git a/dom/workers/test/extensions/traditional/install.rdf b/dom/workers/test/extensions/traditional/install.rdf new file mode 100644 index 000000000..00fc0f441 --- /dev/null +++ b/dom/workers/test/extensions/traditional/install.rdf @@ -0,0 +1,30 @@ +<?xml version="1.0"?> + +<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:em="http://www.mozilla.org/2004/em-rdf#"> + + <Description about="urn:mozilla:install-manifest"> + <em:name>WorkerTest</em:name> + <em:description>Worker functions for use in testing.</em:description> + <em:creator>Mozilla</em:creator> + <em:version>2016.03.09</em:version> + <em:id>worker-test@mozilla.org</em:id> + <em:type>2</em:type> + <em:targetApplication> + <Description> + <!-- Firefox --> + <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> + <em:minVersion>45.0</em:minVersion> + <em:maxVersion>*</em:maxVersion> + </Description> + </em:targetApplication> + <em:targetApplication> + <Description> + <!-- Fennec --> + <em:id>{aa3c5121-dab2-40e2-81ca-7ea25febc110}</em:id> + <em:minVersion>45.0</em:minVersion> + <em:maxVersion>*</em:maxVersion> + </Description> + </em:targetApplication> + </Description> +</RDF> diff --git a/dom/workers/test/extensions/traditional/jar.mn b/dom/workers/test/extensions/traditional/jar.mn new file mode 100644 index 000000000..421ee55a0 --- /dev/null +++ b/dom/workers/test/extensions/traditional/jar.mn @@ -0,0 +1,3 @@ +worker.jar: +% content worker %content/ + content/worker.js (worker.js) diff --git a/dom/workers/test/extensions/traditional/moz.build b/dom/workers/test/extensions/traditional/moz.build new file mode 100644 index 000000000..d0920420d --- /dev/null +++ b/dom/workers/test/extensions/traditional/moz.build @@ -0,0 +1,30 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +XPIDL_SOURCES += [ + 'nsIWorkerTest.idl', +] + +XPIDL_MODULE = 'WorkerTest' + +EXTRA_COMPONENTS += [ + 'WorkerTest.js', + 'WorkerTest.manifest', +] + +XPI_NAME = 'worker' + +JAR_MANIFESTS += ['jar.mn'] +USE_EXTENSION_MANIFEST = True +NO_JS_MANIFEST = True + +FINAL_TARGET_FILES += [ + 'install.rdf', +] + +TEST_HARNESS_FILES.testing.mochitest.extensions += [ + 'worker-test@mozilla.org.xpi', +] diff --git a/dom/workers/test/extensions/traditional/nsIWorkerTest.idl b/dom/workers/test/extensions/traditional/nsIWorkerTest.idl new file mode 100644 index 000000000..32a952038 --- /dev/null +++ b/dom/workers/test/extensions/traditional/nsIWorkerTest.idl @@ -0,0 +1,23 @@ +/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */ +/* vim: set ts=2 et sw=2 tw=40: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(10f8ebdf-1373-4640-9c34-53dee99f526f)] +interface nsIWorkerTestCallback : nsISupports +{ + void onmessage(in DOMString data); + void onerror(in DOMString data); +}; + +[scriptable, uuid(887a0614-a0f0-4c0e-80e0-cf31e6d4e286)] +interface nsIWorkerTest : nsISupports +{ + void postMessage(in DOMString data); + void terminate(); + + attribute nsIWorkerTestCallback callback; +}; diff --git a/dom/workers/test/extensions/traditional/worker-test@mozilla.org.xpi b/dom/workers/test/extensions/traditional/worker-test@mozilla.org.xpi Binary files differnew file mode 100644 index 000000000..8d2386894 --- /dev/null +++ b/dom/workers/test/extensions/traditional/worker-test@mozilla.org.xpi diff --git a/dom/workers/test/extensions/traditional/worker.js b/dom/workers/test/extensions/traditional/worker.js new file mode 100644 index 000000000..7346fc142 --- /dev/null +++ b/dom/workers/test/extensions/traditional/worker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + postMessage(event.data); +} diff --git a/dom/workers/test/fibonacci_worker.js b/dom/workers/test/fibonacci_worker.js new file mode 100644 index 000000000..fa35385e7 --- /dev/null +++ b/dom/workers/test/fibonacci_worker.js @@ -0,0 +1,24 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + var n = parseInt(event.data); + + if (n < 2) { + postMessage(n); + return; + } + + var results = []; + for (var i = 1; i <= 2; i++) { + var worker = new Worker("fibonacci_worker.js"); + worker.onmessage = function(event) { + results.push(parseInt(event.data)); + if (results.length == 2) { + postMessage(results[0] + results[1]); + } + }; + worker.postMessage(n - i); + } +} diff --git a/dom/workers/test/fileBlobSubWorker_worker.js b/dom/workers/test/fileBlobSubWorker_worker.js new file mode 100644 index 000000000..2dc8cd12d --- /dev/null +++ b/dom/workers/test/fileBlobSubWorker_worker.js @@ -0,0 +1,17 @@ +/** + * Expects a blob. Returns an object containing the size, type. + * Used to test posting of blob from worker to worker. + */ +onmessage = function(event) { + var worker = new Worker("fileBlob_worker.js"); + + worker.postMessage(event.data); + + worker.onmessage = function(event) { + postMessage(event.data); + } + + worker.onerror = function(event) { + postMessage(undefined); + } +}; diff --git a/dom/workers/test/fileBlob_worker.js b/dom/workers/test/fileBlob_worker.js new file mode 100644 index 000000000..2f7a31714 --- /dev/null +++ b/dom/workers/test/fileBlob_worker.js @@ -0,0 +1,13 @@ +/** + * Expects a blob. Returns an object containing the size, type. + */ +onmessage = function(event) { + var file = event.data; + + var rtnObj = new Object(); + + rtnObj.size = file.size; + rtnObj.type = file.type; + + postMessage(rtnObj); +}; diff --git a/dom/workers/test/filePosting_worker.js b/dom/workers/test/filePosting_worker.js new file mode 100644 index 000000000..2a24b2a40 --- /dev/null +++ b/dom/workers/test/filePosting_worker.js @@ -0,0 +1,3 @@ +onmessage = function(event) { + postMessage(event.data); +}; diff --git a/dom/workers/test/fileReadSlice_worker.js b/dom/workers/test/fileReadSlice_worker.js new file mode 100644 index 000000000..2c10b7d76 --- /dev/null +++ b/dom/workers/test/fileReadSlice_worker.js @@ -0,0 +1,16 @@ +/** + * Expects an object containing a blob, a start index and an end index + * for slicing. Returns the contents of the blob read as text. + */ +onmessage = function(event) { + var blob = event.data.blob; + var start = event.data.start; + var end = event.data.end; + + var slicedBlob = blob.slice(start, end); + + var fileReader = new FileReaderSync(); + var text = fileReader.readAsText(slicedBlob); + + postMessage(text); +}; diff --git a/dom/workers/test/fileReaderSyncErrors_worker.js b/dom/workers/test/fileReaderSyncErrors_worker.js new file mode 100644 index 000000000..f79ecc6f0 --- /dev/null +++ b/dom/workers/test/fileReaderSyncErrors_worker.js @@ -0,0 +1,74 @@ +/** + * Delegates "is" evaluation back to main thread. + */ +function is(actual, expected, message) { + var rtnObj = new Object(); + rtnObj.actual = actual; + rtnObj.expected = expected; + rtnObj.message = message; + postMessage(rtnObj); +} + +/** + * Tries to write to property. + */ +function writeProperty(file, property) { + var oldValue = file[property]; + file[property] = -1; + is(file[property], oldValue, "Property " + property + " should be readonly."); +} + +/** + * Passes junk arguments to FileReaderSync methods and expects an exception to + * be thrown. + */ +function fileReaderJunkArgument(blob) { + var fileReader = new FileReaderSync(); + + try { + fileReader.readAsBinaryString(blob); + is(false, true, "Should have thrown an exception calling readAsBinaryString."); + } catch(ex) { + is(true, true, "Should have thrown an exception."); + } + + try { + fileReader.readAsDataURL(blob); + is(false, true, "Should have thrown an exception calling readAsDataURL."); + } catch(ex) { + is(true, true, "Should have thrown an exception."); + } + + try { + fileReader.readAsArrayBuffer(blob); + is(false, true, "Should have thrown an exception calling readAsArrayBuffer."); + } catch(ex) { + is(true, true, "Should have thrown an exception."); + } + + try { + fileReader.readAsText(blob); + is(false, true, "Should have thrown an exception calling readAsText."); + } catch(ex) { + is(true, true, "Should have thrown an exception."); + } +} + +onmessage = function(event) { + var file = event.data; + + // Test read only properties. + writeProperty(file, "size"); + writeProperty(file, "type"); + writeProperty(file, "name"); + + // Bad types. + fileReaderJunkArgument(undefined); + fileReaderJunkArgument(-1); + fileReaderJunkArgument(1); + fileReaderJunkArgument(new Object()); + fileReaderJunkArgument("hello"); + + // Post undefined to indicate that testing has finished. + postMessage(undefined); +}; diff --git a/dom/workers/test/fileReaderSync_worker.js b/dom/workers/test/fileReaderSync_worker.js new file mode 100644 index 000000000..4a37409d5 --- /dev/null +++ b/dom/workers/test/fileReaderSync_worker.js @@ -0,0 +1,25 @@ +var reader = new FileReaderSync(); + +/** + * Expects an object containing a file and an encoding then uses a + * FileReaderSync to read the file. Returns an object containing the + * file read a binary string, text, url and ArrayBuffer. + */ +onmessage = function(event) { + var file = event.data.file; + var encoding = event.data.encoding; + + var rtnObj = new Object(); + + if (encoding != undefined) { + rtnObj.text = reader.readAsText(file, encoding); + } else { + rtnObj.text = reader.readAsText(file); + } + + rtnObj.bin = reader.readAsBinaryString(file); + rtnObj.url = reader.readAsDataURL(file); + rtnObj.arrayBuffer = reader.readAsArrayBuffer(file); + + postMessage(rtnObj); +}; diff --git a/dom/workers/test/fileSlice_worker.js b/dom/workers/test/fileSlice_worker.js new file mode 100644 index 000000000..d0c6364e2 --- /dev/null +++ b/dom/workers/test/fileSlice_worker.js @@ -0,0 +1,27 @@ +/** + * Expects an object containing a blob, a start offset, an end offset + * and an optional content type to slice the blob. Returns an object + * containing the size and type of the sliced blob. + */ +onmessage = function(event) { + var blob = event.data.blob; + var start = event.data.start; + var end = event.data.end; + var contentType = event.data.contentType; + + var slicedBlob; + if (contentType == undefined && end == undefined) { + slicedBlob = blob.slice(start); + } else if (contentType == undefined) { + slicedBlob = blob.slice(start, end); + } else { + slicedBlob = blob.slice(start, end, contentType); + } + + var rtnObj = new Object(); + + rtnObj.size = slicedBlob.size; + rtnObj.type = slicedBlob.type; + + postMessage(rtnObj); +}; diff --git a/dom/workers/test/fileSubWorker_worker.js b/dom/workers/test/fileSubWorker_worker.js new file mode 100644 index 000000000..21fbc3454 --- /dev/null +++ b/dom/workers/test/fileSubWorker_worker.js @@ -0,0 +1,17 @@ +/** + * Expects a file. Returns an object containing the size, type, name and path + * using another worker. Used to test posting of file from worker to worker. + */ +onmessage = function(event) { + var worker = new Worker("file_worker.js"); + + worker.postMessage(event.data); + + worker.onmessage = function(event) { + postMessage(event.data); + } + + worker.onerror = function(event) { + postMessage(undefined); + } +}; diff --git a/dom/workers/test/file_bug1010784_worker.js b/dom/workers/test/file_bug1010784_worker.js new file mode 100644 index 000000000..239968069 --- /dev/null +++ b/dom/workers/test/file_bug1010784_worker.js @@ -0,0 +1,9 @@ +onmessage = function(event) { + var xhr = new XMLHttpRequest(); + + xhr.open("GET", event.data, false); + xhr.send(); + xhr.open("GET", event.data, false); + xhr.send(); + postMessage("done"); +} diff --git a/dom/workers/test/file_worker.js b/dom/workers/test/file_worker.js new file mode 100644 index 000000000..23233b8ac --- /dev/null +++ b/dom/workers/test/file_worker.js @@ -0,0 +1,16 @@ +/** + * Expects a file. Returns an object containing the size, type, name and path. + */ +onmessage = function(event) { + var file = event.data; + + var rtnObj = new Object(); + + rtnObj.size = file.size; + rtnObj.type = file.type; + rtnObj.name = file.name; + rtnObj.path = file.path; + rtnObj.lastModifiedDate = file.lastModifiedDate; + + postMessage(rtnObj); +}; diff --git a/dom/workers/test/fileapi_chromeScript.js b/dom/workers/test/fileapi_chromeScript.js new file mode 100644 index 000000000..614b556ed --- /dev/null +++ b/dom/workers/test/fileapi_chromeScript.js @@ -0,0 +1,29 @@ +var { classes: Cc, interfaces: Ci, utils: Cu } = Components; +Cu.importGlobalProperties(["File"]); + +var fileNum = 1; + +function createFileWithData(fileData) { + var willDelete = fileData === null; + var dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties); + var testFile = dirSvc.get("ProfD", Ci.nsIFile); + testFile.append("fileAPItestfile" + fileNum); + fileNum++; + var outStream = Cc["@mozilla.org/network/file-output-stream;1"].createInstance(Ci.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0o666, 0); + if (willDelete) { + fileData = "some irrelevant test data\n"; + } + outStream.write(fileData, fileData.length); + outStream.close(); + var domFile = File.createFromNsIFile(testFile); + if (willDelete) { + testFile.remove(/* recursive: */ false); + } + return domFile; +} + +addMessageListener("files.open", function (message) { + sendAsyncMessage("files.opened", message.map(createFileWithData)); +}); diff --git a/dom/workers/test/foreign.js b/dom/workers/test/foreign.js new file mode 100644 index 000000000..33c982fa8 --- /dev/null +++ b/dom/workers/test/foreign.js @@ -0,0 +1 @@ +response = "bad"; diff --git a/dom/workers/test/frame_script.js b/dom/workers/test/frame_script.js new file mode 100644 index 000000000..ffc384416 --- /dev/null +++ b/dom/workers/test/frame_script.js @@ -0,0 +1,72 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const { interfaces: Ci } = Components; + +let workers = {}; + +let methods = { + /** + * Create a worker with the given `url` in this tab. + */ + createWorker: function (url) { + dump("Frame script: creating worker with url '" + url + "'\n"); + + workers[url] = new content.Worker(url); + return Promise.resolve(); + }, + + /** + * Terminate the worker with the given `url` in this tab. + */ + terminateWorker: function (url) { + dump("Frame script: terminating worker with url '" + url + "'\n"); + + workers[url].terminate(); + delete workers[url]; + return Promise.resolve(); + }, + + /** + * Post the given `message` to the worker with the given `url` in this tab. + */ + postMessageToWorker: function (url, message) { + dump("Frame script: posting message to worker with url '" + url + "'\n"); + + let worker = workers[url]; + worker.postMessage(message); + return new Promise(function (resolve) { + worker.onmessage = function (event) { + worker.onmessage = null; + resolve(event.data); + }; + }); + }, + + /** + * Disable the cache for this tab. + */ + disableCache: function () { + docShell.defaultLoadFlags = Ci.nsIRequest.LOAD_BYPASS_CACHE + | Ci.nsIRequest.INHIBIT_CACHING; + } +}; + +addMessageListener("jsonrpc", function (event) { + let { id, method, params } = event.data; + Promise.resolve().then(function () { + return methods[method].apply(undefined, params); + }).then(function (result) { + sendAsyncMessage("jsonrpc", { + id: id, + result: result + }); + }).catch(function (error) { + sendAsyncMessage("jsonrpc", { + id: id, + error: error.toString() + }); + }); +}); diff --git a/dom/workers/test/gtest/TestReadWrite.cpp b/dom/workers/test/gtest/TestReadWrite.cpp new file mode 100644 index 000000000..d59888e24 --- /dev/null +++ b/dom/workers/test/gtest/TestReadWrite.cpp @@ -0,0 +1,499 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/dom/ServiceWorkerRegistrar.h" +#include "mozilla/dom/ServiceWorkerRegistrarTypes.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" + +#include "nsAppDirectoryServiceDefs.h" +#include "nsIFile.h" +#include "nsIOutputStream.h" +#include "nsNetUtil.h" +#include "nsPrintfCString.h" + +using namespace mozilla::dom; +using namespace mozilla::ipc; + +class ServiceWorkerRegistrarTest : public ServiceWorkerRegistrar +{ +public: + ServiceWorkerRegistrarTest() + { +#if defined(DEBUG) || !defined(RELEASE_OR_BETA) + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(mProfileDir)); + MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv)); +#else + NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(mProfileDir)); +#endif + MOZ_DIAGNOSTIC_ASSERT(mProfileDir); + } + + nsresult TestReadData() { return ReadData(); } + nsresult TestWriteData() { return WriteData(); } + void TestDeleteData() { DeleteData(); } + + void TestRegisterServiceWorker(const ServiceWorkerRegistrationData& aData) + { + RegisterServiceWorkerInternal(aData); + } + + nsTArray<ServiceWorkerRegistrationData>& TestGetData() { return mData; } +}; + +already_AddRefed<nsIFile> +GetFile() +{ + nsCOMPtr<nsIFile> file; + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(file)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + file->Append(NS_LITERAL_STRING(SERVICEWORKERREGISTRAR_FILE)); + return file.forget(); +} + +bool +CreateFile(const nsACString& aData) +{ + nsCOMPtr<nsIFile> file = GetFile(); + + nsCOMPtr<nsIOutputStream> stream; + nsresult rv = NS_NewLocalFileOutputStream(getter_AddRefs(stream), file); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + uint32_t count; + rv = stream->Write(aData.Data(), aData.Length(), &count); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + if (count != aData.Length()) { + return false; + } + + return true; +} + +TEST(ServiceWorkerRegistrar, TestNoFile) +{ + nsCOMPtr<nsIFile> file = GetFile(); + ASSERT_TRUE(file) << "GetFile must return a nsIFIle"; + + bool exists; + nsresult rv = file->Exists(&exists); + ASSERT_EQ(NS_OK, rv) << "nsIFile::Exists cannot fail"; + + if (exists) { + rv = file->Remove(false); + ASSERT_EQ(NS_OK, rv) << "nsIFile::Remove cannot fail"; + } + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)0, data.Length()) << "No data should be found in an empty file"; +} + +TEST(ServiceWorkerRegistrar, TestEmptyFile) +{ + ASSERT_TRUE(CreateFile(EmptyCString())) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_NE(NS_OK, rv) << "ReadData() should fail if the file is empty"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)0, data.Length()) << "No data should be found in an empty file"; +} + +TEST(ServiceWorkerRegistrar, TestRightVersionFile) +{ + ASSERT_TRUE(CreateFile(NS_LITERAL_CSTRING(SERVICEWORKERREGISTRAR_VERSION "\n"))) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail when the version is correct"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)0, data.Length()) << "No data should be found in an empty file"; +} + +TEST(ServiceWorkerRegistrar, TestWrongVersionFile) +{ + ASSERT_TRUE(CreateFile(NS_LITERAL_CSTRING(SERVICEWORKERREGISTRAR_VERSION "bla\n"))) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_NE(NS_OK, rv) << "ReadData() should fail when the version is not correct"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)0, data.Length()) << "No data should be found in an empty file"; +} + +TEST(ServiceWorkerRegistrar, TestReadData) +{ + nsAutoCString buffer(SERVICEWORKERREGISTRAR_VERSION "\n"); + + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("scope 0\ncurrentWorkerURL 0\ncacheName 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("\n"); + buffer.Append("scope 1\ncurrentWorkerURL 1\ncacheName 1\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found"; + + const mozilla::ipc::PrincipalInfo& info0 = data[0].principal(); + ASSERT_EQ(info0.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo0 = data[0].principal(); + + nsAutoCString suffix0; + cInfo0.attrs().CreateSuffix(suffix0); + + ASSERT_STREQ("^appId=123&inBrowser=1", suffix0.get()); + ASSERT_STREQ("scope 0", cInfo0.spec().get()); + ASSERT_STREQ("scope 0", data[0].scope().get()); + ASSERT_STREQ("currentWorkerURL 0", data[0].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 0", NS_ConvertUTF16toUTF8(data[0].cacheName()).get()); + + const mozilla::ipc::PrincipalInfo& info1 = data[1].principal(); + ASSERT_EQ(info1.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo1 = data[1].principal(); + + nsAutoCString suffix1; + cInfo1.attrs().CreateSuffix(suffix1); + + ASSERT_STREQ("", suffix1.get()); + ASSERT_STREQ("scope 1", cInfo1.spec().get()); + ASSERT_STREQ("scope 1", data[1].scope().get()); + ASSERT_STREQ("currentWorkerURL 1", data[1].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get()); +} + +TEST(ServiceWorkerRegistrar, TestDeleteData) +{ + ASSERT_TRUE(CreateFile(NS_LITERAL_CSTRING("Foobar"))) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + swr->TestDeleteData(); + + nsCOMPtr<nsIFile> file = GetFile(); + + bool exists; + nsresult rv = file->Exists(&exists); + ASSERT_EQ(NS_OK, rv) << "nsIFile::Exists cannot fail"; + + ASSERT_FALSE(exists) << "The file should not exist after a DeleteData()."; +} + +TEST(ServiceWorkerRegistrar, TestWriteData) +{ + { + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + for (int i = 0; i < 10; ++i) { + ServiceWorkerRegistrationData reg; + + reg.scope() = nsPrintfCString("scope write %d", i); + reg.currentWorkerURL() = nsPrintfCString("currentWorkerURL write %d", i); + reg.cacheName() = + NS_ConvertUTF8toUTF16(nsPrintfCString("cacheName write %d", i)); + + nsAutoCString spec; + spec.AppendPrintf("spec write %d", i); + reg.principal() = + mozilla::ipc::ContentPrincipalInfo(mozilla::PrincipalOriginAttributes(i, i % 2), + mozilla::void_t(), spec); + + swr->TestRegisterServiceWorker(reg); + } + + nsresult rv = swr->TestWriteData(); + ASSERT_EQ(NS_OK, rv) << "WriteData() should not fail"; + } + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)10, data.Length()) << "10 entries should be found"; + + for (int i = 0; i < 10; ++i) { + nsAutoCString test; + + ASSERT_EQ(data[i].principal().type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); + const mozilla::ipc::ContentPrincipalInfo& cInfo = data[i].principal(); + + mozilla::PrincipalOriginAttributes attrs(i, i % 2); + nsAutoCString suffix, expectSuffix; + attrs.CreateSuffix(expectSuffix); + cInfo.attrs().CreateSuffix(suffix); + + ASSERT_STREQ(expectSuffix.get(), suffix.get()); + + test.AppendPrintf("scope write %d", i); + ASSERT_STREQ(test.get(), cInfo.spec().get()); + + test.Truncate(); + test.AppendPrintf("scope write %d", i); + ASSERT_STREQ(test.get(), data[i].scope().get()); + + test.Truncate(); + test.AppendPrintf("currentWorkerURL write %d", i); + ASSERT_STREQ(test.get(), data[i].currentWorkerURL().get()); + + test.Truncate(); + test.AppendPrintf("cacheName write %d", i); + ASSERT_STREQ(test.get(), NS_ConvertUTF16toUTF8(data[i].cacheName()).get()); + } +} + +TEST(ServiceWorkerRegistrar, TestVersion2Migration) +{ + nsAutoCString buffer("2" "\n"); + + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("spec 0\nscope 0\nscriptSpec 0\ncurrentWorkerURL 0\nactiveCache 0\nwaitingCache 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("\n"); + buffer.Append("spec 1\nscope 1\nscriptSpec 1\ncurrentWorkerURL 1\nactiveCache 1\nwaitingCache 1\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found"; + + const mozilla::ipc::PrincipalInfo& info0 = data[0].principal(); + ASSERT_EQ(info0.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo0 = data[0].principal(); + + nsAutoCString suffix0; + cInfo0.attrs().CreateSuffix(suffix0); + + ASSERT_STREQ("^appId=123&inBrowser=1", suffix0.get()); + ASSERT_STREQ("scope 0", cInfo0.spec().get()); + ASSERT_STREQ("scope 0", data[0].scope().get()); + ASSERT_STREQ("currentWorkerURL 0", data[0].currentWorkerURL().get()); + ASSERT_STREQ("activeCache 0", NS_ConvertUTF16toUTF8(data[0].cacheName()).get()); + + const mozilla::ipc::PrincipalInfo& info1 = data[1].principal(); + ASSERT_EQ(info1.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo1 = data[1].principal(); + + nsAutoCString suffix1; + cInfo1.attrs().CreateSuffix(suffix1); + + ASSERT_STREQ("", suffix1.get()); + ASSERT_STREQ("scope 1", cInfo1.spec().get()); + ASSERT_STREQ("scope 1", data[1].scope().get()); + ASSERT_STREQ("currentWorkerURL 1", data[1].currentWorkerURL().get()); + ASSERT_STREQ("activeCache 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get()); +} + +TEST(ServiceWorkerRegistrar, TestVersion3Migration) +{ + nsAutoCString buffer("3" "\n"); + + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("spec 0\nscope 0\ncurrentWorkerURL 0\ncacheName 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("\n"); + buffer.Append("spec 1\nscope 1\ncurrentWorkerURL 1\ncacheName 1\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found"; + + const mozilla::ipc::PrincipalInfo& info0 = data[0].principal(); + ASSERT_EQ(info0.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo0 = data[0].principal(); + + nsAutoCString suffix0; + cInfo0.attrs().CreateSuffix(suffix0); + + ASSERT_STREQ("^appId=123&inBrowser=1", suffix0.get()); + ASSERT_STREQ("scope 0", cInfo0.spec().get()); + ASSERT_STREQ("scope 0", data[0].scope().get()); + ASSERT_STREQ("currentWorkerURL 0", data[0].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 0", NS_ConvertUTF16toUTF8(data[0].cacheName()).get()); + + const mozilla::ipc::PrincipalInfo& info1 = data[1].principal(); + ASSERT_EQ(info1.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo1 = data[1].principal(); + + nsAutoCString suffix1; + cInfo1.attrs().CreateSuffix(suffix1); + + ASSERT_STREQ("", suffix1.get()); + ASSERT_STREQ("scope 1", cInfo1.spec().get()); + ASSERT_STREQ("scope 1", data[1].scope().get()); + ASSERT_STREQ("currentWorkerURL 1", data[1].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get()); +} + +TEST(ServiceWorkerRegistrar, TestDedupeRead) +{ + nsAutoCString buffer("3" "\n"); + + // unique entries + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("spec 0\nscope 0\ncurrentWorkerURL 0\ncacheName 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("\n"); + buffer.Append("spec 1\nscope 1\ncurrentWorkerURL 1\ncacheName 1\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + // dupe entries + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("spec 1\nscope 0\ncurrentWorkerURL 0\ncacheName 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("^appId=123&inBrowser=1\n"); + buffer.Append("spec 2\nscope 0\ncurrentWorkerURL 0\ncacheName 0\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + buffer.Append("\n"); + buffer.Append("spec 3\nscope 1\ncurrentWorkerURL 1\ncacheName 1\n"); + buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n"); + + ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail"; + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found"; + + const mozilla::ipc::PrincipalInfo& info0 = data[0].principal(); + ASSERT_EQ(info0.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo0 = data[0].principal(); + + nsAutoCString suffix0; + cInfo0.attrs().CreateSuffix(suffix0); + + ASSERT_STREQ("^appId=123&inBrowser=1", suffix0.get()); + ASSERT_STREQ("scope 0", cInfo0.spec().get()); + ASSERT_STREQ("scope 0", data[0].scope().get()); + ASSERT_STREQ("currentWorkerURL 0", data[0].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 0", NS_ConvertUTF16toUTF8(data[0].cacheName()).get()); + + const mozilla::ipc::PrincipalInfo& info1 = data[1].principal(); + ASSERT_EQ(info1.type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) << "First principal must be content"; + const mozilla::ipc::ContentPrincipalInfo& cInfo1 = data[1].principal(); + + nsAutoCString suffix1; + cInfo1.attrs().CreateSuffix(suffix1); + + ASSERT_STREQ("", suffix1.get()); + ASSERT_STREQ("scope 1", cInfo1.spec().get()); + ASSERT_STREQ("scope 1", data[1].scope().get()); + ASSERT_STREQ("currentWorkerURL 1", data[1].currentWorkerURL().get()); + ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get()); +} + +TEST(ServiceWorkerRegistrar, TestDedupeWrite) +{ + { + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + for (int i = 0; i < 10; ++i) { + ServiceWorkerRegistrationData reg; + + reg.scope() = NS_LITERAL_CSTRING("scope write dedupe"); + reg.currentWorkerURL() = nsPrintfCString("currentWorkerURL write %d", i); + reg.cacheName() = + NS_ConvertUTF8toUTF16(nsPrintfCString("cacheName write %d", i)); + + nsAutoCString spec; + spec.AppendPrintf("spec write dedupe/%d", i); + reg.principal() = + mozilla::ipc::ContentPrincipalInfo(mozilla::PrincipalOriginAttributes(0, false), + mozilla::void_t(), spec); + + swr->TestRegisterServiceWorker(reg); + } + + nsresult rv = swr->TestWriteData(); + ASSERT_EQ(NS_OK, rv) << "WriteData() should not fail"; + } + + RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest; + + nsresult rv = swr->TestReadData(); + ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail"; + + // Duplicate entries should be removed. + const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData(); + ASSERT_EQ((uint32_t)1, data.Length()) << "1 entry should be found"; + + ASSERT_EQ(data[0].principal().type(), mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); + const mozilla::ipc::ContentPrincipalInfo& cInfo = data[0].principal(); + + mozilla::PrincipalOriginAttributes attrs(0, false); + nsAutoCString suffix, expectSuffix; + attrs.CreateSuffix(expectSuffix); + cInfo.attrs().CreateSuffix(suffix); + + // Last entry passed to RegisterServiceWorkerInternal() should overwrite + // previous values. So expect "9" in values here. + ASSERT_STREQ(expectSuffix.get(), suffix.get()); + ASSERT_STREQ("scope write dedupe", cInfo.spec().get()); + ASSERT_STREQ("scope write dedupe", data[0].scope().get()); + ASSERT_STREQ("currentWorkerURL write 9", data[0].currentWorkerURL().get()); + ASSERT_STREQ("cacheName write 9", + NS_ConvertUTF16toUTF8(data[0].cacheName()).get()); +} + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + + int rv = RUN_ALL_TESTS(); + return rv; +} diff --git a/dom/workers/test/gtest/moz.build b/dom/workers/test/gtest/moz.build new file mode 100644 index 000000000..5f1f185a9 --- /dev/null +++ b/dom/workers/test/gtest/moz.build @@ -0,0 +1,13 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, you can obtain one at http://mozilla.org/MPL/2.0/. + +UNIFIED_SOURCES = [ + 'TestReadWrite.cpp', +] + +include('/ipc/chromium/chromium-config.mozbuild') + +FINAL_LIBRARY = 'xul-gtest' diff --git a/dom/workers/test/head.js b/dom/workers/test/head.js new file mode 100644 index 000000000..5f0c5c26e --- /dev/null +++ b/dom/workers/test/head.js @@ -0,0 +1,91 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +const EXAMPLE_URL = "http://example.com/browser/dom/workers/test/"; +const FRAME_SCRIPT_URL = getRootDirectory(gTestPath) + "frame_script.js"; + +/** + * Add a tab with given `url`, and load a frame script in it. Returns a promise + * that will be resolved when the tab finished loading. + */ +function addTab(url) { + let tab = gBrowser.addTab(TAB_URL); + gBrowser.selectedTab = tab; + let linkedBrowser = tab.linkedBrowser; + linkedBrowser.messageManager.loadFrameScript(FRAME_SCRIPT_URL, false); + return new Promise(function (resolve) { + linkedBrowser.addEventListener("load", function onload() { + linkedBrowser.removeEventListener("load", onload, true); + resolve(tab); + }, true); + }); +} + +/** + * Remove the given `tab`. + */ +function removeTab(tab) { + gBrowser.removeTab(tab); +} + +let nextId = 0; + +/** + * Send a JSON RPC request to the frame script in the given `tab`, invoking the + * given `method` with the given `params`. Returns a promise that will be + * resolved with the result of the invocation. + */ +function jsonrpc(tab, method, params) { + let currentId = nextId++; + let messageManager = tab.linkedBrowser.messageManager; + messageManager.sendAsyncMessage("jsonrpc", { + id: currentId, + method: method, + params: params + }); + return new Promise(function (resolve, reject) { + messageManager.addMessageListener("jsonrpc", function listener(event) { + let { id, result, error } = event.data; + if (id !== currentId) { + return; + } + messageManager.removeMessageListener("jsonrpc", listener); + if (error) { + reject(error); + return; + } + resolve(result); + }); + }); +} + +/** + * Create a worker with the given `url` in the given `tab`. + */ +function createWorkerInTab(tab, url) { + return jsonrpc(tab, "createWorker", [url]); +} + +/** + * Terminate the worker with the given `url` in the given `tab`. + */ +function terminateWorkerInTab(tab, url) { + return jsonrpc(tab, "terminateWorker", [url]); +} + +/** + * Post the given `message` to the worker with the given `url` in the given + * `tab`. + */ +function postMessageToWorkerInTab(tab, url, message) { + return jsonrpc(tab, "postMessageToWorker", [url, message]); +} + +/** + * Disable the cache in the given `tab`. + */ +function disableCacheInTab(tab) { + return jsonrpc(tab, "disableCache", []); +} diff --git a/dom/workers/test/importForeignScripts_worker.js b/dom/workers/test/importForeignScripts_worker.js new file mode 100644 index 000000000..5faa29c31 --- /dev/null +++ b/dom/workers/test/importForeignScripts_worker.js @@ -0,0 +1,55 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var target = self; +var response; + +function runTests() { + response = "good"; + try { + importScripts("http://example.org/tests/dom/workers/test/foreign.js"); + } catch(e) { + dump("Got error " + e + " when calling importScripts"); + } + if (response === "good") { + try { + importScripts("redirect_to_foreign.sjs"); + } catch(e) { + dump("Got error " + e + " when calling importScripts"); + } + } + target.postMessage(response); + + // Now, test a nested worker. + if (location.search !== "?nested") { + var worker = new Worker("importForeignScripts_worker.js?nested"); + + worker.onmessage = function(e) { + target.postMessage(e.data); + target.postMessage("finish"); + } + + worker.onerror = function() { + target.postMessage("nested worker error"); + } + + worker.postMessage("start"); + } +} + +onmessage = function(e) { + if (e.data === "start") { + runTests(); + } +}; + +onconnect = function(e) { + target = e.ports[0]; + e.ports[0].onmessage = function(e) { + if (e.data === "start") { + runTests(); + } + }; +}; diff --git a/dom/workers/test/importScripts_3rdParty_worker.js b/dom/workers/test/importScripts_3rdParty_worker.js new file mode 100644 index 000000000..ebf2d3b14 --- /dev/null +++ b/dom/workers/test/importScripts_3rdParty_worker.js @@ -0,0 +1,82 @@ +const workerURL = 'http://mochi.test:8888/tests/dom/workers/test/importScripts_3rdParty_worker.js'; + +onmessage = function(a) { + if (a.data.nested) { + var worker = new Worker(workerURL); + worker.onmessage = function(event) { + postMessage(event.data); + } + + worker.onerror = function(event) { + event.preventDefault(); + postMessage({ error: event instanceof ErrorEvent && + event.filename == workerURL }); + } + + a.data.nested = false; + worker.postMessage(a.data); + return; + } + + // This first URL will use the same origin of this script. + var sameOriginURL = new URL(a.data.url); + var fileName1 = 42; + + // This is cross-origin URL. + var crossOriginURL = new URL(a.data.url); + crossOriginURL.host = 'example.com'; + crossOriginURL.port = 80; + var fileName2 = 42; + + if (a.data.test == 'none') { + importScripts(crossOriginURL.href); + return; + } + + try { + importScripts(sameOriginURL.href); + } catch(e) { + if (!(e instanceof SyntaxError)) { + postMessage({ result: false }); + return; + } + + fileName1 = e.fileName; + } + + if (fileName1 != sameOriginURL.href || !fileName1) { + postMessage({ result: false }); + return; + } + + if (a.data.test == 'try') { + var exception; + try { + importScripts(crossOriginURL.href); + } catch(e) { + fileName2 = e.filename; + exception = e; + } + + postMessage({ result: fileName2 == workerURL && + exception.name == "NetworkError" && + exception.code == DOMException.NETWORK_ERR }); + return; + } + + if (a.data.test == 'eventListener') { + addEventListener("error", function(event) { + event.preventDefault(); + postMessage({result: event instanceof ErrorEvent && + event.filename == workerURL }); + }); + } + + if (a.data.test == 'onerror') { + onerror = function(...args) { + postMessage({result: args[1] == workerURL }); + } + } + + importScripts(crossOriginURL.href); +} diff --git a/dom/workers/test/importScripts_mixedcontent.html b/dom/workers/test/importScripts_mixedcontent.html new file mode 100644 index 000000000..82933b091 --- /dev/null +++ b/dom/workers/test/importScripts_mixedcontent.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<script> + function ok(cond, msg) { + window.parent.postMessage({status: "ok", data: cond, msg: msg}, "*"); + } + function finish() { + window.parent.postMessage({status: "done"}, "*"); + } + + function testSharedWorker() { + var sw = new SharedWorker("importForeignScripts_worker.js"); + sw.port.onmessage = function(e) { + if (e.data == "finish") { + finish(); + return; + } + ok(e.data === "good", "mixed content for shared workers is correctly blocked"); + }; + + sw.onerror = function() { + ok(false, "Error on shared worker "); + }; + + sw.port.postMessage("start"); + } + + var worker = new Worker("importForeignScripts_worker.js"); + + worker.onmessage = function(e) { + if (e.data == "finish") { + testSharedWorker(); + return; + } + ok(e.data === "good", "mixed content is correctly blocked"); + } + + worker.onerror = function() { + ok(false, "Error on worker"); + } + + worker.postMessage("start"); +</script> diff --git a/dom/workers/test/importScripts_worker.js b/dom/workers/test/importScripts_worker.js new file mode 100644 index 000000000..7176ce838 --- /dev/null +++ b/dom/workers/test/importScripts_worker.js @@ -0,0 +1,64 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Try no args. This shouldn't do anything. +importScripts(); + +// This caused security exceptions in the past, make sure it doesn't! +var constructor = {}.constructor; + +importScripts("importScripts_worker_imported1.js"); + +// Try to call a function defined in the imported script. +importedScriptFunction(); + +function tryBadScripts() { + var badScripts = [ + // Has a syntax error + "importScripts_worker_imported3.js", + // Throws an exception + "importScripts_worker_imported4.js", + // Shouldn't exist! + "http://example.com/non-existing/importScripts_worker_foo.js", + // Not a valid url + "http://notadomain::notafile aword" + ]; + + for (var i = 0; i < badScripts.length; i++) { + var caughtException = false; + var url = badScripts[i]; + try { + importScripts(url); + } + catch (e) { + caughtException = true; + } + if (!caughtException) { + throw "Bad script didn't throw exception: " + url; + } + } +} + +const url = "data:text/plain,const startResponse = 'started';"; +importScripts(url); + +onmessage = function(event) { + switch (event.data) { + case 'start': + importScripts("importScripts_worker_imported2.js"); + importedScriptFunction2(); + tryBadScripts(); + postMessage(startResponse); + break; + case 'stop': + tryBadScripts(); + postMessage('stopped'); + break; + default: + throw new Error("Bad message: " + event.data); + break; + } +} + +tryBadScripts(); diff --git a/dom/workers/test/importScripts_worker_imported1.js b/dom/workers/test/importScripts_worker_imported1.js new file mode 100644 index 000000000..9c33588c4 --- /dev/null +++ b/dom/workers/test/importScripts_worker_imported1.js @@ -0,0 +1,10 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// This caused security exceptions in the past, make sure it doesn't! +var myConstructor = {}.constructor; + +// Try to call a function defined in the imported script. +function importedScriptFunction() { +} diff --git a/dom/workers/test/importScripts_worker_imported2.js b/dom/workers/test/importScripts_worker_imported2.js new file mode 100644 index 000000000..3aafb60be --- /dev/null +++ b/dom/workers/test/importScripts_worker_imported2.js @@ -0,0 +1,10 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// This caused security exceptions in the past, make sure it doesn't! +var myConstructor2 = {}.constructor; + +// Try to call a function defined in the imported script. +function importedScriptFunction2() { +} diff --git a/dom/workers/test/importScripts_worker_imported3.js b/dom/workers/test/importScripts_worker_imported3.js new file mode 100644 index 000000000..c54be3e5f --- /dev/null +++ b/dom/workers/test/importScripts_worker_imported3.js @@ -0,0 +1,6 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Deliberate syntax error, should generate a worker exception! +for (var index = 0; index < 100) {} diff --git a/dom/workers/test/importScripts_worker_imported4.js b/dom/workers/test/importScripts_worker_imported4.js new file mode 100644 index 000000000..82f8708c5 --- /dev/null +++ b/dom/workers/test/importScripts_worker_imported4.js @@ -0,0 +1,6 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Deliberate throw, should generate a worker exception! +throw new Error("Bah!"); diff --git a/dom/workers/test/instanceof_worker.js b/dom/workers/test/instanceof_worker.js new file mode 100644 index 000000000..a98255388 --- /dev/null +++ b/dom/workers/test/instanceof_worker.js @@ -0,0 +1,12 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + postMessage({event: "XMLHttpRequest", + status: (new XMLHttpRequest() instanceof XMLHttpRequest), + last: false }); + postMessage({event: "XMLHttpRequestUpload", + status: ((new XMLHttpRequest()).upload instanceof XMLHttpRequestUpload), + last: true }); +} diff --git a/dom/workers/test/json_worker.js b/dom/workers/test/json_worker.js new file mode 100644 index 000000000..f35e14cf2 --- /dev/null +++ b/dom/workers/test/json_worker.js @@ -0,0 +1,338 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var cyclicalObject = {}; +cyclicalObject.foo = cyclicalObject; + +var cyclicalArray = []; +cyclicalArray.push(cyclicalArray); + +function makeCrazyNested(obj, count) { + var innermostobj; + for (var i = 0; i < count; i++) { + obj.foo = { bar: 5 } + innermostobj = obj.foo; + obj = innermostobj; + } + return innermostobj; +} + +var crazyNestedObject = {}; +makeCrazyNested(crazyNestedObject, 100); + +var crazyCyclicalObject = {}; +var innermost = makeCrazyNested(crazyCyclicalObject, 1000); +innermost.baz = crazyCyclicalObject; + +var objectWithSaneGetter = { }; +objectWithSaneGetter.__defineGetter__("foo", function() { return 5; }); + +// We don't walk prototype chains for cloning so this won't actually do much... +function objectWithSaneGetter2() { } +objectWithSaneGetter2.prototype = { + get foo() { + return 5; + } +}; + +const throwingGetterThrownString = "bad"; + +var objectWithThrowingGetter = { }; +objectWithThrowingGetter.__defineGetter__("foo", function() { + throw throwingGetterThrownString; +}); + +var typedArrayWithValues = new Int8Array(5); +for (var index in typedArrayWithValues) { + typedArrayWithValues[index] = index; +} + +var typedArrayWithFunBuffer = new Int8Array(4); +for (var index in typedArrayWithFunBuffer) { + typedArrayWithFunBuffer[index] = 255; +} + +var typedArrayWithFunBuffer2 = new Int32Array(typedArrayWithFunBuffer.buffer); + +var xhr = new XMLHttpRequest(); + +var messages = [ + { + type: "object", + value: { }, + jsonValue: '{}' + }, + { + type: "object", + value: {foo: "bar"}, + jsonValue: '{"foo":"bar"}' + }, + { + type: "object", + value: {foo: "bar", foo2: {bee: "bop"}}, + jsonValue: '{"foo":"bar","foo2":{"bee":"bop"}}' + }, + { + type: "object", + value: {foo: "bar", foo2: {bee: "bop"}, foo3: "baz"}, + jsonValue: '{"foo":"bar","foo2":{"bee":"bop"},"foo3":"baz"}' + }, + { + type: "object", + value: {foo: "bar", foo2: [1,2,3]}, + jsonValue: '{"foo":"bar","foo2":[1,2,3]}' + }, + { + type: "object", + value: cyclicalObject, + }, + { + type: "object", + value: [null, 2, false, cyclicalObject], + }, + { + type: "object", + value: cyclicalArray, + }, + { + type: "object", + value: {foo: 1, bar: cyclicalArray}, + }, + { + type: "object", + value: crazyNestedObject, + jsonValue: JSON.stringify(crazyNestedObject) + }, + { + type: "object", + value: crazyCyclicalObject, + }, + { + type: "object", + value: objectWithSaneGetter, + jsonValue: '{"foo":5}' + }, + { + type: "object", + value: new objectWithSaneGetter2(), + jsonValue: '{}' + }, + { + type: "object", + value: objectWithThrowingGetter, + exception: true + }, + { + type: "object", + array: true, + value: [9, 8, 7], + jsonValue: '[9,8,7]' + }, + { + type: "object", + array: true, + value: [9, false, 10.5, {foo: "bar"}], + jsonValue: '[9,false,10.5,{"foo":"bar"}]' + }, + { + type: "object", + shouldEqual: true, + value: null + }, + { + type: "undefined", + shouldEqual: true, + value: undefined + }, + { + type: "string", + shouldEqual: true, + value: "Hello" + }, + { + type: "string", + shouldEqual: true, + value: JSON.stringify({ foo: "bar" }), + compareValue: '{"foo":"bar"}' + }, + { + type: "number", + shouldEqual: true, + value: 1 + }, + { + type: "number", + shouldEqual: true, + value: 0 + }, + { + type: "number", + shouldEqual: true, + value: -1 + }, + { + type: "number", + shouldEqual: true, + value: 238573459843702923492399923049 + }, + { + type: "number", + shouldEqual: true, + value: -238573459843702923492399923049 + }, + { + type: "number", + shouldEqual: true, + value: 0.25 + }, + { + type: "number", + shouldEqual: true, + value: -0.25 + }, + { + type: "boolean", + shouldEqual: true, + value: true + }, + { + type: "boolean", + shouldEqual: true, + value: false + }, + { + type: "object", + value: function (foo) { return "Bad!"; }, + exception: true + }, + { + type: "number", + isNaN: true, + value: NaN + }, + { + type: "number", + isInfinity: true, + value: Infinity + }, + { + type: "number", + isNegativeInfinity: true, + value: -Infinity + }, + { + type: "object", + value: new Int32Array(10), + jsonValue: '{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0}' + }, + { + type: "object", + value: new Float32Array(5), + jsonValue: '{"0":0,"1":0,"2":0,"3":0,"4":0}' + }, + { + type: "object", + value: typedArrayWithValues, + jsonValue: '{"0":0,"1":1,"2":2,"3":3,"4":4}' + }, + { + type: "number", + value: typedArrayWithValues[2], + compareValue: 2, + shouldEqual: true + }, + { + type: "object", + value: typedArrayWithValues.buffer, + jsonValue: '{}' + }, + { + type: "object", + value: typedArrayWithFunBuffer2, + jsonValue: '{"0":-1}' + }, + { + type: "object", + value: { foo: typedArrayWithFunBuffer2 }, + jsonValue: '{"foo":{"0":-1}}' + }, + { + type: "object", + value: [ typedArrayWithFunBuffer2 ], + jsonValue: '[{"0":-1}]' + }, + { + type: "object", + value: { foo: function(a) { alert(b); } }, + exception: true + }, + { + type: "object", + value: xhr, + exception: true + }, + { + type: "number", + value: xhr.readyState, + shouldEqual: true + }, + { + type: "object", + value: { xhr: xhr }, + exception: true + }, + { + type: "object", + value: self, + exception: true + }, + { + type: "object", + value: { p: ArrayBuffer.prototype }, + exception: true + }, + { + type: "string", + shouldEqual: true, + value: "testFinished" + } +]; + +for (var index = 0; index < messages.length; index++) { + var message = messages[index]; + if (message.hasOwnProperty("compareValue")) { + continue; + } + if (message.hasOwnProperty("shouldEqual") || + message.hasOwnProperty("shouldCompare")) { + message.compareValue = message.value; + } +} + +onmessage = function(event) { + for (var index = 0; index < messages.length; index++) { + var exception = undefined; + + try { + postMessage(messages[index].value); + } + catch (e) { + if (e instanceof DOMException) { + if (e.code != DOMException.DATA_CLONE_ERR) { + throw "DOMException with the wrong code: " + e.code; + } + } + else if (e != throwingGetterThrownString) { + throw "Exception of the wrong type: " + e; + } + exception = e; + } + + if ((exception !== undefined && !messages[index].exception) || + (exception === undefined && messages[index].exception)) { + throw "Exception inconsistency [index = " + index + ", " + + messages[index].toSource() + "]: " + exception; + } + } +} diff --git a/dom/workers/test/jsversion_worker.js b/dom/workers/test/jsversion_worker.js new file mode 100644 index 000000000..c66b72977 --- /dev/null +++ b/dom/workers/test/jsversion_worker.js @@ -0,0 +1,14 @@ +onmessage = function(evt) { + if (evt.data != 0) { + var worker = new Worker('jsversion_worker.js'); + worker.onmessage = function(evt) { + postMessage(evt.data); + } + + worker.postMessage(evt.data - 1); + return; + } + + let foo = 'bar'; + postMessage(true); +} diff --git a/dom/workers/test/loadEncoding_worker.js b/dom/workers/test/loadEncoding_worker.js new file mode 100644 index 000000000..5e4047844 --- /dev/null +++ b/dom/workers/test/loadEncoding_worker.js @@ -0,0 +1,7 @@ +/* + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +*/ +// Bug 484305 - Load workers as UTF-8. +postMessage({ encoding: "KOI8-R", text: "ðÒÉ×ÅÔ" }); +postMessage({ encoding: "UTF-8", text: "Привет" }); diff --git a/dom/workers/test/location_worker.js b/dom/workers/test/location_worker.js new file mode 100644 index 000000000..dd35ec8a3 --- /dev/null +++ b/dom/workers/test/location_worker.js @@ -0,0 +1,11 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +for (var string in self.location) { + var value = typeof self.location[string] === "function" + ? self.location[string]() + : self.location[string]; + postMessage({ "string": string, "value": value }); +} +postMessage({ "string": "testfinished" }); diff --git a/dom/workers/test/longThread_worker.js b/dom/workers/test/longThread_worker.js new file mode 100644 index 000000000..f132dd8c1 --- /dev/null +++ b/dom/workers/test/longThread_worker.js @@ -0,0 +1,14 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + switch (event.data) { + case "start": + for (var i = 0; i < 10000000; i++) { }; + postMessage("done"); + break; + default: + throw "Bad message: " + event.data; + } +}; diff --git a/dom/workers/test/mochitest.ini b/dom/workers/test/mochitest.ini new file mode 100644 index 000000000..d4848819c --- /dev/null +++ b/dom/workers/test/mochitest.ini @@ -0,0 +1,227 @@ +[DEFAULT] +support-files = + WorkerTest_badworker.js + atob_worker.js + bug978260_worker.js + bug1014466_data1.txt + bug1014466_data2.txt + bug1014466_worker.js + bug1020226_worker.js + bug1020226_frame.html + bug998474_worker.js + bug1063538_worker.js + clearTimeouts_worker.js + content_worker.js + console_worker.js + consoleReplaceable_worker.js + csp_worker.js + csp_worker.js^headers^ + 404_server.sjs + errorPropagation_iframe.html + errorPropagation_worker.js + errorwarning_worker.js + eventDispatch_worker.js + fibonacci_worker.js + file_bug1010784_worker.js + foreign.js + importForeignScripts_worker.js + importScripts_mixedcontent.html + importScripts_worker.js + importScripts_worker_imported1.js + importScripts_worker_imported2.js + importScripts_worker_imported3.js + importScripts_worker_imported4.js + instanceof_worker.js + json_worker.js + jsversion_worker.js + loadEncoding_worker.js + location_worker.js + longThread_worker.js + multi_sharedWorker_frame.html + multi_sharedWorker_sharedWorker.js + navigator_languages_worker.js + navigator_worker.js + newError_worker.js + notification_worker.js + notification_worker_child-child.js + notification_worker_child-parent.js + notification_permission_worker.js + onLine_worker.js + onLine_worker_child.js + onLine_worker_head.js + promise_worker.js + recursion_worker.js + recursiveOnerror_worker.js + redirect_to_foreign.sjs + rvals_worker.js + sharedWorker_console.js + sharedWorker_sharedWorker.js + simpleThread_worker.js + suspend_iframe.html + suspend_worker.js + terminate_worker.js + test_csp.html^headers^ + test_csp.js + referrer_worker.html + threadErrors_worker1.js + threadErrors_worker2.js + threadErrors_worker3.js + threadErrors_worker4.js + threadTimeouts_worker.js + throwingOnerror_worker.js + timeoutTracing_worker.js + transferable_worker.js + websocket_basic_worker.js + websocket_loadgroup_worker.js + websocket_worker1.js + websocket_worker2.js + websocket_worker3.js + websocket_worker4.js + websocket_worker5.js + websocket_helpers.js + workersDisabled_worker.js + test_worker_interfaces.js + worker_driver.js + worker_wrapper.js + bug1060621_worker.js + bug1062920_worker.js + webSocket_sharedWorker.js + bug1104064_worker.js + worker_consoleAndBlobs.js + bug1132395_sharedWorker.js + bug1132924_worker.js + empty.html + referrer.sjs + referrer_test_server.sjs + sharedWorker_ports.js + sharedWorker_lifetime.js + worker_referrer.js + websocket_https.html + websocket_https_worker.js + worker_fileReader.js + fileapi_chromeScript.js + importScripts_3rdParty_worker.js + worker_bug1278777.js + worker_setTimeoutWith0.js + worker_bug1301094.js + script_createFile.js + worker_suspended.js + window_suspended.html + !/dom/base/test/file_bug945152.jar + !/dom/base/test/file_websocket_basic_wsh.py + !/dom/base/test/file_websocket_hello_wsh.py + !/dom/base/test/file_websocket_http_resource.txt + !/dom/base/test/file_websocket_permessage_deflate_disabled_wsh.py + !/dom/base/test/file_websocket_permessage_deflate_params_wsh.py + !/dom/base/test/file_websocket_permessage_deflate_rejected_wsh.py + !/dom/base/test/file_websocket_permessage_deflate_wsh.py + !/dom/base/test/file_websocket_wsh.py + !/dom/base/test/websocket_helpers.js + !/dom/base/test/websocket_tests.js + !/dom/tests/mochitest/notification/MockServices.js + !/dom/tests/mochitest/notification/NotificationTest.js + !/dom/xhr/tests/relativeLoad_import.js + !/dom/xhr/tests/relativeLoad_worker.js + !/dom/xhr/tests/relativeLoad_worker2.js + !/dom/xhr/tests/subdir/relativeLoad_sub_worker.js + !/dom/xhr/tests/subdir/relativeLoad_sub_worker2.js + !/dom/xhr/tests/subdir/relativeLoad_sub_import.js + +[test_404.html] +[test_atob.html] +[test_blobConstructor.html] +[test_blobWorkers.html] +[test_bug949946.html] +[test_bug978260.html] +[test_bug998474.html] +[test_bug1002702.html] +[test_bug1010784.html] +[test_bug1014466.html] +[test_bug1020226.html] +[test_bug1036484.html] +[test_bug1060621.html] +[test_bug1062920.html] +[test_bug1063538.html] +[test_bug1104064.html] +[test_bug1132395.html] +skip-if = true # bug 1176225 +[test_bug1132924.html] +[test_chromeWorker.html] +[test_clearTimeouts.html] +[test_console.html] +[test_consoleAndBlobs.html] +[test_consoleReplaceable.html] +[test_consoleSharedWorkers.html] +[test_contentWorker.html] +[test_csp.html] +[test_dataURLWorker.html] +[test_errorPropagation.html] +[test_errorwarning.html] +[test_eventDispatch.html] +[test_fibonacci.html] +[test_importScripts.html] +[test_importScripts_mixedcontent.html] +tags = mcb +[test_instanceof.html] +[test_json.html] +[test_jsversion.html] +[test_loadEncoding.html] +[test_loadError.html] +[test_location.html] +[test_longThread.html] +[test_multi_sharedWorker.html] +[test_multi_sharedWorker_lifetimes.html] +[test_navigator.html] +[test_navigator_languages.html] +[test_newError.html] +[test_notification.html] +[test_notification_child.html] +[test_notification_permission.html] +[test_onLine.html] +[test_promise.html] +[test_promise_resolved_with_string.html] +[test_recursion.html] +[test_recursiveOnerror.html] +[test_resolveWorker.html] +[test_resolveWorker-assignment.html] +[test_rvals.html] +[test_sharedWorker.html] +[test_simpleThread.html] +[test_suspend.html] +[test_terminate.html] +[test_threadErrors.html] +[test_threadTimeouts.html] +[test_throwingOnerror.html] +[test_timeoutTracing.html] +[test_transferable.html] +[test_websocket1.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket2.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket3.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket4.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket5.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket_basic.html] +skip-if = toolkit == 'android' #bug 982828 +[test_websocket_https.html] +[test_websocket_loadgroup.html] +skip-if = toolkit == 'android' #bug 982828 +[test_webSocket_sharedWorker.html] +skip-if = toolkit == 'android' #bug 982828 +[test_worker_interfaces.html] +[test_workersDisabled.html] +[test_referrer.html] +[test_referrer_header_worker.html] +[test_importScripts_3rdparty.html] +[test_sharedWorker_ports.html] +[test_sharedWorker_lifetime.html] +[test_fileReader.html] +[test_navigator_workers_hardwareConcurrency.html] +[test_bug1278777.html] +[test_setTimeoutWith0.html] +[test_bug1301094.html] +[test_subworkers_suspended.html] +[test_bug1317725.html] diff --git a/dom/workers/test/multi_sharedWorker_frame.html b/dom/workers/test/multi_sharedWorker_frame.html new file mode 100644 index 000000000..6c0dfe591 --- /dev/null +++ b/dom/workers/test/multi_sharedWorker_frame.html @@ -0,0 +1,52 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for SharedWorker</title> + </head> + <body> + <script type="text/javascript;version=1.7"> + "use strict"; + + function debug(message) { + if (typeof(message) != "string") { + throw new Error("debug() only accepts strings!"); + } + parent.postMessage(message, "*"); + } + + let worker; + + window.addEventListener("message", function(event) { + if (!worker) { + worker = new SharedWorker("multi_sharedWorker_sharedWorker.js", + "FrameWorker"); + worker.onerror = function(event) { + debug("Worker error: " + event.message); + event.preventDefault(); + + let data = { + type: "error", + message: event.message, + filename: event.filename, + lineno: event.lineno, + isErrorEvent: event instanceof ErrorEvent + }; + parent.postMessage(data, "*"); + }; + + worker.port.onmessage = function(event) { + debug("Worker message: " + JSON.stringify(event.data)); + parent.postMessage(event.data, "*"); + }; + } + + debug("Posting message: " + JSON.stringify(event.data)); + worker.port.postMessage(event.data); + }); + </script> + </body> +</html> diff --git a/dom/workers/test/multi_sharedWorker_sharedWorker.js b/dom/workers/test/multi_sharedWorker_sharedWorker.js new file mode 100644 index 000000000..47a7ae04f --- /dev/null +++ b/dom/workers/test/multi_sharedWorker_sharedWorker.js @@ -0,0 +1,72 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +if (self.name != "FrameWorker") { + throw new Error("Bad worker name: " + self.name); +} + +var registeredPorts = []; +var errorCount = 0; +var storedData; + +self.onconnect = function(event) { + var port = event.ports[0]; + + if (registeredPorts.length) { + var data = { + type: "connect" + }; + + registeredPorts.forEach(function(registeredPort) { + registeredPort.postMessage(data); + }); + } + + port.onmessage = function(event) { + switch (event.data.command) { + case "start": + break; + + case "error": + throw new Error("Expected"); + + case "store": + storedData = event.data.data; + break; + + case "retrieve": + var data = { + type: "result", + data: storedData + }; + port.postMessage(data); + break; + + default: + throw new Error("Unknown command '" + error.data.command + "'"); + } + }; + + registeredPorts.push(port); +}; + +self.onerror = function(message, filename, lineno) { + if (!errorCount++) { + var data = { + type: "worker-error", + message: message, + filename: filename, + lineno: lineno + }; + + registeredPorts.forEach(function (registeredPort) { + registeredPort.postMessage(data); + }); + + // Prevent the error from propagating the first time only. + return true; + } +}; diff --git a/dom/workers/test/navigator_languages_worker.js b/dom/workers/test/navigator_languages_worker.js new file mode 100644 index 000000000..53aa4d39e --- /dev/null +++ b/dom/workers/test/navigator_languages_worker.js @@ -0,0 +1,11 @@ +var active = true; +onmessage = function(e) { + if (e.data == 'finish') { + active = false; + return; + } + + if (active) { + postMessage(navigator.languages); + } +} diff --git a/dom/workers/test/navigator_worker.js b/dom/workers/test/navigator_worker.js new file mode 100644 index 000000000..63853aef1 --- /dev/null +++ b/dom/workers/test/navigator_worker.js @@ -0,0 +1,79 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +// IMPORTANT: Do not change the list below without review from a DOM peer! +var supportedProps = [ + "appCodeName", + "appName", + "appVersion", + "platform", + "product", + "userAgent", + "onLine", + "language", + "languages", + "hardwareConcurrency", + { name: "storage", nightly: true }, +]; + +self.onmessage = function(event) { + if (!event || !event.data) { + return; + } + + startTest(event.data); +}; + +function startTest(channelData) { + // Prepare the interface map showing if a propery should exist in this build. + // For example, if interfaceMap[foo] = true means navigator.foo should exist. + var interfaceMap = {}; + + for (var prop of supportedProps) { + if (typeof(prop) === "string") { + interfaceMap[prop] = true; + continue; + } + + if (prop.nightly === !channelData.isNightly || + prop.release === !channelData.isRelease) { + interfaceMap[prop.name] = false; + continue; + } + + interfaceMap[prop.name] = true; + } + + for (var prop in navigator) { + // Make sure the list is current! + if (!interfaceMap[prop]) { + throw "Navigator has the '" + prop + "' property that isn't in the list!"; + } + } + + var obj; + + for (var prop in interfaceMap) { + // Skip the property that is not supposed to exist in this build. + if (!interfaceMap[prop]) { + continue; + } + + if (typeof navigator[prop] == "undefined") { + throw "Navigator has no '" + prop + "' property!"; + } + + obj = { name: prop }; + obj.value = navigator[prop]; + + postMessage(JSON.stringify(obj)); + } + + obj = { + name: "testFinished" + }; + + postMessage(JSON.stringify(obj)); +} diff --git a/dom/workers/test/newError_worker.js b/dom/workers/test/newError_worker.js new file mode 100644 index 000000000..46e6226f7 --- /dev/null +++ b/dom/workers/test/newError_worker.js @@ -0,0 +1,5 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +throw new Error("foo!"); diff --git a/dom/workers/test/notification_permission_worker.js b/dom/workers/test/notification_permission_worker.js new file mode 100644 index 000000000..f69acaeda --- /dev/null +++ b/dom/workers/test/notification_permission_worker.js @@ -0,0 +1,56 @@ +function info(message) { + dump("INFO: " + message + "\n"); +} + +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +function is(a, b, message) { + postMessage({ type: 'is', test1: a, test2: b, message: message }); +} + +if (self.Notification) { + var steps = [ + function (done) { + info("Test notification permission"); + ok(typeof Notification === "function", "Notification constructor exists"); + ok(Notification.permission === "denied", "Notification.permission is denied."); + + var n = new Notification("Hello"); + n.onerror = function(e) { + ok(true, "error called due to permission denied."); + done(); + } + }, + ]; + + onmessage = function(e) { + var context = {}; + (function executeRemainingTests(remainingTests) { + if (!remainingTests.length) { + postMessage({type: 'finish'}); + return; + } + + var nextTest = remainingTests.shift(); + var finishTest = executeRemainingTests.bind(null, remainingTests); + var startTest = nextTest.call.bind(nextTest, context, finishTest); + + try { + startTest(); + // if no callback was defined for test function, + // we must manually invoke finish to continue + if (nextTest.length === 0) { + finishTest(); + } + } catch (e) { + ok(false, "Test threw exception! " + nextTest + " " + e); + finishTest(); + } + })(steps); + } +} else { + ok(true, "Notifications are not enabled in workers on the platform."); + postMessage({ type: 'finish' }); +} diff --git a/dom/workers/test/notification_worker.js b/dom/workers/test/notification_worker.js new file mode 100644 index 000000000..cb55f8358 --- /dev/null +++ b/dom/workers/test/notification_worker.js @@ -0,0 +1,93 @@ +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +function is(a, b, message) { + postMessage({ type: 'is', test1: a, test2: b, message: message }); +} + +if (self.Notification) { + var steps = [ + function () { + ok(typeof Notification === "function", "Notification constructor exists"); + ok(Notification.permission, "Notification.permission exists"); + ok(typeof Notification.requestPermission === "undefined", "Notification.requestPermission should not exist"); + }, + + function (done) { + var options = { + dir: "auto", + lang: "", + body: "This is a notification body", + tag: "sometag", + icon: "icon.png", + data: ["a complex object that should be", { "structured": "cloned" }], + mozbehavior: { vibrationPattern: [30, 200, 30] }, + }; + var notification = new Notification("This is a title", options); + + ok(notification !== undefined, "Notification exists"); + is(notification.onclick, null, "onclick() should be null"); + is(notification.onshow, null, "onshow() should be null"); + is(notification.onerror, null, "onerror() should be null"); + is(notification.onclose, null, "onclose() should be null"); + is(typeof notification.close, "function", "close() should exist"); + + is(notification.dir, options.dir, "auto should get set"); + is(notification.lang, options.lang, "lang should get set"); + is(notification.body, options.body, "body should get set"); + is(notification.tag, options.tag, "tag should get set"); + is(notification.icon, options.icon, "icon should get set"); + is(notification.data[0], "a complex object that should be", "data item 0 should be a matching string"); + is(notification.data[1]["structured"], "cloned", "data item 1 should be a matching object literal"); + + // store notification in test context + this.notification = notification; + + notification.onshow = function () { + ok(true, "onshow handler should be called"); + done(); + }; + }, + + function (done) { + var notification = this.notification; + + notification.onclose = function () { + ok(true, "onclose handler should be called"); + done(); + }; + + notification.close(); + }, + ]; + + onmessage = function(e) { + var context = {}; + (function executeRemainingTests(remainingTests) { + if (!remainingTests.length) { + postMessage({type: 'finish'}); + return; + } + + var nextTest = remainingTests.shift(); + var finishTest = executeRemainingTests.bind(null, remainingTests); + var startTest = nextTest.call.bind(nextTest, context, finishTest); + + try { + startTest(); + // if no callback was defined for test function, + // we must manually invoke finish to continue + if (nextTest.length === 0) { + finishTest(); + } + } catch (e) { + ok(false, "Test threw exception! " + nextTest + " " + e); + finishTest(); + } + })(steps); + } +} else { + ok(true, "Notifications are not enabled in workers on the platform."); + postMessage({ type: 'finish' }); +} diff --git a/dom/workers/test/notification_worker_child-child.js b/dom/workers/test/notification_worker_child-child.js new file mode 100644 index 000000000..829bf43d3 --- /dev/null +++ b/dom/workers/test/notification_worker_child-child.js @@ -0,0 +1,92 @@ +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +function is(a, b, message) { + postMessage({ type: 'is', test1: a, test2: b, message: message }); +} + +if (self.Notification) { + var steps = [ + function () { + ok(typeof Notification === "function", "Notification constructor exists"); + ok(Notification.permission, "Notification.permission exists"); + ok(typeof Notification.requestPermission === "undefined", "Notification.requestPermission should not exist"); + //ok(typeof Notification.get === "function", "Notification.get exists"); + }, + + function (done) { + + var options = { + dir: "auto", + lang: "", + body: "This is a notification body", + tag: "sometag", + icon: "icon.png" + }; + var notification = new Notification("This is a title", options); + + ok(notification !== undefined, "Notification exists"); + is(notification.onclick, null, "onclick() should be null"); + is(notification.onshow, null, "onshow() should be null"); + is(notification.onerror, null, "onerror() should be null"); + is(notification.onclose, null, "onclose() should be null"); + is(typeof notification.close, "function", "close() should exist"); + + is(notification.dir, options.dir, "auto should get set"); + is(notification.lang, options.lang, "lang should get set"); + is(notification.body, options.body, "body should get set"); + is(notification.tag, options.tag, "tag should get set"); + is(notification.icon, options.icon, "icon should get set"); + + // store notification in test context + this.notification = notification; + + notification.onshow = function () { + ok(true, "onshow handler should be called"); + done(); + }; + }, + + function (done) { + var notification = this.notification; + + notification.onclose = function () { + ok(true, "onclose handler should be called"); + done(); + }; + + notification.close(); + }, + ]; + + onmessage = function(e) { + var context = {}; + (function executeRemainingTests(remainingTests) { + if (!remainingTests.length) { + postMessage({type: 'finish'}); + return; + } + + var nextTest = remainingTests.shift(); + var finishTest = executeRemainingTests.bind(null, remainingTests); + var startTest = nextTest.call.bind(nextTest, context, finishTest); + + try { + startTest(); + // if no callback was defined for test function, + // we must manually invoke finish to continue + if (nextTest.length === 0) { + finishTest(); + } + } catch (e) { + ok(false, "Test threw exception! " + nextTest + " " + e); + finishTest(); + } + })(steps); + } +} else { + ok(true, "Notifications are not enabled in workers on the platform."); + postMessage({ type: 'finish' }); +} + diff --git a/dom/workers/test/notification_worker_child-parent.js b/dom/workers/test/notification_worker_child-parent.js new file mode 100644 index 000000000..bb28c520d --- /dev/null +++ b/dom/workers/test/notification_worker_child-parent.js @@ -0,0 +1,26 @@ +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +function is(a, b, message) { + postMessage({ type: 'is', test1: a, test2: b, message: message }); +} + +if (self.Notification) { + var child = new Worker("notification_worker_child-child.js"); + child.onerror = function(e) { + ok(false, "Error loading child worker " + e); + postMessage({ type: 'finish' }); + } + + child.onmessage = function(e) { + postMessage(e.data); + } + + onmessage = function(e) { + child.postMessage('start'); + } +} else { + ok(true, "Notifications are not enabled in workers on the platform."); + postMessage({ type: 'finish' }); +} diff --git a/dom/workers/test/onLine_worker.js b/dom/workers/test/onLine_worker.js new file mode 100644 index 000000000..5a302b15e --- /dev/null +++ b/dom/workers/test/onLine_worker.js @@ -0,0 +1,65 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +importScripts("onLine_worker_head.js"); + +var N_CHILDREN = 3; +var children = []; +var finishedChildrenCount = 0; +var lastTest = false; + +for (var event of ["online", "offline"]) { + addEventListener(event, + makeHandler( + "addEventListener('%1', ..., false)", + event, 1, "Parent Worker"), + false); +} + +onmessage = function(e) { + if (e.data === 'lastTest') { + children.forEach(function(w) { + w.postMessage({ type: 'lastTest' }); + }); + lastTest = true; + } +} + +function setupChildren(cb) { + var readyCount = 0; + for (var i = 0; i < N_CHILDREN; ++i) { + var w = new Worker("onLine_worker_child.js"); + children.push(w); + + w.onerror = function(e) { + info("Error creating child " + e.message); + } + + w.onmessage = function(e) { + if (e.data.type === 'ready') { + info("Got ready from child"); + readyCount++; + if (readyCount === N_CHILDREN) { + cb(); + } + } else if (e.data.type === 'finished') { + finishedChildrenCount++; + + if (lastTest && finishedChildrenCount === N_CHILDREN) { + postMessage({ type: 'finished' }); + children = []; + close(); + } + } else if (e.data.type === 'ok') { + // Pass on test to page. + postMessage(e.data); + } + } + } +} + +setupChildren(function() { + postMessage({ type: 'ready' }); +}); diff --git a/dom/workers/test/onLine_worker_child.js b/dom/workers/test/onLine_worker_child.js new file mode 100644 index 000000000..dc28fac45 --- /dev/null +++ b/dom/workers/test/onLine_worker_child.js @@ -0,0 +1,75 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +function info(text) { + dump("Test for Bug 925437: worker: " + text + "\n"); +} + +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +/** + * Returns a handler function for an online/offline event. The returned handler + * ensures the passed event object has expected properties and that the handler + * is called at the right moment (according to the gState variable). + * @param nameTemplate The string identifying the hanlder. '%1' in that + * string will be replaced with the event name. + * @param eventName 'online' or 'offline' + * @param expectedState value of gState at the moment the handler is called. + * The handler increases gState by one before checking + * if it matches expectedState. + */ +function makeHandler(nameTemplate, eventName, expectedState, prefix, custom) { + prefix += ": "; + return function(e) { + var name = nameTemplate.replace(/%1/, eventName); + ok(e.constructor == Event, prefix + "event should be an Event"); + ok(e.type == eventName, prefix + "event type should be " + eventName); + ok(!e.bubbles, prefix + "event should not bubble"); + ok(!e.cancelable, prefix + "event should not be cancelable"); + ok(e.target == self, prefix + "the event target should be the worker scope"); + ok(eventName == 'online' ? navigator.onLine : !navigator.onLine, prefix + "navigator.onLine " + navigator.onLine + " should reflect event " + eventName); + + if (custom) { + custom(); + } + } +} + + + +var lastTest = false; + +function lastTestTest() { + if (lastTest) { + postMessage({ type: 'finished' }); + close(); + } +} + +for (var event of ["online", "offline"]) { + addEventListener(event, + makeHandler( + "addEventListener('%1', ..., false)", + event, 1, "Child Worker", lastTestTest + ), + false); +} + +onmessage = function(e) { + if (e.data.type === 'lastTest') { + lastTest = true; + } else if (e.data.type === 'navigatorState') { + ok(e.data.state === navigator.onLine, "Child and parent navigator state should match"); + } +} + +postMessage({ type: 'ready' }); diff --git a/dom/workers/test/onLine_worker_head.js b/dom/workers/test/onLine_worker_head.js new file mode 100644 index 000000000..4800457d3 --- /dev/null +++ b/dom/workers/test/onLine_worker_head.js @@ -0,0 +1,43 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +function info(text) { + dump("Test for Bug 925437: worker: " + text + "\n"); +} + +function ok(test, message) { + postMessage({ type: 'ok', test: test, message: message }); +} + +/** + * Returns a handler function for an online/offline event. The returned handler + * ensures the passed event object has expected properties and that the handler + * is called at the right moment (according to the gState variable). + * @param nameTemplate The string identifying the hanlder. '%1' in that + * string will be replaced with the event name. + * @param eventName 'online' or 'offline' + * @param expectedState value of gState at the moment the handler is called. + * The handler increases gState by one before checking + * if it matches expectedState. + */ +function makeHandler(nameTemplate, eventName, expectedState, prefix, custom) { + prefix += ": "; + return function(e) { + var name = nameTemplate.replace(/%1/, eventName); + ok(e.constructor == Event, prefix + "event should be an Event"); + ok(e.type == eventName, prefix + "event type should be " + eventName); + ok(!e.bubbles, prefix + "event should not bubble"); + ok(!e.cancelable, prefix + "event should not be cancelable"); + ok(e.target == self, prefix + "the event target should be the worker scope"); + ok(eventName == 'online' ? navigator.onLine : !navigator.onLine, prefix + "navigator.onLine " + navigator.onLine + " should reflect event " + eventName); + + if (custom) { + custom(); + } + } +} + + + diff --git a/dom/workers/test/promise_worker.js b/dom/workers/test/promise_worker.js new file mode 100644 index 000000000..5b0a8478b --- /dev/null +++ b/dom/workers/test/promise_worker.js @@ -0,0 +1,856 @@ +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + " " + msg + "\n"); + postMessage({type: 'status', status: !!a, msg: a + ": " + msg }); +} + +function todo(a, msg) { + dump("TODO: " + !a + " => " + a + " " + msg + "\n"); + postMessage({type: 'status', status: !a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + dump("IS: " + (a===b) + " => " + a + " | " + b + " " + msg + "\n"); + postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg }); +} + +function isnot(a, b, msg) { + dump("ISNOT: " + (a!==b) + " => " + a + " | " + b + " " + msg + "\n"); + postMessage({type: 'status', status: a !== b, msg: a + " !== " + b + ": " + msg }); +} + +function promiseResolve() { + ok(Promise, "Promise object should exist"); + + var promise = new Promise(function(resolve, reject) { + ok(resolve, "Promise.resolve exists"); + ok(reject, "Promise.reject exists"); + + resolve(42); + }).then(function(what) { + ok(true, "Then - resolveCb has been called"); + is(what, 42, "ResolveCb received 42"); + runTest(); + }, function() { + ok(false, "Then - rejectCb has been called"); + runTest(); + }); +} + +function promiseResolveNoArg() { + var promise = new Promise(function(resolve, reject) { + ok(resolve, "Promise.resolve exists"); + ok(reject, "Promise.reject exists"); + + resolve(); + }).then(function(what) { + ok(true, "Then - resolveCb has been called"); + is(what, undefined, "ResolveCb received undefined"); + runTest(); + }, function() { + ok(false, "Then - rejectCb has been called"); + runTest(); + }); +} + +function promiseRejectNoHandler() { + // This test only checks that the code that reports unhandled errors in the + // Promises implementation does not crash or leak. + var promise = new Promise(function(res, rej) { + noSuchMethod(); + }); + runTest(); +} + +function promiseReject() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }).then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, 42, "RejectCb received 42"); + runTest(); + }); +} + +function promiseRejectNoArg() { + var promise = new Promise(function(resolve, reject) { + reject(); + }).then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, undefined, "RejectCb received undefined"); + runTest(); + }); +} + +function promiseException() { + var promise = new Promise(function(resolve, reject) { + throw 42; + }).then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, 42, "RejectCb received 42"); + runTest(); + }); +} + +function promiseAsync_TimeoutResolveThen() { + var handlerExecuted = false; + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + Promise.resolve().then(function() { + handlerExecuted = true; + }); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_ResolveTimeoutThen() { + var handlerExecuted = false; + + var promise = Promise.resolve(); + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + promise.then(function() { + handlerExecuted = true; + }); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_ResolveThenTimeout() { + var handlerExecuted = false; + + Promise.resolve().then(function() { + handlerExecuted = true; + }); + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_SyncXHRAndImportScripts() +{ + var handlerExecuted = false; + + Promise.resolve().then(function() { + handlerExecuted = true; + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }); + + ok(!handlerExecuted, "Handlers are not called until the next microtask."); + + var xhr = new XMLHttpRequest(); + xhr.open("GET", "testXHR.txt", false); + xhr.send(null); + + ok(!handlerExecuted, "Sync XHR should not trigger microtask execution."); + + importScripts("../../../dom/xhr/tests/relativeLoad_import.js"); + + ok(!handlerExecuted, "importScripts should not trigger microtask execution."); +} + +function promiseDoubleThen() { + var steps = 0; + var promise = new Promise(function(r1, r2) { + r1(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + steps++; + }, function(what) { + ok(false, "Then.reject has been called"); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(steps, 1, "Then.resolve - step == 1"); + is(what, 42, "Value == 42"); + runTest(); + }, function(what) { + ok(false, "Then.reject has been called"); + }); +} + +function promiseThenException() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + throw "booh"; + }).catch(function(e) { + ok(true, "Catch has been called!"); + runTest(); + }); +} + +function promiseThenCatchThen() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + var promise2 = promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + return what + 1; + }, function(what) { + ok(false, "Then.reject has been called"); + }); + + isnot(promise, promise2, "These 2 promise objs are different"); + + promise2.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + return what + 1; + }, function(what) { + ok(false, "Then.reject has been called"); + }).catch(function() { + ok(false, "Catch has been called"); + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }, function(what) { + ok(false, "Then.reject has been called"); + }); +} + +function promiseRejectThenCatchThen() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + var promise2 = promise.then(function(what) { + ok(false, "Then.resolve has been called"); + }, function(what) { + ok(true, "Then.reject has been called"); + is(what, 42, "Value == 42"); + return what + 1; + }); + + isnot(promise, promise2, "These 2 promise objs are different"); + + promise2.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + return what+1; + }).catch(function(what) { + ok(false, "Catch has been called"); + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }); +} + +function promiseRejectThenCatchThen2() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + return what+1; + }).catch(function(what) { + is(what, 42, "Value == 42"); + ok(true, "Catch has been called"); + return what+1; + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + runTest(); + }); +} + +function promiseRejectThenCatchExceptionThen() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + promise.then(function(what) { + ok(false, "Then.resolve has been called"); + }, function(what) { + ok(true, "Then.reject has been called"); + is(what, 42, "Value == 42"); + throw(what + 1); + }).catch(function(what) { + ok(true, "Catch has been called"); + is(what, 43, "Value == 43"); + return what + 1; + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }); +} + +function promiseThenCatchOrderingResolve() { + var global = 0; + var f = new Promise(function(r1, r2) { + r1(42); + }); + + f.then(function() { + f.then(function() { + global++; + }); + f.catch(function() { + global++; + }); + f.then(function() { + global++; + }); + setTimeout(function() { + is(global, 2, "Many steps... should return 2"); + runTest(); + }, 0); + }); +} + +function promiseThenCatchOrderingReject() { + var global = 0; + var f = new Promise(function(r1, r2) { + r2(42); + }) + + f.then(function() {}, function() { + f.then(function() { + global++; + }); + f.catch(function() { + global++; + }); + f.then(function() {}, function() { + global++; + }); + setTimeout(function() { + is(global, 2, "Many steps... should return 2"); + runTest(); + }, 0); + }); +} + +function promiseThenNoArg() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + var clone = promise.then(); + isnot(promise, clone, "These 2 promise objs are different"); + promise.then(function(v) { + clone.then(function(cv) { + is(v, cv, "Both resolve to the same value"); + runTest(); + }); + }); +} + +function promiseThenUndefinedResolveFunction() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + try { + promise.then(undefined, function(v) { + is(v, 42, "Promise rejected with 42"); + runTest(); + }); + } catch (e) { + ok(false, "then should not throw on undefined resolve function"); + } +} + +function promiseThenNullResolveFunction() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + try { + promise.then(null, function(v) { + is(v, 42, "Promise rejected with 42"); + runTest(); + }); + } catch (e) { + ok(false, "then should not throw on null resolve function"); + } +} + +function promiseCatchNoArg() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + var clone = promise.catch(); + isnot(promise, clone, "These 2 promise objs are different"); + promise.catch(function(v) { + clone.catch(function(cv) { + is(v, cv, "Both reject to the same value"); + runTest(); + }); + }); +} + +function promiseNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(resolve, reject) { + ok(true, "Nested promise is executed"); + resolve(42); + })); + }).then(function(value) { + is(value, 42, "Nested promise is executed and then == 42"); + runTest(); + }); +} + +function promiseNestedNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(resolve, reject) { + ok(true, "Nested promise is executed"); + resolve(42); + }).then(function(what) { return what+1; })); + }).then(function(value) { + is(value, 43, "Nested promise is executed and then == 43"); + runTest(); + }); +} + +function promiseWrongNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(r, r2) { + ok(true, "Nested promise is executed"); + r(42); + })); + reject(42); + }).then(function(value) { + is(value, 42, "Nested promise is executed and then == 42"); + runTest(); + }, function(value) { + ok(false, "This is wrong"); + }); +} + +function promiseLoop() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(r1, r2) { + ok(true, "Nested promise is executed"); + r1(new Promise(function(r1, r2) { + ok(true, "Nested nested promise is executed"); + r1(42); + })); + })); + }).then(function(value) { + is(value, 42, "Nested nested promise is executed and then == 42"); + runTest(); + }, function(value) { + ok(false, "This is wrong"); + }); +} + +function promiseStaticReject() { + var promise = Promise.reject(42).then(function(what) { + ok(false, "This should not be called"); + }, function(what) { + is(what, 42, "Value == 42"); + runTest(); + }); +} + +function promiseStaticResolve() { + var promise = Promise.resolve(42).then(function(what) { + is(what, 42, "Value == 42"); + runTest(); + }, function() { + ok(false, "This should not be called"); + }); +} + +function promiseResolveNestedPromise() { + var promise = Promise.resolve(new Promise(function(r, r2) { + ok(true, "Nested promise is executed"); + r(42); + }, function() { + ok(false, "This should not be called"); + })).then(function(what) { + is(what, 42, "Value == 42"); + runTest(); + }, function() { + ok(false, "This should not be called"); + }); +} + +function promiseRejectNoHandler() { + // This test only checks that the code that reports unhandled errors in the + // Promises implementation does not crash or leak. + var promise = new Promise(function(res, rej) { + noSuchMethod(); + }); + runTest(); +} + +function promiseUtilitiesDefined() { + ok(Promise.all, "Promise.all must be defined when Promise is enabled."); + ok(Promise.race, "Promise.race must be defined when Promise is enabled."); + runTest(); +} + +function promiseAllArray() { + var p = Promise.all([1, new Date(), Promise.resolve("firefox")]); + ok(p instanceof Promise, "Return value of Promise.all should be a Promise."); + p.then(function(values) { + ok(Array.isArray(values), "Resolved value should be an array."); + is(values.length, 3, "Resolved array length should match iterable's length."); + is(values[0], 1, "Array values should match."); + ok(values[1] instanceof Date, "Array values should match."); + is(values[2], "firefox", "Array values should match."); + runTest(); + }, function() { + ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises."); + runTest(); + }); +} + +function promiseAllWaitsForAllPromises() { + var arr = [ + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 1), 50); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 2), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, new Promise(function(resolve2) { + resolve2(3); + })), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 4), 20); + }) + ]; + + var p = Promise.all(arr); + p.then(function(values) { + ok(Array.isArray(values), "Resolved value should be an array."); + is(values.length, 4, "Resolved array length should match iterable's length."); + is(values[0], 1, "Array values should match."); + is(values[1], 2, "Array values should match."); + is(values[2], 3, "Array values should match."); + is(values[3], 4, "Array values should match."); + runTest(); + }, function() { + ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises."); + runTest(); + }); +} + +function promiseAllRejectFails() { + var arr = [ + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 1), 50); + }), + new Promise(function(resolve, reject) { + setTimeout(reject.bind(undefined, 2), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 3), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 4), 20); + }) + ]; + + var p = Promise.all(arr); + p.then(function(values) { + ok(false, "Promise.all shouldn't resolve when iterable has rejected Promises."); + runTest(); + }, function(e) { + ok(true, "Promise.all should reject when iterable has rejected Promises."); + is(e, 2, "Rejection value should match."); + runTest(); + }); +} + +function promiseRaceEmpty() { + var p = Promise.race([]); + ok(p instanceof Promise, "Should return a Promise."); + // An empty race never resolves! + runTest(); +} + +function promiseRaceValuesArray() { + var p = Promise.race([true, new Date(), 3]); + ok(p instanceof Promise, "Should return a Promise."); + p.then(function(winner) { + is(winner, true, "First value should win."); + runTest(); + }, function(err) { + ok(false, "Should not fail " + err + "."); + runTest(); + }); +} + +function promiseRacePromiseArray() { + var arr = [ + new Promise(function(resolve) { + resolve("first"); + }), + Promise.resolve("second"), + new Promise(function() {}), + new Promise(function(resolve) { + setTimeout(function() { + setTimeout(function() { + resolve("fourth"); + }, 0); + }, 0); + }), + ]; + + var p = Promise.race(arr); + p.then(function(winner) { + is(winner, "first", "First queued resolution should win the race."); + runTest(); + }); +} + +function promiseRaceReject() { + var p = Promise.race([ + Promise.reject(new Error("Fail bad!")), + new Promise(function(resolve) { + setTimeout(resolve, 0); + }) + ]); + + p.then(function() { + ok(false, "Should not resolve when winning Promise rejected."); + runTest(); + }, function(e) { + ok(true, "Should be rejected"); + ok(e instanceof Error, "Should reject with Error."); + ok(e.message == "Fail bad!", "Message should match."); + runTest(); + }); +} + +function promiseRaceThrow() { + var p = Promise.race([ + new Promise(function(resolve) { + nonExistent(); + }), + new Promise(function(resolve) { + setTimeout(resolve, 0); + }) + ]); + + p.then(function() { + ok(false, "Should not resolve when winning Promise had an error."); + runTest(); + }, function(e) { + ok(true, "Should be rejected"); + ok(e instanceof ReferenceError, "Should reject with ReferenceError for function nonExistent()."); + runTest(); + }); +} + +function promiseResolveArray() { + var p = Promise.resolve([1,2,3]); + ok(p instanceof Promise, "Should return a Promise."); + p.then(function(v) { + ok(Array.isArray(v), "Resolved value should be an Array"); + is(v.length, 3, "Length should match"); + is(v[0], 1, "Resolved value should match original"); + is(v[1], 2, "Resolved value should match original"); + is(v[2], 3, "Resolved value should match original"); + runTest(); + }); +} + +function promiseResolveThenable() { + var p = Promise.resolve({ then: function(onFulfill, onReject) { onFulfill(2); } }); + ok(p instanceof Promise, "Should cast to a Promise."); + p.then(function(v) { + is(v, 2, "Should resolve to 2."); + runTest(); + }, function(e) { + ok(false, "promiseResolveThenable should've resolved"); + runTest(); + }); +} + +function promiseResolvePromise() { + var original = Promise.resolve(true); + var cast = Promise.resolve(original); + + ok(cast instanceof Promise, "Should cast to a Promise."); + is(cast, original, "Should return original Promise."); + cast.then(function(v) { + is(v, true, "Should resolve to true."); + runTest(); + }); +} + +// Bug 1009569. +// Ensure that thenables are run on a clean stack asynchronously. +// Test case adopted from +// https://gist.github.com/getify/d64bb01751b50ed6b281#file-bug1-js. +function promiseResolveThenableCleanStack() { + function immed(s) { x++; s(); } + function incX(){ x++; } + + var x = 0; + var thenable = { then: immed }; + var results = []; + + var p = Promise.resolve(thenable).then(incX); + results.push(x); + + // check what happens after all "next cycle" steps + // have had a chance to complete + setTimeout(function(){ + // Result should be [0, 2] since `thenable` will be called async. + is(results[0], 0, "Expected thenable to be called asynchronously"); + // See Bug 1023547 comment 13 for why this check has to be gated on p. + p.then(function() { + results.push(x); + is(results[1], 2, "Expected thenable to be called asynchronously"); + runTest(); + }); + },1000); +} + +// Bug 1062323 +function promiseWrapperAsyncResolution() +{ + var p = new Promise(function(resolve, reject){ + resolve(); + }); + + var results = []; + var q = p.then(function () { + results.push("1-1"); + }).then(function () { + results.push("1-2"); + }).then(function () { + results.push("1-3"); + }); + + var r = p.then(function () { + results.push("2-1"); + }).then(function () { + results.push("2-2"); + }).then(function () { + results.push("2-3"); + }); + + Promise.all([q, r]).then(function() { + var match = results[0] == "1-1" && + results[1] == "2-1" && + results[2] == "1-2" && + results[3] == "2-2" && + results[4] == "1-3" && + results[5] == "2-3"; + ok(match, "Chained promises should resolve asynchronously."); + runTest(); + }, function() { + ok(false, "promiseWrapperAsyncResolution: One of the promises failed."); + runTest(); + }); +} + +var tests = [ + promiseResolve, + promiseReject, + promiseException, + promiseAsync_TimeoutResolveThen, + promiseAsync_ResolveTimeoutThen, + promiseAsync_ResolveThenTimeout, + promiseAsync_SyncXHRAndImportScripts, + promiseDoubleThen, + promiseThenException, + promiseThenCatchThen, + promiseRejectThenCatchThen, + promiseRejectThenCatchThen2, + promiseRejectThenCatchExceptionThen, + promiseThenCatchOrderingResolve, + promiseThenCatchOrderingReject, + promiseNestedPromise, + promiseNestedNestedPromise, + promiseWrongNestedPromise, + promiseLoop, + promiseStaticReject, + promiseStaticResolve, + promiseResolveNestedPromise, + promiseResolveNoArg, + promiseRejectNoArg, + + promiseThenNoArg, + promiseThenUndefinedResolveFunction, + promiseThenNullResolveFunction, + promiseCatchNoArg, + promiseRejectNoHandler, + + promiseUtilitiesDefined, + + promiseAllArray, + promiseAllWaitsForAllPromises, + promiseAllRejectFails, + + promiseRaceEmpty, + promiseRaceValuesArray, + promiseRacePromiseArray, + promiseRaceReject, + promiseRaceThrow, + + promiseResolveArray, + promiseResolveThenable, + promiseResolvePromise, + + promiseResolveThenableCleanStack, + + promiseWrapperAsyncResolution, +]; + +function runTest() { + if (!tests.length) { + postMessage({ type: 'finish' }); + return; + } + + var test = tests.shift(); + test(); +} + +onmessage = function() { + runTest(); +} diff --git a/dom/workers/test/recursion_worker.js b/dom/workers/test/recursion_worker.js new file mode 100644 index 000000000..1a61ec9d1 --- /dev/null +++ b/dom/workers/test/recursion_worker.js @@ -0,0 +1,46 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +// This function should never run on a too much recursion error. +onerror = function(event) { + postMessage(event.message); +}; + +// Pure JS recursion +function recurse() { + recurse(); +} + +// JS -> C++ -> JS -> C++ recursion +function recurse2() { + var xhr = new XMLHttpRequest(); + xhr.onreadystatechange = function() { + xhr.open("GET", "nonexistent.file"); + } + xhr.open("GET", "nonexistent.file"); +} + +var messageCount = 0; +onmessage = function(event) { + switch (++messageCount) { + case 2: + recurse2(); + + // An exception thrown from an event handler like xhr.onreadystatechange + // should not leave an exception pending in the code that generated the + // event. + postMessage("Done"); + return; + + case 1: + recurse(); + throw "Exception should have prevented us from getting here!"; + + default: + throw "Weird number of messages: " + messageCount; + } + + throw "Impossible to get here!"; +} diff --git a/dom/workers/test/recursiveOnerror_worker.js b/dom/workers/test/recursiveOnerror_worker.js new file mode 100644 index 000000000..e6656d68f --- /dev/null +++ b/dom/workers/test/recursiveOnerror_worker.js @@ -0,0 +1,11 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onerror = function(message, filename, lineno) { + throw new Error("2"); +}; + +onmessage = function(event) { + throw new Error("1"); +}; diff --git a/dom/workers/test/redirect_to_foreign.sjs b/dom/workers/test/redirect_to_foreign.sjs new file mode 100644 index 000000000..1a5e24a59 --- /dev/null +++ b/dom/workers/test/redirect_to_foreign.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "http://example.org/tests/dom/workers/test/foreign.js"); +} diff --git a/dom/workers/test/referrer.sjs b/dom/workers/test/referrer.sjs new file mode 100644 index 000000000..dcfd1fe37 --- /dev/null +++ b/dom/workers/test/referrer.sjs @@ -0,0 +1,15 @@ +function handleRequest(request, response) +{ + if (request.queryString == "result") { + response.write(getState("referer")); + setState("referer", "INVALID"); + } else if (request.queryString == "worker") { + response.setHeader("Content-Type", "text/javascript", false); + response.write("onmessage = function() { postMessage(42); }"); + setState("referer", request.getHeader("referer")); + } else if (request.queryString == 'import') { + setState("referer", request.getHeader("referer")); + response.write("'hello world'"); + } +} + diff --git a/dom/workers/test/referrer_test_server.sjs b/dom/workers/test/referrer_test_server.sjs new file mode 100644 index 000000000..550fefb8a --- /dev/null +++ b/dom/workers/test/referrer_test_server.sjs @@ -0,0 +1,101 @@ +Components.utils.importGlobalProperties(["URLSearchParams"]); +const SJS = "referrer_test_server.sjs?"; +const SHARED_KEY = SJS; + +var SAME_ORIGIN = "https://example.com/tests/dom/workers/test/" + SJS; +var CROSS_ORIGIN = "https://test2.example.com/tests/dom/workers/test/" + SJS; +var DOWNGRADE = "http://example.com/tests/dom/workers/test/" + SJS; + +function createUrl(aRequestType, aPolicy) { + var searchParams = new URLSearchParams(); + searchParams.append("ACTION", "request-worker"); + searchParams.append("Referrer-Policy", aPolicy); + searchParams.append("TYPE", aRequestType); + + var url = SAME_ORIGIN; + + if (aRequestType === "cross-origin") { + url = CROSS_ORIGIN; + } else if (aRequestType === "downgrade") { + url = DOWNGRADE; + } + + return url + searchParams.toString(); +} +function createWorker (aRequestType, aPolicy) { + return ` + onmessage = function() { + fetch("${createUrl(aRequestType, aPolicy)}").then(function () { + postMessage(42); + close(); + }); + } + `; +} + +function handleRequest(request, response) { + var params = new URLSearchParams(request.queryString); + var policy = params.get("Referrer-Policy"); + var type = params.get("TYPE"); + var action = params.get("ACTION"); + response.setHeader("Content-Security-Policy", "default-src *", false); + response.setHeader("Access-Control-Allow-Origin", "*", false); + + if (policy) { + response.setHeader("Referrer-Policy", policy, false); + } + + if (action === "test") { + response.setHeader("Content-Type", "text/javascript", false); + response.write(createWorker(type, policy)); + return; + } + + if (action === "resetState") { + setSharedState(SHARED_KEY, "{}"); + response.write(""); + return; + } + + if (action === "get-test-results") { + response.setHeader("Cache-Control", "no-cache", false); + response.setHeader("Content-Type", "text/plain", false); + response.write(getSharedState(SHARED_KEY)); + return; + } + + if (action === "request-worker") { + var result = getSharedState(SHARED_KEY); + result = result ? JSON.parse(result) : {}; + var referrerLevel = "none"; + var test = {}; + + if (request.hasHeader("Referer")) { + var referrer = request.getHeader("Referer"); + if (referrer.indexOf("referrer_test_server") > 0) { + referrerLevel = "full"; + } else if (referrer.indexOf("https://example.com") == 0) { + referrerLevel = "origin"; + } else { + // this is never supposed to happen + referrerLevel = "other-origin"; + } + test.referrer = referrer; + } else { + test.referrer = ""; + } + + test.policy = referrerLevel; + test.expected = policy; + + // test id equals type + "-" + policy + // Ex: same-origin-default + result[type + "-" + policy] = test; + setSharedState(SHARED_KEY, JSON.stringify(result)); + + response.write("'hello world'"); + return; + } +} + + diff --git a/dom/workers/test/referrer_worker.html b/dom/workers/test/referrer_worker.html new file mode 100644 index 000000000..5693fc340 --- /dev/null +++ b/dom/workers/test/referrer_worker.html @@ -0,0 +1,145 @@ +<!DOCTYPE html> +<html> +<head> +</head> +<body onload="tests.next();"> +<script type="text/javascript;version=1.7"> +const SJS = "referrer_test_server.sjs?"; +const BASE_URL = "https://example.com/tests/dom/workers/test/" + SJS; +const GET_RESULT = BASE_URL + 'ACTION=get-test-results'; +const RESET_STATE = BASE_URL + 'ACTION=resetState'; + +function ok(val, message) { + val = val ? "true" : "false"; + window.parent.postMessage("SimpleTest.ok(" + val + ", '" + message + "');", "*"); +} + +function info(val) { + window.parent.postMessage("SimpleTest.info(" + val + ");", "*"); +} + +function is(a, b, message) { + ok(a == b, message); +} + +function finish() { + // Let window.onerror have a chance to fire + setTimeout(function() { + setTimeout(function() { + tests.close(); + window.parent.postMessage("SimpleTest.finish();", "*"); + }, 0); + }, 0); +} + +var testCases = { + 'same-origin': { 'Referrer-Policy' : { 'default' : 'full', + 'origin' : 'origin', + 'origin-when-cross-origin' : 'full', + 'unsafe-url' : 'full', + 'same-origin' : 'full', + 'strict-origin' : 'origin', + 'strict-origin-when-cross-origin' : 'full', + 'no-referrer' : 'none', + 'unsafe-url, no-referrer' : 'none', + 'invalid' : 'full' }}, + + 'cross-origin': { 'Referrer-Policy' : { 'default' : 'full', + 'origin' : 'origin', + 'origin-when-cross-origin' : 'origin', + 'unsafe-url' : 'full', + 'same-origin' : 'none', + 'strict-origin' : 'origin', + 'strict-origin-when-cross-origin' : 'origin', + 'no-referrer' : 'none', + 'unsafe-url, no-referrer' : 'none', + 'invalid' : 'full' }}, + + // Downgrading in worker is blocked entirely without unblock option + // https://bugzilla.mozilla.org/show_bug.cgi?id=1198078#c17 + // Skip the downgrading test + /* 'downgrade': { 'Referrer-Policy' : { 'default' : 'full', + 'origin' : 'full', + 'origin-when-cross-origin"' : 'full', + 'unsafe-url' : 'full', + 'same-origin' : 'none', + 'strict-origin' : 'none', + 'strict-origin-when-cross-origin' : 'none', + 'no-referrer' : 'full', + 'unsafe-url, no-referrer' : 'none', + 'invalid' : 'full' }}, */ + + +}; + +var advance = function() { tests.next(); }; + +/** + * helper to perform an XHR + * to do checkIndividualResults and resetState + */ +function doXHR(aUrl, onSuccess, onFail) { + var xhr = new XMLHttpRequest({mozSystem: true}); + xhr.responseType = "json"; + xhr.onload = function () { + onSuccess(xhr); + }; + xhr.onerror = function () { + onFail(xhr); + }; + xhr.open('GET', aUrl, true); + xhr.send(null); +} + + +function resetState() { + doXHR(RESET_STATE, + advance, + function(xhr) { + ok(false, "error in reset state"); + finish(); + }); +} + +function checkIndividualResults(aType, aPolicy, aExpected) { + var onload = xhr => { + var results = xhr.response; + dump(JSON.stringify(xhr.response)); + // test id equals type + "-" + policy + // Ex: same-origin-default + var id = aType + "-" + aPolicy; + ok(id in results, id + " tests have to be performed."); + is(results[id].policy, aExpected, id + ' --- ' + results[id].policy + ' (' + results[id].referrer + ')'); + advance(); + }; + var onerror = xhr => { + ok(false, "Can't get results from the counter server."); + finish(); + }; + doXHR(GET_RESULT, onload, onerror); +} + +var tests = (function() { + + for (var type in testCases) { + for (var policy in testCases[type]['Referrer-Policy']) { + yield resetState(); + var searchParams = new URLSearchParams(); + searchParams.append("TYPE", type); + searchParams.append("ACTION", "test"); + searchParams.append("Referrer-Policy", policy); + var worker = new Worker(BASE_URL + searchParams.toString()); + worker.onmessage = function () { + advance(); + }; + yield worker.postMessage(42); + yield checkIndividualResults(type, policy, escape(testCases[type]['Referrer-Policy'][policy])); + } + } + + // complete. Be sure to yield so we don't call this twice. + yield finish(); +})(); +</script> +</body> +</html> diff --git a/dom/workers/test/rvals_worker.js b/dom/workers/test/rvals_worker.js new file mode 100644 index 000000000..51f9ae723 --- /dev/null +++ b/dom/workers/test/rvals_worker.js @@ -0,0 +1,13 @@ +onmessage = function(evt) { + postMessage(postMessage('ignore') == undefined); + + var id = setInterval(function() {}, 200); + postMessage(clearInterval(id) == undefined); + + id = setTimeout(function() {}, 200); + postMessage(clearTimeout(id) == undefined); + + postMessage(dump(42 + '\n') == undefined); + + postMessage('finished'); +} diff --git a/dom/workers/test/script_createFile.js b/dom/workers/test/script_createFile.js new file mode 100644 index 000000000..aee7df10e --- /dev/null +++ b/dom/workers/test/script_createFile.js @@ -0,0 +1,15 @@ +var { classes: Cc, interfaces: Ci, utils: Cu } = Components; +Cu.importGlobalProperties(["File", "Directory"]); + +addMessageListener("file.open", function (e) { + var tmpFile = Cc["@mozilla.org/file/directory_service;1"] + .getService(Ci.nsIDirectoryService) + .QueryInterface(Ci.nsIProperties) + .get('TmpD', Ci.nsIFile) + tmpFile.append('file.txt'); + tmpFile.createUnique(Components.interfaces.nsIFile.FILE_TYPE, 0o600); + + sendAsyncMessage("file.opened", { + data: File.createFromNsIFile(tmpFile) + }); +}); diff --git a/dom/workers/test/serviceworkers/activate_event_error_worker.js b/dom/workers/test/serviceworkers/activate_event_error_worker.js new file mode 100644 index 000000000..a5f159d35 --- /dev/null +++ b/dom/workers/test/serviceworkers/activate_event_error_worker.js @@ -0,0 +1,4 @@ +// Worker that errors on receiving an activate event. +onactivate = function(e) { + undefined.doSomething; +} diff --git a/dom/workers/test/serviceworkers/blocking_install_event_worker.js b/dom/workers/test/serviceworkers/blocking_install_event_worker.js new file mode 100644 index 000000000..0bc6f7b7f --- /dev/null +++ b/dom/workers/test/serviceworkers/blocking_install_event_worker.js @@ -0,0 +1,23 @@ +function postMessageToTest(msg) { + return clients.matchAll({ includeUncontrolled: true }) + .then(list => { + for (var client of list) { + if (client.url.endsWith('test_install_event_gc.html')) { + client.postMessage(msg); + break; + } + } + }); +} + +addEventListener('install', evt => { + // This must be a simple promise to trigger the CC failure. + evt.waitUntil(new Promise(function() { })); + postMessageToTest({ type: 'INSTALL_EVENT' }); +}); + +addEventListener('message', evt => { + if (evt.data.type === 'ping') { + postMessageToTest({ type: 'pong' }); + } +}); diff --git a/dom/workers/test/serviceworkers/browser.ini b/dom/workers/test/serviceworkers/browser.ini new file mode 100644 index 000000000..c0aae30d6 --- /dev/null +++ b/dom/workers/test/serviceworkers/browser.ini @@ -0,0 +1,10 @@ +[DEFAULT] +support-files = + browser_base_force_refresh.html + browser_cached_force_refresh.html + download/window.html + download/worker.js + force_refresh_browser_worker.js + +[browser_force_refresh.js] +[browser_download.js] diff --git a/dom/workers/test/serviceworkers/browser_base_force_refresh.html b/dom/workers/test/serviceworkers/browser_base_force_refresh.html new file mode 100644 index 000000000..1b0d2defe --- /dev/null +++ b/dom/workers/test/serviceworkers/browser_base_force_refresh.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> +</head> +<body> +<script type="text/javascript"> +addEventListener('load', function(event) { + navigator.serviceWorker.register('force_refresh_browser_worker.js').then(function(swr) { + if (!swr) { + return; + } + var custom = new Event('base-register', { bubbles: true }); + document.dispatchEvent(custom); + }); + + navigator.serviceWorker.ready.then(function() { + var custom = new Event('base-sw-ready', { bubbles: true }); + document.dispatchEvent(custom); + }); + + var custom = new Event('base-load', { bubbles: true }); + document.dispatchEvent(custom); +}); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/browser_cached_force_refresh.html b/dom/workers/test/serviceworkers/browser_cached_force_refresh.html new file mode 100644 index 000000000..33bd8cdaa --- /dev/null +++ b/dom/workers/test/serviceworkers/browser_cached_force_refresh.html @@ -0,0 +1,64 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> +</head> +<body> +<script type="text/javascript"> +function ok(exp, msg) { + if (!exp) { + throw(msg); + } +} + +function is(actual, expected, msg) { + if (actual !== expected) { + throw('got "' + actual + '", but expected "' + expected + '" - ' + msg); + } +} + +function fail(err) { + var custom = new CustomEvent('cached-failure', { + bubbles: true, + detail: err + }); + document.dispatchEvent(custom); +} + +function getUncontrolledClients(sw) { + return new Promise(function(resolve, reject) { + navigator.serviceWorker.addEventListener('message', function onMsg(evt) { + if (evt.data.type === 'CLIENTS') { + navigator.serviceWorker.removeEventListener('message', onMsg); + resolve(evt.data.detail); + } + }); + sw.postMessage({ type: 'GET_UNCONTROLLED_CLIENTS' }) + }); +} + +addEventListener('load', function(event) { + if (!navigator.serviceWorker.controller) { + return fail(window.location.href + ' is not controlled!'); + } + + getUncontrolledClients(navigator.serviceWorker.controller) + .then(function(clientList) { + is(clientList.length, 1, 'should only have one client'); + is(clientList[0].url, window.location.href, + 'client url should match current window'); + is(clientList[0].frameType, 'top-level', + 'client should be a top-level window'); + var custom = new Event('cached-load', { bubbles: true }); + document.dispatchEvent(custom); + }) + .catch(function(err) { + fail(err); + }); +}); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/browser_download.js b/dom/workers/test/serviceworkers/browser_download.js new file mode 100644 index 000000000..bd4da10c9 --- /dev/null +++ b/dom/workers/test/serviceworkers/browser_download.js @@ -0,0 +1,83 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +Cu.import('resource://gre/modules/Services.jsm'); +var Downloads = Cu.import("resource://gre/modules/Downloads.jsm", {}).Downloads; +var DownloadsCommon = Cu.import("resource:///modules/DownloadsCommon.jsm", {}).DownloadsCommon; +Cu.import('resource://gre/modules/NetUtil.jsm'); + +var gTestRoot = getRootDirectory(gTestPath).replace("chrome://mochitests/content/", + "http://mochi.test:8888/") + +function getFile(aFilename) { + if (aFilename.startsWith('file:')) { + var url = NetUtil.newURI(aFilename).QueryInterface(Ci.nsIFileURL); + return url.file.clone(); + } + + var file = Cc['@mozilla.org/file/local;1'].createInstance(Ci.nsIFile); + file.initWithPath(aFilename); + return file; +} + +function windowObserver(win, topic) { + if (topic !== 'domwindowopened') { + return; + } + + win.addEventListener('load', function onLoadWindow() { + win.removeEventListener('load', onLoadWindow, false); + if (win.document.documentURI === + 'chrome://mozapps/content/downloads/unknownContentType.xul') { + executeSoon(function() { + var button = win.document.documentElement.getButton('accept'); + button.disabled = false; + win.document.documentElement.acceptDialog(); + }); + } + }, false); +} + +function test() { + waitForExplicitFinish(); + + Services.ww.registerNotification(windowObserver); + + SpecialPowers.pushPrefEnv({'set': [['dom.serviceWorkers.enabled', true], + ['dom.serviceWorkers.exemptFromPerDomainMax', true], + ['dom.serviceWorkers.testing.enabled', true]]}, + function() { + var url = gTestRoot + 'download/window.html'; + var tab = gBrowser.addTab(); + gBrowser.selectedTab = tab; + + Downloads.getList(Downloads.ALL).then(function(downloadList) { + var downloadListener; + + function downloadVerifier(aDownload) { + if (aDownload.succeeded) { + var file = getFile(aDownload.target.path); + ok(file.exists(), 'download completed'); + is(file.fileSize, 33, 'downloaded file has correct size'); + file.remove(false); + DownloadsCommon.removeAndFinalizeDownload(aDownload); + + downloadList.removeView(downloadListener); + gBrowser.removeTab(tab); + Services.ww.unregisterNotification(windowObserver); + + executeSoon(finish); + } + } + + downloadListener = { + onDownloadAdded: downloadVerifier, + onDownloadChanged: downloadVerifier + }; + + return downloadList.addView(downloadListener); + }).then(function() { + gBrowser.loadURI(url); + }); + }); +} diff --git a/dom/workers/test/serviceworkers/browser_force_refresh.js b/dom/workers/test/serviceworkers/browser_force_refresh.js new file mode 100644 index 000000000..a2c9c871c --- /dev/null +++ b/dom/workers/test/serviceworkers/browser_force_refresh.js @@ -0,0 +1,91 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +var gTestRoot = getRootDirectory(gTestPath).replace("chrome://mochitests/content/", + "http://mochi.test:8888/") + +function refresh() { + EventUtils.synthesizeKey('R', { accelKey: true }); +} + +function forceRefresh() { + EventUtils.synthesizeKey('R', { accelKey: true, shiftKey: true }); +} + +function frameScript() { + function eventHandler(event) { + sendAsyncMessage("test:event", {type: event.type, detail: event.detail}); + } + + // These are tab-local, so no need to unregister them. + addEventListener('base-load', eventHandler, true, true); + addEventListener('base-register', eventHandler, true, true); + addEventListener('base-sw-ready', eventHandler, true, true); + addEventListener('cached-load', eventHandler, true, true); + addEventListener('cached-failure', eventHandler, true, true); +} + +function test() { + waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({'set': [['dom.serviceWorkers.enabled', true], + ['dom.serviceWorkers.exemptFromPerDomainMax', true], + ['dom.serviceWorkers.testing.enabled', true], + ['dom.caches.enabled', true], + ['browser.cache.disk.enable', false], + ['browser.cache.memory.enable', false]]}, + function() { + var url = gTestRoot + 'browser_base_force_refresh.html'; + var tab = gBrowser.addTab(); + gBrowser.selectedTab = tab; + + tab.linkedBrowser.messageManager.loadFrameScript("data:,(" + encodeURIComponent(frameScript) + ")()", true); + gBrowser.loadURI(url); + + function done() { + tab.linkedBrowser.messageManager.removeMessageListener("test:event", eventHandler); + + gBrowser.removeTab(tab); + executeSoon(finish); + } + + var maxCacheLoadCount = 3; + var cachedLoadCount = 0; + var baseLoadCount = 0; + + function eventHandler(msg) { + if (msg.data.type === 'base-load') { + baseLoadCount += 1; + if (cachedLoadCount === maxCacheLoadCount) { + is(baseLoadCount, 2, 'cached load should occur before second base load'); + return done(); + } + if (baseLoadCount !== 1) { + ok(false, 'base load without cached load should only occur once'); + return done(); + } + } else if (msg.data.type === 'base-register') { + ok(!cachedLoadCount, 'cached load should not occur before base register'); + is(baseLoadCount, 1, 'register should occur after first base load'); + } else if (msg.data.type === 'base-sw-ready') { + ok(!cachedLoadCount, 'cached load should not occur before base ready'); + is(baseLoadCount, 1, 'ready should occur after first base load'); + refresh(); + } else if (msg.data.type === 'cached-load') { + ok(cachedLoadCount < maxCacheLoadCount, 'cached load should not occur too many times'); + is(baseLoadCount, 1, 'cache load occur after first base load'); + cachedLoadCount += 1; + if (cachedLoadCount < maxCacheLoadCount) { + return refresh(); + } + forceRefresh(); + } else if (msg.data.type === 'cached-failure') { + ok(false, 'failure: ' + msg.data.detail); + done(); + } + + return; + } + + tab.linkedBrowser.messageManager.addMessageListener("test:event", eventHandler); + }); +} diff --git a/dom/workers/test/serviceworkers/bug1151916_driver.html b/dom/workers/test/serviceworkers/bug1151916_driver.html new file mode 100644 index 000000000..e540ad239 --- /dev/null +++ b/dom/workers/test/serviceworkers/bug1151916_driver.html @@ -0,0 +1,53 @@ +<html> + <body> + <script language="javascript"> + function fail(msg) { + window.parent.postMessage({ status: "failed", message: msg }, "*"); + } + + function success(msg) { + window.parent.postMessage({ status: "success", message: msg }, "*"); + } + + if (!window.parent) { + dump("This file must be embedded in an iframe!"); + } + + navigator.serviceWorker.getRegistration() + .then(function(reg) { + if (!reg) { + navigator.serviceWorker.ready.then(function(reg) { + if (reg.active.state == "activating") { + reg.active.onstatechange = function(e) { + reg.active.onstatechange = null; + if (reg.active.state == "activated") { + success("Registered and activated"); + } + } + } else { + success("Registered and activated"); + } + }); + navigator.serviceWorker.register("bug1151916_worker.js", + { scope: "." }); + } else { + // Simply force the sw to load a resource and touch self.caches. + if (!reg.active) { + fail("no-active-worker"); + return; + } + + fetch("madeup.txt").then(function(res) { + res.text().then(function(v) { + if (v == "Hi there") { + success("Loaded from cache"); + } else { + fail("Response text did not match"); + } + }, fail); + }, fail); + } + }, fail); + </script> + </body> +</html> diff --git a/dom/workers/test/serviceworkers/bug1151916_worker.js b/dom/workers/test/serviceworkers/bug1151916_worker.js new file mode 100644 index 000000000..06585e8e7 --- /dev/null +++ b/dom/workers/test/serviceworkers/bug1151916_worker.js @@ -0,0 +1,13 @@ +onactivate = function(e) { + e.waitUntil(self.caches.open("default-cache").then(function(cache) { + var response = new Response("Hi there"); + return cache.put("madeup.txt", response); + })); +} + +onfetch = function(e) { + if (e.request.url.match(/madeup.txt$/)) { + var p = self.caches.match("madeup.txt", { cacheName: "default-cache" }); + e.respondWith(p); + } +} diff --git a/dom/workers/test/serviceworkers/bug1240436_worker.js b/dom/workers/test/serviceworkers/bug1240436_worker.js new file mode 100644 index 000000000..5a588aedf --- /dev/null +++ b/dom/workers/test/serviceworkers/bug1240436_worker.js @@ -0,0 +1,2 @@ +// a contains a ZERO WIDTH JOINER (0x200D) +var a = "â€";
\ No newline at end of file diff --git a/dom/workers/test/serviceworkers/chrome.ini b/dom/workers/test/serviceworkers/chrome.ini new file mode 100644 index 000000000..e064e7fd0 --- /dev/null +++ b/dom/workers/test/serviceworkers/chrome.ini @@ -0,0 +1,16 @@ +[DEFAULT] +skip-if = os == 'android' +support-files = + chrome_helpers.js + empty.js + serviceworker.html + serviceworkerinfo_iframe.html + serviceworkermanager_iframe.html + serviceworkerregistrationinfo_iframe.html + worker.js + worker2.js + +[test_privateBrowsing.html] +[test_serviceworkerinfo.xul] +[test_serviceworkermanager.xul] +[test_serviceworkerregistrationinfo.xul] diff --git a/dom/workers/test/serviceworkers/chrome_helpers.js b/dom/workers/test/serviceworkers/chrome_helpers.js new file mode 100644 index 000000000..a438333e2 --- /dev/null +++ b/dom/workers/test/serviceworkers/chrome_helpers.js @@ -0,0 +1,74 @@ +let { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +Cu.import("resource://gre/modules/Task.jsm"); + +let swm = Cc["@mozilla.org/serviceworkers/manager;1"]. + getService(Ci.nsIServiceWorkerManager); + +let EXAMPLE_URL = "https://example.com/chrome/dom/workers/test/serviceworkers/"; + +function waitForIframeLoad(iframe) { + return new Promise(function (resolve) { + iframe.onload = resolve; + }); +} + +function waitForRegister(scope, callback) { + return new Promise(function (resolve) { + let listener = { + onRegister: function (registration) { + if (registration.scope !== scope) { + return; + } + swm.removeListener(listener); + resolve(callback ? callback(registration) : registration); + } + }; + swm.addListener(listener); + }); +} + +function waitForUnregister(scope) { + return new Promise(function (resolve) { + let listener = { + onUnregister: function (registration) { + if (registration.scope !== scope) { + return; + } + swm.removeListener(listener); + resolve(registration); + } + }; + swm.addListener(listener); + }); +} + +function waitForServiceWorkerRegistrationChange(registration, callback) { + return new Promise(function (resolve) { + let listener = { + onChange: function () { + registration.removeListener(listener); + if (callback) { + callback(); + } + resolve(callback ? callback() : undefined); + } + }; + registration.addListener(listener); + }); +} + +function waitForServiceWorkerShutdown() { + return new Promise(function (resolve) { + let observer = { + observe: function (subject, topic, data) { + if (topic !== "service-worker-shutdown") { + return; + } + SpecialPowers.removeObserver(observer, "service-worker-shutdown"); + resolve(); + } + }; + SpecialPowers.addObserver(observer, "service-worker-shutdown", false); + }); +} diff --git a/dom/workers/test/serviceworkers/claim_clients/client.html b/dom/workers/test/serviceworkers/claim_clients/client.html new file mode 100644 index 000000000..eecfb294e --- /dev/null +++ b/dom/workers/test/serviceworkers/claim_clients/client.html @@ -0,0 +1,44 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1130684 - claim client </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + info("This page shouldn't be launched directly!"); + } + + window.onload = function() { + parent.postMessage("READY", "*"); + } + + navigator.serviceWorker.oncontrollerchange = function() { + parent.postMessage({ + event: "controllerchange", + controller: (navigator.serviceWorker.controller !== null) + }, "*"); + } + + navigator.serviceWorker.onmessage = function(e) { + parent.postMessage({ + event: "message", + data: e.data + }, "*"); + } + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/claim_fetch_worker.js b/dom/workers/test/serviceworkers/claim_fetch_worker.js new file mode 100644 index 000000000..ea62c37b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/claim_fetch_worker.js @@ -0,0 +1,12 @@ +onfetch = function(e) { + if (e.request.url.indexOf("service_worker_controlled") >= 0) { + // pass through + e.respondWith(fetch(e.request)); + } else { + e.respondWith(new Response("Fetch was intercepted")); + } +} + +onmessage = function(e) { + clients.claim(); +} diff --git a/dom/workers/test/serviceworkers/claim_oninstall_worker.js b/dom/workers/test/serviceworkers/claim_oninstall_worker.js new file mode 100644 index 000000000..269afa721 --- /dev/null +++ b/dom/workers/test/serviceworkers/claim_oninstall_worker.js @@ -0,0 +1,7 @@ +oninstall = function(e) { + var claimFailedPromise = new Promise(function(resolve, reject) { + clients.claim().then(reject, () => resolve()); + }); + + e.waitUntil(claimFailedPromise); +} diff --git a/dom/workers/test/serviceworkers/claim_worker_1.js b/dom/workers/test/serviceworkers/claim_worker_1.js new file mode 100644 index 000000000..e5f6392d3 --- /dev/null +++ b/dom/workers/test/serviceworkers/claim_worker_1.js @@ -0,0 +1,28 @@ +onactivate = function(e) { + var result = { + resolve_value: false, + match_count_before: -1, + match_count_after: -1, + message: "claim_worker_1" + }; + + self.clients.matchAll().then(function(matched) { + // should be 0 + result.match_count_before = matched.length; + }).then(function() { + var claimPromise = self.clients.claim().then(function(ret) { + result.resolve_value = ret; + }); + + return claimPromise.then(self.clients.matchAll().then(function(matched) { + // should be 2 + result.match_count_after = matched.length; + for (i = 0; i < matched.length; i++) { + matched[i].postMessage(result); + } + if (result.match_count_after !== 2) { + dump("ERROR: claim_worker_1 failed to capture clients.\n"); + } + })); + }); +} diff --git a/dom/workers/test/serviceworkers/claim_worker_2.js b/dom/workers/test/serviceworkers/claim_worker_2.js new file mode 100644 index 000000000..be8281d34 --- /dev/null +++ b/dom/workers/test/serviceworkers/claim_worker_2.js @@ -0,0 +1,27 @@ +onactivate = function(e) { + var result = { + resolve_value: false, + match_count_before: -1, + match_count_after: -1, + message: "claim_worker_2" + }; + + self.clients.matchAll().then(function(matched) { + // should be 0 + result.match_count_before = matched.length; + }).then(function() { + var claimPromise = self.clients.claim().then(function(ret) { + result.resolve_value = ret; + }); + + return claimPromise.then(self.clients.matchAll().then(function(matched) { + // should be 1 + result.match_count_after = matched.length; + if (result.match_count_after === 1) { + matched[0].postMessage(result); + } else { + dump("ERROR: claim_worker_2 failed to capture clients.\n"); + } + })); + }); +} diff --git a/dom/workers/test/serviceworkers/close_test.js b/dom/workers/test/serviceworkers/close_test.js new file mode 100644 index 000000000..6138d6421 --- /dev/null +++ b/dom/workers/test/serviceworkers/close_test.js @@ -0,0 +1,19 @@ +function ok(v, msg) { + client.postMessage({status: "ok", result: !!v, message: msg}); +} + +var client; +onmessage = function(e) { + if (e.data.message == "start") { + self.clients.matchAll().then(function(clients) { + client = clients[0]; + try { + close(); + ok(false, "close() should throw"); + } catch (e) { + ok(e.name === "InvalidAccessError", "close() should throw InvalidAccessError"); + } + client.postMessage({status: "done"}); + }); + } +} diff --git a/dom/workers/test/serviceworkers/controller/index.html b/dom/workers/test/serviceworkers/controller/index.html new file mode 100644 index 000000000..740e24f15 --- /dev/null +++ b/dom/workers/test/serviceworkers/controller/index.html @@ -0,0 +1,74 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 94048 - test install event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + // Make sure to use good, unique messages, since the actual expression will not show up in test results. + function my_ok(result, msg) { + parent.postMessage({status: "ok", result: result, message: msg}, "*"); + } + + function finish() { + parent.postMessage({status: "done"}, "*"); + } + + navigator.serviceWorker.ready.then(function(swr) { + my_ok(swr.scope.match(/serviceworkers\/control$/), + "This page should be controlled by upper level registration"); + my_ok(swr.installing == undefined, + "Upper level registration should not have a installing worker."); + if (navigator.serviceWorker.controller) { + // We are controlled. + // Register a new worker for this sub-scope. After that, controller should still be for upper level, but active should change to be this scope's. + navigator.serviceWorker.register("../worker2.js", { scope: "./" }).then(function(e) { + my_ok("installing" in e, "ServiceWorkerRegistration.installing exists."); + my_ok(e.installing instanceof ServiceWorker, "ServiceWorkerRegistration.installing is a ServiceWorker."); + + my_ok("waiting" in e, "ServiceWorkerRegistration.waiting exists."); + my_ok("active" in e, "ServiceWorkerRegistration.active exists."); + + my_ok(e.installing && + e.installing.scriptURL.match(/worker2.js$/), + "Installing is serviceworker/controller"); + + my_ok("scope" in e, "ServiceWorkerRegistration.scope exists."); + my_ok(e.scope.match(/serviceworkers\/controller\/$/), "Scope is serviceworker/controller " + e.scope); + + my_ok("unregister" in e, "ServiceWorkerRegistration.unregister exists."); + + my_ok(navigator.serviceWorker.controller.scriptURL.match(/worker\.js$/), + "Controller is still worker.js"); + + e.unregister().then(function(result) { + my_ok(result, "Unregistering the SW should succeed"); + finish(); + }, function(e) { + dump("Error unregistering the SW: " + e + "\n"); + }); + }); + } else { + my_ok(false, "Should've been controlled!"); + finish(); + } + }).catch(function(e) { + my_ok(false, "Some test threw an error " + e); + finish(); + }); +</script> +</pre> +</body> +</html> + + diff --git a/dom/workers/test/serviceworkers/create_another_sharedWorker.html b/dom/workers/test/serviceworkers/create_another_sharedWorker.html new file mode 100644 index 000000000..f49194fa5 --- /dev/null +++ b/dom/workers/test/serviceworkers/create_another_sharedWorker.html @@ -0,0 +1,6 @@ +<!DOCTYPE HTML> +<title>Shared workers: create antoehr sharedworekr client</title> +<pre id=log>Hello World</pre> +<script> + var worker = new SharedWorker('sharedWorker_fetch.js'); +</script> diff --git a/dom/workers/test/serviceworkers/download/window.html b/dom/workers/test/serviceworkers/download/window.html new file mode 100644 index 000000000..7d7893e0e --- /dev/null +++ b/dom/workers/test/serviceworkers/download/window.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> +</head> +<body> +<script type="text/javascript"> + +function wait_until_controlled() { + return new Promise(function(resolve) { + if (navigator.serviceWorker.controller) { + return resolve(); + } + navigator.serviceWorker.addEventListener('controllerchange', function onController() { + if (navigator.serviceWorker.controller) { + navigator.serviceWorker.removeEventListener('controllerchange', onController); + return resolve(); + } + }); + }); +} +addEventListener('load', function(event) { + var registration; + navigator.serviceWorker.register('worker.js').then(function(swr) { + registration = swr; + + // While the iframe below is a navigation, we still wait until we are + // controlled here. We want an active client to hold the service worker + // alive since it calls unregister() on itself. + return wait_until_controlled(); + + }).then(function() { + var frame = document.createElement('iframe'); + document.body.appendChild(frame); + frame.src = 'fake_download'; + + // The service worker is unregistered in the fetch event. The window and + // frame are cleaned up from the browser chrome script. + }); +}); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/download/worker.js b/dom/workers/test/serviceworkers/download/worker.js new file mode 100644 index 000000000..fe46d1a3b --- /dev/null +++ b/dom/workers/test/serviceworkers/download/worker.js @@ -0,0 +1,30 @@ +addEventListener('install', function(evt) { + evt.waitUntil(self.skipWaiting()); +}); + +addEventListener('activate', function(evt) { + // We claim the current clients in order to ensure that we have an + // active client when we call unregister in the fetch handler. Otherwise + // the unregister() can kill the current worker before returning a + // response. + evt.waitUntil(clients.claim()); +}); + +addEventListener('fetch', function(evt) { + // This worker may live long enough to receive a fetch event from the next + // test. Just pass such requests through to the network. + if (evt.request.url.indexOf('fake_download') === -1) { + return; + } + + // We should only get a single download fetch event. Automatically unregister. + evt.respondWith(registration.unregister().then(function() { + return new Response('service worker generated download', { + headers: { + 'Content-Disposition': 'attachment; filename="fake_download.bin"', + // fake encoding header that should have no effect + 'Content-Encoding': 'gzip', + } + }); + })); +}); diff --git a/dom/workers/test/serviceworkers/empty.js b/dom/workers/test/serviceworkers/empty.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/empty.js diff --git a/dom/workers/test/serviceworkers/error_reporting_helpers.js b/dom/workers/test/serviceworkers/error_reporting_helpers.js new file mode 100644 index 000000000..fbc4ca6fc --- /dev/null +++ b/dom/workers/test/serviceworkers/error_reporting_helpers.js @@ -0,0 +1,68 @@ +"use strict"; + +/** + * Helpers for use in tests that want to verify that localized error messages + * are logged during the test. Because most of our errors (ex: + * ServiceWorkerManager) generate nsIScriptError instances with flattened + * strings (the interpolated arguments aren't kept around), we load the string + * bundle and use it to derive the exact string message we expect for the given + * payload. + **/ + +let stringBundleService = + SpecialPowers.Cc["@mozilla.org/intl/stringbundle;1"] + .getService(SpecialPowers.Ci.nsIStringBundleService); +let localizer = + stringBundleService.createBundle("chrome://global/locale/dom/dom.properties"); + +/** + * Start monitoring the console for the given localized error message string(s) + * with the given arguments to be logged. Call before running code that will + * generate the console message. Pair with a call to + * `wait_for_expected_message` invoked after the message should have been + * generated. + * + * Multiple error messages can be expected, just repeat the msgId and args + * argument pair as needed. + * + * @param {String} msgId + * The localization message identifier used in the properties file. + * @param {String[]} args + * The list of formatting arguments we expect the error to be generated with. + * @return {Object} Promise/handle to pass to wait_for_expected_message. + */ +function expect_console_message(/* msgId, args, ... */) { + let expectations = []; + // process repeated paired arguments of: msgId, args + for (let i = 0; i < arguments.length; i += 2) { + let msgId = arguments[i]; + let args = arguments[i + 1]; + expectations.push({ + errorMessage: localizer.formatStringFromName(msgId, args, args.length) + }); + } + return new Promise(resolve => { + SimpleTest.monitorConsole(resolve, expectations); + }); +} +let expect_console_messages = expect_console_message; + +/** + * Stop monitoring the console, returning a Promise that will be resolved when + * the sentinel console message sent through the async data path has been + * received. The Promise will not reject on failure; instead a mochitest + * failure will have been generated by ok(false)/equivalent by the time it is + * resolved. + */ +function wait_for_expected_message(expectedPromise) { + SimpleTest.endMonitorConsole(); + return expectedPromise; +} + +/** + * Derive an absolute URL string from a relative URL to simplify error message + * argument generation. + */ +function make_absolute_url(relUrl) { + return new URL(relUrl, window.location).href; +} diff --git a/dom/workers/test/serviceworkers/eval_worker.js b/dom/workers/test/serviceworkers/eval_worker.js new file mode 100644 index 000000000..c60f2f637 --- /dev/null +++ b/dom/workers/test/serviceworkers/eval_worker.js @@ -0,0 +1 @@ +eval('1+1'); diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource.resource b/dom/workers/test/serviceworkers/eventsource/eventsource.resource new file mode 100644 index 000000000..eb62cbd4c --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource.resource @@ -0,0 +1,22 @@ +:this file must be enconded in utf8 +:and its Content-Type must be equal to text/event-stream + +retry:500 +data: 2 +unknow: unknow + +event: other_event_name +retry:500 +data: 2 +unknow: unknow + +event: click +retry:500 + +event: blur +retry:500 + +event:keypress +retry:500 + + diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource.resource^headers^ b/dom/workers/test/serviceworkers/eventsource/eventsource.resource^headers^ new file mode 100644 index 000000000..5b88be7c3 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource.resource^headers^ @@ -0,0 +1,3 @@ +Content-Type: text/event-stream +Cache-Control: no-cache, must-revalidate +Access-Control-Allow-Origin: * diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response.html b/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response.html new file mode 100644 index 000000000..7c6f7302f --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response.html @@ -0,0 +1,75 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript"> + + var prefix = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/eventsource/"; + + function ok(aCondition, aMessage) { + parent.postMessage({status: "callback", data: "ok", condition: aCondition, message: aMessage}, "*"); + } + + function doUnregister() { + navigator.serviceWorker.getRegistration().then(swr => { + swr.unregister().then(function(result) { + ok(result, "Unregister should return true."); + parent.postMessage({status: "callback", data: "done"}, "*"); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e); + }); + }); + } + + function doEventSource() { + var source = new EventSource(prefix + "eventsource.resource"); + source.onmessage = function(e) { + source.onmessage = null; + source.close(); + ok(true, "EventSource should work with cors responses"); + doUnregister(); + }; + source.onerror = function(error) { + source.onerror = null; + source.close(); + ok(false, "Something went wrong"); + }; + } + + function onLoad() { + if (!parent) { + dump("eventsource/eventsource_cors_response.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function onMessage(e) { + if (e.data.status === "callback") { + switch(e.data.data) { + case "eventsource": + doEventSource(); + window.removeEventListener("message", onMessage); + break; + default: + ok(false, "Something went wrong") + break + } + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage({status: "callback", data: "ready"}, "*"); + }); + + navigator.serviceWorker.addEventListener("message", function(event) { + parent.postMessage(event.data, "*"); + }); + } + + </script> +</head> +<body onload="onLoad()"> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response_intercept_worker.js b/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response_intercept_worker.js new file mode 100644 index 000000000..579e9f568 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_cors_response_intercept_worker.js @@ -0,0 +1,20 @@ +// Cross origin request +var prefix = 'http://example.com/tests/dom/workers/test/serviceworkers/eventsource/'; + +self.importScripts('eventsource_worker_helper.js'); + +self.addEventListener('fetch', function (event) { + var request = event.request; + var url = new URL(request.url); + + if (url.pathname !== '/tests/dom/workers/test/serviceworkers/eventsource/eventsource.resource') { + return; + } + + ok(request.mode === 'cors', 'EventSource should make a CORS request'); + ok(request.cache === 'no-store', 'EventSource should make a no-store request'); + var fetchRequest = new Request(prefix + 'eventsource.resource', { mode: 'cors'}); + event.respondWith(fetch(fetchRequest).then((fetchResponse) => { + return fetchResponse; + })); +}); diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response.html b/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response.html new file mode 100644 index 000000000..f6ae0d96f --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response.html @@ -0,0 +1,75 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript"> + + var prefix = "https://example.com/tests/dom/workers/test/serviceworkers/eventsource/"; + + function ok(aCondition, aMessage) { + parent.postMessage({status: "callback", data: "ok", condition: aCondition, message: aMessage}, "*"); + } + + function doUnregister() { + navigator.serviceWorker.getRegistration().then(swr => { + swr.unregister().then(function(result) { + ok(result, "Unregister should return true."); + parent.postMessage({status: "callback", data: "done"}, "*"); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e); + }); + }); + } + + function doEventSource() { + var source = new EventSource(prefix + "eventsource.resource"); + source.onmessage = function(e) { + source.onmessage = null; + source.close(); + ok(false, "Something went wrong"); + }; + source.onerror = function(error) { + source.onerror = null; + source.close(); + ok(true, "EventSource should not work with mixed content cors responses"); + doUnregister(); + }; + } + + function onLoad() { + if (!parent) { + dump("eventsource/eventsource_cors_response.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function onMessage(e) { + if (e.data.status === "callback") { + switch(e.data.data) { + case "eventsource": + doEventSource(); + window.removeEventListener("message", onMessage); + break; + default: + ok(false, "Something went wrong") + break + } + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage({status: "callback", data: "ready"}, "*"); + }); + + navigator.serviceWorker.addEventListener("message", function(event) { + parent.postMessage(event.data, "*"); + }); + } + + </script> +</head> +<body onload="onLoad()"> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response_intercept_worker.js b/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response_intercept_worker.js new file mode 100644 index 000000000..187d0bc6f --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_mixed_content_cors_response_intercept_worker.js @@ -0,0 +1,19 @@ +var prefix = 'http://example.com/tests/dom/workers/test/serviceworkers/eventsource/'; + +self.importScripts('eventsource_worker_helper.js'); + +self.addEventListener('fetch', function (event) { + var request = event.request; + var url = new URL(request.url); + + if (url.pathname !== '/tests/dom/workers/test/serviceworkers/eventsource/eventsource.resource') { + return; + } + + ok(request.mode === 'cors', 'EventSource should make a CORS request'); + ok(request.cache === 'no-store', 'EventSource should make a no-store request'); + var fetchRequest = new Request(prefix + 'eventsource.resource', { mode: 'cors'}); + event.respondWith(fetch(fetchRequest).then((fetchResponse) => { + return fetchResponse; + })); +}); diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response.html b/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response.html new file mode 100644 index 000000000..f92811e63 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response.html @@ -0,0 +1,75 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript"> + + var prefix = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/eventsource/"; + + function ok(aCondition, aMessage) { + parent.postMessage({status: "callback", data: "ok", condition: aCondition, message: aMessage}, "*"); + } + + function doUnregister() { + navigator.serviceWorker.getRegistration().then(swr => { + swr.unregister().then(function(result) { + ok(result, "Unregister should return true."); + parent.postMessage({status: "callback", data: "done"}, "*"); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e); + }); + }); + } + + function doEventSource() { + var source = new EventSource(prefix + "eventsource.resource"); + source.onmessage = function(e) { + source.onmessage = null; + source.close(); + ok(false, "Something went wrong"); + }; + source.onerror = function(error) { + source.onerror = null; + source.close(); + ok(true, "EventSource should not work with opaque responses"); + doUnregister(); + }; + } + + function onLoad() { + if (!parent) { + dump("eventsource/eventsource_opaque_response.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function onMessage(e) { + if (e.data.status === "callback") { + switch(e.data.data) { + case "eventsource": + doEventSource(); + window.removeEventListener("message", onMessage); + break; + default: + ok(false, "Something went wrong") + break + } + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage({status: "callback", data: "ready"}, "*"); + }); + + navigator.serviceWorker.addEventListener("message", function(event) { + parent.postMessage(event.data, "*"); + }); + } + + </script> +</head> +<body onload="onLoad()"> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response_intercept_worker.js b/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response_intercept_worker.js new file mode 100644 index 000000000..45a80e324 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_opaque_response_intercept_worker.js @@ -0,0 +1,20 @@ +// Cross origin request +var prefix = 'http://example.com/tests/dom/workers/test/serviceworkers/eventsource/'; + +self.importScripts('eventsource_worker_helper.js'); + +self.addEventListener('fetch', function (event) { + var request = event.request; + var url = new URL(request.url); + + if (url.pathname !== '/tests/dom/workers/test/serviceworkers/eventsource/eventsource.resource') { + return; + } + + ok(request.mode === 'cors', 'EventSource should make a CORS request'); + ok(request.cache === 'no-store', 'EventSource should make a no-store request'); + var fetchRequest = new Request(prefix + 'eventsource.resource', { mode: 'no-cors'}); + event.respondWith(fetch(fetchRequest).then((fetchResponse) => { + return fetchResponse; + })); +}); diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_register_worker.html b/dom/workers/test/serviceworkers/eventsource/eventsource_register_worker.html new file mode 100644 index 000000000..59e8e92ab --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_register_worker.html @@ -0,0 +1,27 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript"> + + function getURLParam (aTarget, aValue) { + return decodeURI(aTarget.search.replace(new RegExp("^(?:.*[&\\?]" + encodeURI(aValue).replace(/[\.\+\*]/g, "\\$&") + "(?:\\=([^&]*))?)?.*$", "i"), "$1")); + } + + function onLoad() { + navigator.serviceWorker.ready.then(function() { + parent.postMessage({status: "callback", data: "done"}, "*"); + }); + + navigator.serviceWorker.register(getURLParam(document.location, "script"), {scope: "."}); + } + + </script> +</head> +<body onload="onLoad()"> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response.html b/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response.html new file mode 100644 index 000000000..d9f380e2f --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response.html @@ -0,0 +1,75 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript"> + + var prefix = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/eventsource/"; + + function ok(aCondition, aMessage) { + parent.postMessage({status: "callback", data: "ok", condition: aCondition, message: aMessage}, "*"); + } + + function doUnregister() { + navigator.serviceWorker.getRegistration().then(swr => { + swr.unregister().then(function(result) { + ok(result, "Unregister should return true."); + parent.postMessage({status: "callback", data: "done"}, "*"); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e); + }); + }); + } + + function doEventSource() { + var source = new EventSource(prefix + "eventsource.resource"); + source.onmessage = function(e) { + source.onmessage = null; + source.close(); + ok(true, "EventSource should work with synthetic responses"); + doUnregister(); + }; + source.onerror = function(error) { + source.onmessage = null; + source.close(); + ok(false, "Something went wrong"); + }; + } + + function onLoad() { + if (!parent) { + dump("eventsource/eventsource_synthetic_response.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function onMessage(e) { + if (e.data.status === "callback") { + switch(e.data.data) { + case "eventsource": + doEventSource(); + window.removeEventListener("message", onMessage); + break; + default: + ok(false, "Something went wrong") + break + } + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage({status: "callback", data: "ready"}, "*"); + }); + + navigator.serviceWorker.addEventListener("message", function(event) { + parent.postMessage(event.data, "*"); + }); + } + + </script> +</head> +<body onload="onLoad()"> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response_intercept_worker.js b/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response_intercept_worker.js new file mode 100644 index 000000000..8692f9186 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_synthetic_response_intercept_worker.js @@ -0,0 +1,24 @@ +self.importScripts('eventsource_worker_helper.js'); + +self.addEventListener('fetch', function (event) { + var request = event.request; + var url = new URL(request.url); + + if (url.pathname !== '/tests/dom/workers/test/serviceworkers/eventsource/eventsource.resource') { + return; + } + + ok(request.mode === 'cors', 'EventSource should make a CORS request'); + var headerList = { + 'Content-Type': 'text/event-stream', + 'Cache-Control': 'no-cache, must-revalidate' + }; + var headers = new Headers(headerList); + var init = { + headers: headers, + mode: 'cors' + }; + var body = 'data: data0\r\r'; + var response = new Response(body, init); + event.respondWith(response); +}); diff --git a/dom/workers/test/serviceworkers/eventsource/eventsource_worker_helper.js b/dom/workers/test/serviceworkers/eventsource/eventsource_worker_helper.js new file mode 100644 index 000000000..6d5dbb024 --- /dev/null +++ b/dom/workers/test/serviceworkers/eventsource/eventsource_worker_helper.js @@ -0,0 +1,12 @@ +function ok(aCondition, aMessage) { + return new Promise(function(resolve, reject) { + self.clients.matchAll().then(function(res) { + if (!res.length) { + reject(); + return; + } + res[0].postMessage({status: "callback", data: "ok", condition: aCondition, message: aMessage}); + resolve(); + }); + }); +} diff --git a/dom/workers/test/serviceworkers/fetch.js b/dom/workers/test/serviceworkers/fetch.js new file mode 100644 index 000000000..38d20a638 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch.js @@ -0,0 +1,11 @@ +addEventListener('fetch', function(event) { + if (event.request.url.indexOf("fail.html") !== -1) { + event.respondWith(fetch("hello.html", {"integrity": "abc"})); + } else if (event.request.url.indexOf("fake.html") !== -1) { + event.respondWith(fetch("hello.html")); + } +}); + +addEventListener("activate", function(event) { + event.waitUntil(clients.claim()); +}); diff --git a/dom/workers/test/serviceworkers/fetch/context/beacon.sjs b/dom/workers/test/serviceworkers/fetch/context/beacon.sjs new file mode 100644 index 000000000..8401bc29b --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/beacon.sjs @@ -0,0 +1,43 @@ +/* + * This is based on dom/tests/mochitest/beacon/beacon-originheader-handler.sjs. + */ + +function handleRequest(request, response) +{ + response.setHeader("Cache-Control", "no-cache", false); + response.setHeader("Content-Type", "text/plain", false); + + // case XHR-REQUEST: the xhr-request tries to query the + // stored context from the beacon request. + if (request.queryString == "queryContext") { + var context = getState("interceptContext"); + // if the beacon already stored the context - return. + if (context) { + response.write(context); + setState("interceptContext", ""); + return; + } + // otherwise wait for the beacon request + response.processAsync(); + setObjectState("sw-xhr-response", response); + return; + } + + // case BEACON-REQUEST: get the beacon context and + // store the context on the server. + var context = request.queryString; + setState("interceptContext", context); + + // if there is an xhr-request waiting, return the context now. + try{ + getObjectState("sw-xhr-response", function(xhrResponse) { + if (!xhrResponse) { + return; + } + setState("interceptContext", ""); + xhrResponse.write(context); + xhrResponse.finish(); + }); + } catch(e) { + } +} diff --git a/dom/workers/test/serviceworkers/fetch/context/context_test.js b/dom/workers/test/serviceworkers/fetch/context/context_test.js new file mode 100644 index 000000000..b98d2ab3c --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/context_test.js @@ -0,0 +1,135 @@ +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0 || + event.request.url.indexOf("register.html") >= 0 || + event.request.url.indexOf("unregister.html") >= 0 || + event.request.url.indexOf("ping.html") >= 0 || + event.request.url.indexOf("xml.xml") >= 0 || + event.request.url.indexOf("csp-violate.sjs") >= 0) { + // Handle pass-through requests + event.respondWith(fetch(event.request)); + } else if (event.request.url.indexOf("fetch.txt") >= 0) { + var body = event.request.context == "fetch" ? + "so fetch" : "so unfetch"; + event.respondWith(new Response(body)); + } else if (event.request.url.indexOf("img.jpg") >= 0) { + if (event.request.context == "image") { + event.respondWith(fetch("realimg.jpg")); + } + } else if (event.request.url.indexOf("responsive.jpg") >= 0) { + if (event.request.context == "imageset") { + event.respondWith(fetch("realimg.jpg")); + } + } else if (event.request.url.indexOf("audio.ogg") >= 0) { + if (event.request.context == "audio") { + event.respondWith(fetch("realaudio.ogg")); + } + } else if (event.request.url.indexOf("video.ogg") >= 0) { + if (event.request.context == "video") { + event.respondWith(fetch("realaudio.ogg")); + } + } else if (event.request.url.indexOf("beacon.sjs") >= 0) { + if (event.request.url.indexOf("queryContext") == -1) { + event.respondWith(fetch("beacon.sjs?" + event.request.context)); + } else { + event.respondWith(fetch(event.request)); + } + } else if (event.request.url.indexOf("csp-report.sjs") >= 0) { + respondToServiceWorker(event, "csp-report"); + } else if (event.request.url.indexOf("embed") >= 0) { + respondToServiceWorker(event, "embed"); + } else if (event.request.url.indexOf("object") >= 0) { + respondToServiceWorker(event, "object"); + } else if (event.request.url.indexOf("font") >= 0) { + respondToServiceWorker(event, "font"); + } else if (event.request.url.indexOf("iframe") >= 0) { + if (event.request.context == "iframe") { + event.respondWith(fetch("context_test.js")); + } + } else if (event.request.url.indexOf("frame") >= 0) { + if (event.request.context == "frame") { + event.respondWith(fetch("context_test.js")); + } + } else if (event.request.url.indexOf("newwindow") >= 0) { + respondToServiceWorker(event, "newwindow"); + } else if (event.request.url.indexOf("ping") >= 0) { + respondToServiceWorker(event, "ping"); + } else if (event.request.url.indexOf("plugin") >= 0) { + respondToServiceWorker(event, "plugin"); + } else if (event.request.url.indexOf("script.js") >= 0) { + if (event.request.context == "script") { + event.respondWith(new Response("")); + } + } else if (event.request.url.indexOf("style.css") >= 0) { + respondToServiceWorker(event, "style"); + } else if (event.request.url.indexOf("track") >= 0) { + respondToServiceWorker(event, "track"); + } else if (event.request.url.indexOf("xhr") >= 0) { + if (event.request.context == "xmlhttprequest") { + event.respondWith(new Response("")); + } + } else if (event.request.url.indexOf("xslt") >= 0) { + respondToServiceWorker(event, "xslt"); + } else if (event.request.url.indexOf("myworker") >= 0) { + if (event.request.context == "worker") { + event.respondWith(fetch("worker.js")); + } + } else if (event.request.url.indexOf("myparentworker") >= 0) { + if (event.request.context == "worker") { + event.respondWith(fetch("parentworker.js")); + } + } else if (event.request.url.indexOf("mysharedworker") >= 0) { + if (event.request.context == "sharedworker") { + event.respondWith(fetch("sharedworker.js")); + } + } else if (event.request.url.indexOf("myparentsharedworker") >= 0) { + if (event.request.context == "sharedworker") { + event.respondWith(fetch("parentsharedworker.js")); + } + } else if (event.request.url.indexOf("cache") >= 0) { + var cache; + var origContext = event.request.context; + event.respondWith(caches.open("cache") + .then(function(c) { + cache = c; + // Store the Request in the cache. + return cache.put(event.request, new Response("fake")); + }).then(function() { + // Read it back. + return cache.keys(event.request); + }).then(function(res) { + var req = res[0]; + // Check to see if the context remained the same. + var success = req.context === origContext; + return clients.matchAll() + .then(function(clients) { + // Report it back to the main page. + clients.forEach(function(c) { + c.postMessage({data: "cache", success: success}); + }); + })}).then(function() { + // Cleanup. + return caches.delete("cache"); + }).then(function() { + return new Response("ack"); + })); + } + // Fail any request that we don't know about. + try { + event.respondWith(Promise.reject(event.request.url)); + dump("Fetch event received invalid context value " + event.request.context + + " for " + event.request.url + "\n"); + } catch(e) { + // Eat up the possible InvalidStateError exception that we may get if some + // code above has called respondWith too. + } +}); + +function respondToServiceWorker(event, data) { + event.respondWith(clients.matchAll() + .then(function(clients) { + clients.forEach(function(c) { + c.postMessage({data: data, context: event.request.context}); + }); + return new Response("ack"); + })); +} diff --git a/dom/workers/test/serviceworkers/fetch/context/csp-violate.sjs b/dom/workers/test/serviceworkers/fetch/context/csp-violate.sjs new file mode 100644 index 000000000..4c3e76d15 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/csp-violate.sjs @@ -0,0 +1,6 @@ +function handleRequest(request, response) +{ + response.setHeader("Content-Security-Policy", "default-src 'none'; report-uri /tests/dom/workers/test/serviceworkers/fetch/context/csp-report.sjs", false); + response.setHeader("Content-Type", "text/html", false); + response.write("<link rel=stylesheet href=style.css>"); +} diff --git a/dom/workers/test/serviceworkers/fetch/context/index.html b/dom/workers/test/serviceworkers/fetch/context/index.html new file mode 100644 index 000000000..c6dfef99c --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/index.html @@ -0,0 +1,422 @@ +<!DOCTYPE html> +<script> + var isAndroid = navigator.userAgent.includes("Android"); + var isB2G = !isAndroid && /Mobile|Tablet/.test(navigator.userAgent); + + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function is(a, b, msg) { + ok(a === b, msg + ", expected '" + b + "', got '" + a + "'"); + } + + function todo(v, msg) { + window.parent.postMessage({status: "todo", result: !!v, message: msg}, "*"); + } + + function finish() { + window.parent.postMessage({status: "done"}, "*"); + } + + function testFetch() { + return fetch("fetch.txt").then(function(r) { + return r.text(); + }).then(function(body) { + is(body, "so fetch", "A fetch() Request should have the 'fetch' context"); + }); + } + + function testImage() { + return new Promise(function(resolve, reject) { + var img = document.createElement("img"); + img.src = "img.jpg"; + // The service worker will respond with an existing image only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + img.onload = resolve; + img.onerror = reject; + }); + } + + function testImageSrcSet() { + return new Promise(function(resolve, reject) { + var img = document.createElement("img"); + img.srcset = "responsive.jpg 100w"; + // The service worker will respond with an existing image only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + img.onload = resolve; + img.onerror = reject; + }); + } + + function testPicture() { + return new Promise(function(resolve, reject) { + var pic = document.createElement("picture"); + var img = document.createElement("img"); + pic.appendChild(img); + img.src = "responsive.jpg?picture"; + // The service worker will respond with an existing image only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + img.onload = resolve; + img.onerror = reject; + }); + } + + function testAudio() { + return new Promise(function(resolve, reject) { + var audio = document.createElement("audio"); + audio.src = "audio.ogg"; + audio.preload = "metadata"; + // The service worker will respond with an existing audio only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + audio.onloadedmetadata = resolve; + audio.onerror = reject; + }); + } + + function testVideo() { + return new Promise(function(resolve, reject) { + var video = document.createElement("video"); + video.src = "video.ogg"; + video.preload = "metadata"; + // The service worker will respond with an existing video only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + video.onloadedmetadata = resolve; + video.onerror = reject; + }); + } + + function testBeacon() { + ok(navigator.sendBeacon("beacon.sjs"), "Sending the beacon should succeed"); + // query the context from beacon.sjs + return fetch("beacon.sjs?queryContext") + .then(function(r) { + return r.text(); + }).then(function(body) { + is(body, "beacon", "The context for the intercepted beacon should be correct"); + }); + } + + function testCSPReport() { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = "csp-violate.sjs"; + document.documentElement.appendChild(iframe); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "csp-report") { + is(e.data.context, "cspreport", "Expected the cspreport context on a CSP violation report"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testEmbed() { + return Promise.resolve().then(function() { + todo(false, "<embed> tag is not currently intercepted. See Bug 1168676."); + }); + + return new Promise(function(resolve, reject) { + var embed = document.createElement("embed"); + embed.src = "embed"; + document.documentElement.appendChild(embed); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "embed") { + is(e.data.context, "embed", "Expected the object context on an embed"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testObject() { + return Promise.resolve().then(function() { + todo(false, "<object> tag is not currently intercepted. See Bug 1168676"); + }); + + return new Promise(function(resolve, reject) { + var object = document.createElement("object"); + object.data = "object"; + document.documentElement.appendChild(object); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "object") { + is(e.data.context, "object", "Expected the object context on an object"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testFont() { + return new Promise(function(resolve, reject) { + var css = '@font-face { font-family: "sw-font"; src: url("font"); }'; + css += '* { font-family: "sw-font"; }'; + var style = document.createElement("style"); + style.appendChild(document.createTextNode(css)); + document.documentElement.appendChild(style); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "font") { + is(e.data.context, "font", "Expected the font context on an font"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testIFrame() { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = "iframe"; + document.documentElement.appendChild(iframe); + // The service worker will respond with an existing document only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + iframe.onload = resolve; + iframe.onerror = reject; + }); + } + + function testFrame() { + return new Promise(function(resolve, reject) { + var frame = document.createElement("frame"); + frame.src = "frame"; + document.documentElement.appendChild(frame); + // The service worker will respond with an existing document only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + frame.onload = resolve; + frame.onerror = reject; + }); + } + + function testInternal() { + if (isB2G) { + // We can't open new windows on b2g, so skip this part of the test there. + return Promise.resolve(); + } + return new Promise(function(resolve, reject) { + // Test this with a new window opened through script. There are of course + // other possible ways of testing this too. + var win = window.open("newwindow", "_blank", "width=100,height=100"); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "newwindow") { + is(e.data.context, "internal", "Expected the internal context on a newly opened window"); + navigator.serviceWorker.removeEventListener("message", onMessage); + win.close(); + resolve(); + } + }, false); + }); + } + + function testPing() { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = "ping.html"; + document.documentElement.appendChild(iframe); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "ping") { + is(e.data.context, "ping", "Expected the ping context on an anchor ping"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testPlugin() { + return Promise.resolve().then(function() { + todo(false, "plugins are not currently intercepted. See Bug 1168676."); + }); + + var isMobile = /Mobile|Tablet/.test(navigator.userAgent); + if (isMobile || parent.isMulet()) { + // We can't use plugins on mobile, so skip this part of the test there. + return Promise.resolve(); + } + + return new Promise(function(resolve, reject) { + var embed = document.createElement("embed"); + embed.type = "application/x-test"; + embed.setAttribute("posturl", "plugin"); + embed.setAttribute("postmode", "stream"); + embed.setAttribute("streammode", "normal"); + embed.setAttribute("src", "fetch.txt"); + document.documentElement.appendChild(embed); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "plugin") { + is(e.data.context, "plugin", "Expected the plugin context on a request coming from a plugin"); + navigator.serviceWorker.removeEventListener("message", onMessage); + // Without this, the test leaks in e10s! + embed.parentNode.removeChild(embed); + resolve(); + } + }, false); + }); + } + + function testScript() { + return new Promise(function(resolve, reject) { + var script = document.createElement("script"); + script.src = "script.js"; + document.documentElement.appendChild(script); + // The service worker will respond with an existing script only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + script.onload = resolve; + script.onerror = reject; + }); + } + + function testStyle() { + return new Promise(function(resolve, reject) { + var link = document.createElement("link"); + link.rel = "stylesheet"; + link.href = "style.css"; + document.documentElement.appendChild(link); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "style") { + is(e.data.context, "style", "Expected the style context on a request coming from a stylesheet"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testTrack() { + return new Promise(function(resolve, reject) { + var video = document.createElement("video"); + var track = document.createElement("track"); + track.src = "track"; + video.appendChild(track); + document.documentElement.appendChild(video); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "track") { + is(e.data.context, "track", "Expected the track context on a request coming from a track"); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + function testXHR() { + return new Promise(function(resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open("get", "xhr", true); + xhr.send(); + // The service worker will respond with an existing resource only if the + // Request has the correct context, otherwise the Promise will get + // rejected and the test will fail. + xhr.onload = resolve; + xhr.onerror = reject; + }); + } + + function testXSLT() { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = "xml.xml"; + document.documentElement.appendChild(iframe); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "xslt") { + is(e.data.context, "xslt", "Expected the xslt context on an XSLT stylesheet"); + navigator.serviceWorker.removeEventListener("message", onMessage); + // Without this, the test leaks in e10s! + iframe.parentNode.removeChild(iframe); + resolve(); + } + }, false); + }); + } + + function testWorker() { + return new Promise(function(resolve, reject) { + var worker = new Worker("myworker"); + worker.onmessage = function(e) { + if (e.data == "ack") { + worker.terminate(); + resolve(); + } + }; + worker.onerror = reject; + }); + } + + function testNestedWorker() { + return new Promise(function(resolve, reject) { + var worker = new Worker("myparentworker"); + worker.onmessage = function(e) { + if (e.data == "ack") { + worker.terminate(); + resolve(); + } + }; + worker.onerror = reject; + }); + } + + function testSharedWorker() { + return new Promise(function(resolve, reject) { + var worker = new SharedWorker("mysharedworker"); + worker.port.start(); + worker.port.onmessage = function(e) { + if (e.data == "ack") { + resolve(); + } + }; + worker.onerror = reject; + }); + } + + function testNestedWorkerInSharedWorker() { + return new Promise(function(resolve, reject) { + var worker = new SharedWorker("myparentsharedworker"); + worker.port.start(); + worker.port.onmessage = function(e) { + if (e.data == "ack") { + resolve(); + } + }; + worker.onerror = reject; + }); + } + + function testCache() { + return new Promise(function(resolve, reject) { + // Issue an XHR that will be intercepted by the SW in order to start off + // the test with a RequestContext value that is not the default ("fetch"). + // This needs to run inside a fetch event handler because synthesized + // RequestContext objects can only have the "fetch" context, and we'd + // prefer to test the more general case of some other RequestContext value. + var xhr = new XMLHttpRequest(); + xhr.open("get", "cache", true); + xhr.send(); + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.data == "cache") { + ok(e.data.success, "The RequestContext can be persisted in the cache."); + navigator.serviceWorker.removeEventListener("message", onMessage); + resolve(); + } + }, false); + }); + } + + var testName = location.search.substr(1); + window[testName]().then(function() { + finish(); + }, function(e) { + ok(false, "A promise was rejected: " + e); + finish(); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/context/parentsharedworker.js b/dom/workers/test/serviceworkers/fetch/context/parentsharedworker.js new file mode 100644 index 000000000..eac8d5e71 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/parentsharedworker.js @@ -0,0 +1,8 @@ +onconnect = function(e) { + e.ports[0].start(); + var worker = new Worker("myworker?shared"); + worker.onmessage = function(e2) { + e.ports[0].postMessage(e2.data); + self.close(); + }; +}; diff --git a/dom/workers/test/serviceworkers/fetch/context/parentworker.js b/dom/workers/test/serviceworkers/fetch/context/parentworker.js new file mode 100644 index 000000000..839fb6640 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/parentworker.js @@ -0,0 +1,4 @@ +var worker = new Worker("myworker"); +worker.onmessage = function(e) { + postMessage(e.data); +}; diff --git a/dom/workers/test/serviceworkers/fetch/context/ping.html b/dom/workers/test/serviceworkers/fetch/context/ping.html new file mode 100644 index 000000000..b1bebe41e --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/ping.html @@ -0,0 +1,7 @@ +<!DOCTYPE html> +<script> + onload = function() { + document.querySelector("a").click(); + }; +</script> +<a ping="ping" href="fetch.txt">link</a> diff --git a/dom/workers/test/serviceworkers/fetch/context/realaudio.ogg b/dom/workers/test/serviceworkers/fetch/context/realaudio.ogg Binary files differnew file mode 100644 index 000000000..1a41623f8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/realaudio.ogg diff --git a/dom/workers/test/serviceworkers/fetch/context/realimg.jpg b/dom/workers/test/serviceworkers/fetch/context/realimg.jpg Binary files differnew file mode 100644 index 000000000..5b920f7c0 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/realimg.jpg diff --git a/dom/workers/test/serviceworkers/fetch/context/register.html b/dom/workers/test/serviceworkers/fetch/context/register.html new file mode 100644 index 000000000..6528d0eae --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("context_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/context/sharedworker.js b/dom/workers/test/serviceworkers/fetch/context/sharedworker.js new file mode 100644 index 000000000..94dca5839 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/sharedworker.js @@ -0,0 +1,5 @@ +onconnect = function(e) { + e.ports[0].start(); + e.ports[0].postMessage("ack"); + self.close(); +}; diff --git a/dom/workers/test/serviceworkers/fetch/context/unregister.html b/dom/workers/test/serviceworkers/fetch/context/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/context/worker.js b/dom/workers/test/serviceworkers/fetch/context/worker.js new file mode 100644 index 000000000..e26e5bc69 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/worker.js @@ -0,0 +1 @@ +postMessage("ack"); diff --git a/dom/workers/test/serviceworkers/fetch/context/xml.xml b/dom/workers/test/serviceworkers/fetch/context/xml.xml new file mode 100644 index 000000000..69c64adf1 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/context/xml.xml @@ -0,0 +1,3 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/xsl" href="xslt"?> +<root/> diff --git a/dom/workers/test/serviceworkers/fetch/deliver-gzip.sjs b/dom/workers/test/serviceworkers/fetch/deliver-gzip.sjs new file mode 100644 index 000000000..abacdd2ad --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/deliver-gzip.sjs @@ -0,0 +1,17 @@ +function handleRequest(request, response) { + // The string "hello" repeated 10 times followed by newline. Compressed using gzip. + var bytes = [0x1f, 0x8b, 0x08, 0x08, 0x4d, 0xe2, 0xf9, 0x54, 0x00, 0x03, 0x68, + 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0xcb, 0x48, 0xcd, 0xc9, 0xc9, 0xcf, + 0x20, 0x85, 0xe0, 0x02, 0x00, 0xf5, 0x4b, 0x38, 0xcf, 0x33, 0x00, + 0x00, 0x00]; + + response.setHeader("Content-Encoding", "gzip", false); + response.setHeader("Content-Length", "" + bytes.length, false); + response.setHeader("Content-Type", "text/plain", false); + + var bos = Components.classes["@mozilla.org/binaryoutputstream;1"] + .createInstance(Components.interfaces.nsIBinaryOutputStream); + bos.setOutputStream(response.bodyOutputStream); + + bos.writeByteArray(bytes, bytes.length); +} diff --git a/dom/workers/test/serviceworkers/fetch/fetch_tests.js b/dom/workers/test/serviceworkers/fetch/fetch_tests.js new file mode 100644 index 000000000..54da1b66e --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/fetch_tests.js @@ -0,0 +1,416 @@ +var origin = 'http://mochi.test:8888'; + +function fetchXHRWithMethod(name, method, onload, onerror, headers) { + expectAsyncResult(); + + onload = onload || function() { + my_ok(false, "XHR load should not complete successfully"); + finish(); + }; + onerror = onerror || function() { + my_ok(false, "XHR load for " + name + " should be intercepted successfully"); + finish(); + }; + + var x = new XMLHttpRequest(); + x.open(method, name, true); + x.onload = function() { onload(x) }; + x.onerror = function() { onerror(x) }; + headers = headers || []; + headers.forEach(function(header) { + x.setRequestHeader(header[0], header[1]); + }); + x.send(); +} + +var corsServerPath = '/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs'; +var corsServerURL = 'http://example.com' + corsServerPath; + +function redirectURL(hops) { + return hops[0].server + corsServerPath + "?hop=1&hops=" + + encodeURIComponent(hops.toSource()); +} + +function fetchXHR(name, onload, onerror, headers) { + return fetchXHRWithMethod(name, 'GET', onload, onerror, headers); +} + +fetchXHR('bare-synthesized.txt', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "synthesized response body", "load should have synthesized response"); + finish(); +}); + +fetchXHR('test-respondwith-response.txt', function(xhr) { + my_ok(xhr.status == 200, "test-respondwith-response load should be successful"); + my_ok(xhr.responseText == "test-respondwith-response response body", "load should have response"); + finish(); +}); + +fetchXHR('synthesized-404.txt', function(xhr) { + my_ok(xhr.status == 404, "load should 404"); + my_ok(xhr.responseText == "synthesized response body", "404 load should have synthesized response"); + finish(); +}); + +fetchXHR('synthesized-headers.txt', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.getResponseHeader("X-Custom-Greeting") === "Hello", "custom header should be set"); + my_ok(xhr.responseText == "synthesized response body", "custom header load should have synthesized response"); + finish(); +}); + +fetchXHR('synthesized-redirect-real-file.txt', function(xhr) { +dump("Got status AARRGH " + xhr.status + " " + xhr.responseText + "\n"); + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "This is a real file.\n", "Redirect to real file should complete."); + finish(); +}); + +fetchXHR('synthesized-redirect-twice-real-file.txt', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "This is a real file.\n", "Redirect to real file (twice) should complete."); + finish(); +}); + +fetchXHR('synthesized-redirect-synthesized.txt', function(xhr) { + my_ok(xhr.status == 200, "synth+redirect+synth load should be successful"); + my_ok(xhr.responseText == "synthesized response body", "load should have redirected+synthesized response"); + finish(); +}); + +fetchXHR('synthesized-redirect-twice-synthesized.txt', function(xhr) { + my_ok(xhr.status == 200, "synth+redirect+synth (twice) load should be successful"); + my_ok(xhr.responseText == "synthesized response body", "load should have redirected+synthesized (twice) response"); + finish(); +}); + +fetchXHR('redirect.sjs', function(xhr) { + my_ok(xhr.status == 404, "redirected load should be uninterrupted"); + finish(); +}); + +fetchXHR('ignored.txt', function(xhr) { + my_ok(xhr.status == 404, "load should be uninterrupted"); + finish(); +}); + +fetchXHR('rejected.txt', null, function(xhr) { + my_ok(xhr.status == 0, "load should not complete"); + finish(); +}); + +fetchXHR('nonresponse.txt', null, function(xhr) { + my_ok(xhr.status == 0, "load should not complete"); + finish(); +}); + +fetchXHR('nonresponse2.txt', null, function(xhr) { + my_ok(xhr.status == 0, "load should not complete"); + finish(); +}); + +fetchXHR('nonpromise.txt', null, function(xhr) { + my_ok(xhr.status == 0, "load should not complete"); + finish(); +}); + +fetchXHR('headers.txt', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "1", "request header checks should have passed"); + finish(); +}, null, [["X-Test1", "header1"], ["X-Test2", "header2"]]); + +fetchXHR('http://user:pass@mochi.test:8888/user-pass', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == 'http://user:pass@mochi.test:8888/user-pass', 'The username and password should be preserved'); + finish(); +}); + +var expectedUncompressedResponse = ""; +for (var i = 0; i < 10; ++i) { + expectedUncompressedResponse += "hello"; +} +expectedUncompressedResponse += "\n"; + +// ServiceWorker does not intercept, at which point the network request should +// be correctly decoded. +fetchXHR('deliver-gzip.sjs', function(xhr) { + my_ok(xhr.status == 200, "network gzip load should be successful"); + my_ok(xhr.responseText == expectedUncompressedResponse, "network gzip load should have synthesized response."); + my_ok(xhr.getResponseHeader("Content-Encoding") == "gzip", "network Content-Encoding should be gzip."); + my_ok(xhr.getResponseHeader("Content-Length") == "35", "network Content-Length should be of original gzipped file."); + finish(); +}); + +fetchXHR('hello.gz', function(xhr) { + my_ok(xhr.status == 200, "gzip load should be successful"); + my_ok(xhr.responseText == expectedUncompressedResponse, "gzip load should have synthesized response."); + my_ok(xhr.getResponseHeader("Content-Encoding") == "gzip", "Content-Encoding should be gzip."); + my_ok(xhr.getResponseHeader("Content-Length") == "35", "Content-Length should be of original gzipped file."); + finish(); +}); + +fetchXHR('hello-after-extracting.gz', function(xhr) { + my_ok(xhr.status == 200, "gzip load after extracting should be successful"); + my_ok(xhr.responseText == expectedUncompressedResponse, "gzip load after extracting should have synthesized response."); + my_ok(xhr.getResponseHeader("Content-Encoding") == "gzip", "Content-Encoding after extracting should be gzip."); + my_ok(xhr.getResponseHeader("Content-Length") == "35", "Content-Length after extracting should be of original gzipped file."); + finish(); +}); + +fetchXHR(corsServerURL + '?status=200&allowOrigin=*', function(xhr) { + my_ok(xhr.status == 200, "cross origin load with correct headers should be successful"); + my_ok(xhr.getResponseHeader("access-control-allow-origin") == null, "cors headers should be filtered out"); + finish(); +}); + +// Verify origin header is sent properly even when we have a no-intercept SW. +var uriOrigin = encodeURIComponent(origin); +fetchXHR('http://example.org' + corsServerPath + '?ignore&status=200&origin=' + uriOrigin + + '&allowOrigin=' + uriOrigin, function(xhr) { + my_ok(xhr.status == 200, "cross origin load with correct headers should be successful"); + my_ok(xhr.getResponseHeader("access-control-allow-origin") == null, "cors headers should be filtered out"); + finish(); +}); + +// Verify that XHR is considered CORS tainted even when original URL is same-origin +// redirected to cross-origin. +fetchXHR(redirectURL([{ server: origin }, + { server: 'http://example.org', + allowOrigin: origin }]), function(xhr) { + my_ok(xhr.status == 200, "cross origin load with correct headers should be successful"); + my_ok(xhr.getResponseHeader("access-control-allow-origin") == null, "cors headers should be filtered out"); + finish(); +}); + +// Test that CORS preflight requests cannot be intercepted. Performs a +// cross-origin XHR that the SW chooses not to intercept. This requires a +// preflight request, which the SW must not be allowed to intercept. +fetchXHR(corsServerURL + '?status=200&allowOrigin=*', null, function(xhr) { + my_ok(xhr.status == 0, "cross origin load with incorrect headers should be a failure"); + finish(); +}, [["X-Unsafe", "unsafe"]]); + +// Test that CORS preflight requests cannot be intercepted. Performs a +// cross-origin XHR that the SW chooses to intercept and respond with a +// cross-origin fetch. This requires a preflight request, which the SW must not +// be allowed to intercept. +fetchXHR('http://example.org' + corsServerPath + '?status=200&allowOrigin=*', null, function(xhr) { + my_ok(xhr.status == 0, "cross origin load with incorrect headers should be a failure"); + finish(); +}, [["X-Unsafe", "unsafe"]]); + +// Test that when the page fetches a url the controlling SW forces a redirect to +// another location. This other location fetch should also be intercepted by +// the SW. +fetchXHR('something.txt', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "something else response body", "load should have something else"); + finish(); +}); + +// Test fetch will internally get it's SkipServiceWorker flag set. The request is +// made from the SW through fetch(). fetch() fetches a server-side JavaScript +// file that force a redirect. The redirect location fetch does not go through +// the SW. +fetchXHR('redirect_serviceworker.sjs', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "// empty worker, always succeed!\n", "load should have redirection content"); + finish(); +}); + +fetchXHR('empty-header', function(xhr) { + my_ok(xhr.status == 200, "load should be successful"); + my_ok(xhr.responseText == "emptyheader", "load should have the expected content"); + finish(); +}, null, [["emptyheader", ""]]); + +expectAsyncResult(); +fetch('http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*') +.then(function(res) { + my_ok(res.ok, "Valid CORS request should receive valid response"); + my_ok(res.type == "cors", "Response type should be CORS"); + res.text().then(function(body) { + my_ok(body === "<res>hello pass</res>\n", "cors response body should match"); + finish(); + }); +}, function(e) { + my_ok(false, "CORS Fetch failed"); + finish(); +}); + +expectAsyncResult(); +fetch('http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200', { mode: 'no-cors' }) +.then(function(res) { + my_ok(res.type == "opaque", "Response type should be opaque"); + my_ok(res.status == 0, "Status should be 0"); + res.text().then(function(body) { + my_ok(body === "", "opaque response body should be empty"); + finish(); + }); +}, function(e) { + my_ok(false, "no-cors Fetch failed"); + finish(); +}); + +expectAsyncResult(); +fetch('opaque-on-same-origin') +.then(function(res) { + my_ok(false, "intercepted opaque response for non no-cors request should fail."); + finish(); +}, function(e) { + my_ok(true, "intercepted opaque response for non no-cors request should fail."); + finish(); +}); + +expectAsyncResult(); +fetch('http://example.com/opaque-no-cors', { mode: "no-cors" }) +.then(function(res) { + my_ok(res.type == "opaque", "intercepted opaque response for no-cors request should have type opaque."); + finish(); +}, function(e) { + my_ok(false, "intercepted opaque response for no-cors request should pass."); + finish(); +}); + +expectAsyncResult(); +fetch('http://example.com/cors-for-no-cors', { mode: "no-cors" }) +.then(function(res) { + my_ok(res.type == "opaque", "intercepted non-opaque response for no-cors request should resolve to opaque response."); + finish(); +}, function(e) { + my_ok(false, "intercepted non-opaque response for no-cors request should resolve to opaque response. It should not fail."); + finish(); +}); + +function arrayBufferFromString(str) { + var arr = new Uint8Array(str.length); + for (var i = 0; i < str.length; ++i) { + arr[i] = str.charCodeAt(i); + } + return arr; +} + +expectAsyncResult(); +fetch(new Request('body-simple', {method: 'POST', body: 'my body'})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == 'my bodymy body', "the body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +fetch(new Request('body-arraybufferview', {method: 'POST', body: arrayBufferFromString('my body')})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == 'my bodymy body', "the ArrayBufferView body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +fetch(new Request('body-arraybuffer', {method: 'POST', body: arrayBufferFromString('my body').buffer})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == 'my bodymy body', "the ArrayBuffer body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +var usp = new URLSearchParams(); +usp.set("foo", "bar"); +usp.set("baz", "qux"); +fetch(new Request('body-urlsearchparams', {method: 'POST', body: usp})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == 'foo=bar&baz=quxfoo=bar&baz=qux', "the URLSearchParams body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +var fd = new FormData(); +fd.set("foo", "bar"); +fd.set("baz", "qux"); +fetch(new Request('body-formdata', {method: 'POST', body: fd})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body.indexOf("Content-Disposition: form-data; name=\"foo\"\r\n\r\nbar") < + body.indexOf("Content-Disposition: form-data; name=\"baz\"\r\n\r\nqux"), + "the FormData body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +fetch(new Request('body-blob', {method: 'POST', body: new Blob(new String('my body'))})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == 'my bodymy body', "the Blob body of the intercepted fetch should be visible in the SW"); + finish(); +}); + +expectAsyncResult(); +fetch('interrupt.sjs') +.then(function(res) { + my_ok(true, "interrupted fetch succeeded"); + res.text().then(function(body) { + my_ok(false, "interrupted fetch shouldn't have complete body"); + finish(); + }, + function() { + my_ok(true, "interrupted fetch shouldn't have complete body"); + finish(); + }) +}, function(e) { + my_ok(false, "interrupted fetch failed"); + finish(); +}); + +['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'].forEach(function(method) { + fetchXHRWithMethod('xhr-method-test.txt', method, function(xhr) { + my_ok(xhr.status == 200, method + " load should be successful"); + my_ok(xhr.responseText == ("intercepted " + method), method + " load should have synthesized response"); + finish(); + }); +}); + +expectAsyncResult(); +fetch(new Request('empty-header', {headers:{"emptyheader":""}})) +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == "emptyheader", "The empty header was observed in the fetch event"); + finish(); +}, function(err) { + my_ok(false, "A promise was rejected with " + err); + finish(); +}); + +expectAsyncResult(); +fetch('fetchevent-extendable') +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == "extendable", "FetchEvent inherits from ExtendableEvent"); + finish(); +}, function(err) { + my_ok(false, "A promise was rejected with " + err); + finish(); +}); + +expectAsyncResult(); +fetch('fetchevent-request') +.then(function(res) { + return res.text(); +}).then(function(body) { + my_ok(body == "non-nullable", "FetchEvent.request must be non-nullable"); + finish(); +}, function(err) { + my_ok(false, "A promise was rejected with " + err); + finish(); +}); diff --git a/dom/workers/test/serviceworkers/fetch/fetch_worker_script.js b/dom/workers/test/serviceworkers/fetch/fetch_worker_script.js new file mode 100644 index 000000000..61efb647c --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/fetch_worker_script.js @@ -0,0 +1,29 @@ +function my_ok(v, msg) { + postMessage({type: "ok", value: v, msg: msg}); +} + +function finish() { + postMessage('finish'); +} + +function expectAsyncResult() { + postMessage('expect'); +} + +expectAsyncResult(); +try { + var success = false; + importScripts("nonexistent_imported_script.js"); +} catch(x) { +} + +my_ok(success, "worker imported script should be intercepted"); +finish(); + +function check_intercepted_script() { + success = true; +} + +importScripts('fetch_tests.js') + +finish(); //corresponds to the gExpected increment before creating this worker diff --git a/dom/workers/test/serviceworkers/fetch/hsts/embedder.html b/dom/workers/test/serviceworkers/fetch/hsts/embedder.html new file mode 100644 index 000000000..c98555423 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/embedder.html @@ -0,0 +1,7 @@ +<!DOCTYPE html> +<script> + window.onmessage = function(e) { + window.parent.postMessage(e.data, "*"); + }; +</script> +<iframe src="http://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/index.html"></iframe> diff --git a/dom/workers/test/serviceworkers/fetch/hsts/hsts_test.js b/dom/workers/test/serviceworkers/fetch/hsts/hsts_test.js new file mode 100644 index 000000000..ab54164ed --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/hsts_test.js @@ -0,0 +1,11 @@ +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + event.respondWith(fetch("realindex.html")); + } else if (event.request.url.indexOf("image-20px.png") >= 0) { + if (event.request.url.indexOf("https://") == 0) { + event.respondWith(fetch("image-40px.png")); + } else { + event.respondWith(Response.error()); + } + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/hsts/image-20px.png b/dom/workers/test/serviceworkers/fetch/hsts/image-20px.png Binary files differnew file mode 100644 index 000000000..ae6a8a6b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/image-20px.png diff --git a/dom/workers/test/serviceworkers/fetch/hsts/image-40px.png b/dom/workers/test/serviceworkers/fetch/hsts/image-40px.png Binary files differnew file mode 100644 index 000000000..fe391dc8a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/image-40px.png diff --git a/dom/workers/test/serviceworkers/fetch/hsts/image.html b/dom/workers/test/serviceworkers/fetch/hsts/image.html new file mode 100644 index 000000000..cadbdef5a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/image.html @@ -0,0 +1,13 @@ +<!DOCTYPE html> +<script> +onload=function(){ + var img = new Image(); + img.src = "http://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/image-20px.png"; + img.onload = function() { + window.parent.postMessage({status: "image", data: img.width}, "*"); + }; + img.onerror = function() { + window.parent.postMessage({status: "image", data: "error"}, "*"); + }; +}; +</script> diff --git a/dom/workers/test/serviceworkers/fetch/hsts/realindex.html b/dom/workers/test/serviceworkers/fetch/hsts/realindex.html new file mode 100644 index 000000000..b3d1d527e --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/realindex.html @@ -0,0 +1,8 @@ +<!DOCTYPE html> +<script> + var securityInfoPresent = !!SpecialPowers.wrap(document).docShell.currentDocumentChannel.securityInfo; + window.parent.postMessage({status: "protocol", + data: location.protocol, + securityInfoPresent: securityInfoPresent}, + "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/hsts/register.html b/dom/workers/test/serviceworkers/fetch/hsts/register.html new file mode 100644 index 000000000..bcdc146ae --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("hsts_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/hsts/register.html^headers^ b/dom/workers/test/serviceworkers/fetch/hsts/register.html^headers^ new file mode 100644 index 000000000..a46bf65bd --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/register.html^headers^ @@ -0,0 +1,2 @@ +Cache-Control: no-cache +Strict-Transport-Security: max-age=60 diff --git a/dom/workers/test/serviceworkers/fetch/hsts/unregister.html b/dom/workers/test/serviceworkers/fetch/hsts/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/hsts/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/clonedresponse/https_test.js b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/https_test.js new file mode 100644 index 000000000..48f7b9307 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/https_test.js @@ -0,0 +1,15 @@ +self.addEventListener("install", function(event) { + event.waitUntil(caches.open("cache").then(function(cache) { + return cache.add("index.html"); + })); +}); + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + event.respondWith(new Promise(function(resolve, reject) { + caches.match(event.request).then(function(response) { + resolve(response.clone()); + }); + })); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/https/clonedresponse/index.html b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/index.html new file mode 100644 index 000000000..a43554844 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/index.html @@ -0,0 +1,4 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/clonedresponse/register.html b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/register.html new file mode 100644 index 000000000..41774f70d --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("https_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/clonedresponse/unregister.html b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/clonedresponse/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/https_test.js b/dom/workers/test/serviceworkers/fetch/https/https_test.js new file mode 100644 index 000000000..6f87bb5ee --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/https_test.js @@ -0,0 +1,23 @@ +self.addEventListener("install", function(event) { + event.waitUntil(caches.open("cache").then(function(cache) { + var synth = new Response('<!DOCTYPE html><script>window.parent.postMessage({status: "done-synth-sw"}, "*");</script>', + {headers:{"Content-Type": "text/html"}}); + return Promise.all([ + cache.add("index.html"), + cache.put("synth-sw.html", synth), + ]); + })); +}); + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + event.respondWith(caches.match(event.request)); + } else if (event.request.url.indexOf("synth-sw.html") >= 0) { + event.respondWith(caches.match(event.request)); + } else if (event.request.url.indexOf("synth-window.html") >= 0) { + event.respondWith(caches.match(event.request)); + } else if (event.request.url.indexOf("synth.html") >= 0) { + event.respondWith(new Response('<!DOCTYPE html><script>window.parent.postMessage({status: "done-synth"}, "*");</script>', + {headers:{"Content-Type": "text/html"}})); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/https/index.html b/dom/workers/test/serviceworkers/fetch/https/index.html new file mode 100644 index 000000000..a43554844 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/index.html @@ -0,0 +1,4 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/register.html b/dom/workers/test/serviceworkers/fetch/https/register.html new file mode 100644 index 000000000..fa666fe95 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/register.html @@ -0,0 +1,20 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(reg => { + return window.caches.open("cache").then(function(cache) { + var synth = new Response('<!DOCTYPE html><script>window.parent.postMessage({status: "done-synth-window"}, "*");</scri' + 'pt>', + {headers:{"Content-Type": "text/html"}}); + return cache.put('synth-window.html', synth).then(_ => done(reg)); + }); + }); + navigator.serviceWorker.register("https_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/https/unregister.html b/dom/workers/test/serviceworkers/fetch/https/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/https/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-20px.png b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-20px.png Binary files differnew file mode 100644 index 000000000..ae6a8a6b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-20px.png diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-40px.png b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-40px.png Binary files differnew file mode 100644 index 000000000..fe391dc8a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/image-40px.png diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/index.html b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/index.html new file mode 100644 index 000000000..426c27a73 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/index.html @@ -0,0 +1,29 @@ +<!DOCTYPE html> +<script> +var width, url, width2, url2; +function maybeReport() { + if (width !== undefined && url !== undefined && + width2 !== undefined && url2 !== undefined) { + window.parent.postMessage({status: "result", + width: width, + width2: width2, + url: url, + url2: url2}, "*"); + } +} +onload = function() { + width = document.querySelector("img").width; + width2 = document.querySelector("img").width; + maybeReport(); +}; +navigator.serviceWorker.onmessage = function(event) { + if (event.data.suffix == "2") { + url2 = event.data.url; + } else { + url = event.data.url; + } + maybeReport(); +}; +</script> +<img src="image.png"> +<img src="image2.png"> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/maxage_test.js b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/maxage_test.js new file mode 100644 index 000000000..1922111df --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/maxage_test.js @@ -0,0 +1,41 @@ +function synthesizeImage(suffix) { + // Serve image-20px for the first page, and image-40px for the second page. + return clients.matchAll().then(clients => { + var url = "image-20px.png"; + clients.forEach(client => { + if (client.url.indexOf("?new") > 0) { + url = "image-40px.png"; + } + client.postMessage({suffix: suffix, url: url}); + }); + return fetch(url); + }).then(response => { + return response.arrayBuffer(); + }).then(ab => { + var headers; + if (suffix == "") { + headers = { + "Content-Type": "image/png", + "Date": "Tue, 1 Jan 1990 01:02:03 GMT", + "Cache-Control": "max-age=1", + }; + } else { + headers = { + "Content-Type": "image/png", + "Cache-Control": "no-cache", + }; + } + return new Response(ab, { + status: 200, + headers: headers, + }); + }); +} + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("image.png") >= 0) { + event.respondWith(synthesizeImage("")); + } else if (event.request.url.indexOf("image2.png") >= 0) { + event.respondWith(synthesizeImage("2")); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/register.html b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/register.html new file mode 100644 index 000000000..af4dde2e2 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("maxage_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache-maxage/unregister.html b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache-maxage/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/image-20px.png b/dom/workers/test/serviceworkers/fetch/imagecache/image-20px.png Binary files differnew file mode 100644 index 000000000..ae6a8a6b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/image-20px.png diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/image-40px.png b/dom/workers/test/serviceworkers/fetch/imagecache/image-40px.png Binary files differnew file mode 100644 index 000000000..fe391dc8a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/image-40px.png diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/imagecache_test.js b/dom/workers/test/serviceworkers/fetch/imagecache/imagecache_test.js new file mode 100644 index 000000000..598d8213f --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/imagecache_test.js @@ -0,0 +1,15 @@ +function synthesizeImage() { + return clients.matchAll().then(clients => { + var url = "image-40px.png"; + clients.forEach(client => { + client.postMessage(url); + }); + return fetch(url); + }); +} + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("image-20px.png") >= 0) { + event.respondWith(synthesizeImage()); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/index.html b/dom/workers/test/serviceworkers/fetch/imagecache/index.html new file mode 100644 index 000000000..93b30f184 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/index.html @@ -0,0 +1,20 @@ +<!DOCTYPE html> +<script> +var width, url; +function maybeReport() { + if (width !== undefined && url !== undefined) { + window.parent.postMessage({status: "result", + width: width, + url: url}, "*"); + } +} +onload = function() { + width = document.querySelector("img").width; + maybeReport(); +}; +navigator.serviceWorker.onmessage = function(event) { + url = event.data; + maybeReport(); +}; +</script> +<img src="image-20px.png"> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/postmortem.html b/dom/workers/test/serviceworkers/fetch/imagecache/postmortem.html new file mode 100644 index 000000000..72a650d26 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/postmortem.html @@ -0,0 +1,9 @@ +<!DOCTYPE html> +<script> +onload = function() { + var width = document.querySelector("img").width; + window.parent.postMessage({status: "postmortem", + width: width}, "*"); +}; +</script> +<img src="image-20px.png"> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/register.html b/dom/workers/test/serviceworkers/fetch/imagecache/register.html new file mode 100644 index 000000000..f6d1eb382 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/register.html @@ -0,0 +1,16 @@ +<!DOCTYPE html> +<!-- Load the image here to put it in the image cache --> +<img src="image-20px.png"> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("imagecache_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/imagecache/unregister.html b/dom/workers/test/serviceworkers/fetch/imagecache/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/imagecache/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/https_test.js b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/https_test.js new file mode 100644 index 000000000..0f08ba74e --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/https_test.js @@ -0,0 +1,28 @@ +function sendResponseToParent(response) { + return ` + <!DOCTYPE html> + <script> + window.parent.postMessage({status: "done", data: "${response}"}, "*"); + </script> + `; +} + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + var response = "good"; + try { + importScripts("http://example.org/tests/dom/workers/test/foreign.js"); + } catch(e) { + dump("Got error " + e + " when importing the script\n"); + } + if (response === "good") { + try { + importScripts("/tests/dom/workers/test/redirect_to_foreign.sjs"); + } catch(e) { + dump("Got error " + e + " when importing the script\n"); + } + } + event.respondWith(new Response(sendResponseToParent(response), + {headers: {'Content-Type': 'text/html'}})); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/register.html b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/register.html new file mode 100644 index 000000000..41774f70d --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("https_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/unregister.html b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/index.html b/dom/workers/test/serviceworkers/fetch/index.html new file mode 100644 index 000000000..4db0fb139 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/index.html @@ -0,0 +1,183 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 94048 - test install event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<div id="style-test" style="background-color: white"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + function my_ok(result, msg) { + window.opener.postMessage({status: "ok", result: result, message: msg}, "*"); + } + + function check_intercepted_script() { + document.getElementById('intercepted-script').test_result = + document.currentScript == document.getElementById('intercepted-script'); + } + + function fetchXHR(name, onload, onerror, headers) { + gExpected++; + + onload = onload || function() { + my_ok(false, "load should not complete successfully"); + finish(); + }; + onerror = onerror || function() { + my_ok(false, "load should be intercepted successfully"); + finish(); + }; + + var x = new XMLHttpRequest(); + x.open('GET', name, true); + x.onload = function() { onload(x) }; + x.onerror = function() { onerror(x) }; + headers = headers || []; + headers.forEach(function(header) { + x.setRequestHeader(header[0], header[1]); + }); + x.send(); + } + + var gExpected = 0; + var gEncountered = 0; + function finish() { + gEncountered++; + if (gEncountered == gExpected) { + window.opener.postMessage({status: "done"}, "*"); + } + } + + function test_onload(creator, complete) { + gExpected++; + var elem = creator(); + elem.onload = function() { + complete.call(elem); + finish(); + }; + elem.onerror = function() { + my_ok(false, elem.tagName + " load should complete successfully"); + finish(); + }; + document.body.appendChild(elem); + } + + function expectAsyncResult() { + gExpected++; + } + + my_ok(navigator.serviceWorker.controller != null, "should be controlled"); +</script> +<script src="fetch_tests.js"></script> +<script> + test_onload(function() { + var elem = document.createElement('img'); + elem.src = "nonexistent_image.gifs"; + elem.id = 'intercepted-img'; + return elem; + }, function() { + my_ok(this.complete, "image should be complete"); + my_ok(this.naturalWidth == 1 && this.naturalHeight == 1, "image should be 1x1 gif"); + }); + + test_onload(function() { + var elem = document.createElement('script'); + elem.id = 'intercepted-script'; + elem.src = "nonexistent_script.js"; + return elem; + }, function() { + my_ok(this.test_result, "script load should be intercepted"); + }); + + test_onload(function() { + var elem = document.createElement('link'); + elem.href = "nonexistent_stylesheet.css"; + elem.rel = "stylesheet"; + return elem; + }, function() { + var styled = document.getElementById('style-test'); + my_ok(window.getComputedStyle(styled).backgroundColor == 'rgb(0, 0, 0)', + "stylesheet load should be intercepted"); + }); + + test_onload(function() { + var elem = document.createElement('iframe'); + elem.id = 'intercepted-iframe'; + elem.src = "nonexistent_page.html"; + return elem; + }, function() { + my_ok(this.test_result, "iframe load should be intercepted"); + }); + + test_onload(function() { + var elem = document.createElement('iframe'); + elem.id = 'intercepted-iframe-2'; + elem.src = "navigate.html"; + return elem; + }, function() { + my_ok(this.test_result, "iframe should successfully load"); + }); + + gExpected++; + var xmlDoc = document.implementation.createDocument(null, null, null); + xmlDoc.load('load_cross_origin_xml_document_synthetic.xml'); + xmlDoc.onload = function(evt) { + var content = new XMLSerializer().serializeToString(evt.target); + my_ok(!content.includes('parsererror'), "Load synthetic cross origin XML Document should be allowed"); + finish(); + }; + + gExpected++; + var xmlDoc = document.implementation.createDocument(null, null, null); + xmlDoc.load('load_cross_origin_xml_document_cors.xml'); + xmlDoc.onload = function(evt) { + var content = new XMLSerializer().serializeToString(evt.target); + my_ok(!content.includes('parsererror'), "Load CORS cross origin XML Document should be allowed"); + finish(); + }; + + gExpected++; + var xmlDoc = document.implementation.createDocument(null, null, null); + xmlDoc.load('load_cross_origin_xml_document_opaque.xml'); + xmlDoc.onload = function(evt) { + var content = new XMLSerializer().serializeToString(evt.target); + my_ok(content.includes('parsererror'), "Load opaque cross origin XML Document should not be allowed"); + finish(); + }; + + gExpected++; + var worker = new Worker('nonexistent_worker_script.js'); + worker.onmessage = function(e) { + my_ok(e.data == "worker-intercept-success", "worker load intercepted"); + finish(); + }; + worker.onerror = function() { + my_ok(false, "worker load should be intercepted"); + }; + + gExpected++; + var worker = new Worker('fetch_worker_script.js'); + worker.onmessage = function(e) { + if (e.data == "finish") { + finish(); + } else if (e.data == "expect") { + gExpected++; + } else if (e.data.type == "ok") { + my_ok(e.data.value, "Fetch test on worker: " + e.data.msg); + } + }; + worker.onerror = function() { + my_ok(false, "worker should not cause any errors"); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/fetch/interrupt.sjs b/dom/workers/test/serviceworkers/fetch/interrupt.sjs new file mode 100644 index 000000000..f6fe870ef --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/interrupt.sjs @@ -0,0 +1,20 @@ +function handleRequest(request, response) { + var body = "a"; + for (var i = 0; i < 20; i++) { + body += body; + } + + response.seizePower(); + response.write("HTTP/1.1 200 OK\r\n") + var count = 10; + response.write("Content-Length: " + body.length * count + "\r\n"); + response.write("Content-Type: text/plain; charset=utf-8\r\n"); + response.write("Cache-Control: no-cache, must-revalidate\r\n"); + response.write("\r\n"); + + for (var i = 0; i < count; i++) { + response.write(body); + } + + throw Components.results.NS_BINDING_ABORTED; +} diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/index-https.sjs b/dom/workers/test/serviceworkers/fetch/origin/https/index-https.sjs new file mode 100644 index 000000000..7266925ea --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/index-https.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine(null, 308, "Permanent Redirect"); + response.setHeader("Location", "https://example.org/tests/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html", false); +} diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/origin_test.js b/dom/workers/test/serviceworkers/fetch/origin/https/origin_test.js new file mode 100644 index 000000000..9839fc5f0 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/origin_test.js @@ -0,0 +1,29 @@ +var prefix = "/tests/dom/workers/test/serviceworkers/fetch/origin/https/"; + +function addOpaqueRedirect(cache, file) { + return fetch(new Request(prefix + file, { redirect: "manual" })).then(function(response) { + return cache.put(prefix + file, response); + }); +} + +self.addEventListener("install", function(event) { + event.waitUntil( + self.caches.open("origin-cache") + .then(c => { + return addOpaqueRedirect(c, 'index-https.sjs'); + }) + ); +}); + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index-cached-https.sjs") >= 0) { + event.respondWith( + self.caches.open("origin-cache") + .then(c => { + return c.match(prefix + 'index-https.sjs'); + }) + ); + } else { + event.respondWith(fetch(event.request)); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html b/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html new file mode 100644 index 000000000..87f348945 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html @@ -0,0 +1,6 @@ +<!DOCTYPE html> +<script> + window.opener.postMessage({status: "domain", data: document.domain}, "*"); + window.opener.postMessage({status: "origin", data: location.origin}, "*"); + window.opener.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html^headers^ b/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html^headers^ new file mode 100644 index 000000000..5ed82fd06 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/realindex.html^headers^ @@ -0,0 +1 @@ +Access-Control-Allow-Origin: https://example.com diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/register.html b/dom/workers/test/serviceworkers/fetch/origin/https/register.html new file mode 100644 index 000000000..2e99adba5 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("origin_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/origin/https/unregister.html b/dom/workers/test/serviceworkers/fetch/origin/https/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/https/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/origin/index-to-https.sjs b/dom/workers/test/serviceworkers/fetch/origin/index-to-https.sjs new file mode 100644 index 000000000..1cc916ff3 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/index-to-https.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine(null, 308, "Permanent Redirect"); + response.setHeader("Location", "https://example.org/tests/dom/workers/test/serviceworkers/fetch/origin/realindex.html", false); +} diff --git a/dom/workers/test/serviceworkers/fetch/origin/index.sjs b/dom/workers/test/serviceworkers/fetch/origin/index.sjs new file mode 100644 index 000000000..a79588e76 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/index.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine(null, 308, "Permanent Redirect"); + response.setHeader("Location", "http://example.org/tests/dom/workers/test/serviceworkers/fetch/origin/realindex.html", false); +} diff --git a/dom/workers/test/serviceworkers/fetch/origin/origin_test.js b/dom/workers/test/serviceworkers/fetch/origin/origin_test.js new file mode 100644 index 000000000..d2be9573b --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/origin_test.js @@ -0,0 +1,41 @@ +var prefix = "/tests/dom/workers/test/serviceworkers/fetch/origin/"; + +function addOpaqueRedirect(cache, file) { + return fetch(new Request(prefix + file, { redirect: "manual" })).then(function(response) { + return cache.put(prefix + file, response); + }); +} + +self.addEventListener("install", function(event) { + event.waitUntil( + self.caches.open("origin-cache") + .then(c => { + return Promise.all( + [ + addOpaqueRedirect(c, 'index.sjs'), + addOpaqueRedirect(c, 'index-to-https.sjs') + ] + ); + }) + ); +}); + +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index-cached.sjs") >= 0) { + event.respondWith( + self.caches.open("origin-cache") + .then(c => { + return c.match(prefix + 'index.sjs'); + }) + ); + } else if (event.request.url.indexOf("index-to-https-cached.sjs") >= 0) { + event.respondWith( + self.caches.open("origin-cache") + .then(c => { + return c.match(prefix + 'index-to-https.sjs'); + }) + ); + } else { + event.respondWith(fetch(event.request)); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/origin/realindex.html b/dom/workers/test/serviceworkers/fetch/origin/realindex.html new file mode 100644 index 000000000..87f348945 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/realindex.html @@ -0,0 +1,6 @@ +<!DOCTYPE html> +<script> + window.opener.postMessage({status: "domain", data: document.domain}, "*"); + window.opener.postMessage({status: "origin", data: location.origin}, "*"); + window.opener.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/origin/realindex.html^headers^ b/dom/workers/test/serviceworkers/fetch/origin/realindex.html^headers^ new file mode 100644 index 000000000..3a6a85d89 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/realindex.html^headers^ @@ -0,0 +1 @@ +Access-Control-Allow-Origin: http://mochi.test:8888 diff --git a/dom/workers/test/serviceworkers/fetch/origin/register.html b/dom/workers/test/serviceworkers/fetch/origin/register.html new file mode 100644 index 000000000..2e99adba5 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("origin_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/origin/unregister.html b/dom/workers/test/serviceworkers/fetch/origin/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/origin/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/plugin/plugins.html b/dom/workers/test/serviceworkers/fetch/plugin/plugins.html new file mode 100644 index 000000000..78e31b3c2 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/plugin/plugins.html @@ -0,0 +1,43 @@ +<!DOCTYPE html> +<script> + var obj, embed; + + function ok(v, msg) { + window.opener.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function finish() { + document.documentElement.removeChild(obj); + document.documentElement.removeChild(embed); + window.opener.postMessage({status: "done"}, "*"); + } + + function test_object() { + obj = document.createElement("object"); + obj.setAttribute('data', "object"); + document.documentElement.appendChild(obj); + } + + function test_embed() { + embed = document.createElement("embed"); + embed.setAttribute('src', "embed"); + document.documentElement.appendChild(embed); + } + + navigator.serviceWorker.addEventListener("message", function onMessage(e) { + if (e.data.context === "object") { + ok(false, "<object> should not be intercepted"); + } else if (e.data.context === "embed") { + ok(false, "<embed> should not be intercepted"); + } else if (e.data.context === "fetch" && e.data.resource === "foo.txt") { + navigator.serviceWorker.removeEventListener("message", onMessage); + finish(); + } + }, false); + + test_object(); + test_embed(); + // SW will definitely intercept fetch API, use this to see if plugins are + // intercepted before fetch(). + fetch("foo.txt"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/plugin/worker.js b/dom/workers/test/serviceworkers/fetch/plugin/worker.js new file mode 100644 index 000000000..e97d06205 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/plugin/worker.js @@ -0,0 +1,14 @@ +self.addEventListener("fetch", function(event) { + var resource = event.request.url.split('/').pop(); + event.waitUntil( + clients.matchAll() + .then(clients => { + clients.forEach(client => { + if (client.url.includes("plugins.html")) { + client.postMessage({context: event.request.context, + resource: resource}); + } + }); + }) + ); +}); diff --git a/dom/workers/test/serviceworkers/fetch/real-file.txt b/dom/workers/test/serviceworkers/fetch/real-file.txt new file mode 100644 index 000000000..3ca2088ec --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/real-file.txt @@ -0,0 +1 @@ +This is a real file. diff --git a/dom/workers/test/serviceworkers/fetch/redirect.sjs b/dom/workers/test/serviceworkers/fetch/redirect.sjs new file mode 100644 index 000000000..dab558f4a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/redirect.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine(request.httpVersion, 301, "Moved Permanently"); + response.setHeader("Location", "synthesized-redirect-twice-real-file.txt"); +} diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/index.html b/dom/workers/test/serviceworkers/fetch/requesturl/index.html new file mode 100644 index 000000000..bc3e400a9 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/index.html @@ -0,0 +1,7 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.onmessage = window.onmessage = e => { + window.parent.postMessage(e.data, "*"); + }; +</script> +<iframe src="redirector.html"></iframe> diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/redirect.sjs b/dom/workers/test/serviceworkers/fetch/requesturl/redirect.sjs new file mode 100644 index 000000000..7b92fec20 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/redirect.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine(null, 308, "Permanent Redirect"); + response.setHeader("Location", "http://example.org/tests/dom/workers/test/serviceworkers/fetch/requesturl/secret.html", false); +} diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/redirector.html b/dom/workers/test/serviceworkers/fetch/requesturl/redirector.html new file mode 100644 index 000000000..73bf4af49 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/redirector.html @@ -0,0 +1,2 @@ +<!DOCTYPE html> +<meta http-equiv="refresh" content="3;URL=/tests/dom/workers/test/serviceworkers/fetch/requesturl/redirect.sjs"> diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/register.html b/dom/workers/test/serviceworkers/fetch/requesturl/register.html new file mode 100644 index 000000000..19a2e022c --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("requesturl_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/requesturl_test.js b/dom/workers/test/serviceworkers/fetch/requesturl/requesturl_test.js new file mode 100644 index 000000000..c8be3daf4 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/requesturl_test.js @@ -0,0 +1,17 @@ +addEventListener("fetch", event => { + var url = event.request.url; + var badURL = url.indexOf("secret.html") > -1; + event.respondWith( + new Promise(resolve => { + clients.matchAll().then(clients => { + for (var client of clients) { + if (client.url.indexOf("index.html") > -1) { + client.postMessage({status: "ok", result: !badURL, message: "Should not find a bad URL (" + url + ")"}); + break; + } + } + resolve(fetch(event.request)); + }); + }) + ); +}); diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/secret.html b/dom/workers/test/serviceworkers/fetch/requesturl/secret.html new file mode 100644 index 000000000..694c33635 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/secret.html @@ -0,0 +1,5 @@ +<!DOCTYPE html> +secret stuff +<script> + window.parent.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/requesturl/unregister.html b/dom/workers/test/serviceworkers/fetch/requesturl/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/requesturl/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/sandbox/index.html b/dom/workers/test/serviceworkers/fetch/sandbox/index.html new file mode 100644 index 000000000..1094a3995 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/sandbox/index.html @@ -0,0 +1,5 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({status: "ok", result: true, message: "The iframe is not being intercepted"}, "*"); + window.parent.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/sandbox/intercepted_index.html b/dom/workers/test/serviceworkers/fetch/sandbox/intercepted_index.html new file mode 100644 index 000000000..87261a495 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/sandbox/intercepted_index.html @@ -0,0 +1,5 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({status: "ok", result: false, message: "The iframe is being intercepted"}, "*"); + window.parent.postMessage({status: "done"}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/sandbox/register.html b/dom/workers/test/serviceworkers/fetch/sandbox/register.html new file mode 100644 index 000000000..427b1a8da --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/sandbox/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("sandbox_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/sandbox/sandbox_test.js b/dom/workers/test/serviceworkers/fetch/sandbox/sandbox_test.js new file mode 100644 index 000000000..1ed351794 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/sandbox/sandbox_test.js @@ -0,0 +1,5 @@ +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + event.respondWith(fetch("intercepted_index.html")); + } +}); diff --git a/dom/workers/test/serviceworkers/fetch/sandbox/unregister.html b/dom/workers/test/serviceworkers/fetch/sandbox/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/sandbox/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html new file mode 100644 index 000000000..6098a45dd --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<script> + window.onmessage = function(e) { + window.parent.postMessage(e.data, "*"); + if (e.data.status == "protocol") { + document.querySelector("iframe").src = "image.html"; + } + }; +</script> +<iframe src="http://example.com/tests/dom/workers/test/serviceworkers/fetch/upgrade-insecure/index.html"></iframe> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html^headers^ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html^headers^ new file mode 100644 index 000000000..602d9dc38 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html^headers^ @@ -0,0 +1 @@ +Content-Security-Policy: upgrade-insecure-requests diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-20px.png b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-20px.png Binary files differnew file mode 100644 index 000000000..ae6a8a6b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-20px.png diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-40px.png b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-40px.png Binary files differnew file mode 100644 index 000000000..fe391dc8a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-40px.png diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image.html b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image.html new file mode 100644 index 000000000..34e24e35a --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image.html @@ -0,0 +1,13 @@ +<!DOCTYPE html> +<script> +onload=function(){ + var img = new Image(); + img.src = "http://example.com/tests/dom/workers/test/serviceworkers/fetch/upgrade-insecure/image-20px.png"; + img.onload = function() { + window.parent.postMessage({status: "image", data: img.width}, "*"); + }; + img.onerror = function() { + window.parent.postMessage({status: "image", data: "error"}, "*"); + }; +}; +</script> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/realindex.html b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/realindex.html new file mode 100644 index 000000000..aaa255aad --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/realindex.html @@ -0,0 +1,4 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({status: "protocol", data: location.protocol}, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/register.html b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/register.html new file mode 100644 index 000000000..6309b9b21 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/register.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + function done(reg) { + ok(reg.active, "The active worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("upgrade-insecure_test.js", {scope: "."}); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/unregister.html b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/unregister.html new file mode 100644 index 000000000..1f13508fa --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/fetch/upgrade-insecure/upgrade-insecure_test.js b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/upgrade-insecure_test.js new file mode 100644 index 000000000..ab54164ed --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch/upgrade-insecure/upgrade-insecure_test.js @@ -0,0 +1,11 @@ +self.addEventListener("fetch", function(event) { + if (event.request.url.indexOf("index.html") >= 0) { + event.respondWith(fetch("realindex.html")); + } else if (event.request.url.indexOf("image-20px.png") >= 0) { + if (event.request.url.indexOf("https://") == 0) { + event.respondWith(fetch("image-40px.png")); + } else { + event.respondWith(Response.error()); + } + } +}); diff --git a/dom/workers/test/serviceworkers/fetch_event_worker.js b/dom/workers/test/serviceworkers/fetch_event_worker.js new file mode 100644 index 000000000..1caef71e8 --- /dev/null +++ b/dom/workers/test/serviceworkers/fetch_event_worker.js @@ -0,0 +1,337 @@ +var seenIndex = false; + +onfetch = function(ev) { + if (ev.request.url.includes("ignore")) { + return; + } + + if (ev.request.url.includes("bare-synthesized.txt")) { + ev.respondWith(Promise.resolve( + new Response("synthesized response body", {}) + )); + } + + else if (ev.request.url.includes('file_CrossSiteXHR_server.sjs')) { + // N.B. this response would break the rules of CORS if it were allowed, but + // this test relies upon the preflight request not being intercepted and + // thus this response should not be used. + if (ev.request.method == 'OPTIONS') { + ev.respondWith(new Response('', {headers: {'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Headers': 'X-Unsafe'}})) + } else if (ev.request.url.includes('example.org')) { + ev.respondWith(fetch(ev.request)); + } + } + + else if (ev.request.url.includes("synthesized-404.txt")) { + ev.respondWith(Promise.resolve( + new Response("synthesized response body", { status: 404 }) + )); + } + + else if (ev.request.url.includes("synthesized-headers.txt")) { + ev.respondWith(Promise.resolve( + new Response("synthesized response body", { + headers: { + "X-Custom-Greeting": "Hello" + } + }) + )); + } + + else if (ev.request.url.includes("test-respondwith-response.txt")) { + ev.respondWith(new Response("test-respondwith-response response body", {})); + } + + else if (ev.request.url.includes("synthesized-redirect-real-file.txt")) { + ev.respondWith(Promise.resolve( + Response.redirect("fetch/real-file.txt") + )); + } + + else if (ev.request.url.includes("synthesized-redirect-twice-real-file.txt")) { + ev.respondWith(Promise.resolve( + Response.redirect("synthesized-redirect-real-file.txt") + )); + } + + else if (ev.request.url.includes("synthesized-redirect-synthesized.txt")) { + ev.respondWith(Promise.resolve( + Response.redirect("bare-synthesized.txt") + )); + } + + else if (ev.request.url.includes("synthesized-redirect-twice-synthesized.txt")) { + ev.respondWith(Promise.resolve( + Response.redirect("synthesized-redirect-synthesized.txt") + )); + } + + else if (ev.request.url.includes("rejected.txt")) { + ev.respondWith(Promise.reject()); + } + + else if (ev.request.url.includes("nonresponse.txt")) { + ev.respondWith(Promise.resolve(5)); + } + + else if (ev.request.url.includes("nonresponse2.txt")) { + ev.respondWith(Promise.resolve({})); + } + + else if (ev.request.url.includes("nonpromise.txt")) { + try { + // This should coerce to Promise(5) instead of throwing + ev.respondWith(5); + } catch (e) { + // test is expecting failure, so return a success if we get a thrown + // exception + ev.respondWith(new Response('respondWith(5) threw ' + e)); + } + } + + else if (ev.request.url.includes("headers.txt")) { + var ok = true; + ok &= ev.request.headers.get("X-Test1") == "header1"; + ok &= ev.request.headers.get("X-Test2") == "header2"; + ev.respondWith(Promise.resolve( + new Response(ok.toString(), {}) + )); + } + + else if (ev.request.url.includes('user-pass')) { + ev.respondWith(new Response(ev.request.url)); + } + + else if (ev.request.url.includes("nonexistent_image.gif")) { + var imageAsBinaryString = atob("R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs"); + var imageLength = imageAsBinaryString.length; + + // If we just pass |imageAsBinaryString| to the Response constructor, an + // encoding conversion occurs that corrupts the image. Instead, we need to + // convert it to a typed array. + // typed array. + var imageAsArray = new Uint8Array(imageLength); + for (var i = 0; i < imageLength; ++i) { + imageAsArray[i] = imageAsBinaryString.charCodeAt(i); + } + + ev.respondWith(Promise.resolve( + new Response(imageAsArray, { headers: { "Content-Type": "image/gif" } }) + )); + } + + else if (ev.request.url.includes("nonexistent_script.js")) { + ev.respondWith(Promise.resolve( + new Response("check_intercepted_script();", {}) + )); + } + + else if (ev.request.url.includes("nonexistent_stylesheet.css")) { + ev.respondWith(Promise.resolve( + new Response("#style-test { background-color: black !important; }", { + headers : { + "Content-Type": "text/css" + } + }) + )); + } + + else if (ev.request.url.includes("nonexistent_page.html")) { + ev.respondWith(Promise.resolve( + new Response("<script>window.frameElement.test_result = true;</script>", { + headers : { + "Content-Type": "text/html" + } + }) + )); + } + + else if (ev.request.url.includes("navigate.html")) { + var navigateModeCorrectlyChecked = false; + var requests = [ // should not throw + new Request(ev.request), + new Request(ev.request, undefined), + new Request(ev.request, null), + new Request(ev.request, {}), + new Request(ev.request, {someUnrelatedProperty: 42}), + ]; + try { + var request3 = new Request(ev.request, {method: "GET"}); // should throw + } catch(e) { + navigateModeCorrectlyChecked = requests[0].mode == "navigate"; + } + if (navigateModeCorrectlyChecked) { + ev.respondWith(Promise.resolve( + new Response("<script>window.frameElement.test_result = true;</script>", { + headers : { + "Content-Type": "text/html" + } + }) + )); + } + } + + else if (ev.request.url.includes("nonexistent_worker_script.js")) { + ev.respondWith(Promise.resolve( + new Response("postMessage('worker-intercept-success')", {}) + )); + } + + else if (ev.request.url.includes("nonexistent_imported_script.js")) { + ev.respondWith(Promise.resolve( + new Response("check_intercepted_script();", {}) + )); + } + + else if (ev.request.url.includes("deliver-gzip")) { + // Don't handle the request, this will make Necko perform a network request, at + // which point SetApplyConversion must be re-enabled, otherwise the request + // will fail. + return; + } + + else if (ev.request.url.includes("hello.gz")) { + ev.respondWith(fetch("fetch/deliver-gzip.sjs")); + } + + else if (ev.request.url.includes("hello-after-extracting.gz")) { + ev.respondWith(fetch("fetch/deliver-gzip.sjs").then(function(res) { + return res.text().then(function(body) { + return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers }); + }); + })); + } + + else if (ev.request.url.includes('opaque-on-same-origin')) { + var url = 'http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200'; + ev.respondWith(fetch(url, { mode: 'no-cors' })); + } + + else if (ev.request.url.includes('opaque-no-cors')) { + if (ev.request.mode != "no-cors") { + ev.respondWith(Promise.reject()); + return; + } + + var url = 'http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200'; + ev.respondWith(fetch(url, { mode: ev.request.mode })); + } + + else if (ev.request.url.includes('cors-for-no-cors')) { + if (ev.request.mode != "no-cors") { + ev.respondWith(Promise.reject()); + return; + } + + var url = 'http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*'; + ev.respondWith(fetch(url)); + } + + else if (ev.request.url.includes('example.com')) { + ev.respondWith(fetch(ev.request)); + } + + else if (ev.request.url.includes("index.html")) { + if (seenIndex) { + var body = "<script>" + + "opener.postMessage({status: 'ok', result: " + ev.isReload + "," + + "message: 'reload status should be indicated'}, '*');" + + "opener.postMessage({status: 'done'}, '*');" + + "</script>"; + ev.respondWith(new Response(body, {headers: {'Content-Type': 'text/html'}})); + } else { + seenIndex = true; + ev.respondWith(fetch(ev.request.url)); + } + } + + else if (ev.request.url.includes("body-")) { + ev.respondWith(ev.request.text().then(function (body) { + return new Response(body + body); + })); + } + + else if (ev.request.url.includes('something.txt')) { + ev.respondWith(Response.redirect('fetch/somethingelse.txt')); + } + + else if (ev.request.url.includes('somethingelse.txt')) { + ev.respondWith(new Response('something else response body', {})); + } + + else if (ev.request.url.includes('redirect_serviceworker.sjs')) { + // The redirect_serviceworker.sjs server-side JavaScript file redirects to + // 'http://mochi.test:8888/tests/dom/workers/test/serviceworkers/worker.js' + // The redirected fetch should not go through the SW since the original + // fetch was initiated from a SW. + ev.respondWith(fetch('redirect_serviceworker.sjs')); + } + + else if (ev.request.url.includes('load_cross_origin_xml_document_synthetic.xml')) { + if (ev.request.mode != 'same-origin') { + ev.respondWith(Promise.reject()); + return; + } + + ev.respondWith(Promise.resolve( + new Response("<response>body</response>", { headers: {'Content-Type': 'text/xtml'}}) + )); + } + + else if (ev.request.url.includes('load_cross_origin_xml_document_cors.xml')) { + if (ev.request.mode != 'same-origin') { + ev.respondWith(Promise.reject()); + return; + } + + var url = 'http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*'; + ev.respondWith(fetch(url, { mode: 'cors' })); + } + + else if (ev.request.url.includes('load_cross_origin_xml_document_opaque.xml')) { + if (ev.request.mode != 'same-origin') { + Promise.resolve( + new Response("<error>Invalid Request mode</error>", { headers: {'Content-Type': 'text/xtml'}}) + ); + return; + } + + var url = 'http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200'; + ev.respondWith(fetch(url, { mode: 'no-cors' })); + } + + else if (ev.request.url.includes('xhr-method-test.txt')) { + ev.respondWith(new Response('intercepted ' + ev.request.method)); + } + + else if (ev.request.url.includes('empty-header')) { + if (!ev.request.headers.has("emptyheader") || + ev.request.headers.get("emptyheader") !== "") { + ev.respondWith(Promise.reject()); + return; + } + ev.respondWith(new Response("emptyheader")); + } + + else if (ev.request.url.includes('fetchevent-extendable')) { + if (ev instanceof ExtendableEvent) { + ev.respondWith(new Response("extendable")); + } else { + ev.respondWith(Promise.reject()); + } + } + + else if (ev.request.url.includes('fetchevent-request')) { + var threw = false; + try { + new FetchEvent("foo"); + } catch(e) { + if (e.name == "TypeError") { + threw = true; + } + } finally { + ev.respondWith(new Response(threw ? "non-nullable" : "nullable")); + } + } +}; diff --git a/dom/workers/test/serviceworkers/file_blob_response_worker.js b/dom/workers/test/serviceworkers/file_blob_response_worker.js new file mode 100644 index 000000000..4b4379d0b --- /dev/null +++ b/dom/workers/test/serviceworkers/file_blob_response_worker.js @@ -0,0 +1,38 @@ +function makeFileBlob(obj) { + return new Promise(function(resolve, reject) { + var request = indexedDB.open('file_blob_response_worker', 1); + request.onerror = reject; + request.onupgradeneeded = function(evt) { + var db = evt.target.result; + db.onerror = reject; + + var objectStore = db.createObjectStore('test', { autoIncrement: true }); + var index = objectStore.createIndex('test', 'index'); + }; + + request.onsuccess = function(evt) { + var db = evt.target.result; + db.onerror = reject; + + var blob = new Blob([JSON.stringify(obj)], + { type: 'application/json' }); + var data = { blob: blob, index: 5 }; + + objectStore = db.transaction('test', 'readwrite').objectStore('test'); + objectStore.add(data).onsuccess = function(evt) { + var key = evt.target.result; + objectStore = db.transaction('test').objectStore('test'); + objectStore.get(key).onsuccess = function(evt) { + resolve(evt.target.result.blob); + }; + }; + }; + }); +} + +self.addEventListener('fetch', function(evt) { + var result = { value: 'success' }; + evt.respondWith(makeFileBlob(result).then(function(blob) { + return new Response(blob) + })); +}); diff --git a/dom/workers/test/serviceworkers/force_refresh_browser_worker.js b/dom/workers/test/serviceworkers/force_refresh_browser_worker.js new file mode 100644 index 000000000..96d9d0f17 --- /dev/null +++ b/dom/workers/test/serviceworkers/force_refresh_browser_worker.js @@ -0,0 +1,34 @@ +var name = 'browserRefresherCache'; + +self.addEventListener('install', function(event) { + event.waitUntil( + Promise.all([caches.open(name), + fetch('./browser_cached_force_refresh.html')]).then(function(results) { + var cache = results[0]; + var response = results[1]; + return cache.put('./browser_base_force_refresh.html', response); + }) + ); +}); + +self.addEventListener('fetch', function (event) { + event.respondWith( + caches.open(name).then(function(cache) { + return cache.match(event.request); + }).then(function(response) { + return response || fetch(event.request); + }) + ); +}); + +self.addEventListener('message', function (event) { + if (event.data.type === 'GET_UNCONTROLLED_CLIENTS') { + event.waitUntil(clients.matchAll({ includeUncontrolled: true }) + .then(function(clientList) { + var resultList = clientList.map(function(c) { + return { url: c.url, frameType: c.frameType }; + }); + event.source.postMessage({ type: 'CLIENTS', detail: resultList }); + })); + } +}); diff --git a/dom/workers/test/serviceworkers/force_refresh_worker.js b/dom/workers/test/serviceworkers/force_refresh_worker.js new file mode 100644 index 000000000..f0752d0cb --- /dev/null +++ b/dom/workers/test/serviceworkers/force_refresh_worker.js @@ -0,0 +1,33 @@ +var name = 'refresherCache'; + +self.addEventListener('install', function(event) { + event.waitUntil( + Promise.all([caches.open(name), + fetch('./sw_clients/refresher_cached.html'), + fetch('./sw_clients/refresher_cached_compressed.html')]).then(function(results) { + var cache = results[0]; + var response = results[1]; + var compressed = results[2]; + return Promise.all([cache.put('./sw_clients/refresher.html', response), + cache.put('./sw_clients/refresher_compressed.html', compressed)]); + }) + ); +}); + +self.addEventListener('fetch', function (event) { + event.respondWith( + caches.open(name).then(function(cache) { + return cache.match(event.request); + }).then(function(response) { + // If this is one of our primary cached responses, then the window + // must have generated the request via a normal window reload. That + // should be detectable in the event.request.cache attribute. + if (response && event.request.cache !== 'no-cache') { + dump('### ### FetchEvent.request.cache is "' + event.request.cache + + '" instead of expected "no-cache"\n'); + return Response.error(); + } + return response || fetch(event.request); + }) + ); +}); diff --git a/dom/workers/test/serviceworkers/gzip_redirect_worker.js b/dom/workers/test/serviceworkers/gzip_redirect_worker.js new file mode 100644 index 000000000..72aeba222 --- /dev/null +++ b/dom/workers/test/serviceworkers/gzip_redirect_worker.js @@ -0,0 +1,13 @@ +self.addEventListener('fetch', function (event) { + if (!event.request.url.endsWith('sw_clients/does_not_exist.html')) { + return; + } + + event.respondWith(new Response('', { + status: 301, + statusText: 'Moved Permanently', + headers: { + 'Location': 'refresher_compressed.html' + } + })); +}); diff --git a/dom/workers/test/serviceworkers/header_checker.sjs b/dom/workers/test/serviceworkers/header_checker.sjs new file mode 100644 index 000000000..706104103 --- /dev/null +++ b/dom/workers/test/serviceworkers/header_checker.sjs @@ -0,0 +1,9 @@ +function handleRequest(request, response) { + if (request.getHeader("Service-Worker") === "script") { + response.setStatusLine("1.1", 200, "OK"); + response.setHeader("Content-Type", "text/javascript"); + response.write("// empty"); + } else { + response.setStatusLine("1.1", 404, "Not Found"); + } +} diff --git a/dom/workers/test/serviceworkers/hello.html b/dom/workers/test/serviceworkers/hello.html new file mode 100644 index 000000000..97eb03c90 --- /dev/null +++ b/dom/workers/test/serviceworkers/hello.html @@ -0,0 +1,9 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + </head> + <body> + Hello. + </body> +<html> diff --git a/dom/workers/test/serviceworkers/importscript.sjs b/dom/workers/test/serviceworkers/importscript.sjs new file mode 100644 index 000000000..6d177a734 --- /dev/null +++ b/dom/workers/test/serviceworkers/importscript.sjs @@ -0,0 +1,11 @@ +function handleRequest(request, response) { + if (request.queryString == 'clearcounter') { + setState('counter', ''); + } else if (!getState('counter')) { + response.setHeader("Content-Type", "application/javascript", false); + response.write("callByScript();"); + setState('counter', '1'); + } else { + response.write("no cache no party!"); + } +} diff --git a/dom/workers/test/serviceworkers/importscript_worker.js b/dom/workers/test/serviceworkers/importscript_worker.js new file mode 100644 index 000000000..3cddec194 --- /dev/null +++ b/dom/workers/test/serviceworkers/importscript_worker.js @@ -0,0 +1,37 @@ +var counter = 0; +function callByScript() { + ++counter; +} + +// Use multiple scripts in this load to verify we support that case correctly. +// See bug 1249351 for a case where we broke this. +importScripts('lorem_script.js', 'importscript.sjs'); + +importScripts('importscript.sjs'); + +var missingScriptFailed = false; +try { + importScripts(['there-is-nothing-here.js']); +} catch(e) { + missingScriptFailed = true; +} + +onmessage = function(e) { + self.clients.matchAll().then(function(res) { + if (!res.length) { + dump("ERROR: no clients are currently controlled.\n"); + } + + if (!missingScriptFailed) { + res[0].postMessage("KO"); + } + + try { + importScripts(['importscript.sjs']); + res[0].postMessage("KO"); + return; + } catch(e) {} + + res[0].postMessage(counter == 2 ? "OK" : "KO"); + }); +}; diff --git a/dom/workers/test/serviceworkers/install_event_error_worker.js b/dom/workers/test/serviceworkers/install_event_error_worker.js new file mode 100644 index 000000000..c06d648b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/install_event_error_worker.js @@ -0,0 +1,4 @@ +// Worker that errors on receiving an install event. +oninstall = function(e) { + undefined.doSomething; +}; diff --git a/dom/workers/test/serviceworkers/install_event_worker.js b/dom/workers/test/serviceworkers/install_event_worker.js new file mode 100644 index 000000000..f965d28aa --- /dev/null +++ b/dom/workers/test/serviceworkers/install_event_worker.js @@ -0,0 +1,3 @@ +oninstall = function(e) { + dump("Got install event\n"); +} diff --git a/dom/workers/test/serviceworkers/lorem_script.js b/dom/workers/test/serviceworkers/lorem_script.js new file mode 100644 index 000000000..5502a44da --- /dev/null +++ b/dom/workers/test/serviceworkers/lorem_script.js @@ -0,0 +1,8 @@ +var lorem_str = ` +Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor +incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis +nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo +consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum +dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, +sunt in culpa qui officia deserunt mollit anim id est laborum. +` diff --git a/dom/workers/test/serviceworkers/match_all_advanced_worker.js b/dom/workers/test/serviceworkers/match_all_advanced_worker.js new file mode 100644 index 000000000..3721aedfe --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_advanced_worker.js @@ -0,0 +1,5 @@ +onmessage = function(e) { + self.clients.matchAll().then(function(clients) { + e.source.postMessage(clients.length); + }); +} diff --git a/dom/workers/test/serviceworkers/match_all_client/match_all_client_id.html b/dom/workers/test/serviceworkers/match_all_client/match_all_client_id.html new file mode 100644 index 000000000..7ac6fc9d0 --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_client/match_all_client_id.html @@ -0,0 +1,31 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1139425 - controlled page</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + window.onload = function() { + navigator.serviceWorker.ready.then(function(swr) { + swr.active.postMessage("Start"); + }); + } + + navigator.serviceWorker.onmessage = function(msg) { + // worker message; + testWindow.postMessage(msg.data, "*"); + window.close(); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/match_all_client_id_worker.js b/dom/workers/test/serviceworkers/match_all_client_id_worker.js new file mode 100644 index 000000000..a7d9ff594 --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_client_id_worker.js @@ -0,0 +1,28 @@ +onmessage = function(e) { + dump("MatchAllClientIdWorker:" + e.data + "\n"); + var id = []; + var iterations = 5; + var counter = 0; + + for (var i = 0; i < iterations; i++) { + self.clients.matchAll().then(function(res) { + if (!res.length) { + dump("ERROR: no clients are currently controlled.\n"); + } + + client = res[0]; + id[counter] = client.id; + counter++; + if (counter >= iterations) { + var response = true; + for (var index = 1; index < iterations; index++) { + if (id[0] != id[index]) { + response = false; + break; + } + } + client.postMessage(response); + } + }); + } +} diff --git a/dom/workers/test/serviceworkers/match_all_clients/match_all_controlled.html b/dom/workers/test/serviceworkers/match_all_clients/match_all_controlled.html new file mode 100644 index 000000000..25317b9fc --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_clients/match_all_controlled.html @@ -0,0 +1,65 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1058311 - controlled page</title> +<script class="testbody" type="text/javascript"> + var re = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/; + var frameType = "none"; + var testWindow = parent; + + if (parent != window) { + frameType = "nested"; + } else if (opener) { + frameType = "auxiliary"; + testWindow = opener; + } else if (parent != window) { + frameType = "top-level"; + } else { + postResult(false, "Unexpected frameType"); + } + + window.onload = function() { + navigator.serviceWorker.ready.then(function(swr) { + swr.active.postMessage("Start"); + }); + } + + function postResult(result, msg) { + response = { + result: result, + message: msg + }; + + testWindow.postMessage(response, "*"); + } + + navigator.serviceWorker.onmessage = function(msg) { + // worker message; + result = re.test(msg.data.id); + postResult(result, "Client id test"); + + result = msg.data.url == window.location; + postResult(result, "Client url test"); + + result = msg.data.visibilityState === document.visibilityState; + postResult(result, "Client visibility test. expected=" +document.visibilityState); + + result = msg.data.focused === document.hasFocus(); + postResult(result, "Client focus test. expected=" + document.hasFocus()); + + result = msg.data.frameType === frameType; + postResult(result, "Client frameType test. expected=" + frameType); + + postResult(true, "DONE"); + window.close(); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/match_all_properties_worker.js b/dom/workers/test/serviceworkers/match_all_properties_worker.js new file mode 100644 index 000000000..f007a5ce8 --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_properties_worker.js @@ -0,0 +1,20 @@ +onmessage = function(e) { + dump("MatchAllPropertiesWorker:" + e.data + "\n"); + self.clients.matchAll().then(function(res) { + if (!res.length) { + dump("ERROR: no clients are currently controlled.\n"); + } + + for (i = 0; i < res.length; i++) { + client = res[i]; + response = { + id: client.id, + url: client.url, + visibilityState: client.visibilityState, + focused: client.focused, + frameType: client.frameType + }; + client.postMessage(response); + } + }); +} diff --git a/dom/workers/test/serviceworkers/match_all_worker.js b/dom/workers/test/serviceworkers/match_all_worker.js new file mode 100644 index 000000000..9d1c8c363 --- /dev/null +++ b/dom/workers/test/serviceworkers/match_all_worker.js @@ -0,0 +1,10 @@ +function loop() { + self.clients.matchAll().then(function(result) { + setTimeout(loop, 0); + }); +} + +onactivate = function(e) { + // spam matchAll until the worker is closed. + loop(); +} diff --git a/dom/workers/test/serviceworkers/message_posting_worker.js b/dom/workers/test/serviceworkers/message_posting_worker.js new file mode 100644 index 000000000..26db99775 --- /dev/null +++ b/dom/workers/test/serviceworkers/message_posting_worker.js @@ -0,0 +1,8 @@ +onmessage = function(e) { + self.clients.matchAll().then(function(res) { + if (!res.length) { + dump("ERROR: no clients are currently controlled.\n"); + } + res[0].postMessage(e.data); + }); +}; diff --git a/dom/workers/test/serviceworkers/message_receiver.html b/dom/workers/test/serviceworkers/message_receiver.html new file mode 100644 index 000000000..82cb587c7 --- /dev/null +++ b/dom/workers/test/serviceworkers/message_receiver.html @@ -0,0 +1,6 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.onmessage = function(e) { + window.parent.postMessage(e.data, "*"); + }; +</script> diff --git a/dom/workers/test/serviceworkers/mochitest.ini b/dom/workers/test/serviceworkers/mochitest.ini new file mode 100644 index 000000000..29ac9e036 --- /dev/null +++ b/dom/workers/test/serviceworkers/mochitest.ini @@ -0,0 +1,317 @@ +[DEFAULT] + +support-files = + worker.js + worker2.js + worker3.js + fetch_event_worker.js + parse_error_worker.js + activate_event_error_worker.js + install_event_worker.js + install_event_error_worker.js + simpleregister/index.html + simpleregister/ready.html + controller/index.html + unregister/index.html + unregister/unregister.html + workerUpdate/update.html + sw_clients/simple.html + sw_clients/service_worker_controlled.html + match_all_worker.js + match_all_advanced_worker.js + worker_unregister.js + worker_update.js + message_posting_worker.js + fetch/index.html + fetch/fetch_worker_script.js + fetch/fetch_tests.js + fetch/deliver-gzip.sjs + fetch/redirect.sjs + fetch/real-file.txt + fetch/context/index.html + fetch/context/register.html + fetch/context/unregister.html + fetch/context/context_test.js + fetch/context/realimg.jpg + fetch/context/realaudio.ogg + fetch/context/beacon.sjs + fetch/context/csp-violate.sjs + fetch/context/ping.html + fetch/context/worker.js + fetch/context/parentworker.js + fetch/context/sharedworker.js + fetch/context/parentsharedworker.js + fetch/context/xml.xml + fetch/hsts/hsts_test.js + fetch/hsts/embedder.html + fetch/hsts/image.html + fetch/hsts/image-20px.png + fetch/hsts/image-40px.png + fetch/hsts/realindex.html + fetch/hsts/register.html + fetch/hsts/register.html^headers^ + fetch/hsts/unregister.html + fetch/https/index.html + fetch/https/register.html + fetch/https/unregister.html + fetch/https/https_test.js + fetch/https/clonedresponse/index.html + fetch/https/clonedresponse/register.html + fetch/https/clonedresponse/unregister.html + fetch/https/clonedresponse/https_test.js + fetch/imagecache/image-20px.png + fetch/imagecache/image-40px.png + fetch/imagecache/imagecache_test.js + fetch/imagecache/index.html + fetch/imagecache/postmortem.html + fetch/imagecache/register.html + fetch/imagecache/unregister.html + fetch/imagecache-maxage/index.html + fetch/imagecache-maxage/image-20px.png + fetch/imagecache-maxage/image-40px.png + fetch/imagecache-maxage/maxage_test.js + fetch/imagecache-maxage/register.html + fetch/imagecache-maxage/unregister.html + fetch/importscript-mixedcontent/register.html + fetch/importscript-mixedcontent/unregister.html + fetch/importscript-mixedcontent/https_test.js + fetch/interrupt.sjs + fetch/origin/index.sjs + fetch/origin/index-to-https.sjs + fetch/origin/realindex.html + fetch/origin/realindex.html^headers^ + fetch/origin/register.html + fetch/origin/unregister.html + fetch/origin/origin_test.js + fetch/origin/https/index-https.sjs + fetch/origin/https/realindex.html + fetch/origin/https/realindex.html^headers^ + fetch/origin/https/register.html + fetch/origin/https/unregister.html + fetch/origin/https/origin_test.js + fetch/requesturl/index.html + fetch/requesturl/redirect.sjs + fetch/requesturl/redirector.html + fetch/requesturl/register.html + fetch/requesturl/requesturl_test.js + fetch/requesturl/secret.html + fetch/requesturl/unregister.html + fetch/sandbox/index.html + fetch/sandbox/intercepted_index.html + fetch/sandbox/register.html + fetch/sandbox/unregister.html + fetch/sandbox/sandbox_test.js + fetch/upgrade-insecure/upgrade-insecure_test.js + fetch/upgrade-insecure/embedder.html + fetch/upgrade-insecure/embedder.html^headers^ + fetch/upgrade-insecure/image.html + fetch/upgrade-insecure/image-20px.png + fetch/upgrade-insecure/image-40px.png + fetch/upgrade-insecure/realindex.html + fetch/upgrade-insecure/register.html + fetch/upgrade-insecure/unregister.html + match_all_properties_worker.js + match_all_clients/match_all_controlled.html + test_serviceworker_interfaces.js + serviceworker_wrapper.js + message_receiver.html + close_test.js + serviceworker_not_sharedworker.js + match_all_client/match_all_client_id.html + match_all_client_id_worker.js + source_message_posting_worker.js + scope/scope_worker.js + redirect_serviceworker.sjs + importscript.sjs + importscript_worker.js + bug1151916_worker.js + bug1151916_driver.html + bug1240436_worker.js + notificationclick.html + notificationclick-otherwindow.html + notificationclick.js + notificationclick_focus.html + notificationclick_focus.js + notificationclose.html + notificationclose.js + worker_updatefoundevent.js + worker_updatefoundevent2.js + updatefoundevent.html + empty.js + notification_constructor_error.js + notification_get_sw.js + notification/register.html + notification/unregister.html + notification/listener.html + notification_alt/register.html + notification_alt/unregister.html + sanitize/frame.html + sanitize/register.html + sanitize/example_check_and_unregister.html + sanitize_worker.js + swa/worker_scope_different.js + swa/worker_scope_different.js^headers^ + swa/worker_scope_different2.js + swa/worker_scope_different2.js^headers^ + swa/worker_scope_precise.js + swa/worker_scope_precise.js^headers^ + swa/worker_scope_too_deep.js + swa/worker_scope_too_deep.js^headers^ + swa/worker_scope_too_narrow.js + swa/worker_scope_too_narrow.js^headers^ + claim_oninstall_worker.js + claim_worker_1.js + claim_worker_2.js + claim_clients/client.html + claim_fetch_worker.js + force_refresh_worker.js + sw_clients/refresher.html + sw_clients/refresher_compressed.html + sw_clients/refresher_compressed.html^headers^ + sw_clients/refresher_cached.html + sw_clients/refresher_cached_compressed.html + sw_clients/refresher_cached_compressed.html^headers^ + strict_mode_warning.js + skip_waiting_installed_worker.js + skip_waiting_scope/index.html + thirdparty/iframe1.html + thirdparty/iframe2.html + thirdparty/register.html + thirdparty/unregister.html + thirdparty/sw.js + register_https.html + gzip_redirect_worker.js + sw_clients/navigator.html + eval_worker.js + test_eval_allowed.html^headers^ + opaque_intercept_worker.js + notify_loaded.js + test_request_context.js + fetch/plugin/worker.js + fetch/plugin/plugins.html + eventsource/* + sw_clients/file_blob_upload_frame.html + redirect_post.sjs + xslt_worker.js + xslt/* + unresolved_fetch_worker.js + header_checker.sjs + openWindow_worker.js + redirect.sjs + open_window/client.html + lorem_script.js + file_blob_response_worker.js + !/dom/security/test/cors/file_CrossSiteXHR_server.sjs + !/dom/tests/mochitest/notification/MockServices.js + !/dom/tests/mochitest/notification/NotificationTest.js + blocking_install_event_worker.js + sw_bad_mime_type.js + sw_bad_mime_type.js^headers^ + error_reporting_helpers.js + fetch.js + hello.html + create_another_sharedWorker.html + sharedWorker_fetch.js + +[test_bug1151916.html] +[test_bug1240436.html] +[test_claim.html] +[test_claim_fetch.html] +[test_claim_oninstall.html] +[test_close.html] +[test_controller.html] +[test_cross_origin_url_after_redirect.html] +[test_csp_upgrade-insecure_intercept.html] +[test_empty_serviceworker.html] +[test_error_reporting.html] +[test_escapedSlashes.html] +[test_eval_allowed.html] +[test_eventsource_intercept.html] +[test_fetch_event.html] +skip-if = (debug && e10s) # Bug 1262224 +[test_fetch_integrity.html] +[test_file_blob_response.html] +[test_file_blob_upload.html] +[test_force_refresh.html] +[test_gzip_redirect.html] +[test_hsts_upgrade_intercept.html] +[test_https_fetch.html] +[test_https_fetch_cloned_response.html] +[test_https_origin_after_redirect.html] +[test_https_origin_after_redirect_cached.html] +[test_https_synth_fetch_from_cached_sw.html] +[test_imagecache.html] +[test_imagecache_max_age.html] +[test_importscript.html] +[test_importscript_mixedcontent.html] +tags = mcb +[test_install_event.html] +[test_install_event_gc.html] +[test_installation_simple.html] +[test_match_all.html] +[test_match_all_advanced.html] +[test_match_all_client_id.html] +[test_match_all_client_properties.html] +[test_navigator.html] +[test_not_intercept_plugin.html] +[test_notification_constructor_error.html] +[test_notification_get.html] +[test_notificationclick.html] +[test_notificationclick_focus.html] +[test_notificationclick-otherwindow.html] +[test_notificationclose.html] +[test_opaque_intercept.html] +[test_openWindow.html] +tags = openwindow +[test_origin_after_redirect.html] +[test_origin_after_redirect_cached.html] +[test_origin_after_redirect_to_https.html] +[test_origin_after_redirect_to_https_cached.html] +[test_post_message.html] +[test_post_message_advanced.html] +[test_post_message_source.html] +[test_register_base.html] +[test_register_https_in_http.html] +[test_request_context_audio.html] +[test_request_context_beacon.html] +[test_request_context_cache.html] +[test_request_context_cspreport.html] +[test_request_context_embed.html] +[test_request_context_fetch.html] +[test_request_context_font.html] +[test_request_context_frame.html] +[test_request_context_iframe.html] +[test_request_context_image.html] +[test_request_context_imagesrcset.html] +[test_request_context_internal.html] +[test_request_context_nestedworker.html] +[test_request_context_nestedworkerinsharedworker.html] +[test_request_context_object.html] +[test_request_context_picture.html] +[test_request_context_ping.html] +[test_request_context_plugin.html] +[test_request_context_script.html] +[test_request_context_sharedworker.html] +[test_request_context_style.html] +[test_request_context_track.html] +[test_request_context_video.html] +[test_request_context_worker.html] +[test_request_context_xhr.html] +[test_request_context_xslt.html] +[test_sandbox_intercept.html] +[test_scopes.html] +[test_sanitize.html] +[test_sanitize_domain.html] +[test_service_worker_allowed.html] +[test_serviceworker_header.html] +[test_serviceworker_interfaces.html] +[test_serviceworker_not_sharedworker.html] +[test_skip_waiting.html] +[test_strict_mode_warning.html] +[test_third_party_iframes.html] +[test_unregister.html] +[test_unresolved_fetch_interception.html] +[test_workerUnregister.html] +[test_workerUpdate.html] +[test_workerupdatefoundevent.html] +[test_xslt.html] diff --git a/dom/workers/test/serviceworkers/notification/listener.html b/dom/workers/test/serviceworkers/notification/listener.html new file mode 100644 index 000000000..1c6e282ec --- /dev/null +++ b/dom/workers/test/serviceworkers/notification/listener.html @@ -0,0 +1,27 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1114554 - proxy to forward messages from SW to test</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + navigator.serviceWorker.onmessage = function(msg) { + // worker message; + testWindow.postMessage(msg.data, "*"); + if (msg.data.type == 'finish') { + window.close(); + } + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/notification/register.html b/dom/workers/test/serviceworkers/notification/register.html new file mode 100644 index 000000000..b7df73bed --- /dev/null +++ b/dom/workers/test/serviceworkers/notification/register.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<script> + function done() { + parent.callback(); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("../notification_get_sw.js", {scope: "."}).catch(function(e) { + dump("Registration failure " + e.message + "\n"); + }); +</script> diff --git a/dom/workers/test/serviceworkers/notification/unregister.html b/dom/workers/test/serviceworkers/notification/unregister.html new file mode 100644 index 000000000..d5a141f83 --- /dev/null +++ b/dom/workers/test/serviceworkers/notification/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.callback(); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/notification_alt/register.html b/dom/workers/test/serviceworkers/notification_alt/register.html new file mode 100644 index 000000000..b7df73bed --- /dev/null +++ b/dom/workers/test/serviceworkers/notification_alt/register.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<script> + function done() { + parent.callback(); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("../notification_get_sw.js", {scope: "."}).catch(function(e) { + dump("Registration failure " + e.message + "\n"); + }); +</script> diff --git a/dom/workers/test/serviceworkers/notification_alt/unregister.html b/dom/workers/test/serviceworkers/notification_alt/unregister.html new file mode 100644 index 000000000..d5a141f83 --- /dev/null +++ b/dom/workers/test/serviceworkers/notification_alt/unregister.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + registration.unregister().then(function(success) { + if (success) { + window.parent.callback(); + } + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/notification_constructor_error.js b/dom/workers/test/serviceworkers/notification_constructor_error.js new file mode 100644 index 000000000..644dba480 --- /dev/null +++ b/dom/workers/test/serviceworkers/notification_constructor_error.js @@ -0,0 +1 @@ +new Notification("Hi there"); diff --git a/dom/workers/test/serviceworkers/notification_get_sw.js b/dom/workers/test/serviceworkers/notification_get_sw.js new file mode 100644 index 000000000..540c9d93c --- /dev/null +++ b/dom/workers/test/serviceworkers/notification_get_sw.js @@ -0,0 +1,49 @@ +function postAll(data) { + self.clients.matchAll().then(function(clients) { + if (clients.length == 0) { + dump("***************** NO CLIENTS FOUND! Test messages are being lost *******************\n"); + } + clients.forEach(function(client) { + client.postMessage(data); + }); + }); +} + +function ok(a, msg) { + postAll({type: 'status', status: !!a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + postAll({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg }); +} + +function done() { + postAll({type: 'finish'}); +} + +onmessage = function(e) { +dump("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% MESSAGE " + e.data + "\n"); + var start; + if (e.data == 'create') { + start = registration.showNotification("This is a title"); + } else { + start = Promise.resolve(); + } + + start.then(function() { + dump("CALLING getNotification\n"); + registration.getNotifications().then(function(notifications) { + dump("RECD getNotification\n"); + is(notifications.length, 1, "There should be one stored notification"); + var notification = notifications[0]; + if (!notification) { + done(); + return; + } + ok(notification instanceof Notification, "Should be a Notification"); + is(notification.title, "This is a title", "Title should match"); + notification.close(); + done(); + }); + }); +} diff --git a/dom/workers/test/serviceworkers/notificationclick-otherwindow.html b/dom/workers/test/serviceworkers/notificationclick-otherwindow.html new file mode 100644 index 000000000..f64e82aab --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclick-otherwindow.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1114554 - controlled page</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + navigator.serviceWorker.ready.then(function(swr) { + var ifr = document.createElement("iframe"); + document.documentElement.appendChild(ifr); + ifr.contentWindow.ServiceWorkerRegistration.prototype.showNotification + .call(swr, "Hi there. The ServiceWorker should receive a click event for this.", { data: { complex: ["jsval", 5] }}); + }); + + navigator.serviceWorker.onmessage = function(msg) { + testWindow.callback(msg.data.result); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/notificationclick.html b/dom/workers/test/serviceworkers/notificationclick.html new file mode 100644 index 000000000..448764a1c --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclick.html @@ -0,0 +1,27 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1114554 - controlled page</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + navigator.serviceWorker.ready.then(function(swr) { + swr.showNotification("Hi there. The ServiceWorker should receive a click event for this.", { data: { complex: ["jsval", 5] }}); + }); + + navigator.serviceWorker.onmessage = function(msg) { + testWindow.callback(msg.data.result); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/notificationclick.js b/dom/workers/test/serviceworkers/notificationclick.js new file mode 100644 index 000000000..39e7adb81 --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclick.js @@ -0,0 +1,19 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// +onnotificationclick = function(e) { + self.clients.matchAll().then(function(clients) { + if (clients.length === 0) { + dump("********************* CLIENTS LIST EMPTY! Test will timeout! ***********************\n"); + return; + } + + clients.forEach(function(client) { + client.postMessage({ result: e.notification.data && + e.notification.data['complex'] && + e.notification.data['complex'][0] == "jsval" && + e.notification.data['complex'][1] == 5 }); + + }); + }); +} diff --git a/dom/workers/test/serviceworkers/notificationclick_focus.html b/dom/workers/test/serviceworkers/notificationclick_focus.html new file mode 100644 index 000000000..0152d397f --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclick_focus.html @@ -0,0 +1,28 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1144660 - controlled page</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + navigator.serviceWorker.ready.then(function(swr) { + swr.showNotification("Hi there. The ServiceWorker should receive a click event for this."); + }); + + navigator.serviceWorker.onmessage = function(msg) { + dump("GOT Message " + JSON.stringify(msg.data) + "\n"); + testWindow.callback(msg.data.ok); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/notificationclick_focus.js b/dom/workers/test/serviceworkers/notificationclick_focus.js new file mode 100644 index 000000000..5fb73651e --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclick_focus.js @@ -0,0 +1,40 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// + +function promisifyTimerFocus(client, delay) { + return new Promise(function(resolve, reject) { + setTimeout(function() { + client.focus().then(resolve, reject); + }, delay); + }); +} + +onnotificationclick = function(e) { + e.waitUntil(self.clients.matchAll().then(function(clients) { + if (clients.length === 0) { + dump("********************* CLIENTS LIST EMPTY! Test will timeout! ***********************\n"); + return Promise.resolve(); + } + + var immediatePromise = clients[0].focus(); + var withinTimeout = promisifyTimerFocus(clients[0], 100); + + var afterTimeout = promisifyTimerFocus(clients[0], 2000).then(function() { + throw "Should have failed!"; + }, function() { + return Promise.resolve(); + }); + + return Promise.all([immediatePromise, withinTimeout, afterTimeout]).then(function() { + clients.forEach(function(client) { + client.postMessage({ok: true}); + }); + }).catch(function(e) { + dump("Error " + e + "\n"); + clients.forEach(function(client) { + client.postMessage({ok: false}); + }); + }); + })); +} diff --git a/dom/workers/test/serviceworkers/notificationclose.html b/dom/workers/test/serviceworkers/notificationclose.html new file mode 100644 index 000000000..10c8da453 --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclose.html @@ -0,0 +1,37 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1265841 - controlled page</title> +<script class="testbody" type="text/javascript"> + var testWindow = parent; + if (opener) { + testWindow = opener; + } + + navigator.serviceWorker.ready.then(function(swr) { + return swr.showNotification( + "Hi there. The ServiceWorker should receive a close event for this.", + { data: { complex: ["jsval", 5] }}).then(function() { + return swr; + }); + }).then(function(swr) { + return swr.getNotifications(); + }).then(function(notifications) { + notifications.forEach(function(notification) { + notification.close(); + }); + }); + + navigator.serviceWorker.onmessage = function(msg) { + testWindow.callback(msg.data.result); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/notificationclose.js b/dom/workers/test/serviceworkers/notificationclose.js new file mode 100644 index 000000000..d48218075 --- /dev/null +++ b/dom/workers/test/serviceworkers/notificationclose.js @@ -0,0 +1,19 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// +onnotificationclose = function(e) { + self.clients.matchAll().then(function(clients) { + if (clients.length === 0) { + dump("********************* CLIENTS LIST EMPTY! Test will timeout! ***********************\n"); + return; + } + + clients.forEach(function(client) { + client.postMessage({ result: e.notification.data && + e.notification.data['complex'] && + e.notification.data['complex'][0] == "jsval" && + e.notification.data['complex'][1] == 5 }); + + }); + }); +} diff --git a/dom/workers/test/serviceworkers/notify_loaded.js b/dom/workers/test/serviceworkers/notify_loaded.js new file mode 100644 index 000000000..d07573b2c --- /dev/null +++ b/dom/workers/test/serviceworkers/notify_loaded.js @@ -0,0 +1 @@ +parent.postMessage('SCRIPT_LOADED', '*'); diff --git a/dom/workers/test/serviceworkers/opaque_intercept_worker.js b/dom/workers/test/serviceworkers/opaque_intercept_worker.js new file mode 100644 index 000000000..d593be783 --- /dev/null +++ b/dom/workers/test/serviceworkers/opaque_intercept_worker.js @@ -0,0 +1,25 @@ +var name = 'opaqueInterceptCache'; + +// Cross origin request to ensure that an opaque response is used +var prefix = 'http://example.com/tests/dom/workers/test/serviceworkers/' + +self.addEventListener('install', function(event) { + var request = new Request(prefix + 'notify_loaded.js', { mode: 'no-cors' }); + event.waitUntil( + Promise.all([caches.open(name), fetch(request)]).then(function(results) { + var cache = results[0]; + var response = results[1]; + return cache.put('./sw_clients/does_not_exist.js', response); + }) + ); +}); + +self.addEventListener('fetch', function (event) { + event.respondWith( + caches.open(name).then(function(cache) { + return cache.match(event.request); + }).then(function(response) { + return response || fetch(event.request); + }) + ); +}); diff --git a/dom/workers/test/serviceworkers/openWindow_worker.js b/dom/workers/test/serviceworkers/openWindow_worker.js new file mode 100644 index 000000000..46c0f998e --- /dev/null +++ b/dom/workers/test/serviceworkers/openWindow_worker.js @@ -0,0 +1,116 @@ +// the worker won't shut down between events because we increased +// the timeout values. +var client; +var window_count = 0; +var expected_window_count = 7; +var resolve_got_all_windows = null; +var got_all_windows = new Promise(function(res, rej) { + resolve_got_all_windows = res; +}); + +// |expected_window_count| needs to be updated for every new call that's +// expected to actually open a new window regardless of what |clients.openWindow| +// returns. +function testForUrl(url, throwType, clientProperties, resultsArray) { + return clients.openWindow(url) + .then(function(e) { + if (throwType != null) { + resultsArray.push({ + result: false, + message: "openWindow should throw " + throwType + }); + } else if (clientProperties) { + resultsArray.push({ + result: (e instanceof WindowClient), + message: "openWindow should resolve to a WindowClient" + }); + resultsArray.push({ + result: e.url == clientProperties.url, + message: "Client url should be " + clientProperties.url + }); + // Add more properties + } else { + resultsArray.push({ + result: e == null, + message: "Open window should resolve to null. Got: " + e + }); + } + }) + .catch(function(err) { + if (throwType == null) { + resultsArray.push({ + result: false, + message: "Unexpected throw: " + err + }); + } else { + resultsArray.push({ + result: err.toString().indexOf(throwType) >= 0, + message: "openWindow should throw: " + err + }); + } + }) +} + +onmessage = function(event) { + if (event.data == "testNoPopup") { + client = event.source; + + var results = []; + var promises = []; + promises.push(testForUrl("about:blank", "TypeError", null, results)); + promises.push(testForUrl("http://example.com", "InvalidAccessError", null, results)); + promises.push(testForUrl("_._*`InvalidURL", "InvalidAccessError", null, results)); + Promise.all(promises).then(function(e) { + client.postMessage(results); + }); + } + if (event.data == "NEW_WINDOW") { + window_count += 1; + if (window_count == expected_window_count) { + resolve_got_all_windows(); + } + } + + if (event.data == "CHECK_NUMBER_OF_WINDOWS") { + got_all_windows.then(function() { + return clients.matchAll(); + }).then(function(cl) { + event.source.postMessage({result: cl.length == expected_window_count, + message: "The number of windows is correct."}); + for (i = 0; i < cl.length; i++) { + cl[i].postMessage("CLOSE"); + } + }); + } +} + +onnotificationclick = function(e) { + var results = []; + var promises = []; + + var redirect = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/redirect.sjs?" + var redirect_xorigin = "http://example.com/tests/dom/workers/test/serviceworkers/redirect.sjs?" + var same_origin = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/open_window/client.html" + var different_origin = "http://example.com/tests/dom/workers/test/serviceworkers/open_window/client.html" + + + promises.push(testForUrl("about:blank", "TypeError", null, results)); + promises.push(testForUrl(different_origin, null, null, results)); + promises.push(testForUrl(same_origin, null, {url: same_origin}, results)); + promises.push(testForUrl("open_window/client.html", null, {url: same_origin}, results)); + + // redirect tests + promises.push(testForUrl(redirect + "open_window/client.html", null, + {url: same_origin}, results)); + promises.push(testForUrl(redirect + different_origin, null, null, results)); + + promises.push(testForUrl(redirect_xorigin + "open_window/client.html", null, + null, results)); + promises.push(testForUrl(redirect_xorigin + same_origin, null, + {url: same_origin}, results)); + + Promise.all(promises).then(function(e) { + client.postMessage(results); + }); +} + diff --git a/dom/workers/test/serviceworkers/open_window/client.html b/dom/workers/test/serviceworkers/open_window/client.html new file mode 100644 index 000000000..82b93ff7e --- /dev/null +++ b/dom/workers/test/serviceworkers/open_window/client.html @@ -0,0 +1,48 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1172870 - page opened by ServiceWorkerClients.OpenWindow</title> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + window.onload = function() { + if (window.location == "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/open_window/client.html") { + navigator.serviceWorker.ready.then(function(result) { + navigator.serviceWorker.onmessage = function(event) { + if (event.data !== "CLOSE") { + dump("ERROR: unexepected reply from the service worker.\n"); + } + if (parent) { + parent.postMessage("CLOSE", "*"); + } + window.close(); + } + navigator.serviceWorker.controller.postMessage("NEW_WINDOW"); + }) + } else { + window.onmessage = function(event) { + if (event.data !== "CLOSE") { + dump("ERROR: unexepected reply from the iframe.\n"); + } + window.close(); + } + + var iframe = document.createElement('iframe'); + iframe.src = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/open_window/client.html"; + document.body.appendChild(iframe); + } + } + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/parse_error_worker.js b/dom/workers/test/serviceworkers/parse_error_worker.js new file mode 100644 index 000000000..b6a8ef0a1 --- /dev/null +++ b/dom/workers/test/serviceworkers/parse_error_worker.js @@ -0,0 +1,2 @@ +// intentional parse error. +var foo = {; diff --git a/dom/workers/test/serviceworkers/redirect.sjs b/dom/workers/test/serviceworkers/redirect.sjs new file mode 100644 index 000000000..b6249cadf --- /dev/null +++ b/dom/workers/test/serviceworkers/redirect.sjs @@ -0,0 +1,5 @@ +function handleRequest(request, response) +{ + response.setStatusLine(request.httpVersion, 301, "Moved Permanently"); + response.setHeader("Location", request.queryString, false); +} diff --git a/dom/workers/test/serviceworkers/redirect_post.sjs b/dom/workers/test/serviceworkers/redirect_post.sjs new file mode 100644 index 000000000..8b805be63 --- /dev/null +++ b/dom/workers/test/serviceworkers/redirect_post.sjs @@ -0,0 +1,35 @@ +const CC = Components.Constructor; +const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream"); + +function handleRequest(request, response) +{ + var query = {}; + request.queryString.split('&').forEach(function (val) { + var [name, value] = val.split('='); + query[name] = unescape(value); + }); + + var bodyStream = new BinaryInputStream(request.bodyInputStream); + var bodyBytes = []; + while ((bodyAvail = bodyStream.available()) > 0) + Array.prototype.push.apply(bodyBytes, bodyStream.readByteArray(bodyAvail)); + + var body = decodeURIComponent( + escape(String.fromCharCode.apply(null, bodyBytes))); + + var currentHop = query.hop ? parseInt(query.hop) : 0; + + var obj = JSON.parse(body); + if (currentHop < obj.hops) { + var newURL = '/tests/dom/workers/test/serviceworkers/redirect_post.sjs?hop=' + + (1 + currentHop); + response.setStatusLine(null, 307, 'redirect'); + response.setHeader('Location', newURL); + return; + } + + response.setHeader('Content-Type', 'application/json'); + response.write(body); +} diff --git a/dom/workers/test/serviceworkers/redirect_serviceworker.sjs b/dom/workers/test/serviceworkers/redirect_serviceworker.sjs new file mode 100644 index 000000000..9d3a0a2cd --- /dev/null +++ b/dom/workers/test/serviceworkers/redirect_serviceworker.sjs @@ -0,0 +1,4 @@ +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/worker.js"); +} diff --git a/dom/workers/test/serviceworkers/register_https.html b/dom/workers/test/serviceworkers/register_https.html new file mode 100644 index 000000000..d14d8c380 --- /dev/null +++ b/dom/workers/test/serviceworkers/register_https.html @@ -0,0 +1,21 @@ +<!DOCTYPE html> +<script> +function ok(condition, message) { + parent.postMessage({type: "ok", status: condition, msg: message}, "*"); +} + +function done() { + parent.postMessage({type: "done"}, "*"); +} + +ok(location.protocol == "https:", "We should be loaded from HTTPS"); + +navigator.serviceWorker.register("empty.js", {scope: "register-https"}) + .then(reg => { + ok(false, "Registration should fail"); + done(); + }).catch(err => { + ok(err.name === "SecurityError", "Registration should fail with SecurityError"); + done(); + }); +</script> diff --git a/dom/workers/test/serviceworkers/sanitize/example_check_and_unregister.html b/dom/workers/test/serviceworkers/sanitize/example_check_and_unregister.html new file mode 100644 index 000000000..4de8f317b --- /dev/null +++ b/dom/workers/test/serviceworkers/sanitize/example_check_and_unregister.html @@ -0,0 +1,23 @@ +<!DOCTYPE html> +<script> + function done(exists) { + parent.postMessage(exists, '*'); + } + + function fail() { + parent.postMessage("FAIL", '*'); + } + + navigator.serviceWorker.getRegistration(".").then(function(reg) { + if (reg) { + reg.unregister().then(done.bind(undefined, true), fail); + } else { + dump("getRegistration() returned undefined registration\n"); + done(false); + } + }, function(e) { + dump("getRegistration() failed\n"); + fail(); + }); +</script> + diff --git a/dom/workers/test/serviceworkers/sanitize/frame.html b/dom/workers/test/serviceworkers/sanitize/frame.html new file mode 100644 index 000000000..b4bf7a1ff --- /dev/null +++ b/dom/workers/test/serviceworkers/sanitize/frame.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<script> + fetch("intercept-this").then(function(r) { + if (!r.ok) { + return "FAIL"; + } + return r.text(); + }).then(function(body) { + parent.postMessage(body, '*'); + }); +</script> diff --git a/dom/workers/test/serviceworkers/sanitize/register.html b/dom/workers/test/serviceworkers/sanitize/register.html new file mode 100644 index 000000000..f1edd27be --- /dev/null +++ b/dom/workers/test/serviceworkers/sanitize/register.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<script> + function done() { + parent.postMessage('', '*'); + } + + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("../sanitize_worker.js", {scope: "."}); +</script> + diff --git a/dom/workers/test/serviceworkers/sanitize_worker.js b/dom/workers/test/serviceworkers/sanitize_worker.js new file mode 100644 index 000000000..66495e186 --- /dev/null +++ b/dom/workers/test/serviceworkers/sanitize_worker.js @@ -0,0 +1,5 @@ +onfetch = function(e) { + if (e.request.url.indexOf("intercept-this") != -1) { + e.respondWith(new Response("intercepted")); + } +} diff --git a/dom/workers/test/serviceworkers/scope/scope_worker.js b/dom/workers/test/serviceworkers/scope/scope_worker.js new file mode 100644 index 000000000..4164e7a24 --- /dev/null +++ b/dom/workers/test/serviceworkers/scope/scope_worker.js @@ -0,0 +1,2 @@ +// This worker is used to test if calling register() without a scope argument +// leads to scope being relative to service worker script. diff --git a/dom/workers/test/serviceworkers/serviceworker.html b/dom/workers/test/serviceworkers/serviceworker.html new file mode 100644 index 000000000..11edd001a --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworker.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + navigator.serviceWorker.register("worker.js"); + </script> + </head> + <body> + This is a test page. + </body> +<html> diff --git a/dom/workers/test/serviceworkers/serviceworker_not_sharedworker.js b/dom/workers/test/serviceworkers/serviceworker_not_sharedworker.js new file mode 100644 index 000000000..077da2366 --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworker_not_sharedworker.js @@ -0,0 +1,21 @@ +function OnMessage(e) +{ + if (e.data.msg == "whoareyou") { + if ("ServiceWorker" in self) { + self.clients.matchAll().then(function(clients) { + clients[0].postMessage({result: "serviceworker"}); + }); + } else { + port.postMessage({result: "sharedworker"}); + } + } +}; + +var port; +onconnect = function(e) { + port = e.ports[0]; + port.onmessage = OnMessage; + port.start(); +}; + +onmessage = OnMessage; diff --git a/dom/workers/test/serviceworkers/serviceworker_wrapper.js b/dom/workers/test/serviceworkers/serviceworker_wrapper.js new file mode 100644 index 000000000..6a7ec0c0f --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworker_wrapper.js @@ -0,0 +1,101 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// +// ServiceWorker equivalent of worker_wrapper.js. + +var client; + +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + ": " + msg + "\n"); + client.postMessage({type: 'status', status: !!a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + dump("IS: " + (a===b) + " => " + a + " | " + b + ": " + msg + "\n"); + client.postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg }); +} + +function workerTestArrayEquals(a, b) { + if (!Array.isArray(a) || !Array.isArray(b) || a.length != b.length) { + return false; + } + for (var i = 0, n = a.length; i < n; ++i) { + if (a[i] !== b[i]) { + return false; + } + } + return true; +} + +function workerTestDone() { + client.postMessage({ type: 'finish' }); +} + +function workerTestGetVersion(cb) { + addEventListener('message', function workerTestGetVersionCB(e) { + if (e.data.type !== 'returnVersion') { + return; + } + removeEventListener('message', workerTestGetVersionCB); + cb(e.data.result); + }); + client.postMessage({ + type: 'getVersion' + }); +} + +function workerTestGetUserAgent(cb) { + addEventListener('message', function workerTestGetUserAgentCB(e) { + if (e.data.type !== 'returnUserAgent') { + return; + } + removeEventListener('message', workerTestGetUserAgentCB); + cb(e.data.result); + }); + client.postMessage({ + type: 'getUserAgent' + }); +} + +function workerTestGetOSCPU(cb) { + addEventListener('message', function workerTestGetOSCPUCB(e) { + if (e.data.type !== 'returnOSCPU') { + return; + } + removeEventListener('message', workerTestGetOSCPUCB); + cb(e.data.result); + }); + client.postMessage({ + type: 'getOSCPU' + }); +} + +function workerTestGetStorageManager(cb) { + addEventListener('message', function workerTestGetStorageManagerCB(e) { + if (e.data.type !== 'returnStorageManager') { + return; + } + removeEventListener('message', workerTestGetStorageManagerCB); + cb(e.data.result); + }); + client.postMessage({ + type: 'getStorageManager' + }); +} + +addEventListener('message', function workerWrapperOnMessage(e) { + removeEventListener('message', workerWrapperOnMessage); + var data = e.data; + self.clients.matchAll().then(function(clients) { + client = clients[0]; + try { + importScripts(data.script); + } catch(e) { + client.postMessage({ + type: 'status', + status: false, + msg: 'worker failed to import ' + data.script + "; error: " + e.message + }); + } + }); +}); diff --git a/dom/workers/test/serviceworkers/serviceworkerinfo_iframe.html b/dom/workers/test/serviceworkers/serviceworkerinfo_iframe.html new file mode 100644 index 000000000..a0a2de760 --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworkerinfo_iframe.html @@ -0,0 +1,26 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + window.onmessage = function (event) { + if (event.data !== "register") { + return; + } + var promise = navigator.serviceWorker.register("worker.js"); + window.onmessage = function (event) { + if (event.data !== "unregister") { + return; + } + promise.then(function (registration) { + registration.unregister(); + }); + window.onmessage = null; + }; + }; + </script> + </head> + <body> + This is a test page. + </body> +<html> diff --git a/dom/workers/test/serviceworkers/serviceworkermanager_iframe.html b/dom/workers/test/serviceworkers/serviceworkermanager_iframe.html new file mode 100644 index 000000000..0df93da96 --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworkermanager_iframe.html @@ -0,0 +1,34 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + window.onmessage = function (event) { + if (event.data !== "register") { + return; + } + var promise = navigator.serviceWorker.register("worker.js"); + window.onmessage = function (event) { + if (event.data !== "register") { + return; + } + promise = promise.then(function (registration) { + return navigator.serviceWorker.register("worker2.js"); + }); + window.onmessage = function (event) { + if (event.data !== "unregister") { + return; + } + promise.then(function (registration) { + registration.unregister(); + }); + window.onmessage = null; + }; + }; + }; + </script> + </head> + <body> + This is a test page. + </body> +<html> diff --git a/dom/workers/test/serviceworkers/serviceworkerregistrationinfo_iframe.html b/dom/workers/test/serviceworkers/serviceworkerregistrationinfo_iframe.html new file mode 100644 index 000000000..f093d38db --- /dev/null +++ b/dom/workers/test/serviceworkers/serviceworkerregistrationinfo_iframe.html @@ -0,0 +1,30 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <script> + var reg; + window.onmessage = function (event) { + if (event.data !== "register") { + return; + } + var promise = navigator.serviceWorker.register("worker.js"); + window.onmessage = function (event) { + if (event.data === "register") { + promise.then(function (registration) { + return navigator.serviceWorker.register("worker2.js") + .then(function(registration) { + reg = registration; + }); + }); + } else if (event.data === "unregister") { + reg.unregister(); + } + }; + }; + </script> + </head> + <body> + This is a test page. + </body> +<html> diff --git a/dom/workers/test/serviceworkers/sharedWorker_fetch.js b/dom/workers/test/serviceworkers/sharedWorker_fetch.js new file mode 100644 index 000000000..4970a1fd2 --- /dev/null +++ b/dom/workers/test/serviceworkers/sharedWorker_fetch.js @@ -0,0 +1,29 @@ +var clients = new Array(); +clients.length = 0; + +var broadcast = function(message) { + var length = clients.length; + for (var i = 0; i < length; i++) { + port = clients[i]; + port.postMessage(message); + } +} + +onconnect = function(e) { + clients.push(e.ports[0]); + if (clients.length == 1) { + clients[0].postMessage("Connected"); + } else if (clients.length == 2) { + broadcast("BothConnected"); + clients[0].onmessage = function(e) { + if (e.data == "StartFetchWithWrongIntegrity") { + // The fetch will succeed because the integrity value is invalid and we + // are looking for the console message regarding the bad integrity value. + fetch("SharedWorker_SRIFailed.html", {"integrity": "abc"}).then( + function () { + clients[0].postMessage('SRI_failed'); + }); + } + } + } +} diff --git a/dom/workers/test/serviceworkers/simpleregister/index.html b/dom/workers/test/serviceworkers/simpleregister/index.html new file mode 100644 index 000000000..2c0eb5345 --- /dev/null +++ b/dom/workers/test/serviceworkers/simpleregister/index.html @@ -0,0 +1,51 @@ +<html> + <head></head> + <body> + <script type="text/javascript"> + var expectedEvents = 2; + function eventReceived() { + window.parent.postMessage({ type: "check", status: expectedEvents > 0, msg: "updatefound received" }, "*"); + + if (--expectedEvents) { + window.parent.postMessage({ type: "finish" }, "*"); + } + } + + navigator.serviceWorker.getRegistrations().then(function(a) { + window.parent.postMessage({ type: "check", status: Array.isArray(a), + msg: "getRegistrations returns an array" }, "*"); + window.parent.postMessage({ type: "check", status: a.length > 0, + msg: "getRegistrations returns an array with 1 item" }, "*"); + for (var i = 0; i < a.length; ++i) { + window.parent.postMessage({ type: "check", status: a[i] instanceof ServiceWorkerRegistration, + msg: "getRegistrations returns an array of ServiceWorkerRegistration objects" }, "*"); + if (a[i].scope.match(/simpleregister\//)) { + a[i].onupdatefound = function(e) { + eventReceived(); + } + } + } + }); + + navigator.serviceWorker.getRegistration('http://mochi.test:8888/tests/dom/workers/test/serviceworkers/simpleregister/') + .then(function(a) { + window.parent.postMessage({ type: "check", status: a instanceof ServiceWorkerRegistration, + msg: "getRegistration returns a ServiceWorkerRegistration" }, "*"); + a.onupdatefound = function(e) { + eventReceived(); + } + }); + + navigator.serviceWorker.getRegistration('http://www.something_else.net/') + .then(function(a) { + window.parent.postMessage({ type: "check", status: false, + msg: "getRegistration should throw for security error!" }, "*"); + }, function(a) { + window.parent.postMessage({ type: "check", status: true, + msg: "getRegistration should throw for security error!" }, "*"); + }); + + window.parent.postMessage({ type: "ready" }, "*"); + </script> + </body> +</html> diff --git a/dom/workers/test/serviceworkers/simpleregister/ready.html b/dom/workers/test/serviceworkers/simpleregister/ready.html new file mode 100644 index 000000000..3afc4bfdb --- /dev/null +++ b/dom/workers/test/serviceworkers/simpleregister/ready.html @@ -0,0 +1,15 @@ +<html> + <head></head> + <body> + <script type="text/javascript"> + + window.addEventListener('message', function(evt) { + navigator.serviceWorker.ready.then(function() { + evt.ports[0].postMessage("WOW!"); + }); + }, false); + + </script> + </body> +</html> + diff --git a/dom/workers/test/serviceworkers/skip_waiting_installed_worker.js b/dom/workers/test/serviceworkers/skip_waiting_installed_worker.js new file mode 100644 index 000000000..68573f100 --- /dev/null +++ b/dom/workers/test/serviceworkers/skip_waiting_installed_worker.js @@ -0,0 +1,6 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +self.addEventListener('install', evt => { + evt.waitUntil(self.skipWaiting()); +}); diff --git a/dom/workers/test/serviceworkers/skip_waiting_scope/index.html b/dom/workers/test/serviceworkers/skip_waiting_scope/index.html new file mode 100644 index 000000000..b8a64d512 --- /dev/null +++ b/dom/workers/test/serviceworkers/skip_waiting_scope/index.html @@ -0,0 +1,37 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1131352 - Add ServiceWorkerGlobalScope skipWaiting()</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + info("skip_waiting_scope/index.html shouldn't be launched directly!"); + } + + navigator.serviceWorker.ready.then(function() { + parent.postMessage("READY", "*"); + }); + + navigator.serviceWorker.oncontrollerchange = function() { + parent.postMessage({ + event: "controllerchange", + controllerScriptURL: navigator.serviceWorker.controller && + navigator.serviceWorker.controller.scriptURL + }, "*"); + } + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/source_message_posting_worker.js b/dom/workers/test/serviceworkers/source_message_posting_worker.js new file mode 100644 index 000000000..36ce951fe --- /dev/null +++ b/dom/workers/test/serviceworkers/source_message_posting_worker.js @@ -0,0 +1,16 @@ +onmessage = function(e) { + if (!e.source) { + dump("ERROR: message doesn't have a source."); + } + + if (!(e instanceof ExtendableMessageEvent)) { + e.source.postMessage("ERROR. event is not an extendable message event."); + } + + // The client should be a window client + if (e.source instanceof WindowClient) { + e.source.postMessage(e.data); + } else { + e.source.postMessage("ERROR. source is not a window client."); + } +}; diff --git a/dom/workers/test/serviceworkers/strict_mode_warning.js b/dom/workers/test/serviceworkers/strict_mode_warning.js new file mode 100644 index 000000000..38418de3d --- /dev/null +++ b/dom/workers/test/serviceworkers/strict_mode_warning.js @@ -0,0 +1,4 @@ +function f() { + return 1; + return 2; +} diff --git a/dom/workers/test/serviceworkers/sw_bad_mime_type.js b/dom/workers/test/serviceworkers/sw_bad_mime_type.js new file mode 100644 index 000000000..f371807db --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_bad_mime_type.js @@ -0,0 +1 @@ +// I need some contents. diff --git a/dom/workers/test/serviceworkers/sw_bad_mime_type.js^headers^ b/dom/workers/test/serviceworkers/sw_bad_mime_type.js^headers^ new file mode 100644 index 000000000..a1f9e38d9 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_bad_mime_type.js^headers^ @@ -0,0 +1 @@ +Content-Type: text/plain diff --git a/dom/workers/test/serviceworkers/sw_clients/file_blob_upload_frame.html b/dom/workers/test/serviceworkers/sw_clients/file_blob_upload_frame.html new file mode 100644 index 000000000..e594c514d --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/file_blob_upload_frame.html @@ -0,0 +1,77 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>test file blob upload with SW interception</title> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + +if (!parent) { + dump("sw_clients/file_blob_upload_frame.html shouldn't be launched directly!"); +} + +function makeFileBlob(obj) { + return new Promise(function(resolve, reject) { + + var request = indexedDB.open(window.location.pathname, 1); + request.onerror = reject; + request.onupgradeneeded = function(evt) { + var db = evt.target.result; + db.onerror = reject; + + var objectStore = db.createObjectStore('test', { autoIncrement: true }); + var index = objectStore.createIndex('test', 'index'); + }; + + request.onsuccess = function(evt) { + var db = evt.target.result; + db.onerror = reject; + + var blob = new Blob([JSON.stringify(obj)], + { type: 'application/json' }); + var data = { blob: blob, index: 5 }; + + objectStore = db.transaction('test', 'readwrite').objectStore('test'); + objectStore.add(data).onsuccess = function(evt) { + var key = evt.target.result; + objectStore = db.transaction('test').objectStore('test'); + objectStore.get(key).onsuccess = function(evt) { + resolve(evt.target.result.blob); + }; + }; + }; + }); +} + +navigator.serviceWorker.ready.then(function() { + parent.postMessage({ status: 'READY' }, '*'); +}); + +var URL = '/tests/dom/workers/test/serviceworkers/redirect_post.sjs'; + +addEventListener('message', function(evt) { + if (evt.data.type = 'TEST') { + makeFileBlob(evt.data.body).then(function(blob) { + return fetch(URL, { method: 'POST', body: blob }); + }).then(function(response) { + return response.json(); + }).then(function(result) { + parent.postMessage({ status: 'OK', result: result }, '*'); + }).catch(function(e) { + parent.postMessage({ status: 'ERROR', result: e.toString() }, '*'); + }); + } +}); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/sw_clients/navigator.html b/dom/workers/test/serviceworkers/sw_clients/navigator.html new file mode 100644 index 000000000..f6019bf28 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/navigator.html @@ -0,0 +1,35 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - test match_all not crashing</title> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + dump("sw_clients/navigator.html shouldn't be launched directly!\n"); + } + + window.addEventListener("message", function(event) { + if (event.data.type === "NAVIGATE") { + window.location = event.data.url; + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage("NAVIGATOR_READY", "*"); + }); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher.html b/dom/workers/test/serviceworkers/sw_clients/refresher.html new file mode 100644 index 000000000..054f6bfc8 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher.html @@ -0,0 +1,39 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - test match_all not crashing</title> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <!-- some tests will intercept this bogus script request --> + <script type="text/javascript" src="does_not_exist.js"></script> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + dump("sw_clients/simple.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function(event) { + if (event.data === "REFRESH") { + window.location.reload(); + } else if (event.data === "FORCE_REFRESH") { + window.location.reload(true); + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage("READY", "*"); + }); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher_cached.html b/dom/workers/test/serviceworkers/sw_clients/refresher_cached.html new file mode 100644 index 000000000..3ec0cc427 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher_cached.html @@ -0,0 +1,38 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - test match_all not crashing</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + info("sw_clients/simple.html shouldn't be launched directly!"); + } + + window.addEventListener("message", function(event) { + if (event.data === "REFRESH") { + window.location.reload(); + } else if (event.data === "FORCE_REFRESH") { + window.location.reload(true); + } + }); + + navigator.serviceWorker.ready.then(function() { + parent.postMessage("READY_CACHED", "*"); + }); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html b/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html Binary files differnew file mode 100644 index 000000000..55e97ac24 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html^headers^ b/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html^headers^ new file mode 100644 index 000000000..4204d8601 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher_cached_compressed.html^headers^ @@ -0,0 +1,2 @@ +Content-Type: text/html +Content-Encoding: gzip diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html b/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html Binary files differnew file mode 100644 index 000000000..7a45bcafa --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html diff --git a/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html^headers^ b/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html^headers^ new file mode 100644 index 000000000..4204d8601 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/refresher_compressed.html^headers^ @@ -0,0 +1,2 @@ +Content-Type: text/html +Content-Encoding: gzip diff --git a/dom/workers/test/serviceworkers/sw_clients/service_worker_controlled.html b/dom/workers/test/serviceworkers/sw_clients/service_worker_controlled.html new file mode 100644 index 000000000..e0d7bce57 --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/service_worker_controlled.html @@ -0,0 +1,38 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>controlled page</title> + <!-- + Paged controlled by a service worker for testing matchAll(). + See bug 982726, 1058311. + --> +<script class="testbody" type="text/javascript"> + function fail(msg) { + info("service_worker_controlled.html: " + msg); + opener.postMessage("FAIL", "*"); + } + + if (!parent) { + info("service_worker_controlled.html should not be launched directly!"); + } + + window.onload = function() { + navigator.serviceWorker.ready.then(function(swr) { + parent.postMessage("READY", "*"); + }); + } + + navigator.serviceWorker.onmessage = function(msg) { + // forward message to the test page. + parent.postMessage(msg.data, "*"); + }; +</script> + +</head> +<body> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/sw_clients/simple.html b/dom/workers/test/serviceworkers/sw_clients/simple.html new file mode 100644 index 000000000..3e4d7deca --- /dev/null +++ b/dom/workers/test/serviceworkers/sw_clients/simple.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - test match_all not crashing</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + info("sw_clients/simple.html shouldn't be launched directly!"); + } + + navigator.serviceWorker.ready.then(function() { + parent.postMessage("READY", "*"); + }); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_different.js b/dom/workers/test/serviceworkers/swa/worker_scope_different.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_different.js diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_different.js^headers^ b/dom/workers/test/serviceworkers/swa/worker_scope_different.js^headers^ new file mode 100644 index 000000000..e85a7f09d --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_different.js^headers^ @@ -0,0 +1 @@ +Service-Worker-Allowed: different/path diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_different2.js b/dom/workers/test/serviceworkers/swa/worker_scope_different2.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_different2.js diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_different2.js^headers^ b/dom/workers/test/serviceworkers/swa/worker_scope_different2.js^headers^ new file mode 100644 index 000000000..e37307d66 --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_different2.js^headers^ @@ -0,0 +1 @@ +Service-Worker-Allowed: /different/path diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_precise.js b/dom/workers/test/serviceworkers/swa/worker_scope_precise.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_precise.js diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_precise.js^headers^ b/dom/workers/test/serviceworkers/swa/worker_scope_precise.js^headers^ new file mode 100644 index 000000000..30b053055 --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_precise.js^headers^ @@ -0,0 +1 @@ +Service-Worker-Allowed: /tests/dom/workers/test/serviceworkers/swa diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js b/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js^headers^ b/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js^headers^ new file mode 100644 index 000000000..b2056fc4a --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_too_deep.js^headers^ @@ -0,0 +1 @@ +Service-Worker-Allowed: /tests/dom/workers/test/serviceworkers/swa/deep/way/too/specific diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js b/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js diff --git a/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js^headers^ b/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js^headers^ new file mode 100644 index 000000000..22add13bf --- /dev/null +++ b/dom/workers/test/serviceworkers/swa/worker_scope_too_narrow.js^headers^ @@ -0,0 +1 @@ +Service-Worker-Allowed: /tests/dom/workers diff --git a/dom/workers/test/serviceworkers/test_bug1151916.html b/dom/workers/test/serviceworkers/test_bug1151916.html new file mode 100644 index 000000000..92811775b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_bug1151916.html @@ -0,0 +1,105 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1151916 - Test principal is set on cached serviceworkers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +<!-- + If the principal is not set, accessing self.caches in the worker will crash. +--> +</head> +<body> +<p id="display"></p> +<div id="content"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var frame; + + function listenForMessage() { + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data.status == "failed") { + ok(false, "iframe had error " + e.data.message); + reject(e.data.message); + } else if (e.data.status == "success") { + ok(true, "iframe step success " + e.data.message); + resolve(e.data.message); + } else { + ok(false, "Unexpected message " + e.data); + reject(); + } + } + }); + + return p; + } + + // We have the iframe register for its own scope so that this page is not + // holding any references when we GC. + function register() { + var p = listenForMessage(); + + frame = document.createElement("iframe"); + document.body.appendChild(frame); + frame.src = "bug1151916_driver.html"; + + return p; + } + + function unloadFrame() { + frame.src = "about:blank"; + frame.parentNode.removeChild(frame); + frame = null; + } + + function gc() { + return new Promise(function(resolve) { + SpecialPowers.exactGC(resolve); + }); + } + + function testCaches() { + var p = listenForMessage(); + + frame = document.createElement("iframe"); + document.body.appendChild(frame); + frame.src = "bug1151916_driver.html"; + + return p; + } + + function unregister() { + return navigator.serviceWorker.getRegistration("./bug1151916_driver.html").then(function(reg) { + ok(reg instanceof ServiceWorkerRegistration, "Must have valid registration."); + return reg.unregister(); + }); + } + + function runTest() { + register() + .then(unloadFrame) + .then(gc) + .then(testCaches) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_bug1240436.html b/dom/workers/test/serviceworkers/test_bug1240436.html new file mode 100644 index 000000000..e93535840 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_bug1240436.html @@ -0,0 +1,34 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for encoding of service workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + SimpleTest.waitForExplicitFinish(); + + function runTest() { + navigator.serviceWorker.register("bug1240436_worker.js") + .then(reg => reg.unregister()) + .then(() => ok(true, "service worker register script succeed")) + .catch(err => ok(false, "service worker register script faled " + err)) + .then(() => SimpleTest.finish()); + } + + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_claim.html b/dom/workers/test/serviceworkers/test_claim.html new file mode 100644 index 000000000..d7015850f --- /dev/null +++ b/dom/workers/test/serviceworkers/test_claim.html @@ -0,0 +1,172 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1130684 - Test service worker clients claim onactivate </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration_1; + var registration_2; + var client; + + function register_1() { + return navigator.serviceWorker.register("claim_worker_1.js", + { scope: "./" }) + .then((swr) => registration_1 = swr); + } + + function register_2() { + return navigator.serviceWorker.register("claim_worker_2.js", + { scope: "./claim_clients/client.html" }) + .then((swr) => registration_2 = swr); + } + + function unregister(reg) { + return reg.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }); + } + + function createClient() { + var p = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data === "READY") { + res(); + } + } + }); + + content = document.getElementById("content"); + ok(content, "parent exists."); + + client = document.createElement("iframe"); + client.setAttribute('src', "claim_clients/client.html"); + content.appendChild(client); + + return p; + } + + function testController() { + ok(navigator.serviceWorker.controller.scriptURL.match("claim_worker_1"), + "Controlling service worker has the correct url."); + } + + function testClientWasClaimed(expected) { + var resolveClientMessage, resolveClientControllerChange; + var messageFromClient = new Promise(function(res, rej) { + resolveClientMessage = res; + }); + var controllerChangeFromClient = new Promise(function(res, rej) { + resolveClientControllerChange = res; + }); + window.onmessage = function(e) { + if (!e.data.event) { + ok(false, "Unknown message received: " + e.data); + } + + if (e.data.event === "controllerchange") { + ok(e.data.controller, + "Client was claimed and received controllerchange event."); + resolveClientControllerChange(); + } + + if (e.data.event === "message") { + ok(e.data.data.resolve_value === undefined, + "Claim should resolve with undefined."); + ok(e.data.data.message === expected.message, + "Client received message from claiming worker."); + ok(e.data.data.match_count_before === expected.match_count_before, + "MatchAll clients count before claim should be " + expected.match_count_before); + ok(e.data.data.match_count_after === expected.match_count_after, + "MatchAll clients count after claim should be " + expected.match_count_after); + resolveClientMessage(); + } + } + + return Promise.all([messageFromClient, controllerChangeFromClient]) + .then(() => window.onmessage = null); + } + + function testClaimFirstWorker() { + // wait for the worker to control us + var controllerChange = new Promise(function(res, rej) { + navigator.serviceWorker.oncontrollerchange = function(e) { + ok(true, "controller changed event received."); + res(); + }; + }); + + var messageFromWorker = new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function(e) { + ok(e.data.resolve_value === undefined, + "Claim should resolve with undefined."); + ok(e.data.message === "claim_worker_1", + "Received message from claiming worker."); + ok(e.data.match_count_before === 0, + "Worker doesn't control any client before claim."); + ok(e.data.match_count_after === 2, "Worker should claim 2 clients."); + res(); + } + }); + + var clientClaim = testClientWasClaimed({ + message: "claim_worker_1", + match_count_before: 0, + match_count_after: 2 + }); + + return Promise.all([controllerChange, messageFromWorker, clientClaim]) + .then(testController); + } + + function testClaimSecondWorker() { + navigator.serviceWorker.oncontrollerchange = function(e) { + ok(false, "Claim_worker_2 shouldn't claim this window."); + } + + navigator.serviceWorker.onmessage = function(e) { + ok(false, "Claim_worker_2 shouldn't claim this window."); + } + + var clientClaim = testClientWasClaimed({ + message: "claim_worker_2", + match_count_before: 0, + match_count_after: 1 + }); + + return clientClaim.then(testController); + } + + function runTest() { + createClient() + .then(register_1) + .then(testClaimFirstWorker) + .then(register_2) + .then(testClaimSecondWorker) + .then(function() { return unregister(registration_1); }) + .then(function() { return unregister(registration_2); }) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_claim_fetch.html b/dom/workers/test/serviceworkers/test_claim_fetch.html new file mode 100644 index 000000000..8db6d304e --- /dev/null +++ b/dom/workers/test/serviceworkers/test_claim_fetch.html @@ -0,0 +1,98 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1130684 - Test fetch events are intercepted after claim </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + <a ping="ping" href="fetch.txt">link</a> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + + function register() { + return navigator.serviceWorker.register("claim_fetch_worker.js", + { scope: "./" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }); + } + + function createClient() { + var p = new Promise(function(res, rej){ + window.onmessage = function(e) { + if(e.data === "READY") { + res(); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/service_worker_controlled.html"); + content.appendChild(iframe); + + return p; + } + + function testFetch(before) { + return fetch("fetch/real-file.txt").then(function(res) { + ok(res.ok, "Response should be valid."); + return res.text().then(function(body) { + if (before) { + ok(body !== "Fetch was intercepted", "Fetch events should not be intercepted."); + } else { + ok(body === "Fetch was intercepted", "Fetch events should be intercepted."); + } + }); + }); + } + + function claimThisPage() { + ok(registration.active, "Worker is active."); + var p = new Promise(function (res, rej) { + navigator.serviceWorker.oncontrollerchange = res; + }); + + registration.active.postMessage("Claim"); + + return p; + } + + function runTest() { + register() + .then(createClient) + .then(testFetch.bind(this, true)) + .then(claimThisPage) + .then(testFetch.bind(this, false)) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_claim_oninstall.html b/dom/workers/test/serviceworkers/test_claim_oninstall.html new file mode 100644 index 000000000..4605cfb76 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_claim_oninstall.html @@ -0,0 +1,78 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1130684 - Test service worker clients.claim oninstall</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + + function register() { + return navigator.serviceWorker.register("claim_oninstall_worker.js", + { scope: "./" }) + .then((swr) => registration = swr); + } + + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }); + } + + function testClaim() { + ok(registration.installing, "Worker should be in installing state"); + + navigator.serviceWorker.oncontrollerchange = function() { + ok(false, "Claim should not succeed when the worker is not active."); + } + + var p = new Promise(function(res, rej) { + var worker = registration.installing; + worker.onstatechange = function(e) { + if (worker.state === 'installed') { + is(worker, registration.waiting, "Worker should be in waiting state"); + } else if (worker.state === 'activated') { + // The worker will become active only if claim will reject inside the + // install handler. + is(worker, registration.active, + "Claim should reject if the worker is not active"); + ok(navigator.serviceWorker.controller === null, "Client is not controlled."); + e.target.onstatechange = null; + res(); + } + } + }); + + return p; + } + + function runTest() { + register() + .then(testClaim) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_client_focus.html b/dom/workers/test/serviceworkers/test_client_focus.html new file mode 100644 index 000000000..b0bf43bb3 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_client_focus.html @@ -0,0 +1,96 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1130686 - Test service worker client.focus </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +<!-- + This test checks that client.focus is available. + Actual focusing is tested by test_notificationclick_focus.html since only notification events have permission to change focus. +--> +</head> +<body> +<p id="display"></p> +<div id="content"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var worker; + + function start() { + return navigator.serviceWorker.register("client_focus_worker.js", + { scope: "./sw_clients/focus_stealing_client.html" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function loseFocus() { + var p = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data == "READY") { + ok(true, "iframe created."); + iframe.contentWindow.focus(); + } + } + window.onblur = function() { + ok(true, "blurred"); + res(); + } + }); + + content = document.getElementById("content"); + ok(content, "parent exists."); + + iframe = document.createElement("iframe"); + content.appendChild(iframe); + + iframe.setAttribute('src', "sw_clients/focus_stealing_client.html"); + return p; + } + + function testFocus() { + var p = new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function(e) { + ok(e.data, "client object is marked as focused."); + ok(document.hasFocus(), "document has focus."); + res(); + } + }); + + ok(registration.active, "active worker exists."); + registration.active.postMessage("go"); + return p; + } + + function runTest() { + start() + .then(loseFocus) + .then(testFocus) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_close.html b/dom/workers/test/serviceworkers/test_close.html new file mode 100644 index 000000000..d2f72b9ef --- /dev/null +++ b/dom/workers/test/serviceworkers/test_close.html @@ -0,0 +1,64 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1131353 - test WorkerGlobalScope.close() on service workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + navigator.serviceWorker.ready.then(setupSW); + navigator.serviceWorker.register("close_test.js", {scope: "."}); + + function setupSW(registration) { + var worker = registration.waiting || + registration.active; + var iframe = document.createElement("iframe"); + iframe.src = "message_receiver.html"; + iframe.onload = function() { + worker.postMessage({ message: "start" }); + }; + document.body.appendChild(iframe); + } + + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "done") { + navigator.serviceWorker.getRegistration().then(function(registration) { + registration.unregister().then(function(result) { + ok(result, "Unregistering the service worker should succeed"); + SimpleTest.finish(); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + SimpleTest.finish(); + }); + }); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_controller.html b/dom/workers/test/serviceworkers/test_controller.html new file mode 100644 index 000000000..789d7746d --- /dev/null +++ b/dom/workers/test/serviceworkers/test_controller.html @@ -0,0 +1,84 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1002570 - test controller instance.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var content; + var iframe; + var registration; + + function simpleRegister() { + // We use the control scope for the less specific registration. The window will register a worker on controller/ + return navigator.serviceWorker.register("worker.js", { scope: "./control" }) + .then(function(reg) { + registration = reg; + });; + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed: " + e + "\n"); + }); + } + + function testController() { + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "done") { + window.onmessage = null; + content.removeChild(iframe); + resolve(); + } + } + }); + + content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "controller/index.html"); + content.appendChild(iframe); + + return p; + } + + // This document just flips the prefs and opens the iframe for the actual test. + function runTest() { + simpleRegister() + .then(testController) + .then(unregister) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_cross_origin_url_after_redirect.html b/dom/workers/test/serviceworkers/test_cross_origin_url_after_redirect.html new file mode 100644 index 000000000..e56bb84ca --- /dev/null +++ b/dom/workers/test/serviceworkers/test_cross_origin_url_after_redirect.html @@ -0,0 +1,50 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test access to a cross origin Request.url property from a service worker for a redirected intercepted iframe</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/requesturl/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/requesturl/index.html"; + } else if (e.data.status == "done") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/requesturl/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_csp_upgrade-insecure_intercept.html b/dom/workers/test/serviceworkers/test_csp_upgrade-insecure_intercept.html new file mode 100644 index 000000000..fe4cb991c --- /dev/null +++ b/dom/workers/test/serviceworkers/test_csp_upgrade-insecure_intercept.html @@ -0,0 +1,55 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that a CSP upgraded request can be intercepted by a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/upgrade-insecure/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/upgrade-insecure/embedder.html"; + } else if (e.data.status == "protocol") { + is(e.data.data, "https:", "Correct protocol expected"); + } else if (e.data.status == "image") { + is(e.data.data, 40, "The image request was upgraded before interception"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/upgrade-insecure/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + // This is needed so that we can test upgrading a non-secure load inside an https iframe. + ["security.mixed_content.block_active_content", false], + ["security.mixed_content.block_display_content", false], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_empty_serviceworker.html b/dom/workers/test/serviceworkers/test_empty_serviceworker.html new file mode 100644 index 000000000..e42951896 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_empty_serviceworker.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that registering an empty service worker works</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + navigator.serviceWorker.ready.then(done); + navigator.serviceWorker.register("empty.js", {scope: "."}); + } + + function done(registration) { + ok(registration.waiting || registration.active, "registration worked"); + registration.unregister().then(function(success) { + ok(success, "unregister worked"); + SimpleTest.finish(); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_error_reporting.html b/dom/workers/test/serviceworkers/test_error_reporting.html new file mode 100644 index 000000000..619d602e8 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_error_reporting.html @@ -0,0 +1,76 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test Error Reporting of Service Worker Failures</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/SpawnTask.js"></script> + <script src="error_reporting_helpers.js"></script> + <link rel="stylesheet" href="/tests/SimpleTest/test.css"/> + <meta http-equiv="Content-type" content="text/html;charset=UTF-8"> +</head> +<body> + +<script type="text/javascript"> +"use strict"; + +/** + * Test that a bunch of service worker coding errors and failure modes that + * might otherwise be hard to diagnose are surfaced as console error messages. + * The driving use-case is minimizing cursing from a developer looking at a + * document in Firefox testing a page that involves service workers. + * + * This test assumes that errors will be reported via + * ServiceWorkerManager::ReportToAllClients and that that method is reliable and + * tested via some other file. + **/ + +add_task(function setupPrefs() { + return SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.testing.enabled", true], + ]}); +}); + +/** + * Ensure an error is logged during the initial registration of a SW when a 404 + * is received. + */ +add_task(function* register_404() { + // Start monitoring for the error + let expectedMessage = expect_console_message( + "ServiceWorkerRegisterNetworkError", + [make_absolute_url("network_error/"), "404", make_absolute_url("404.js")]); + + // Register, generating the 404 error. This will reject with a TypeError + // which we need to consume so it doesn't get thrown at our generator. + yield navigator.serviceWorker.register("404.js", { scope: "network_error/" }) + .then( + () => { ok(false, "should have rejected"); }, + (e) => { ok(e.name === "TypeError", "404 failed as expected"); }); + + yield wait_for_expected_message(expectedMessage); +}); + +/** + * Ensure an error is logged when the service worker is being served with a + * MIME type of text/plain rather than a JS type. + */ +add_task(function* register_bad_mime_type() { + let expectedMessage = expect_console_message( + "ServiceWorkerRegisterMimeTypeError", + [make_absolute_url("bad_mime_type/"), "text/plain", + make_absolute_url("sw_bad_mime_type.js")]); + + // consume the expected rejection so it doesn't get thrown at us. + yield navigator.serviceWorker.register("sw_bad_mime_type.js", { scope: "bad_mime_type/" }) + .then( + () => { ok(false, "should have rejected"); }, + (e) => { ok(e.name === "SecurityError", "bad MIME type failed as expected"); }); + + yield wait_for_expected_message(expectedMessage); +}); +</script> + +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_escapedSlashes.html b/dom/workers/test/serviceworkers/test_escapedSlashes.html new file mode 100644 index 000000000..001c66024 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_escapedSlashes.html @@ -0,0 +1,102 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for escaped slashes in navigator.serviceWorker.register</title> + <script type="text/javascript" src="http://mochi.test:8888/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="http://mochi.test:8888/tests/SimpleTest/test.css" /> + <base href="https://mozilla.org/"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + +var tests = [ + { status: true, + scriptURL: "a.js?foo%2fbar", + scopeURL: null }, + { status: false, + scriptURL: "foo%2fbar", + scopeURL: null }, + { status: true, + scriptURL: "a.js?foo%2Fbar", + scopeURL: null }, + { status: false, + scriptURL: "foo%2Fbar", + scopeURL: null }, + { status: true, + scriptURL: "a.js?foo%5cbar", + scopeURL: null }, + { status: false, + scriptURL: "foo%5cbar", + scopeURL: null }, + { status: true, + scriptURL: "a.js?foo%2Cbar", + scopeURL: null }, + { status: false, + scriptURL: "foo%5Cbar", + scopeURL: null }, + { status: true, + scriptURL: "ok.js", + scopeURL: "/scope?foo%2fbar"}, + { status: false, + scriptURL: "ok.js", + scopeURL: "/foo%2fbar"}, + { status: true, + scriptURL: "ok.js", + scopeURL: "/scope?foo%2Fbar"}, + { status: false, + scriptURL: "ok.js", + scopeURL: "foo%2Fbar"}, + { status: true, + scriptURL: "ok.js", + scopeURL: "/scope?foo%5cbar"}, + { status: false, + scriptURL: "ok.js", + scopeURL: "foo%5cbar"}, + { status: true, + scriptURL: "ok.js", + scopeURL: "/scope?foo%5Cbar"}, + { status: false, + scriptURL: "ok.js", + scopeURL: "foo%5Cbar"}, +]; + +function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + navigator.serviceWorker.register(test.scriptURL, test.scopeURL) + .then(reg => { + ok(false, "Register should fail"); + }, err => { + if (!test.status) { + is(err.name, "TypeError", "Registration should fail with TypeError"); + } else { + ok(test.status, "Register should fail"); + } + }) + .then(runTest); +} + +SimpleTest.waitForExplicitFinish(); +onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.serviceWorkers.enabled", true], + ]}, runTest); +}; + +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_eval_allowed.html b/dom/workers/test/serviceworkers/test_eval_allowed.html new file mode 100644 index 000000000..bfe8ac280 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_eval_allowed.html @@ -0,0 +1,51 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1160458 - CSP activated by default in Service Workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + function register() { + return navigator.serviceWorker.register("eval_worker.js"); + } + + function runTest() { + try { + eval("1"); + ok(false, "should throw"); + } + catch (ex) { + ok(true, "did throw"); + } + register() + .then(function(swr) { + ok(true, "eval restriction didn't get inherited"); + swr.unregister() + .then(function() { + SimpleTest.finish(); + }); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_eval_allowed.html^headers^ b/dom/workers/test/serviceworkers/test_eval_allowed.html^headers^ new file mode 100644 index 000000000..51ffaa71d --- /dev/null +++ b/dom/workers/test/serviceworkers/test_eval_allowed.html^headers^ @@ -0,0 +1 @@ +Content-Security-Policy: "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self'" diff --git a/dom/workers/test/serviceworkers/test_eventsource_intercept.html b/dom/workers/test/serviceworkers/test_eventsource_intercept.html new file mode 100644 index 000000000..55df62bb7 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_eventsource_intercept.html @@ -0,0 +1,103 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182103 - Test EventSource scenarios with fetch interception</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function testFrame(src) { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.onmessage = function(e) { + if (e.data.status == "callback") { + switch(e.data.data) { + case "ok": + ok(e.data.condition, e.data.message); + break; + case "ready": + iframe.contentWindow.postMessage({status: "callback", data: "eventsource"}, "*"); + break; + case "done": + window.onmessage = null; + iframe.src = "about:blank"; + document.body.removeChild(iframe); + iframe = null; + resolve(); + break; + default: + ok(false, "Something went wrong"); + break; + } + } else { + ok(false, "Something went wrong"); + } + }; + document.body.appendChild(iframe); + }); + } + + function runTest() { + Promise.resolve() + .then(() => { + info("Going to intercept and test opaque responses"); + return testFrame("eventsource/eventsource_register_worker.html" + + "?script=eventsource_opaque_response_intercept_worker.js"); + }) + .then(() => { + return testFrame("eventsource/eventsource_opaque_response.html"); + }) + .then(() => { + info("Going to intercept and test cors responses"); + return testFrame("eventsource/eventsource_register_worker.html" + + "?script=eventsource_cors_response_intercept_worker.js"); + }) + .then(() => { + return testFrame("eventsource/eventsource_cors_response.html"); + }) + .then(() => { + info("Going to intercept and test synthetic responses"); + return testFrame("eventsource/eventsource_register_worker.html" + + "?script=eventsource_synthetic_response_intercept_worker.js"); + }) + .then(() => { + return testFrame("eventsource/eventsource_synthetic_response.html"); + }) + .then(() => { + info("Going to intercept and test mixed content cors responses"); + return testFrame("https://example.com/tests/dom/workers/test/serviceworkers/" + + "eventsource/eventsource_register_worker.html" + + "?script=eventsource_mixed_content_cors_response_intercept_worker.js"); + }) + .then(() => { + return testFrame("https://example.com/tests/dom/workers/test/serviceworkers/" + + "eventsource/eventsource_mixed_content_cors_response.html"); + }) + .then(SimpleTest.finish) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_fetch_event.html b/dom/workers/test/serviceworkers/test_fetch_event.html new file mode 100644 index 000000000..764be87b1 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_fetch_event.html @@ -0,0 +1,83 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 94048 - test install event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + SimpleTest.requestCompleteLog(); + + var registration; + function simpleRegister() { + var p = navigator.serviceWorker.register("fetch_event_worker.js", { scope: "./fetch" }); + return p.then(function(swr) { + registration = swr; + return new Promise(function(resolve) { + swr.installing.onstatechange = resolve; + }); + }); + } + + function unregister() { + return registration.unregister().then(function(success) { + ok(success, "Service worker should be unregistered successfully"); + }, function(e) { + dump("SW unregistration error: " + e + "\n"); + }); + } + + function testController() { + var p = new Promise(function(resolve, reject) { + var reloaded = false; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "done") { + if (reloaded) { + window.onmessage = null; + w.close(); + resolve(); + } else { + w.location.reload(); + reloaded = true; + } + } + } + }); + + var w = window.open("fetch/index.html"); + return p; + } + + function runTest() { + simpleRegister() + .then(testController) + .then(unregister) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_fetch_integrity.html b/dom/workers/test/serviceworkers/test_fetch_integrity.html new file mode 100644 index 000000000..50eb05581 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_fetch_integrity.html @@ -0,0 +1,178 @@ +<!DOCTYPE HTML> +<html> +<head> + <title> Test fetch.integrity on console report for serviceWorker and sharedWorker </title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/SpawnTask.js"></script> + <script src="error_reporting_helpers.js"></script> + <link rel="stylesheet" href="/tests/SimpleTest/test.css"/> + <meta http-equiv="Content-type" content="text/html;charset=UTF-8"> +</head> +<body> +<div id="content" style="display: none"></div> +<script type="text/javascript"> +"use strict"; + +let security_localizer = + stringBundleService.createBundle("chrome://global/locale/security/security.properties"); + +function expect_security_console_message(/* msgId, args, ... */) { + let expectations = []; + // process repeated paired arguments of: msgId, args + for (let i = 0; i < arguments.length; i += 4) { + let msgId = arguments[i]; + let args = arguments[i + 1]; + let filename = arguments[i + 2]; + let windowId = arguments[i + 3]; + expectations.push({ + errorMessage: security_localizer.formatStringFromName(msgId, args, args.length), + sourceName: filename, + windowID: windowId + }); + } + return new Promise(resolve => { + SimpleTest.monitorConsole(resolve, expectations); + }); +} + +// (This doesn't really need to be its own task, but it allows the actual test +// case to be self-contained.) +add_task(function setupPrefs() { + return SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}); +}); + +add_task(function* test_integrity_serviceWorker() { + var filename = make_absolute_url("fetch.js"); + var filename2 = make_absolute_url("fake.html"); + + // The SW will claim us once it activates; this is async, start listening now. + let waitForControlled = new Promise((resolve) => { + navigator.serviceWorker.oncontrollerchange = resolve; + }); + + let registration = yield navigator.serviceWorker.register("fetch.js", + { scope: "./" }); + yield waitForControlled; + + info("Test for mNavigationInterceptions.") + // The client_win will reload to another URL after opening filename2. + let client_win = window.open(filename2); + + // XXX windowID should be innerWindowID + let mainWindowID = SpecialPowers.getDOMWindowUtils(window).outerWindowID; + let clientWindowID = SpecialPowers.getDOMWindowUtils(client_win).outerWindowID; + let expectedMessage = expect_security_console_message( + "MalformedIntegrityHash", + ["abc"], + filename, + mainWindowID, + "NoValidMetadata", + [""], + filename, + mainWindowID + ); + let expectedMessage2 = expect_security_console_message( + "MalformedIntegrityHash", + ["abc"], + filename, + clientWindowID, + "NoValidMetadata", + [""], + filename, + clientWindowID + ); + + info("Test for mControlledDocuments and report error message to console."); + // The fetch will succeed because the integrity value is invalid and we are + // looking for the console message regarding the bad integrity value. + yield fetch("fail.html"); + + yield wait_for_expected_message(expectedMessage); + + yield wait_for_expected_message(expectedMessage2); + + yield registration.unregister(); + client_win.close(); +}); + +add_task(function* test_integrity_sharedWorker() { + var filename = make_absolute_url("sharedWorker_fetch.js"); + + info("Attch main window to a SharedWorker."); + let sharedWorker = new SharedWorker(filename); + let waitForConnected = new Promise((resolve) => { + sharedWorker.port.onmessage = function (e) { + if (e.data == "Connected") { + resolve(); + } else { + reject(); + } + } + }); + yield waitForConnected; + + info("Attch another window to the same SharedWorker."); + // Open another window and its also managed by the shared worker. + let client_win = window.open("create_another_sharedWorker.html"); + let waitForBothConnected = new Promise((resolve) => { + sharedWorker.port.onmessage = function (e) { + if (e.data == "BothConnected") { + resolve(); + } else { + reject(); + } + } + }); + yield waitForBothConnected; + + // XXX windowID should be innerWindowID + let mainWindowID = SpecialPowers.getDOMWindowUtils(window).outerWindowID; + let clientWindowID = SpecialPowers.getDOMWindowUtils(client_win).outerWindowID; + let expectedMessage = expect_security_console_message( + "MalformedIntegrityHash", + ["abc"], + filename, + mainWindowID, + "NoValidMetadata", + [""], + filename, + mainWindowID + ); + let expectedMessage2 = expect_security_console_message( + "MalformedIntegrityHash", + ["abc"], + filename, + clientWindowID, + "NoValidMetadata", + [""], + filename, + clientWindowID + ); + + info("Start to fetch a URL with wrong integrity.") + sharedWorker.port.start(); + sharedWorker.port.postMessage("StartFetchWithWrongIntegrity"); + + let waitForSRIFailed = new Promise((resolve) => { + sharedWorker.port.onmessage = function (e) { + if (e.data == "SRI_failed") { + resolve(); + } else { + reject(); + } + } + }); + yield waitForSRIFailed; + + yield wait_for_expected_message(expectedMessage); + + yield wait_for_expected_message(expectedMessage2); + client_win.close(); +}); + +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_file_blob_response.html b/dom/workers/test/serviceworkers/test_file_blob_response.html new file mode 100644 index 000000000..6db0656c6 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_file_blob_response.html @@ -0,0 +1,86 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1253777 - Test interception using file blob response body</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var scope = './file_blob_response/'; + function start() { + return navigator.serviceWorker.register("file_blob_response_worker.js", + { scope: scope }) + .then(function(swr) { + registration = swr; + return new Promise(function(resolve) { + registration.installing.onstatechange = function(evt) { + if (evt.target.state === 'activated') { + evt.target.onstate = null; + resolve(); + } + } + }); + }); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e + "\n"); + }); + } + + function withFrame(url) { + return new Promise(function(resolve, reject) { + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + var frame = document.createElement("iframe"); + frame.setAttribute('src', url); + content.appendChild(frame); + + frame.addEventListener('load', function loadCallback(evt) { + frame.removeEventListener('load', loadCallback); + resolve(frame); + }); + }); + } + + function runTest() { + start() + .then(function() { + return withFrame(scope + 'dummy.txt'); + }) + .then(function(frame) { + var result = JSON.parse(frame.contentWindow.document.body.textContent); + frame.remove(); + is(result.value, 'success'); + }) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }) + .then(unregister) + .then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_file_blob_upload.html b/dom/workers/test/serviceworkers/test_file_blob_upload.html new file mode 100644 index 000000000..30a31eb7e --- /dev/null +++ b/dom/workers/test/serviceworkers/test_file_blob_upload.html @@ -0,0 +1,145 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1203680 - Test interception of file blob uploads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var iframe; + function start() { + return navigator.serviceWorker.register("empty.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + if (iframe) { + iframe.remove(); + iframe = null; + } + + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + ok(false, "Unregistering the SW failed with " + e + "\n"); + }); + } + + function withFrame() { + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/file_blob_upload_frame.html"); + content.appendChild(iframe); + + return new Promise(function(resolve, reject) { + window.addEventListener('message', function readyCallback(evt) { + window.removeEventListener('message', readyCallback); + if (evt.data.status === 'READY') { + resolve(); + } else { + reject(evt.data.result); + } + }); + }); + } + + function postBlob(body) { + return new Promise(function(resolve, reject) { + window.addEventListener('message', function postBlobCallback(evt) { + window.removeEventListener('message', postBlobCallback); + if (evt.data.status === 'OK') { + is(JSON.stringify(body), JSON.stringify(evt.data.result), + 'body echoed back correctly'); + resolve(); + } else { + reject(evt.data.result); + } + }); + + iframe.contentWindow.postMessage({ type: 'TEST', body: body }, '*'); + }); + } + + function generateMessage(length) { + + var lorem = + 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis egestas ' + 'vehicula tortor eget ultrices. Sed et luctus est. Nunc eu orci ligula. ' + 'In vel ornare eros, eget lacinia diam. Praesent vel metus mattis, ' + 'cursus nulla sit amet, rhoncus diam. Aliquam nulla tortor, aliquet et ' + 'viverra non, dignissim vel tellus. Praesent sed ex in dolor aliquet ' + 'aliquet. In at facilisis sem, et aliquet eros. Maecenas feugiat nisl ' + 'quis elit blandit posuere. Duis viverra odio sed eros consectetur, ' + 'viverra mattis ligula volutpat.'; + + var result = ''; + + while (result.length < length) { + var remaining = length - result.length; + if (remaining < lorem.length) { + result += lorem.slice(0, remaining); + } else { + result += lorem; + } + } + + return result; + } + + var smallBody = generateMessage(64); + var mediumBody = generateMessage(1024); + + // TODO: Test large bodies over the default pipe size. Currently stalls + // due to bug 1134372. + //var largeBody = generateMessage(100 * 1024); + + function runTest() { + start() + .then(withFrame) + .then(function() { + return postBlob({ hops: 0, message: smallBody }); + }) + .then(function() { + return postBlob({ hops: 1, message: smallBody }); + }) + .then(function() { + return postBlob({ hops: 10, message: smallBody }); + }) + .then(function() { + return postBlob({ hops: 0, message: mediumBody }); + }) + .then(function() { + return postBlob({ hops: 1, message: mediumBody }); + }) + .then(function() { + return postBlob({ hops: 10, message: mediumBody }); + }) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_force_refresh.html b/dom/workers/test/serviceworkers/test_force_refresh.html new file mode 100644 index 000000000..05caf0e6a --- /dev/null +++ b/dom/workers/test/serviceworkers/test_force_refresh.html @@ -0,0 +1,84 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test service worker post message </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + function start() { + return navigator.serviceWorker.register("force_refresh_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testForceRefresh(swr) { + var p = new Promise(function(res, rej) { + var count = 0; + var cachedCount = 0; + window.onmessage = function(e) { + if (e.data === "READY") { + count += 1; + if (count == 2) { + is(cachedCount, 1, "should have received cached message before " + + "second non-cached message"); + res(); + } + iframe.contentWindow.postMessage("REFRESH", "*"); + } else if (e.data === "READY_CACHED") { + cachedCount += 1; + is(count, 1, "should have received non-cached message before " + + "cached message"); + iframe.contentWindow.postMessage("FORCE_REFRESH", "*"); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/refresher_compressed.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testForceRefresh) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_gzip_redirect.html b/dom/workers/test/serviceworkers/test_gzip_redirect.html new file mode 100644 index 000000000..7ac92122c --- /dev/null +++ b/dom/workers/test/serviceworkers/test_gzip_redirect.html @@ -0,0 +1,84 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test service worker post message </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + function start() { + return navigator.serviceWorker.register("gzip_redirect_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testGzipRedirect(swr) { + var p = new Promise(function(res, rej) { + var navigatorReady = false; + var finalReady = false; + + window.onmessage = function(e) { + if (e.data === "NAVIGATOR_READY") { + ok(!navigatorReady, "should only get navigator ready message once"); + ok(!finalReady, "should get navigator ready before final redirect ready message"); + navigatorReady = true; + iframe.contentWindow.postMessage({ + type: "NAVIGATE", + url: "does_not_exist.html" + }, "*"); + } else if (e.data === "READY") { + ok(navigatorReady, "should only get navigator ready message once"); + ok(!finalReady, "should get final ready message only once"); + finalReady = true; + res(); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/navigator.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testGzipRedirect) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_hsts_upgrade_intercept.html b/dom/workers/test/serviceworkers/test_hsts_upgrade_intercept.html new file mode 100644 index 000000000..dfce406b8 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_hsts_upgrade_intercept.html @@ -0,0 +1,66 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that an HSTS upgraded request can be intercepted by a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + var framesLoaded = 0; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "http://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/index.html"; + } else if (e.data.status == "protocol") { + is(e.data.data, "https:", "Correct protocol expected"); + ok(e.data.securityInfoPresent, "Security info present on intercepted value"); + switch (++framesLoaded) { + case 1: + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/embedder.html"; + break; + case 2: + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/image.html"; + break; + } + } else if (e.data.status == "image") { + is(e.data.data, 40, "The image request was upgraded before interception"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/hsts/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + SpecialPowers.cleanUpSTSData("http://example.com"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + // This is needed so that we can test upgrading a non-secure load inside an https iframe. + ["security.mixed_content.block_active_content", false], + ["security.mixed_content.block_display_content", false], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_https_fetch.html b/dom/workers/test/serviceworkers/test_https_fetch.html new file mode 100644 index 000000000..e990200f8 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_https_fetch.html @@ -0,0 +1,62 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1133763 - test fetch event in HTTPS origins</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/register.html"; + var ios; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + ios = SpecialPowers.Cc["@mozilla.org/network/io-service;1"] + .getService(SpecialPowers.Ci.nsIIOService); + ios.offline = true; + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/index.html"; + } else if (e.data.status == "done") { + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/synth-sw.html"; + } else if (e.data.status == "done-synth-sw") { + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/synth-window.html"; + } else if (e.data.status == "done-synth-window") { + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/synth.html"; + } else if (e.data.status == "done-synth") { + ios.offline = false; + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true] + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_https_fetch_cloned_response.html b/dom/workers/test/serviceworkers/test_https_fetch_cloned_response.html new file mode 100644 index 000000000..1cf1dbef1 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_https_fetch_cloned_response.html @@ -0,0 +1,56 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1133763 - test fetch event in HTTPS origins with a cloned response</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/clonedresponse/register.html"; + var ios; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + ios = SpecialPowers.Cc["@mozilla.org/network/io-service;1"] + .getService(SpecialPowers.Ci.nsIIOService); + ios.offline = true; + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/clonedresponse/index.html"; + } else if (e.data.status == "done") { + ios.offline = false; + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/clonedresponse/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true] + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_https_origin_after_redirect.html b/dom/workers/test/serviceworkers/test_https_origin_after_redirect.html new file mode 100644 index 000000000..3878a1df6 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_https_origin_after_redirect.html @@ -0,0 +1,57 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/index-https.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "https://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_https_origin_after_redirect_cached.html b/dom/workers/test/serviceworkers/test_https_origin_after_redirect_cached.html new file mode 100644 index 000000000..81a1d1da0 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_https_origin_after_redirect_cached.html @@ -0,0 +1,57 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/index-cached-https.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "https://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/origin/https/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_https_synth_fetch_from_cached_sw.html b/dom/workers/test/serviceworkers/test_https_synth_fetch_from_cached_sw.html new file mode 100644 index 000000000..7bf3b352a --- /dev/null +++ b/dom/workers/test/serviceworkers/test_https_synth_fetch_from_cached_sw.html @@ -0,0 +1,69 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1156847 - test fetch event generating a synthesized response in HTTPS origins from a cached SW</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" tyle="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/register.html"; + var ios; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + ios = SpecialPowers.Cc["@mozilla.org/network/io-service;1"] + .getService(SpecialPowers.Ci.nsIIOService); + ios.offline = true; + + // In order to load synth.html from a cached service worker, we first + // remove the existing window that is keeping the service worker alive, + // and do a GC to ensure that the SW is destroyed. This way, when we + // load synth.html for the second time, we will first recreate the + // service worker from the cache. This is intended to test that we + // properly store and retrieve the security info from the cache. + iframe.parentNode.removeChild(iframe); + iframe = null; + SpecialPowers.exactGC(function() { + iframe = document.createElement("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/synth.html"; + document.body.appendChild(iframe); + }); + } else if (e.data.status == "done-synth") { + ios.offline = false; + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/https/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true] + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_imagecache.html b/dom/workers/test/serviceworkers/test_imagecache.html new file mode 100644 index 000000000..8627b54af --- /dev/null +++ b/dom/workers/test/serviceworkers/test_imagecache.html @@ -0,0 +1,55 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1202085 - Test that images from different controllers don't cached together</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache/index.html"; + } else if (e.data.status == "result") { + is(e.data.url, "image-40px.png", "Correct url expected"); + is(e.data.width, 40, "Correct width expected"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache/postmortem.html"; + } else if (e.data.status == "postmortem") { + is(e.data.width, 20, "Correct width expected"); + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_imagecache_max_age.html b/dom/workers/test/serviceworkers/test_imagecache_max_age.html new file mode 100644 index 000000000..eb3c1f166 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_imagecache_max_age.html @@ -0,0 +1,71 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that the image cache respects a synthesized image's Cache headers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + var framesLoaded = 0; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache-maxage/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache-maxage/index.html"; + } else if (e.data.status == "result") { + switch (++framesLoaded) { + case 1: + is(e.data.url, "image-20px.png", "Correct url expected"); + is(e.data.url2, "image-20px.png", "Correct url expected"); + is(e.data.width, 20, "Correct width expected"); + is(e.data.width2, 20, "Correct width expected"); + // Wait for 100ms so that the image gets expired. + setTimeout(function() { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache-maxage/index.html?new" + }, 100); + break; + case 2: + is(e.data.url, "image-40px.png", "Correct url expected"); + is(e.data.url2, "image-40px.png", "Correct url expected"); + is(e.data.width, 40, "Correct width expected"); + is(e.data.width2, 40, "Correct width expected"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/imagecache-maxage/unregister.html"; + break; + default: + ok(false, "This should never happen"); + } + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + SimpleTest.finish(); + } + }; + } + + SimpleTest.requestFlakyTimeout("This test needs to simulate the passing of time"); + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_importscript.html b/dom/workers/test/serviceworkers/test_importscript.html new file mode 100644 index 000000000..5d2d5b352 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_importscript.html @@ -0,0 +1,72 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test service worker - script cache policy</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="content"></div> +<script class="testbody" type="text/javascript"> + function start() { + return navigator.serviceWorker.register("importscript_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return fetch("importscript.sjs?clearcounter").then(function() { + return registration.unregister(); + }).then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function testPostMessage(swr) { + var p = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data === "READY") { + swr.active.postMessage("do magic"); + return; + } + + ok(e.data === "OK", "Worker posted the correct value: " + e.data); + res(); + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/service_worker_controlled.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testPostMessage) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_importscript_mixedcontent.html b/dom/workers/test/serviceworkers/test_importscript_mixedcontent.html new file mode 100644 index 000000000..a659af92b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_importscript_mixedcontent.html @@ -0,0 +1,53 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1198078 - test that we respect mixed content blocking in importScript() inside service workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/register.html"; + var ios; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/index.html"; + } else if (e.data.status == "done") { + ok(e.data.data, "good", "Mixed content blocking should work correctly for service workers"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/fetch/importscript-mixedcontent/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["security.mixed_content.block_active_content", false], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_install_event.html b/dom/workers/test/serviceworkers/test_install_event.html new file mode 100644 index 000000000..0e59510fe --- /dev/null +++ b/dom/workers/test/serviceworkers/test_install_event.html @@ -0,0 +1,144 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 94048 - test install event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + var p = navigator.serviceWorker.register("worker.js", { scope: "./install_event" }); + return p; + } + + function nextRegister(reg) { + ok(reg instanceof ServiceWorkerRegistration, "reg should be a ServiceWorkerRegistration"); + var p = navigator.serviceWorker.register("install_event_worker.js", { scope: "./install_event" }); + return p.then(function(swr) { + ok(reg === swr, "register should resolve to the same registration object"); + var update_found_promise = new Promise(function(resolve, reject) { + swr.addEventListener('updatefound', function(e) { + ok(true, "Received onupdatefound"); + resolve(); + }); + }); + + var worker_activating = new Promise(function(res, reject) { + ok(swr.installing instanceof ServiceWorker, "There should be an installing worker if promise resolves."); + ok(swr.installing.state == "installing", "Installing worker's state should be 'installing'"); + swr.installing.onstatechange = function(e) { + if (e.target.state == "activating") { + e.target.onstatechange = null; + res(); + } + } + }); + + return Promise.all([update_found_promise, worker_activating]); + }, function(e) { + ok(false, "Unexpected Error in nextRegister! " + e); + }); + } + + function installError() { + // Silence worker errors so they don't cause the test to fail. + window.onerror = function(e) {} + return navigator.serviceWorker.register("install_event_error_worker.js", { scope: "./install_event" }) + .then(function(swr) { + ok(swr.installing instanceof ServiceWorker, "There should be an installing worker if promise resolves."); + ok(swr.installing.state == "installing", "Installing worker's state should be 'installing'"); + return new Promise(function(resolve, reject) { + swr.installing.onstatechange = function(e) { + ok(e.target.state == "redundant", "Installation of worker with error should fail."); + resolve(); + } + }); + }).then(function() { + return navigator.serviceWorker.getRegistration("./install_event").then(function(swr) { + var newest = swr.waiting || swr.active; + ok(newest, "Waiting or active worker should still exist"); + ok(newest.scriptURL.match(/install_event_worker.js$/), "Previous worker should remain the newest worker"); + }); + }); + } + + function testActive(worker) { + is(worker.state, "activating", "Should be activating"); + return new Promise(function(resolve, reject) { + worker.onstatechange = function(e) { + e.target.onstatechange = null; + is(e.target.state, "activated", "Activation of worker with error in activate event handler should still succeed."); + resolve(); + } + }); + } + + function activateErrorShouldSucceed() { + // Silence worker errors so they don't cause the test to fail. + window.onerror = function() { } + return navigator.serviceWorker.register("activate_event_error_worker.js", { scope: "./activate_error" }) + .then(function(swr) { + var p = new Promise(function(resolve, reject) { + ok(swr.installing.state == "installing", "activateErrorShouldSucceed(): Installing worker's state should be 'installing'"); + swr.installing.onstatechange = function(e) { + e.target.onstatechange = null; + if (swr.waiting) { + swr.waiting.onstatechange = function(e) { + e.target.onstatechange = null; + testActive(swr.active).then(resolve, reject); + } + } else { + testActive(swr.active).then(resolve, reject); + } + } + }); + + return p.then(function() { + return Promise.resolve(swr); + }); + }).then(function(swr) { + return swr.unregister(); + }); + } + + function unregister() { + return navigator.serviceWorker.getRegistration("./install_event").then(function(reg) { + return reg.unregister(); + }); + } + + function runTest() { + Promise.resolve() + .then(simpleRegister) + .then(nextRegister) + .then(installError) + .then(activateErrorShouldSucceed) + .then(unregister) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_install_event_gc.html b/dom/workers/test/serviceworkers/test_install_event_gc.html new file mode 100644 index 000000000..ccccd2b43 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_install_event_gc.html @@ -0,0 +1,121 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test install event being GC'd before waitUntil fulfills</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script class="testbody" type="text/javascript"> +var script = 'blocking_install_event_worker.js'; +var scope = 'sw_clients/simple.html?install-event-gc'; +var registration; + +function register() { + return navigator.serviceWorker.register(script, { scope: scope }) + .then(swr => registration = swr); +} + +function unregister() { + if (!registration) { + return; + } + return registration.unregister(); +} + +function waitForInstallEvent() { + return new Promise((resolve, reject) => { + navigator.serviceWorker.addEventListener('message', evt => { + if (evt.data.type === 'INSTALL_EVENT') { + resolve(); + } + }); + }); +} + +function gcWorker() { + return new Promise(function(resolve, reject) { + // We are able to trigger asynchronous garbage collection and cycle + // collection by emitting "child-cc-request" and "child-gc-request" + // observer notifications. The worker RuntimeService will translate + // these notifications into the appropriate operation on all known + // worker threads. + // + // In the failure case where GC/CC causes us to abort the installation, + // we will know something happened from the statechange event. + const statechangeHandler = evt => { + // Reject rather than resolving to avoid the possibility of us seeing + // an unrelated racing statechange somehow. Since in the success case we + // will still see a state change on termination, we do explicitly need to + // be removed on the success path. + ok(registration.installing, 'service worker is still installing?'); + reject(); + }; + registration.installing.addEventListener('statechange', statechangeHandler); + // In the success case since the service worker installation is effectively + // hung, we instead depend on sending a 'ping' message to the service worker + // and hearing it 'pong' back. Since we issue our postMessage after we + // trigger the GC/CC, our 'ping' will only be processed after the GC/CC and + // therefore the pong will also strictly occur after the cycle collection. + navigator.serviceWorker.addEventListener('message', evt => { + if (evt.data.type === 'pong') { + registration.installing.removeEventListener( + 'statechange', statechangeHandler); + resolve(); + } + }); + // At the current time, the service worker will exist in our same process + // and notifyObservers is synchronous. However, in the future, service + // workers may end up in a separate process and in that case it will be + // appropriate to use notifyObserversInParentProcess or something like it. + // (notifyObserversInParentProcess is a synchronous IPC call to the parent + // process's main thread. IPDL PContent::CycleCollect is an async message. + // Ordering will be maintained if the postMessage goes via PContent as well, + // but that seems unlikely.) + SpecialPowers.notifyObservers(null, 'child-gc-request', null); + SpecialPowers.notifyObservers(null, 'child-cc-request', null); + SpecialPowers.notifyObservers(null, 'child-gc-request', null); + // (Only send the ping after we set the gc/cc/gc in motion.) + registration.installing.postMessage({ type: 'ping' }); + }); +} + +function terminateWorker() { + return SpecialPowers.pushPrefEnv({ + set: [ + ["dom.serviceWorkers.idle_timeout", 0], + ["dom.serviceWorkers.idle_extended_timeout", 0] + ] + }).then(_ => { + registration.installing.postMessage({ type: 'RESET_TIMER' }); + }); +} + +function runTest() { + Promise.all([ + waitForInstallEvent(), + register() + ]).then(_ => ok(registration.installing, 'service worker is installing')) + .then(gcWorker) + .then(_ => ok(registration.installing, 'service worker is still installing')) + .then(terminateWorker) + .catch(e => ok(false, e)) + .then(unregister) + .then(SimpleTest.finish); +} + +SimpleTest.waitForExplicitFinish(); +SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], +]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_installation_simple.html b/dom/workers/test/serviceworkers/test_installation_simple.html new file mode 100644 index 000000000..1b0d6c947 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_installation_simple.html @@ -0,0 +1,212 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 930348 - test stub Navigator ServiceWorker utilities.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + var p = navigator.serviceWorker.register("worker.js", { scope: "simpleregister/" }); + ok(p instanceof Promise, "register() should return a Promise"); + return Promise.resolve(); + } + + function sameOriginWorker() { + p = navigator.serviceWorker.register("http://some-other-origin/worker.js"); + return p.then(function(w) { + ok(false, "Worker from different origin should fail"); + }, function(e) { + ok(e.name === "SecurityError", "Should fail with a SecurityError"); + }); + } + + function sameOriginScope() { + p = navigator.serviceWorker.register("worker.js", { scope: "http://www.example.com/" }); + return p.then(function(w) { + ok(false, "Worker controlling scope for different origin should fail"); + }, function(e) { + ok(e.name === "SecurityError", "Should fail with a SecurityError"); + }); + } + + function httpsOnly() { + var promise = new Promise(function(resolve) { + SpecialPowers.pushPrefEnv({'set': [["dom.serviceWorkers.testing.enabled", false]] }, resolve); + }); + + return promise.then(function() { + return navigator.serviceWorker.register("/worker.js"); + }).then(function(w) { + ok(false, "non-HTTPS pages cannot register ServiceWorkers"); + }, function(e) { + ok(e.name === "SecurityError", "Should fail with a SecurityError"); + }).then(function() { + return new Promise((resolve) => SpecialPowers.popPrefEnv(resolve)); + }); + } + + function realWorker() { + var p = navigator.serviceWorker.register("worker.js", { scope: "realworker" }); + return p.then(function(wr) { + ok(wr instanceof ServiceWorkerRegistration, "Register a ServiceWorker"); + + info(wr.scope); + ok(wr.scope == (new URL("realworker", document.baseURI)).href, "Scope should match"); + // active, waiting, installing should return valid worker instances + // because the registration is for the realworker scope, so the workers + // should be obtained for that scope and not for + // test_installation_simple.html + var worker = wr.installing; + ok(worker && wr.scope.match(/realworker$/) && + worker.scriptURL.match(/worker.js$/), "Valid worker instance should be available."); + return wr.unregister().then(function(success) { + ok(success, "The worker should be unregistered successfully"); + }, function(e) { + dump("Error unregistering the worker: " + e + "\n"); + }); + }, function(e) { + info("Error: " + e.name); + ok(false, "realWorker Registration should have succeeded!"); + }); + } + + function networkError404() { + return navigator.serviceWorker.register("404.js", { scope: "network_error/"}).then(function(w) { + ok(false, "404 response should fail with TypeError"); + }, function(e) { + ok(e.name === "TypeError", "404 response should fail with TypeError"); + }); + } + + function redirectError() { + return navigator.serviceWorker.register("redirect_serviceworker.sjs", { scope: "redirect_error/" }).then(function(swr) { + ok(false, "redirection should fail"); + }, function (e) { + ok(e.name === "SecurityError", "redirection should fail with SecurityError"); + }); + } + + function parseError() { + var p = navigator.serviceWorker.register("parse_error_worker.js", { scope: "parse_error/" }); + return p.then(function(wr) { + ok(false, "Registration should fail with parse error"); + return navigator.serviceWorker.getRegistration("parse_error/").then(function(swr) { + // See https://github.com/slightlyoff/ServiceWorker/issues/547 + is(swr, undefined, "A failed registration for a scope with no prior controllers should clear itself"); + }); + }, function(e) { + ok(e instanceof Error, "Registration should fail with parse error"); + }); + } + + // FIXME(nsm): test for parse error when Update step doesn't happen (directly from register). + + function updatefound() { + var frame = document.createElement("iframe"); + frame.setAttribute("id", "simpleregister-frame"); + frame.setAttribute("src", new URL("simpleregister/index.html", document.baseURI).href); + document.body.appendChild(frame); + var resolve, reject; + var p = new Promise(function(res, rej) { + resolve = res; + reject = rej; + }); + + var reg; + function continueTest() { + navigator.serviceWorker.register("worker2.js", { scope: "simpleregister/" }) + .then(function(r) { + reg = r; + });; + } + + window.onmessage = function(e) { + if (e.data.type == "ready") { + continueTest(); + } else if (e.data.type == "finish") { + window.onmessage = null; + // We have to make frame navigate away, otherwise it will call + // MaybeStopControlling() when this document is unloaded. At that point + // the pref has been disabled, so the ServiceWorkerManager is not available. + frame.setAttribute("src", new URL("about:blank").href); + reg.unregister().then(function(success) { + ok(success, "The worker should be unregistered successfully"); + resolve(); + }, function(e) { + dump("Error unregistering the worker: " + e + "\n"); + }); + } else if (e.data.type == "check") { + ok(e.data.status, e.data.msg); + } + } + return p; + } + + var readyPromiseResolved = false; + + function readyPromise() { + var frame = document.createElement("iframe"); + frame.setAttribute("id", "simpleregister-frame-ready"); + frame.setAttribute("src", new URL("simpleregister/ready.html", document.baseURI).href); + document.body.appendChild(frame); + + var channel = new MessageChannel(); + frame.addEventListener('load', function() { + frame.contentWindow.postMessage('your port!', '*', [channel.port2]); + }, false); + + channel.port1.onmessage = function() { + readyPromiseResolved = true; + } + + return Promise.resolve(); + } + + function checkReadyPromise() { + ok(readyPromiseResolved, "The ready promise has been resolved!"); + return Promise.resolve(); + } + + function runTest() { + simpleRegister() + .then(readyPromise) + .then(sameOriginWorker) + .then(sameOriginScope) + .then(httpsOnly) + .then(realWorker) + .then(networkError404) + .then(redirectError) + .then(parseError) + .then(updatefound) + .then(checkReadyPromise) + // put more tests here. + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_match_all.html b/dom/workers/test/serviceworkers/test_match_all.html new file mode 100644 index 000000000..f4e65a730 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_match_all.html @@ -0,0 +1,80 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - test match_all not crashing</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + // match_all_worker will call matchAll until the worker shuts down. + // Test passes if the browser doesn't crash on leaked promise objects. + var registration; + var content; + var iframe; + + function simpleRegister() { + return navigator.serviceWorker.register("match_all_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function closeAndUnregister() { + content.removeChild(iframe); + + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function openClient() { + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data === "READY") { + resolve(); + } + } + }); + + content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/simple.html"); + content.appendChild(iframe); + + return p; + } + + function runTest() { + simpleRegister() + .then(openClient) + .then(closeAndUnregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(function() { + ok(true, "Didn't crash on resolving matchAll promises while worker shuts down."); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_match_all_advanced.html b/dom/workers/test/serviceworkers/test_match_all_advanced.html new file mode 100644 index 000000000..a458ed70b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_match_all_advanced.html @@ -0,0 +1,100 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test matchAll with multiple clients</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var client_iframes = []; + var registration; + + function start() { + return navigator.serviceWorker.register("match_all_advanced_worker.js", + { scope: "./sw_clients/" }).then(function(swr) { + registration = swr; + window.onmessage = function (e) { + if (e.data === "READY") { + ok(registration.active, "Worker is active."); + registration.active.postMessage("RUN"); + } + } + }); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testMatchAll() { + var p = new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function (e) { + ok(e.data === client_iframes.length, "MatchAll returned the correct number of clients."); + res(); + } + }); + + content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/service_worker_controlled.html"); + content.appendChild(iframe); + + client_iframes.push(iframe); + return p; + } + + function removeAndTest() { + content = document.getElementById("content"); + ok(content, "Parent exists."); + + content.removeChild(client_iframes.pop()); + content.removeChild(client_iframes.pop()); + + return testMatchAll(); + } + + function runTest() { + start() + .then(testMatchAll) + .then(testMatchAll) + .then(testMatchAll) + .then(removeAndTest) + .then(function(e) { + content = document.getElementById("content"); + while (client_iframes.length) { + content.removeChild(client_iframes.pop()); + } + }).then(unregister).catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(function() { + SimpleTest.finish(); + }); + + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_match_all_client_id.html b/dom/workers/test/serviceworkers/test_match_all_client_id.html new file mode 100644 index 000000000..4c8ed9673 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_match_all_client_id.html @@ -0,0 +1,91 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1058311 - Test matchAll client id </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var clientURL = "match_all_client/match_all_client_id.html"; + function start() { + return navigator.serviceWorker.register("match_all_client_id_worker.js", + { scope: "./match_all_client/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function getMessageListener() { + return new Promise(function(res, rej) { + window.onmessage = function(e) { + ok(e.data, "Same client id for multiple calls."); + is(e.origin, "http://mochi.test:8888", "Event should have the correct origin"); + + if (!e.data) { + rej(); + return; + } + + info("DONE from: " + e.source); + res(); + } + }); + } + + function testNestedWindow() { + var p = getMessageListener(); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + + content.appendChild(iframe); + iframe.setAttribute('src', clientURL); + + return p.then(() => content.removeChild(iframe)); + } + + function testAuxiliaryWindow() { + var p = getMessageListener(); + var w = window.open(clientURL); + + return p.then(() => w.close()); + } + + function runTest() { + info(window.opener == undefined); + start() + .then(testAuxiliaryWindow) + .then(testNestedWindow) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_match_all_client_properties.html b/dom/workers/test/serviceworkers/test_match_all_client_properties.html new file mode 100644 index 000000000..14e3445a4 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_match_all_client_properties.html @@ -0,0 +1,97 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1058311 - Test matchAll clients properties </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var clientURL = "match_all_clients/match_all_controlled.html"; + function start() { + return navigator.serviceWorker.register("match_all_properties_worker.js", + { scope: "./match_all_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function getMessageListener() { + return new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data.message === undefined) { + info("rejecting promise"); + rej(); + return; + } + + ok(e.data.result, e.data.message); + + if (!e.data.result) { + rej(); + } + if (e.data.message == "DONE") { + info("DONE from: " + e.source); + res(); + } + } + }); + } + + function testNestedWindow() { + var p = getMessageListener(); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + + content.appendChild(iframe); + iframe.setAttribute('src', clientURL); + + return p.then(() => content.removeChild(iframe)); + } + + function testAuxiliaryWindow() { + var p = getMessageListener(); + var w = window.open(clientURL); + + return p.then(() => w.close()); + } + + function runTest() { + info("catalin"); + info(window.opener == undefined); + start() + .then(testAuxiliaryWindow) + .then(testNestedWindow) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_navigator.html b/dom/workers/test/serviceworkers/test_navigator.html new file mode 100644 index 000000000..164f41bcd --- /dev/null +++ b/dom/workers/test/serviceworkers/test_navigator.html @@ -0,0 +1,40 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 930348 - test stub Navigator ServiceWorker utilities.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function checkEnabled() { + ok(navigator.serviceWorker, "navigator.serviceWorker should exist when ServiceWorkers are enabled."); + ok(typeof navigator.serviceWorker.register === "function", "navigator.serviceWorker.register() should be a function."); + ok(typeof navigator.serviceWorker.getRegistration === "function", "navigator.serviceWorker.getAll() should be a function."); + ok(typeof navigator.serviceWorker.getRegistrations === "function", "navigator.serviceWorker.getAll() should be a function."); + ok(navigator.serviceWorker.ready instanceof Promise, "navigator.serviceWorker.ready should be a Promise."); + ok(navigator.serviceWorker.controller === null, "There should be no controller worker for an uncontrolled document."); + } + + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true] + ]}, function() { + checkEnabled(); + SimpleTest.finish(); + }); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_not_intercept_plugin.html b/dom/workers/test/serviceworkers/test_not_intercept_plugin.html new file mode 100644 index 000000000..a90e068d3 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_not_intercept_plugin.html @@ -0,0 +1,78 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1187766 - Test loading plugins scenarios with fetch interception.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + SimpleTest.requestCompleteLog(); + + var registration; + function simpleRegister() { + var p = navigator.serviceWorker.register("./fetch/plugin/worker.js", { scope: "./fetch/plugin/" }); + return p.then(function(swr) { + registration = swr; + return new Promise(function(resolve) { + swr.installing.onstatechange = resolve; + }); + }); + } + + function unregister() { + return registration.unregister().then(function(success) { + ok(success, "Service worker should be unregistered successfully"); + }, function(e) { + dump("SW unregistration error: " + e + "\n"); + }); + } + + function testPlugins() { + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "done") { + window.onmessage = null; + w.close(); + resolve(); + } + } + }); + + var w = window.open("fetch/plugin/plugins.html"); + return p; + } + + function runTest() { + simpleRegister() + .then(testPlugins) + .then(unregister) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.requestcontext.enabled", true], + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_notification_constructor_error.html b/dom/workers/test/serviceworkers/test_notification_constructor_error.html new file mode 100644 index 000000000..6a8ecf8c0 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notification_constructor_error.html @@ -0,0 +1,52 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug XXXXXXX - Check that Notification constructor throws in ServiceWorkerGlobalScope</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + return navigator.serviceWorker.register("notification_constructor_error.js", { scope: "notification_constructor_error/" }).then(function(swr) { + ok(false, "Registration should fail."); + }, function(e) { + is(e.name, 'TypeError', "Registration should fail with a TypeError."); + }); + } + + function runTest() { + MockServices.register(); + simpleRegister() + .then(function() { + MockServices.unregister(); + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + MockServices.unregister(); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["notification.prompt.testing", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_notification_get.html b/dom/workers/test/serviceworkers/test_notification_get.html new file mode 100644 index 000000000..dbb312e7b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notification_get.html @@ -0,0 +1,213 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>ServiceWorkerRegistration.getNotifications() on main thread and worker thread.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script type="text/javascript"> + + SimpleTest.requestFlakyTimeout("untriaged"); + + function testFrame(src) { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.callback = function(result) { + iframe.src = "about:blank"; + document.body.removeChild(iframe); + iframe = null; + SpecialPowers.exactGC(function() { + resolve(result); + }); + }; + document.body.appendChild(iframe); + }); + } + + function registerSW() { + return testFrame('notification/register.html').then(function() { + ok(true, "Registered service worker."); + }); + } + + function unregisterSW() { + return testFrame('notification/unregister.html').then(function() { + ok(true, "Unregistered service worker."); + }); + } + + // To check that the scope is respected when retrieving notifications. + function registerAlternateSWAndAddNotification() { + return testFrame('notification_alt/register.html').then(function() { + ok(true, "Registered alternate service worker."); + return navigator.serviceWorker.getRegistration("./notification_alt/").then(function(reg) { + return reg.showNotification("This is a notification_alt"); + }); + }); + } + + function unregisterAlternateSWAndAddNotification() { + return testFrame('notification_alt/unregister.html').then(function() { + ok(true, "unregistered alternate service worker."); + }); + } + + function testDismiss() { + // Dismissed persistent notifications should be removed from the + // notification list. + var alertsService = SpecialPowers.Cc["@mozilla.org/alerts-service;1"] + .getService(SpecialPowers.Ci.nsIAlertsService); + return navigator.serviceWorker.getRegistration("./notification/") + .then(function(reg) { + return reg.showNotification( + "This is a notification that will be closed", { tag: "dismiss" }) + .then(function() { + return reg; + }); + }).then(function(reg) { + return reg.getNotifications() + .then(function(notifications) { + is(notifications.length, 1, "There should be one visible notification"); + is(notifications[0].tag, "dismiss", "Tag should match"); + + // Simulate dismissing the notification by using the alerts service + // directly, instead of `Notification#close`. + var principal = SpecialPowers.wrap(document).nodePrincipal; + var id = principal.origin + "#tag:dismiss"; + alertsService.closeAlert(id, principal); + + return reg; + }); + }).then(function(reg) { + return reg.getNotifications(); + }).then(function(notifications) { + // Make sure dismissed notifications are no longer retrieved. + is(notifications.length, 0, "There should be no more stored notifications"); + }); + } + + function testGet() { + // Non persistent notifications will not show up in getNotification(). + var n = new Notification("Scope does not match"); + var options = NotificationTest.payload; + return navigator.serviceWorker.getRegistration("./notification/") + .then(function(reg) { + return reg.showNotification("This is a title", options) + .then(function() { + return reg; + }); + }).then(function(reg) { + return registerAlternateSWAndAddNotification().then(function() { + return reg; + }); + }).then(function(reg) { + return reg.getNotifications(); + }).then(function(notifications) { + is(notifications.length, 1, "There should be one stored notification"); + var notification = notifications[0]; + ok(notification instanceof Notification, "Should be a Notification"); + is(notification.title, "This is a title", "Title should match"); + for (var key in options) { + if (key === "data") { + ok(NotificationTest.customDataMatches(notification.data), + "data property should match"); + continue; + } + is(notification[key], options[key], key + " property should match"); + } + notification.close(); + }).then(function() { + return navigator.serviceWorker.getRegistration("./notification/").then(function(reg) { + return reg.getNotifications(); + }); + }).then(function(notifications) { + // Make sure closed notifications are no longer retrieved. + is(notifications.length, 0, "There should be no more stored notifications"); + }).catch(function(e) { + ok(false, "Something went wrong " + e.message); + }).then(unregisterAlternateSWAndAddNotification); + } + + function testGetWorker() { + todo(false, "navigator.serviceWorker is not available on workers yet"); + return Promise.resolve(); + } + + function waitForSWTests(reg, msg) { + return new Promise(function(resolve, reject) { + var content = document.getElementById("content"); + + iframe = document.createElement("iframe"); + + content.appendChild(iframe); + iframe.setAttribute('src', "notification/listener.html"); + + window.onmessage = function(e) { + if (e.data.type == 'status') { + ok(e.data.status, "Service worker test: " + e.data.msg); + } else if (e.data.type == 'finish') { + content.removeChild(iframe); + resolve(); + } + } + + iframe.onload = function(e) { + iframe.onload = null; + reg.active.postMessage(msg); + } + }); + } + + function testGetServiceWorker() { + return navigator.serviceWorker.getRegistration("./notification/") + .then(function(reg) { + return waitForSWTests(reg, 'create'); + }); + } + + // Create a Notification here, make sure ServiceWorker sees it. + function testAcrossThreads() { + return navigator.serviceWorker.getRegistration("./notification/") + .then(function(reg) { + return reg.showNotification("This is a title") + .then(function() { + return reg; + }); + }).then(function(reg) { + return waitForSWTests(reg, 'do-not-create'); + }); + } + + SimpleTest.waitForExplicitFinish(); + + MockServices.register(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ]}, function() { + registerSW() + .then(testGet) + .then(testGetWorker) + .then(testGetServiceWorker) + .then(testAcrossThreads) + .then(testDismiss) + .then(unregisterSW) + .then(function() { + MockServices.unregister(); + SimpleTest.finish(); + }); + }); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_notificationclick-otherwindow.html b/dom/workers/test/serviceworkers/test_notificationclick-otherwindow.html new file mode 100644 index 000000000..4a785be9a --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notificationclick-otherwindow.html @@ -0,0 +1,62 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 1114554 - Test ServiceWorkerGlobalScope.notificationclick event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1114554">Bug 1114554</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show and click events."); + + function testFrame(src) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.callback = function(result) { + window.callback = null; + document.body.removeChild(iframe); + iframe = null; + ok(result, "Got notificationclick event with correct data."); + MockServices.unregister(); + registration.unregister().then(function() { + SimpleTest.finish(); + }); + }; + document.body.appendChild(iframe); + } + + var registration; + + function runTest() { + MockServices.register(); + testFrame('notificationclick-otherwindow.html'); + navigator.serviceWorker.register("notificationclick.js", { scope: "notificationclick-otherwindow.html" }).then(function(reg) { + registration = reg; + }, function(e) { + ok(false, "registration should have passed!"); + }); + }; + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ]}, runTest); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_notificationclick.html b/dom/workers/test/serviceworkers/test_notificationclick.html new file mode 100644 index 000000000..d5c3ecf8b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notificationclick.html @@ -0,0 +1,62 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 1114554 - Test ServiceWorkerGlobalScope.notificationclick event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1114554">Bug 1114554</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show and click events."); + + function testFrame(src) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.callback = function(result) { + window.callback = null; + document.body.removeChild(iframe); + iframe = null; + ok(result, "Got notificationclick event with correct data."); + MockServices.unregister(); + registration.unregister().then(function() { + SimpleTest.finish(); + }); + }; + document.body.appendChild(iframe); + } + + var registration; + + function runTest() { + MockServices.register(); + testFrame('notificationclick.html'); + navigator.serviceWorker.register("notificationclick.js", { scope: "notificationclick.html" }).then(function(reg) { + registration = reg; + }, function(e) { + ok(false, "registration should have passed!"); + }); + }; + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ]}, runTest); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_notificationclick_focus.html b/dom/workers/test/serviceworkers/test_notificationclick_focus.html new file mode 100644 index 000000000..81d6e269c --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notificationclick_focus.html @@ -0,0 +1,63 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 1144660 - Test client.focus() permissions on notification click</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1114554">Bug 1114554</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show and click events."); + + function testFrame(src) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.callback = function(result) { + window.callback = null; + document.body.removeChild(iframe); + iframe = null; + ok(result, "All tests passed."); + MockServices.unregister(); + registration.unregister().then(function() { + SimpleTest.finish(); + }); + }; + document.body.appendChild(iframe); + } + + var registration; + + function runTest() { + MockServices.register(); + testFrame('notificationclick_focus.html'); + navigator.serviceWorker.register("notificationclick_focus.js", { scope: "notificationclick_focus.html" }).then(function(reg) { + registration = reg; + }, function(e) { + ok(false, "registration should have passed!"); + }); + }; + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ["dom.disable_open_click_delay", 1000], + ]}, runTest); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_notificationclose.html b/dom/workers/test/serviceworkers/test_notificationclose.html new file mode 100644 index 000000000..3b81132c4 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_notificationclose.html @@ -0,0 +1,62 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1265841 +--> +<head> + <title>Bug 1265841 - Test ServiceWorkerGlobalScope.notificationclose event.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1265841">Bug 1265841</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show, click, and close events."); + + function testFrame(src) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.callback = function(result) { + window.callback = null; + document.body.removeChild(iframe); + iframe = null; + ok(result, "Got notificationclose event with correct data."); + MockServices.unregister(); + registration.unregister().then(function() { + SimpleTest.finish(); + }); + }; + document.body.appendChild(iframe); + } + + var registration; + + function runTest() { + MockServices.register(); + testFrame('notificationclose.html'); + navigator.serviceWorker.register("notificationclose.js", { scope: "notificationclose.html" }).then(function(reg) { + registration = reg; + }, function(e) { + ok(false, "registration should have passed!"); + }); + }; + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ]}, runTest); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_opaque_intercept.html b/dom/workers/test/serviceworkers/test_opaque_intercept.html new file mode 100644 index 000000000..5cb12e518 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_opaque_intercept.html @@ -0,0 +1,85 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test service worker post message </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + function start() { + return navigator.serviceWorker.register("opaque_intercept_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testOpaqueIntercept(swr) { + var p = new Promise(function(res, rej) { + var ready = false; + var scriptLoaded = false; + window.onmessage = function(e) { + if (e.data === "READY") { + ok(!ready, "ready message should only be received once"); + ok(!scriptLoaded, "ready message should be received before script loaded"); + if (ready) { + res(); + return; + } + ready = true; + iframe.contentWindow.postMessage("REFRESH", "*"); + } else if (e.data === "SCRIPT_LOADED") { + ok(ready, "script loaded should be received after ready"); + ok(!scriptLoaded, "script loaded message should be received only once"); + scriptLoaded = true; + res(); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/refresher.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testOpaqueIntercept) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_openWindow.html b/dom/workers/test/serviceworkers/test_openWindow.html new file mode 100644 index 000000000..2417648b9 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_openWindow.html @@ -0,0 +1,117 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1172870 +--> +<head> + <title>Bug 1172870 - Test clients.openWindow</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1172870">Bug 1172870</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show and click events."); + + function setup(ctx) { + MockServices.register(); + + return navigator.serviceWorker.register("openWindow_worker.js", {scope: "./"}) + .then(function(swr) { + ok(swr, "Registration successful"); + ctx.registration = swr; + return ctx; + }); + } + + function waitForActiveServiceWorker(ctx) { + return navigator.serviceWorker.ready.then(function(result) { + ok(ctx.registration.active, "Service Worker is active"); + return ctx; + }); + } + + function setupMessageHandler(ctx) { + return new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function(event) { + navigator.serviceWorker.onmessage = null; + for (i = 0; i < event.data.length; i++) { + ok(event.data[i].result, event.data[i].message); + } + res(ctx); + } + }); + } + + function testPopupNotAllowed(ctx) { + var p = setupMessageHandler(ctx); + ok(ctx.registration.active, "Worker is active."); + ctx.registration.active.postMessage("testNoPopup"); + + return p; + } + + function testPopupAllowed(ctx) { + var p = setupMessageHandler(ctx); + ctx.registration.showNotification("testPopup"); + + return p; + } + + function checkNumberOfWindows(ctx) { + return new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function(event) { + navigator.serviceWorker.onmessage = null; + ok(event.data.result, event.data.message); + res(ctx); + } + ctx.registration.active.postMessage("CHECK_NUMBER_OF_WINDOWS"); + }); + } + + function clear(ctx) { + MockServices.unregister(); + + return ctx.registration.unregister().then(function(result) { + ctx.registration = null; + ok(result, "Unregister was successful."); + }); + } + + function runTest() { + setup({}) + .then(waitForActiveServiceWorker) + // Permission to allow popups persists for some time after a notification + // click event, so the order here is important. + .then(testPopupNotAllowed) + .then(testPopupAllowed) + .then(checkNumberOfWindows) + .then(clear) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.webnotifications.workers.enabled", true], + ["dom.webnotifications.serviceworker.enabled", true], + ["notification.prompt.testing", true], + ["dom.disable_open_click_delay", 1000], + ["dom.serviceWorkers.idle_timeout", 299999], + ["dom.serviceWorkers.idle_extended_timeout", 299999] + ]}, runTest); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_origin_after_redirect.html b/dom/workers/test/serviceworkers/test_origin_after_redirect.html new file mode 100644 index 000000000..b68537d9d --- /dev/null +++ b/dom/workers/test/serviceworkers/test_origin_after_redirect.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("/tests/dom/workers/test/serviceworkers/fetch/origin/index.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "http://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_origin_after_redirect_cached.html b/dom/workers/test/serviceworkers/test_origin_after_redirect_cached.html new file mode 100644 index 000000000..69644abfa --- /dev/null +++ b/dom/workers/test/serviceworkers/test_origin_after_redirect_cached.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("/tests/dom/workers/test/serviceworkers/fetch/origin/index-cached.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "http://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https.html b/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https.html new file mode 100644 index 000000000..dcac11aea --- /dev/null +++ b/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https.html @@ -0,0 +1,57 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("/tests/dom/workers/test/serviceworkers/fetch/origin/index-to-https.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "https://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https_cached.html b/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https_cached.html new file mode 100644 index 000000000..3922fdb90 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_origin_after_redirect_to_https_cached.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the origin of a redirected response from a service worker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/register.html"; + var win; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + win = window.open("/tests/dom/workers/test/serviceworkers/fetch/origin/index-to-https-cached.sjs", "mywindow", "width=100,height=100"); + } else if (e.data.status == "domain") { + is(e.data.data, "example.org", "Correct domain expected"); + } else if (e.data.status == "origin") { + is(e.data.data, "https://example.org", "Correct origin expected"); + } else if (e.data.status == "done") { + win.close(); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/origin/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.caches.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_post_message.html b/dom/workers/test/serviceworkers/test_post_message.html new file mode 100644 index 000000000..e366423cb --- /dev/null +++ b/dom/workers/test/serviceworkers/test_post_message.html @@ -0,0 +1,80 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test service worker post message </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var magic_value = "MAGIC_VALUE_123"; + var registration; + function start() { + return navigator.serviceWorker.register("message_posting_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testPostMessage(swr) { + var p = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data === "READY") { + swr.active.postMessage(magic_value); + } else if (e.data === magic_value) { + ok(true, "Worker posted the correct value."); + res(); + } else { + ok(false, "Wrong value. Expected: " + magic_value + + ", got: " + e.data); + res(); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/service_worker_controlled.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testPostMessage) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_post_message_advanced.html b/dom/workers/test/serviceworkers/test_post_message_advanced.html new file mode 100644 index 000000000..8ea0d2300 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_post_message_advanced.html @@ -0,0 +1,109 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982726 - Test service worker post message advanced </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var base = ["string", true, 42]; + var blob = new Blob(["blob_content"]); + var file = new File(["file_content"], "file"); + var obj = { body : "object_content" }; + + function readBlob(blob) { + return new Promise(function(resolve, reject) { + var reader = new FileReader(); + reader.onloadend = () => resolve(reader.result); + reader.readAsText(blob); + }); + } + + function equals(v1, v2) { + return Promise.all([v1, v2]).then(function(val) { + ok(val[0] === val[1], "Values should match."); + }); + } + + function blob_equals(b1, b2) { + return equals(readBlob(b1), readBlob(b2)); + } + + function file_equals(f1, f2) { + return equals(f1.name, f2.name).then(blob_equals(f1, f2)); + } + + function obj_equals(o1, o2) { + return equals(o1.body, o2.body); + } + + function start() { + return navigator.serviceWorker.register("message_posting_worker.js", + { scope: "./sw_clients/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function testPostMessageObject(obj, test) { + var p = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (e.data === "READY") { + registration.active.postMessage(obj) + } else { + test(obj, e.data).then(res); + } + } + }); + + var content = document.getElementById("content"); + ok(content, "Parent exists."); + + iframe = document.createElement("iframe"); + iframe.setAttribute('src', "sw_clients/service_worker_controlled.html"); + content.appendChild(iframe); + + return p.then(() => content.removeChild(iframe)); + } + + function runTest() { + start() + .then(testPostMessageObject.bind(this, base[0], equals)) + .then(testPostMessageObject.bind(this, base[1], equals)) + .then(testPostMessageObject.bind(this, base[2], equals)) + .then(testPostMessageObject.bind(this, blob, blob_equals)) + .then(testPostMessageObject.bind(this, file, file_equals)) + .then(testPostMessageObject.bind(this, obj, obj_equals)) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_post_message_source.html b/dom/workers/test/serviceworkers/test_post_message_source.html new file mode 100644 index 000000000..543f64b4a --- /dev/null +++ b/dom/workers/test/serviceworkers/test_post_message_source.html @@ -0,0 +1,68 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1142015 - Test service worker post message source </title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var magic_value = "MAGIC_VALUE_RANDOM"; + var registration; + function start() { + return navigator.serviceWorker.register("source_message_posting_worker.js", + { scope: "./nonexistent_scope/" }) + .then((swr) => registration = swr); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + + function testPostMessage(swr) { + var p = new Promise(function(res, rej) { + navigator.serviceWorker.onmessage = function(e) { + ok(e.data === magic_value, "Worker posted the correct value."); + res(); + } + }); + + ok(swr.installing, "Installing worker exists."); + swr.installing.postMessage(magic_value); + return p; + } + + + function runTest() { + start() + .then(testPostMessage) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_privateBrowsing.html b/dom/workers/test/serviceworkers/test_privateBrowsing.html new file mode 100644 index 000000000..976337711 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_privateBrowsing.html @@ -0,0 +1,113 @@ +<html xmlns="http://www.w3.org/1999/xhtml"> +<head> + <title>Test for ServiceWorker - Private Browsing</title> + <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?> +</head> +<body> + +<script type="application/javascript"> + +const Ci = Components.interfaces; +var mainWindow; + +var contentPage = "http://mochi.test:8888/chrome/dom/workers/test/empty.html"; +var workerScope = "http://mochi.test:8888/chrome/dom/workers/test/serviceworkers/"; +var workerURL = workerScope + "worker.js"; + +function testOnWindow(aIsPrivate, aCallback) { + var win = mainWindow.OpenBrowserWindow({private: aIsPrivate}); + win.addEventListener("load", function onLoad() { + win.removeEventListener("load", onLoad, false); + win.addEventListener("DOMContentLoaded", function onInnerLoad() { + if (win.content.location.href != contentPage) { + win.gBrowser.loadURI(contentPage); + return; + } + + win.removeEventListener("DOMContentLoaded", onInnerLoad, true); + SimpleTest.executeSoon(function() { aCallback(win); }); + }, true); + + if (!aIsPrivate) { + win.gBrowser.loadURI(contentPage); + } + }, true); +} + +function setupWindow() { + mainWindow = window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebNavigation) + .QueryInterface(Ci.nsIDocShellTreeItem) + .rootTreeItem + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindow); + runTest(); +} + +var wN; +var registration; +var wP; + +function testPrivateWindow() { + testOnWindow(true, function(aWin) { + wP = aWin; + ok(!("serviceWorker" in wP.content.navigator), "ServiceWorkers are not available for private windows"); + runTest(); + }); +} + +function doTests() { + testOnWindow(false, function(aWin) { + wN = aWin; + ok("serviceWorker" in wN.content.navigator, "ServiceWorkers are available for normal windows"); + + wN.content.navigator.serviceWorker.register(workerURL, + { scope: workerScope }) + .then(function(aRegistration) { + registration = aRegistration; + ok(registration, "Registering a service worker in a normal window should succeed"); + + // Bug 1255621: We should be able to load a controlled document in a private window. + testPrivateWindow(); + }, function(aError) { + ok(false, "Error registering worker in normal window: " + aError); + testPrivateWindow(); + }); + }); +} + +var steps = [ + setupWindow, + doTests +]; + +function cleanup() { + wN.close(); + wP.close(); + + SimpleTest.finish(); +} + +function runTest() { + if (!steps.length) { + registration.unregister().then(cleanup, cleanup); + + return; + } + + var step = steps.shift(); + step(); +} + +SimpleTest.waitForExplicitFinish(); +SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["browser.startup.page", 0], + ["browser.startup.homepage_override.mstone", "ignore"], +]}, runTest); + +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_register_base.html b/dom/workers/test/serviceworkers/test_register_base.html new file mode 100644 index 000000000..58b08d27a --- /dev/null +++ b/dom/workers/test/serviceworkers/test_register_base.html @@ -0,0 +1,41 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that registering a service worker uses the docuemnt URI for the secure origin check</title> + <script type="text/javascript" src="http://mochi.test:8888/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="http://mochi.test:8888/tests/SimpleTest/test.css" /> + <base href="https://mozilla.org/"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + navigator.serviceWorker.register("http://mochi.test:8888/tests/dom/workers/test/serviceworkers/empty.js") + .then(reg => { + ok(false, "Register should fail"); + SimpleTest.finish(); + }, err => { + is(err.name, "SecurityError", "Registration should fail with SecurityError"); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ]}, runTest); + }; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_register_https_in_http.html b/dom/workers/test/serviceworkers/test_register_https_in_http.html new file mode 100644 index 000000000..2c8e998f7 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_register_https_in_http.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1172948 - Test that registering a service worker from inside an HTTPS iframe embedded in an HTTP iframe doesn't work</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + var iframe = document.createElement("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/serviceworkers/register_https.html"; + document.body.appendChild(iframe); + + window.onmessage = event => { + switch (event.data.type) { + case "ok": + ok(event.data.status, event.data.msg); + break; + case "done": + SimpleTest.finish(); + break; + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ]}, runTest); + }; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context.js b/dom/workers/test/serviceworkers/test_request_context.js new file mode 100644 index 000000000..aebba79a7 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context.js @@ -0,0 +1,75 @@ +// Copied from /dom/plugins/test/mochitest/utils.js +function getTestPlugin(pluginName) { + var ph = SpecialPowers.Cc["@mozilla.org/plugin/host;1"] + .getService(SpecialPowers.Ci.nsIPluginHost); + var tags = ph.getPluginTags(); + var name = pluginName || "Test Plug-in"; + for (var tag of tags) { + if (tag.name == name) { + return tag; + } + } + + ok(false, "Could not find plugin tag with plugin name '" + name + "'"); + return null; +} +function setTestPluginEnabledState(newEnabledState, pluginName) { + var oldEnabledState = SpecialPowers.setTestPluginEnabledState(newEnabledState, pluginName); + if (!oldEnabledState) { + return; + } + var plugin = getTestPlugin(pluginName); + while (plugin.enabledState != newEnabledState) { + // Run a nested event loop to wait for the preference change to + // propagate to the child. Yuck! + SpecialPowers.Services.tm.currentThread.processNextEvent(true); + } + SimpleTest.registerCleanupFunction(function() { + SpecialPowers.setTestPluginEnabledState(oldEnabledState, pluginName); + }); +} +setTestPluginEnabledState(SpecialPowers.Ci.nsIPluginTag.STATE_ENABLED); + +function isMulet() { + try { + return SpecialPowers.getBoolPref("b2g.is_mulet"); + } catch(e) { + return false; + } +} + +var iframe; +function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/context/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "todo") { + todo(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/context/index.html?" + gTest; + } else if (e.data.status == "done") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/context/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; +} + +SimpleTest.waitForExplicitFinish(); +onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["beacon.enabled", true], + ["browser.send_pings", true], + ["browser.send_pings.max_per_link", -1], + ["dom.caches.enabled", true], + ["dom.requestcontext.enabled", true], + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.openWindow.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +}; diff --git a/dom/workers/test/serviceworkers/test_request_context_audio.html b/dom/workers/test/serviceworkers/test_request_context_audio.html new file mode 100644 index 000000000..929a24428 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_audio.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testAudio"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_beacon.html b/dom/workers/test/serviceworkers/test_request_context_beacon.html new file mode 100644 index 000000000..ce44214d6 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_beacon.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testBeacon"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_cache.html b/dom/workers/test/serviceworkers/test_request_context_cache.html new file mode 100644 index 000000000..3d62baabc --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_cache.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testCache"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_cspreport.html b/dom/workers/test/serviceworkers/test_request_context_cspreport.html new file mode 100644 index 000000000..a27e79303 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_cspreport.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testCSPReport"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_embed.html b/dom/workers/test/serviceworkers/test_request_context_embed.html new file mode 100644 index 000000000..f8d374246 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_embed.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testEmbed"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_fetch.html b/dom/workers/test/serviceworkers/test_request_context_fetch.html new file mode 100644 index 000000000..94de8be31 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_fetch.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testFetch"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_font.html b/dom/workers/test/serviceworkers/test_request_context_font.html new file mode 100644 index 000000000..d81a0686b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_font.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testFont"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_frame.html b/dom/workers/test/serviceworkers/test_request_context_frame.html new file mode 100644 index 000000000..d5dc1f745 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_frame.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testFrame"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_iframe.html b/dom/workers/test/serviceworkers/test_request_context_iframe.html new file mode 100644 index 000000000..d3b0675e0 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_iframe.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testIFrame"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_image.html b/dom/workers/test/serviceworkers/test_request_context_image.html new file mode 100644 index 000000000..810063da4 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_image.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testImage"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_imagesrcset.html b/dom/workers/test/serviceworkers/test_request_context_imagesrcset.html new file mode 100644 index 000000000..95b2b7214 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_imagesrcset.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testImageSrcSet"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_internal.html b/dom/workers/test/serviceworkers/test_request_context_internal.html new file mode 100644 index 000000000..45f454495 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_internal.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testInternal"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_nestedworker.html b/dom/workers/test/serviceworkers/test_request_context_nestedworker.html new file mode 100644 index 000000000..226de691b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_nestedworker.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testNestedWorker"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_nestedworkerinsharedworker.html b/dom/workers/test/serviceworkers/test_request_context_nestedworkerinsharedworker.html new file mode 100644 index 000000000..48934a57c --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_nestedworkerinsharedworker.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testNestedWorkerInSharedWorker"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_object.html b/dom/workers/test/serviceworkers/test_request_context_object.html new file mode 100644 index 000000000..189c5adbb --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_object.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testObject"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_picture.html b/dom/workers/test/serviceworkers/test_request_context_picture.html new file mode 100644 index 000000000..1b49e7eb9 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_picture.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testPicture"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_ping.html b/dom/workers/test/serviceworkers/test_request_context_ping.html new file mode 100644 index 000000000..460e9efb4 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_ping.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testPing"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_plugin.html b/dom/workers/test/serviceworkers/test_request_context_plugin.html new file mode 100644 index 000000000..862e9d4a5 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_plugin.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testPlugin"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_script.html b/dom/workers/test/serviceworkers/test_request_context_script.html new file mode 100644 index 000000000..ec560ef72 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_script.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testScript"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_sharedworker.html b/dom/workers/test/serviceworkers/test_request_context_sharedworker.html new file mode 100644 index 000000000..93ccdf3ae --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_sharedworker.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testSharedWorker"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_style.html b/dom/workers/test/serviceworkers/test_request_context_style.html new file mode 100644 index 000000000..b557d5c04 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_style.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testStyle"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_track.html b/dom/workers/test/serviceworkers/test_request_context_track.html new file mode 100644 index 000000000..1b161c4d0 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_track.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testTrack"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_video.html b/dom/workers/test/serviceworkers/test_request_context_video.html new file mode 100644 index 000000000..1886e31d7 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_video.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testVideo"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_worker.html b/dom/workers/test/serviceworkers/test_request_context_worker.html new file mode 100644 index 000000000..9de127304 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_worker.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testWorker"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_xhr.html b/dom/workers/test/serviceworkers/test_request_context_xhr.html new file mode 100644 index 000000000..ed0d60bf8 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_xhr.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testXHR"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_request_context_xslt.html b/dom/workers/test/serviceworkers/test_request_context_xslt.html new file mode 100644 index 000000000..a6d837b69 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_request_context_xslt.html @@ -0,0 +1,19 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1121157 - Test that Request objects passed to FetchEvent have the correct context</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_request_context.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<script type="text/javascript"> +var gTest = "testXSLT"; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_sandbox_intercept.html b/dom/workers/test/serviceworkers/test_sandbox_intercept.html new file mode 100644 index 000000000..273df53ff --- /dev/null +++ b/dom/workers/test/serviceworkers/test_sandbox_intercept.html @@ -0,0 +1,50 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1142727 - Test that sandboxed iframes are not intercepted</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> +<iframe sandbox="allow-scripts allow-same-origin"></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + function runTest() { + iframe = document.querySelector("iframe"); + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/sandbox/register.html"; + window.onmessage = function(e) { + if (e.data.status == "ok") { + ok(e.data.result, e.data.message); + } else if (e.data.status == "registrationdone") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/sandbox/index.html"; + } else if (e.data.status == "done") { + iframe.src = "/tests/dom/workers/test/serviceworkers/fetch/sandbox/unregister.html"; + } else if (e.data.status == "unregistrationdone") { + window.onmessage = null; + ok(true, "Test finished successfully"); + SimpleTest.finish(); + } + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_sanitize.html b/dom/workers/test/serviceworkers/test_sanitize.html new file mode 100644 index 000000000..842cb38c3 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_sanitize.html @@ -0,0 +1,87 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1080109 - Clear ServiceWorker registrations for all domains</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function start() { + const Cc = SpecialPowers.Cc; + const Ci = SpecialPowers.Ci; + + function testNotIntercepted() { + testFrame("sanitize/frame.html").then(function(body) { + is(body, "FAIL", "Expected frame to not be controlled"); + // No need to unregister since that already happened. + navigator.serviceWorker.getRegistration("sanitize/foo").then(function(reg) { + ok(reg === undefined, "There should no longer be a valid registration"); + }, function(e) { + ok(false, "getRegistration() should not error"); + }).then(function(e) { + SimpleTest.finish(); + }); + }); + } + + registerSW().then(function() { + return testFrame("sanitize/frame.html").then(function(body) { + is(body, "intercepted", "Expected serviceworker to intercept request"); + }); + }).then(function() { + return navigator.serviceWorker.getRegistration("sanitize/foo"); + }).then(function(reg) { + reg.active.onstatechange = function(e) { + e.target.onstatechange = null; + ok(e.target.state, "redundant", "On clearing data, serviceworker should become redundant"); + testNotIntercepted(); + }; + }).then(function() { + SpecialPowers.removeAllServiceWorkerData(); + }); + } + + function testFrame(src) { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.onmessage = function(message) { + window.onmessage = null; + iframe.src = "about:blank"; + document.body.removeChild(iframe); + iframe = null; + SpecialPowers.exactGC(function() { + resolve(message.data); + }); + }; + document.body.appendChild(iframe); + }); + } + + function registerSW() { + return testFrame("sanitize/register.html"); + } + + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, function() { + start(); + }); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_sanitize_domain.html b/dom/workers/test/serviceworkers/test_sanitize_domain.html new file mode 100644 index 000000000..054b60f37 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_sanitize_domain.html @@ -0,0 +1,90 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1080109 - Clear ServiceWorker registrations for specific domains</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function start() { + const Cc = SpecialPowers.Cc; + const Ci = SpecialPowers.Ci; + + function checkDomainRegistration(domain, exists) { + return testFrame("http://" + domain + "/tests/dom/workers/test/serviceworkers/sanitize/example_check_and_unregister.html").then(function(body) { + if (body === "FAIL") { + ok(false, "Error acquiring registration or unregistering for " + domain); + } else { + if (exists) { + ok(body === true, "Expected " + domain + " to still have a registration."); + } else { + ok(body === false, "Expected " + domain + " to have no registration."); + } + } + }); + } + + registerSW().then(function() { + return testFrame("http://example.com/tests/dom/workers/test/serviceworkers/sanitize/frame.html").then(function(body) { + is(body, "intercepted", "Expected serviceworker to intercept request"); + }); + }).then(function() { + SpecialPowers.removeServiceWorkerDataForExampleDomain(); + }).then(function() { + return checkDomainRegistration("prefixexample.com", true /* exists */) + .then(function(e) { + return checkDomainRegistration("example.com", false /* exists */); + }).then(function(e) { + SimpleTest.finish(); + }); + }) + } + + function testFrame(src) { + return new Promise(function(resolve, reject) { + var iframe = document.createElement("iframe"); + iframe.src = src; + window.onmessage = function(message) { + window.onmessage = null; + iframe.src = "about:blank"; + document.body.removeChild(iframe); + iframe = null; + SpecialPowers.exactGC(function() { + resolve(message.data); + }); + }; + document.body.appendChild(iframe); + }); + } + + function registerSW() { + return testFrame("http://example.com/tests/dom/workers/test/serviceworkers/sanitize/register.html") + .then(function(e) { + // Register for prefixexample.com and then ensure it does not get unregistered. + return testFrame("http://prefixexample.com/tests/dom/workers/test/serviceworkers/sanitize/register.html"); + }); + } + + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, function() { + start(); + }); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_scopes.html b/dom/workers/test/serviceworkers/test_scopes.html new file mode 100644 index 000000000..2d8116f83 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_scopes.html @@ -0,0 +1,121 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 984048 - Test scope glob matching.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var scriptsAndScopes = [ + [ "worker.js", "./sub/dir/"], + [ "worker.js", "./sub/dir" ], + [ "worker.js", "./sub/dir.html" ], + [ "worker.js", "./sub/dir/a" ], + [ "worker.js", "./sub" ], + [ "worker.js", "./star*" ], // '*' has no special meaning + ]; + + function registerWorkers() { + var registerArray = []; + scriptsAndScopes.forEach(function(item) { + registerArray.push(navigator.serviceWorker.register(item[0], { scope: item[1] })); + }); + + // Check register()'s step 4 which uses script's url with "./" as the scope if no scope is passed. + // The other tests already check step 5. + registerArray.push(navigator.serviceWorker.register("scope/scope_worker.js")); + + // Check that SW cannot be registered for a scope "above" the script's location. + registerArray.push(new Promise(function(resolve, reject) { + navigator.serviceWorker.register("scope/scope_worker.js", { scope: "./" }) + .then(function() { + ok(false, "registration scope has to be inside service worker script scope."); + reject(); + }, function() { + ok(true, "registration scope has to be inside service worker script scope."); + resolve(); + }); + })); + return Promise.all(registerArray); + } + + function unregisterWorkers() { + var unregisterArray = []; + scriptsAndScopes.forEach(function(item) { + var p = navigator.serviceWorker.getRegistration(item[1]); + unregisterArray.push(p.then(function(reg) { + return reg.unregister(); + })); + }); + + unregisterArray.push(navigator.serviceWorker.getRegistration("scope/").then(function (reg) { + return reg.unregister(); + })); + + return Promise.all(unregisterArray); + } + + function testScopes() { + return new Promise(function(resolve, reject) { + var getScope = navigator.serviceWorker.getScopeForUrl.bind(navigator.serviceWorker); + var base = new URL(".", document.baseURI); + + function p(s) { + return base + s; + } + + function fail(fn) { + try { + getScope(p("index.html")); + ok(false, "No registration"); + } catch(e) { + ok(true, "No registration"); + } + } + + ok(getScope(p("sub.html")) === p("sub"), "Scope should match"); + ok(getScope(p("sub/dir.html")) === p("sub/dir.html"), "Scope should match"); + ok(getScope(p("sub/dir")) === p("sub/dir"), "Scope should match"); + ok(getScope(p("sub/dir/foo")) === p("sub/dir/"), "Scope should match"); + ok(getScope(p("sub/dir/afoo")) === p("sub/dir/a"), "Scope should match"); + ok(getScope(p("star*wars")) === p("star*"), "Scope should match"); + ok(getScope(p("scope/some_file.html")) === p("scope/"), "Scope should match"); + fail("index.html"); + fail("sua.html"); + fail("star/a.html"); + resolve(); + }); + } + + function runTest() { + registerWorkers() + .then(testScopes) + .then(unregisterWorkers) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_service_worker_allowed.html b/dom/workers/test/serviceworkers/test_service_worker_allowed.html new file mode 100644 index 000000000..eca94ebb4 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_service_worker_allowed.html @@ -0,0 +1,74 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the Service-Worker-Allowed header</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="content"></div> +<script class="testbody" type="text/javascript"> + var gTests = [ + "worker_scope_different.js", + "worker_scope_different2.js", + "worker_scope_too_deep.js", + ]; + + function testPermissiveHeader() { + // Make sure that this registration succeeds, as the prefix check should pass. + return navigator.serviceWorker.register("swa/worker_scope_too_narrow.js", {scope: "swa/"}) + .then(swr => { + ok(true, "Registration should finish successfully"); + return swr.unregister(); + }, err => { + ok(false, "Unexpected error when registering the service worker: " + err); + }); + } + + function testPreciseHeader() { + // Make sure that this registration succeeds, as the prefix check should pass + // given that we parse the use the full pathname from this URL.. + return navigator.serviceWorker.register("swa/worker_scope_precise.js", {scope: "swa/"}) + .then(swr => { + ok(true, "Registration should finish successfully"); + return swr.unregister(); + }, err => { + ok(false, "Unexpected error when registering the service worker: " + err); + }); + } + + function runTest() { + Promise.all(gTests.map(testName => { + return new Promise((resolve, reject) => { + // Make sure that registration fails. + navigator.serviceWorker.register("swa/" + testName, {scope: "swa/"}) + .then(reject, resolve); + }); + })).then(values => { + values.forEach(error => { + is(error.name, "SecurityError", "Registration should fail"); + }); + Promise.all([ + testPermissiveHeader(), + testPreciseHeader(), + ]).then(SimpleTest.finish, SimpleTest.finish); + }, (x) => { + ok(false, "Registration should not succeed, but it did"); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_serviceworker_header.html b/dom/workers/test/serviceworkers/test_serviceworker_header.html new file mode 100644 index 000000000..ac5a6e49f --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworker_header.html @@ -0,0 +1,41 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that service worker scripts are fetched with a Service-Worker: script header</title> + <script type="text/javascript" src="http://mochi.test:8888/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="http://mochi.test:8888/tests/SimpleTest/test.css" /> + <base href="https://mozilla.org/"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + navigator.serviceWorker.register("http://mochi.test:8888/tests/dom/workers/test/serviceworkers/header_checker.sjs") + .then(reg => { + ok(true, "Register should succeed"); + reg.unregister().then(() => SimpleTest.finish()); + }, err => { + ok(false, "Register should not fail"); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.testing.enabled", true], + ["dom.serviceWorkers.enabled", true], + ]}, runTest); + }; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_serviceworker_interfaces.html b/dom/workers/test/serviceworkers/test_serviceworker_interfaces.html new file mode 100644 index 000000000..0130ca2d9 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworker_interfaces.html @@ -0,0 +1,106 @@ +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +<!DOCTYPE HTML> +<html> +<head> + <title>Validate Interfaces Exposed to Service Workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="text/javascript" src="../worker_driver.js"></script> +</head> +<body> +<script class="testbody" type="text/javascript"> + + function setupSW(registration) { + var worker = registration.waiting || + registration.active; + window.onmessage = function(event) { + if (event.data.type == 'finish') { + registration.unregister().then(function(success) { + ok(success, "The service worker should be unregistered successfully"); + + SimpleTest.finish(); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + SimpleTest.finish(); + }); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + + } else if (event.data.type == 'getPrefs') { + var result = {}; + event.data.prefs.forEach(function(pref) { + result[pref] = SpecialPowers.Services.prefs.getBoolPref(pref); + }); + worker.postMessage({ + type: 'returnPrefs', + prefs: event.data.prefs, + result: result + }); + + } else if (event.data.type == 'getVersion') { + var result = SpecialPowers.Cc['@mozilla.org/xre/app-info;1'].getService(SpecialPowers.Ci.nsIXULAppInfo).version; + worker.postMessage({ + type: 'returnVersion', + result: result + }); + + } else if (event.data.type == 'getUserAgent') { + worker.postMessage({ + type: 'returnUserAgent', + result: navigator.userAgent + }); + } else if (event.data.type == 'getOSCPU') { + worker.postMessage({ + type: 'returnOSCPU', + result: navigator.oscpu + }); + } + } + + worker.onerror = function(event) { + ok(false, 'Worker had an error: ' + event.data); + SimpleTest.finish(); + }; + + var iframe = document.createElement("iframe"); + iframe.src = "message_receiver.html"; + iframe.onload = function() { + worker.postMessage({ script: "test_serviceworker_interfaces.js" }); + }; + document.body.appendChild(iframe); + } + + function runTest() { + navigator.serviceWorker.ready.then(setupSW); + navigator.serviceWorker.register("serviceworker_wrapper.js", {scope: "."}); + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + // The handling of "dom.caches.enabled" here is a bit complicated. What we + // want to happen is that Cache is always enabled in service workers. So + // if service workers are disabled by default we want to force on both + // service workers and "dom.caches.enabled". But if service workers are + // enabled by default, we do not want to mess with the "dom.caches.enabled" + // value, since that would defeat the purpose of the test. Use a subframe + // to decide whether service workers are enabled by default, so we don't + // force creation of our own Navigator object before our prefs are set. + var prefs = [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]; + + var subframe = document.createElement("iframe"); + document.body.appendChild(subframe); + if (!("serviceWorker" in subframe.contentWindow.navigator)) { + prefs.push(["dom.caches.enabled", true]); + } + subframe.remove(); + + SpecialPowers.pushPrefEnv({"set": prefs}, runTest); + }; +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_serviceworker_interfaces.js b/dom/workers/test/serviceworkers/test_serviceworker_interfaces.js new file mode 100644 index 000000000..9dbfcc099 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworker_interfaces.js @@ -0,0 +1,278 @@ +// This is a list of all interfaces that are exposed to workers. +// Please only add things to this list with great care and proper review +// from the associated module peers. + +// This file lists global interfaces we want exposed and verifies they +// are what we intend. Each entry in the arrays below can either be a +// simple string with the interface name, or an object with a 'name' +// property giving the interface name as a string, and additional +// properties which qualify the exposure of that interface. For example: +// +// [ +// "AGlobalInterface", +// { name: "ExperimentalThing", release: false }, +// { name: "ReallyExperimentalThing", nightly: true }, +// { name: "DesktopOnlyThing", desktop: true }, +// { name: "FancyControl", xbl: true }, +// { name: "DisabledEverywhere", disabled: true }, +// ]; +// +// See createInterfaceMap() below for a complete list of properties. + +// IMPORTANT: Do not change this list without review from +// a JavaScript Engine peer! +var ecmaGlobals = + [ + "Array", + "ArrayBuffer", + "Boolean", + "DataView", + "Date", + "Error", + "EvalError", + "Float32Array", + "Float64Array", + "Function", + "Infinity", + "Int16Array", + "Int32Array", + "Int8Array", + "InternalError", + {name: "Intl", android: false}, + "Iterator", + "JSON", + "Map", + "Math", + "NaN", + "Number", + "Object", + "Promise", + "Proxy", + "RangeError", + "ReferenceError", + "Reflect", + "RegExp", + "Set", + {name: "SharedArrayBuffer", release: false}, + {name: "SIMD", nightly: true}, + {name: "Atomics", release: false}, + "StopIteration", + "String", + "Symbol", + "SyntaxError", + {name: "TypedObject", nightly: true}, + "TypeError", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray", + "URIError", + "WeakMap", + "WeakSet", + ]; +// IMPORTANT: Do not change the list above without review from +// a JavaScript Engine peer! + +// IMPORTANT: Do not change the list below without review from a DOM peer! +var interfaceNamesInGlobalScope = + [ +// IMPORTANT: Do not change this list without review from a DOM peer! + "Blob", +// IMPORTANT: Do not change this list without review from a DOM peer! + "BroadcastChannel", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Cache", +// IMPORTANT: Do not change this list without review from a DOM peer! + "CacheStorage", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Client", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Clients", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Crypto", +// IMPORTANT: Do not change this list without review from a DOM peer! + "CustomEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Directory", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMCursor", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMError", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMException", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMStringList", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Event", +// IMPORTANT: Do not change this list without review from a DOM peer! + "EventTarget", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ExtendableEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ExtendableMessageEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FetchEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "File", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FileReader", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FileReaderSync", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FormData", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Headers", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBCursor", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBCursorWithValue", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBDatabase", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBFactory", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBIndex", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBKeyRange", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBObjectStore", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBOpenDBRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBTransaction", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBVersionChangeEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageBitmap", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageBitmapRenderingContext", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageData", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessageChannel", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessageEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessagePort", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Notification", +// IMPORTANT: Do not change this list without review from a DOM peer! + "NotificationEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! +// IMPORTANT: Do not change this list without review from a DOM peer! + "Performance", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceEntry", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceMark", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceMeasure", +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "PerformanceObserver", nightly: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "PerformanceObserverEntryList", nightly: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + "Request", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Response", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ServiceWorker", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ServiceWorkerGlobalScope", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ServiceWorkerRegistration", +// IMPORTANT: Do not change this list without review from a DOM peer! + {name: "StorageManager", nightly: true}, +// IMPORTANT: Do not change this list without review from a DOM peer! + "SubtleCrypto", +// IMPORTANT: Do not change this list without review from a DOM peer! + "TextDecoder", +// IMPORTANT: Do not change this list without review from a DOM peer! + "TextEncoder", +// IMPORTANT: Do not change this list without review from a DOM peer! + "URL", +// IMPORTANT: Do not change this list without review from a DOM peer! + "URLSearchParams", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WebSocket", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WindowClient", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerGlobalScope", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerLocation", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerNavigator", +// IMPORTANT: Do not change this list without review from a DOM peer! + ]; +// IMPORTANT: Do not change the list above without review from a DOM peer! + +function createInterfaceMap(version, userAgent) { + var isNightly = version.endsWith("a1"); + var isRelease = !version.includes("a"); + var isDesktop = !/Mobile|Tablet/.test(userAgent); + var isAndroid = !!navigator.userAgent.includes("Android"); + + var interfaceMap = {}; + + function addInterfaces(interfaces) + { + for (var entry of interfaces) { + if (typeof(entry) === "string") { + interfaceMap[entry] = true; + } else { + ok(!("pref" in entry), "Bogus pref annotation for " + entry.name); + if ((entry.nightly === !isNightly) || + (entry.nightlyAndroid === !(isAndroid && isNightly) && isAndroid) || + (entry.nonReleaseAndroid === !(isAndroid && !isRelease) && isAndroid) || + (entry.desktop === !isDesktop) || + (entry.android === !isAndroid && !entry.nonReleaseAndroid && !entry.nightlyAndroid) || + (entry.release === !isRelease)) { + interfaceMap[entry.name] = false; + } else { + interfaceMap[entry.name] = true; + } + } + } + } + + addInterfaces(ecmaGlobals); + addInterfaces(interfaceNamesInGlobalScope); + + return interfaceMap; +} + +function runTest(version, userAgent) { + var interfaceMap = createInterfaceMap(version, userAgent); + for (var name of Object.getOwnPropertyNames(self)) { + // An interface name should start with an upper case character. + if (!/^[A-Z]/.test(name)) { + continue; + } + ok(interfaceMap[name], + "If this is failing: DANGER, are you sure you want to expose the new interface " + name + + " to all webpages as a property on the service worker? Do not make a change to this file without a " + + " review from a DOM peer for that specific change!!! (or a JS peer for changes to ecmaGlobals)"); + delete interfaceMap[name]; + } + for (var name of Object.keys(interfaceMap)) { + ok(name in self === interfaceMap[name], + name + " should " + (interfaceMap[name] ? "" : " NOT") + " be defined on the global scope"); + if (!interfaceMap[name]) { + delete interfaceMap[name]; + } + } + is(Object.keys(interfaceMap).length, 0, + "The following interface(s) are not enumerated: " + Object.keys(interfaceMap).join(", ")); +} + +workerTestGetVersion(function(version) { + workerTestGetUserAgent(function(userAgent) { + runTest(version, userAgent); + workerTestDone(); + }); +}); diff --git a/dom/workers/test/serviceworkers/test_serviceworker_not_sharedworker.html b/dom/workers/test/serviceworkers/test_serviceworker_not_sharedworker.html new file mode 100644 index 000000000..96dd9f159 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworker_not_sharedworker.html @@ -0,0 +1,66 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1141274 - test that service workers and shared workers are separate</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var iframe; + const SCOPE = "http://mochi.test:8888/tests/dom/workers/test/serviceworkers/"; + function runTest() { + navigator.serviceWorker.ready.then(setupSW); + navigator.serviceWorker.register("serviceworker_not_sharedworker.js", + {scope: SCOPE}); + } + + var sw, worker; + function setupSW(registration) { + sw = registration.waiting || registration.active; + worker = new SharedWorker("serviceworker_not_sharedworker.js", SCOPE); + worker.port.start(); + iframe = document.querySelector("iframe"); + iframe.src = "message_receiver.html"; + iframe.onload = function() { + window.onmessage = function(e) { + is(e.data.result, "serviceworker", "We should be talking to a service worker"); + window.onmessage = null; + worker.port.onmessage = function(e) { + is(e.data.result, "sharedworker", "We should be talking to a shared worker"); + registration.unregister().then(function(success) { + ok(success, "unregister should succeed"); + SimpleTest.finish(); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + SimpleTest.finish(); + }); + }; + worker.port.postMessage({msg: "whoareyou"}); + }; + sw.postMessage({msg: "whoareyou"}); + }; + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_serviceworkerinfo.xul b/dom/workers/test/serviceworkers/test_serviceworkerinfo.xul new file mode 100644 index 000000000..96e4bb1c3 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworkerinfo.xul @@ -0,0 +1,115 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for ServiceWorkerInfo" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="chrome_helpers.js"/> + <script type="application/javascript"> + <![CDATA[ + + let IFRAME_URL = EXAMPLE_URL + "serviceworkerinfo_iframe.html"; + + function wait_for_active_worker(registration) { + ok(registration, "Registration is valid."); + return new Promise(function(res, rej) { + if (registration.activeWorker) { + res(registration); + return; + } + let listener = { + onChange: function() { + if (registration.activeWorker) { + registration.removeListener(listener); + res(registration); + } + } + } + registration.addListener(listener); + }); + } + + function test() { + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({'set': [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.idle_extended_timeout", 1000000], + ["dom.serviceWorkers.idle_timeout", 0], + ["dom.serviceWorkers.testing.enabled", true], + ]}, function () { + Task.spawn(function *() { + let iframe = $("iframe"); + let promise = new Promise(function (resolve) { + iframe.onload = function () { + resolve(); + }; + }); + iframe.src = IFRAME_URL; + yield promise; + + info("Check that a service worker eventually shuts down."); + promise = Promise.all([ + waitForRegister(EXAMPLE_URL), + waitForServiceWorkerShutdown() + ]); + iframe.contentWindow.postMessage("register", "*"); + let [registration] = yield promise; + + // Make sure the worker is active. + registration = yield wait_for_active_worker(registration); + + let activeWorker = registration.activeWorker; + ok(activeWorker !== null, "Worker is not active!"); + ok(activeWorker.debugger === null); + + info("Attach a debugger to the service worker, and check that the " + + "service worker is restarted."); + activeWorker.attachDebugger(); + let workerDebugger = activeWorker.debugger; + ok(workerDebugger !== null); + + // Verify debugger properties + ok(workerDebugger.principal instanceof Ci.nsIPrincipal); + is(workerDebugger.url, EXAMPLE_URL + "worker.js"); + + info("Verify that getRegistrationByPrincipal return the same " + + "nsIServiceWorkerRegistrationInfo"); + let reg = swm.getRegistrationByPrincipal(workerDebugger.principal, + workerDebugger.url); + is(reg, registration); + + info("Check that getWorkerByID returns the same nsIWorkerDebugger"); + is(activeWorker, reg.getWorkerByID(workerDebugger.serviceWorkerID)); + + info("Detach the debugger from the service worker, and check that " + + "the service worker eventually shuts down again."); + promise = waitForServiceWorkerShutdown(); + activeWorker.detachDebugger(); + yield promise; + ok(activeWorker.debugger === null); + + promise = waitForUnregister(EXAMPLE_URL); + iframe.contentWindow.postMessage("unregister", "*"); + registration = yield promise; + + SimpleTest.finish(); + }); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + <iframe id="iframe"></iframe> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/serviceworkers/test_serviceworkermanager.xul b/dom/workers/test/serviceworkers/test_serviceworkermanager.xul new file mode 100644 index 000000000..ead935a3c --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworkermanager.xul @@ -0,0 +1,80 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for ServiceWorkerManager" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="chrome_helpers.js"/> + <script type="application/javascript"> + <![CDATA[ + + let IFRAME_URL = EXAMPLE_URL + "serviceworkermanager_iframe.html"; + + function test() { + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({'set': [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, function () { + Task.spawn(function* () { + let registrations = swm.getAllRegistrations(); + is(registrations.length, 0); + + let iframe = $("iframe"); + let promise = waitForIframeLoad(iframe); + iframe.src = IFRAME_URL; + yield promise; + + info("Check that the service worker manager notifies its listeners " + + "when a service worker is registered."); + promise = waitForRegister(EXAMPLE_URL); + iframe.contentWindow.postMessage("register", "*"); + let registration = yield promise; + + registrations = swm.getAllRegistrations(); + is(registrations.length, 1); + is(registrations.queryElementAt(0, Ci.nsIServiceWorkerRegistrationInfo), + registration); + + info("Check that the service worker manager does not notify its " + + "listeners when a service worker is registered with the same " + + "scope as an existing registration."); + let listener = { + onRegister: function () { + ok(false, "Listener should not have been notified."); + } + }; + swm.addListener(listener); + iframe.contentWindow.postMessage("register", "*"); + + info("Check that the service worker manager notifies its listeners " + + "when a service worker is unregistered."); + promise = waitForUnregister(EXAMPLE_URL); + iframe.contentWindow.postMessage("unregister", "*"); + registration = yield promise; + swm.removeListener(listener); + + registrations = swm.getAllRegistrations(); + is(registrations.length, 0); + + SimpleTest.finish(); + }); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + <iframe id="iframe"></iframe> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/serviceworkers/test_serviceworkerregistrationinfo.xul b/dom/workers/test/serviceworkers/test_serviceworkerregistrationinfo.xul new file mode 100644 index 000000000..c879dc01b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_serviceworkerregistrationinfo.xul @@ -0,0 +1,115 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for ServiceWorkerRegistrationInfo" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="chrome_helpers.js"/> + <script type="application/javascript"> + <![CDATA[ + + let IFRAME_URL = EXAMPLE_URL + "serviceworkerregistrationinfo_iframe.html"; + + function test() { + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv({'set': [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, function () { + Task.spawn(function* () { + let iframe = $("iframe"); + let promise = waitForIframeLoad(iframe); + iframe.src = IFRAME_URL; + yield promise; + + // The change handler is not guaranteed to be called within the same + // tick of the event loop as the one in which the change happened. + // Because of this, the exact state of the service worker registration + // is only known until the handler returns. + // + // Because then-handlers are resolved asynchronously, the following + // checks are done using callbacks, which are called synchronously + // when then handler is called. These callbacks can return a promise, + // which is used to resolve the promise returned by the function. + + info("Check that a service worker registration notifies its " + + "listeners when its state changes."); + promise = waitForRegister(EXAMPLE_URL, function (registration) { + is(registration.scriptSpec, ""); + ok(registration.installingWorker === null); + ok(registration.waitingWorker === null); + ok(registration.activeWorker === null); + + return waitForServiceWorkerRegistrationChange(registration, function () { + is(registration.scriptSpec, EXAMPLE_URL + "worker.js"); + ok(registration.installingWorker !== null); + is(registration.installingWorker.scriptSpec, EXAMPLE_URL + "worker.js"); + ok(registration.waitingWorker === null); + ok(registration.activeWorker === null); + + return waitForServiceWorkerRegistrationChange(registration, function () { + ok(registration.installingWorker === null); + ok(registration.waitingWorker !== null); + ok(registration.activeWorker === null); + + return waitForServiceWorkerRegistrationChange(registration, function () { + ok(registration.installingWorker === null); + ok(registration.waitingWorker === null); + ok(registration.activeWorker !== null); + + return registration; + }); + }); + }); + }); + iframe.contentWindow.postMessage("register", "*"); + let registration = yield promise; + + promise = waitForServiceWorkerRegistrationChange(registration, function () { + is(registration.scriptSpec, EXAMPLE_URL + "worker2.js"); + ok(registration.installingWorker !== null); + is(registration.installingWorker.scriptSpec, EXAMPLE_URL + "worker2.js"); + ok(registration.waitingWorker === null); + ok(registration.activeWorker !== null); + + return waitForServiceWorkerRegistrationChange(registration, function () { + ok(registration.installingWorker === null); + ok(registration.waitingWorker !== null); + ok(registration.activeWorker !== null); + + return waitForServiceWorkerRegistrationChange(registration, function () { + ok(registration.installingWorker === null); + ok(registration.waitingWorker === null); + ok(registration.activeWorker !== null); + + return registration; + }); + }); + }); + iframe.contentWindow.postMessage("register", "*"); + yield promise; + + iframe.contentWindow.postMessage("unregister", "*"); + yield waitForUnregister(EXAMPLE_URL); + + SimpleTest.finish(); + }); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + <iframe id="iframe"></iframe> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/serviceworkers/test_skip_waiting.html b/dom/workers/test/serviceworkers/test_skip_waiting.html new file mode 100644 index 000000000..7707d6035 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_skip_waiting.html @@ -0,0 +1,95 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1131352 - Add ServiceWorkerGlobalScope skipWaiting()</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration, iframe, content; + + function start() { + return navigator.serviceWorker.register("worker.js", + {scope: "./skip_waiting_scope/"}); + } + + function waitForActivated(swr) { + registration = swr; + var promise = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data === "READY") { + ok(true, "Active worker is activated now"); + resolve(); + } else { + ok(false, "Wrong value. Somenting went wrong"); + resolve(); + } + } + }); + + iframe = document.createElement("iframe"); + iframe.setAttribute("src", "skip_waiting_scope/index.html"); + + content = document.getElementById("content"); + content.appendChild(iframe); + + return promise; + } + + function checkWhetherItSkippedWaiting() { + var promise = new Promise(function(resolve, reject) { + window.onmessage = function (evt) { + if (evt.data.event === "controllerchange") { + ok(evt.data.controllerScriptURL.match("skip_waiting_installed_worker"), + "The controller changed after skiping the waiting step"); + resolve(); + } else { + ok(false, "Wrong value. Somenting went wrong"); + resolve(); + } + }; + }); + + navigator.serviceWorker.register("skip_waiting_installed_worker.js", + {scope: "./skip_waiting_scope/"}) + .then(swr => { + registration = swr; + }); + + return promise; + } + + function clean() { + content.removeChild(iframe); + + return registration.unregister(); + } + + function runTest() { + start() + .then(waitForActivated) + .then(checkWhetherItSkippedWaiting) + .then(clean) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_strict_mode_warning.html b/dom/workers/test/serviceworkers/test_strict_mode_warning.html new file mode 100644 index 000000000..5b66673b9 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_strict_mode_warning.html @@ -0,0 +1,42 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1170550 - test registration of service worker scripts with a strict mode warning</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + navigator.serviceWorker + .register("strict_mode_warning.js", {scope: "strict_mode_warning"}) + .then((reg) => { + ok(true, "Registration should not fail for warnings"); + return reg.unregister(); + }) + .then(() => { + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); + }; +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_third_party_iframes.html b/dom/workers/test/serviceworkers/test_third_party_iframes.html new file mode 100644 index 000000000..33e815379 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_third_party_iframes.html @@ -0,0 +1,175 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <meta http-equiv="Content-type" content="text/html;charset=UTF-8"> + <title>Bug 1152899 - Disallow the interception of third-party iframes using service workers when the third-party cookie preference is set</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe></iframe> +</div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript;version=1.7"> + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestLongerTimeout(2); + +let index = 0; +function next() { + info("Step " + index); + if (index >= steps.length) { + SimpleTest.finish(); + return; + } + try { + let i = index++; + steps[i](); + } catch(ex) { + ok(false, "Caught exception", ex); + } +} + +onload = next; + +let iframe; +let basePath = "/tests/dom/workers/test/serviceworkers/thirdparty/"; +let origin = window.location.protocol + "//" + window.location.host; +let thirdPartyOrigin = "https://example.com"; + +function testIframeLoaded() { + ok(true, "Iframe loaded"); + iframe.removeEventListener("load", testIframeLoaded); + let message = { + source: "parent", + href: origin + basePath + "iframe2.html" + }; + iframe.contentWindow.postMessage(message.toSource(), "*"); +} + +function loadThirdPartyIframe() { + let message = { + source: "parent", + href: thirdPartyOrigin + basePath + "iframe2.html" + } + iframe.contentWindow.postMessage(message.toSource(), "*"); +} + +function runTest(aExpectedResponses) { + iframe = document.querySelector("iframe"); + iframe.src = thirdPartyOrigin + basePath + "register.html"; + let responsesIndex = 0; + window.onmessage = function(e) { + let status = e.data.status; + let expected = aExpectedResponses[responsesIndex]; + if (status == expected.status) { + ok(true, "Received expected " + expected.status); + if (expected.next) { + expected.next(); + } + } else { + ok(false, "Expected " + expected.status + " got " + status); + } + responsesIndex++; + }; +} + +function testShouldIntercept(done) { + runTest([{ + status: "ok" + }, { + status: "registrationdone", + next: function() { + iframe.addEventListener("load", testIframeLoaded); + iframe.src = origin + basePath + "iframe1.html"; + } + }, { + status: "networkresponse", + next: loadThirdPartyIframe + }, { + status: "swresponse", + next: function() { + iframe.src = thirdPartyOrigin + basePath + "unregister.html"; + } + }, { + status: "unregistrationdone", + next: function() { + window.onmessage = null; + ok(true, "Test finished successfully"); + done(); + } + }]); +} + +function testShouldNotIntercept(done) { + runTest([{ + status: "ok" + }, { + status: "registrationdone", + next: function() { + iframe.addEventListener("load", testIframeLoaded); + iframe.src = origin + basePath + "iframe1.html"; + } + }, { + status: "networkresponse", + next: loadThirdPartyIframe + }, { + status: "networkresponse", + next: function() { + iframe.src = thirdPartyOrigin + basePath + "unregister.html"; + } + }, { + status: "unregistrationdone", + next: function() { + window.onmessage = null; + ok(true, "Test finished successfully"); + done(); + } + }]); +} + +const COOKIE_BEHAVIOR_ACCEPT = 0; +const COOKIE_BEHAVIOR_REJECTFOREIGN = 1; +const COOKIE_BEHAVIOR_REJECT = 2; +const COOKIE_BEHAVIOR_LIMITFOREIGN = 3; + +let steps = [() => { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ["browser.dom.window.dump.enabled", true], + ["network.cookie.cookieBehavior", COOKIE_BEHAVIOR_ACCEPT] + ]}, next); +}, () => { + testShouldIntercept(next); +}, () => { + SpecialPowers.pushPrefEnv({"set": [ + ["network.cookie.cookieBehavior", COOKIE_BEHAVIOR_REJECTFOREIGN] + ]}, next); +}, () => { + testShouldNotIntercept(next); +}, () => { + SpecialPowers.pushPrefEnv({"set": [ + ["network.cookie.cookieBehavior", COOKIE_BEHAVIOR_REJECT] + ]}, next); +}, () => { + testShouldIntercept(next); +}, () => { + SpecialPowers.pushPrefEnv({"set": [ + ["network.cookie.cookieBehavior", COOKIE_BEHAVIOR_LIMITFOREIGN] + ]}, next); +}, () => { + testShouldIntercept(next); +}]; + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_unregister.html b/dom/workers/test/serviceworkers/test_unregister.html new file mode 100644 index 000000000..8366f50c1 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_unregister.html @@ -0,0 +1,138 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 984048 - Test unregister</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + return navigator.serviceWorker.register("worker.js", { scope: "unregister/" }).then(function(swr) { + if (swr.installing) { + return new Promise(function(resolve, reject) { + swr.installing.onstatechange = function(e) { + if (swr.waiting) { + swr.waiting.onstatechange = function(e) { + if (swr.active) { + resolve(); + } else if (swr.waiting && swr.waiting.state == "redundant") { + reject("Should not go into redundant"); + } + } + } else { + if (swr.active) { + resolve(); + } else { + reject("No waiting and no active!"); + } + } + } + }); + } else { + return Promise.reject("Installing should be non-null"); + } + }); + } + + function testControlled() { + var testPromise = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (!("controlled" in e.data)) { + ok(false, "Something went wrong."); + rej(); + return; + } + + ok(e.data.controlled, "New window should be controlled."); + res(); + } + }) + + var div = document.getElementById("content"); + ok(div, "Parent exists"); + + var ifr = document.createElement("iframe"); + ifr.setAttribute('src', "unregister/index.html"); + div.appendChild(ifr); + + return testPromise.then(function() { + div.removeChild(ifr); + }); + } + + function unregister() { + return navigator.serviceWorker.getRegistration("unregister/") + .then(function(reg) { + if (!reg) { + info("Registration already removed"); + return; + } + + info("getRegistration() succeeded " + reg.scope); + return reg.unregister().then(function(v) { + ok(v, "Unregister should resolve to true"); + }, function(e) { + ok(false, "Unregister failed with " + e.name); + }); + }); + } + + function testUncontrolled() { + var testPromise = new Promise(function(res, rej) { + window.onmessage = function(e) { + if (!("controlled" in e.data)) { + ok(false, "Something went wrong."); + rej(); + return; + } + + ok(!e.data.controlled, "New window should not be controlled."); + res(); + } + }); + + var div = document.getElementById("content"); + ok(div, "Parent exists"); + + var ifr = document.createElement("iframe"); + ifr.setAttribute('src', "unregister/index.html"); + div.appendChild(ifr); + + return testPromise.then(function() { + div.removeChild(ifr); + }); + } + + function runTest() { + simpleRegister() + .then(testControlled) + .then(unregister) + .then(testUncontrolled) + .then(function() { + SimpleTest.finish(); + }).catch(function(e) { + ok(false, "Some test failed with error " + e); + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_unresolved_fetch_interception.html b/dom/workers/test/serviceworkers/test_unresolved_fetch_interception.html new file mode 100644 index 000000000..7296a3ddf --- /dev/null +++ b/dom/workers/test/serviceworkers/test_unresolved_fetch_interception.html @@ -0,0 +1,100 @@ +<!DOCTYPE HTML> +<html> +<!-- + Test that an unresolved respondWith promise will reset the channel when + the service worker is terminated due to idling, and that appropriate error + messages are logged for both the termination of the serice worker and the + resetting of the channel. + --> +<head> + <title>Test for Bug 1188545</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/SpawnTask.js"></script> + <script src="error_reporting_helpers.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <meta http-equiv="Content-type" content="text/html;charset=UTF-8"> +</head> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1188545">Mozilla Bug 118845</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> + +<script class="testbody" type="text/javascript"> +// (This doesn't really need to be its own task, but it allows the actual test +// case to be self-contained.) +add_task(function setupPrefs() { + return SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}); +}); + +add_task(function* grace_timeout_termination_with_interrupted_intercept() { + // Setup timeouts so that the service worker will go into grace timeout after + // a zero-length idle timeout. + yield SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.idle_timeout", 0], + ["dom.serviceWorkers.idle_extended_timeout", 299999]]}); + + // The SW will claim us once it activates; this is async, start listening now. + let waitForControlled = new Promise((resolve) => { + navigator.serviceWorker.oncontrollerchange = resolve; + }); + + let registration = yield navigator.serviceWorker.register( + "unresolved_fetch_worker.js", { scope: "./"} ); + yield waitForControlled; + ok(navigator.serviceWorker.controller, "Controlled"); // double check! + + // We want to make sure the SW is active and processing the fetch before we + // try and kill it. It sends us a message when it has done so. + let waitForFetchActive = new Promise((resolve) => { + navigator.serviceWorker.onmessage = resolve; + }); + + // Issue a fetch which the SW will respondWith() a never resolved promise. + // The fetch, however, will terminate when the SW is killed, so check that. + let hangingFetch = fetch("does_not_exist.html") + .then(() => { ok(false, "should have rejected "); }, + () => { ok(true, "hung fetch terminates when worker dies"); }); + + yield waitForFetchActive; + + let expectedMessage = expect_console_message( + // Termination error + "ServiceWorkerGraceTimeoutTermination", + [make_absolute_url("./")], + // The interception failure error generated by the RespondWithHandler + // destructor when it notices it didn't get a response before being + // destroyed. It logs via the intercepted channel nsIConsoleReportCollector + // that is eventually flushed to our document and its console. + "InterceptionFailedWithURL", + [make_absolute_url("does_not_exist.html")] + ); + + // Zero out the grace timeout too so the worker will get terminated after two + // zero-length timer firings. Note that we need to do something to get the + // SW to renew its keepalive for this to actually cause the timers to be + // rescheduled... + yield SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.idle_extended_timeout", 0]]}); + // ...which we do by postMessaging it. + navigator.serviceWorker.controller.postMessage("doomity doom doom"); + + // Now wait for signs that the worker was terminated by the fetch failing. + yield hangingFetch; + + // The worker should now be dead and the error logged, wait/assert. + yield wait_for_expected_message(expectedMessage); + + // roll back all of our test case specific preferences and otherwise cleanup + yield SpecialPowers.popPrefEnv(); + yield SpecialPowers.popPrefEnv(); + yield registration.unregister(); +}); +</script> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/test_workerUnregister.html b/dom/workers/test/serviceworkers/test_workerUnregister.html new file mode 100644 index 000000000..947861c17 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_workerUnregister.html @@ -0,0 +1,82 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 982728 - Test ServiceWorkerGlobalScope.unregister</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="container"></div> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + return navigator.serviceWorker.register("worker_unregister.js", { scope: "unregister/" }).then(function(swr) { + if (swr.installing) { + return new Promise(function(resolve, reject) { + swr.installing.onstatechange = function(e) { + if (swr.waiting) { + swr.waiting.onstatechange = function(e) { + if (swr.active) { + resolve(); + } else if (swr.waiting && swr.waiting.state == "redundant") { + reject("Should not go into redundant"); + } + } + } else { + if (swr.active) { + resolve(); + } else { + reject("No waiting and no active!"); + } + } + } + }); + } else { + return Promise.reject("Installing should be non-null"); + } + }); + } + + function waitForMessages(sw) { + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data === "DONE") { + ok(true, "The worker has unregistered itself"); + } else if (e.data === "ERROR") { + ok(false, "The worker has unregistered itself"); + } else if (e.data === "FINISH") { + resolve(); + } + } + }); + + var frame = document.createElement("iframe"); + frame.setAttribute("src", "unregister/unregister.html"); + document.body.appendChild(frame); + + return p; + } + + function runTest() { + simpleRegister().then(waitForMessages).catch(function(e) { + ok(false, "Something went wrong."); + }).then(function() { + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_workerUpdate.html b/dom/workers/test/serviceworkers/test_workerUpdate.html new file mode 100644 index 000000000..5621d6cb8 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_workerUpdate.html @@ -0,0 +1,62 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1065366 - Test ServiceWorkerGlobalScope.update</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="container"></div> +<script class="testbody" type="text/javascript"> + + function simpleRegister() { + return navigator.serviceWorker.register("worker_update.js", { scope: "workerUpdate/" }); + } + + var registration; + function waitForMessages(sw) { + registration = sw; + var p = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + if (e.data === "FINISH") { + ok(true, "The worker has updated itself"); + resolve(); + } else if (e.data === "FAIL") { + ok(false, "The worker failed to update itself"); + resolve(); + } + } + }); + + var frame = document.createElement("iframe"); + frame.setAttribute("src", "workerUpdate/update.html"); + document.body.appendChild(frame); + + return p; + } + + function runTest() { + simpleRegister().then(waitForMessages).catch(function(e) { + ok(false, "Something went wrong."); + }).then(function() { + return registration.unregister(); + }).then(function() { + SimpleTest.finish(); + }); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true] + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_workerupdatefoundevent.html b/dom/workers/test/serviceworkers/test_workerupdatefoundevent.html new file mode 100644 index 000000000..3361eba08 --- /dev/null +++ b/dom/workers/test/serviceworkers/test_workerupdatefoundevent.html @@ -0,0 +1,85 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1131327 - Test ServiceWorkerRegistration.onupdatefound on ServiceWorker</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var promise; + + function start() { + return navigator.serviceWorker.register("worker_updatefoundevent.js", + { scope: "./updatefoundevent.html" }) + .then((swr) => registration = swr); + } + + function startWaitForUpdateFound() { + registration.onupdatefound = function(e) { + } + + promise = new Promise(function(resolve, reject) { + window.onmessage = function(e) { + + if (e.data == "finish") { + ok(true, "Received updatefound"); + resolve(); + } + } + }); + + content = document.getElementById("content"); + iframe = document.createElement("iframe"); + content.appendChild(iframe); + iframe.setAttribute("src", "./updatefoundevent.html"); + + return Promise.resolve(); + } + + function registerNext() { + return navigator.serviceWorker.register("worker_updatefoundevent2.js", + { scope: "./updatefoundevent.html" }); + } + + function waitForUpdateFound() { + return promise; + } + + function unregister() { + window.onmessage = null; + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }); + } + + function runTest() { + start() + .then(startWaitForUpdateFound) + .then(registerNext) + .then(waitForUpdateFound) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/test_xslt.html b/dom/workers/test/serviceworkers/test_xslt.html new file mode 100644 index 000000000..44270753b --- /dev/null +++ b/dom/workers/test/serviceworkers/test_xslt.html @@ -0,0 +1,128 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1182113 - Test service worker XSLT interception</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + var registration; + var worker; + + function start() { + return navigator.serviceWorker.register("xslt_worker.js", + { scope: "./" }) + .then((swr) => { + registration = swr; + + // Ensure the registration is active before continuing + var worker = registration.installing; + return new Promise((resolve) => { + if (worker.state === 'activated') { + resolve(); + return; + } + worker.addEventListener('statechange', () => { + if (worker.state === 'activated') { + resolve(); + } + }); + }); + }); + } + + function unregister() { + return registration.unregister().then(function(result) { + ok(result, "Unregister should return true."); + }, function(e) { + dump("Unregistering the SW failed with " + e + "\n"); + }); + } + + function getXmlString(xmlObject) { + serializer = new XMLSerializer(); + return serializer.serializeToString(iframe.contentDocument); + } + + function synthetic() { + content = document.getElementById("content"); + ok(content, "parent exists."); + + iframe = document.createElement("iframe"); + content.appendChild(iframe); + + iframe.setAttribute('src', "xslt/test.xml"); + + var p = new Promise(function(res, rej) { + iframe.onload = function(e) { + dump("Set request mode\n"); + registration.active.postMessage("synthetic"); + xmlString = getXmlString(iframe.contentDocument); + ok(!xmlString.includes("Error"), "Load synthetic cross origin XSLT should be allowed"); + res(); + }; + }); + + return p; + } + + function cors() { + var p = new Promise(function(res, rej) { + iframe.onload = function(e) { + xmlString = getXmlString(iframe.contentDocument); + ok(!xmlString.includes("Error"), "Load CORS cross origin XSLT should be allowed"); + res(); + }; + }); + + registration.active.postMessage("cors"); + iframe.setAttribute('src', "xslt/test.xml"); + + return p; + } + + function opaque() { + var p = new Promise(function(res, rej) { + iframe.onload = function(e) { + xmlString = getXmlString(iframe.contentDocument); + ok(xmlString.includes("Error"), "Load opaque cross origin XSLT should not be allowed"); + res(); + }; + }); + + registration.active.postMessage("opaque"); + iframe.setAttribute('src', "xslt/test.xml"); + + return p; + } + + function runTest() { + start() + .then(synthetic) + .then(opaque) + .then(cors) + .then(unregister) + .catch(function(e) { + ok(false, "Some test failed with error " + e); + }).then(SimpleTest.finish); + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.exemptFromPerDomainMax", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}, runTest); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/thirdparty/iframe1.html b/dom/workers/test/serviceworkers/thirdparty/iframe1.html new file mode 100644 index 000000000..43fe8c572 --- /dev/null +++ b/dom/workers/test/serviceworkers/thirdparty/iframe1.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <meta http-equiv="Content-type" content="text/html;charset=UTF-8"> + <title>SW third party iframe test</title> + + <script type="text/javascript;version=1.7"> + function messageListener(event) { + let message = eval(event.data); + + dump("got message " + JSON.stringify(message) + "\n"); + if (message.source == "parent") { + document.getElementById("iframe2").src = message.href; + } + else if (message.source == "iframe") { + parent.postMessage(event.data, "*"); + } + } + </script> + +</head> + +<body onload="window.addEventListener('message', messageListener, false);"> + <iframe id="iframe2"></iframe> +</body> + +</html> diff --git a/dom/workers/test/serviceworkers/thirdparty/iframe2.html b/dom/workers/test/serviceworkers/thirdparty/iframe2.html new file mode 100644 index 000000000..fac6a9395 --- /dev/null +++ b/dom/workers/test/serviceworkers/thirdparty/iframe2.html @@ -0,0 +1,7 @@ +<!DOCTYPE html> +<script> + window.parent.postMessage({ + source: "iframe", + status: "networkresponse" + }, "*"); +</script> diff --git a/dom/workers/test/serviceworkers/thirdparty/register.html b/dom/workers/test/serviceworkers/thirdparty/register.html new file mode 100644 index 000000000..59b8c5c41 --- /dev/null +++ b/dom/workers/test/serviceworkers/thirdparty/register.html @@ -0,0 +1,27 @@ +<!DOCTYPE html> +<script> + function ok(v, msg) { + window.parent.postMessage({status: "ok", result: !!v, message: msg}, "*"); + } + + var isDone = false; + function done(reg) { + if (!isDone) { + ok(reg.waiting || reg.active, + "Either active or waiting worker should be available."); + window.parent.postMessage({status: "registrationdone"}, "*"); + isDone = true; + } + } + + navigator.serviceWorker.register("sw.js", {scope: "."}) + .then(function(registration) { + if (registration.installing) { + registration.installing.onstatechange = function(e) { + done(registration); + }; + } else { + done(registration); + } + }); +</script> diff --git a/dom/workers/test/serviceworkers/thirdparty/sw.js b/dom/workers/test/serviceworkers/thirdparty/sw.js new file mode 100644 index 000000000..ca45698c8 --- /dev/null +++ b/dom/workers/test/serviceworkers/thirdparty/sw.js @@ -0,0 +1,14 @@ +self.addEventListener("fetch", function(event) { + dump("fetch " + event.request.url + "\n"); + if (event.request.url.indexOf("iframe2.html") >= 0) { + var body = + "<script>" + + "window.parent.postMessage({" + + "source: 'iframe', status: 'swresponse'" + + "}, '*');" + + "</script>"; + event.respondWith(new Response(body, { + headers: {'Content-Type': 'text/html'} + })); + } +}); diff --git a/dom/workers/test/serviceworkers/thirdparty/unregister.html b/dom/workers/test/serviceworkers/thirdparty/unregister.html new file mode 100644 index 000000000..2cb6ee0ce --- /dev/null +++ b/dom/workers/test/serviceworkers/thirdparty/unregister.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<script> + navigator.serviceWorker.getRegistration(".").then(function(registration) { + if(!registration) { + return; + } + registration.unregister().then(() => { + window.parent.postMessage({status: "unregistrationdone"}, "*"); + }); + }); +</script> diff --git a/dom/workers/test/serviceworkers/unregister/index.html b/dom/workers/test/serviceworkers/unregister/index.html new file mode 100644 index 000000000..db23d2cb7 --- /dev/null +++ b/dom/workers/test/serviceworkers/unregister/index.html @@ -0,0 +1,26 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 984048 - Test unregister</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + if (!parent) { + info("unregister/index.html should not to be launched directly!"); + } + + parent.postMessage({ controlled: !!navigator.serviceWorker.controller }, "*"); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/serviceworkers/unregister/unregister.html b/dom/workers/test/serviceworkers/unregister/unregister.html new file mode 100644 index 000000000..6fda82026 --- /dev/null +++ b/dom/workers/test/serviceworkers/unregister/unregister.html @@ -0,0 +1,22 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test worker::unregister</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script type="text/javascript"> + + navigator.serviceWorker.onmessage = function(e) { parent.postMessage(e.data, "*"); } + navigator.serviceWorker.controller.postMessage("GO"); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/unresolved_fetch_worker.js b/dom/workers/test/serviceworkers/unresolved_fetch_worker.js new file mode 100644 index 000000000..71fbad781 --- /dev/null +++ b/dom/workers/test/serviceworkers/unresolved_fetch_worker.js @@ -0,0 +1,19 @@ +var keepPromiseAlive; +onfetch = function(event) { + event.waitUntil( + clients.matchAll() + .then(clients => { + clients.forEach(client => { + client.postMessage("continue"); + }); + }) + ); + + // Never resolve, and keep it alive on our global so it can't get GC'ed and + // make this test weird and intermittent. + event.respondWith((keepPromiseAlive = new Promise(function(res, rej) {}))); +} + +onactivate = function(event) { + event.waitUntil(clients.claim()); +} diff --git a/dom/workers/test/serviceworkers/updatefoundevent.html b/dom/workers/test/serviceworkers/updatefoundevent.html new file mode 100644 index 000000000..78088c7cd --- /dev/null +++ b/dom/workers/test/serviceworkers/updatefoundevent.html @@ -0,0 +1,13 @@ +<!DOCTYPE html> +<html> +<head> + <title>Bug 1131327 - Test ServiceWorkerRegistration.onupdatefound on ServiceWorker</title> +</head> +<body> +<script> + navigator.serviceWorker.onmessage = function(e) { + dump("NSM iframe got message " + e.data + "\n"); + window.parent.postMessage(e.data, "*"); + }; +</script> +</body> diff --git a/dom/workers/test/serviceworkers/worker.js b/dom/workers/test/serviceworkers/worker.js new file mode 100644 index 000000000..2aba167d1 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker.js @@ -0,0 +1 @@ +// empty worker, always succeed! diff --git a/dom/workers/test/serviceworkers/worker2.js b/dom/workers/test/serviceworkers/worker2.js new file mode 100644 index 000000000..3072d0817 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker2.js @@ -0,0 +1 @@ +// worker2.js diff --git a/dom/workers/test/serviceworkers/worker3.js b/dom/workers/test/serviceworkers/worker3.js new file mode 100644 index 000000000..449fc2f97 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker3.js @@ -0,0 +1 @@ +// worker3.js diff --git a/dom/workers/test/serviceworkers/workerUpdate/update.html b/dom/workers/test/serviceworkers/workerUpdate/update.html new file mode 100644 index 000000000..8f984ccc4 --- /dev/null +++ b/dom/workers/test/serviceworkers/workerUpdate/update.html @@ -0,0 +1,24 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test worker::update</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script type="text/javascript"> + + navigator.serviceWorker.onmessage = function(e) { parent.postMessage(e.data, "*"); } + navigator.serviceWorker.ready.then(function() { + navigator.serviceWorker.controller.postMessage("GO"); + }); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/serviceworkers/worker_unregister.js b/dom/workers/test/serviceworkers/worker_unregister.js new file mode 100644 index 000000000..7a3e764f4 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker_unregister.js @@ -0,0 +1,16 @@ +onmessage = function(e) { + clients.matchAll().then(function(c) { + if (c.length === 0) { + // We cannot proceed. + return; + } + + registration.unregister().then(function() { + c[0].postMessage('DONE'); + }, function() { + c[0].postMessage('ERROR'); + }).then(function() { + c[0].postMessage('FINISH'); + }); + }); +} diff --git a/dom/workers/test/serviceworkers/worker_update.js b/dom/workers/test/serviceworkers/worker_update.js new file mode 100644 index 000000000..9f3e55b18 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker_update.js @@ -0,0 +1,19 @@ +// For now this test only calls update to verify that our registration +// job queueing works properly when called from the worker thread. We should +// test actual update scenarios with a SJS test. +onmessage = function(e) { + self.registration.update().then(function(v) { + return v === undefined ? 'FINISH' : 'FAIL'; + }).catch(function(e) { + return 'FAIL'; + }).then(function(result) { + clients.matchAll().then(function(c) { + if (c.length == 0) { + dump("!!!!!!!!!!! WORKER HAS NO CLIENTS TO FINISH TEST !!!!!!!!!!!!\n"); + return; + } + + c[0].postMessage(result); + }); + }); +} diff --git a/dom/workers/test/serviceworkers/worker_updatefoundevent.js b/dom/workers/test/serviceworkers/worker_updatefoundevent.js new file mode 100644 index 000000000..a297bf455 --- /dev/null +++ b/dom/workers/test/serviceworkers/worker_updatefoundevent.js @@ -0,0 +1,23 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +onactivate = function(e) { + e.waitUntil(new Promise(function(resolve, reject) { + registration.onupdatefound = function(e) { + clients.matchAll().then(function(clients) { + if (!clients.length) { + reject("No clients found"); + } + + if (registration.scope.match(/updatefoundevent\.html$/)) { + clients[0].postMessage("finish"); + resolve(); + } else { + dump("Scope did not match"); + } + }, reject); + } + })); +} diff --git a/dom/workers/test/serviceworkers/worker_updatefoundevent2.js b/dom/workers/test/serviceworkers/worker_updatefoundevent2.js new file mode 100644 index 000000000..da4c592aa --- /dev/null +++ b/dom/workers/test/serviceworkers/worker_updatefoundevent2.js @@ -0,0 +1 @@ +// Not useful. diff --git a/dom/workers/test/serviceworkers/xslt/test.xml b/dom/workers/test/serviceworkers/xslt/test.xml new file mode 100644 index 000000000..83c777633 --- /dev/null +++ b/dom/workers/test/serviceworkers/xslt/test.xml @@ -0,0 +1,6 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/xsl" href="test.xsl"?> +<result> + <Title>Example</Title> + <Error>Error</Error> +</result> diff --git a/dom/workers/test/serviceworkers/xslt/xslt.sjs b/dom/workers/test/serviceworkers/xslt/xslt.sjs new file mode 100644 index 000000000..db681ab50 --- /dev/null +++ b/dom/workers/test/serviceworkers/xslt/xslt.sjs @@ -0,0 +1,12 @@ +function handleRequest(request, response) { + response.setHeader("Content-Type", "application/xslt+xml", false); + response.setHeader("Access-Control-Allow-Origin", "*"); + + var body = request.queryString; + if (!body) { + response.setStatusLine(null, 500, "Invalid querystring"); + return; + } + + response.write(unescape(body)); +} diff --git a/dom/workers/test/serviceworkers/xslt_worker.js b/dom/workers/test/serviceworkers/xslt_worker.js new file mode 100644 index 000000000..bf9bdbc56 --- /dev/null +++ b/dom/workers/test/serviceworkers/xslt_worker.js @@ -0,0 +1,52 @@ +var testType = 'synthetic'; + +var xslt = "<?xml version=\"1.0\"?> " + + "<xsl:stylesheet version=\"1.0\"" + + " xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">" + + " <xsl:template match=\"node()|@*\">" + + " <xsl:copy>" + + " <xsl:apply-templates select=\"node()|@*\"/>" + + " </xsl:copy>" + + " </xsl:template>" + + " <xsl:template match=\"Error\"/>" + + "</xsl:stylesheet>"; + +onfetch = function(event) { + if (event.request.url.includes('test.xsl')) { + if (testType == 'synthetic') { + if (event.request.mode != 'cors') { + event.respondWith(Response.error()); + return; + } + + event.respondWith(Promise.resolve( + new Response(xslt, { headers: {'Content-Type': 'application/xslt+xml'}}) + )); + } + else if (testType == 'cors') { + if (event.request.mode != 'cors') { + event.respondWith(Response.error()); + return; + } + + var url = "http://example.com/tests/dom/workers/test/serviceworkers/xslt/xslt.sjs?" + escape(xslt); + event.respondWith(fetch(url, { mode: 'cors' })); + } + else if (testType == 'opaque') { + if (event.request.mode != 'cors') { + event.respondWith(Response.error()); + return; + } + + var url = "http://example.com/tests/dom/workers/test/serviceworkers/xslt/xslt.sjs?" + escape(xslt); + event.respondWith(fetch(url, { mode: 'no-cors' })); + } + else { + event.respondWith(Response.error()); + } + } +}; + +onmessage = function(event) { + testType = event.data; +}; diff --git a/dom/workers/test/sharedWorker_console.js b/dom/workers/test/sharedWorker_console.js new file mode 100644 index 000000000..932235eb7 --- /dev/null +++ b/dom/workers/test/sharedWorker_console.js @@ -0,0 +1,11 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +onconnect = function(evt) { + console.profile("Hello profiling from a SharedWorker!"); + console.log("Hello world from a SharedWorker!"); + evt.ports[0].postMessage('ok!'); +} diff --git a/dom/workers/test/sharedWorker_lifetime.js b/dom/workers/test/sharedWorker_lifetime.js new file mode 100644 index 000000000..3d9a837bb --- /dev/null +++ b/dom/workers/test/sharedWorker_lifetime.js @@ -0,0 +1,5 @@ +onconnect = function(e) { + setTimeout(function() { + e.ports[0].postMessage("Still alive!"); + }, 500); +} diff --git a/dom/workers/test/sharedWorker_ports.js b/dom/workers/test/sharedWorker_ports.js new file mode 100644 index 000000000..64672e6ab --- /dev/null +++ b/dom/workers/test/sharedWorker_ports.js @@ -0,0 +1,24 @@ +var port; +onconnect = function(evt) { + evt.source.postMessage({ type: "connected" }); + + if (!port) { + port = evt.source; + evt.source.onmessage = function(evtFromPort) { + port.postMessage({type: "status", + test: "Port from the main-thread!" == evtFromPort.data, + msg: "The message is coming from the main-thread"}); + port.postMessage({type: "status", + test: (evtFromPort.ports.length == 1), + msg: "1 port transferred"}); + + evtFromPort.ports[0].onmessage = function(evtFromPort2) { + port.postMessage({type: "status", + test: (evtFromPort2.data.type == "connected"), + msg: "The original message received" }); + port.postMessage({type: "finish"}); + close(); + } + } + } +} diff --git a/dom/workers/test/sharedWorker_privateBrowsing.js b/dom/workers/test/sharedWorker_privateBrowsing.js new file mode 100644 index 000000000..9d7ec886f --- /dev/null +++ b/dom/workers/test/sharedWorker_privateBrowsing.js @@ -0,0 +1,5 @@ +var counter = 0; +onconnect = function(evt) { + evt.ports[0].postMessage(++counter); +} + diff --git a/dom/workers/test/sharedWorker_sharedWorker.js b/dom/workers/test/sharedWorker_sharedWorker.js new file mode 100644 index 000000000..5e8e93392 --- /dev/null +++ b/dom/workers/test/sharedWorker_sharedWorker.js @@ -0,0 +1,93 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +if (!("self" in this)) { + throw new Error("No 'self' exists on SharedWorkerGlobalScope!"); +} +if (this !== self) { + throw new Error("'self' not equal to global object!"); +} +if (!(self instanceof SharedWorkerGlobalScope)) { + throw new Error("self not a SharedWorkerGlobalScope instance!"); +} + +var propsToCheck = [ + "location", + "navigator", + "close", + "importScripts", + "setTimeout", + "clearTimeout", + "setInterval", + "clearInterval", + "dump", + "atob", + "btoa" +]; + +for (var index = 0; index < propsToCheck.length; index++) { + var prop = propsToCheck[index]; + if (!(prop in self)) { + throw new Error("SharedWorkerGlobalScope has no '" + prop + "' property!"); + } +} + +onconnect = function(event) { + if (!("SharedWorkerGlobalScope" in self)) { + throw new Error("SharedWorkerGlobalScope should be visible!"); + } + if (!(self instanceof SharedWorkerGlobalScope)) { + throw new Error("The global should be a SharedWorkerGlobalScope!"); + } + if (!(self instanceof WorkerGlobalScope)) { + throw new Error("The global should be a WorkerGlobalScope!"); + } + if ("DedicatedWorkerGlobalScope" in self) { + throw new Error("DedicatedWorkerGlobalScope should not be visible!"); + } + if (!(event instanceof MessageEvent)) { + throw new Error("'connect' event is not a MessageEvent!"); + } + if (!("ports" in event)) { + throw new Error("'connect' event doesn't have a 'ports' property!"); + } + if (event.ports.length != 1) { + throw new Error("'connect' event has a 'ports' property with length '" + + event.ports.length + "'!"); + } + if (!event.ports[0]) { + throw new Error("'connect' event has a null 'ports[0]' property!"); + } + if (!(event.ports[0] instanceof MessagePort)) { + throw new Error("'connect' event has a 'ports[0]' property that isn't a " + + "MessagePort!"); + } + if (!(event.ports[0] == event.source)) { + throw new Error("'connect' event source property is incorrect!"); + } + if (event.data) { + throw new Error("'connect' event has data: " + event.data); + } + + // The expression closures should trigger a warning in debug builds, but NOT + // fire error events at us. If we ever actually remove expression closures + // (in bug 1083458), we'll need something else to test this case. + (function() "Expected console warning: expression closures are deprecated"); + + event.ports[0].onmessage = function(event) { + if (!(event instanceof MessageEvent)) { + throw new Error("'message' event is not a MessageEvent!"); + } + if (!("ports" in event)) { + throw new Error("'message' event doesn't have a 'ports' property!"); + } + if (event.ports === null) { + throw new Error("'message' event has a null 'ports' property!"); + } + event.target.postMessage(event.data); + throw new Error(event.data); + }; +}; diff --git a/dom/workers/test/simpleThread_worker.js b/dom/workers/test/simpleThread_worker.js new file mode 100644 index 000000000..543d8b3dd --- /dev/null +++ b/dom/workers/test/simpleThread_worker.js @@ -0,0 +1,53 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +function messageListener(event) { + var exception; + try { + event.bubbles = true; + } + catch(e) { + exception = e; + } + + if (!(exception instanceof TypeError)) { + throw exception; + } + + switch (event.data) { + case "no-op": + break; + case "components": + postMessage(Components.toString()); + break; + case "start": + for (var i = 0; i < 1000; i++) { } + postMessage("started"); + break; + case "stop": + self.postMessage('no-op'); + postMessage("stopped"); + self.removeEventListener("message", messageListener, false); + break; + default: + throw 'Bad message: ' + event.data; + } +} + +if (!("DedicatedWorkerGlobalScope" in self)) { + throw new Error("DedicatedWorkerGlobalScope should be visible!"); +} +if (!(self instanceof DedicatedWorkerGlobalScope)) { + throw new Error("The global should be a SharedWorkerGlobalScope!"); +} +if (!(self instanceof WorkerGlobalScope)) { + throw new Error("The global should be a WorkerGlobalScope!"); +} +if ("SharedWorkerGlobalScope" in self) { + throw new Error("SharedWorkerGlobalScope should not be visible!"); +} + +addEventListener("message", { handleEvent: messageListener }); diff --git a/dom/workers/test/suspend_iframe.html b/dom/workers/test/suspend_iframe.html new file mode 100644 index 000000000..86d9d6bc1 --- /dev/null +++ b/dom/workers/test/suspend_iframe.html @@ -0,0 +1,47 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for DOM Worker Threads Suspending</title> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<div id="output"></div> +<script class="testbody" type="text/javascript"> + + var output = document.getElementById("output"); + + var worker; + + function terminateWorker() { + if (worker) { + worker.postMessage("stop"); + worker = null; + } + } + + function startWorker(messageCallback, errorCallback) { + var lastData; + worker = new Worker("suspend_worker.js"); + + worker.onmessage = function(event) { + output.textContent = (lastData ? lastData + " -> " : "") + event.data; + lastData = event.data; + messageCallback(event.data); + }; + + worker.onerror = function(event) { + this.terminate(); + errorCallback(event.message); + }; + } + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/suspend_worker.js b/dom/workers/test/suspend_worker.js new file mode 100644 index 000000000..43eb24a7a --- /dev/null +++ b/dom/workers/test/suspend_worker.js @@ -0,0 +1,13 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var counter = 0; + +var interval = setInterval(function() { + postMessage(++counter); +}, 100); + +onmessage = function(event) { + clearInterval(interval); +} diff --git a/dom/workers/test/terminate_worker.js b/dom/workers/test/terminate_worker.js new file mode 100644 index 000000000..f1a49e032 --- /dev/null +++ b/dom/workers/test/terminate_worker.js @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + throw "No messages should reach me!"; +} + +setInterval(function() { postMessage("Still alive!"); }, 100); diff --git a/dom/workers/test/test_404.html b/dom/workers/test/test_404.html new file mode 100644 index 000000000..e2e83a35e --- /dev/null +++ b/dom/workers/test/test_404.html @@ -0,0 +1,41 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads +--> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("nonexistent_worker.js"); + + worker.onmessage = function(event) { + ok(false, "Shouldn't ever get a message!"); + SimpleTest.finish(); + } + + worker.onerror = function(event) { + is(event.target, worker); + is(event.message, 'NetworkError: Failed to load worker script at "nonexistent_worker.js"'); + event.preventDefault(); + SimpleTest.finish(); + }; + + worker.postMessage("dummy"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_WorkerDebugger.initialize.xul b/dom/workers/test/test_WorkerDebugger.initialize.xul new file mode 100644 index 000000000..9e40bb78c --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger.initialize.xul @@ -0,0 +1,58 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger.initialize" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger.initialize_worker.js"; + const CHILD_WORKER_URL = "WorkerDebugger.initialize_childWorker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebugger.initialize_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker that creates a child worker, wait for their " + + "debuggers to be registered, and initialize them."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL, DEBUGGER_URL), + waitForRegister(CHILD_WORKER_URL, DEBUGGER_URL) + ]); + let worker = new Worker(WORKER_URL); + yield promise; + + info("Check that the debuggers are initialized before the workers " + + "start running."); + yield waitForMultiple([ + waitForWorkerMessage(worker, "debugger"), + waitForWorkerMessage(worker, "worker"), + waitForWorkerMessage(worker, "child:debugger"), + waitForWorkerMessage(worker, "child:worker") + ]); + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger.postMessage.xul b/dom/workers/test/test_WorkerDebugger.postMessage.xul new file mode 100644 index 000000000..7affbed21 --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger.postMessage.xul @@ -0,0 +1,61 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger.postMessage" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger.postMessage_worker.js"; + const CHILD_WORKER_URL = "WorkerDebugger.postMessage_childWorker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebugger.postMessage_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker that creates a child worker, wait for their " + + "debuggers to be registered, and initialize them."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL, DEBUGGER_URL), + waitForRegister(CHILD_WORKER_URL, DEBUGGER_URL) + ]); + let worker = new Worker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + info("Send a request to the worker debugger. This should cause the " + + "the worker debugger to send a response."); + promise = waitForDebuggerMessage(dbg, "pong"); + dbg.postMessage("ping"); + yield promise; + + info("Send a request to the child worker debugger. This should cause " + + "the child worker debugger to send a response."); + promise = waitForDebuggerMessage(childDbg, "pong"); + childDbg.postMessage("ping"); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger.xul b/dom/workers/test/test_WorkerDebugger.xul new file mode 100644 index 000000000..f3397bd54 --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger.xul @@ -0,0 +1,122 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger_worker.js"; + const CHILD_WORKER_URL = "WorkerDebugger_childWorker.js"; + const SHARED_WORKER_URL = "WorkerDebugger_sharedWorker.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a top-level chrome worker that creates a non-top-level " + + "content worker and wait for their debuggers to be registered."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL), + waitForRegister(CHILD_WORKER_URL) + ]); + worker = new ChromeWorker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + info("Check that the top-level chrome worker debugger has the " + + "correct properties."); + is(dbg.isChrome, true, + "Chrome worker debugger should be chrome."); + is(dbg.parent, null, + "Top-level debugger should not have parent."); + is(dbg.type, Ci.nsIWorkerDebugger.TYPE_DEDICATED, + "Chrome worker debugger should be dedicated."); + is(dbg.window, window, + "Top-level dedicated worker debugger should have window."); + + info("Check that the non-top-level content worker debugger has the " + + "correct properties."); + is(childDbg.isChrome, false, + "Content worker debugger should be content."); + is(childDbg.parent, dbg, + "Non-top-level worker debugger should have parent."); + is(childDbg.type, Ci.nsIWorkerDebugger.TYPE_DEDICATED, + "Content worker debugger should be dedicated."); + is(childDbg.window, null, + "Non-top-level worker debugger should not have window."); + + info("Terminate the top-level chrome worker and the non-top-level " + + "content worker, and wait for their debuggers to be " + + "unregistered and closed."); + promise = waitForMultiple([ + waitForUnregister(CHILD_WORKER_URL), + waitForDebuggerClose(childDbg), + waitForUnregister(WORKER_URL), + waitForDebuggerClose(dbg), + ]); + worker.terminate(); + yield promise; + + info("Create a shared worker and wait for its debugger to be " + + "registered"); + promise = waitForRegister(SHARED_WORKER_URL); + worker = new SharedWorker(SHARED_WORKER_URL); + let sharedDbg = yield promise; + + info("Check that the shared worker debugger has the correct " + + "properties."); + is(sharedDbg.isChrome, false, + "Shared worker debugger should be content."); + is(sharedDbg.parent, null, + "Shared worker debugger should not have parent."); + is(sharedDbg.type, Ci.nsIWorkerDebugger.TYPE_SHARED, + "Shared worker debugger should be shared."); + is(sharedDbg.window, null, + "Shared worker debugger should not have window."); + + info("Create a shared worker with the same URL and check that its " + + "debugger is not registered again."); + let listener = { + onRegistered: function () { + ok(false, + "Shared worker debugger should not be registered again."); + }, + }; + wdm.addListener(listener); + worker = new SharedWorker(SHARED_WORKER_URL); + + info("Send a message to the shared worker to tell it to close " + + "itself, and wait for its debugger to be closed."); + promise = waitForMultiple([ + waitForUnregister(SHARED_WORKER_URL), + waitForDebuggerClose(sharedDbg) + ]); + worker.port.start(); + worker.port.postMessage("close"); + yield promise; + + wdm.removeListener(listener); + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebuggerGlobalScope.createSandbox.xul b/dom/workers/test/test_WorkerDebuggerGlobalScope.createSandbox.xul new file mode 100644 index 000000000..0440c482b --- /dev/null +++ b/dom/workers/test/test_WorkerDebuggerGlobalScope.createSandbox.xul @@ -0,0 +1,52 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerGlobalScope.createSandbox" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebuggerGlobalScope.createSandbox_worker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebuggerGlobalScope.createSandbox_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker, wait for its debugger to be registered, and " + + "initialize it."); + let promise = waitForRegister(WORKER_URL, DEBUGGER_URL); + let worker = new Worker(WORKER_URL); + let dbg = yield promise; + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to send a response from within a sandbox."); + promise = waitForDebuggerMessage(dbg, "pong"); + dbg.postMessage("ping"); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> + diff --git a/dom/workers/test/test_WorkerDebuggerGlobalScope.enterEventLoop.xul b/dom/workers/test/test_WorkerDebuggerGlobalScope.enterEventLoop.xul new file mode 100644 index 000000000..081395308 --- /dev/null +++ b/dom/workers/test/test_WorkerDebuggerGlobalScope.enterEventLoop.xul @@ -0,0 +1,126 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerGlobalScope.enterEventLoop" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebuggerGlobalScope.enterEventLoop_worker.js"; + const CHILD_WORKER_URL = "WorkerDebuggerGlobalScope.enterEventLoop_childWorker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebuggerGlobalScope.enterEventLoop_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker that creates a child worker, wait for their " + + "debuggers to be registered, and initialize them."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL, DEBUGGER_URL), + waitForRegister(CHILD_WORKER_URL, DEBUGGER_URL) + ]); + let worker = new Worker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + info("Send a request to the child worker. This should cause the " + + "child worker debugger to enter a nested event loop."); + promise = waitForDebuggerMessage(childDbg, "paused"); + worker.postMessage("child:ping"); + yield promise; + + info("Send a request to the child worker debugger. This should cause " + + "the child worker debugger to enter a second nested event loop."); + promise = waitForDebuggerMessage(childDbg, "paused"); + childDbg.postMessage("eval"); + yield promise; + + info("Send a request to the child worker debugger. This should cause " + + "the child worker debugger to leave its second nested event " + + "loop. The child worker debugger should not send a response " + + "for its previous request until after it has left the nested " + + "event loop."); + promise = waitForMultiple([ + waitForDebuggerMessage(childDbg, "resumed"), + waitForDebuggerMessage(childDbg, "evalled") + ]); + childDbg.postMessage("resume"); + yield promise; + + info("Send a request to the child worker debugger. This should cause " + + "the child worker debugger to leave its first nested event loop." + + "The child worker should not send a response for its earlier " + + "request until after the child worker debugger has left the " + + "nested event loop."); + promise = waitForMultiple([ + waitForDebuggerMessage(childDbg, "resumed"), + waitForWorkerMessage(worker, "child:pong") + ]); + childDbg.postMessage("resume"); + yield promise; + + info("Send a request to the worker. This should cause the worker " + + "debugger to enter a nested event loop."); + promise = waitForDebuggerMessage(dbg, "paused"); + worker.postMessage("ping"); + yield promise; + + info("Terminate the worker. This should not cause the worker " + + "debugger to terminate as well."); + worker.terminate(); + + worker.onmessage = function () { + ok(false, "Worker should have been terminated."); + }; + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to enter a second nested event loop."); + promise = waitForDebuggerMessage(dbg, "paused"); + dbg.postMessage("eval"); + yield promise; + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to leave its second nested event loop. The " + + "worker debugger should not send a response for the previous " + + "request until after leaving the nested event loop."); + promise = waitForMultiple([ + waitForDebuggerMessage(dbg, "resumed"), + waitForDebuggerMessage(dbg, "evalled") + ]); + dbg.postMessage("resume"); + yield promise; + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to leave its first nested event loop. The " + + "worker should not send a response for its earlier request, " + + "since it has been terminated."); + promise = waitForMultiple([ + waitForDebuggerMessage(dbg, "resumed"), + ]); + dbg.postMessage("resume"); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebuggerGlobalScope.reportError.xul b/dom/workers/test/test_WorkerDebuggerGlobalScope.reportError.xul new file mode 100644 index 000000000..88b078674 --- /dev/null +++ b/dom/workers/test/test_WorkerDebuggerGlobalScope.reportError.xul @@ -0,0 +1,98 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerGlobalScope.reportError" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebuggerGlobalScope.reportError_worker.js"; + const CHILD_WORKER_URL = "WorkerDebuggerGlobalScope.reportError_childWorker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebuggerGlobalScope.reportError_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker that creates a child worker, wait for their " + + "debuggers to be registered, and initialize them."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL, DEBUGGER_URL), + waitForRegister(CHILD_WORKER_URL, DEBUGGER_URL) + ]); + let worker = new Worker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + worker.onmessage = function () { + ok(false, "Debugger error events should not be fired at workers."); + }; + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to report an error."); + promise = waitForDebuggerError(dbg); + dbg.postMessage("report"); + let error = yield promise; + is(error.fileName, DEBUGGER_URL, + "fileName should be name of file from which error is reported."); + is(error.lineNumber, 6, + "lineNumber should be line number from which error is reported."); + is(error.message, "reported", "message should be reported."); + + info("Send a request to the worker debugger. This should cause the " + + "worker debugger to throw an error."); + promise = waitForDebuggerError(dbg); + dbg.postMessage("throw"); + error = yield promise; + is(error.fileName, DEBUGGER_URL, + "fileName should be name of file from which error is thrown"); + is(error.lineNumber, 9, + "lineNumber should be line number from which error is thrown"); + is(error.message, "Error: thrown", "message should be Error: thrown"); + + info("Send a reqeust to the child worker debugger. This should cause " + + "the child worker debugger to report an error."); + promise = waitForDebuggerError(childDbg); + childDbg.postMessage("report"); + error = yield promise; + is(error.fileName, DEBUGGER_URL, + "fileName should be name of file from which error is reported."); + is(error.lineNumber, 6, + "lineNumber should be line number from which error is reported."); + is(error.message, "reported", "message should be reported."); + + info("Send a message to the child worker debugger. This should cause " + + "the child worker debugger to throw an error."); + promise = waitForDebuggerError(childDbg); + childDbg.postMessage("throw"); + error = yield promise; + is(error.fileName, DEBUGGER_URL, + "fileName should be name of file from which error is thrown"); + is(error.lineNumber, 9, + "lineNumber should be line number from which error is thrown"); + is(error.message, "Error: thrown", "message should be Error: thrown"); + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> + diff --git a/dom/workers/test/test_WorkerDebuggerGlobalScope.setImmediate.xul b/dom/workers/test/test_WorkerDebuggerGlobalScope.setImmediate.xul new file mode 100644 index 000000000..3ecac681b --- /dev/null +++ b/dom/workers/test/test_WorkerDebuggerGlobalScope.setImmediate.xul @@ -0,0 +1,54 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerGlobalScope.setImmediate" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebuggerGlobalScope.setImmediate_worker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebuggerGlobalScope.setImmediate_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + let promise = waitForRegister(WORKER_URL, DEBUGGER_URL); + let worker = new Worker(WORKER_URL); + let dbg = yield promise; + + info("Send a request to the worker debugger. This should cause a " + + "the worker debugger to send two responses. The worker debugger " + + "should send the second response before the first one, since " + + "the latter is delayed until the next tick of the event loop."); + promise = waitForMultiple([ + waitForDebuggerMessage(dbg, "pong2"), + waitForDebuggerMessage(dbg, "pong1") + ]); + dbg.postMessage("ping"); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebuggerManager.xul b/dom/workers/test/test_WorkerDebuggerManager.xul new file mode 100644 index 000000000..6807226bd --- /dev/null +++ b/dom/workers/test/test_WorkerDebuggerManager.xul @@ -0,0 +1,106 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerManager" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebuggerManager_worker.js"; + const CHILD_WORKER_URL = "WorkerDebuggerManager_childWorker.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Check that worker debuggers are not enumerated before they are " + + "registered."); + ok(!findDebugger(WORKER_URL), + "Worker debugger should not be enumerated before it is registered."); + ok(!findDebugger(CHILD_WORKER_URL), + "Child worker debugger should not be enumerated before it is " + + "registered."); + + info("Create a worker that creates a child worker, and wait for " + + "their debuggers to be registered."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL), + waitForRegister(CHILD_WORKER_URL) + ]); + let worker = new Worker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + info("Check that worker debuggers are enumerated after they are " + + "registered."); + ok(findDebugger(WORKER_URL), + "Worker debugger should be enumerated after it is registered."); + ok(findDebugger(CHILD_WORKER_URL), + "Child worker debugger should be enumerated after it is " + + "registered."); + + info("Check that worker debuggers are not closed before they are " + + "unregistered."); + is(dbg.isClosed, false, + "Worker debugger should not be closed before it is unregistered."); + is(childDbg.isClosed, false, + "Child worker debugger should not be closed before it is " + + "unregistered"); + + info("Terminate the worker and the child worker, and wait for their " + + "debuggers to be unregistered."); + promise = waitForMultiple([ + waitForUnregister(CHILD_WORKER_URL), + waitForUnregister(WORKER_URL), + ]); + worker.terminate(); + yield promise; + + info("Check that worker debuggers are not enumerated after they are " + + "unregistered."); + ok(!findDebugger(WORKER_URL), + "Worker debugger should not be enumerated after it is " + + "unregistered."); + ok(!findDebugger(CHILD_WORKER_URL), + "Child worker debugger should not be enumerated after it is " + + "unregistered."); + + info("Check that worker debuggers are closed after they are " + + "unregistered."); + is(dbg.isClosed, true, + "Worker debugger should be closed after it is unregistered."); + is(childDbg.isClosed, true, + "Child worker debugger should be closed after it is unregistered."); + + info("Check that property accesses on worker debuggers throws " + + "after they are closed."); + assertThrows(() => dbg.url, + "Property accesses on worker debugger should throw " + + "after it is closed."); + assertThrows(() => childDbg.url, + "Property accesses on child worker debugger should " + + "throw after it is closed."); + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger_console.xul b/dom/workers/test/test_WorkerDebugger_console.xul new file mode 100644 index 000000000..0852002ea --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger_console.xul @@ -0,0 +1,97 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebuggerGlobalScope.console methods" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger.console_worker.js"; + const CHILD_WORKER_URL = "WorkerDebugger.console_childWorker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebugger.console_debugger.js"; + + consoleMessagesReceived = 0; + function test() { + function consoleListener() { + SpecialPowers.addObserver(this, "console-api-log-event", false); + } + + consoleListener.prototype = { + observe: function(aSubject, aTopic, aData) { + if (aTopic == "console-api-log-event") { + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] == "Hello from the debugger script!" && + !consoleMessagesReceived) { + consoleMessagesReceived++; + ok(true, "Something has been received"); + SpecialPowers.removeObserver(this, "console-api-log-event"); + } + } + } + } + + var cl = new consoleListener(); + + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker that creates a child worker, wait for their " + + "debuggers to be registered, and initialize them."); + let promise = waitForMultiple([ + waitForRegister(WORKER_URL, DEBUGGER_URL), + waitForRegister(CHILD_WORKER_URL, DEBUGGER_URL) + ]); + let worker = new Worker(WORKER_URL); + let [dbg, childDbg] = yield promise; + + info("Send a request to the worker debugger. This should cause the " + + "the worker debugger to send a response."); + dbg.addListener({ + onMessage: function(msg) { + try { + msg = JSON.parse(msg); + } catch(e) { + ok(false, "Something went wrong"); + return; + } + + if (msg.type == 'finish') { + ok(consoleMessagesReceived, "We received something via debugger console!"); + dbg.removeListener(this); + SimpleTest.finish(); + return; + } + + if (msg.type == 'status') { + ok(msg.what, msg.msg); + return; + } + + ok(false, "Something went wrong"); + } + }); + + dbg.postMessage("do magic"); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger_frozen.xul b/dom/workers/test/test_WorkerDebugger_frozen.xul new file mode 100644 index 000000000..6b22e7702 --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger_frozen.xul @@ -0,0 +1,90 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger with frozen workers" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const CACHE_SUBFRAMES = "browser.sessionhistory.cache_subframes"; + const MAX_TOTAL_VIEWERS = "browser.sessionhistory.max_total_viewers"; + + const IFRAME1_URL = "WorkerDebugger_frozen_iframe1.html"; + const IFRAME2_URL = "WorkerDebugger_frozen_iframe2.html"; + + const WORKER1_URL = "WorkerDebugger_frozen_worker1.js"; + const WORKER2_URL = "WorkerDebugger_frozen_worker2.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + var oldMaxTotalViewers = SpecialPowers.getIntPref(MAX_TOTAL_VIEWERS); + + SpecialPowers.setBoolPref(CACHE_SUBFRAMES, true); + SpecialPowers.setIntPref(MAX_TOTAL_VIEWERS, 10); + + let iframe = $("iframe"); + + let promise = waitForMultiple([ + waitForRegister(WORKER1_URL), + waitForWindowMessage(window, "ready"), + ]); + iframe.src = IFRAME1_URL; + let [dbg1] = yield promise; + is(dbg1.isClosed, false, + "debugger for worker on page 1 should not be closed"); + + promise = waitForMultiple([ + waitForUnregister(WORKER1_URL), + waitForDebuggerClose(dbg1), + waitForRegister(WORKER2_URL), + waitForWindowMessage(window, "ready"), + ]); + iframe.src = IFRAME2_URL; + let [,, dbg2] = yield promise; + is(dbg1.isClosed, true, + "debugger for worker on page 1 should be closed"); + is(dbg2.isClosed, false, + "debugger for worker on page 2 should not be closed"); + + promise = Promise.all([ + waitForUnregister(WORKER2_URL), + waitForDebuggerClose(dbg2), + waitForRegister(WORKER1_URL) + ]); + iframe.contentWindow.history.back(); + [,, dbg1] = yield promise; + is(dbg1.isClosed, false, + "debugger for worker on page 1 should not be closed"); + is(dbg2.isClosed, true, + "debugger for worker on page 2 should be closed"); + + SpecialPowers.clearUserPref(CACHE_SUBFRAMES); + SpecialPowers.setIntPref(MAX_TOTAL_VIEWERS, oldMaxTotalViewers); + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + <iframe id="iframe"></iframe> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger_promise.xul b/dom/workers/test/test_WorkerDebugger_promise.xul new file mode 100644 index 000000000..24ed07133 --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger_promise.xul @@ -0,0 +1,70 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. ++ http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger with DOM Promises" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger_promise_worker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebugger_promise_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + let promise = waitForRegister(WORKER_URL, DEBUGGER_URL); + let worker = new Worker(WORKER_URL); + let dbg = yield promise; + + info("Send a request to the worker. This should cause the worker " + + "to send a response."); + promise = waitForWorkerMessage(worker, "resolved"); + worker.postMessage("resolve"); + yield promise; + + info("Send a request to the debugger. This should cause the debugger " + + "to send a response."); + promise = waitForDebuggerMessage(dbg, "resolved"); + dbg.postMessage("resolve"); + yield promise; + + info("Send a request to the worker. This should cause the debugger " + + "to enter a nested event loop."); + promise = waitForDebuggerMessage(dbg, "paused"); + worker.postMessage("pause"); + yield promise; + + info("Send a request to the debugger. This should cause the debugger " + + "to leave the nested event loop."); + promise = waitForMultiple([ + waitForDebuggerMessage(dbg, "resumed"), + waitForWorkerMessage(worker, "resumed") + ]); + dbg.postMessage("resume"); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_WorkerDebugger_suspended.xul b/dom/workers/test/test_WorkerDebugger_suspended.xul new file mode 100644 index 000000000..0ed8bb71a --- /dev/null +++ b/dom/workers/test/test_WorkerDebugger_suspended.xul @@ -0,0 +1,75 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Test for WorkerDebugger with suspended workers" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + const WORKER_URL = "WorkerDebugger_suspended_worker.js"; + const DEBUGGER_URL = BASE_URL + "WorkerDebugger_suspended_debugger.js"; + + function test() { + Task.spawn(function* () { + SimpleTest.waitForExplicitFinish(); + + info("Create a worker, wait for its debugger to be registered, and " + + "initialize it."); + let promise = waitForRegister(WORKER_URL, DEBUGGER_URL); + let worker = new Worker(WORKER_URL); + let dbg = yield promise; + + info("Send a request to the worker. This should cause both the " + + "worker and the worker debugger to send a response."); + promise = waitForMultiple([ + waitForWorkerMessage(worker, "worker"), + waitForDebuggerMessage(dbg, "debugger") + ]); + worker.postMessage("ping"); + yield promise; + + info("Suspend the workers for this window, and send another request " + + "to the worker. This should cause only the worker debugger to " + + "send a response."); + let windowUtils = window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindowUtils); + windowUtils.suspendTimeouts(); + function onmessage() { + ok(false, "The worker should not send a response."); + }; + worker.addEventListener("message", onmessage); + promise = waitForDebuggerMessage(dbg, "debugger"); + worker.postMessage("ping"); + yield promise; + worker.removeEventListener("message", onmessage); + + info("Resume the workers for this window. This should cause the " + + "worker to send a response to the previous request."); + promise = waitForWorkerMessage(worker, "worker"); + windowUtils.resumeTimeouts(); + yield promise; + + SimpleTest.finish(); + }); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_atob.html b/dom/workers/test/test_atob.html new file mode 100644 index 000000000..99419174c --- /dev/null +++ b/dom/workers/test/test_atob.html @@ -0,0 +1,57 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"> +<script src="atob_worker.js" language="javascript"></script> +<script class="testbody" type="text/javascript"> + + var dataIndex = 0; + + var worker = new Worker("atob_worker.js"); + worker.onmessage = function(event) { + switch (event.data.type) { + case "done": + is(dataIndex, data.length, "Saw all values"); + SimpleTest.finish(); + return; + case "btoa": + is(btoa(data[dataIndex]), event.data.value, + "Good btoa value " + dataIndex); + break; + case "atob": + is(atob(btoa(data[dataIndex])) + "", event.data.value, + "Good round trip value " + dataIndex); + dataIndex++; + break; + default: + ok(false, "Worker posted a bad message: " + event.message); + worker.terminate(); + SimpleTest.finish(); + } + } + + worker.onerror = function(event) { + ok(false, "Worker threw an error: " + event.message); + worker.terminate(); + SimpleTest.finish(); + } + + worker.postMessage("go"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_blobConstructor.html b/dom/workers/test/test_blobConstructor.html new file mode 100644 index 000000000..e8cfaf19d --- /dev/null +++ b/dom/workers/test/test_blobConstructor.html @@ -0,0 +1,60 @@ +<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE html>
+<html>
+<!--
+Tests of DOM Worker Blob constructor
+-->
+<head>
+ <title>Test for DOM Worker Blob constructor</title>
+ <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+(function() {
+ onerror = function(e) {
+ ok(false, "Main Thread had an error: " + event.data);
+ SimpleTest.finish();
+ };
+ function f() {
+ onmessage = function(e) {
+ var b = new Blob([e.data, "World"],{type: "text/plain"});
+ var fr = new FileReaderSync();
+ postMessage({text: fr.readAsText(b), type: b.type});
+ };
+ }
+ var b = new Blob([f,"f();"]);
+ var u = URL.createObjectURL(b);
+ var w = new Worker(u);
+ w.onmessage = function(e) {
+ URL.revokeObjectURL(u);
+ is(e.data.text, fr.result);
+ is(e.data.type, "text/plain");
+ SimpleTest.finish();
+ };
+ w.onerror = function(e) {
+ is(e.target, w);
+ ok(false, "Worker had an error: " + e.message);
+ SimpleTest.finish();
+ };
+
+ b = new Blob(["Hello, "]);
+ var fr = new FileReader();
+ fr.readAsText(new Blob([b, "World"],{}));
+ fr.onload = function() {
+ w.postMessage(b);
+ };
+ SimpleTest.waitForExplicitFinish();
+})();
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/workers/test/test_blobWorkers.html b/dom/workers/test/test_blobWorkers.html new file mode 100644 index 000000000..6e2a83f53 --- /dev/null +++ b/dom/workers/test/test_blobWorkers.html @@ -0,0 +1,32 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="text/javascript"> + const message = "hi"; + + const workerScript = + "onmessage = function(event) {" + + " postMessage(event.data);" + + "};"; + + var worker = new Worker(URL.createObjectURL(new Blob([workerScript]))); + worker.onmessage = function(event) { + is(event.data, message, "Got correct message"); + SimpleTest.finish(); + }; + worker.postMessage(message); + + SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> + diff --git a/dom/workers/test/test_bug1002702.html b/dom/workers/test/test_bug1002702.html new file mode 100644 index 000000000..3db6d2580 --- /dev/null +++ b/dom/workers/test/test_bug1002702.html @@ -0,0 +1,27 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 1002702</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + +var port = new SharedWorker('data:application/javascript,1').port; +port.close(); +SpecialPowers.forceGC(); +ok(true, "No crash \\o/"); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_bug1010784.html b/dom/workers/test/test_bug1010784.html new file mode 100644 index 000000000..f746f35e6 --- /dev/null +++ b/dom/workers/test/test_bug1010784.html @@ -0,0 +1,35 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1010784 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1010784</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1010784">Mozilla Bug 1010784</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"> + + var worker = new Worker("file_bug1010784_worker.js"); + + worker.onmessage = function(event) { + is(event.data, "done", "Got correct result"); + SimpleTest.finish(); + } + + worker.postMessage("testXHR.txt"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1014466.html b/dom/workers/test/test_bug1014466.html new file mode 100644 index 000000000..59f5a6185 --- /dev/null +++ b/dom/workers/test/test_bug1014466.html @@ -0,0 +1,42 @@ +<!-- +2 Any copyright is dedicated to the Public Domain. +3 http://creativecommons.org/publicdomain/zero/1.0/ +4 --> +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1014466 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1014466</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1014466">Mozilla Bug 1014466</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"> + + var worker = new Worker("bug1014466_worker.js"); + + worker.onmessage = function(event) { + if (event.data.type == 'finish') { + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } + }; + + worker.postMessage(true); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1020226.html b/dom/workers/test/test_bug1020226.html new file mode 100644 index 000000000..b6db2aeb4 --- /dev/null +++ b/dom/workers/test/test_bug1020226.html @@ -0,0 +1,38 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1020226 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1020226</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1020226">Mozilla Bug 1020226</a> +<p id="display"></p> +<div id="content" style="display: none"> + +<iframe id="iframe" src="bug1020226_frame.html" onload="finishTest();"> +</iframe> +</div> +<pre id="test"> +<script type="application/javascript"> +function finishTest() { + document.getElementById("iframe").onload = null; + window.onmessage = function(e) { + info("Got message"); + document.getElementById("iframe").src = "about:blank"; + // We aren't really interested in the test, it shouldn't crash when the + // worker is GCed later. + ok(true, "Should not crash"); + SimpleTest.finish(); + }; +} + +SimpleTest.waitForExplicitFinish(); +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1036484.html b/dom/workers/test/test_bug1036484.html new file mode 100644 index 000000000..17b9d490f --- /dev/null +++ b/dom/workers/test/test_bug1036484.html @@ -0,0 +1,54 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads: bug 1036484 +--> +<head> + <title>Test for DOM Worker Threads: bug 1036484</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> + +function test(script) { + var worker = new Worker(script); + + worker.onmessage = function(event) { + ok(false, "Shouldn't ever get a message!"); + } + + worker.onerror = function(event) { + is(event.target, worker); + ok(event.message.startsWith("NetworkError: Failed to load worker script")) + event.preventDefault(); + runTests(); + }; + + worker.postMessage("dummy"); +} + +var tests = [ '404_server.sjs', '404_server.sjs?js' ]; +function runTests() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var script = tests.shift(); + test(script); +} + +SimpleTest.waitForExplicitFinish(); +runTests(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_bug1060621.html b/dom/workers/test/test_bug1060621.html new file mode 100644 index 000000000..758bf996e --- /dev/null +++ b/dom/workers/test/test_bug1060621.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for URLSearchParams object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("bug1060621_worker.js"); + + worker.onmessage = function(event) { + ok(true, "The operation is done. We should not leak."); + SimpleTest.finish(); + }; + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1062920.html b/dom/workers/test/test_bug1062920.html new file mode 100644 index 000000000..31061a2b1 --- /dev/null +++ b/dom/workers/test/test_bug1062920.html @@ -0,0 +1,70 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for navigator property override</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function checkValues() { + var worker = new Worker("bug1062920_worker.js"); + + worker.onmessage = function(event) { + var ifr = document.createElement('IFRAME'); + ifr.src = "about:blank"; + + ifr.addEventListener('load', function() { + var nav = ifr.contentWindow.navigator; + is(event.data.appCodeName, nav.appCodeName, "appCodeName should match"); + is(event.data.appName, nav.appName, "appName should match"); + is(event.data.appVersion, nav.appVersion, "appVersion should match"); + is(event.data.platform, nav.platform, "platform should match"); + is(event.data.userAgent, nav.userAgent, "userAgent should match"); + is(event.data.product, nav.product, "product should match"); + runTests(); + }, false); + + document.getElementById('content').appendChild(ifr); + }; + } + + function replaceAndCheckValues() { + SpecialPowers.pushPrefEnv({"set": [ + ["general.appname.override", "appName overridden"], + ["general.appversion.override", "appVersion overridden"], + ["general.platform.override", "platform overridden"], + ["general.useragent.override", "userAgent overridden"] + ]}, checkValues); + } + + var tests = [ + checkValues, + replaceAndCheckValues + ]; + + function runTests() { + if (tests.length == 0) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + SimpleTest.waitForExplicitFinish(); + runTests(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1062920.xul b/dom/workers/test/test_bug1062920.xul new file mode 100644 index 000000000..635c1b9f9 --- /dev/null +++ b/dom/workers/test/test_bug1062920.xul @@ -0,0 +1,69 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + + function checkValues() { + var worker = new Worker("bug1062920_worker.js"); + + worker.onmessage = function(event) { + is(event.data.appCodeName, navigator.appCodeName, "appCodeName should match"); + is(event.data.appName, navigator.appName, "appName should match"); + isnot(event.data.appName, "appName overridden", "appName is not overridden"); + is(event.data.appVersion, navigator.appVersion, "appVersion should match"); + isnot(event.data.appVersion, "appVersion overridden", "appVersion is not overridden"); + is(event.data.platform, navigator.platform, "platform should match"); + isnot(event.data.platform, "platform overridden", "platform is not overridden"); + is(event.data.userAgent, navigator.userAgent, "userAgent should match"); + is(event.data.product, navigator.product, "product should match"); + runTests(); + }; + } + + function replaceAndCheckValues() { + SpecialPowers.pushPrefEnv({"set": [ + ["general.appname.override", "appName overridden"], + ["general.appversion.override", "appVersion overridden"], + ["general.platform.override", "platform overridden"], + ["general.useragent.override", "userAgent overridden"] + ]}, checkValues); + } + + var tests = [ + replaceAndCheckValues, + checkValues + ]; + + function runTests() { + if (tests.length == 0) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + SimpleTest.waitForExplicitFinish(); + runTests(); + + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_bug1063538.html b/dom/workers/test/test_bug1063538.html new file mode 100644 index 000000000..7c32b8ed3 --- /dev/null +++ b/dom/workers/test/test_bug1063538.html @@ -0,0 +1,49 @@ +<!-- +2 Any copyright is dedicated to the Public Domain. +3 http://creativecommons.org/publicdomain/zero/1.0/ +4 --> +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1063538 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1063538</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1063538">Mozilla Bug 1063538</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"> + +function runTest() { + var worker = new Worker("bug1063538_worker.js"); + + worker.onmessage = function(e) { + if (e.data.type == 'finish') { + ok(e.data.progressFired, "Progress was fired."); + SimpleTest.finish(); + } + }; + + worker.postMessage(true); +} + +SimpleTest.waitForExplicitFinish(); + +addLoadEvent(function() { + SpecialPowers.pushPrefEnv({"set": [["network.jar.block-remote-files", false]]}, function() { + SpecialPowers.pushPermissions([{'type': 'systemXHR', 'allow': true, 'context': document}], runTest); + }); +}); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1104064.html b/dom/workers/test/test_bug1104064.html new file mode 100644 index 000000000..9f83fd007 --- /dev/null +++ b/dom/workers/test/test_bug1104064.html @@ -0,0 +1,28 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 1104064</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script class="testbody" type="text/javascript"> + +var worker = new Worker("bug1104064_worker.js"); +worker.onmessage = function() { + ok(true, "setInterval has been called twice."); + SimpleTest.finish(); +} +worker.postMessage("go"); + +SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_bug1132395.html b/dom/workers/test/test_bug1132395.html new file mode 100644 index 000000000..30ca9b0ae --- /dev/null +++ b/dom/workers/test/test_bug1132395.html @@ -0,0 +1,40 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for 1132395</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + +<script class="testbody" type="text/javascript"> + +// This test is full of dummy debug messages. This is because I need to follow +// an hard-to-reproduce timeout failure. + +info("test started"); +var sw = new SharedWorker('bug1132395_sharedWorker.js'); +sw.port.onmessage = function(event) { + info("sw.onmessage received"); + ok(true, "We didn't crash."); + SimpleTest.finish(); +} + +sw.onerror = function(event) { + ok(false, "Failed to create a ServiceWorker"); + SimpleTest.finish(); +} + +info("sw.postmessage called"); +sw.port.postMessage('go'); + +SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1132924.html b/dom/workers/test/test_bug1132924.html new file mode 100644 index 000000000..8c54813ef --- /dev/null +++ b/dom/workers/test/test_bug1132924.html @@ -0,0 +1,28 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for 1132924</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + +<script class="testbody" type="text/javascript"> + +SimpleTest.waitForExplicitFinish(); +var w = new Worker('bug1132924_worker.js'); +w.onmessage = function(event) { + ok(true, "We are still alive."); + SimpleTest.finish(); +} + +w.postMessage('go'); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug1278777.html b/dom/workers/test/test_bug1278777.html new file mode 100644 index 000000000..a91902d26 --- /dev/null +++ b/dom/workers/test/test_bug1278777.html @@ -0,0 +1,31 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1278777 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1278777</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1278777">Mozilla Bug 1278777</a> + <script type="application/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var worker = new Worker('worker_bug1278777.js'); +worker.onerror = function() { + ok(false, "We should not see any error."); + SimpleTest.finish(); +} + +worker.onmessage = function(e) { + ok(e.data, "Everything seems ok."); + SimpleTest.finish(); +} + + </script> +</body> +</html> diff --git a/dom/workers/test/test_bug1301094.html b/dom/workers/test/test_bug1301094.html new file mode 100644 index 000000000..ea396b32e --- /dev/null +++ b/dom/workers/test/test_bug1301094.html @@ -0,0 +1,69 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1301094 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1301094</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1301094">Mozilla Bug 1301094</a> + <input id="file" type="file"></input> + <script type="application/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var url = SimpleTest.getTestFileURL("script_createFile.js"); +script = SpecialPowers.loadChromeScript(url); + +var mainThreadOk, workerOk; + +function maybeFinish() { + if (mainThreadOk & workerOk) { + SimpleTest.finish(); + } +} + +function onOpened(message) { + var input = document.getElementById('file'); + SpecialPowers.wrap(input).mozSetDndFilesAndDirectories([message.data]); + + var worker = new Worker('worker_bug1301094.js'); + worker.onerror = function() { + ok(false, "We should not see any error."); + SimpleTest.finish(); + } + + worker.onmessage = function(e) { + ok(e.data, "Everything seems OK on the worker-side."); + + workerOk = true; + maybeFinish(); + } + + is(input.files.length, 1, "We have something"); + ok(input.files[0] instanceof Blob, "We have one Blob"); + worker.postMessage(input.files[0]); + + var xhr = new XMLHttpRequest(); + xhr.open("POST", 'worker_bug1301094.js', false); + xhr.onload = function() { + ok(xhr.responseText, "Everything seems OK on the main-thread-side."); + mainThreadOk = true; + maybeFinish(); + }; + + var fd = new FormData(); + fd.append('file', input.files[0]); + xhr.send(fd); +} + +script.addMessageListener("file.opened", onOpened); +script.sendAsyncMessage("file.open"); + + </script> +</body> +</html> diff --git a/dom/workers/test/test_bug1317725.html b/dom/workers/test/test_bug1317725.html new file mode 100644 index 000000000..c23587318 --- /dev/null +++ b/dom/workers/test/test_bug1317725.html @@ -0,0 +1,62 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 1317725</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + +<input type="file" id="file" /> + +<script type="text/js-worker" id="worker-src"> +onmessage = function(e) { + var data = new FormData(); + data.append('Filedata', e.data.slice(0, 127), encodeURI(e.data.name)); + var xhr = new XMLHttpRequest(); + xhr.open('POST', location.href, false); + xhr.send(data); + postMessage("No crash \\o/"); +} +</script> + +<script class="testbody" type="text/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var url = SimpleTest.getTestFileURL("script_createFile.js"); +script = SpecialPowers.loadChromeScript(url); + +function onOpened(message) { + var input = document.getElementById('file'); + SpecialPowers.wrap(input).mozSetFileArray([message.data]); + + var blob = new Blob([ document.getElementById("worker-src").textContent ], + { type: "text/javascript" }); + var worker = new Worker(URL.createObjectURL(blob)); + worker.onerror = function(e) { + ok(false, "We should not see any error."); + SimpleTest.finish(); + } + + worker.onmessage = function(e) { + ok(e.data, "Everything seems OK on the worker-side."); + SimpleTest.finish(); + } + + is(input.files.length, 1, "We have something"); + ok(input.files[0] instanceof Blob, "We have one Blob"); + worker.postMessage(input.files[0]); +} + +script.addMessageListener("file.opened", onOpened); +script.sendAsyncMessage("file.open"); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug949946.html b/dom/workers/test/test_bug949946.html new file mode 100644 index 000000000..547bdbda4 --- /dev/null +++ b/dom/workers/test/test_bug949946.html @@ -0,0 +1,26 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 949946</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + +new SharedWorker('sharedWorker_sharedWorker.js'); +new SharedWorker('sharedWorker_sharedWorker.js', ':'); +new SharedWorker('sharedWorker_sharedWorker.js', '|||'); +ok(true, "3 SharedWorkers created!"); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug978260.html b/dom/workers/test/test_bug978260.html new file mode 100644 index 000000000..49e84c659 --- /dev/null +++ b/dom/workers/test/test_bug978260.html @@ -0,0 +1,35 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + SimpleTest.waitForExplicitFinish(); + + var xhr = new XMLHttpRequest(); + xhr.onload = function () { + var worker = new Worker("bug978260_worker.js"); + worker.onmessage = function(event) { + is(event.data, "loaded"); + SimpleTest.finish(); + } + } + + xhr.open('GET', '/', false); + xhr.send(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_bug998474.html b/dom/workers/test/test_bug998474.html new file mode 100644 index 000000000..892b42ef9 --- /dev/null +++ b/dom/workers/test/test_bug998474.html @@ -0,0 +1,40 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 998474</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body onload="boom();"> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + +function boom() +{ + var worker = new SharedWorker("bug998474_worker.js"); + + setTimeout(function() { + port = worker.port; + port.postMessage(""); + + setTimeout(function() { + port.start(); + ok(true, "Still alive!"); + SimpleTest.finish(); + }, 150); + }, 150); +} + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestFlakyTimeout("untriaged"); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_chromeWorker.html b/dom/workers/test/test_chromeWorker.html new file mode 100644 index 000000000..644593949 --- /dev/null +++ b/dom/workers/test/test_chromeWorker.html @@ -0,0 +1,27 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + try { + var worker = new ChromeWorker("simpleThread_worker.js"); + ok(false, "ChromeWorker constructor should be blocked!"); + } + catch (e) { + ok(true, "ChromeWorker constructor wasn't blocked!"); + } + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_chromeWorker.xul b/dom/workers/test/test_chromeWorker.xul new file mode 100644 index 000000000..35df768be --- /dev/null +++ b/dom/workers/test/test_chromeWorker.xul @@ -0,0 +1,45 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + function test() + { + waitForWorkerFinish(); + + var worker = new ChromeWorker("chromeWorker_worker.js"); + worker.onmessage = function(event) { + is(event.data, "Done!", "Wrong message!"); + finish(); + } + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + worker.terminate(); + finish(); + } + worker.postMessage("go"); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_chromeWorkerJSM.xul b/dom/workers/test/test_chromeWorkerJSM.xul new file mode 100644 index 000000000..01a88bc2a --- /dev/null +++ b/dom/workers/test/test_chromeWorkerJSM.xul @@ -0,0 +1,56 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + function test() + { + waitForWorkerFinish(); + + var worker; + + function done() + { + worker = null; + finish(); + } + + function messageCallback(event) { + is(event.data, "Done", "Correct message"); + done(); + } + + function errorCallback(event) { + ok(false, "Worker had an error: " + event.message); + done(); + } + + Components.utils.import("chrome://mochitests/content/chrome/dom/workers/test/WorkerTest.jsm"); + + worker = WorkerTest.go(window.location.href, messageCallback, + errorCallback); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_clearTimeouts.html b/dom/workers/test/test_clearTimeouts.html new file mode 100644 index 000000000..d9bc6a9f9 --- /dev/null +++ b/dom/workers/test/test_clearTimeouts.html @@ -0,0 +1,31 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + new Worker("clearTimeouts_worker.js").onmessage = function(event) { + event.target.terminate(); + + is(event.data, "ready", "Correct message"); + setTimeout(function() { SimpleTest.finish(); }, 1000); + } + + SimpleTest.waitForExplicitFinish(); + SimpleTest.requestFlakyTimeout("untriaged"); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_console.html b/dom/workers/test/test_console.html new file mode 100644 index 000000000..af82a7de0 --- /dev/null +++ b/dom/workers/test/test_console.html @@ -0,0 +1,44 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Console +--> +<head> + <title>Test for DOM Worker Console</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + var worker = new Worker("console_worker.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "Worker and target match!"); + ok(event.data.status, event.data.event); + + if (!event.data.status || event.data.last) + SimpleTest.finish(); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + worker.postMessage(true); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_consoleAndBlobs.html b/dom/workers/test/test_consoleAndBlobs.html new file mode 100644 index 000000000..e765500fa --- /dev/null +++ b/dom/workers/test/test_consoleAndBlobs.html @@ -0,0 +1,43 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for console API and blobs</title> + <script src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> + </head> + <body> + <script type="text/javascript"> + + function consoleListener() { + SpecialPowers.addObserver(this, "console-api-log-event", false); + } + + var order = 0; + consoleListener.prototype = { + observe: function(aSubject, aTopic, aData) { + ok(true, "Something has been received"); + is(aTopic, "console-api-log-event"); + + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] && obj.arguments[0].msg === 'consoleAndBlobs') { + SpecialPowers.removeObserver(this, "console-api-log-event"); + is(obj.arguments[0].blob.size, 3, "The size is correct"); + is(obj.arguments[0].blob.type, 'foo/bar', "The type is correct"); + SimpleTest.finish(); + } + } + } + + var cl = new consoleListener(); + + new Worker('worker_consoleAndBlobs.js'); + SimpleTest.waitForExplicitFinish(); + + </script> + </body> +</html> diff --git a/dom/workers/test/test_consoleReplaceable.html b/dom/workers/test/test_consoleReplaceable.html new file mode 100644 index 000000000..3886b679d --- /dev/null +++ b/dom/workers/test/test_consoleReplaceable.html @@ -0,0 +1,44 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Console +--> +<head> + <title>Test for DOM Worker Console</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + var worker = new Worker("consoleReplaceable_worker.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "Worker and target match!"); + ok(event.data.status, event.data.event); + + if (event.data.last) + SimpleTest.finish(); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + worker.postMessage(true); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_consoleSharedWorkers.html b/dom/workers/test/test_consoleSharedWorkers.html new file mode 100644 index 000000000..74e1ec742 --- /dev/null +++ b/dom/workers/test/test_consoleSharedWorkers.html @@ -0,0 +1,56 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for console API in SharedWorker</title> + <script src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> + </head> + <body> + <script type="text/javascript"> + + function consoleListener() { + SpecialPowers.addObserver(this, "console-api-log-event", false); + SpecialPowers.addObserver(this, "console-api-profiler", false); + } + + var order = 0; + consoleListener.prototype = { + observe: function(aSubject, aTopic, aData) { + ok(true, "Something has been received"); + + if (aTopic == "console-api-profiler") { + var obj = aSubject.wrappedJSObject; + is (obj.arguments[0], "Hello profiling from a SharedWorker!", "A message from a SharedWorker \\o/"); + is (order++, 0, "First a profiler message."); + + SpecialPowers.removeObserver(this, "console-api-profiler"); + return; + } + + if (aTopic == "console-api-log-event") { + var obj = aSubject.wrappedJSObject; + is (obj.arguments[0], "Hello world from a SharedWorker!", "A message from a SharedWorker \\o/"); + is (obj.ID, "http://mochi.test:8888/tests/dom/workers/test/sharedWorker_console.js", "The ID is SharedWorker"); + is (obj.innerID, "SharedWorker", "The ID is SharedWorker"); + is (order++, 1, "Then a log message."); + + SpecialPowers.removeObserver(this, "console-api-log-event"); + SimpleTest.finish(); + return; + } + } + } + + var cl = new consoleListener(); + new SharedWorker('sharedWorker_console.js'); + + SimpleTest.waitForExplicitFinish(); + + </script> + </body> +</html> diff --git a/dom/workers/test/test_contentWorker.html b/dom/workers/test/test_contentWorker.html new file mode 100644 index 000000000..e745ca4a0 --- /dev/null +++ b/dom/workers/test/test_contentWorker.html @@ -0,0 +1,48 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for DOM Worker privileged properties</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var workerFilename = "content_worker.js"; + var worker = new Worker(workerFilename); + + var props = { + 'ctypes': 1, + 'OS': 1 + }; + + worker.onmessage = function(event) { + if (event.data.testfinished) { + SimpleTest.finish(); + return; + } + var prop = event.data.prop; + ok(prop in props, "checking " + prop); + is(event.data.value, undefined, prop + " should be undefined"); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_csp.html b/dom/workers/test/test_csp.html new file mode 100644 index 000000000..a24217f04 --- /dev/null +++ b/dom/workers/test/test_csp.html @@ -0,0 +1,18 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for DOM Worker + CSP</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +</body> +<script type="text/javascript" src="test_csp.js"></script> +</html> diff --git a/dom/workers/test/test_csp.html^headers^ b/dom/workers/test/test_csp.html^headers^ new file mode 100644 index 000000000..1c9321079 --- /dev/null +++ b/dom/workers/test/test_csp.html^headers^ @@ -0,0 +1,2 @@ +Cache-Control: no-cache +Content-Security-Policy: default-src 'self' blob: diff --git a/dom/workers/test/test_csp.js b/dom/workers/test/test_csp.js new file mode 100644 index 000000000..dcbcd8c3a --- /dev/null +++ b/dom/workers/test/test_csp.js @@ -0,0 +1,48 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var tests = 3; + +SimpleTest.waitForExplicitFinish(); + +testDone = function(event) { + if (!--tests) SimpleTest.finish(); +} + +// Workers don't inherit CSP +worker = new Worker("csp_worker.js"); +worker.postMessage({ do: "eval" }); +worker.onmessage = function(event) { + is(event.data, 42, "Eval succeeded!"); + testDone(); +} + +// blob: workers *do* inherit CSP +xhr = new XMLHttpRequest; +xhr.open("GET", "csp_worker.js"); +xhr.responseType = "blob"; +xhr.send(); +xhr.onload = (e) => { + uri = URL.createObjectURL(e.target.response); + worker = new Worker(uri); + worker.postMessage({ do: "eval" }) + worker.onmessage = function(event) { + is(event.data, "Error: call to eval() blocked by CSP", "Eval threw"); + testDone(); + } +} + +xhr = new XMLHttpRequest; +xhr.open("GET", "csp_worker.js"); +xhr.responseType = "blob"; +xhr.send(); +xhr.onload = (e) => { + uri = URL.createObjectURL(e.target.response); + worker = new Worker(uri); + worker.postMessage({ do: "nest", uri: uri, level: 3 }) + worker.onmessage = function(event) { + is(event.data, "Error: call to eval() blocked by CSP", "Eval threw in nested worker"); + testDone(); + } +} diff --git a/dom/workers/test/test_dataURLWorker.html b/dom/workers/test/test_dataURLWorker.html new file mode 100644 index 000000000..1ff72424f --- /dev/null +++ b/dom/workers/test/test_dataURLWorker.html @@ -0,0 +1,31 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="text/javascript"> + const message = "hi"; + const url = "DATA:text/plain," + + "onmessage = function(event) {" + + " postMessage(event.data);" + + "};"; + + var worker = new Worker(url); + worker.onmessage = function(event) { + is(event.data, message, "Got correct message"); + SimpleTest.finish(); + }; + worker.postMessage(message); + + SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> + diff --git a/dom/workers/test/test_errorPropagation.html b/dom/workers/test/test_errorPropagation.html new file mode 100644 index 000000000..7e1aafe25 --- /dev/null +++ b/dom/workers/test/test_errorPropagation.html @@ -0,0 +1,66 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <meta charset="utf-8"> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <iframe id="workerFrame" src="errorPropagation_iframe.html" + onload="workerFrameLoaded();"></iframe> + <script type="text/javascript"> + const workerCount = 3; + + const errorMessage = "Error: expectedError"; + const errorFilename = "http://mochi.test:8888/tests/dom/workers/test/" + + "errorPropagation_worker.js"; + const errorLineno = 48; + + var workerFrame; + + scopeErrorCount = 0; + workerErrorCount = 0; + windowErrorCount = 0; + + function messageListener(event) { + if (event.type == "scope") { + scopeErrorCount++; + } + else if (event.type == "worker") { + workerErrorCount++; + } + else if (event.type == "window") { + windowErrorCount++; + } + else { + ok(false, "Bad event type: " + event.type); + } + + is(event.data.message, errorMessage, "Correct message event.message"); + is(event.data.filename, errorFilename, + "Correct message event.filename"); + is(event.data.lineno, errorLineno, "Correct message event.lineno"); + + if (windowErrorCount == 1) { + is(scopeErrorCount, workerCount, "Good number of scope errors"); + is(workerErrorCount, workerCount, "Good number of worker errors"); + workerFrame.stop(); + SimpleTest.finish(); + } + } + + function workerFrameLoaded() { + workerFrame = document.getElementById("workerFrame").contentWindow; + workerFrame.start(workerCount, messageListener); + } + + SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> + diff --git a/dom/workers/test/test_errorwarning.html b/dom/workers/test/test_errorwarning.html new file mode 100644 index 000000000..04523c839 --- /dev/null +++ b/dom/workers/test/test_errorwarning.html @@ -0,0 +1,95 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Test javascript.options.strict in Workers +--> +<head> + <title>Test javascript.options.strict in Workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var errors = 0; + function errorHandler(e) { + ok(true, "An error has been received!"); + errors++; + } + + function test_noErrors() { + errors = 0; + + var worker = new Worker('errorwarning_worker.js'); + worker.onerror = errorHandler; + worker.onmessage = function(e) { + if (e.data.type == 'ignore') + return; + + if (e.data.type == 'error') { + errorHandler(); + return; + } + + if (e.data.type == 'finish') { + ok(errors == 0, "Here we are with 0 errors!"); + runTests(); + return; + } + } + + onerror = errorHandler; + worker.postMessage({ loop: 5, errors: false }); + } + + function test_errors() { + errors = 0; + + var worker = new Worker('errorwarning_worker.js'); + worker.onerror = errorHandler; + worker.onmessage = function(e) { + if (e.data.type == 'ignore') + return; + + if (e.data.type == 'error') { + errorHandler(); + return; + } + + if (e.data.type == 'finish') { + ok(errors != 0, "Here we are with errors!"); + runTests(); + return; + } + } + + onerror = errorHandler; + worker.postMessage({ loop: 5, errors: true }); + } + + var tests = [ test_noErrors, test_errors ]; + function runTests() { + var test = tests.shift(); + if (test) { + test(); + } else { + SimpleTest.finish(); + } + } + + runTests(); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_eventDispatch.html b/dom/workers/test/test_eventDispatch.html new file mode 100644 index 000000000..b3c3123f0 --- /dev/null +++ b/dom/workers/test/test_eventDispatch.html @@ -0,0 +1,33 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="text/javascript"> + const message = "Hi"; + + var messageCount = 0; + + var worker = new Worker("eventDispatch_worker.js"); + worker.onmessage = function(event) { + is(event.data, message, "Got correct data."); + if (!messageCount++) { + event.target.postMessage(event.data); + return; + } + SimpleTest.finish(); + } + worker.postMessage(message); + + SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> + diff --git a/dom/workers/test/test_extension.xul b/dom/workers/test/test_extension.xul new file mode 100644 index 000000000..ba68ef03a --- /dev/null +++ b/dom/workers/test/test_extension.xul @@ -0,0 +1,55 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + function test() { + const message = "woohoo"; + + var workertest = + Cc["@mozilla.org/test/workertest;1"].createInstance(Ci.nsIWorkerTest); + + workertest.callback = { + onmessage: function(data) { + is(data, message, "Correct message"); + workertest.callback = null; + workertest = null; + SimpleTest.finish(); + }, + onerror: function(data) { + ok(false, "Worker had an error: " + data.message); + workertest.callback = null; + workertest = null; + SimpleTest.finish(); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIWorkerTestCallback]) + }; + + workertest.postMessage(message); + + SimpleTest.waitForExplicitFinish(); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_extensionBootstrap.xul b/dom/workers/test/test_extensionBootstrap.xul new file mode 100644 index 000000000..18bdde1d3 --- /dev/null +++ b/dom/workers/test/test_extensionBootstrap.xul @@ -0,0 +1,66 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + + function test() { + const message = "woohoo"; + + var observer = { + observe: function(subject, topic, data) { + is(topic, "message", "Correct type of event"); + is(data, message, "Correct message"); + + AddonManager.getAddonByID("workerbootstrap-test@mozilla.org", + function(addon) { + addon.uninstall(); + + const stages = [ "install", "startup", "shutdown", "uninstall" ]; + const symbols = [ "Worker", "ChromeWorker" ]; + + for (var stage of stages) { + for (var symbol of symbols) { + is(Services.prefs.getBoolPref("workertest.bootstrap." + stage + + "." + symbol), + true, + "Symbol '" + symbol + "' present during '" + stage + "'"); + } + } + + SimpleTest.finish(); + }); + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]) + }; + + var workertestbootstrap = Cc["@mozilla.org/test/workertestbootstrap;1"]. + createInstance(Ci.nsIObserver); + + workertestbootstrap.observe(observer, "postMessage", message); + + SimpleTest.waitForExplicitFinish(); + } + + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/test_fibonacci.html b/dom/workers/test/test_fibonacci.html new file mode 100644 index 000000000..d93eb12d4 --- /dev/null +++ b/dom/workers/test/test_fibonacci.html @@ -0,0 +1,52 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads with Fibonacci +--> +<head> + <title>Test for DOM Worker Threads with Fibonacci</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=450452">DOM Worker Threads Fibonacci</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + const seqNum = 5; + + function recursivefib(n) { + return n < 2 ? n : recursivefib(n - 1) + recursivefib(n - 2); + } + + var worker = new Worker("fibonacci_worker.js"); + + worker.onmessage = function(event) { + is(event.target, worker); + is(event.data, recursivefib(seqNum)); + SimpleTest.finish(); + }; + + worker.onerror = function(event) { + is(event.target, worker); + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + }; + + worker.postMessage(seqNum); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_file.xul b/dom/workers/test/test_file.xul new file mode 100644 index 000000000..800e88fbc --- /dev/null +++ b/dom/workers/test/test_file.xul @@ -0,0 +1,97 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=123456 +--> +<window title="Mozilla Bug 123456" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=123456" + target="_blank">Mozilla Bug 123456</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 123456 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data and optionally adds the specified file extension. + */ + function createFileWithData(fileData, /** optional */ extension) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + var fileExtension = (extension == undefined) ? "" : "." + extension; + testFile.append("workerFile" + fileNum++ + fileExtension); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Create a worker to access file properties. + */ + function accessFileProperties(file, expectedSize, expectedType) { + waitForWorkerFinish(); + + var worker = new Worker("file_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + is(event.data.size, expectedSize, "size proproperty accessed from worker is not the same as on main thread."); + is(event.data.type, expectedType, "type proproperty accessed from worker is incorrect."); + is(event.data.name, file.name, "name proproperty accessed from worker is incorrect."); + is(event.data.lastModifiedDate.toString(), file.lastModifiedDate.toString(), "lastModifiedDate proproperty accessed from worker is incorrect."); + finish(); + }; + + worker.postMessage(file); + } + + // Empty file. + accessFileProperties(createFileWithData(""), 0, ""); + + // Typical use case. + accessFileProperties(createFileWithData("Hello"), 5, ""); + + // Longish file. + var text = ""; + for (var i = 0; i < 10000; ++i) { + text += "long"; + } + accessFileProperties(createFileWithData(text), 40000, ""); + + // Type detection based on extension. + accessFileProperties(createFileWithData("text", "txt"), 4, "text/plain"); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileBlobPosting.xul b/dom/workers/test/test_fileBlobPosting.xul new file mode 100644 index 000000000..358054598 --- /dev/null +++ b/dom/workers/test/test_fileBlobPosting.xul @@ -0,0 +1,86 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data. + */ + function createFileWithData(fileData) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + testFile.append("workerBlobPosting" + fileNum++); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Create a worker which posts the same blob given. Used to test cloning of blobs. + * Checks the size, type, name and path of the file posted from the worker to ensure it + * is the same as the original. + */ + function postBlob(file) { + var worker = new Worker("filePosting_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + console.log(event.data); + is(event.data.size, file.size, "size of file posted from worker does not match file posted to worker."); + finish(); + }; + + var blob = file.slice(); + worker.postMessage(blob); + waitForWorkerFinish(); + } + + // Empty file. + postBlob(createFileWithData("")); + + // Typical use case. + postBlob(createFileWithData("Hello")); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileBlobSubWorker.xul b/dom/workers/test/test_fileBlobSubWorker.xul new file mode 100644 index 000000000..6a8dba636 --- /dev/null +++ b/dom/workers/test/test_fileBlobSubWorker.xul @@ -0,0 +1,98 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data and optionally adds the specified file extension. + */ + function createFileWithData(fileData, /** optional */ extension) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + var fileExtension = (extension == undefined) ? "" : "." + extension; + testFile.append("workerBlobSubWorker" + fileNum++ + fileExtension); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Create a worker to access blob properties. + */ + function accessFileProperties(file, expectedSize) { + var worker = new Worker("fileBlobSubWorker_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + if (event.data == undefined) { + ok(false, "Worker had an error."); + } else { + is(event.data.size, expectedSize, "size proproperty accessed from worker is not the same as on main thread."); + } + finish(); + }; + + var blob = file.slice(); + worker.postMessage(blob); + waitForWorkerFinish(); + } + + // Empty file. + accessFileProperties(createFileWithData(""), 0); + + // Typical use case. + accessFileProperties(createFileWithData("Hello"), 5); + + // Longish file. + var text = ""; + for (var i = 0; i < 10000; ++i) { + text += "long"; + } + accessFileProperties(createFileWithData(text), 40000); + + // Type detection based on extension. + accessFileProperties(createFileWithData("text", "txt"), 4); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_filePosting.xul b/dom/workers/test/test_filePosting.xul new file mode 100644 index 000000000..ff8520d7e --- /dev/null +++ b/dom/workers/test/test_filePosting.xul @@ -0,0 +1,86 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data. + */ + function createFileWithData(fileData) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + testFile.append("workerFilePosting" + fileNum++); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Create a worker which posts the same file given. Used to test cloning of files. + * Checks the size, type, name and path of the file posted from the worker to ensure it + * is the same as the original. + */ + function postFile(file) { + var worker = new Worker("file_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + is(event.data.size, file.size, "size of file posted from worker does not match file posted to worker."); + is(event.data.type, file.type, "type of file posted from worker does not match file posted to worker."); + is(event.data.name, file.name, "name of file posted from worker does not match file posted to worker."); + finish(); + }; + + worker.postMessage(file); + waitForWorkerFinish(); + } + + // Empty file. + postFile(createFileWithData("")); + + // Typical use case. + postFile(createFileWithData("Hello")); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileReadSlice.xul b/dom/workers/test/test_fileReadSlice.xul new file mode 100644 index 000000000..da2e16719 --- /dev/null +++ b/dom/workers/test/test_fileReadSlice.xul @@ -0,0 +1,94 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + if (navigator.platform.startsWith("Win")) { + SimpleTest.expectAssertions(0, 1); + } + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data. + */ + function createFileWithData(fileData) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + testFile.append("workerReadSlice" + fileNum++); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Creates a worker which slices a blob to the given start and end offset and + * reads the content as text. + */ + function readSlice(blob, start, end, expectedText) { + var worker = new Worker("fileReadSlice_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + is(event.data, expectedText, "Text from sliced blob in worker is incorrect."); + finish(); + }; + + var params = {blob: blob, start: start, end: end}; + worker.postMessage(params); + waitForWorkerFinish(); + } + + // Empty file. + readSlice(createFileWithData(""), 0, 0, ""); + + // Typical use case. + readSlice(createFileWithData("HelloBye"), 5, 8, "Bye"); + + // End offset too large. + readSlice(createFileWithData("HelloBye"), 5, 9, "Bye"); + + // Start of file. + readSlice(createFileWithData("HelloBye"), 0, 5, "Hello"); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileReader.html b/dom/workers/test/test_fileReader.html new file mode 100644 index 000000000..26e73bdb6 --- /dev/null +++ b/dom/workers/test/test_fileReader.html @@ -0,0 +1,100 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for FileReader in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> + +<body> +<script type="text/javascript;version=1.7"> + +const minFileSize = 20000; +SimpleTest.waitForExplicitFinish(); + +// Create strings containing data we'll test with. We'll want long +// strings to ensure they span multiple buffers while loading +var testTextData = "asd b\tlah\u1234w\u00a0r"; +while (testTextData.length < minFileSize) { + testTextData = testTextData + testTextData; +} + +var testASCIIData = "abcdef 123456\n"; +while (testASCIIData.length < minFileSize) { + testASCIIData = testASCIIData + testASCIIData; +} + +var testBinaryData = ""; +for (var i = 0; i < 256; i++) { + testBinaryData += String.fromCharCode(i); +} +while (testBinaryData.length < minFileSize) { + testBinaryData = testBinaryData + testBinaryData; +} + +var dataurldata0 = testBinaryData.substr(0, testBinaryData.length - + testBinaryData.length % 3); +var dataurldata1 = testBinaryData.substr(0, testBinaryData.length - 2 - + testBinaryData.length % 3); +var dataurldata2 = testBinaryData.substr(0, testBinaryData.length - 1 - + testBinaryData.length % 3); + + +//Set up files for testing +var openerURL = SimpleTest.getTestFileURL("fileapi_chromeScript.js"); +var opener = SpecialPowers.loadChromeScript(openerURL); +opener.addMessageListener("files.opened", onFilesOpened); +opener.sendAsyncMessage("files.open", [ + testASCIIData, + testBinaryData, + null, + convertToUTF8(testTextData), + convertToUTF16(testTextData), + "", + dataurldata0, + dataurldata1, + dataurldata2, +]); + +function onFilesOpened(message) { + var worker = new Worker('worker_fileReader.js'); + worker.postMessage({ blobs: message, + testTextData: testTextData, + testASCIIData: testASCIIData, + testBinaryData: testBinaryData, + dataurldata0: dataurldata0, + dataurldata1: dataurldata1, + dataurldata2: dataurldata2 }); + + worker.onmessage = function(e) { + var msg = e.data; + if (msg.type == 'finish') { + SimpleTest.finish(); + return; + } + + if (msg.type == 'check') { + ok(msg.status, msg.msg); + return; + } + + ok(false, "Unknown message."); + } +} + +function convertToUTF16(s) { + res = ""; + for (var i = 0; i < s.length; ++i) { + c = s.charCodeAt(i); + res += String.fromCharCode(c & 255, c >>> 8); + } + return res; +} + +function convertToUTF8(s) { + return unescape(encodeURIComponent(s)); +} + +</script> +</body> +</html> diff --git a/dom/workers/test/test_fileReaderSync.xul b/dom/workers/test/test_fileReaderSync.xul new file mode 100644 index 000000000..de93c3ed7 --- /dev/null +++ b/dom/workers/test/test_fileReaderSync.xul @@ -0,0 +1,199 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data and optionally adds the specified file extension. + */ + function createFileWithData(fileData, /** optional */ extension) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + var fileExtension = (extension == undefined) ? "" : "." + extension; + testFile.append("workerFileReaderSync" + fileNum++ + fileExtension); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + function convertToUTF16(s) { + res = ""; + for (var i = 0; i < s.length; ++i) { + c = s.charCodeAt(i); + res += String.fromCharCode(c & 255, c >>> 8); + } + return res; + } + + /** + * Converts the given string to a data URL of the specified mime type. + */ + function convertToDataURL(mime, s) { + return "data:" + mime + ";base64," + btoa(s); + } + + /** + * Create a worker to read a file containing fileData using FileReaderSync and + * checks the return type against the expected type. Optionally set an encoding + * for reading the file as text. + */ + function readFileData(fileData, expectedText, /** optional */ encoding) { + var worker = new Worker("fileReaderSync_worker.js"); + + worker.onmessage = function(event) { + is(event.data.text, expectedText, "readAsText in worker returned incorrect result."); + is(event.data.bin, fileData, "readAsBinaryString in worker returned incorrect result."); + is(event.data.url, convertToDataURL("application/octet-stream", fileData), "readAsDataURL in worker returned incorrect result."); + is(event.data.arrayBuffer.byteLength, fileData.length, "readAsArrayBuffer returned buffer of incorrect length."); + finish(); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + var params = {file: createFileWithData(fileData), encoding: encoding}; + + worker.postMessage(params); + + waitForWorkerFinish(); + } + + /** + * Create a worker which reuses a FileReaderSync to read multiple files as DataURLs. + */ + function reuseReaderForURL(files, expected) { + var worker = new Worker("fileReaderSync_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + var k = 0; + worker.onmessage = function(event) { + is(event.data.url, expected[k], "readAsDataURL in worker returned incorrect result when reusing FileReaderSync."); + k++; + finish(); + }; + + for (var i = 0; i < files.length; ++i) { + var params = {file: files[i], encoding: undefined}; + worker.postMessage(params); + waitForWorkerFinish(); + } + } + + /** + * Create a worker which reuses a FileReaderSync to read multiple files as text. + */ + function reuseReaderForText(fileData, expected) { + var worker = new Worker("fileReaderSync_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + var k = 0; + worker.onmessage = function(event) { + is(event.data.text, expected[k++], "readAsText in worker returned incorrect result when reusing FileReaderSync."); + finish(); + }; + + for (var i = 0; i < fileData.length; ++i) { + var params = {file: createFileWithData(fileData[i]), encoding: undefined}; + worker.postMessage(params); + waitForWorkerFinish(); + } + } + + + /** + * Creates a a worker which reads a file containing fileData as an ArrayBuffer. + * Verifies that the ArrayBuffer when interpreted as a string matches the original data. + */ + function readArrayBuffer(fileData) { + var worker = new Worker("fileReaderSync_worker.js"); + + worker.onmessage = function(event) { + var view = new Uint8Array(event.data.arrayBuffer); + is(event.data.arrayBuffer.byteLength, fileData.length, "readAsArrayBuffer returned buffer of incorrect length."); + is(String.fromCharCode.apply(String, view), fileData, "readAsArrayBuffer returned buffer containing incorrect data."); + finish(); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + var params = {file: createFileWithData(fileData), encoding: undefined}; + + worker.postMessage(params); + + waitForWorkerFinish(); + } + + // Empty file. + readFileData("", ""); + + // Typical use case. + readFileData("text", "text"); + + // Test reading UTF-16 characters. + readFileData(convertToUTF16("text"), "text", "UTF-16"); + + // First read a file of type "text/plain", then read a file of type "application/octet-stream". + reuseReaderForURL([createFileWithData("text", "txt"), createFileWithData("text")], + [convertToDataURL("text/plain", "text"), + convertToDataURL("application/octet-stream", "text")]); + + // First read UTF-16 characters marked using BOM, then read UTF-8 characters. + reuseReaderForText([convertToUTF16("\ufefftext"), "text"], + ["text", "text"]); + + // Reading data as ArrayBuffer. + readArrayBuffer(""); + readArrayBuffer("text"); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileReaderSyncErrors.xul b/dom/workers/test/test_fileReaderSyncErrors.xul new file mode 100644 index 000000000..9e416a603 --- /dev/null +++ b/dom/workers/test/test_fileReaderSyncErrors.xul @@ -0,0 +1,84 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data. + */ + function createFileWithData(fileData) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + testFile.append("workerFileReaderSyncErrors" + fileNum++); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Creates a worker which runs errors cases. + */ + function runWorkerErrors(file) { + var worker = new Worker("fileReaderSyncErrors_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + if(event.data == undefined) { + // Worker returns undefined when tests have finished running. + finish(); + } else { + // Otherwise worker will return results of tests to be evaluated. + is(event.data.actual, event.data.expected, event.data.message); + } + }; + + worker.postMessage(file); + waitForWorkerFinish(); + } + + // Run worker which creates exceptions. + runWorkerErrors(createFileWithData("text")); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileSlice.xul b/dom/workers/test/test_fileSlice.xul new file mode 100644 index 000000000..31531da2e --- /dev/null +++ b/dom/workers/test/test_fileSlice.xul @@ -0,0 +1,106 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data and optionally adds the specified file extension. + */ + function createFileWithData(fileData, /** optional */ extension) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + var fileExtension = (extension == undefined) ? "" : "." + extension; + testFile.append("workerSlice" + fileNum++ + fileExtension); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Starts a worker which slices the blob to the given start offset and optional end offset and + * content type. It then verifies that the size and type of the sliced blob is correct. + */ + function createSlice(blob, start, expectedLength, /** optional */ end, /** optional */ contentType) { + var worker = new Worker("fileSlice_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + is(event.data.size, expectedLength, "size property of slice is incorrect."); + is(event.data.type, contentType ? contentType : blob.type, "type property of slice is incorrect."); + finish(); + }; + + var params = {blob: blob, start: start, end: end, contentType: contentType}; + worker.postMessage(params); + waitForWorkerFinish(); + } + + // Empty file. + createSlice(createFileWithData(""), 0, 0, 0); + + // Typical use case. + createSlice(createFileWithData("Hello"), 1, 1, 2); + + // Longish file. + var text = ""; + for (var i = 0; i < 10000; ++i) { + text += "long"; + } + createSlice(createFileWithData(text), 2000, 2000, 4000); + + // Slice to different type. + createSlice(createFileWithData("text", "txt"), 0, 2, 2, "image/png"); + + // Length longer than blob. + createSlice(createFileWithData("text"), 0, 4, 20); + + // Start longer than blob. + createSlice(createFileWithData("text"), 20, 0, 4); + + // No optional arguments + createSlice(createFileWithData("text"), 0, 4); + createSlice(createFileWithData("text"), 2, 2); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_fileSubWorker.xul b/dom/workers/test/test_fileSubWorker.xul new file mode 100644 index 000000000..94b41704a --- /dev/null +++ b/dom/workers/test/test_fileSubWorker.xul @@ -0,0 +1,99 @@ +<?xml version="1.0"?> +<?xml-stylesheet type="text/css" href="chrome://global/skin"?> +<?xml-stylesheet type="text/css" href="/tests/SimpleTest/test.css"?> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=664783 +--> +<window title="Mozilla Bug 664783" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <!-- test results are displayed in the html:body --> + <body xmlns="http://www.w3.org/1999/xhtml"> + <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=664783" + target="_blank">Mozilla Bug 664783</a> + + <div id="content" style="display: none"> + <input id="fileList" type="file"></input> + </div> + + </body> + + <!-- test code goes here --> + <script type="application/javascript"> + <![CDATA[ + + /** Test for Bug 664783 **/ + + var fileNum = 0; + + /** + * Create a file which contains the given data and optionally adds the specified file extension. + */ + function createFileWithData(fileData, /** optional */ extension) { + var testFile = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties) + .get("ProfD", Components.interfaces.nsIFile); + var fileExtension = (extension == undefined) ? "" : "." + extension; + testFile.append("workerSubWorker" + fileNum++ + fileExtension); + + var outStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + outStream.init(testFile, 0x02 | 0x08 | 0x20, // write, create, truncate + 0666, 0); + outStream.write(fileData, fileData.length); + outStream.close(); + + var fileList = document.getElementById('fileList'); + fileList.value = testFile.path; + + return fileList.files[0]; + } + + /** + * Create a worker to access file properties. + */ + function accessFileProperties(file, expectedSize, expectedType) { + var worker = new Worker("fileSubWorker_worker.js"); + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + finish(); + }; + + worker.onmessage = function(event) { + if (event.data == undefined) { + ok(false, "Worker had an error."); + } else { + is(event.data.size, expectedSize, "size proproperty accessed from worker is not the same as on main thread."); + is(event.data.type, expectedType, "type proproperty accessed from worker is incorrect."); + is(event.data.name, file.name, "name proproperty accessed from worker is incorrect."); + } + finish(); + }; + + worker.postMessage(file); + waitForWorkerFinish(); + } + + // Empty file. + accessFileProperties(createFileWithData(""), 0, ""); + + // Typical use case. + accessFileProperties(createFileWithData("Hello"), 5, ""); + + // Longish file. + var text = ""; + for (var i = 0; i < 10000; ++i) { + text += "long"; + } + accessFileProperties(createFileWithData(text), 40000, ""); + + // Type detection based on extension. + accessFileProperties(createFileWithData("text", "txt"), 4, "text/plain"); + + ]]> + </script> +</window> diff --git a/dom/workers/test/test_importScripts.html b/dom/workers/test/test_importScripts.html new file mode 100644 index 000000000..718409ce3 --- /dev/null +++ b/dom/workers/test/test_importScripts.html @@ -0,0 +1,53 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads (Bug 437152) +--> +<head> + <title>Test for DOM Worker Threads (Bug 437152)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=437152">DOM Worker Threads Bug 437152</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("importScripts_worker.js"); + + worker.onmessage = function(event) { + switch (event.data) { + case "started": + worker.postMessage("stop"); + break; + case "stopped": + ok(true, "worker correctly stopped"); + SimpleTest.finish(); + break; + default: + ok(false, "Unexpected message:" + event.data); + SimpleTest.finish(); + } + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error:" + event.message); + SimpleTest.finish(); + } + + worker.postMessage("start"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_importScripts_3rdparty.html b/dom/workers/test/test_importScripts_3rdparty.html new file mode 100644 index 000000000..a3d73c5b5 --- /dev/null +++ b/dom/workers/test/test_importScripts_3rdparty.html @@ -0,0 +1,134 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for 3rd party imported script and muted errors</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script type="text/javascript"> + +const workerURL = 'http://mochi.test:8888/tests/dom/workers/test/importScripts_3rdParty_worker.js'; + +var tests = [ + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onmessage = function(event) { + ok("result" in event.data && event.data.result, "It seems we don't share data!"); + next(); + }; + + worker.postMessage({ url: location.href, test: 'try', nested: false }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onmessage = function(event) { + ok("result" in event.data && event.data.result, "It seems we don't share data in nested workers!"); + next(); + }; + + worker.postMessage({ url: location.href, test: 'try', nested: true }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onmessage = function(event) { + ok("result" in event.data && event.data.result, "It seems we don't share data via eventListener!"); + next(); + }; + + worker.postMessage({ url: location.href, test: 'eventListener', nested: false }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onmessage = function(event) { + ok("result" in event.data && event.data.result, "It seems we don't share data in nested workers via eventListener!"); + next(); + }; + + worker.postMessage({ url: location.href, test: 'eventListener', nested: true }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onmessage = function(event) { + ok("result" in event.data && event.data.result, "It seems we don't share data via onerror!"); + next(); + }; + worker.onerror = function(event) { + event.preventDefault(); + } + + worker.postMessage({ url: location.href, test: 'onerror', nested: false }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onerror = function(event) { + event.preventDefault(); + ok(event instanceof ErrorEvent, "ErrorEvent received."); + is(event.filename, workerURL, "ErrorEvent.filename is correct"); + next(); + }; + + worker.postMessage({ url: location.href, test: 'none', nested: false }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.addEventListener("error", function(event) { + event.preventDefault(); + ok(event instanceof ErrorEvent, "ErrorEvent received."); + is(event.filename, workerURL, "ErrorEvent.filename is correct"); + next(); + }); + + worker.postMessage({ url: location.href, test: 'none', nested: false }); + }, + + function() { + var worker = new Worker("importScripts_3rdParty_worker.js"); + worker.onerror = function(event) { + ok(false, "No error should be received!"); + }; + + worker.onmessage = function(event) { + ok("error" in event.data && event.data.error, "The error has been fully received from a nested worker"); + next(); + }; + worker.postMessage({ url: location.href, test: 'none', nested: true }); + }, + + function() { + var url = URL.createObjectURL(new Blob(["%&%^&%^"])); + var worker = new Worker(url); + worker.onerror = function(event) { + event.preventDefault(); + ok(event instanceof ErrorEvent, "ErrorEvent received."); + next(); + }; + } +]; + +function next() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); +} + +SimpleTest.waitForExplicitFinish(); +next(); + +</script> +</body> +</html> diff --git a/dom/workers/test/test_importScripts_mixedcontent.html b/dom/workers/test/test_importScripts_mixedcontent.html new file mode 100644 index 000000000..0a7ce005c --- /dev/null +++ b/dom/workers/test/test_importScripts_mixedcontent.html @@ -0,0 +1,50 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 1198078 - test that we respect mixed content blocking in importScript() inside workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1198078">DOM Worker Threads Bug 1198078</a> +<iframe></iframe> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + onmessage = function(event) { + switch (event.data.status) { + case "done": + SimpleTest.finish(); + break; + case "ok": + ok(event.data.data, event.data.msg); + break; + default: + ok(false, "Unexpected message:" + event.data); + SimpleTest.finish(); + } + }; + + SimpleTest.waitForExplicitFinish(); + onload = function() { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.workers.sharedWorkers.enabled", true], + ["security.mixed_content.block_active_content", false], + ]}, function() { + var iframe = document.querySelector("iframe"); + iframe.src = "https://example.com/tests/dom/workers/test/importScripts_mixedcontent.html"; + }); + }; + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_instanceof.html b/dom/workers/test/test_instanceof.html new file mode 100644 index 000000000..f73b3b6a7 --- /dev/null +++ b/dom/workers/test/test_instanceof.html @@ -0,0 +1,40 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker JSON messages +--> +<head> + <title>Test for DOM Worker Navigator</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script src="json_worker.js" language="javascript"></script> +<script class="testbody" language="javascript"> + + var worker = new Worker("instanceof_worker.js"); + + worker.onmessage = function(event) { + ok(event.data.status, event.data.event); + + if (event.data.last) + SimpleTest.finish(); + }; + + worker.postMessage(42); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_json.html b/dom/workers/test/test_json.html new file mode 100644 index 000000000..3a495de09 --- /dev/null +++ b/dom/workers/test/test_json.html @@ -0,0 +1,89 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker JSON messages +--> +<head> + <title>Test for DOM Worker Navigator</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script src="json_worker.js" language="javascript"></script> +<script class="testbody" language="javascript"> + + ok(messages.length, "No messages to test!"); + + var worker = new Worker("json_worker.js"); + + var index = 0; + worker.onmessage = function(event) { + var key = messages[index++]; + + // Loop for the ones we shouldn't receive. + while (key.exception) { + key = messages[index++]; + } + + is(typeof event.data, key.type, "Bad type! " + messages.indexOf(key)); + + if (key.array) { + is(event.data instanceof Array, key.array, + "Array mismatch! " + messages.indexOf(key)); + } + + if (key.isNaN) { + ok(isNaN(event.data), "Should be NaN!" + messages.indexOf(key)); + } + + if (key.isInfinity) { + is(event.data, Infinity, "Should be Infinity!" + messages.indexOf(key)); + } + + if (key.isNegativeInfinity) { + is(event.data, -Infinity, "Should be -Infinity!" + messages.indexOf(key)); + } + + if (key.shouldCompare || key.shouldEqual) { + ok(event.data == key.compareValue, + "Values don't compare! " + messages.indexOf(key)); + } + + if (key.shouldEqual) { + ok(event.data === key.compareValue, + "Values don't equal! " + messages.indexOf(key)); + } + + if (key.jsonValue) { + is(JSON.stringify(event.data), key.jsonValue, + "Object stringification inconsistent!" + messages.indexOf(key)); + } + + if (event.data == "testFinished") { + is(index, messages.length, "Didn't see the right number of messages!"); + SimpleTest.finish(); + } + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + worker.postMessage("start"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_jsversion.html b/dom/workers/test/test_jsversion.html new file mode 100644 index 000000000..495b8a3fa --- /dev/null +++ b/dom/workers/test/test_jsversion.html @@ -0,0 +1,68 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for JSVersion in workers - Bug 487070</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var gExpectedError = false; + + onerror = function(evt) { + ok(gExpectedError, "Error expected!"); + runTest(); + } + + function doMagic() { + var worker = new Worker('jsversion_worker.js'); + worker.onmessage = function(evt) { + ok(evt.data, 'All the tests passed'); + runTest(); + } + worker.postMessage(1); + } + + var tests = [ + // No custom version + function() { + gExpectedError = true; + SpecialPowers.pushPrefEnv({"set":[['dom.workers.latestJSVersion', false]]}, + function() { doMagic(true); }); + }, + + // Enable latest JS Version + function() { + gExpectedError = false; + SpecialPowers.pushPrefEnv({"set":[['dom.workers.latestJSVersion', true]]}, + function() { doMagic(false); }); + } + ]; + + function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + SimpleTest.waitForExplicitFinish(); + runTest(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_loadEncoding.html b/dom/workers/test/test_loadEncoding.html new file mode 100644 index 000000000..47e08f2f5 --- /dev/null +++ b/dom/workers/test/test_loadEncoding.html @@ -0,0 +1,50 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Bug 484305 - Load workers as UTF-8</title> + <meta http-equiv="content-type" content="text/html; charset=KOI8-R"> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=484305">Bug 484305 - Load workers as UTF-8</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var canonical = String.fromCharCode(0x41F, 0x440, 0x438, 0x432, 0x435, 0x442); +ok(document.inputEncoding === "KOI8-R", "Document encoding is KOI8-R"); + +// Worker sends two strings, one with `canonical` encoded in KOI8-R and one as UTF-8. +// Since Worker scripts should always be decoded using UTF-8, even if the owning document's charset is different, the UTF-8 decode should match, while KOI8-R should fail. +var counter = 0; +var worker = new Worker("loadEncoding_worker.js"); +worker.onmessage = function(e) { + if (e.data.encoding === "KOI8-R") { + ok(e.data.text !== canonical, "KOI8-R decoded text should not match"); + } else if (e.data.encoding === "UTF-8") { + ok(e.data.text === canonical, "UTF-8 decoded text should match"); + } + counter++; + if (counter === 2) + SimpleTest.finish(); +} + +worker.onerror = function(e) { + ok(false, "Worker error"); + SimpleTest.finish(); +} +</script> + +</pre> +</body> +</html> diff --git a/dom/workers/test/test_loadError.html b/dom/workers/test/test_loadError.html new file mode 100644 index 000000000..dc109b796 --- /dev/null +++ b/dom/workers/test/test_loadError.html @@ -0,0 +1,77 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> +"use strict"; + +var loadErrorMessage = 'SecurityError: Failed to load worker script at "about:blank"'; + +function nextTest() { + (function(){ + function workerfunc() { + var subworker = new Worker("about:blank"); + subworker.onerror = function(e) { + e.preventDefault(); + postMessage(e.message); + } + } + var b = new Blob([workerfunc+'workerfunc();']); + var u = URL.createObjectURL(b); + function callworker(i) { + try { + var w = new Worker(u); + URL.revokeObjectURL(u); + is(i, 0, 'worker creation succeeded'); + } catch (e) { + is(i, 1, 'worker creation failed'); + SimpleTest.finish(); + return; + } + w.onmessage = function(e) { + is(e.data, loadErrorMessage, + "Should catch the error when loading inner script"); + if (++i < 2) callworker(i); + else SimpleTest.finish(); + }; + w.onerrror = function(e) { + ok(false, "Should not get any errors from this worker"); + } + } + callworker(0); + })(); +} + +try { + var worker = new Worker("about:blank"); + worker.onerror = function(e) { + e.preventDefault(); + is(e.message, loadErrorMessage, + "Should get the right error from the toplevel script"); + nextTest(); + } + + worker.onmessage = function(event) { + ok(false, "Shouldn't get a message!"); + SimpleTest.finish(); + } +} catch (e) { + ok(false, "This should not happen."); +} + + +SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_location.html b/dom/workers/test/test_location.html new file mode 100644 index 000000000..cbd605307 --- /dev/null +++ b/dom/workers/test/test_location.html @@ -0,0 +1,72 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Location +--> +<head> + <title>Test for DOM Worker Location</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var thisFilename = "test_location.html"; + var workerFilename = "location_worker.js"; + + var href = window.location.href + var queryPos = href.lastIndexOf(window.location.search); + var baseHref = href.substr(0, href.substr(0, queryPos).lastIndexOf("/") + 1); + + var path = window.location.pathname; + var basePath = path.substr(0, path.lastIndexOf("/") + 1); + + var strings = { + "toString": baseHref + workerFilename, + "href": baseHref + workerFilename, + "protocol": window.location.protocol, + "host": window.location.host, + "hostname": window.location.hostname, + "port": window.location.port, + "pathname": basePath + workerFilename, + "search": "", + "hash": "", + "origin": "http://mochi.test:8888" + }; + + var lastSlash = href.substr(0, queryPos).lastIndexOf("/") + 1; + is(thisFilename, + href.substr(lastSlash, queryPos - lastSlash), + "Correct filename "); + + var worker = new Worker(workerFilename); + + worker.onmessage = function(event) { + if (event.data.string == "testfinished") { + SimpleTest.finish(); + return; + } + ok(event.data.string in strings, event.data.string); + is(event.data.value, strings[event.data.string], event.data.string); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_longThread.html b/dom/workers/test/test_longThread.html new file mode 100644 index 000000000..d23989f8b --- /dev/null +++ b/dom/workers/test/test_longThread.html @@ -0,0 +1,59 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads (Bug 437152) +--> +<head> + <title>Test for DOM Worker Threads (Bug 437152)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=437152">DOM Worker Threads Bug 437152</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + const numThreads = 5; + var doneThreads = 0; + + function onmessage(event) { + switch (event.data) { + case "done": + if (++doneThreads == numThreads) { + ok(true, "All messages received from workers"); + SimpleTest.finish(); + } + break; + default: + ok(false, "Unexpected message"); + SimpleTest.finish(); + } + } + + function onerror(event) { + ok(false, "Worker had an error"); + SimpleTest.finish(); + } + + for (var i = 0; i < numThreads; i++) { + var worker = new Worker("longThread_worker.js"); + worker.onmessage = onmessage; + worker.onerror = onerror; + worker.postMessage("start"); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_multi_sharedWorker.html b/dom/workers/test/test_multi_sharedWorker.html new file mode 100644 index 000000000..ba028302f --- /dev/null +++ b/dom/workers/test/test_multi_sharedWorker.html @@ -0,0 +1,242 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for SharedWorker</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> + <script class="testbody" type="text/javascript;version=1.7"> + "use strict"; + + const basePath = + location.pathname.substring(0, + location.pathname.lastIndexOf("/") + 1); + const baseURL = location.origin + basePath; + + const frameRelativeURL = "multi_sharedWorker_frame.html"; + const frameAbsoluteURL = baseURL + frameRelativeURL; + const workerAbsoluteURL = + baseURL + "multi_sharedWorker_sharedWorker.js"; + + const storedData = "0123456789abcdefghijklmnopqrstuvwxyz"; + const errorMessage = "Error: Expected"; + const errorLineno = 34; + + let testGenerator = (function() { + SimpleTest.waitForExplicitFinish(); + + window.addEventListener("message", function(event) { + if (typeof(event.data) == "string") { + info(event.data); + } else { + sendToGenerator(event); + } + }); + + let frame1 = document.getElementById("frame1"); + frame1.src = frameRelativeURL; + frame1.onload = sendToGenerator; + + yield undefined; + + frame1 = frame1.contentWindow; + + let frame2 = document.getElementById("frame2"); + frame2.src = frameAbsoluteURL; + frame2.onload = sendToGenerator; + + yield undefined; + + frame2 = frame2.contentWindow; + + let data = { + command: "start" + }; + + frame1.postMessage(data, "*"); + frame2.postMessage(data, "*"); + + let event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame1, "First window got the event"); + is(event.data.type, "connect", "Got a connect message"); + + data = { + command: "retrieve" + }; + frame1.postMessage(data, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame1, "First window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, undefined, "No data stored yet"); + + frame2.postMessage(data, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame2, "Second window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, undefined, "No data stored yet"); + + data = { + command: "store", + data: storedData + }; + frame2.postMessage(data, "*"); + + data = { + command: "retrieve" + }; + frame1.postMessage(data, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame1, "First window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, storedData, "Got stored data"); + + // This will generate two MessageEvents, one for each window. + let sawFrame1Error = false; + let sawFrame2Error = false; + + data = { + command: "error" + }; + frame1.postMessage(data, "*"); + + // First event. + event = yield undefined; + + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.data.type, "worker-error", "Got an error message"); + is(event.data.message, errorMessage, "Got correct error message"); + is(event.data.filename, workerAbsoluteURL, "Got correct filename"); + is(event.data.lineno, errorLineno, "Got correct lineno"); + if (event.source == frame1) { + is(sawFrame1Error, false, "Haven't seen error for frame1 yet"); + sawFrame1Error = true; + } else if (event.source == frame2) { + is(sawFrame2Error, false, "Haven't seen error for frame1 yet"); + sawFrame2Error = true; + } else { + ok(false, "Saw error from unknown window"); + } + + // Second event + event = yield undefined; + + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.data.type, "worker-error", "Got an error message"); + is(event.data.message, errorMessage, "Got correct error message"); + is(event.data.filename, workerAbsoluteURL, "Got correct filename"); + is(event.data.lineno, errorLineno, "Got correct lineno"); + if (event.source == frame1) { + is(sawFrame1Error, false, "Haven't seen error for frame1 yet"); + sawFrame1Error = true; + } else if (event.source == frame2) { + is(sawFrame2Error, false, "Haven't seen error for frame1 yet"); + sawFrame2Error = true; + } else { + ok(false, "Saw error from unknown window"); + } + + is(sawFrame1Error, true, "Saw error for frame1"); + is(sawFrame2Error, true, "Saw error for frame2"); + + // This will generate two MessageEvents, one for each window. + sawFrame1Error = false; + sawFrame2Error = false; + + data = { + command: "error" + }; + frame1.postMessage(data, "*"); + + // First event. + event = yield undefined; + + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.data.type, "error", "Got an error message"); + is(event.data.message, errorMessage, "Got correct error message"); + is(event.data.filename, workerAbsoluteURL, "Got correct filename"); + is(event.data.lineno, errorLineno, "Got correct lineno"); + is(event.data.isErrorEvent, true, "Frame got an ErrorEvent"); + if (event.source == frame1) { + is(sawFrame1Error, false, "Haven't seen error for frame1 yet"); + sawFrame1Error = true; + } else if (event.source == frame2) { + is(sawFrame2Error, false, "Haven't seen error for frame1 yet"); + sawFrame2Error = true; + } else { + ok(false, "Saw error from unknown window"); + } + + // Second event + event = yield undefined; + + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.data.type, "error", "Got an error message"); + is(event.data.message, errorMessage, "Got correct error message"); + is(event.data.filename, workerAbsoluteURL, "Got correct filename"); + is(event.data.lineno, errorLineno, "Got correct lineno"); + is(event.data.isErrorEvent, true, "Frame got an ErrorEvent"); + if (event.source == frame1) { + is(sawFrame1Error, false, "Haven't seen error for frame1 yet"); + sawFrame1Error = true; + } else if (event.source == frame2) { + is(sawFrame2Error, false, "Haven't seen error for frame1 yet"); + sawFrame2Error = true; + } else { + ok(false, "Saw error from unknown window"); + } + + is(sawFrame1Error, true, "Saw error for frame1"); + is(sawFrame2Error, true, "Saw error for frame2"); + + // Try a shared worker in a different origin. + frame1 = document.getElementById("frame1"); + frame1.src = "http://example.org" + basePath + frameRelativeURL; + frame1.onload = sendToGenerator; + yield undefined; + + frame1 = frame1.contentWindow; + + data = { + command: "retrieve" + }; + frame1.postMessage(data, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame1, "First window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, undefined, "No data stored yet"); + + frame2.postMessage(data, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame2, "First window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, storedData, "Got stored data"); + + window.removeEventListener("message", sendToGenerator); + + SimpleTest.finish(); + yield undefined; + })(); + + let sendToGenerator = testGenerator.send.bind(testGenerator); + + </script> + </head> + <body onload="testGenerator.next();"> + <iframe id="frame1"></iframe> + <iframe id="frame2"></iframe> + </body> +</html> diff --git a/dom/workers/test/test_multi_sharedWorker_lifetimes.html b/dom/workers/test/test_multi_sharedWorker_lifetimes.html new file mode 100644 index 000000000..a3f4dc9b5 --- /dev/null +++ b/dom/workers/test/test_multi_sharedWorker_lifetimes.html @@ -0,0 +1,156 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for SharedWorker</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> + <script class="testbody" type="text/javascript;version=1.7"> + "use strict"; + + const scrollbarPref = "layout.testing.overlay-scrollbars.always-visible"; + const bfCacheEnabledPref = "browser.sessionhistory.cache_subframes"; + const bfCacheDepthPref = "browser.sessionhistory.max_total_viewers"; + const bfCacheDepth = 10; + + const frameRelativeURL = "multi_sharedWorker_frame.html"; + const storedData = "0123456789abcdefghijklmnopqrstuvwxyz"; + + let testGenerator = (function() { + SimpleTest.waitForExplicitFinish(); + + // Force scrollbar to always be shown. The scrollbar setting is + // necessary to avoid the fade-in/fade-out from evicting our document + // from the BF cache below. If bug 1049277 is fixed, then we can + // stop setting the scrollbar pref here. + SpecialPowers.pushPrefEnv({ set: [[scrollbarPref, true]] }, + sendToGenerator); + yield undefined; + + window.addEventListener("message", function(event) { + if (typeof(event.data) == "string") { + info(event.data); + } else { + sendToGenerator(event); + } + }); + + let frame = document.getElementById("frame"); + frame.src = frameRelativeURL; + frame.onload = sendToGenerator; + + yield undefined; + + frame = frame.contentWindow; + frame.postMessage({ command: "retrieve" }, "*"); + + let event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame, "Correct window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, undefined, "No data stored yet"); + + frame.postMessage({ command: "store", data: storedData }, "*"); + frame.postMessage({ command: "retrieve" }, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame, "Correct window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, storedData, "Got stored data"); + + // Navigate when the bfcache is disabled. + info("Navigating to about:blank"); + frame = document.getElementById("frame"); + frame.onload = sendToGenerator; + frame.src = "about:blank"; + frame.contentWindow.document.body.offsetTop; + + yield undefined; + + info("Navigating to " + frameRelativeURL); + frame.src = frameRelativeURL; + frame.contentWindow.document.body.offsetTop; + + yield undefined; + + frame = frame.contentWindow; + frame.postMessage({ command: "retrieve" }, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame, "Correct window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, undefined, "No data stored"); + + frame.postMessage({ command: "store", data: storedData }, "*"); + frame.postMessage({ command: "retrieve" }, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame, "Correct window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, storedData, "Got stored data"); + + info("Enabling '" + bfCacheEnabledPref + "' pref"); + SpecialPowers.pushPrefEnv({ set: [[bfCacheEnabledPref, true], + [bfCacheDepthPref, bfCacheDepth]] }, + sendToGenerator); + yield undefined; + + // Navigate when the bfcache is enabled. + frame = document.getElementById("frame"); + frame.onload = sendToGenerator; + + info("Navigating to about:blank"); + frame.src = "about:blank"; + frame.contentWindow.document.body.offsetTop; + + yield undefined; + + for (let i = 0; i < 3; i++) { + info("Running GC"); + SpecialPowers.exactGC(sendToGenerator); + yield undefined; + + info("Waiting the event queue to clear"); + SpecialPowers.executeSoon(sendToGenerator); + yield undefined; + } + + info("Navigating to " + frameRelativeURL); + frame.src = frameRelativeURL; + frame.contentWindow.document.body.offsetTop; + + yield undefined; + + frame = frame.contentWindow; + frame.postMessage({ command: "retrieve" }, "*"); + + event = yield undefined; + ok(event instanceof MessageEvent, "Got a MessageEvent"); + is(event.source, frame, "Correct window got the event"); + is(event.data.type, "result", "Got a result message"); + is(event.data.data, storedData, "Still have data stored"); + + info("Resetting '" + bfCacheEnabledPref + "' pref"); + SpecialPowers.popPrefEnv(sendToGenerator); + yield undefined; + + window.removeEventListener("message", sendToGenerator); + + SimpleTest.finish(); + yield undefined; + })(); + + let sendToGenerator = testGenerator.send.bind(testGenerator); + + </script> + </head> + <body onload="testGenerator.next();"> + <iframe id="frame"></iframe> + </body> +</html> diff --git a/dom/workers/test/test_navigator.html b/dom/workers/test/test_navigator.html new file mode 100644 index 000000000..49d320967 --- /dev/null +++ b/dom/workers/test/test_navigator.html @@ -0,0 +1,68 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Navigator +--> +<head> + <title>Test for DOM Worker Navigator</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var worker = new Worker("navigator_worker.js"); + + worker.onmessage = function(event) { + var args = JSON.parse(event.data); + + if (args.name == "testFinished") { + SimpleTest.finish(); + return; + } + + if (typeof navigator[args.name] == "undefined") { + ok(false, "Navigator has no '" + args.name + "' property!"); + return; + } + + if (args.name === "languages") { + is(navigator.languages.toString(), args.value.toString(), "languages matches"); + return; + } + + if (args.name === "storage") { + is(typeof navigator.storage, typeof args.value, "storage type matches"); + return; + } + + is(navigator[args.name], args.value, + "Mismatched navigator string for " + args.name + "!"); + }; + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + } + + var version = SpecialPowers.Cc["@mozilla.org/xre/app-info;1"].getService(SpecialPowers.Ci.nsIXULAppInfo).version; + var isNightly = version.endsWith("a1"); + var isRelease = !version.includes("a"); + + worker.postMessage({ isNightly, isRelease }); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_navigator_languages.html b/dom/workers/test/test_navigator_languages.html new file mode 100644 index 000000000..2111739d9 --- /dev/null +++ b/dom/workers/test/test_navigator_languages.html @@ -0,0 +1,53 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Navigator +--> +<head> + <title>Test for DOM Worker Navigator.languages</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + var tests = [ 'en,it', 'it,en,fr', '', 'en' ]; + var expectedLanguages; + function runTests() { + if (!tests.length) { + worker.postMessage('finish'); + SimpleTest.finish(); + return; + } + + expectedLanguages = tests.shift(); + SpecialPowers.pushPrefEnv({"set": [["intl.accept_languages", expectedLanguages]]}, function() { + worker.postMessage(true); + }); + } + + SimpleTest.waitForExplicitFinish(); + + var worker = new Worker("navigator_languages_worker.js"); + + worker.onmessage = function(event) { + is(event.data.toString(), navigator.languages.toString(), "The languages mach."); + is(event.data.toString(), expectedLanguages, "This is the correct result."); + runTests(); + } + + runTests(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_navigator_workers_hardwareConcurrency.html b/dom/workers/test/test_navigator_workers_hardwareConcurrency.html new file mode 100644 index 000000000..6fbbc75a9 --- /dev/null +++ b/dom/workers/test/test_navigator_workers_hardwareConcurrency.html @@ -0,0 +1,30 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for Navigator.hardwareConcurrency</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript"> + + SimpleTest.waitForExplicitFinish(); + var script = "postMessage(navigator.hardwareConcurrency)"; + var url = URL.createObjectURL(new Blob([script])); + var w = new Worker(url); + w.onmessage = function(e) { + var x = e.data; + is(typeof x, "number", "hardwareConcurrency should be a number."); + ok(x > 0, "hardwareConcurrency should be greater than 0."); + SimpleTest.finish(); + } + </script> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_newError.html b/dom/workers/test/test_newError.html new file mode 100644 index 000000000..51aeae6b0 --- /dev/null +++ b/dom/workers/test/test_newError.html @@ -0,0 +1,34 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("newError_worker.js"); + + worker.onmessage = function(event) { + ok(false, "Shouldn't get a message!"); + SimpleTest.finish(); + } + + worker.onerror = function(event) { + is(event.message, "Error: foo!", "Got wrong error message!"); + event.preventDefault(); + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_notification.html b/dom/workers/test/test_notification.html new file mode 100644 index 000000000..409d9dfd1 --- /dev/null +++ b/dom/workers/test/test_notification.html @@ -0,0 +1,50 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 916893</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=916893">Bug 916893</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show and click events."); + + function runTest() { + MockServices.register(); + var w = new Worker("notification_worker.js"); + w.onmessage = function(e) { + if (e.data.type === 'finish') { + MockServices.unregister(); + SimpleTest.finish(); + } else if (e.data.type === 'ok') { + ok(e.data.test, e.data.message); + } else if (e.data.type === 'is') { + is(e.data.test1, e.data.test2, e.data.message); + } + } + + SimpleTest.waitForExplicitFinish(); + // turn on testing pref (used by notification.cpp, and mock the alerts + SpecialPowers.setBoolPref("notification.prompt.testing", true); + w.postMessage('start') + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv( + {"set": [["dom.webnotifications.workers.enabled", true]]}, + runTest + ); +</script> +</body> +</html> diff --git a/dom/workers/test/test_notification_child.html b/dom/workers/test/test_notification_child.html new file mode 100644 index 000000000..74a1e8e09 --- /dev/null +++ b/dom/workers/test/test_notification_child.html @@ -0,0 +1,49 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 916893 - Test Notifications in child workers.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=916893">Bug 916893</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show event."); + function runTest() { + MockServices.register(); + var w = new Worker("notification_worker_child-parent.js"); + w.onmessage = function(e) { + if (e.data.type === 'finish') { + MockServices.unregister(); + SimpleTest.finish(); + } else if (e.data.type === 'ok') { + ok(e.data.test, e.data.message); + } else if (e.data.type === 'is') { + is(e.data.test1, e.data.test2, e.data.message); + } + } + + SimpleTest.waitForExplicitFinish(); + // turn on testing pref (used by notification.cpp, and mock the alerts + SpecialPowers.setBoolPref("notification.prompt.testing", true); + w.postMessage('start') + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv( + {"set": [["dom.webnotifications.workers.enabled", true]]}, + runTest + ); +</script> +</body> +</html> diff --git a/dom/workers/test/test_notification_permission.html b/dom/workers/test/test_notification_permission.html new file mode 100644 index 000000000..e51e060d3 --- /dev/null +++ b/dom/workers/test/test_notification_permission.html @@ -0,0 +1,51 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=916893 +--> +<head> + <title>Bug 916893 - Make sure error is fired on Notification if permission is denied.</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/MockServices.js"></script> + <script type="text/javascript" src="/tests/dom/tests/mochitest/notification/NotificationTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=916893">Bug 916893</a> +<p id="display"></p> +<div id="content" style="display: none"> +</div> +<pre id="test"> +</pre> +<script type="text/javascript"> + SimpleTest.requestFlakyTimeout("Mock alert service dispatches show event."); + function runTest() { + MockServices.register(); + var w = new Worker("notification_permission_worker.js"); + w.onmessage = function(e) { + if (e.data.type === 'finish') { + SpecialPowers.setBoolPref("notification.prompt.testing.allow", true); + MockServices.unregister(); + SimpleTest.finish(); + } else if (e.data.type === 'ok') { + ok(e.data.test, e.data.message); + } else if (e.data.type === 'is') { + is(e.data.test1, e.data.test2, e.data.message); + } + } + + SimpleTest.waitForExplicitFinish(); + // turn on testing pref (used by notification.cpp, and mock the alerts + SpecialPowers.setBoolPref("notification.prompt.testing", true); + SpecialPowers.setBoolPref("notification.prompt.testing.allow", false); + w.postMessage('start') + } + + SimpleTest.waitForExplicitFinish(); + SpecialPowers.pushPrefEnv( + {"set": [["dom.webnotifications.workers.enabled", true]]}, + runTest + ); +</script> +</body> +</html> diff --git a/dom/workers/test/test_onLine.html b/dom/workers/test/test_onLine.html new file mode 100644 index 000000000..660835f82 --- /dev/null +++ b/dom/workers/test/test_onLine.html @@ -0,0 +1,64 @@ +<!DOCTYPE HTML> +<html> +<!-- +Bug 925437: online/offline events tests. + +Any copyright is dedicated to the Public Domain. +http://creativecommons.org/licenses/publicdomain/ +--> +<head> + <title>Test for Bug 925437 (worker online/offline events)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=925437">Mozilla Bug 925437</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> + +<script class="testbody" type="text/javascript"> + +addLoadEvent(function() { + var w = new Worker("onLine_worker.js"); + + w.onmessage = function(e) { + if (e.data.type === 'ready') { + doTest(); + } else if (e.data.type === 'ok') { + ok(e.data.test, e.data.message); + } else if (e.data.type === 'finished') { + SimpleTest.finish(); + } + } + + function doTest() { + var iosvc = SpecialPowers.Cc["@mozilla.org/network/io-service;1"] + .getService(SpecialPowers.Ci.nsIIOService2); + iosvc.manageOfflineStatus = false; + + info("setting iosvc.offline = true"); + iosvc.offline = true; + + info("setting iosvc.offline = false"); + iosvc.offline = false; + + info("setting iosvc.offline = true"); + iosvc.offline = true; + + for (var i = 0; i < 10; ++i) { + iosvc.offline = !iosvc.offline; + } + + info("setting iosvc.offline = false"); + w.postMessage('lastTest'); + iosvc.offline = false; + } +}); + +SimpleTest.waitForExplicitFinish(); +</script> +</body> +</html> diff --git a/dom/workers/test/test_promise.html b/dom/workers/test/test_promise.html new file mode 100644 index 000000000..63f359f9d --- /dev/null +++ b/dom/workers/test/test_promise.html @@ -0,0 +1,44 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Promise object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function runTest() { + var worker = new Worker("promise_worker.js"); + + worker.onmessage = function(event) { + + if (event.data.type == 'finish') { + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } + } + + worker.onerror = function(event) { + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + }; + + worker.postMessage(true); + } + + SimpleTest.waitForExplicitFinish(); + runTest(); +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_promise_resolved_with_string.html b/dom/workers/test/test_promise_resolved_with_string.html new file mode 100644 index 000000000..28caaaaa8 --- /dev/null +++ b/dom/workers/test/test_promise_resolved_with_string.html @@ -0,0 +1,41 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1027221 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1027221</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript"> + + /** Test for Bug 1027221 **/ + // Set up a permanent atom + SimpleTest.waitForExplicitFinish(); + var x = "x"; + // Trigger some incremental gc + SpecialPowers.Cu.getJSTestingFunctions().gcslice(1); + + // Kick off a worker that uses this same atom + var w = new Worker("data:text/plain,Promise.resolve('x').then(function() { postMessage(1); });"); + // Maybe trigger some more incremental gc + SpecialPowers.Cu.getJSTestingFunctions().gcslice(1); + + w.onmessage = function() { + ok(true, "Got here"); + SimpleTest.finish(); + }; + + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1027221">Mozilla Bug 1027221</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_recursion.html b/dom/workers/test/test_recursion.html new file mode 100644 index 000000000..888a607c4 --- /dev/null +++ b/dom/workers/test/test_recursion.html @@ -0,0 +1,69 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads +--> +<head> + <title>Test for DOM Worker Threads Recursion</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + // Intermittently triggers one assertion on Mac (bug 848098). + if (navigator.platform.indexOf("Mac") == 0) { + SimpleTest.expectAssertions(0, 1); + } + + const testCount = 2; + var errorCount = 0; + + var worker = new Worker("recursion_worker.js"); + + function done() { + worker.terminate(); + SimpleTest.finish(); + } + + worker.onmessage = function(event) { + if (event.data == "Done") { + ok(true, "correct message"); + } + else { + ok(false, "Bad message: " + event.data); + } + done(); + } + + worker.onerror = function(event) { + event.preventDefault(); + if (event.message == "too much recursion") { + ok(true, "got correct error message"); + ++errorCount; + } + else { + ok(false, "got bad error message: " + event.message); + done(); + } + } + + for (var i = 0; i < testCount; i++) { + worker.postMessage(""); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_recursiveOnerror.html b/dom/workers/test/test_recursiveOnerror.html new file mode 100644 index 000000000..06471d978 --- /dev/null +++ b/dom/workers/test/test_recursiveOnerror.html @@ -0,0 +1,44 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="text/javascript"> + const filename = "http://mochi.test:8888/tests/dom/workers/test/" + + "recursiveOnerror_worker.js"; + const errors = [ + { message: "Error: 2", lineno: 6 }, + { message: "Error: 1", lineno: 10 } + ] + + var errorCount = 0; + + var worker = new Worker("recursiveOnerror_worker.js"); + worker.postMessage("go"); + + worker.onerror = function(event) { + event.preventDefault(); + + ok(errorCount < errors.length, "Correct number of error events"); + const error = errors[errorCount++]; + + is(event.message, error.message, "Correct message"); + is(event.filename, filename, "Correct filename"); + is(event.lineno, error.lineno, "Correct lineno"); + + if (errorCount == errors.length) { + SimpleTest.finish(); + } + } + + SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> diff --git a/dom/workers/test/test_referrer.html b/dom/workers/test/test_referrer.html new file mode 100644 index 000000000..c3afec78e --- /dev/null +++ b/dom/workers/test/test_referrer.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test the referrer of workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + function test_mainScript() { + var worker = new Worker("referrer.sjs?worker"); + worker.onmessage = function() { + var xhr = new XMLHttpRequest(); + xhr.open('GET', 'referrer.sjs?result', true); + xhr.onload = function() { + is(xhr.responseText, location.href, "The referrer has been sent."); + next(); + } + xhr.send(); + } + worker.postMessage(42); + } + + function test_importScript() { + var worker = new Worker("worker_referrer.js"); + worker.onmessage = function(e) { + is(e.data, location.href.replace("test_referrer.html", "worker_referrer.js"), "The referrer has been sent."); + next(); + } + worker.postMessage(42); + } + + var tests = [ test_mainScript, test_importScript ]; + function next() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + SimpleTest.waitForExplicitFinish(); + next(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_referrer_header_worker.html b/dom/workers/test/test_referrer_header_worker.html new file mode 100644 index 000000000..d04c8b591 --- /dev/null +++ b/dom/workers/test/test_referrer_header_worker.html @@ -0,0 +1,39 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test the referrer of workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + <script class="testbody" type="text/javascript"> + SimpleTest.waitForExplicitFinish(); + + SpecialPowers.pushPrefEnv( + {"set": [ + ['security.mixed_content.block_display_content', false], + ['security.mixed_content.block_active_content', false] + ]}, + function() { + SpecialPowers.pushPermissions([{'type': 'systemXHR', 'allow': true, 'context': document}], test); + }); + + function test() { + function messageListener(event) { + eval(event.data); + } + window.addEventListener("message", messageListener, false); + + var ifr = document.createElement('iframe'); + ifr.setAttribute('src', 'https://example.com/tests/dom/workers/test/referrer_worker.html'); + document.body.appendChild(ifr); + } + </script> +</body> +</html> + diff --git a/dom/workers/test/test_resolveWorker-assignment.html b/dom/workers/test/test_resolveWorker-assignment.html new file mode 100644 index 000000000..b6733e010 --- /dev/null +++ b/dom/workers/test/test_resolveWorker-assignment.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> + <head> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="application/javascript"> + window.Worker = 17; // resolve through assignment + + var desc = Object.getOwnPropertyDescriptor(window, "Worker"); + ok(typeof desc === "object" && desc !== null, "Worker property must exist"); + + is(desc.value, 17, "Overwrite didn't work correctly"); + is(desc.enumerable, false, + "Initial descriptor was non-enumerable, and [[Put]] changes the " + + "property value but not its enumerability"); + is(desc.configurable, true, + "Initial descriptor was configurable, and [[Put]] changes the " + + "property value but not its configurability"); + is(desc.writable, true, + "Initial descriptor was writable, and [[Put]] changes the " + + "property value but not its writability"); + </script> + </body> +</html> diff --git a/dom/workers/test/test_resolveWorker.html b/dom/workers/test/test_resolveWorker.html new file mode 100644 index 000000000..8e2ea5445 --- /dev/null +++ b/dom/workers/test/test_resolveWorker.html @@ -0,0 +1,31 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> + <head> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="application/javascript"> + window.Worker; // resolve not through assignment + Worker = 17; + + var desc = Object.getOwnPropertyDescriptor(window, "Worker"); + ok(typeof desc === "object" && desc !== null, "Worker property must exist"); + + is(desc.value, 17, "Overwrite didn't work correctly"); + is(desc.enumerable, false, + "Initial descriptor was non-enumerable, and [[Put]] changes the " + + "property value but not its enumerability"); + is(desc.configurable, true, + "Initial descriptor was configurable, and [[Put]] changes the " + + "property value but not its configurability"); + is(desc.writable, true, + "Initial descriptor was writable, and [[Put]] changes the " + + "property value but not its writability"); + </script> + </body> +</html> diff --git a/dom/workers/test/test_rvals.html b/dom/workers/test/test_rvals.html new file mode 100644 index 000000000..eba858928 --- /dev/null +++ b/dom/workers/test/test_rvals.html @@ -0,0 +1,37 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 911085</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("rvals_worker.js"); + + worker.onmessage = function(event) { + if (event.data == 'ignore') return; + + if (event.data == 'finished') { + is(worker.terminate(), undefined, "Terminate() returns 'undefined'"); + SimpleTest.finish(); + return; + } + + ok(event.data, "something good returns 'undefined' in workers"); + }; + + is(worker.postMessage(42), undefined, "PostMessage() returns 'undefined' on main thread"); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + + diff --git a/dom/workers/test/test_setTimeoutWith0.html b/dom/workers/test/test_setTimeoutWith0.html new file mode 100644 index 000000000..4c0dacafb --- /dev/null +++ b/dom/workers/test/test_setTimeoutWith0.html @@ -0,0 +1,20 @@ +<html> +<head> + <title>Test for DOM Worker setTimeout and strings containing 0</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script> + +var a = new Worker('worker_setTimeoutWith0.js'); +a.onmessage = function(e) { + is(e.data, 2, "We want to see 2 here"); + SimpleTest.finish(); +} + +SimpleTest.waitForExplicitFinish(); +</script> +</body> +</html> + diff --git a/dom/workers/test/test_sharedWorker.html b/dom/workers/test/test_sharedWorker.html new file mode 100644 index 000000000..3d3d4e2c6 --- /dev/null +++ b/dom/workers/test/test_sharedWorker.html @@ -0,0 +1,71 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for SharedWorker</title> + <script src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> + </head> + <body> + <p id="display"></p> + <div id="content" style="display: none"></div> + <pre id="test"> + <script class="testbody"> + "use strict"; + + const href = window.location.href; + const filename = "sharedWorker_sharedWorker.js"; + const sentMessage = "ping"; + const errorFilename = href.substring(0, href.lastIndexOf("/") + 1) + + filename; + const errorLine = 91; + const errorColumn = 0; + + var worker = new SharedWorker(filename); + + ok(worker instanceof SharedWorker, "Got SharedWorker instance"); + ok(!("postMessage" in worker), "SharedWorker has no 'postMessage'"); + ok(worker.port instanceof MessagePort, + "Shared worker has MessagePort"); + + var receivedMessage; + var receivedError; + + worker.port.onmessage = function(event) { + ok(event instanceof MessageEvent, "Got a MessageEvent"); + ok(event.target === worker.port, + "MessageEvent has correct 'target' property"); + is(event.data, sentMessage, "Got correct message"); + ok(receivedMessage === undefined, "Haven't gotten message yet"); + receivedMessage = event.data; + if (receivedError) { + SimpleTest.finish(); + } + }; + + worker.onerror = function(event) { + ok(event instanceof ErrorEvent, "Got an ErrorEvent"); + is(event.message, "Error: " + sentMessage, "Got correct error"); + is(event.filename, errorFilename, "Got correct filename"); + is(event.lineno, errorLine, "Got correct lineno"); + is(event.colno, errorColumn, "Got correct column"); + ok(receivedError === undefined, "Haven't gotten error yet"); + receivedError = event.message; + event.preventDefault(); + if (receivedMessage) { + SimpleTest.finish(); + } + }; + + worker.port.postMessage(sentMessage); + + SimpleTest.waitForExplicitFinish(); + + </script> + </pre> + </body> +</html> diff --git a/dom/workers/test/test_sharedWorker_lifetime.html b/dom/workers/test/test_sharedWorker_lifetime.html new file mode 100644 index 000000000..169746892 --- /dev/null +++ b/dom/workers/test/test_sharedWorker_lifetime.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for MessagePort and SharedWorkers</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <script class="testbody" type="text/javascript"> + +var gced = false; + +var sw = new SharedWorker('sharedWorker_lifetime.js'); +sw.port.onmessage = function(event) { + ok(gced, "The SW is still alive also after GC"); + SimpleTest.finish(); +} + +sw = null; +SpecialPowers.forceGC(); +gced = true; + +SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> diff --git a/dom/workers/test/test_sharedWorker_ports.html b/dom/workers/test/test_sharedWorker_ports.html new file mode 100644 index 000000000..32698ab52 --- /dev/null +++ b/dom/workers/test/test_sharedWorker_ports.html @@ -0,0 +1,42 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for MessagePort and SharedWorkers</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <script class="testbody" type="text/javascript"> + +var sw1 = new SharedWorker('sharedWorker_ports.js'); +sw1.port.onmessage = function(event) { + if (event.data.type == "connected") { + ok(true, "The SharedWorker is alive."); + + var sw2 = new SharedWorker('sharedWorker_ports.js'); + sw1.port.postMessage("Port from the main-thread!", [sw2.port]); + return; + } + + if (event.data.type == "status") { + ok(event.data.test, event.data.msg); + return; + } + + if (event.data.type == "finish") { + info("Finished!"); + ok(sw1.port, "The port still exists"); + sw1.port.foo = sw1; // Just a test to see if we leak. + SimpleTest.finish(); + } +} + +SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> + diff --git a/dom/workers/test/test_sharedWorker_privateBrowsing.html b/dom/workers/test/test_sharedWorker_privateBrowsing.html new file mode 100644 index 000000000..b0eac5831 --- /dev/null +++ b/dom/workers/test/test_sharedWorker_privateBrowsing.html @@ -0,0 +1,101 @@ +<html xmlns="http://www.w3.org/1999/xhtml"> +<head> + <title>Test for SharedWorker - Private Browsing</title> + <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?> +</head> +<body> + +<script type="application/javascript"> + +const Ci = Components.interfaces; +var mainWindow; + +var contentPage = "http://mochi.test:8888/chrome/dom/workers/test/empty.html"; + +function testOnWindow(aIsPrivate, aCallback) { + var win = mainWindow.OpenBrowserWindow({private: aIsPrivate}); + win.addEventListener("load", function onLoad() { + win.removeEventListener("load", onLoad, false); + win.addEventListener("DOMContentLoaded", function onInnerLoad() { + if (win.content.location.href != contentPage) { + win.gBrowser.loadURI(contentPage); + return; + } + + win.removeEventListener("DOMContentLoaded", onInnerLoad, true); + SimpleTest.executeSoon(function() { aCallback(win); }); + }, true); + + if (!aIsPrivate) { + win.gBrowser.loadURI(contentPage); + } + }, true); +} + +function setupWindow() { + mainWindow = window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebNavigation) + .QueryInterface(Ci.nsIDocShellTreeItem) + .rootTreeItem + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindow); + runTest(); +} + +var wN; +var wP; + +function doTests() { + testOnWindow(false, function(aWin) { + wN = aWin; + + testOnWindow(true, function(aWin) { + wP = aWin; + + var sharedWorker1 = new wP.content.SharedWorker('sharedWorker_privateBrowsing.js'); + sharedWorker1.port.onmessage = function(event) { + is(event.data, 1, "Only 1 sharedworker expected in the private window"); + + var sharedWorker2 = new wN.content.SharedWorker('sharedWorker_privateBrowsing.js'); + sharedWorker2.port.onmessage = function(event) { + is(event.data, 1, "Only 1 sharedworker expected in the normal window"); + + var sharedWorker3 = new wP.content.SharedWorker('sharedWorker_privateBrowsing.js'); + sharedWorker3.port.onmessage = function(event) { + is(event.data, 2, "Only 2 sharedworker expected in the private window"); + runTest(); + } + } + } + }); + }); +} + +var steps = [ + setupWindow, + doTests +]; + +function runTest() { + if (!steps.length) { + wN.close(); + wP.close(); + + SimpleTest.finish(); + return; + } + + var step = steps.shift(); + step(); +} + +SimpleTest.waitForExplicitFinish(); +SpecialPowers.pushPrefEnv({"set": [ + ["browser.startup.page", 0], + ["browser.startup.homepage_override.mstone", "ignore"], +]}, runTest); + +</script> +</body> +</html> diff --git a/dom/workers/test/test_simpleThread.html b/dom/workers/test/test_simpleThread.html new file mode 100644 index 000000000..0dad90312 --- /dev/null +++ b/dom/workers/test/test_simpleThread.html @@ -0,0 +1,75 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads (Bug 437152) +--> +<head> + <title>Test for DOM Worker Threads (Bug 437152)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=437152">DOM Worker Threads Bug 437152</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("simpleThread_worker.js"); + + worker.addEventListener("message",function(event) { + is(event.target, worker); + switch (event.data) { + case "no-op": + break; + case "started": + is(gotErrors, true); + worker.postMessage("no-op"); + worker.postMessage("stop"); + break; + case "stopped": + worker.postMessage("no-op"); + SimpleTest.finish(); + break; + default: + ok(false, "Unexpected message:" + event.data); + SimpleTest.finish(); + } + }, false); + + var gotErrors = false; + worker.onerror = function(event) { + event.preventDefault(); + is(event.target, worker); + is(event.message, "uncaught exception: Bad message: asdf"); + + worker.onerror = function(otherEvent) { + otherEvent.preventDefault(); + is(otherEvent.target, worker); + is(otherEvent.message, "ReferenceError: Components is not defined"); + gotErrors = true; + + worker.onerror = function(oneMoreEvent) { + ok(false, "Worker had an error:" + oneMoreEvent.message); + SimpleTest.finish(); + }; + }; + }; + + worker.postMessage("asdf"); + worker.postMessage("components"); + worker.postMessage("start"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_subworkers_suspended.html b/dom/workers/test/test_subworkers_suspended.html new file mode 100644 index 000000000..063ccaa64 --- /dev/null +++ b/dom/workers/test/test_subworkers_suspended.html @@ -0,0 +1,135 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for sub workers+bfcache behavior</title> + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <script type="application/javascript"> + + const WORKER_URL = "worker_suspended.js"; + const SUB_WORKERS = 3 + + var testUrl1 = "window_suspended.html?page1Shown"; + var testUrl2 = "window_suspended.html?page2Shown"; + + var testWin; + var counter = 0; + + function cacheData() { + return caches.open("test") + .then(function(cache) { + return cache.match("http://mochi.test:888/foo"); + }) + .then(function(response) { + return response.text(); + }); + } + + function page1Shown(e) { + info("Page1Shown: " + testWin.location.href); + + // First time this page is shown. + if (counter == 0) { + ok(!e.persisted, "test page should have been persisted initially"); + + info("Create a worker and subworkers..."); + let worker = new e.target.defaultView.Worker(WORKER_URL); + + var promise = new Promise((resolve, reject) => { + info("Waiting until workers are ready..."); + worker.addEventListener("message", function onmessage(e) { + is(e.data, "ready", "We want to receive: -ready-"); + worker.removeEventListener("message", onmessage); + resolve(); + }); + worker.postMessage({ type: "page1", count: SUB_WORKERS }); + }); + + promise.then(function() { + info("Retrieving data from cache..."); + return cacheData(); + }) + + .then(function(content) { + is(content.indexOf("page1-"), 0, "We have data from the worker"); + }) + + .then(function() { + info("New location: " + testUrl2); + testWin.location.href = testUrl2; + }); + } else { + is(e.persisted, true, "test page should have been persisted in pageshow"); + + var promise = new Promise((resolve, reject) => { + info("Waiting a few seconds..."); + setTimeout(resolve, 5000); + }); + + promise.then(function() { + info("Retrieving data from cache..."); + return cacheData(); + }) + + .then(function(content) { + is(content.indexOf("page1-"), 0, "We have data from the worker"); + }) + + .then(function() { + testWin.close(); + SimpleTest.finish(); + }); + } + + counter++; + } + + function page2Shown(e) { + info("Page2Shown: " + testWin.location.href); + + info("Create a worker..."); + let worker = new e.target.defaultView.Worker(WORKER_URL); + + var promise = new Promise((resolve, reject) => { + info("Waiting until workers are ready..."); + worker.addEventListener("message", function onmessage(e) { + is(e.data, "ready", "We want to receive: -ready-"); + worker.removeEventListener("message", onmessage); + resolve(); + }); + worker.postMessage({ type: "page2" }); + }); + + promise.then(function() { + info("Retrieving data from cache..."); + return cacheData(); + }) + + .then(function(content) { + is(content, "page2-0", "We have data from the second worker"); + }) + + .then(function() { + info("Going back"); + testWin.history.back(); + }); + } + + SpecialPowers.pushPrefEnv({ set: [ + ["dom.caches.enabled", true], + ["dom.caches.testing.enabled", true], + ] }, + function() { + testWin = window.open(testUrl1); + }); + + SimpleTest.waitForExplicitFinish(); + SimpleTest.requestFlakyTimeout("untriaged"); + + </script> +</body> +</html> + diff --git a/dom/workers/test/test_suspend.html b/dom/workers/test/test_suspend.html new file mode 100644 index 000000000..806b97f6c --- /dev/null +++ b/dom/workers/test/test_suspend.html @@ -0,0 +1,138 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"> +<iframe id="workerFrame" src="suspend_iframe.html" onload="subframeLoaded();"> +</iframe> +<script class="testbody" type="text/javascript"> + + SimpleTest.waitForExplicitFinish(); + + var iframe; + var lastCount; + + var suspended = false; + var resumed = false; + var finished = false; + + var interval; + var oldMessageCount; + var waitCount = 0; + + function finishTest() { + if (finished) { + return; + } + finished = true; + SpecialPowers.flushPrefEnv(function () { + iframe.terminateWorker(); + SimpleTest.finish(); + }); + } + + function waitInterval() { + if (finished) { + return; + } + is(String(iframe.location), "about:blank", "Wrong url!"); + is(suspended, true, "Not suspended?"); + is(resumed, false, "Already resumed?!"); + is(lastCount, oldMessageCount, "Received a message while suspended!"); + if (++waitCount == 5) { + clearInterval(interval); + resumed = true; + iframe.history.back(); + } + } + + function badOnloadCallback() { + if (finished) { + return; + } + ok(false, "We don't want suspend_iframe.html to fire a new load event, we want it to come out of the bfcache!"); + finishTest(); + } + + function suspendCallback() { + if (finished) { + return; + } + is(String(iframe.location), "about:blank", "Wrong url!"); + is(suspended, false, "Already suspended?"); + is(resumed, false, "Already resumed?"); + SpecialPowers.popPrefEnv(function () { + suspended = true; + var iframeElement = document.getElementById("workerFrame"); + iframeElement.onload = badOnloadCallback; + oldMessageCount = lastCount; + interval = setInterval(waitInterval, 1000); + }); + } + + function messageCallback(data) { + if (finished) { + return; + } + + if (!suspended) { + ok(lastCount === undefined || lastCount == data - 1, + "Got good data, lastCount = " + lastCount + ", data = " + data); + lastCount = data; + if (lastCount == 25) { + SpecialPowers.pushPrefEnv({"set": [["browser.sessionhistory.cache_subframes", true]]}, function () { + iframe.location = "about:blank"; + // We want suspend_iframe.html to go into bfcache, so we need to flush + // out all pending notifications. Otherwise, if they're flushed too + // late, they could kick us out of the bfcache again. + iframe.document.body.offsetTop; + }); + } + return; + } + + var newLocation = + window.location.toString().replace("test_suspend.html", + "suspend_iframe.html"); + is(newLocation.indexOf(iframe.location.toString()), 0, "Wrong url!"); + is(resumed, true, "Got message before resumed!"); + is(lastCount, data - 1, "Missed a message, suspend failed!"); + finishTest(); + } + + function errorCallback(data) { + if (finished) { + return; + } + ok(false, "Iframe had an error: '" + data + "'"); + finishTest(); + } + + function subframeLoaded() { + if (finished) { + return; + } + var iframeElement = document.getElementById("workerFrame"); + iframeElement.onload = suspendCallback; + + iframe = iframeElement.contentWindow; + ok(iframe, "No iframe?!"); + + iframe.startWorker(messageCallback, errorCallback); + } + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_terminate.html b/dom/workers/test/test_terminate.html new file mode 100644 index 000000000..5d31bd165 --- /dev/null +++ b/dom/workers/test/test_terminate.html @@ -0,0 +1,100 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker terminate feature +--> +<head> + <title>Test for DOM Worker Navigator</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + + var messageCount = 0; + var intervalCount = 0; + + var interval; + + var worker; + + function messageListener(event) { + is(event.data, "Still alive!", "Correct message!"); + if (++messageCount == 20) { + ok(worker.onmessage === messageListener, + "Correct listener before terminate"); + + worker.terminate(); + + var exception = false; + try { + worker.addEventListener("message", messageListener, false); + } + catch (e) { + exception = true; + } + is(exception, false, "addEventListener didn't throw after terminate"); + + exception = false; + try { + worker.removeEventListener("message", messageListener, false); + } + catch (e) { + exception = true; + } + is(exception, false, "removeEventListener didn't throw after terminate"); + + exception = false; + try { + worker.postMessage("foo"); + } + catch (e) { + exception = true; + } + is(exception, false, "postMessage didn't throw after terminate"); + + exception = false; + try { + worker.terminate(); + } + catch (e) { + exception = true; + } + is(exception, false, "terminate didn't throw after terminate"); + + ok(worker.onmessage === messageListener, + "Correct listener after terminate"); + + worker.onmessage = function(event) { } + + interval = setInterval(testCount, 1000); + } + } + + function testCount() { + is(messageCount, 20, "Received another message after terminated!"); + if (intervalCount++ == 5) { + clearInterval(interval); + SimpleTest.finish(); + } + } + + worker = new Worker("terminate_worker.js"); + worker.onmessage = messageListener; + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_threadErrors.html b/dom/workers/test/test_threadErrors.html new file mode 100644 index 000000000..034a443e7 --- /dev/null +++ b/dom/workers/test/test_threadErrors.html @@ -0,0 +1,64 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads (Bug 437152) +--> +<head> + <title>Test for DOM Worker Threads (Bug 437152)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=437152">DOM Worker Threads Bug 437152</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + const expectedErrorCount = 4; + + function messageListener(event) { + ok(false, "Unexpected message: " + event.data); + SimpleTest.finish(); + }; + + var actualErrorCount = 0; + var failedWorkers = []; + + function errorListener(event) { + event.preventDefault(); + + if (failedWorkers.indexOf(event.target) != -1) { + ok(false, "Seen an extra error from this worker"); + SimpleTest.finish(); + return; + } + + failedWorkers.push(event.target); + actualErrorCount++; + + if (actualErrorCount == expectedErrorCount) { + ok(true, "all errors correctly detected"); + SimpleTest.finish(); + } + }; + + for (var i = 1; i <= expectedErrorCount; i++) { + var worker = new Worker("threadErrors_worker" + i + ".js"); + worker.onmessage = messageListener; + worker.onerror = errorListener; + worker.postMessage("Hi"); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_threadTimeouts.html b/dom/workers/test/test_threadTimeouts.html new file mode 100644 index 000000000..0fa86935a --- /dev/null +++ b/dom/workers/test/test_threadTimeouts.html @@ -0,0 +1,61 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads (Bug 437152) +--> +<head> + <title>Test for DOM Worker Threads (Bug 437152)</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=437152">DOM Worker Threads Bug 437152</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("threadTimeouts_worker.js"); + + worker.onmessage = function(event) { + is(event.target, worker); + switch (event.data) { + case "timeoutFinished": + event.target.postMessage("startInterval"); + break; + case "intervalFinished": + event.target.postMessage("cancelInterval"); + break; + case "intervalCanceled": + worker.postMessage("startExpression"); + break; + case "expressionFinished": + SimpleTest.finish(); + break; + default: + ok(false, "Unexpected message"); + SimpleTest.finish(); + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + ok(false, "Worker had an error: " + event.message); + SimpleTest.finish(); + }; + + worker.postMessage("startTimeout"); + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_throwingOnerror.html b/dom/workers/test/test_throwingOnerror.html new file mode 100644 index 000000000..7676541f7 --- /dev/null +++ b/dom/workers/test/test_throwingOnerror.html @@ -0,0 +1,54 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads +--> +<head> + <title>Test for DOM Worker Threads Recursion</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("throwingOnerror_worker.js"); + + var errors = ["foo", "bar"]; + + worker.onerror = function(event) { + event.preventDefault(); + var found = false; + for (var index in errors) { + if (event.message == "uncaught exception: " + errors[index]) { + errors.splice(index, 1); + found = true; + break; + } + } + is(found, true, "Unexpected error!"); + }; + + worker.onmessage = function(event) { + is(errors.length, 0, "Didn't see expected errors!"); + SimpleTest.finish(); + }; + + for (var i = 0; i < 2; i++) { + worker.postMessage(""); + } + + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_timeoutTracing.html b/dom/workers/test/test_timeoutTracing.html new file mode 100644 index 000000000..6770d36a1 --- /dev/null +++ b/dom/workers/test/test_timeoutTracing.html @@ -0,0 +1,48 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker Threads +--> +<head> + <title>Test for DOM Worker Threads</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("timeoutTracing_worker.js"); + + worker.onmessage = function(event) { + // begin + worker.onmessage = null; + + // 1 second should be enough to crash. + window.setTimeout(function(event) { + ok(true, "Didn't crash!"); + SimpleTest.finish(); + }, 1000); + + var os = SpecialPowers.Cc["@mozilla.org/observer-service;1"] + .getService(SpecialPowers.Ci.nsIObserverService); + os.notifyObservers(null, "memory-pressure", "heap-minimize"); + } + + worker.onerror = function(event) { + ok(false, "I was expecting a crash, not an error"); + SimpleTest.finish(); + }; + + SimpleTest.waitForExplicitFinish(); + SimpleTest.requestFlakyTimeout("untriaged"); + +</script> +</pre> +</body> +</html> + diff --git a/dom/workers/test/test_transferable.html b/dom/workers/test/test_transferable.html new file mode 100644 index 000000000..a3deec12a --- /dev/null +++ b/dom/workers/test/test_transferable.html @@ -0,0 +1,123 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<!-- +Tests of DOM Worker transferable objects +--> +<head> + <title>Test for DOM Worker transferable objects</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + function test1(sizes) { + if (!sizes.length) { + runTests(); + return; + } + + var size = sizes.pop(); + + var worker = new Worker("transferable_worker.js"); + worker.onmessage = function(event) { + ok(event.data.status, event.data.event); + if (!event.data.status) { + runTests(); + return; + } + + if ("notEmpty" in event.data && "byteLength" in event.data.notEmpty) { + ok(event.data.notEmpty.byteLength != 0, + "P: NotEmpty object received: " + event.data.notEmpty.byteLength); + } + + if (!event.data.last) + return; + + test1(sizes); + } + worker.onerror = function(event) { + ok(false, "No errors!"); + } + + try { + worker.postMessage(42, true); + ok(false, "P: PostMessage - Exception for wrong type"); + } catch(e) { + ok(true, "P: PostMessage - Exception for wrong type"); + } + + try { + ab = new ArrayBuffer(size); + worker.postMessage(42,[ab, ab]); + ok(false, "P: PostMessage - Exception for duplicate"); + } catch(e) { + ok(true, "P: PostMessage - Exception for duplicate"); + } + + var ab = new ArrayBuffer(size); + ok(ab.byteLength == size, "P: The size is: " + size + " == " + ab.byteLength); + worker.postMessage({ data: 0, timeout: 0, ab: ab, cb: ab, size: size }, [ab]); + ok(ab.byteLength == 0, "P: PostMessage - The size is: 0 == " + ab.byteLength) + } + + function test2() { + var worker = new Worker("transferable_worker.js"); + worker.onmessage = function(event) { + ok(event.data.status, event.data.event); + if (!event.data.status) { + runTests(); + return; + } + + if ("notEmpty" in event.data && "byteLength" in event.data.notEmpty) { + ok(event.data.notEmpty.byteLength != 0, + "P: NotEmpty object received: " + event.data.notEmpty.byteLength); + } + + if (event.data.last) { + runTests(); + } + } + worker.onerror = function(event) { + ok(false, "No errors!"); + } + + var f = new Float32Array([0,1,2,3]); + ok(f.byteLength != 0, "P: The size is: " + f.byteLength + " is not 0"); + worker.postMessage({ event: "P: postMessage with Float32Array", status: true, + size: 4, notEmpty: f, bc: [ f, f, { dd: f } ] }, [f.buffer]); + ok(f.byteLength == 0, "P: The size is: " + f.byteLength + " is 0"); + } + + var tests = [ + function() { test1([1024 * 1024 * 32, 128, 4]); }, + test2 + ]; + function runTests() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + SimpleTest.waitForExplicitFinish(); + runTests(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_webSocket_sharedWorker.html b/dom/workers/test/test_webSocket_sharedWorker.html new file mode 100644 index 000000000..7609a164b --- /dev/null +++ b/dom/workers/test/test_webSocket_sharedWorker.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for bug 1090183</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + +<script class="testbody" type="text/javascript"> + +var sw = new SharedWorker('webSocket_sharedWorker.js'); +sw.port.onmessage = function(event) { + if (event.data.type == 'finish') { + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } +} + +SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket1.html b/dom/workers/test/test_websocket1.html new file mode 100644 index 000000000..6c74af03c --- /dev/null +++ b/dom/workers/test/test_websocket1.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<pre id="feedback"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_worker1.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "event.target should be a worker!"); + + if (event.data.type == 'finish') { + info("All done!"); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } else if (event.data.type == 'feedback') { + info(event.data.msg); + document.getElementById('feedback').innerHTML += event.data.msg + "\n"; + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + info("error!"); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + worker.postMessage('foobar'); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket2.html b/dom/workers/test/test_websocket2.html new file mode 100644 index 000000000..d774be5a2 --- /dev/null +++ b/dom/workers/test/test_websocket2.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<pre id="feedback"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_worker2.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "event.target should be a worker!"); + + if (event.data.type == 'finish') { + info("All done!"); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } else if (event.data.type == 'feedback') { + info(event.data.msg); + document.getElementById('feedback').innerHTML += event.data.msg + "\n"; + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + info("error!"); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + worker.postMessage('foobar'); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket3.html b/dom/workers/test/test_websocket3.html new file mode 100644 index 000000000..0882cf313 --- /dev/null +++ b/dom/workers/test/test_websocket3.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<pre id="feedback"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_worker3.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "event.target should be a worker!"); + + if (event.data.type == 'finish') { + info("All done!"); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } else if (event.data.type == 'feedback') { + info(event.data.msg); + document.getElementById('feedback').innerHTML += event.data.msg + "\n"; + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + info("error!"); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + worker.postMessage('foobar'); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket4.html b/dom/workers/test/test_websocket4.html new file mode 100644 index 000000000..8c6bef506 --- /dev/null +++ b/dom/workers/test/test_websocket4.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<pre id="feedback"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_worker4.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "event.target should be a worker!"); + + if (event.data.type == 'finish') { + info("All done!"); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } else if (event.data.type == 'feedback') { + info(event.data.msg); + document.getElementById('feedback').innerHTML += event.data.msg + "\n"; + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + info("error!"); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + worker.postMessage('foobar'); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket5.html b/dom/workers/test/test_websocket5.html new file mode 100644 index 000000000..cadae3782 --- /dev/null +++ b/dom/workers/test/test_websocket5.html @@ -0,0 +1,46 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<pre id="feedback"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_worker5.js"); + + worker.onmessage = function(event) { + is(event.target, worker, "event.target should be a worker!"); + + if (event.data.type == 'finish') { + info("All done!"); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } else if (event.data.type == 'feedback') { + info(event.data.msg); + document.getElementById('feedback').innerHTML += event.data.msg + "\n"; + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + info("error!"); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + worker.postMessage('foobar'); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket_basic.html b/dom/workers/test/test_websocket_basic.html new file mode 100644 index 000000000..5c9f8bf10 --- /dev/null +++ b/dom/workers/test/test_websocket_basic.html @@ -0,0 +1,57 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_basic_worker.js"); + + worker.onmessage = function(event) { + is(event.target, worker); + + if (event.data.type == 'finish') { + runTest(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + var tests = [ + function() { worker.postMessage(0); }, + function() { worker.postMessage(1); } + ]; + + function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + runTest(); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_websocket_https.html b/dom/workers/test/test_websocket_https.html new file mode 100644 index 000000000..aa94141fd --- /dev/null +++ b/dom/workers/test/test_websocket_https.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test that creating insecure websockets from https workers is not possible</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script class="testbody" language="javascript"> + + onmessage = function(event) { + is(event.data, "not created", "WebSocket object must not be created"); + SimpleTest.finish(); + }; + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +<iframe src="https://example.com/tests/dom/workers/test/websocket_https.html"></iframe> +</body> +</html> diff --git a/dom/workers/test/test_websocket_loadgroup.html b/dom/workers/test/test_websocket_loadgroup.html new file mode 100644 index 000000000..3c65e262b --- /dev/null +++ b/dom/workers/test/test_websocket_loadgroup.html @@ -0,0 +1,61 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> +<head> + <title>Test for WebSocket object in workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"></div> +<pre id="test"></pre> +<script class="testbody" type="text/javascript"> + + var worker = new Worker("websocket_loadgroup_worker.js"); + + var stopped = false; + worker.onmessage = function(e) { + if (e.data == 'opened') { + stopped = true; + window.stop(); + } else if (e.data == 'closed') { + ok(stopped, "Good!"); + stopped = false; + runTest(); + } else { + ok(false, "An error has been received"); + } + }; + + worker.onerror = function(event) { + is(event.target, worker); + ok(false, "Worker had an error: " + event.data); + SimpleTest.finish(); + }; + + var tests = [ + function() { worker.postMessage(0); }, + function() { worker.postMessage(1); } + ]; + + function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); + } + + runTest(); + SimpleTest.waitForExplicitFinish(); + +</script> +</pre> +</body> +</html> diff --git a/dom/workers/test/test_worker_interfaces.html b/dom/workers/test/test_worker_interfaces.html new file mode 100644 index 000000000..26af63e51 --- /dev/null +++ b/dom/workers/test/test_worker_interfaces.html @@ -0,0 +1,16 @@ +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +<!DOCTYPE HTML> +<html> +<head> + <title>Validate Interfaces Exposed to Workers</title> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="text/javascript" src="worker_driver.js"></script> +</head> +<body> +<script class="testbody" type="text/javascript"> +workerTestExec("test_worker_interfaces.js"); +</script> +</body> +</html> diff --git a/dom/workers/test/test_worker_interfaces.js b/dom/workers/test/test_worker_interfaces.js new file mode 100644 index 000000000..e0647682c --- /dev/null +++ b/dom/workers/test/test_worker_interfaces.js @@ -0,0 +1,291 @@ +// This is a list of all interfaces that are exposed to workers. +// Please only add things to this list with great care and proper review +// from the associated module peers. + +// This file lists global interfaces we want exposed and verifies they +// are what we intend. Each entry in the arrays below can either be a +// simple string with the interface name, or an object with a 'name' +// property giving the interface name as a string, and additional +// properties which qualify the exposure of that interface. For example: +// +// [ +// "AGlobalInterface", +// { name: "ExperimentalThing", release: false }, +// { name: "ReallyExperimentalThing", nightly: true }, +// { name: "DesktopOnlyThing", desktop: true }, +// { name: "FancyControl", xbl: true }, +// { name: "DisabledEverywhere", disabled: true }, +// ]; +// +// See createInterfaceMap() below for a complete list of properties. + +// IMPORTANT: Do not change this list without review from +// a JavaScript Engine peer! +var ecmaGlobals = + [ + "Array", + "ArrayBuffer", + "Boolean", + "DataView", + "Date", + "Error", + "EvalError", + "Float32Array", + "Float64Array", + "Function", + "Infinity", + "Int16Array", + "Int32Array", + "Int8Array", + "InternalError", + {name: "Intl", android: false}, + "Iterator", + "JSON", + "Map", + "Math", + "NaN", + "Number", + "Object", + "Promise", + "Proxy", + "RangeError", + "ReferenceError", + "Reflect", + "RegExp", + "Set", + {name: "SharedArrayBuffer", release: false}, + {name: "SIMD", nightly: true}, + {name: "Atomics", release: false}, + "StopIteration", + "String", + "Symbol", + "SyntaxError", + {name: "TypedObject", nightly: true}, + "TypeError", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray", + "URIError", + "WeakMap", + "WeakSet", + ]; +// IMPORTANT: Do not change the list above without review from +// a JavaScript Engine peer! + +// IMPORTANT: Do not change the list below without review from a DOM peer! +var interfaceNamesInGlobalScope = + [ +// IMPORTANT: Do not change this list without review from a DOM peer! + "Blob", +// IMPORTANT: Do not change this list without review from a DOM peer! + "BroadcastChannel", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Cache", +// IMPORTANT: Do not change this list without review from a DOM peer! + "CacheStorage", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Crypto", +// IMPORTANT: Do not change this list without review from a DOM peer! + "CustomEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DedicatedWorkerGlobalScope", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Directory", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMCursor", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMError", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMException", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "DOMStringList", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Event", +// IMPORTANT: Do not change this list without review from a DOM peer! + "EventTarget", +// IMPORTANT: Do not change this list without review from a DOM peer! + "File", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FileReader", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FileReaderSync", +// IMPORTANT: Do not change this list without review from a DOM peer! + "FormData", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Headers", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBCursor", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBCursorWithValue", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBDatabase", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBFactory", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBIndex", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBKeyRange", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBObjectStore", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBOpenDBRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBTransaction", +// IMPORTANT: Do not change this list without review from a DOM peer! + "IDBVersionChangeEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageBitmap", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageBitmapRenderingContext", +// IMPORTANT: Do not change this list without review from a DOM peer! + "ImageData", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessageChannel", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessageEvent", +// IMPORTANT: Do not change this list without review from a DOM peer! + "MessagePort", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Notification", +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "OffscreenCanvas", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + "Performance", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceEntry", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceMark", +// IMPORTANT: Do not change this list without review from a DOM peer! + "PerformanceMeasure", +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "PerformanceObserver", nightly: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "PerformanceObserverEntryList", nightly: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + "Request", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Response", +// IMPORTANT: Do not change this list without review from a DOM peer! + {name: "StorageManager", nightly: true}, +// IMPORTANT: Do not change this list without review from a DOM peer! + "SubtleCrypto", +// IMPORTANT: Do not change this list without review from a DOM peer! + "TextDecoder", +// IMPORTANT: Do not change this list without review from a DOM peer! + "TextEncoder", +// IMPORTANT: Do not change this list without review from a DOM peer! + "XMLHttpRequest", +// IMPORTANT: Do not change this list without review from a DOM peer! + "XMLHttpRequestEventTarget", +// IMPORTANT: Do not change this list without review from a DOM peer! + "XMLHttpRequestUpload", +// IMPORTANT: Do not change this list without review from a DOM peer! + "URL", +// IMPORTANT: Do not change this list without review from a DOM peer! + "URLSearchParams", +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLActiveInfo", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLBuffer", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLContextEvent", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLFramebuffer", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLProgram", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLRenderbuffer", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLRenderingContext", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLShader", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLShaderPrecisionFormat", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLTexture", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + { name: "WebGLUniformLocation", disabled: true }, +// IMPORTANT: Do not change this list without review from a DOM peer! + "WebSocket", +// IMPORTANT: Do not change this list without review from a DOM peer! + "Worker", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerGlobalScope", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerLocation", +// IMPORTANT: Do not change this list without review from a DOM peer! + "WorkerNavigator", +// IMPORTANT: Do not change this list without review from a DOM peer! + ]; +// IMPORTANT: Do not change the list above without review from a DOM peer! + +function createInterfaceMap(version, userAgent) { + var isNightly = version.endsWith("a1"); + var isRelease = !version.includes("a"); + var isDesktop = !/Mobile|Tablet/.test(userAgent); + var isAndroid = !!navigator.userAgent.includes("Android"); + + var interfaceMap = {}; + + function addInterfaces(interfaces) + { + for (var entry of interfaces) { + if (typeof(entry) === "string") { + interfaceMap[entry] = true; + } else { + ok(!("pref" in entry), "Bogus pref annotation for " + entry.name); + if ((entry.nightly === !isNightly) || + (entry.nightlyAndroid === !(isAndroid && isNightly) && isAndroid) || + (entry.desktop === !isDesktop) || + (entry.android === !isAndroid && !entry.nightlyAndroid) || + (entry.release === !isRelease) || + entry.disabled) { + interfaceMap[entry.name] = false; + } else { + interfaceMap[entry.name] = true; + } + } + } + } + + addInterfaces(ecmaGlobals); + addInterfaces(interfaceNamesInGlobalScope); + + return interfaceMap; +} + +function runTest(version, userAgent) { + var interfaceMap = createInterfaceMap(version, userAgent); + for (var name of Object.getOwnPropertyNames(self)) { + // An interface name should start with an upper case character. + if (!/^[A-Z]/.test(name)) { + continue; + } + ok(interfaceMap[name], + "If this is failing: DANGER, are you sure you want to expose the new interface " + name + + " to all webpages as a property on the worker? Do not make a change to this file without a " + + " review from a DOM peer for that specific change!!! (or a JS peer for changes to ecmaGlobals)"); + delete interfaceMap[name]; + } + for (var name of Object.keys(interfaceMap)) { + ok(name in self === interfaceMap[name], + name + " should " + (interfaceMap[name] ? "" : " NOT") + " be defined on the global scope"); + if (!interfaceMap[name]) { + delete interfaceMap[name]; + } + } + is(Object.keys(interfaceMap).length, 0, + "The following interface(s) are not enumerated: " + Object.keys(interfaceMap).join(", ")); +} + +workerTestGetVersion(function(version) { + workerTestGetUserAgent(function(userAgent) { + runTest(version, userAgent); + workerTestDone(); + }); +}); diff --git a/dom/workers/test/test_workersDisabled.html b/dom/workers/test/test_workersDisabled.html new file mode 100644 index 000000000..39a7fcc5b --- /dev/null +++ b/dom/workers/test/test_workersDisabled.html @@ -0,0 +1,54 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"> + </script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <script type="text/javascript"> + SimpleTest.waitForExplicitFinish(); + + const enabledPref = "dom.workers.enabled"; + + is(SpecialPowers.getBoolPref(enabledPref), true, + "Workers should be enabled."); + + SpecialPowers.pushPrefEnv({"set": [[enabledPref, false]]}, test1); + + function test1() { + ok(!("Worker" in window), "Worker constructor should not be available."); + + var exception; + try { + var worker = new Worker("workersDisabled_worker.js"); + } + catch(e) { + exception = e; + } + + ok(exception, "Shouldn't be able to make a worker."); + + SpecialPowers.pushPrefEnv({"set": [[enabledPref, true]]}, test2); + } + + function test2() { + ok(("Worker" in window), "Worker constructor should be available."); + + const message = "Hi"; + + var worker = new Worker("workersDisabled_worker.js"); + worker.onmessage = function(event) { + is(event.data, message, "Good message."); + SimpleTest.finish(); + } + worker.postMessage(message); + } + </script> + </body> +</html> + diff --git a/dom/workers/test/test_workersDisabled.xul b/dom/workers/test/test_workersDisabled.xul new file mode 100644 index 000000000..1674f819f --- /dev/null +++ b/dom/workers/test/test_workersDisabled.xul @@ -0,0 +1,49 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="DOM Worker Threads Test" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + <script type="application/javascript" + src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script type="application/javascript" src="dom_worker_helper.js"/> + + <script type="application/javascript"> + <![CDATA[ + function test() + { + const enabledPref = "dom.workers.enabled"; + const message = "Hi"; + + var prefs = Components.classes["@mozilla.org/preferences-service;1"] + .getService(Components.interfaces.nsIPrefBranch); + is(prefs.getBoolPref(enabledPref), true, "Workers should be enabled."); + + prefs.setBoolPref(enabledPref, false); + + ok("Worker" in window, "Worker constructor should be available."); + ok("ChromeWorker" in window, + "ChromeWorker constructor should be available."); + + var worker = new ChromeWorker("workersDisabled_worker.js"); + worker.onmessage = function(event) { + is(event.data, message, "Good message."); + prefs.clearUserPref(enabledPref); + finish(); + } + worker.postMessage(message); + + waitForWorkerFinish(); + } + ]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/dom/workers/test/threadErrors_worker1.js b/dom/workers/test/threadErrors_worker1.js new file mode 100644 index 000000000..c0ddade82 --- /dev/null +++ b/dom/workers/test/threadErrors_worker1.js @@ -0,0 +1,8 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Syntax error +onmessage = function(event) { + for (var i = 0; i < 10) { } +} diff --git a/dom/workers/test/threadErrors_worker2.js b/dom/workers/test/threadErrors_worker2.js new file mode 100644 index 000000000..0462d9668 --- /dev/null +++ b/dom/workers/test/threadErrors_worker2.js @@ -0,0 +1,8 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Bad function error +onmessage = function(event) { + foopy(); +} diff --git a/dom/workers/test/threadErrors_worker3.js b/dom/workers/test/threadErrors_worker3.js new file mode 100644 index 000000000..151ffbe5e --- /dev/null +++ b/dom/workers/test/threadErrors_worker3.js @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Unhandled exception in body +onmessage = function(event) { +}; + +throw new Error("Bah!"); diff --git a/dom/workers/test/threadErrors_worker4.js b/dom/workers/test/threadErrors_worker4.js new file mode 100644 index 000000000..4518ce017 --- /dev/null +++ b/dom/workers/test/threadErrors_worker4.js @@ -0,0 +1,8 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +// Throwing message listener +onmessage = function(event) { + throw new Error("Bah!"); +}; diff --git a/dom/workers/test/threadTimeouts_worker.js b/dom/workers/test/threadTimeouts_worker.js new file mode 100644 index 000000000..7aaac03d2 --- /dev/null +++ b/dom/workers/test/threadTimeouts_worker.js @@ -0,0 +1,44 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +var gTimeoutId; +var gTimeoutCount = 0; +var gIntervalCount = 0; + +function timeoutFunc() { + if (++gTimeoutCount > 1) { + throw new Error("Timeout called more than once!"); + } + postMessage("timeoutFinished"); +} + +function intervalFunc() { + if (++gIntervalCount == 2) { + postMessage("intervalFinished"); + } +} + +function messageListener(event) { + switch (event.data) { + case "startTimeout": + gTimeoutId = setTimeout(timeoutFunc, 2000); + clearTimeout(gTimeoutId); + gTimeoutId = setTimeout(timeoutFunc, 2000); + break; + case "startInterval": + gTimeoutId = setInterval(intervalFunc, 2000); + break; + case "cancelInterval": + clearInterval(gTimeoutId); + postMessage("intervalCanceled"); + break; + case "startExpression": + setTimeout("this.postMessage('expressionFinished');", 2000); + break; + default: + throw "Bad message: " + event.data; + } +} + +addEventListener("message", messageListener, false); diff --git a/dom/workers/test/throwingOnerror_worker.js b/dom/workers/test/throwingOnerror_worker.js new file mode 100644 index 000000000..07e01787b --- /dev/null +++ b/dom/workers/test/throwingOnerror_worker.js @@ -0,0 +1,15 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onerror = function(event) { + throw "bar"; +}; + +var count = 0; +onmessage = function(event) { + if (!count++) { + throw "foo"; + } + postMessage(""); +}; diff --git a/dom/workers/test/timeoutTracing_worker.js b/dom/workers/test/timeoutTracing_worker.js new file mode 100644 index 000000000..d62cc50c5 --- /dev/null +++ b/dom/workers/test/timeoutTracing_worker.js @@ -0,0 +1,13 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +onmessage = function(event) { + throw "No messages should reach me!"; +} + +setInterval(function() { postMessage("Still alive!"); }, 20); +setInterval(";", 20); + +postMessage("Begin!"); diff --git a/dom/workers/test/transferable_worker.js b/dom/workers/test/transferable_worker.js new file mode 100644 index 000000000..3caf6121b --- /dev/null +++ b/dom/workers/test/transferable_worker.js @@ -0,0 +1,23 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +onmessage = function(event) { + if ("notEmpty" in event.data && "byteLength" in event.data.notEmpty) { + postMessage({ event: "W: NotEmpty object received: " + event.data.notEmpty.byteLength, + status: event.data.notEmpty.byteLength != 0, last: false }); + } + + var ab = new ArrayBuffer(event.data.size); + postMessage({ event: "W: The size is: " + event.data.size + " == " + ab.byteLength, + status: ab.byteLength == event.data.size, last: false }); + + postMessage({ event: "W: postMessage with arrayBuffer", status: true, + notEmpty: ab, ab: ab, bc: [ ab, ab, { dd: ab } ] }, [ab]); + + postMessage({ event: "W: The size is: 0 == " + ab.byteLength, + status: ab.byteLength == 0, last: false }); + + postMessage({ event: "W: last one!", status: true, last: true }); +} diff --git a/dom/workers/test/webSocket_sharedWorker.js b/dom/workers/test/webSocket_sharedWorker.js new file mode 100644 index 000000000..7c8fa0e12 --- /dev/null +++ b/dom/workers/test/webSocket_sharedWorker.js @@ -0,0 +1,20 @@ +onconnect = function(evt) { + var ws = new WebSocket("ws://mochi.test:8888/tests/dom/base/test/file_websocket_hello"); + + ws.onopen = function(e) { + evt.ports[0].postMessage({type: 'status', status: true, msg: 'OnOpen called' }); + ws.send("data"); + } + + ws.onclose = function(e) {} + + ws.onerror = function(e) { + evt.ports[0].postMessage({type: 'status', status: false, msg: 'onerror called!'}); + } + + ws.onmessage = function(e) { + evt.ports[0].postMessage({type: 'status', status: e.data == 'Hello world!', msg: 'Wrong data'}); + ws.close(); + evt.ports[0].postMessage({type: 'finish' }); + } +} diff --git a/dom/workers/test/websocket_basic_worker.js b/dom/workers/test/websocket_basic_worker.js new file mode 100644 index 000000000..256af569a --- /dev/null +++ b/dom/workers/test/websocket_basic_worker.js @@ -0,0 +1,39 @@ +onmessage = function(event) { + if (event.data != 0) { + var worker = new Worker('websocket_basic_worker.js'); + worker.onmessage = function(event) { + postMessage(event.data); + } + + worker.postMessage(event.data - 1); + return; + } + + status = false; + try { + if ((WebSocket instanceof Object)) { + status = true; + } + } catch(e) { + } + + postMessage({type: 'status', status: status, msg: 'WebSocket object:' + WebSocket}); + + var ws = new WebSocket("ws://mochi.test:8888/tests/dom/base/test/file_websocket_hello"); + ws.onopen = function(e) { + postMessage({type: 'status', status: true, msg: 'OnOpen called' }); + ws.send("data"); + } + + ws.onclose = function(e) {} + + ws.onerror = function(e) { + postMessage({type: 'status', status: false, msg: 'onerror called!'}); + } + + ws.onmessage = function(e) { + postMessage({type: 'status', status: e.data == 'Hello world!', msg: 'Wrong data'}); + ws.close(); + postMessage({type: 'finish' }); + } +} diff --git a/dom/workers/test/websocket_helpers.js b/dom/workers/test/websocket_helpers.js new file mode 100644 index 000000000..c2dc3f969 --- /dev/null +++ b/dom/workers/test/websocket_helpers.js @@ -0,0 +1,19 @@ +function feedback() { + postMessage({type: 'feedback', msg: "executing test: " + (current_test+1) + " of " + tests.length + " tests." }); +} + +function ok(status, msg) { + postMessage({type: 'status', status: !!status, msg: msg}); +} + +function is(a, b, msg) { + ok(a === b, msg); +} + +function isnot(a, b, msg) { + ok(a != b, msg); +} + +function finish() { + postMessage({type: 'finish'}); +} diff --git a/dom/workers/test/websocket_https.html b/dom/workers/test/websocket_https.html new file mode 100644 index 000000000..549147a33 --- /dev/null +++ b/dom/workers/test/websocket_https.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<script> + var worker = new Worker("https://example.com/tests/dom/workers/test/websocket_https_worker.js"); + + worker.onmessage = function(event) { + parent.postMessage(event.data, "*"); + }; + + worker.onerror = function(event) { + parent.postMessage("error", "*"); + }; + + worker.postMessage("start"); +</script> diff --git a/dom/workers/test/websocket_https_worker.js b/dom/workers/test/websocket_https_worker.js new file mode 100644 index 000000000..2592ed6d0 --- /dev/null +++ b/dom/workers/test/websocket_https_worker.js @@ -0,0 +1,9 @@ +onmessage = function() { + var wsCreated = true; + try { + new WebSocket("ws://mochi.test:8888/tests/dom/base/test/file_websocket_hello"); + } catch(e) { + wsCreated = false; + } + postMessage(wsCreated ? "created" : "not created"); +}; diff --git a/dom/workers/test/websocket_loadgroup_worker.js b/dom/workers/test/websocket_loadgroup_worker.js new file mode 100644 index 000000000..21cf248bc --- /dev/null +++ b/dom/workers/test/websocket_loadgroup_worker.js @@ -0,0 +1,24 @@ +onmessage = function(event) { + if (event.data != 0) { + var worker = new Worker('websocket_loadgroup_worker.js'); + worker.onmessage = function(event) { + postMessage(event.data); + } + + worker.postMessage(event.data - 1); + return; + } + + var ws = new WebSocket("ws://mochi.test:8888/tests/dom/base/test/file_websocket_hello"); + ws.onopen = function(e) { + postMessage('opened'); + } + + ws.onclose = function(e) { + postMessage('closed'); + } + + ws.onerror = function(e) { + postMessage('error'); + } +} diff --git a/dom/workers/test/websocket_worker1.js b/dom/workers/test/websocket_worker1.js new file mode 100644 index 000000000..cc2b6e825 --- /dev/null +++ b/dom/workers/test/websocket_worker1.js @@ -0,0 +1,19 @@ +importScripts('../../../dom/base/test/websocket_helpers.js'); +importScripts('../../../dom/base/test/websocket_tests.js'); +importScripts('websocket_helpers.js'); + +var tests = [ + test1, // client tries to connect to a http scheme location; + test2, // assure serialization of the connections; + test3, // client tries to connect to an non-existent ws server; + test4, // client tries to connect using a relative url; + test5, // client uses an invalid protocol value; + test6, // counter and encoding check; + test7, // onmessage event origin property check + test8, // client calls close() and the server sends the close frame (with no + // code or reason) in acknowledgement; + test9, // client closes the connection before the ws connection is established; + test10, // client sends a message before the ws connection is established; +]; + +doTest(); diff --git a/dom/workers/test/websocket_worker2.js b/dom/workers/test/websocket_worker2.js new file mode 100644 index 000000000..9dd4ae685 --- /dev/null +++ b/dom/workers/test/websocket_worker2.js @@ -0,0 +1,19 @@ +importScripts('../../../dom/base/test/websocket_helpers.js'); +importScripts('../../../dom/base/test/websocket_tests.js'); +importScripts('websocket_helpers.js'); + +var tests = [ + test11, // a simple hello echo; + test12, // client sends a message containing unpaired surrogates + test13, //server sends an invalid message; + test14, // server sends the close frame, it doesn't close the tcp connection + // and it keeps sending normal ws messages; + test15, // server closes the tcp connection, but it doesn't send the close + // frame; + test16, // client calls close() and tries to send a message; + test18, // client tries to connect to an http resource; + test19, // server closes the tcp connection before establishing the ws + // connection; +]; + +doTest(); diff --git a/dom/workers/test/websocket_worker3.js b/dom/workers/test/websocket_worker3.js new file mode 100644 index 000000000..d2811294f --- /dev/null +++ b/dom/workers/test/websocket_worker3.js @@ -0,0 +1,17 @@ +importScripts('../../../dom/base/test/websocket_helpers.js'); +importScripts('../../../dom/base/test/websocket_tests.js'); +importScripts('websocket_helpers.js'); + +var tests = [ + test24, // server rejects sub-protocol string + test25, // ctor with valid empty sub-protocol array + test26, // ctor with invalid sub-protocol array containing 1 empty element + test27, // ctor with invalid sub-protocol array containing an empty element in + // list + test28, // ctor using valid 1 element sub-protocol array + test29, // ctor using all valid 5 element sub-protocol array + test30, // ctor using valid 1 element sub-protocol array with element server + // will reject +]; + +doTest(); diff --git a/dom/workers/test/websocket_worker4.js b/dom/workers/test/websocket_worker4.js new file mode 100644 index 000000000..030ee67f5 --- /dev/null +++ b/dom/workers/test/websocket_worker4.js @@ -0,0 +1,19 @@ +importScripts('../../../dom/base/test/websocket_helpers.js'); +importScripts('../../../dom/base/test/websocket_tests.js'); +importScripts('websocket_helpers.js'); + +var tests = [ + test31, // ctor using valid 2 element sub-protocol array with 1 element server + // will reject and one server will accept + test32, // ctor using invalid sub-protocol array that contains duplicate items + test33, // test for sending/receiving custom close code (but no close reason) + test34, // test for receiving custom close code and reason + test35, // test for sending custom close code and reason + test36, // negative test for sending out of range close code + test37, // negative test for too long of a close reason + test38, // ensure extensions attribute is defined + test39, // a basic wss:// connectivity test + test40, // negative test for wss:// with no cert +]; + +doTest(); diff --git a/dom/workers/test/websocket_worker5.js b/dom/workers/test/websocket_worker5.js new file mode 100644 index 000000000..41d6e9be0 --- /dev/null +++ b/dom/workers/test/websocket_worker5.js @@ -0,0 +1,13 @@ +importScripts('../../../dom/base/test/websocket_helpers.js'); +importScripts('../../../dom/base/test/websocket_tests.js'); +importScripts('websocket_helpers.js'); + +var tests = [ + test42, // non-char utf-8 sequences + test43, // Test setting binaryType attribute + test44, // Test sending/receving binary ArrayBuffer + test46, // Test that we don't dispatch incoming msgs once in CLOSING state + test47, // Make sure onerror/onclose aren't called during close() +]; + +doTest(); diff --git a/dom/workers/test/window_suspended.html b/dom/workers/test/window_suspended.html new file mode 100644 index 000000000..b482cbe09 --- /dev/null +++ b/dom/workers/test/window_suspended.html @@ -0,0 +1,5 @@ +<script> +onpageshow = function(e) { + opener[location.search.split('?')[1]](e); +} +</script> diff --git a/dom/workers/test/worker_bug1278777.js b/dom/workers/test/worker_bug1278777.js new file mode 100644 index 000000000..c056d0254 --- /dev/null +++ b/dom/workers/test/worker_bug1278777.js @@ -0,0 +1,9 @@ +var xhr = new XMLHttpRequest(); +xhr.responseType = 'blob'; +xhr.open('GET', 'worker_bug1278777.js'); + +xhr.onload = function() { + postMessage(xhr.response instanceof Blob); +} + +xhr.send(); diff --git a/dom/workers/test/worker_bug1301094.js b/dom/workers/test/worker_bug1301094.js new file mode 100644 index 000000000..69cc25d23 --- /dev/null +++ b/dom/workers/test/worker_bug1301094.js @@ -0,0 +1,11 @@ +onmessage = function(e) { + var xhr = new XMLHttpRequest(); + xhr.open("POST", 'worker_bug1301094.js', false); + xhr.onload = function() { + self.postMessage("OK"); + }; + + var fd = new FormData(); + fd.append('file', e.data); + xhr.send(fd); +} diff --git a/dom/workers/test/worker_consoleAndBlobs.js b/dom/workers/test/worker_consoleAndBlobs.js new file mode 100644 index 000000000..41e8317ac --- /dev/null +++ b/dom/workers/test/worker_consoleAndBlobs.js @@ -0,0 +1,8 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +var b = new Blob(['123'], { type: 'foo/bar'}); +console.log({ msg: 'consoleAndBlobs', blob: b }); diff --git a/dom/workers/test/worker_driver.js b/dom/workers/test/worker_driver.js new file mode 100644 index 000000000..35eb17985 --- /dev/null +++ b/dom/workers/test/worker_driver.js @@ -0,0 +1,64 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// +// Utility script for writing worker tests. In your main document do: +// +// <script type="text/javascript" src="worker_driver.js"></script> +// <script type="text/javascript"> +// workerTestExec('myWorkerTestCase.js') +// </script> +// +// This will then spawn a worker, define some utility functions, and then +// execute the code in myWorkerTestCase.js. You can then use these +// functions in your worker-side test: +// +// ok() - like the SimpleTest assert +// is() - like the SimpleTest assert +// workerTestDone() - like SimpleTest.finish() indicating the test is complete +// +// There are also some functions for requesting information that requires +// SpecialPowers or other main-thread-only resources: +// +// workerTestGetVersion() - request the current version string from the MT +// workerTestGetUserAgent() - request the user agent string from the MT +// workerTestGetOSCPU() - request the navigator.oscpu string from the MT +// +// For an example see test_worker_interfaces.html and test_worker_interfaces.js. + +function workerTestExec(script) { + SimpleTest.waitForExplicitFinish(); + var worker = new Worker('worker_wrapper.js'); + worker.onmessage = function(event) { + if (event.data.type == 'finish') { + SimpleTest.finish(); + + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + + } else if (event.data.type == 'getVersion') { + var result = SpecialPowers.Cc['@mozilla.org/xre/app-info;1'].getService(SpecialPowers.Ci.nsIXULAppInfo).version; + worker.postMessage({ + type: 'returnVersion', + result: result + }); + + } else if (event.data.type == 'getUserAgent') { + worker.postMessage({ + type: 'returnUserAgent', + result: navigator.userAgent + }); + } else if (event.data.type == 'getOSCPU') { + worker.postMessage({ + type: 'returnOSCPU', + result: navigator.oscpu + }); + } + } + + worker.onerror = function(event) { + ok(false, 'Worker had an error: ' + event.data); + SimpleTest.finish(); + }; + + worker.postMessage({ script: script }); +} diff --git a/dom/workers/test/worker_fileReader.js b/dom/workers/test/worker_fileReader.js new file mode 100644 index 000000000..f4e91b325 --- /dev/null +++ b/dom/workers/test/worker_fileReader.js @@ -0,0 +1,417 @@ +var testRanCounter = 0; +var expectedTestCount = 0; +var testSetupFinished = false; + +function ok(a, msg) { + postMessage({type: 'check', status: !!a, msg: msg }); +} + +function is(a, b, msg) { + ok(a === b, msg); +} + +function finish() { + postMessage({type: 'finish'}); +} + +function convertToUTF16(s) { + res = ""; + for (var i = 0; i < s.length; ++i) { + c = s.charCodeAt(i); + res += String.fromCharCode(c & 255, c >>> 8); + } + return res; +} + +function convertToUTF8(s) { + return unescape(encodeURIComponent(s)); +} + +function convertToDataURL(s) { + return "data:application/octet-stream;base64," + btoa(s); +} + +onmessage = function(message) { + is(FileReader.EMPTY, 0, "correct EMPTY value"); + is(FileReader.LOADING, 1, "correct LOADING value"); + is(FileReader.DONE, 2, "correct DONE value"); + + // List of blobs. + var asciiFile = message.data.blobs.shift(); + var binaryFile = message.data.blobs.shift(); + var nonExistingFile = message.data.blobs.shift(); + var utf8TextFile = message.data.blobs.shift(); + var utf16TextFile = message.data.blobs.shift(); + var emptyFile = message.data.blobs.shift(); + var dataUrlFile0 = message.data.blobs.shift(); + var dataUrlFile1 = message.data.blobs.shift(); + var dataUrlFile2 = message.data.blobs.shift(); + + // List of buffers for testing. + var testTextData = message.data.testTextData; + var testASCIIData = message.data.testASCIIData; + var testBinaryData = message.data.testBinaryData; + var dataurldata0 = message.data.dataurldata0; + var dataurldata1 = message.data.dataurldata1; + var dataurldata2 = message.data.dataurldata2; + + // Test that plain reading works and fires events as expected, both + // for text and binary reading + + var onloadHasRunText = false; + var onloadStartHasRunText = false; + r = new FileReader(); + is(r.readyState, FileReader.EMPTY, "correct initial text readyState"); + r.onload = getLoadHandler(testASCIIData, testASCIIData.length, "plain reading"); + r.addEventListener("load", function() { onloadHasRunText = true }, false); + r.addEventListener("loadstart", function() { onloadStartHasRunText = true }, false); + r.readAsText(asciiFile); + is(r.readyState, FileReader.LOADING, "correct loading text readyState"); + is(onloadHasRunText, false, "text loading must be async"); + is(onloadStartHasRunText, true, "text loadstart should fire sync"); + expectedTestCount++; + + var onloadHasRunBinary = false; + var onloadStartHasRunBinary = false; + r = new FileReader(); + is(r.readyState, FileReader.EMPTY, "correct initial binary readyState"); + r.addEventListener("load", function() { onloadHasRunBinary = true }, false); + r.addEventListener("loadstart", function() { onloadStartHasRunBinary = true }, false); + r.readAsBinaryString(binaryFile); + r.onload = getLoadHandler(testBinaryData, testBinaryData.length, "binary reading"); + is(r.readyState, FileReader.LOADING, "correct loading binary readyState"); + is(onloadHasRunBinary, false, "binary loading must be async"); + is(onloadStartHasRunBinary, true, "binary loadstart should fire sync"); + expectedTestCount++; + + var onloadHasRunArrayBuffer = false; + var onloadStartHasRunArrayBuffer = false; + r = new FileReader(); + is(r.readyState, FileReader.EMPTY, "correct initial arrayBuffer readyState"); + r.addEventListener("load", function() { onloadHasRunArrayBuffer = true }, false); + r.addEventListener("loadstart", function() { onloadStartHasRunArrayBuffer = true }, false); + r.readAsArrayBuffer(binaryFile); + r.onload = getLoadHandlerForArrayBuffer(testBinaryData, testBinaryData.length, "array buffer reading"); + is(r.readyState, FileReader.LOADING, "correct loading arrayBuffer readyState"); + is(onloadHasRunArrayBuffer, false, "arrayBuffer loading must be async"); + is(onloadStartHasRunArrayBuffer, true, "arrayBuffer loadstart should fire sync"); + expectedTestCount++; + + // Test a variety of encodings, and make sure they work properly + r = new FileReader(); + r.onload = getLoadHandler(testASCIIData, testASCIIData.length, "no encoding reading"); + r.readAsText(asciiFile, ""); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler(testASCIIData, testASCIIData.length, "iso8859 reading"); + r.readAsText(asciiFile, "iso-8859-1"); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler(testTextData, + convertToUTF8(testTextData).length, + "utf8 reading"); + r.readAsText(utf8TextFile, "utf8"); + expectedTestCount++; + + r = new FileReader(); + r.readAsText(utf16TextFile, "utf-16"); + r.onload = getLoadHandler(testTextData, + convertToUTF16(testTextData).length, + "utf16 reading"); + expectedTestCount++; + + // Test get result without reading + r = new FileReader(); + is(r.readyState, FileReader.EMPTY, + "readyState in test reader get result without reading"); + is(r.error, null, + "no error in test reader get result without reading"); + is(r.result, null, + "result in test reader get result without reading"); + + // Test loading an empty file works (and doesn't crash!) + r = new FileReader(); + r.onload = getLoadHandler("", 0, "empty no encoding reading"); + r.readAsText(emptyFile, ""); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler("", 0, "empty utf8 reading"); + r.readAsText(emptyFile, "utf8"); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler("", 0, "empty utf16 reading"); + r.readAsText(emptyFile, "utf-16"); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler("", 0, "empty binary string reading"); + r.readAsBinaryString(emptyFile); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandlerForArrayBuffer("", 0, "empty array buffer reading"); + r.readAsArrayBuffer(emptyFile); + expectedTestCount++; + + r = new FileReader(); + r.onload = getLoadHandler(convertToDataURL(""), 0, "empt binary string reading"); + r.readAsDataURL(emptyFile); + expectedTestCount++; + + // Test reusing a FileReader to read multiple times + r = new FileReader(); + r.onload = getLoadHandler(testASCIIData, + testASCIIData.length, + "to-be-reused reading text") + var makeAnotherReadListener = function(event) { + r = event.target; + r.removeEventListener("load", makeAnotherReadListener, false); + r.onload = getLoadHandler(testASCIIData, + testASCIIData.length, + "reused reading text"); + r.readAsText(asciiFile); + }; + r.addEventListener("load", makeAnotherReadListener, false); + r.readAsText(asciiFile); + expectedTestCount += 2; + + r = new FileReader(); + r.onload = getLoadHandler(testBinaryData, + testBinaryData.length, + "to-be-reused reading binary") + var makeAnotherReadListener2 = function(event) { + r = event.target; + r.removeEventListener("load", makeAnotherReadListener2, false); + r.onload = getLoadHandler(testBinaryData, + testBinaryData.length, + "reused reading binary"); + r.readAsBinaryString(binaryFile); + }; + r.addEventListener("load", makeAnotherReadListener2, false); + r.readAsBinaryString(binaryFile); + expectedTestCount += 2; + + r = new FileReader(); + r.onload = getLoadHandler(convertToDataURL(testBinaryData), + testBinaryData.length, + "to-be-reused reading data url") + var makeAnotherReadListener3 = function(event) { + r = event.target; + r.removeEventListener("load", makeAnotherReadListener3, false); + r.onload = getLoadHandler(convertToDataURL(testBinaryData), + testBinaryData.length, + "reused reading data url"); + r.readAsDataURL(binaryFile); + }; + r.addEventListener("load", makeAnotherReadListener3, false); + r.readAsDataURL(binaryFile); + expectedTestCount += 2; + + r = new FileReader(); + r.onload = getLoadHandlerForArrayBuffer(testBinaryData, + testBinaryData.length, + "to-be-reused reading arrayBuffer") + var makeAnotherReadListener4 = function(event) { + r = event.target; + r.removeEventListener("load", makeAnotherReadListener4, false); + r.onload = getLoadHandlerForArrayBuffer(testBinaryData, + testBinaryData.length, + "reused reading arrayBuffer"); + r.readAsArrayBuffer(binaryFile); + }; + r.addEventListener("load", makeAnotherReadListener4, false); + r.readAsArrayBuffer(binaryFile); + expectedTestCount += 2; + + // Test first reading as ArrayBuffer then read as something else + // (BinaryString) and doesn't crash + r = new FileReader(); + r.onload = getLoadHandlerForArrayBuffer(testBinaryData, + testBinaryData.length, + "to-be-reused reading arrayBuffer") + var makeAnotherReadListener5 = function(event) { + r = event.target; + r.removeEventListener("load", makeAnotherReadListener5, false); + r.onload = getLoadHandler(testBinaryData, + testBinaryData.length, + "reused reading binary string"); + r.readAsBinaryString(binaryFile); + }; + r.addEventListener("load", makeAnotherReadListener5, false); + r.readAsArrayBuffer(binaryFile); + expectedTestCount += 2; + + //Test data-URI encoding on differing file sizes + is(dataurldata0.length % 3, 0, "Want to test data with length % 3 == 0"); + r = new FileReader(); + r.onload = getLoadHandler(convertToDataURL(dataurldata0), + dataurldata0.length, + "dataurl reading, %3 = 0"); + r.readAsDataURL(dataUrlFile0); + expectedTestCount++; + + is(dataurldata1.length % 3, 1, "Want to test data with length % 3 == 1"); + r = new FileReader(); + r.onload = getLoadHandler(convertToDataURL(dataurldata1), + dataurldata1.length, + "dataurl reading, %3 = 1"); + r.readAsDataURL(dataUrlFile1); + expectedTestCount++; + + is(dataurldata2.length % 3, 2, "Want to test data with length % 3 == 2"); + r = new FileReader(); + r.onload = getLoadHandler(convertToDataURL(dataurldata2), + dataurldata2.length, + "dataurl reading, %3 = 2"); + r.readAsDataURL(dataUrlFile2), + expectedTestCount++; + + + // Test abort() + var abortHasRun = false; + var loadEndHasRun = false; + r = new FileReader(); + r.onabort = function (event) { + is(abortHasRun, false, "abort should only fire once"); + is(loadEndHasRun, false, "loadend shouldn't have fired yet"); + abortHasRun = true; + is(event.target.readyState, FileReader.DONE, "should be DONE while firing onabort"); + is(event.target.error.name, "AbortError", "error set to AbortError for aborted reads"); + is(event.target.result, null, "file data should be null on aborted reads"); + } + r.onloadend = function (event) { + is(abortHasRun, true, "abort should fire before loadend"); + is(loadEndHasRun, false, "loadend should only fire once"); + loadEndHasRun = true; + is(event.target.readyState, FileReader.DONE, "should be DONE while firing onabort"); + is(event.target.error.name, "AbortError", "error set to AbortError for aborted reads"); + is(event.target.result, null, "file data should be null on aborted reads"); + } + r.onload = function() { ok(false, "load should not fire for aborted reads") }; + r.onerror = function() { ok(false, "error should not fire for aborted reads") }; + r.onprogress = function() { ok(false, "progress should not fire for aborted reads") }; + var abortThrew = false; + try { + r.abort(); + } catch(e) { + abortThrew = true; + } + is(abortThrew, true, "abort() must throw if not loading"); + is(abortHasRun, false, "abort() is a no-op unless loading"); + r.readAsText(asciiFile); + r.abort(); + is(abortHasRun, true, "abort should fire sync"); + is(loadEndHasRun, true, "loadend should fire sync"); + + // Test calling readAsX to cause abort() + var reuseAbortHasRun = false; + r = new FileReader(); + r.onabort = function (event) { + is(reuseAbortHasRun, false, "abort should only fire once"); + reuseAbortHasRun = true; + is(event.target.readyState, FileReader.DONE, "should be DONE while firing onabort"); + is(event.target.error.name, "AbortError", "error set to AbortError for aborted reads"); + is(event.target.result, null, "file data should be null on aborted reads"); + } + r.onload = function() { ok(false, "load should not fire for aborted reads") }; + var abortThrew = false; + try { + r.abort(); + } catch(e) { + abortThrew = true; + } + is(abortThrew, true, "abort() must throw if not loading"); + is(reuseAbortHasRun, false, "abort() is a no-op unless loading"); + r.readAsText(asciiFile); + r.readAsText(asciiFile); + is(reuseAbortHasRun, true, "abort should fire sync"); + r.onload = getLoadHandler(testASCIIData, testASCIIData.length, "reuse-as-abort reading"); + expectedTestCount++; + + + // Test reading from nonexistent files + r = new FileReader(); + var didThrow = false; + r.onerror = function (event) { + is(event.target.readyState, FileReader.DONE, "should be DONE while firing onerror"); + is(event.target.error.name, "NotFoundError", "error set to NotFoundError for nonexistent files"); + is(event.target.result, null, "file data should be null on aborted reads"); + testHasRun(); + }; + r.onload = function (event) { + is(false, "nonexistent file shouldn't load! (FIXME: bug 1122788)"); + testHasRun(); + }; + try { + r.readAsDataURL(nonExistingFile); + expectedTestCount++; + } catch(ex) { + didThrow = true; + } + // Once this test passes, we should test that onerror gets called and + // that the FileReader object is in the right state during that call. + is(didThrow, false, "shouldn't throw when opening nonexistent file, should fire error instead"); + + + function getLoadHandler(expectedResult, expectedLength, testName) { + return function (event) { + is(event.target.readyState, FileReader.DONE, + "readyState in test " + testName); + is(event.target.error, null, + "no error in test " + testName); + is(event.target.result, expectedResult, + "result in test " + testName); + is(event.lengthComputable, true, + "lengthComputable in test " + testName); + is(event.loaded, expectedLength, + "loaded in test " + testName); + is(event.total, expectedLength, + "total in test " + testName); + testHasRun(); + } + } + + function getLoadHandlerForArrayBuffer(expectedResult, expectedLength, testName) { + return function (event) { + is(event.target.readyState, FileReader.DONE, + "readyState in test " + testName); + is(event.target.error, null, + "no error in test " + testName); + is(event.lengthComputable, true, + "lengthComputable in test " + testName); + is(event.loaded, expectedLength, + "loaded in test " + testName); + is(event.total, expectedLength, + "total in test " + testName); + is(event.target.result.byteLength, expectedLength, + "array buffer size in test " + testName); + var u8v = new Uint8Array(event.target.result); + is(String.fromCharCode.apply(String, u8v), expectedResult, + "array buffer contents in test " + testName); + u8v = null; + is(event.target.result.byteLength, expectedLength, + "array buffer size after gc in test " + testName); + u8v = new Uint8Array(event.target.result); + is(String.fromCharCode.apply(String, u8v), expectedResult, + "array buffer contents after gc in test " + testName); + testHasRun(); + } + } + + function testHasRun() { + //alert(testRanCounter); + ++testRanCounter; + if (testRanCounter == expectedTestCount) { + is(testSetupFinished, true, "test setup should have finished; check for exceptions"); + is(onloadHasRunText, true, "onload text should have fired by now"); + is(onloadHasRunBinary, true, "onload binary should have fired by now"); + finish(); + } + } + + testSetupFinished = true; +} diff --git a/dom/workers/test/worker_referrer.js b/dom/workers/test/worker_referrer.js new file mode 100644 index 000000000..227a77caf --- /dev/null +++ b/dom/workers/test/worker_referrer.js @@ -0,0 +1,9 @@ +onmessage = function() { + importScripts(['referrer.sjs?import']); + var xhr = new XMLHttpRequest(); + xhr.open('GET', 'referrer.sjs?result', true); + xhr.onload = function() { + postMessage(xhr.responseText); + } + xhr.send(); +} diff --git a/dom/workers/test/worker_setTimeoutWith0.js b/dom/workers/test/worker_setTimeoutWith0.js new file mode 100644 index 000000000..2d8e5e6c2 --- /dev/null +++ b/dom/workers/test/worker_setTimeoutWith0.js @@ -0,0 +1,3 @@ +var x = 0; +setTimeout("x++; '\x00'; x++;"); +setTimeout("postMessage(x);"); diff --git a/dom/workers/test/worker_suspended.js b/dom/workers/test/worker_suspended.js new file mode 100644 index 000000000..3b53fcea2 --- /dev/null +++ b/dom/workers/test/worker_suspended.js @@ -0,0 +1,31 @@ +var count = 0; + +function do_magic(data) { + caches.open("test") + .then(function(cache) { + return cache.put("http://mochi.test:888/foo", new Response(data.type + "-" + count++)); + }) + .then(function() { + if (count == 1) { + postMessage("ready"); + } + + if (data.loop) { + setTimeout(function() {do_magic(data); }, 500); + } + }); +} + +onmessage = function(e) { + if (e.data.type == 'page1') { + if (e.data.count > 0) { + var a = new Worker("worker_suspended.js"); + a.postMessage({ type: "page1", count: e.data - 1 }); + a.onmessage = function() { postMessage("ready"); } + } else { + do_magic({ type: e.data.type, loop: true }); + } + } else if (e.data.type == 'page2') { + do_magic({ type: e.data.type, loop: false }); + } +} diff --git a/dom/workers/test/worker_wrapper.js b/dom/workers/test/worker_wrapper.js new file mode 100644 index 000000000..c385803c4 --- /dev/null +++ b/dom/workers/test/worker_wrapper.js @@ -0,0 +1,99 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ +// +// Worker-side wrapper script for the worker_driver.js helper code. See +// the comments at the top of worker_driver.js for more information. + +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + ": " + msg + "\n"); + postMessage({type: 'status', status: !!a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + dump("IS: " + (a===b) + " => " + a + " | " + b + ": " + msg + "\n"); + postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg }); +} + +function workerTestArrayEquals(a, b) { + if (!Array.isArray(a) || !Array.isArray(b) || a.length != b.length) { + return false; + } + for (var i = 0, n = a.length; i < n; ++i) { + if (a[i] !== b[i]) { + return false; + } + } + return true; +} + +function workerTestDone() { + postMessage({ type: 'finish' }); +} + +function workerTestGetPermissions(permissions, cb) { + addEventListener('message', function workerTestGetPermissionsCB(e) { + if (e.data.type != 'returnPermissions' || + !workerTestArrayEquals(permissions, e.data.permissions)) { + return; + } + removeEventListener('message', workerTestGetPermissionsCB); + cb(e.data.result); + }); + postMessage({ + type: 'getPermissions', + permissions: permissions + }); +} + +function workerTestGetVersion(cb) { + addEventListener('message', function workerTestGetVersionCB(e) { + if (e.data.type !== 'returnVersion') { + return; + } + removeEventListener('message', workerTestGetVersionCB); + cb(e.data.result); + }); + postMessage({ + type: 'getVersion' + }); +} + +function workerTestGetUserAgent(cb) { + addEventListener('message', function workerTestGetUserAgentCB(e) { + if (e.data.type !== 'returnUserAgent') { + return; + } + removeEventListener('message', workerTestGetUserAgentCB); + cb(e.data.result); + }); + postMessage({ + type: 'getUserAgent' + }); +} + +function workerTestGetOSCPU(cb) { + addEventListener('message', function workerTestGetOSCPUCB(e) { + if (e.data.type !== 'returnOSCPU') { + return; + } + removeEventListener('message', workerTestGetOSCPUCB); + cb(e.data.result); + }); + postMessage({ + type: 'getOSCPU' + }); +} + +addEventListener('message', function workerWrapperOnMessage(e) { + removeEventListener('message', workerWrapperOnMessage); + var data = e.data; + try { + importScripts(data.script); + } catch(e) { + postMessage({ + type: 'status', + status: false, + msg: 'worker failed to import ' + data.script + "; error: " + e.message + }); + } +}); diff --git a/dom/workers/test/workersDisabled_worker.js b/dom/workers/test/workersDisabled_worker.js new file mode 100644 index 000000000..7346fc142 --- /dev/null +++ b/dom/workers/test/workersDisabled_worker.js @@ -0,0 +1,7 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +onmessage = function(event) { + postMessage(event.data); +} diff --git a/dom/workers/test/xpcshell/data/chrome.manifest b/dom/workers/test/xpcshell/data/chrome.manifest new file mode 100644 index 000000000..611e81fd4 --- /dev/null +++ b/dom/workers/test/xpcshell/data/chrome.manifest @@ -0,0 +1 @@ +content workers ./ diff --git a/dom/workers/test/xpcshell/data/worker.js b/dom/workers/test/xpcshell/data/worker.js new file mode 100644 index 000000000..9a83bb128 --- /dev/null +++ b/dom/workers/test/xpcshell/data/worker.js @@ -0,0 +1,7 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + + +self.onmessage = function(msg) { + self.postMessage("OK"); +}; diff --git a/dom/workers/test/xpcshell/data/worker_fileReader.js b/dom/workers/test/xpcshell/data/worker_fileReader.js new file mode 100644 index 000000000..b27366d17 --- /dev/null +++ b/dom/workers/test/xpcshell/data/worker_fileReader.js @@ -0,0 +1,8 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + + +self.onmessage = function(msg) { + var fr = new FileReader(); + self.postMessage("OK"); +}; diff --git a/dom/workers/test/xpcshell/test_fileReader.js b/dom/workers/test/xpcshell/test_fileReader.js new file mode 100644 index 000000000..0e283fbe0 --- /dev/null +++ b/dom/workers/test/xpcshell/test_fileReader.js @@ -0,0 +1,40 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +Components.utils.import("resource://gre/modules/Promise.jsm"); + +// Worker must be loaded from a chrome:// uri, not a file:// +// uri, so we first need to load it. +var WORKER_SOURCE_URI = "chrome://workers/content/worker_fileReader.js"; +do_load_manifest("data/chrome.manifest"); + +function run_test() { + run_next_test(); +} + +function talk_with_worker(worker) { + let deferred = Promise.defer(); + worker.onmessage = function(event) { + let success = true; + if (event.data == "OK") { + deferred.resolve(); + } else { + success = false; + deferred.reject(event); + } + do_check_true(success); + worker.terminate(); + }; + worker.onerror = function(event) { + let error = new Error(event.message, event.filename, event.lineno); + worker.terminate(); + deferred.reject(error); + }; + worker.postMessage("START"); + return deferred.promise; +} + + +add_task(function test_chrome_worker() { + return talk_with_worker(new ChromeWorker(WORKER_SOURCE_URI)); +}); diff --git a/dom/workers/test/xpcshell/test_workers.js b/dom/workers/test/xpcshell/test_workers.js new file mode 100644 index 000000000..c06e62af3 --- /dev/null +++ b/dom/workers/test/xpcshell/test_workers.js @@ -0,0 +1,44 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +Components.utils.import("resource://gre/modules/Promise.jsm"); + +// Worker must be loaded from a chrome:// uri, not a file:// +// uri, so we first need to load it. +var WORKER_SOURCE_URI = "chrome://workers/content/worker.js"; +do_load_manifest("data/chrome.manifest"); + +function run_test() { + run_next_test(); +} + +function talk_with_worker(worker) { + let deferred = Promise.defer(); + worker.onmessage = function(event) { + let success = true; + if (event.data == "OK") { + deferred.resolve(); + } else { + success = false; + deferred.reject(event); + } + do_check_true(success); + worker.terminate(); + }; + worker.onerror = function(event) { + let error = new Error(event.message, event.filename, event.lineno); + worker.terminate(); + deferred.reject(error); + }; + worker.postMessage("START"); + return deferred.promise; +} + + +add_task(function test_chrome_worker() { + return talk_with_worker(new ChromeWorker(WORKER_SOURCE_URI)); +}); + +add_task(function test_worker() { + return talk_with_worker(new Worker(WORKER_SOURCE_URI)); +}); diff --git a/dom/workers/test/xpcshell/xpcshell.ini b/dom/workers/test/xpcshell/xpcshell.ini new file mode 100644 index 000000000..917b842f5 --- /dev/null +++ b/dom/workers/test/xpcshell/xpcshell.ini @@ -0,0 +1,11 @@ +[DEFAULT] +head = +tail = +skip-if = toolkit == 'android' +support-files = + data/worker.js + data/worker_fileReader.js + data/chrome.manifest + +[test_workers.js] +[test_fileReader.js] |
