michael@0: /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
michael@0: /* vim: set ts=2 et sw=2 tw=80: */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "WorkerPrivate.h"
michael@0: 
michael@0: #include "amIAddonManager.h"
michael@0: #include "nsIClassInfo.h"
michael@0: #include "nsIContentSecurityPolicy.h"
michael@0: #include "nsIConsoleService.h"
michael@0: #include "nsIDOMDOMException.h"
michael@0: #include "nsIDOMEvent.h"
michael@0: #include "nsIDOMFile.h"
michael@0: #include "nsIDOMMessageEvent.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIDocShell.h"
michael@0: #include "nsIMemoryReporter.h"
michael@0: #include "nsIPermissionManager.h"
michael@0: #include "nsIScriptError.h"
michael@0: #include "nsIScriptGlobalObject.h"
michael@0: #include "nsIScriptSecurityManager.h"
michael@0: #include "nsPIDOMWindow.h"
michael@0: #include "nsITextToSubURI.h"
michael@0: #include "nsIThreadInternal.h"
michael@0: #include "nsITimer.h"
michael@0: #include "nsIURI.h"
michael@0: #include "nsIURL.h"
michael@0: #include "nsIXPConnect.h"
michael@0: 
michael@0: #include <algorithm>
michael@0: #include "jsfriendapi.h"
michael@0: #include "js/OldDebugAPI.h"
michael@0: #include "js/MemoryMetrics.h"
michael@0: #include "mozilla/Assertions.h"
michael@0: #include "mozilla/ContentEvents.h"
michael@0: #include "mozilla/EventDispatcher.h"
michael@0: #include "mozilla/Likely.h"
michael@0: #include "mozilla/dom/BindingUtils.h"
michael@0: #include "mozilla/dom/ErrorEvent.h"
michael@0: #include "mozilla/dom/ErrorEventBinding.h"
michael@0: #include "mozilla/dom/Exceptions.h"
michael@0: #include "mozilla/dom/FunctionBinding.h"
michael@0: #include "mozilla/dom/ImageData.h"
michael@0: #include "mozilla/dom/ImageDataBinding.h"
michael@0: #include "mozilla/dom/MessageEvent.h"
michael@0: #include "mozilla/dom/MessageEventBinding.h"
michael@0: #include "mozilla/dom/MessagePortList.h"
michael@0: #include "mozilla/dom/WorkerBinding.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "nsAlgorithm.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsCxPusher.h"
michael@0: #include "nsError.h"
michael@0: #include "nsDOMJSUtils.h"
michael@0: #include "nsHostObjectProtocolHandler.h"
michael@0: #include "nsJSEnvironment.h"
michael@0: #include "nsJSUtils.h"
michael@0: #include "nsNetUtil.h"
michael@0: #include "nsPrintfCString.h"
michael@0: #include "nsProxyRelease.h"
michael@0: #include "nsSandboxFlags.h"
michael@0: #include "xpcpublic.h"
michael@0: 
michael@0: #ifdef ANDROID
michael@0: #include <android/log.h>
michael@0: #endif
michael@0: 
michael@0: #ifdef DEBUG
michael@0: #include "nsThreadManager.h"
michael@0: #endif
michael@0: 
michael@0: #include "File.h"
michael@0: #include "MessagePort.h"
michael@0: #include "Navigator.h"
michael@0: #include "Principal.h"
michael@0: #include "RuntimeService.h"
michael@0: #include "ScriptLoader.h"
michael@0: #include "SharedWorker.h"
michael@0: #include "WorkerFeature.h"
michael@0: #include "WorkerRunnable.h"
michael@0: #include "WorkerScope.h"
michael@0: 
michael@0: // JS_MaybeGC will run once every second during normal execution.
michael@0: #define PERIODIC_GC_TIMER_DELAY_SEC 1
michael@0: 
michael@0: // A shrinking GC will run five seconds after the last event is processed.
michael@0: #define IDLE_GC_TIMER_DELAY_SEC 5
michael@0: 
michael@0: #define PREF_WORKERS_ENABLED "dom.workers.enabled"
michael@0: 
michael@0: #ifdef WORKER_LOGGING
michael@0: #define LOG(_args) do { printf _args ; fflush(stdout); } while (0)
michael@0: #else
michael@0: #define LOG(_args) do { } while (0)
michael@0: #endif
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::dom;
michael@0: USING_WORKERS_NAMESPACE
michael@0: 
michael@0: MOZ_DEFINE_MALLOC_SIZE_OF(JsWorkerMallocSizeOf)
michael@0: 
michael@0: #ifdef DEBUG
michael@0: 
michael@0: BEGIN_WORKERS_NAMESPACE
michael@0: 
michael@0: void
michael@0: AssertIsOnMainThread()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
michael@0: }
michael@0: 
michael@0: END_WORKERS_NAMESPACE
michael@0: 
michael@0: #endif
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: #ifdef DEBUG
michael@0: 
michael@0: const nsIID kDEBUGWorkerEventTargetIID = {
michael@0:   0xccaba3fa, 0x5be2, 0x4de2, { 0xba, 0x87, 0x3b, 0x3b, 0x5b, 0x1d, 0x5, 0xfb }
michael@0: };
michael@0: 
michael@0: #endif
michael@0: 
michael@0: template <class T>
michael@0: class AutoPtrComparator
michael@0: {
michael@0:   typedef nsAutoPtr<T> A;
michael@0:   typedef T* B;
michael@0: 
michael@0: public:
michael@0:   bool Equals(const A& a, const B& b) const {
michael@0:     return a && b ? *a == *b : !a && !b ? true : false;
michael@0:   }
michael@0:   bool LessThan(const A& a, const B& b) const {
michael@0:     return a && b ? *a < *b : b ? true : false;
michael@0:   }
michael@0: };
michael@0: 
michael@0: template <class T>
michael@0: inline AutoPtrComparator<T>
michael@0: GetAutoPtrComparator(const nsTArray<nsAutoPtr<T> >&)
michael@0: {
michael@0:   return AutoPtrComparator<T>();
michael@0: }
michael@0: 
michael@0: // Specialize this if there's some class that has multiple nsISupports bases.
michael@0: template <class T>
michael@0: struct ISupportsBaseInfo
michael@0: {
michael@0:   typedef T ISupportsBase;
michael@0: };
michael@0: 
michael@0: template <template <class> class SmartPtr, class T>
michael@0: inline void
michael@0: SwapToISupportsArray(SmartPtr<T>& aSrc,
michael@0:                      nsTArray<nsCOMPtr<nsISupports> >& aDest)
michael@0: {
michael@0:   nsCOMPtr<nsISupports>* dest = aDest.AppendElement();
michael@0: 
michael@0:   T* raw = nullptr;
michael@0:   aSrc.swap(raw);
michael@0: 
michael@0:   nsISupports* rawSupports =
michael@0:     static_cast<typename ISupportsBaseInfo<T>::ISupportsBase*>(raw);
michael@0:   dest->swap(rawSupports);
michael@0: }
michael@0: 
michael@0: // This class is used to wrap any runnables that the worker receives via the
michael@0: // nsIEventTarget::Dispatch() method (either from NS_DispatchToCurrentThread or
michael@0: // from the worker's EventTarget).
michael@0: class ExternalRunnableWrapper MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0:   nsCOMPtr<nsICancelableRunnable> mWrappedRunnable;
michael@0: 
michael@0: public:
michael@0:   ExternalRunnableWrapper(WorkerPrivate* aWorkerPrivate,
michael@0:                           nsICancelableRunnable* aWrappedRunnable)
michael@0:   : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mWrappedRunnable(aWrappedRunnable)
michael@0:   {
michael@0:     MOZ_ASSERT(aWorkerPrivate);
michael@0:     MOZ_ASSERT(aWrappedRunnable);
michael@0:   }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0: private:
michael@0:   ~ExternalRunnableWrapper()
michael@0:   { }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = mWrappedRunnable->Run();
michael@0:     if (NS_FAILED(rv)) {
michael@0:       if (!JS_IsExceptionPending(aCx)) {
michael@0:         Throw(aCx, rv);
michael@0:       }
michael@0:       return false;
michael@0:     }
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Cancel() MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = mWrappedRunnable->Cancel();
michael@0:     nsresult rv2 = WorkerRunnable::Cancel();
michael@0:     return NS_FAILED(rv) ? rv : rv2;
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct WindowAction
michael@0: {
michael@0:   nsPIDOMWindow* mWindow;
michael@0:   JSContext* mJSContext;
michael@0:   bool mDefaultAction;
michael@0: 
michael@0:   WindowAction(nsPIDOMWindow* aWindow, JSContext* aJSContext)
michael@0:   : mWindow(aWindow), mJSContext(aJSContext), mDefaultAction(true)
michael@0:   {
michael@0:     MOZ_ASSERT(aJSContext);
michael@0:   }
michael@0: 
michael@0:   WindowAction(nsPIDOMWindow* aWindow)
michael@0:   : mWindow(aWindow), mJSContext(nullptr), mDefaultAction(true)
michael@0:   { }
michael@0: 
michael@0:   bool
michael@0:   operator==(const WindowAction& aOther) const
michael@0:   {
michael@0:     return mWindow == aOther.mWindow;
michael@0:   }
michael@0: };
michael@0: 
michael@0: void
michael@0: LogErrorToConsole(const nsAString& aMessage,
michael@0:                   const nsAString& aFilename,
michael@0:                   const nsAString& aLine,
michael@0:                   uint32_t aLineNumber,
michael@0:                   uint32_t aColumnNumber,
michael@0:                   uint32_t aFlags,
michael@0:                   uint64_t aInnerWindowId)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   nsCOMPtr<nsIScriptError> scriptError =
michael@0:     do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
michael@0:   NS_WARN_IF_FALSE(scriptError, "Failed to create script error!");
michael@0: 
michael@0:   if (scriptError) {
michael@0:     if (NS_FAILED(scriptError->InitWithWindowID(aMessage, aFilename, aLine,
michael@0:                                                 aLineNumber, aColumnNumber,
michael@0:                                                 aFlags, "Web Worker",
michael@0:                                                 aInnerWindowId))) {
michael@0:       NS_WARNING("Failed to init script error!");
michael@0:       scriptError = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIConsoleService> consoleService =
michael@0:     do_GetService(NS_CONSOLESERVICE_CONTRACTID);
michael@0:   NS_WARN_IF_FALSE(consoleService, "Failed to get console service!");
michael@0: 
michael@0:   if (consoleService) {
michael@0:     if (scriptError) {
michael@0:       if (NS_SUCCEEDED(consoleService->LogMessage(scriptError))) {
michael@0:         return;
michael@0:       }
michael@0:       NS_WARNING("LogMessage failed!");
michael@0:     } else if (NS_SUCCEEDED(consoleService->LogStringMessage(
michael@0:                                                     aMessage.BeginReading()))) {
michael@0:       return;
michael@0:     }
michael@0:     NS_WARNING("LogStringMessage failed!");
michael@0:   }
michael@0: 
michael@0:   NS_ConvertUTF16toUTF8 msg(aMessage);
michael@0:   NS_ConvertUTF16toUTF8 filename(aFilename);
michael@0: 
michael@0:   static const char kErrorString[] = "JS error in Web Worker: %s [%s:%u]";
michael@0: 
michael@0: #ifdef ANDROID
michael@0:   __android_log_print(ANDROID_LOG_INFO, "Gecko", kErrorString, msg.get(),
michael@0:                       filename.get(), aLineNumber);
michael@0: #endif
michael@0: 
michael@0:   fprintf(stderr, kErrorString, msg.get(), filename.get(), aLineNumber);
michael@0:   fflush(stderr);
michael@0: }
michael@0: 
michael@0: struct WorkerStructuredCloneCallbacks
michael@0: {
michael@0:   static JSObject*
michael@0:   Read(JSContext* aCx, JSStructuredCloneReader* aReader, uint32_t aTag,
michael@0:        uint32_t aData, void* aClosure)
michael@0:   {
michael@0:     // See if object is a nsIDOMFile pointer.
michael@0:     if (aTag == DOMWORKER_SCTAG_FILE) {
michael@0:       MOZ_ASSERT(!aData);
michael@0: 
michael@0:       nsIDOMFile* file;
michael@0:       if (JS_ReadBytes(aReader, &file, sizeof(file))) {
michael@0:         MOZ_ASSERT(file);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:         {
michael@0:           // File should not be mutable.
michael@0:           nsCOMPtr<nsIMutable> mutableFile = do_QueryInterface(file);
michael@0:           bool isMutable;
michael@0:           NS_ASSERTION(NS_SUCCEEDED(mutableFile->GetMutable(&isMutable)) &&
michael@0:                        !isMutable,
michael@0:                        "Only immutable file should be passed to worker");
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // nsIDOMFiles should be threadsafe, thus we will use the same instance
michael@0:         // in the worker.
michael@0:         JSObject* jsFile = file::CreateFile(aCx, file);
michael@0:         return jsFile;
michael@0:       }
michael@0:     }
michael@0:     // See if object is a nsIDOMBlob pointer.
michael@0:     else if (aTag == DOMWORKER_SCTAG_BLOB) {
michael@0:       MOZ_ASSERT(!aData);
michael@0: 
michael@0:       nsIDOMBlob* blob;
michael@0:       if (JS_ReadBytes(aReader, &blob, sizeof(blob))) {
michael@0:         MOZ_ASSERT(blob);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:         {
michael@0:           // Blob should not be mutable.
michael@0:           nsCOMPtr<nsIMutable> mutableBlob = do_QueryInterface(blob);
michael@0:           bool isMutable;
michael@0:           NS_ASSERTION(NS_SUCCEEDED(mutableBlob->GetMutable(&isMutable)) &&
michael@0:                        !isMutable,
michael@0:                        "Only immutable blob should be passed to worker");
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // nsIDOMBlob should be threadsafe, thus we will use the same instance
michael@0:         // in the worker.
michael@0:         JSObject* jsBlob = file::CreateBlob(aCx, blob);
michael@0:         return jsBlob;
michael@0:       }
michael@0:     }
michael@0:     // See if the object is an ImageData.
michael@0:     else if (aTag == SCTAG_DOM_IMAGEDATA) {
michael@0:       MOZ_ASSERT(!aData);
michael@0: 
michael@0:       // Read the information out of the stream.
michael@0:       uint32_t width, height;
michael@0:       JS::Rooted<JS::Value> dataArray(aCx);
michael@0:       if (!JS_ReadUint32Pair(aReader, &width, &height) ||
michael@0:           !JS_ReadTypedArray(aReader, &dataArray))
michael@0:       {
michael@0:         return nullptr;
michael@0:       }
michael@0:       MOZ_ASSERT(dataArray.isObject());
michael@0: 
michael@0:       JS::Rooted<JSObject*> result(aCx);
michael@0:       {
michael@0:         // Construct the ImageData.
michael@0:         nsRefPtr<ImageData> imageData = new ImageData(width, height,
michael@0:                                                       dataArray.toObject());
michael@0:         // Wrap it in a JS::Value, protected from a moving GC during ~nsRefPtr.
michael@0:         result = imageData->WrapObject(aCx);
michael@0:       }
michael@0:       return result;
michael@0:     }
michael@0: 
michael@0:     Error(aCx, 0);
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   static bool
michael@0:   Write(JSContext* aCx, JSStructuredCloneWriter* aWriter,
michael@0:         JS::Handle<JSObject*> aObj, void* aClosure)
michael@0:   {
michael@0:     NS_ASSERTION(aClosure, "Null pointer!");
michael@0: 
michael@0:     // We'll stash any nsISupports pointers that need to be AddRef'd here.
michael@0:     nsTArray<nsCOMPtr<nsISupports> >* clonedObjects =
michael@0:       static_cast<nsTArray<nsCOMPtr<nsISupports> >*>(aClosure);
michael@0: 
michael@0:     // See if this is a File object.
michael@0:     {
michael@0:       nsIDOMFile* file = file::GetDOMFileFromJSObject(aObj);
michael@0:       if (file) {
michael@0:         if (JS_WriteUint32Pair(aWriter, DOMWORKER_SCTAG_FILE, 0) &&
michael@0:             JS_WriteBytes(aWriter, &file, sizeof(file))) {
michael@0:           clonedObjects->AppendElement(file);
michael@0:           return true;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // See if this is a Blob object.
michael@0:     {
michael@0:       nsIDOMBlob* blob = file::GetDOMBlobFromJSObject(aObj);
michael@0:       if (blob) {
michael@0:         nsCOMPtr<nsIMutable> mutableBlob = do_QueryInterface(blob);
michael@0:         if (mutableBlob && NS_SUCCEEDED(mutableBlob->SetMutable(false)) &&
michael@0:             JS_WriteUint32Pair(aWriter, DOMWORKER_SCTAG_BLOB, 0) &&
michael@0:             JS_WriteBytes(aWriter, &blob, sizeof(blob))) {
michael@0:           clonedObjects->AppendElement(blob);
michael@0:           return true;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // See if this is an ImageData object.
michael@0:     {
michael@0:       ImageData* imageData = nullptr;
michael@0:       if (NS_SUCCEEDED(UNWRAP_OBJECT(ImageData, aObj, imageData))) {
michael@0:         // Prepare the ImageData internals.
michael@0:         uint32_t width = imageData->Width();
michael@0:         uint32_t height = imageData->Height();
michael@0:         JS::Rooted<JSObject*> dataArray(aCx, imageData->GetDataObject());
michael@0: 
michael@0:         // Write the internals to the stream.
michael@0:         JSAutoCompartment ac(aCx, dataArray);
michael@0:         JS::Rooted<JS::Value> arrayValue(aCx, JS::ObjectValue(*dataArray));
michael@0:         return JS_WriteUint32Pair(aWriter, SCTAG_DOM_IMAGEDATA, 0) &&
michael@0:                JS_WriteUint32Pair(aWriter, width, height) &&
michael@0:                JS_WriteTypedArray(aWriter, arrayValue);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     Error(aCx, 0);
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   static void
michael@0:   Error(JSContext* aCx, uint32_t /* aErrorId */)
michael@0:   {
michael@0:     Throw(aCx, NS_ERROR_DOM_DATA_CLONE_ERR);
michael@0:   }
michael@0: };
michael@0: 
michael@0: JSStructuredCloneCallbacks gWorkerStructuredCloneCallbacks = {
michael@0:   WorkerStructuredCloneCallbacks::Read,
michael@0:   WorkerStructuredCloneCallbacks::Write,
michael@0:   WorkerStructuredCloneCallbacks::Error,
michael@0:   nullptr,
michael@0:   nullptr,
michael@0:   nullptr
michael@0: };
michael@0: 
michael@0: struct MainThreadWorkerStructuredCloneCallbacks
michael@0: {
michael@0:   static JSObject*
michael@0:   Read(JSContext* aCx, JSStructuredCloneReader* aReader, uint32_t aTag,
michael@0:        uint32_t aData, void* aClosure)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     // See if object is a nsIDOMFile pointer.
michael@0:     if (aTag == DOMWORKER_SCTAG_FILE) {
michael@0:       MOZ_ASSERT(!aData);
michael@0: 
michael@0:       nsIDOMFile* file;
michael@0:       if (JS_ReadBytes(aReader, &file, sizeof(file))) {
michael@0:         MOZ_ASSERT(file);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:         {
michael@0:           // File should not be mutable.
michael@0:           nsCOMPtr<nsIMutable> mutableFile = do_QueryInterface(file);
michael@0:           bool isMutable;
michael@0:           NS_ASSERTION(NS_SUCCEEDED(mutableFile->GetMutable(&isMutable)) &&
michael@0:                        !isMutable,
michael@0:                        "Only immutable file should be passed to worker");
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // nsIDOMFiles should be threadsafe, thus we will use the same instance
michael@0:         // on the main thread.
michael@0:         JS::Rooted<JS::Value> wrappedFile(aCx);
michael@0:         nsresult rv = nsContentUtils::WrapNative(aCx, file,
michael@0:                                                  &NS_GET_IID(nsIDOMFile),
michael@0:                                                  &wrappedFile);
michael@0:         if (NS_FAILED(rv)) {
michael@0:           Error(aCx, nsIDOMDOMException::DATA_CLONE_ERR);
michael@0:           return nullptr;
michael@0:         }
michael@0: 
michael@0:         return &wrappedFile.toObject();
michael@0:       }
michael@0:     }
michael@0:     // See if object is a nsIDOMBlob pointer.
michael@0:     else if (aTag == DOMWORKER_SCTAG_BLOB) {
michael@0:       MOZ_ASSERT(!aData);
michael@0: 
michael@0:       nsIDOMBlob* blob;
michael@0:       if (JS_ReadBytes(aReader, &blob, sizeof(blob))) {
michael@0:         MOZ_ASSERT(blob);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:         {
michael@0:           // Blob should not be mutable.
michael@0:           nsCOMPtr<nsIMutable> mutableBlob = do_QueryInterface(blob);
michael@0:           bool isMutable;
michael@0:           NS_ASSERTION(NS_SUCCEEDED(mutableBlob->GetMutable(&isMutable)) &&
michael@0:                        !isMutable,
michael@0:                        "Only immutable blob should be passed to worker");
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // nsIDOMBlobs should be threadsafe, thus we will use the same instance
michael@0:         // on the main thread.
michael@0:         JS::Rooted<JS::Value> wrappedBlob(aCx);
michael@0:         nsresult rv = nsContentUtils::WrapNative(aCx, blob,
michael@0:                                                  &NS_GET_IID(nsIDOMBlob),
michael@0:                                                  &wrappedBlob);
michael@0:         if (NS_FAILED(rv)) {
michael@0:           Error(aCx, nsIDOMDOMException::DATA_CLONE_ERR);
michael@0:           return nullptr;
michael@0:         }
michael@0: 
michael@0:         return &wrappedBlob.toObject();
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     JS_ClearPendingException(aCx);
michael@0:     return NS_DOMReadStructuredClone(aCx, aReader, aTag, aData, nullptr);
michael@0:   }
michael@0: 
michael@0:   static bool
michael@0:   Write(JSContext* aCx, JSStructuredCloneWriter* aWriter,
michael@0:         JS::Handle<JSObject*> aObj, void* aClosure)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     NS_ASSERTION(aClosure, "Null pointer!");
michael@0: 
michael@0:     // We'll stash any nsISupports pointers that need to be AddRef'd here.
michael@0:     nsTArray<nsCOMPtr<nsISupports> >* clonedObjects =
michael@0:       static_cast<nsTArray<nsCOMPtr<nsISupports> >*>(aClosure);
michael@0: 
michael@0:     // See if this is a wrapped native.
michael@0:     nsCOMPtr<nsIXPConnectWrappedNative> wrappedNative;
michael@0:     nsContentUtils::XPConnect()->
michael@0:       GetWrappedNativeOfJSObject(aCx, aObj, getter_AddRefs(wrappedNative));
michael@0: 
michael@0:     if (wrappedNative) {
michael@0:       // Get the raw nsISupports out of it.
michael@0:       nsISupports* wrappedObject = wrappedNative->Native();
michael@0:       NS_ASSERTION(wrappedObject, "Null pointer?!");
michael@0: 
michael@0:       nsISupports* ccISupports = nullptr;
michael@0:       wrappedObject->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
michael@0:                                     reinterpret_cast<void**>(&ccISupports));
michael@0:       if (ccISupports) {
michael@0:         NS_WARNING("Cycle collected objects are not supported!");
michael@0:       }
michael@0:       else {
michael@0:         // See if the wrapped native is a nsIDOMFile.
michael@0:         nsCOMPtr<nsIDOMFile> file = do_QueryInterface(wrappedObject);
michael@0:         if (file) {
michael@0:           nsCOMPtr<nsIMutable> mutableFile = do_QueryInterface(file);
michael@0:           if (mutableFile && NS_SUCCEEDED(mutableFile->SetMutable(false))) {
michael@0:             nsIDOMFile* filePtr = file;
michael@0:             if (JS_WriteUint32Pair(aWriter, DOMWORKER_SCTAG_FILE, 0) &&
michael@0:                 JS_WriteBytes(aWriter, &filePtr, sizeof(filePtr))) {
michael@0:               clonedObjects->AppendElement(file);
michael@0:               return true;
michael@0:             }
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         // See if the wrapped native is a nsIDOMBlob.
michael@0:         nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(wrappedObject);
michael@0:         if (blob) {
michael@0:           nsCOMPtr<nsIMutable> mutableBlob = do_QueryInterface(blob);
michael@0:           if (mutableBlob && NS_SUCCEEDED(mutableBlob->SetMutable(false))) {
michael@0:             nsIDOMBlob* blobPtr = blob;
michael@0:             if (JS_WriteUint32Pair(aWriter, DOMWORKER_SCTAG_BLOB, 0) &&
michael@0:                 JS_WriteBytes(aWriter, &blobPtr, sizeof(blobPtr))) {
michael@0:               clonedObjects->AppendElement(blob);
michael@0:               return true;
michael@0:             }
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     JS_ClearPendingException(aCx);
michael@0:     return NS_DOMWriteStructuredClone(aCx, aWriter, aObj, nullptr);
michael@0:   }
michael@0: 
michael@0:   static void
michael@0:   Error(JSContext* aCx, uint32_t aErrorId)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     NS_DOMStructuredCloneError(aCx, aErrorId);
michael@0:   }
michael@0: };
michael@0: 
michael@0: JSStructuredCloneCallbacks gMainThreadWorkerStructuredCloneCallbacks = {
michael@0:   MainThreadWorkerStructuredCloneCallbacks::Read,
michael@0:   MainThreadWorkerStructuredCloneCallbacks::Write,
michael@0:   MainThreadWorkerStructuredCloneCallbacks::Error,
michael@0:   nullptr,
michael@0:   nullptr,
michael@0:   nullptr
michael@0: };
michael@0: 
michael@0: struct ChromeWorkerStructuredCloneCallbacks
michael@0: {
michael@0:   static JSObject*
michael@0:   Read(JSContext* aCx, JSStructuredCloneReader* aReader, uint32_t aTag,
michael@0:        uint32_t aData, void* aClosure)
michael@0:   {
michael@0:     return WorkerStructuredCloneCallbacks::Read(aCx, aReader, aTag, aData,
michael@0:                                                 aClosure);
michael@0:   }
michael@0: 
michael@0:   static bool
michael@0:   Write(JSContext* aCx, JSStructuredCloneWriter* aWriter,
michael@0:         JS::Handle<JSObject*> aObj, void* aClosure)
michael@0:   {
michael@0:     return WorkerStructuredCloneCallbacks::Write(aCx, aWriter, aObj, aClosure);
michael@0:   }
michael@0: 
michael@0:   static void
michael@0:   Error(JSContext* aCx, uint32_t aErrorId)
michael@0:   {
michael@0:     return WorkerStructuredCloneCallbacks::Error(aCx, aErrorId);
michael@0:   }
michael@0: };
michael@0: 
michael@0: JSStructuredCloneCallbacks gChromeWorkerStructuredCloneCallbacks = {
michael@0:   ChromeWorkerStructuredCloneCallbacks::Read,
michael@0:   ChromeWorkerStructuredCloneCallbacks::Write,
michael@0:   ChromeWorkerStructuredCloneCallbacks::Error,
michael@0:   nullptr,
michael@0:   nullptr,
michael@0:   nullptr
michael@0: };
michael@0: 
michael@0: struct MainThreadChromeWorkerStructuredCloneCallbacks
michael@0: {
michael@0:   static JSObject*
michael@0:   Read(JSContext* aCx, JSStructuredCloneReader* aReader, uint32_t aTag,
michael@0:        uint32_t aData, void* aClosure)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     JSObject* clone =
michael@0:       MainThreadWorkerStructuredCloneCallbacks::Read(aCx, aReader, aTag, aData,
michael@0:                                                      aClosure);
michael@0:     if (clone) {
michael@0:       return clone;
michael@0:     }
michael@0: 
michael@0:     clone =
michael@0:       ChromeWorkerStructuredCloneCallbacks::Read(aCx, aReader, aTag, aData,
michael@0:                                                  aClosure);
michael@0:     if (clone) {
michael@0:       return clone;
michael@0:     }
michael@0: 
michael@0:     JS_ClearPendingException(aCx);
michael@0:     return NS_DOMReadStructuredClone(aCx, aReader, aTag, aData, nullptr);
michael@0:   }
michael@0: 
michael@0:   static bool
michael@0:   Write(JSContext* aCx, JSStructuredCloneWriter* aWriter,
michael@0:         JS::Handle<JSObject*> aObj, void* aClosure)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     if (MainThreadWorkerStructuredCloneCallbacks::Write(aCx, aWriter, aObj,
michael@0:                                                         aClosure) ||
michael@0:         ChromeWorkerStructuredCloneCallbacks::Write(aCx, aWriter, aObj,
michael@0:                                                     aClosure) ||
michael@0:         NS_DOMWriteStructuredClone(aCx, aWriter, aObj, nullptr)) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   static void
michael@0:   Error(JSContext* aCx, uint32_t aErrorId)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     NS_DOMStructuredCloneError(aCx, aErrorId);
michael@0:   }
michael@0: };
michael@0: 
michael@0: JSStructuredCloneCallbacks gMainThreadChromeWorkerStructuredCloneCallbacks = {
michael@0:   MainThreadChromeWorkerStructuredCloneCallbacks::Read,
michael@0:   MainThreadChromeWorkerStructuredCloneCallbacks::Write,
michael@0:   MainThreadChromeWorkerStructuredCloneCallbacks::Error,
michael@0:   nullptr,
michael@0:   nullptr,
michael@0:   nullptr
michael@0: };
michael@0: 
michael@0: class MainThreadReleaseRunnable MOZ_FINAL : public nsRunnable
michael@0: {
michael@0:   nsTArray<nsCOMPtr<nsISupports>> mDoomed;
michael@0:   nsTArray<nsCString> mHostObjectURIs;
michael@0: 
michael@0: public:
michael@0:   MainThreadReleaseRunnable(nsTArray<nsCOMPtr<nsISupports>>& aDoomed,
michael@0:                             nsTArray<nsCString>& aHostObjectURIs)
michael@0:   {
michael@0:     mDoomed.SwapElements(aDoomed);
michael@0:     mHostObjectURIs.SwapElements(aHostObjectURIs);
michael@0:   }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run() MOZ_OVERRIDE
michael@0:   {
michael@0:     mDoomed.Clear();
michael@0: 
michael@0:     for (uint32_t index = 0; index < mHostObjectURIs.Length(); index++) {
michael@0:       nsHostObjectProtocolHandler::RemoveDataEntry(mHostObjectURIs[index]);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   ~MainThreadReleaseRunnable()
michael@0:   { }
michael@0: };
michael@0: 
michael@0: class WorkerFinishedRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   WorkerPrivate* mFinishedWorker;
michael@0: 
michael@0: public:
michael@0:   WorkerFinishedRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                          WorkerPrivate* aFinishedWorker)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mFinishedWorker(aFinishedWorker)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions.
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions.
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     nsTArray<nsCOMPtr<nsISupports>> doomed;
michael@0:     mFinishedWorker->ForgetMainThreadObjects(doomed);
michael@0: 
michael@0:     nsTArray<nsCString> hostObjectURIs;
michael@0:     mFinishedWorker->StealHostObjectURIs(hostObjectURIs);
michael@0: 
michael@0:     nsRefPtr<MainThreadReleaseRunnable> runnable =
michael@0:       new MainThreadReleaseRunnable(doomed, hostObjectURIs);
michael@0:     if (NS_FAILED(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL))) {
michael@0:       NS_WARNING("Failed to dispatch, going to leak!");
michael@0:     }
michael@0: 
michael@0:     RuntimeService* runtime = RuntimeService::GetService();
michael@0:     NS_ASSERTION(runtime, "This should never be null!");
michael@0: 
michael@0:     runtime->UnregisterWorker(aCx, mFinishedWorker);
michael@0: 
michael@0:     mFinishedWorker->ClearSelfRef();
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class TopLevelWorkerFinishedRunnable MOZ_FINAL : public nsRunnable
michael@0: {
michael@0:   WorkerPrivate* mFinishedWorker;
michael@0: 
michael@0: public:
michael@0:   TopLevelWorkerFinishedRunnable(WorkerPrivate* aFinishedWorker)
michael@0:   : mFinishedWorker(aFinishedWorker)
michael@0:   {
michael@0:     aFinishedWorker->AssertIsOnWorkerThread();
michael@0:   }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0: private:
michael@0:   NS_IMETHOD
michael@0:   Run() MOZ_OVERRIDE
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     RuntimeService* runtime = RuntimeService::GetService();
michael@0:     MOZ_ASSERT(runtime);
michael@0: 
michael@0:     AutoSafeJSContext cx;
michael@0:     JSAutoRequest ar(cx);
michael@0: 
michael@0:     runtime->UnregisterWorker(cx, mFinishedWorker);
michael@0: 
michael@0:     nsTArray<nsCOMPtr<nsISupports> > doomed;
michael@0:     mFinishedWorker->ForgetMainThreadObjects(doomed);
michael@0: 
michael@0:     nsTArray<nsCString> hostObjectURIs;
michael@0:     mFinishedWorker->StealHostObjectURIs(hostObjectURIs);
michael@0: 
michael@0:     nsRefPtr<MainThreadReleaseRunnable> runnable =
michael@0:       new MainThreadReleaseRunnable(doomed, hostObjectURIs);
michael@0:     if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
michael@0:       NS_WARNING("Failed to dispatch, going to leak!");
michael@0:     }
michael@0: 
michael@0:     mFinishedWorker->ClearSelfRef();
michael@0:     return NS_OK;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class ModifyBusyCountRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   bool mIncrease;
michael@0: 
michael@0: public:
michael@0:   ModifyBusyCountRunnable(WorkerPrivate* aWorkerPrivate, bool aIncrease)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount),
michael@0:     mIncrease(aIncrease)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     return aWorkerPrivate->ModifyBusyCount(aCx, mIncrease);
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult)
michael@0:           MOZ_OVERRIDE
michael@0:   {
michael@0:     if (mIncrease) {
michael@0:       WorkerControlRunnable::PostRun(aCx, aWorkerPrivate, aRunResult);
michael@0:       return;
michael@0:     }
michael@0:     // Don't do anything here as it's possible that aWorkerPrivate has been
michael@0:     // deleted.
michael@0:   }
michael@0: };
michael@0: 
michael@0: class CompileScriptRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0: public:
michael@0:   CompileScriptRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerRunnable(aWorkerPrivate, WorkerThreadModifyBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     JS::Rooted<JSObject*> global(aCx,
michael@0:       aWorkerPrivate->CreateGlobalScope(aCx));
michael@0:     if (!global) {
michael@0:       NS_WARNING("Failed to make global!");
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     JSAutoCompartment ac(aCx, global);
michael@0:     return scriptloader::LoadWorkerScript(aCx);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class CloseEventRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0: public:
michael@0:   CloseEventRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSUME_UNREACHABLE("Don't call Dispatch() on CloseEventRunnable!");
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSUME_UNREACHABLE("Don't call Dispatch() on CloseEventRunnable!");
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     JS::Rooted<JSObject*> target(aCx, JS::CurrentGlobalOrNull(aCx));
michael@0:     NS_ASSERTION(target, "This must never be null!");
michael@0: 
michael@0:     aWorkerPrivate->CloseHandlerStarted();
michael@0: 
michael@0:     WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope();
michael@0: 
michael@0:     nsCOMPtr<nsIDOMEvent> event;
michael@0:     nsresult rv =
michael@0:       NS_NewDOMEvent(getter_AddRefs(event), globalScope, nullptr, nullptr);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       Throw(aCx, rv);
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     rv = event->InitEvent(NS_LITERAL_STRING("close"), false, false);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       Throw(aCx, rv);
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     event->SetTrusted(true);
michael@0: 
michael@0:     globalScope->DispatchDOMEvent(nullptr, event, nullptr, nullptr);
michael@0: 
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult)
michael@0:           MOZ_OVERRIDE
michael@0:   {
michael@0:     // Report errors.
michael@0:     WorkerRunnable::PostRun(aCx, aWorkerPrivate, aRunResult);
michael@0: 
michael@0:     // Match the busy count increase from NotifyRunnable.
michael@0:     if (!aWorkerPrivate->ModifyBusyCountFromWorker(aCx, false)) {
michael@0:       JS_ReportPendingException(aCx);
michael@0:     }
michael@0: 
michael@0:     aWorkerPrivate->CloseHandlerFinished();
michael@0:   }
michael@0: };
michael@0: 
michael@0: class MessageEventRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0:   JSAutoStructuredCloneBuffer mBuffer;
michael@0:   nsTArray<nsCOMPtr<nsISupports> > mClonedObjects;
michael@0:   uint64_t mMessagePortSerial;
michael@0:   bool mToMessagePort;
michael@0: 
michael@0: public:
michael@0:   MessageEventRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                        TargetAndBusyBehavior aBehavior,
michael@0:                        JSAutoStructuredCloneBuffer&& aData,
michael@0:                        nsTArray<nsCOMPtr<nsISupports> >& aClonedObjects,
michael@0:                        bool aToMessagePort, uint64_t aMessagePortSerial)
michael@0:   : WorkerRunnable(aWorkerPrivate, aBehavior)
michael@0:   , mBuffer(Move(aData))
michael@0:   , mMessagePortSerial(aMessagePortSerial)
michael@0:   , mToMessagePort(aToMessagePort)
michael@0:   {
michael@0:     mClonedObjects.SwapElements(aClonedObjects);
michael@0:   }
michael@0: 
michael@0:   bool
michael@0:   DispatchDOMEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                    DOMEventTargetHelper* aTarget, bool aIsMainThread)
michael@0:   {
michael@0:     // Release reference to objects that were AddRef'd for
michael@0:     // cloning into worker when array goes out of scope.
michael@0:     nsTArray<nsCOMPtr<nsISupports>> clonedObjects;
michael@0:     clonedObjects.SwapElements(mClonedObjects);
michael@0: 
michael@0:     JS::Rooted<JS::Value> messageData(aCx);
michael@0:     if (!mBuffer.read(aCx, &messageData,
michael@0:                       workers::WorkerStructuredCloneCallbacks(aIsMainThread))) {
michael@0:       xpc::Throw(aCx, NS_ERROR_DOM_DATA_CLONE_ERR);
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     nsRefPtr<MessageEvent> event = new MessageEvent(aTarget, nullptr, nullptr);
michael@0:     nsresult rv =
michael@0:       event->InitMessageEvent(NS_LITERAL_STRING("message"),
michael@0:                               false /* non-bubbling */,
michael@0:                               true /* cancelable */,
michael@0:                               messageData,
michael@0:                               EmptyString(),
michael@0:                               EmptyString(),
michael@0:                               nullptr);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       xpc::Throw(aCx, rv);
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     event->SetTrusted(true);
michael@0: 
michael@0:     nsCOMPtr<nsIDOMEvent> domEvent = do_QueryObject(event);
michael@0: 
michael@0:     nsEventStatus dummy = nsEventStatus_eIgnore;
michael@0:     aTarget->DispatchDOMEvent(nullptr, domEvent, nullptr, &dummy);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSERT_IF(mToMessagePort, aWorkerPrivate->IsSharedWorker());
michael@0: 
michael@0:     if (mBehavior == ParentThreadUnchangedBusyCount) {
michael@0:       // Don't fire this event if the JS object has been disconnected from the
michael@0:       // private object.
michael@0:       if (!aWorkerPrivate->IsAcceptingEvents()) {
michael@0:         return true;
michael@0:       }
michael@0: 
michael@0:       if (mToMessagePort) {
michael@0:         return
michael@0:           aWorkerPrivate->DispatchMessageEventToMessagePort(aCx,
michael@0:                                                             mMessagePortSerial,
michael@0:                                                             Move(mBuffer),
michael@0:                                                             mClonedObjects);
michael@0:       }
michael@0: 
michael@0:       if (aWorkerPrivate->IsSuspended()) {
michael@0:         aWorkerPrivate->QueueRunnable(this);
michael@0:         return true;
michael@0:       }
michael@0: 
michael@0:       aWorkerPrivate->AssertInnerWindowIsCorrect();
michael@0: 
michael@0:       return DispatchDOMEvent(aCx, aWorkerPrivate, aWorkerPrivate,
michael@0:                               !aWorkerPrivate->GetParent());
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(aWorkerPrivate == GetWorkerPrivateFromContext(aCx));
michael@0: 
michael@0:     if (mToMessagePort) {
michael@0:       nsRefPtr<workers::MessagePort> port =
michael@0:         aWorkerPrivate->GetMessagePort(mMessagePortSerial);
michael@0:       if (!port) {
michael@0:         // Must have been closed already.
michael@0:         return true;
michael@0:       }
michael@0:       return DispatchDOMEvent(aCx, aWorkerPrivate, port, false);
michael@0:     }
michael@0: 
michael@0:     return DispatchDOMEvent(aCx, aWorkerPrivate, aWorkerPrivate->GlobalScope(),
michael@0:                             false);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class NotifyRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   Status mStatus;
michael@0: 
michael@0: public:
michael@0:   NotifyRunnable(WorkerPrivate* aWorkerPrivate, Status aStatus)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mStatus(aStatus)
michael@0:   {
michael@0:     MOZ_ASSERT(aStatus == Closing || aStatus == Terminating ||
michael@0:                aStatus == Canceling || aStatus == Killing);
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Modify here, but not in PostRun! This busy count addition will be matched
michael@0:     // by the CloseEventRunnable.
michael@0:     return aWorkerPrivate->ModifyBusyCount(aCx, true);
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     if (!aDispatchResult) {
michael@0:       // We couldn't dispatch to the worker, which means it's already dead.
michael@0:       // Undo the busy count modification.
michael@0:       aWorkerPrivate->ModifyBusyCount(aCx, false);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     return aWorkerPrivate->NotifyInternal(aCx, mStatus);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class CloseRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0: public:
michael@0:   CloseRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // This busy count will be matched by the CloseEventRunnable.
michael@0:     return aWorkerPrivate->ModifyBusyCount(aCx, true) &&
michael@0:            aWorkerPrivate->Close(aCx);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class SuspendRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0: public:
michael@0:   SuspendRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     return aWorkerPrivate->SuspendInternal(aCx);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class ResumeRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0: public:
michael@0:   ResumeRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     return aWorkerPrivate->ResumeInternal(aCx);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class ReportErrorRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0:   nsString mMessage;
michael@0:   nsString mFilename;
michael@0:   nsString mLine;
michael@0:   uint32_t mLineNumber;
michael@0:   uint32_t mColumnNumber;
michael@0:   uint32_t mFlags;
michael@0:   uint32_t mErrorNumber;
michael@0: 
michael@0: public:
michael@0:   // aWorkerPrivate is the worker thread we're on (or the main thread, if null)
michael@0:   // aTarget is the worker object that we are going to fire an error at
michael@0:   // (if any).
michael@0:   static bool
michael@0:   ReportError(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:               bool aFireAtScope, WorkerPrivate* aTarget,
michael@0:               const nsString& aMessage, const nsString& aFilename,
michael@0:               const nsString& aLine, uint32_t aLineNumber,
michael@0:               uint32_t aColumnNumber, uint32_t aFlags,
michael@0:               uint32_t aErrorNumber, uint64_t aInnerWindowId)
michael@0:   {
michael@0:     if (aWorkerPrivate) {
michael@0:       aWorkerPrivate->AssertIsOnWorkerThread();
michael@0:     }
michael@0:     else {
michael@0:       AssertIsOnMainThread();
michael@0:     }
michael@0: 
michael@0:     JS::Rooted<JSString*> message(aCx, JS_NewUCStringCopyN(aCx, aMessage.get(),
michael@0:                                                            aMessage.Length()));
michael@0:     if (!message) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     JS::Rooted<JSString*> filename(aCx, JS_NewUCStringCopyN(aCx, aFilename.get(),
michael@0:                                                             aFilename.Length()));
michael@0:     if (!filename) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // We should not fire error events for warnings but instead make sure that
michael@0:     // they show up in the error console.
michael@0:     if (!JSREPORT_IS_WARNING(aFlags)) {
michael@0:       // First fire an ErrorEvent at the worker.
michael@0:       RootedDictionary<ErrorEventInit> init(aCx);
michael@0:       init.mMessage = aMessage;
michael@0:       init.mFilename = aFilename;
michael@0:       init.mLineno = aLineNumber;
michael@0:       init.mCancelable = true;
michael@0:       init.mBubbles = true;
michael@0: 
michael@0:       if (aTarget) {
michael@0:         nsRefPtr<ErrorEvent> event =
michael@0:           ErrorEvent::Constructor(aTarget, NS_LITERAL_STRING("error"), init);
michael@0:         event->SetTrusted(true);
michael@0: 
michael@0:         nsEventStatus status = nsEventStatus_eIgnore;
michael@0:         aTarget->DispatchDOMEvent(nullptr, event, nullptr, &status);
michael@0: 
michael@0:         if (status == nsEventStatus_eConsumeNoDefault) {
michael@0:           return true;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       // Now fire an event at the global object, but don't do that if the error
michael@0:       // code is too much recursion and this is the same script threw the error.
michael@0:       if (aFireAtScope && (aTarget || aErrorNumber != JSMSG_OVER_RECURSED)) {
michael@0:         JS::Rooted<JSObject*> target(aCx, JS::CurrentGlobalOrNull(aCx));
michael@0:         NS_ASSERTION(target, "This should never be null!");
michael@0: 
michael@0:         nsEventStatus status = nsEventStatus_eIgnore;
michael@0:         nsIScriptGlobalObject* sgo;
michael@0: 
michael@0:         if (aWorkerPrivate) {
michael@0:           WorkerGlobalScope* globalTarget = aWorkerPrivate->GlobalScope();
michael@0:           MOZ_ASSERT(target == globalTarget->GetWrapperPreserveColor());
michael@0: 
michael@0:           nsRefPtr<ErrorEvent> event =
michael@0:             ErrorEvent::Constructor(aTarget, NS_LITERAL_STRING("error"), init);
michael@0:           event->SetTrusted(true);
michael@0: 
michael@0:           nsIDOMEventTarget* target = static_cast<nsIDOMEventTarget*>(globalTarget);
michael@0:           if (NS_FAILED(EventDispatcher::DispatchDOMEvent(target, nullptr,
michael@0:                                                           event, nullptr,
michael@0:                                                           &status))) {
michael@0:             NS_WARNING("Failed to dispatch worker thread error event!");
michael@0:             status = nsEventStatus_eIgnore;
michael@0:           }
michael@0:         }
michael@0:         else if ((sgo = nsJSUtils::GetStaticScriptGlobal(target))) {
michael@0:           MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:           if (NS_FAILED(sgo->HandleScriptError(init, &status))) {
michael@0:             NS_WARNING("Failed to dispatch main thread error event!");
michael@0:             status = nsEventStatus_eIgnore;
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         // Was preventDefault() called?
michael@0:         if (status == nsEventStatus_eConsumeNoDefault) {
michael@0:           return true;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Now fire a runnable to do the same on the parent's thread if we can.
michael@0:     if (aWorkerPrivate) {
michael@0:       nsRefPtr<ReportErrorRunnable> runnable =
michael@0:         new ReportErrorRunnable(aWorkerPrivate, aMessage, aFilename, aLine,
michael@0:                                 aLineNumber, aColumnNumber, aFlags,
michael@0:                                 aErrorNumber);
michael@0:       return runnable->Dispatch(aCx);
michael@0:     }
michael@0: 
michael@0:     // Otherwise log an error to the error console.
michael@0:     LogErrorToConsole(aMessage, aFilename, aLine, aLineNumber, aColumnNumber,
michael@0:                       aFlags, aInnerWindowId);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   ReportErrorRunnable(WorkerPrivate* aWorkerPrivate, const nsString& aMessage,
michael@0:                       const nsString& aFilename, const nsString& aLine,
michael@0:                       uint32_t aLineNumber, uint32_t aColumnNumber,
michael@0:                       uint32_t aFlags, uint32_t aErrorNumber)
michael@0:   : WorkerRunnable(aWorkerPrivate, ParentThreadUnchangedBusyCount),
michael@0:     mMessage(aMessage), mFilename(aFilename), mLine(aLine),
michael@0:     mLineNumber(aLineNumber), mColumnNumber(aColumnNumber), mFlags(aFlags),
michael@0:     mErrorNumber(aErrorNumber)
michael@0:   { }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->AssertIsOnWorkerThread();
michael@0: 
michael@0:     // Dispatch may fail if the worker was canceled, no need to report that as
michael@0:     // an error, so don't call base class PostDispatch.
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Don't fire this event if the JS object has been disconnected from the
michael@0:     // private object.
michael@0:     if (!aWorkerPrivate->IsAcceptingEvents()) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     JS::Rooted<JSObject*> target(aCx, aWorkerPrivate->GetWrapper());
michael@0: 
michael@0:     uint64_t innerWindowId;
michael@0:     bool fireAtScope = true;
michael@0: 
michael@0:     WorkerPrivate* parent = aWorkerPrivate->GetParent();
michael@0:     if (parent) {
michael@0:       innerWindowId = 0;
michael@0:     }
michael@0:     else {
michael@0:       AssertIsOnMainThread();
michael@0: 
michael@0:       if (aWorkerPrivate->IsSuspended()) {
michael@0:         aWorkerPrivate->QueueRunnable(this);
michael@0:         return true;
michael@0:       }
michael@0: 
michael@0:       if (aWorkerPrivate->IsSharedWorker()) {
michael@0:         aWorkerPrivate->BroadcastErrorToSharedWorkers(aCx, mMessage, mFilename,
michael@0:                                                       mLine, mLineNumber,
michael@0:                                                       mColumnNumber, mFlags);
michael@0:         return true;
michael@0:       }
michael@0: 
michael@0:       aWorkerPrivate->AssertInnerWindowIsCorrect();
michael@0: 
michael@0:       innerWindowId = aWorkerPrivate->GetInnerWindowId();
michael@0:     }
michael@0: 
michael@0:     return ReportError(aCx, parent, fireAtScope, aWorkerPrivate, mMessage,
michael@0:                        mFilename, mLine, mLineNumber, mColumnNumber, mFlags,
michael@0:                        mErrorNumber, innerWindowId);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class TimerRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0: public:
michael@0:   TimerRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions.
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions.
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     return aWorkerPrivate->RunExpiredTimeouts(aCx);
michael@0:   }
michael@0: };
michael@0: 
michael@0: void
michael@0: DummyCallback(nsITimer* aTimer, void* aClosure)
michael@0: {
michael@0:   // Nothing!
michael@0: }
michael@0: 
michael@0: class TimerThreadEventTarget MOZ_FINAL : public nsIEventTarget
michael@0: {
michael@0:   WorkerPrivate* mWorkerPrivate;
michael@0:   nsRefPtr<WorkerRunnable> mWorkerRunnable;
michael@0: 
michael@0: public:
michael@0:   TimerThreadEventTarget(WorkerPrivate* aWorkerPrivate,
michael@0:                          WorkerRunnable* aWorkerRunnable)
michael@0:   : mWorkerPrivate(aWorkerPrivate), mWorkerRunnable(aWorkerRunnable)
michael@0:   {
michael@0:     MOZ_ASSERT(aWorkerPrivate);
michael@0:     MOZ_ASSERT(aWorkerRunnable);
michael@0:   }
michael@0: 
michael@0:   NS_DECL_THREADSAFE_ISUPPORTS
michael@0: 
michael@0: protected:
michael@0:   NS_IMETHOD
michael@0:   Dispatch(nsIRunnable* aRunnable, uint32_t aFlags) MOZ_OVERRIDE
michael@0:   {
michael@0:     // This should only happen on the timer thread.
michael@0:     MOZ_ASSERT(!NS_IsMainThread());
michael@0:     MOZ_ASSERT(aFlags == nsIEventTarget::DISPATCH_NORMAL);
michael@0: 
michael@0:     nsRefPtr<TimerThreadEventTarget> kungFuDeathGrip = this;
michael@0: 
michael@0:     // Run the runnable we're given now (should just call DummyCallback()),
michael@0:     // otherwise the timer thread will leak it...  If we run this after
michael@0:     // dispatch running the event can race against resetting the timer.
michael@0:     aRunnable->Run();
michael@0: 
michael@0:     // This can fail if we're racing to terminate or cancel, should be handled
michael@0:     // by the terminate or cancel code.
michael@0:     mWorkerRunnable->Dispatch(nullptr);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   IsOnCurrentThread(bool* aIsOnCurrentThread) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSERT(aIsOnCurrentThread);
michael@0: 
michael@0:     nsresult rv = mWorkerPrivate->IsOnCurrentThread(aIsOnCurrentThread);
michael@0:     if (NS_WARN_IF(NS_FAILED(rv))) {
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class KillCloseEventRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0:   nsCOMPtr<nsITimer> mTimer;
michael@0: 
michael@0:   class KillScriptRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0:   {
michael@0:   public:
michael@0:     KillScriptRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:     : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:     { }
michael@0: 
michael@0:   private:
michael@0:     virtual bool
michael@0:     PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:     {
michael@0:       // Silence bad assertions, this is dispatched from the timer thread.
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     virtual void
michael@0:     PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                  bool aDispatchResult) MOZ_OVERRIDE
michael@0:     {
michael@0:       // Silence bad assertions, this is dispatched from the timer thread.
michael@0:     }
michael@0: 
michael@0:     virtual bool
michael@0:     WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:     {
michael@0:       // Kill running script.
michael@0:       return false;
michael@0:     }
michael@0:   };
michael@0: 
michael@0: public:
michael@0:   KillCloseEventRunnable(WorkerPrivate* aWorkerPrivate)
michael@0:   : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
michael@0:   { }
michael@0: 
michael@0:   bool
michael@0:   SetTimeout(JSContext* aCx, uint32_t aDelayMS)
michael@0:   {
michael@0:     nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
michael@0:     if (!timer) {
michael@0:       JS_ReportError(aCx, "Failed to create timer!");
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     nsRefPtr<KillScriptRunnable> runnable =
michael@0:       new KillScriptRunnable(mWorkerPrivate);
michael@0: 
michael@0:     nsRefPtr<TimerThreadEventTarget> target =
michael@0:       new TimerThreadEventTarget(mWorkerPrivate, runnable);
michael@0: 
michael@0:     if (NS_FAILED(timer->SetTarget(target))) {
michael@0:       JS_ReportError(aCx, "Failed to set timer's target!");
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     if (NS_FAILED(timer->InitWithFuncCallback(DummyCallback, nullptr, aDelayMS,
michael@0:                                               nsITimer::TYPE_ONE_SHOT))) {
michael@0:       JS_ReportError(aCx, "Failed to start timer!");
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     mTimer.swap(timer);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   ~KillCloseEventRunnable()
michael@0:   {
michael@0:     if (mTimer) {
michael@0:       mTimer->Cancel();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSUME_UNREACHABLE("Don't call Dispatch() on KillCloseEventRunnable!");
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSUME_UNREACHABLE("Don't call Dispatch() on KillCloseEventRunnable!");
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     if (mTimer) {
michael@0:       mTimer->Cancel();
michael@0:       mTimer = nullptr;
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class UpdateRuntimeAndContextOptionsRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   JS::RuntimeOptions mRuntimeOptions;
michael@0:   JS::ContextOptions mContentCxOptions;
michael@0:   JS::ContextOptions mChromeCxOptions;
michael@0: 
michael@0: public:
michael@0:   UpdateRuntimeAndContextOptionsRunnable(
michael@0:                                     WorkerPrivate* aWorkerPrivate,
michael@0:                                     const JS::RuntimeOptions& aRuntimeOptions,
michael@0:                                     const JS::ContextOptions& aContentCxOptions,
michael@0:                                     const JS::ContextOptions& aChromeCxOptions)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mRuntimeOptions(aRuntimeOptions),
michael@0:     mContentCxOptions(aContentCxOptions),
michael@0:     mChromeCxOptions(aChromeCxOptions)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->UpdateRuntimeAndContextOptionsInternal(aCx,
michael@0:                                                            mRuntimeOptions,
michael@0:                                                            mContentCxOptions,
michael@0:                                                            mChromeCxOptions);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class UpdatePreferenceRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   WorkerPreference mPref;
michael@0:   bool mValue;
michael@0: 
michael@0: public:
michael@0:   UpdatePreferenceRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                            WorkerPreference aPref,
michael@0:                            bool aValue)
michael@0:     : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:       mPref(aPref),
michael@0:       mValue(aValue)
michael@0:   { }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->UpdatePreferenceInternal(aCx, mPref, mValue);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class UpdateJSWorkerMemoryParameterRunnable MOZ_FINAL :
michael@0:   public WorkerControlRunnable
michael@0: {
michael@0:   uint32_t mValue;
michael@0:   JSGCParamKey mKey;
michael@0: 
michael@0: public:
michael@0:   UpdateJSWorkerMemoryParameterRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                                         JSGCParamKey aKey,
michael@0:                                         uint32_t aValue)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mValue(aValue), mKey(aKey)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->UpdateJSWorkerMemoryParameterInternal(aCx, mKey, mValue);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: #ifdef JS_GC_ZEAL
michael@0: class UpdateGCZealRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   uint8_t mGCZeal;
michael@0:   uint32_t mFrequency;
michael@0: 
michael@0: public:
michael@0:   UpdateGCZealRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                        uint8_t aGCZeal,
michael@0:                        uint32_t aFrequency)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mGCZeal(aGCZeal), mFrequency(aFrequency)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->UpdateGCZealInternal(aCx, mGCZeal, mFrequency);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: #endif
michael@0: 
michael@0: class GarbageCollectRunnable MOZ_FINAL : public WorkerControlRunnable
michael@0: {
michael@0:   bool mShrinking;
michael@0:   bool mCollectChildren;
michael@0: 
michael@0: public:
michael@0:   GarbageCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aShrinking,
michael@0:                          bool aCollectChildren)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mShrinking(aShrinking), mCollectChildren(aCollectChildren)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   virtual bool
michael@0:   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions, this can be dispatched from either the main
michael@0:     // thread or the timer thread..
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
michael@0:                 bool aDispatchResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     // Silence bad assertions, this can be dispatched from either the main
michael@0:     // thread or the timer thread..
michael@0:   }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     aWorkerPrivate->GarbageCollectInternal(aCx, mShrinking, mCollectChildren);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class CycleCollectRunnable : public WorkerControlRunnable
michael@0: {
michael@0:   bool mCollectChildren;
michael@0: 
michael@0: public:
michael@0:   CycleCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aCollectChildren)
michael@0:   : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
michael@0:     mCollectChildren(aCollectChildren)
michael@0:   { }
michael@0: 
michael@0:   bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
michael@0:   {
michael@0:     aWorkerPrivate->CycleCollectInternal(aCx, mCollectChildren);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class OfflineStatusChangeRunnable : public WorkerRunnable
michael@0: {
michael@0: public:
michael@0:   OfflineStatusChangeRunnable(WorkerPrivate* aWorkerPrivate, bool aIsOffline)
michael@0:     : WorkerRunnable(aWorkerPrivate, WorkerThreadModifyBusyCount),
michael@0:       mIsOffline(aIsOffline)
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
michael@0:   {
michael@0:     aWorkerPrivate->OfflineStatusChangeEventInternal(aCx, mIsOffline);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   bool mIsOffline;
michael@0: };
michael@0: 
michael@0: class WorkerJSRuntimeStats : public JS::RuntimeStats
michael@0: {
michael@0:   const nsACString& mRtPath;
michael@0: 
michael@0: public:
michael@0:   WorkerJSRuntimeStats(const nsACString& aRtPath)
michael@0:   : JS::RuntimeStats(JsWorkerMallocSizeOf), mRtPath(aRtPath)
michael@0:   { }
michael@0: 
michael@0:   ~WorkerJSRuntimeStats()
michael@0:   {
michael@0:     for (size_t i = 0; i != zoneStatsVector.length(); i++) {
michael@0:       delete static_cast<xpc::ZoneStatsExtras*>(zoneStatsVector[i].extra);
michael@0:     }
michael@0: 
michael@0:     for (size_t i = 0; i != compartmentStatsVector.length(); i++) {
michael@0:       delete static_cast<xpc::CompartmentStatsExtras*>(compartmentStatsVector[i].extra);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   initExtraZoneStats(JS::Zone* aZone,
michael@0:                      JS::ZoneStats* aZoneStats)
michael@0:                      MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSERT(!aZoneStats->extra);
michael@0: 
michael@0:     // ReportJSRuntimeExplicitTreeStats expects that
michael@0:     // aZoneStats->extra is a xpc::ZoneStatsExtras pointer.
michael@0:     xpc::ZoneStatsExtras* extras = new xpc::ZoneStatsExtras;
michael@0:     extras->pathPrefix = mRtPath;
michael@0:     extras->pathPrefix += nsPrintfCString("zone(0x%p)/", (void *)aZone);
michael@0:     aZoneStats->extra = extras;
michael@0:   }
michael@0: 
michael@0:   virtual void
michael@0:   initExtraCompartmentStats(JSCompartment* aCompartment,
michael@0:                             JS::CompartmentStats* aCompartmentStats)
michael@0:                             MOZ_OVERRIDE
michael@0:   {
michael@0:     MOZ_ASSERT(!aCompartmentStats->extra);
michael@0: 
michael@0:     // ReportJSRuntimeExplicitTreeStats expects that
michael@0:     // aCompartmentStats->extra is a xpc::CompartmentStatsExtras pointer.
michael@0:     xpc::CompartmentStatsExtras* extras = new xpc::CompartmentStatsExtras;
michael@0: 
michael@0:     // This is the |jsPathPrefix|.  Each worker has exactly two compartments:
michael@0:     // one for atoms, and one for everything else.
michael@0:     extras->jsPathPrefix.Assign(mRtPath);
michael@0:     extras->jsPathPrefix += nsPrintfCString("zone(0x%p)/",
michael@0:                                             (void *)js::GetCompartmentZone(aCompartment));
michael@0:     extras->jsPathPrefix += js::IsAtomsCompartment(aCompartment)
michael@0:                             ? NS_LITERAL_CSTRING("compartment(web-worker-atoms)/")
michael@0:                             : NS_LITERAL_CSTRING("compartment(web-worker)/");
michael@0: 
michael@0:     // This should never be used when reporting with workers (hence the "?!").
michael@0:     extras->domPathPrefix.AssignLiteral("explicit/workers/?!/");
michael@0: 
michael@0:     aCompartmentStats->extra = extras;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class MessagePortRunnable MOZ_FINAL : public WorkerRunnable
michael@0: {
michael@0:   uint64_t mMessagePortSerial;
michael@0:   bool mConnect;
michael@0: 
michael@0: public:
michael@0:   MessagePortRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                       uint64_t aMessagePortSerial,
michael@0:                       bool aConnect)
michael@0:   : WorkerRunnable(aWorkerPrivate, aConnect ?
michael@0:                                    WorkerThreadModifyBusyCount :
michael@0:                                    WorkerThreadUnchangedBusyCount),
michael@0:     mMessagePortSerial(aMessagePortSerial), mConnect(aConnect)
michael@0:   { }
michael@0: 
michael@0: private:
michael@0:   ~MessagePortRunnable()
michael@0:   { }
michael@0: 
michael@0:   virtual bool
michael@0:   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
michael@0:   {
michael@0:     if (mConnect) {
michael@0:       return aWorkerPrivate->ConnectMessagePort(aCx, mMessagePortSerial);
michael@0:     }
michael@0: 
michael@0:     aWorkerPrivate->DisconnectMessagePort(mMessagePortSerial);
michael@0:     return true;
michael@0:   }
michael@0: };
michael@0: 
michael@0: #ifdef DEBUG
michael@0: 
michael@0: PRThread*
michael@0: PRThreadFromThread(nsIThread* aThread)
michael@0: {
michael@0:   MOZ_ASSERT(aThread);
michael@0: 
michael@0:   PRThread* result;
michael@0:   MOZ_ASSERT(NS_SUCCEEDED(aThread->GetPRThread(&result)));
michael@0:   MOZ_ASSERT(result);
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: #endif // DEBUG
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: NS_IMPL_ISUPPORTS_INHERITED0(MainThreadReleaseRunnable, nsRunnable)
michael@0: 
michael@0: NS_IMPL_ISUPPORTS_INHERITED0(TopLevelWorkerFinishedRunnable, nsRunnable)
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(TimerThreadEventTarget, nsIEventTarget)
michael@0: 
michael@0: template <class Derived>
michael@0: class WorkerPrivateParent<Derived>::SynchronizeAndResumeRunnable MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   friend class nsRevocableEventPtr<SynchronizeAndResumeRunnable>;
michael@0: 
michael@0:   WorkerPrivate* mWorkerPrivate;
michael@0:   nsCOMPtr<nsPIDOMWindow> mWindow;
michael@0:   nsCOMPtr<nsIScriptContext> mScriptContext;
michael@0: 
michael@0: public:
michael@0:   SynchronizeAndResumeRunnable(WorkerPrivate* aWorkerPrivate,
michael@0:                                nsPIDOMWindow* aWindow,
michael@0:                                nsIScriptContext* aScriptContext)
michael@0:   : mWorkerPrivate(aWorkerPrivate), mWindow(aWindow),
michael@0:     mScriptContext(aScriptContext)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(aWorkerPrivate);
michael@0:     MOZ_ASSERT(aWindow);
michael@0:     MOZ_ASSERT(!aWorkerPrivate->GetParent());
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   ~SynchronizeAndResumeRunnable()
michael@0:   { }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run() MOZ_OVERRIDE
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     if (mWorkerPrivate) {
michael@0:       AutoPushJSContext cx(mScriptContext ?
michael@0:                            mScriptContext->GetNativeContext() :
michael@0:                            nsContentUtils::GetSafeJSContext());
michael@0: 
michael@0:       if (!mWorkerPrivate->Resume(cx, mWindow)) {
michael@0:         JS_ReportPendingException(cx);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   Revoke()
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(mWorkerPrivate);
michael@0:     MOZ_ASSERT(mWindow);
michael@0: 
michael@0:     mWorkerPrivate = nullptr;
michael@0:     mWindow = nullptr;
michael@0:     mScriptContext = nullptr;
michael@0:   }
michael@0: };
michael@0: 
michael@0: template <class Derived>
michael@0: class WorkerPrivateParent<Derived>::EventTarget MOZ_FINAL
michael@0:   : public nsIEventTarget
michael@0: {
michael@0:   // This mutex protects mWorkerPrivate and must be acquired *before* the
michael@0:   // WorkerPrivate's mutex whenever they must both be held.
michael@0:   mozilla::Mutex mMutex;
michael@0:   WorkerPrivate* mWorkerPrivate;
michael@0:   nsIEventTarget* mWeakNestedEventTarget;
michael@0:   nsCOMPtr<nsIEventTarget> mNestedEventTarget;
michael@0: 
michael@0: public:
michael@0:   EventTarget(WorkerPrivate* aWorkerPrivate)
michael@0:   : mMutex("WorkerPrivateParent::EventTarget::mMutex"),
michael@0:     mWorkerPrivate(aWorkerPrivate), mWeakNestedEventTarget(nullptr)
michael@0:   {
michael@0:     MOZ_ASSERT(aWorkerPrivate);
michael@0:   }
michael@0: 
michael@0:   EventTarget(WorkerPrivate* aWorkerPrivate, nsIEventTarget* aNestedEventTarget)
michael@0:   : mMutex("WorkerPrivateParent::EventTarget::mMutex"),
michael@0:     mWorkerPrivate(aWorkerPrivate), mWeakNestedEventTarget(aNestedEventTarget),
michael@0:     mNestedEventTarget(aNestedEventTarget)
michael@0:   {
michael@0:     MOZ_ASSERT(aWorkerPrivate);
michael@0:     MOZ_ASSERT(aNestedEventTarget);
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   Disable()
michael@0:   {
michael@0:     nsCOMPtr<nsIEventTarget> nestedEventTarget;
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0: 
michael@0:       MOZ_ASSERT(mWorkerPrivate);
michael@0:       mWorkerPrivate = nullptr;
michael@0:       mNestedEventTarget.swap(nestedEventTarget);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsIEventTarget*
michael@0:   GetWeakNestedEventTarget() const
michael@0:   {
michael@0:     MOZ_ASSERT(mWeakNestedEventTarget);
michael@0:     return mWeakNestedEventTarget;
michael@0:   }
michael@0: 
michael@0:   NS_DECL_THREADSAFE_ISUPPORTS
michael@0:   NS_DECL_NSIEVENTTARGET
michael@0: 
michael@0: private:
michael@0:   ~EventTarget()
michael@0:   { }
michael@0: };
michael@0: 
michael@0: struct WorkerPrivate::TimeoutInfo
michael@0: {
michael@0:   TimeoutInfo()
michael@0:   : mTimeoutCallable(JS::UndefinedValue()), mLineNumber(0), mId(0),
michael@0:     mIsInterval(false), mCanceled(false)
michael@0:   {
michael@0:     MOZ_COUNT_CTOR(mozilla::dom::workers::WorkerPrivate::TimeoutInfo);
michael@0:   }
michael@0: 
michael@0:   ~TimeoutInfo()
michael@0:   {
michael@0:     MOZ_COUNT_DTOR(mozilla::dom::workers::WorkerPrivate::TimeoutInfo);
michael@0:   }
michael@0: 
michael@0:   bool operator==(const TimeoutInfo& aOther)
michael@0:   {
michael@0:     return mTargetTime == aOther.mTargetTime;
michael@0:   }
michael@0: 
michael@0:   bool operator<(const TimeoutInfo& aOther)
michael@0:   {
michael@0:     return mTargetTime < aOther.mTargetTime;
michael@0:   }
michael@0: 
michael@0:   JS::Heap<JS::Value> mTimeoutCallable;
michael@0:   nsString mTimeoutString;
michael@0:   nsTArray<JS::Heap<JS::Value> > mExtraArgVals;
michael@0:   mozilla::TimeStamp mTargetTime;
michael@0:   mozilla::TimeDuration mInterval;
michael@0:   nsCString mFilename;
michael@0:   uint32_t mLineNumber;
michael@0:   int32_t mId;
michael@0:   bool mIsInterval;
michael@0:   bool mCanceled;
michael@0: };
michael@0: 
michael@0: class WorkerPrivate::MemoryReporter MOZ_FINAL : public nsIMemoryReporter
michael@0: {
michael@0:   NS_DECL_THREADSAFE_ISUPPORTS
michael@0: 
michael@0:   friend class WorkerPrivate;
michael@0: 
michael@0:   SharedMutex mMutex;
michael@0:   WorkerPrivate* mWorkerPrivate;
michael@0:   nsCString mRtPath;
michael@0:   bool mAlreadyMappedToAddon;
michael@0: 
michael@0: public:
michael@0:   MemoryReporter(WorkerPrivate* aWorkerPrivate)
michael@0:   : mMutex(aWorkerPrivate->mMutex), mWorkerPrivate(aWorkerPrivate),
michael@0:     mAlreadyMappedToAddon(false)
michael@0:   {
michael@0:     aWorkerPrivate->AssertIsOnWorkerThread();
michael@0: 
michael@0:     nsCString escapedDomain(aWorkerPrivate->Domain());
michael@0:     escapedDomain.ReplaceChar('/', '\\');
michael@0: 
michael@0:     NS_ConvertUTF16toUTF8 escapedURL(aWorkerPrivate->ScriptURL());
michael@0:     escapedURL.ReplaceChar('/', '\\');
michael@0: 
michael@0:     nsAutoCString addressString;
michael@0:     addressString.AppendPrintf("0x%p", static_cast<void*>(aWorkerPrivate));
michael@0: 
michael@0:     mRtPath = NS_LITERAL_CSTRING("explicit/workers/workers(") +
michael@0:               escapedDomain + NS_LITERAL_CSTRING(")/worker(") +
michael@0:               escapedURL + NS_LITERAL_CSTRING(", ") + addressString +
michael@0:               NS_LITERAL_CSTRING(")/");
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   CollectReports(nsIMemoryReporterCallback* aCallback,
michael@0:                  nsISupports* aClosure)
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     // Assumes that WorkerJSRuntimeStats will hold a reference to mRtPath,
michael@0:     // and not a copy, as TryToMapAddon() may later modify the string again.
michael@0:     WorkerJSRuntimeStats rtStats(mRtPath);
michael@0: 
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0: 
michael@0:       TryToMapAddon();
michael@0: 
michael@0:       if (!mWorkerPrivate ||
michael@0:           !mWorkerPrivate->BlockAndCollectRuntimeStats(&rtStats)) {
michael@0:         // Returning NS_OK here will effectively report 0 memory.
michael@0:         return NS_OK;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     return xpc::ReportJSRuntimeExplicitTreeStats(rtStats, mRtPath,
michael@0:                                                  aCallback, aClosure);
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   ~MemoryReporter()
michael@0:   { }
michael@0: 
michael@0:   void
michael@0:   Disable()
michael@0:   {
michael@0:     // Called from WorkerPrivate::DisableMemoryReporter.
michael@0:     mMutex.AssertCurrentThreadOwns();
michael@0: 
michael@0:     NS_ASSERTION(mWorkerPrivate, "Disabled more than once!");
michael@0:     mWorkerPrivate = nullptr;
michael@0:   }
michael@0: 
michael@0:   // Only call this from the main thread and under mMutex lock.
michael@0:   void
michael@0:   TryToMapAddon()
michael@0:   {
michael@0:     AssertIsOnMainThread();
michael@0:     mMutex.AssertCurrentThreadOwns();
michael@0: 
michael@0:     if (mAlreadyMappedToAddon || !mWorkerPrivate) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIURI> scriptURI;
michael@0:     if (NS_FAILED(NS_NewURI(getter_AddRefs(scriptURI),
michael@0:                             mWorkerPrivate->ScriptURL()))) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     mAlreadyMappedToAddon = true;
michael@0: 
michael@0:     if (XRE_GetProcessType() != GeckoProcessType_Default) {
michael@0:       // Only try to access the service from the main process.
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     nsAutoCString addonId;
michael@0:     bool ok;
michael@0:     nsCOMPtr<amIAddonManager> addonManager =
michael@0:       do_GetService("@mozilla.org/addons/integration;1");
michael@0: 
michael@0:     if (!addonManager ||
michael@0:         NS_FAILED(addonManager->MapURIToAddonID(scriptURI, addonId, &ok)) ||
michael@0:         !ok) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     static const size_t explicitLength = strlen("explicit/");
michael@0:     addonId.Insert(NS_LITERAL_CSTRING("add-ons/"), 0);
michael@0:     addonId += "/";
michael@0:     mRtPath.Insert(addonId, explicitLength);
michael@0:   }
michael@0: };
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(WorkerPrivate::MemoryReporter, nsIMemoryReporter)
michael@0: 
michael@0: WorkerPrivate::SyncLoopInfo::SyncLoopInfo(EventTarget* aEventTarget)
michael@0: : mEventTarget(aEventTarget), mCompleted(false), mResult(false)
michael@0: #ifdef DEBUG
michael@0:   , mHasRun(false)
michael@0: #endif
michael@0: {
michael@0: }
michael@0: 
michael@0: // Can't use NS_IMPL_CYCLE_COLLECTION_CLASS(WorkerPrivateParent) because of the
michael@0: // templates.
michael@0: template <class Derived>
michael@0: typename WorkerPrivateParent<Derived>::cycleCollection
michael@0:   WorkerPrivateParent<Derived>::_cycleCollectorGlobal =
michael@0:     WorkerPrivateParent<Derived>::cycleCollection();
michael@0: 
michael@0: template <class Derived>
michael@0: WorkerPrivateParent<Derived>::WorkerPrivateParent(
michael@0:                                            JSContext* aCx,
michael@0:                                            WorkerPrivate* aParent,
michael@0:                                            const nsAString& aScriptURL,
michael@0:                                            bool aIsChromeWorker,
michael@0:                                            WorkerType aWorkerType,
michael@0:                                            const nsACString& aSharedWorkerName,
michael@0:                                            LoadInfo& aLoadInfo)
michael@0: : mMutex("WorkerPrivateParent Mutex"),
michael@0:   mCondVar(mMutex, "WorkerPrivateParent CondVar"),
michael@0:   mMemoryReportCondVar(mMutex, "WorkerPrivateParent Memory Report CondVar"),
michael@0:   mParent(aParent), mScriptURL(aScriptURL),
michael@0:   mSharedWorkerName(aSharedWorkerName), mBusyCount(0), mMessagePortSerial(0),
michael@0:   mParentStatus(Pending), mParentSuspended(false),
michael@0:   mIsChromeWorker(aIsChromeWorker), mMainThreadObjectsForgotten(false),
michael@0:   mWorkerType(aWorkerType),
michael@0:   mCreationTimeStamp(TimeStamp::Now())
michael@0: {
michael@0:   SetIsDOMBinding();
michael@0: 
michael@0:   MOZ_ASSERT_IF(IsSharedWorker(), !aSharedWorkerName.IsVoid() &&
michael@0:                                   NS_IsMainThread());
michael@0:   MOZ_ASSERT_IF(!IsSharedWorker(), aSharedWorkerName.IsEmpty());
michael@0: 
michael@0:   if (aLoadInfo.mWindow) {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(aLoadInfo.mWindow->IsInnerWindow(),
michael@0:                "Should have inner window here!");
michael@0:     BindToOwner(aLoadInfo.mWindow);
michael@0:   }
michael@0: 
michael@0:   mLoadInfo.StealFrom(aLoadInfo);
michael@0: 
michael@0:   if (aParent) {
michael@0:     aParent->AssertIsOnWorkerThread();
michael@0: 
michael@0:     aParent->CopyJSSettings(mJSSettings);
michael@0:   }
michael@0:   else {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     RuntimeService::GetDefaultJSSettings(mJSSettings);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: WorkerPrivateParent<Derived>::~WorkerPrivateParent()
michael@0: {
michael@0:   DropJSObjects(this);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: JSObject*
michael@0: WorkerPrivateParent<Derived>::WrapObject(JSContext* aCx)
michael@0: {
michael@0:   MOZ_ASSERT(!IsSharedWorker(),
michael@0:              "We should never wrap a WorkerPrivate for a SharedWorker");
michael@0: 
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   // XXXkhuey this should not need to be rooted, the analysis is dumb.
michael@0:   // See bug 980181.
michael@0:   JS::Rooted<JSObject*> wrapper(aCx,
michael@0:     WorkerBinding::Wrap(aCx, ParentAsWorkerPrivate()));
michael@0:   if (wrapper) {
michael@0:     MOZ_ALWAYS_TRUE(TryPreserveWrapper(wrapper));
michael@0:   }
michael@0: 
michael@0:   return wrapper;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: nsresult
michael@0: WorkerPrivateParent<Derived>::DispatchPrivate(WorkerRunnable* aRunnable,
michael@0:                                               nsIEventTarget* aSyncLoopTarget)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   WorkerPrivate* self = ParentAsWorkerPrivate();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     MOZ_ASSERT_IF(aSyncLoopTarget, self->mThread);
michael@0: 
michael@0:     if (!self->mThread) {
michael@0:       if (ParentStatus() == Pending || self->mStatus == Pending) {
michael@0:         mPreStartRunnables.AppendElement(aRunnable);
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       NS_WARNING("Using a worker event target after the thread has already"
michael@0:                  "been released!");
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     if (self->mStatus == Dead ||
michael@0:         (!aSyncLoopTarget && ParentStatus() > Running)) {
michael@0:       NS_WARNING("A runnable was posted to a worker that is already shutting "
michael@0:                  "down!");
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIEventTarget> target;
michael@0:     if (aSyncLoopTarget) {
michael@0:       target = aSyncLoopTarget;
michael@0:     }
michael@0:     else {
michael@0:       target = self->mThread;
michael@0:     }
michael@0: 
michael@0:     nsresult rv = target->Dispatch(aRunnable, NS_DISPATCH_NORMAL);
michael@0:     if (NS_WARN_IF(NS_FAILED(rv))) {
michael@0:       return rv;
michael@0:     }
michael@0: 
michael@0:     mCondVar.Notify();
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: nsresult
michael@0: WorkerPrivateParent<Derived>::DispatchControlRunnable(
michael@0:                                   WorkerControlRunnable* aWorkerControlRunnable)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   MOZ_ASSERT(aWorkerControlRunnable);
michael@0: 
michael@0:   nsRefPtr<WorkerControlRunnable> runnable = aWorkerControlRunnable;
michael@0: 
michael@0:   WorkerPrivate* self = ParentAsWorkerPrivate();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (self->mStatus == Dead) {
michael@0:       NS_WARNING("A control runnable was posted to a worker that is already "
michael@0:                  "shutting down!");
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     // Transfer ownership to the control queue.
michael@0:     self->mControlQueue.Push(runnable.forget().take());
michael@0: 
michael@0:     if (JSContext* cx = self->mJSContext) {
michael@0:       MOZ_ASSERT(self->mThread);
michael@0: 
michael@0:       JSRuntime* rt = JS_GetRuntime(cx);
michael@0:       MOZ_ASSERT(rt);
michael@0: 
michael@0:       JS_RequestInterruptCallback(rt);
michael@0:     }
michael@0: 
michael@0:     mCondVar.Notify();
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: already_AddRefed<WorkerRunnable>
michael@0: WorkerPrivateParent<Derived>::MaybeWrapAsWorkerRunnable(nsIRunnable* aRunnable)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   MOZ_ASSERT(aRunnable);
michael@0: 
michael@0:   nsRefPtr<WorkerRunnable> workerRunnable =
michael@0:     WorkerRunnable::FromRunnable(aRunnable);
michael@0:   if (workerRunnable) {
michael@0:     return workerRunnable.forget();
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsICancelableRunnable> cancelable = do_QueryInterface(aRunnable);
michael@0:   if (!cancelable) {
michael@0:     MOZ_CRASH("All runnables destined for a worker thread must be cancelable!");
michael@0:   }
michael@0: 
michael@0:   workerRunnable =
michael@0:     new ExternalRunnableWrapper(ParentAsWorkerPrivate(), cancelable);
michael@0:   return workerRunnable.forget();
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: already_AddRefed<nsIEventTarget>
michael@0: WorkerPrivateParent<Derived>::GetEventTarget()
michael@0: {
michael@0:   WorkerPrivate* self = ParentAsWorkerPrivate();
michael@0: 
michael@0:   nsCOMPtr<nsIEventTarget> target;
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (!mEventTarget &&
michael@0:         ParentStatus() <= Running &&
michael@0:         self->mStatus <= Running) {
michael@0:       mEventTarget = new EventTarget(self);
michael@0:     }
michael@0: 
michael@0:     target = mEventTarget;
michael@0:   }
michael@0: 
michael@0:   NS_WARN_IF_FALSE(target,
michael@0:                    "Requested event target for a worker that is already "
michael@0:                    "shutting down!");
michael@0: 
michael@0:   return target.forget();
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::Start()
michael@0: {
michael@0:   // May be called on any thread!
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     NS_ASSERTION(mParentStatus != Running, "How can this be?!");
michael@0: 
michael@0:     if (mParentStatus == Pending) {
michael@0:       mParentStatus = Running;
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: // aCx is null when called from the finalizer
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::NotifyPrivate(JSContext* aCx, Status aStatus)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   bool pending;
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mParentStatus >= aStatus) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     pending = mParentStatus == Pending;
michael@0:     mParentStatus = aStatus;
michael@0:   }
michael@0: 
michael@0:   if (IsSharedWorker()) {
michael@0:     RuntimeService* runtime = RuntimeService::GetService();
michael@0:     MOZ_ASSERT(runtime);
michael@0: 
michael@0:     runtime->ForgetSharedWorker(ParentAsWorkerPrivate());
michael@0:   }
michael@0: 
michael@0:   if (pending) {
michael@0:     WorkerPrivate* self = ParentAsWorkerPrivate();
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     {
michael@0:       // Fake a thread here just so that our assertions don't go off for no
michael@0:       // reason.
michael@0:       nsIThread* currentThread = NS_GetCurrentThread();
michael@0:       MOZ_ASSERT(currentThread);
michael@0: 
michael@0:       MOZ_ASSERT(!self->mPRThread);
michael@0:       self->mPRThread = PRThreadFromThread(currentThread);
michael@0:       MOZ_ASSERT(self->mPRThread);
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     // Worker never got a chance to run, go ahead and delete it.
michael@0:     self->ScheduleDeletion(WorkerPrivate::WorkerNeverRan);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Only top-level workers should have a synchronize runnable.
michael@0:   MOZ_ASSERT_IF(mSynchronizeRunnable.get(), !GetParent());
michael@0:   mSynchronizeRunnable.Revoke();
michael@0: 
michael@0:   NS_ASSERTION(aStatus != Terminating || mQueuedRunnables.IsEmpty(),
michael@0:                "Shouldn't have anything queued!");
michael@0: 
michael@0:   // Anything queued will be discarded.
michael@0:   mQueuedRunnables.Clear();
michael@0: 
michael@0:   nsRefPtr<NotifyRunnable> runnable =
michael@0:     new NotifyRunnable(ParentAsWorkerPrivate(), aStatus);
michael@0:   return runnable->Dispatch(aCx);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::Suspend(JSContext* aCx, nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0:   MOZ_ASSERT(aCx);
michael@0: 
michael@0:   // Shared workers are only suspended if all of their owning documents are
michael@0:   // suspended.
michael@0:   if (IsSharedWorker()) {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(mSharedWorkers.Count());
michael@0: 
michael@0:     struct Closure
michael@0:     {
michael@0:       nsPIDOMWindow* mWindow;
michael@0:       bool mAllSuspended;
michael@0: 
michael@0:       Closure(nsPIDOMWindow* aWindow)
michael@0:       : mWindow(aWindow), mAllSuspended(true)
michael@0:       {
michael@0:         AssertIsOnMainThread();
michael@0:         // aWindow may be null here.
michael@0:       }
michael@0: 
michael@0:       static PLDHashOperator
michael@0:       Suspend(const uint64_t& aKey,
michael@0:               SharedWorker* aSharedWorker,
michael@0:               void* aClosure)
michael@0:       {
michael@0:         AssertIsOnMainThread();
michael@0:         MOZ_ASSERT(aSharedWorker);
michael@0:         MOZ_ASSERT(aClosure);
michael@0: 
michael@0:         auto closure = static_cast<Closure*>(aClosure);
michael@0: 
michael@0:         if (closure->mWindow && aSharedWorker->GetOwner() == closure->mWindow) {
michael@0:           // Calling Suspend() may change the refcount, ensure that the worker
michael@0:           // outlives this call.
michael@0:           nsRefPtr<SharedWorker> kungFuDeathGrip = aSharedWorker;
michael@0: 
michael@0:           aSharedWorker->Suspend();
michael@0:         } else {
michael@0:           MOZ_ASSERT_IF(aSharedWorker->GetOwner() && closure->mWindow,
michael@0:                         !SameCOMIdentity(aSharedWorker->GetOwner(),
michael@0:                                          closure->mWindow));
michael@0:           if (!aSharedWorker->IsSuspended()) {
michael@0:             closure->mAllSuspended = false;
michael@0:           }
michael@0:         }
michael@0:         return PL_DHASH_NEXT;
michael@0:       }
michael@0:     };
michael@0: 
michael@0:     Closure closure(aWindow);
michael@0: 
michael@0:     mSharedWorkers.EnumerateRead(Closure::Suspend, &closure);
michael@0: 
michael@0:     if (!closure.mAllSuspended || mParentSuspended) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0: //  MOZ_ASSERT(!mParentSuspended, "Suspended more than once!");
michael@0: 
michael@0:   mParentSuspended = true;
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mParentStatus >= Terminating) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<SuspendRunnable> runnable =
michael@0:     new SuspendRunnable(ParentAsWorkerPrivate());
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::Resume(JSContext* aCx, nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0:   MOZ_ASSERT(aCx);
michael@0:   MOZ_ASSERT_IF(!IsSharedWorker(), mParentSuspended);
michael@0: 
michael@0:   // Shared workers are resumed if any of their owning documents are resumed.
michael@0:   if (IsSharedWorker()) {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(mSharedWorkers.Count());
michael@0: 
michael@0:     struct Closure
michael@0:     {
michael@0:       nsPIDOMWindow* mWindow;
michael@0:       bool mAnyRunning;
michael@0: 
michael@0:       Closure(nsPIDOMWindow* aWindow)
michael@0:       : mWindow(aWindow), mAnyRunning(false)
michael@0:       {
michael@0:         AssertIsOnMainThread();
michael@0:         // aWindow may be null here.
michael@0:       }
michael@0: 
michael@0:       static PLDHashOperator
michael@0:       Resume(const uint64_t& aKey,
michael@0:               SharedWorker* aSharedWorker,
michael@0:               void* aClosure)
michael@0:       {
michael@0:         AssertIsOnMainThread();
michael@0:         MOZ_ASSERT(aSharedWorker);
michael@0:         MOZ_ASSERT(aClosure);
michael@0: 
michael@0:         auto closure = static_cast<Closure*>(aClosure);
michael@0: 
michael@0:         if (closure->mWindow && aSharedWorker->GetOwner() == closure->mWindow) {
michael@0:           // Calling Resume() may change the refcount, ensure that the worker
michael@0:           // outlives this call.
michael@0:           nsRefPtr<SharedWorker> kungFuDeathGrip = aSharedWorker;
michael@0: 
michael@0:           aSharedWorker->Resume();
michael@0:           closure->mAnyRunning = true;
michael@0:         } else {
michael@0:           MOZ_ASSERT_IF(aSharedWorker->GetOwner() && closure->mWindow,
michael@0:                         !SameCOMIdentity(aSharedWorker->GetOwner(),
michael@0:                                          closure->mWindow));
michael@0:           if (!aSharedWorker->IsSuspended()) {
michael@0:             closure->mAnyRunning = true;
michael@0:           }
michael@0:         }
michael@0:         return PL_DHASH_NEXT;
michael@0:       }
michael@0:     };
michael@0: 
michael@0:     Closure closure(aWindow);
michael@0: 
michael@0:     mSharedWorkers.EnumerateRead(Closure::Resume, &closure);
michael@0: 
michael@0:     if (!closure.mAnyRunning || !mParentSuspended) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(mParentSuspended);
michael@0: 
michael@0:   mParentSuspended = false;
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mParentStatus >= Terminating) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Only top-level workers should have a synchronize runnable.
michael@0:   MOZ_ASSERT_IF(mSynchronizeRunnable.get(), !GetParent());
michael@0:   mSynchronizeRunnable.Revoke();
michael@0: 
michael@0:   // Execute queued runnables before waking up the worker, otherwise the worker
michael@0:   // could post new messages before we run those that have been queued.
michael@0:   if (!mQueuedRunnables.IsEmpty()) {
michael@0:     AssertIsOnMainThread();
michael@0:     MOZ_ASSERT(IsDedicatedWorker());
michael@0: 
michael@0:     nsTArray<nsCOMPtr<nsIRunnable>> runnables;
michael@0:     mQueuedRunnables.SwapElements(runnables);
michael@0: 
michael@0:     for (uint32_t index = 0; index < runnables.Length(); index++) {
michael@0:       runnables[index]->Run();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<ResumeRunnable> runnable =
michael@0:     new ResumeRunnable(ParentAsWorkerPrivate());
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::SynchronizeAndResume(
michael@0:                                                JSContext* aCx,
michael@0:                                                nsPIDOMWindow* aWindow,
michael@0:                                                nsIScriptContext* aScriptContext)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   MOZ_ASSERT(!GetParent());
michael@0:   MOZ_ASSERT_IF(IsDedicatedWorker(), mParentSuspended);
michael@0: 
michael@0:   // NB: There may be pending unqueued messages.  If we resume here we will
michael@0:   // execute those messages out of order.  Instead we post an event to the
michael@0:   // end of the event queue, allowing all of the outstanding messages to be
michael@0:   // queued up in order on the worker.  Then and only then we execute all of
michael@0:   // the messages.
michael@0: 
michael@0:   nsRefPtr<SynchronizeAndResumeRunnable> runnable =
michael@0:     new SynchronizeAndResumeRunnable(ParentAsWorkerPrivate(), aWindow,
michael@0:                                      aScriptContext);
michael@0:   if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
michael@0:     JS_ReportError(aCx, "Failed to dispatch to current thread!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   mSynchronizeRunnable = runnable;
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::Close(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mParentStatus < Closing) {
michael@0:       mParentStatus = Closing;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::ModifyBusyCount(JSContext* aCx, bool aIncrease)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   NS_ASSERTION(aIncrease || mBusyCount, "Mismatched busy count mods!");
michael@0: 
michael@0:   if (aIncrease) {
michael@0:     mBusyCount++;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   if (--mBusyCount == 0) {
michael@0: 
michael@0:     bool shouldCancel;
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0:       shouldCancel = mParentStatus == Terminating;
michael@0:     }
michael@0: 
michael@0:     if (shouldCancel && !Cancel(aCx)) {
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::ForgetMainThreadObjects(
michael@0:                                       nsTArray<nsCOMPtr<nsISupports> >& aDoomed)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0:   MOZ_ASSERT(!mMainThreadObjectsForgotten);
michael@0: 
michael@0:   static const uint32_t kDoomedCount = 7;
michael@0: 
michael@0:   aDoomed.SetCapacity(kDoomedCount);
michael@0: 
michael@0:   SwapToISupportsArray(mLoadInfo.mWindow, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mScriptContext, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mBaseURI, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mResolvedScriptURI, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mPrincipal, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mChannel, aDoomed);
michael@0:   SwapToISupportsArray(mLoadInfo.mCSP, aDoomed);
michael@0:   // Before adding anything here update kDoomedCount above!
michael@0: 
michael@0:   MOZ_ASSERT(aDoomed.Length() == kDoomedCount);
michael@0: 
michael@0:   mMainThreadObjectsForgotten = true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::PostMessageInternal(
michael@0:                                             JSContext* aCx,
michael@0:                                             JS::Handle<JS::Value> aMessage,
michael@0:                                             const Optional<Sequence<JS::Value> >& aTransferable,
michael@0:                                             bool aToMessagePort,
michael@0:                                             uint64_t aMessagePortSerial,
michael@0:                                             ErrorResult& aRv)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     if (mParentStatus > Running) {
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   JSStructuredCloneCallbacks* callbacks;
michael@0:   if (GetParent()) {
michael@0:     if (IsChromeWorker()) {
michael@0:       callbacks = &gChromeWorkerStructuredCloneCallbacks;
michael@0:     }
michael@0:     else {
michael@0:       callbacks = &gWorkerStructuredCloneCallbacks;
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     if (IsChromeWorker()) {
michael@0:       callbacks = &gMainThreadChromeWorkerStructuredCloneCallbacks;
michael@0:     }
michael@0:     else {
michael@0:       callbacks = &gMainThreadWorkerStructuredCloneCallbacks;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue());
michael@0:   if (aTransferable.WasPassed()) {
michael@0:     const Sequence<JS::Value>& realTransferable = aTransferable.Value();
michael@0: 
michael@0:     // The input sequence only comes from the generated bindings code, which
michael@0:     // ensures it is rooted.
michael@0:     JS::HandleValueArray elements =
michael@0:       JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(),
michael@0:                                                realTransferable.Elements());
michael@0: 
michael@0:     JSObject* array =
michael@0:       JS_NewArrayObject(aCx, elements);
michael@0:     if (!array) {
michael@0:       aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
michael@0:       return;
michael@0:     }
michael@0:     transferable.setObject(*array);
michael@0:   }
michael@0: 
michael@0:   nsTArray<nsCOMPtr<nsISupports> > clonedObjects;
michael@0: 
michael@0:   JSAutoStructuredCloneBuffer buffer;
michael@0:   if (!buffer.write(aCx, aMessage, transferable, callbacks, &clonedObjects)) {
michael@0:     aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<MessageEventRunnable> runnable =
michael@0:     new MessageEventRunnable(ParentAsWorkerPrivate(),
michael@0:                              WorkerRunnable::WorkerThreadModifyBusyCount,
michael@0:                              Move(buffer), clonedObjects, aToMessagePort,
michael@0:                              aMessagePortSerial);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     aRv.Throw(NS_ERROR_FAILURE);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::PostMessageToMessagePort(
michael@0:                              JSContext* aCx,
michael@0:                              uint64_t aMessagePortSerial,
michael@0:                              JS::Handle<JS::Value> aMessage,
michael@0:                              const Optional<Sequence<JS::Value>>& aTransferable,
michael@0:                              ErrorResult& aRv)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   PostMessageInternal(aCx, aMessage, aTransferable, true, aMessagePortSerial,
michael@0:                       aRv);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::DispatchMessageEventToMessagePort(
michael@0:                                 JSContext* aCx, uint64_t aMessagePortSerial,
michael@0:                                 JSAutoStructuredCloneBuffer&& aBuffer,
michael@0:                                 nsTArray<nsCOMPtr<nsISupports>>& aClonedObjects)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   JSAutoStructuredCloneBuffer buffer(Move(aBuffer));
michael@0: 
michael@0:   nsTArray<nsCOMPtr<nsISupports>> clonedObjects;
michael@0:   clonedObjects.SwapElements(aClonedObjects);
michael@0: 
michael@0:   SharedWorker* sharedWorker;
michael@0:   if (!mSharedWorkers.Get(aMessagePortSerial, &sharedWorker)) {
michael@0:     // SharedWorker has already been unregistered?
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<MessagePort> port = sharedWorker->Port();
michael@0:   NS_ASSERTION(port, "SharedWorkers always have a port!");
michael@0: 
michael@0:   if (port->IsClosed()) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIScriptGlobalObject> sgo;
michael@0:   port->GetParentObject(getter_AddRefs(sgo));
michael@0:   MOZ_ASSERT(sgo, "Should never happen if IsClosed() returned false!");
michael@0:   MOZ_ASSERT(sgo->GetGlobalJSObject());
michael@0: 
michael@0:   nsCOMPtr<nsIScriptContext> scx = sgo->GetContext();
michael@0:   MOZ_ASSERT_IF(scx, scx->GetNativeContext());
michael@0: 
michael@0:   AutoPushJSContext cx(scx ? scx->GetNativeContext() : aCx);
michael@0:   JSAutoCompartment(cx, sgo->GetGlobalJSObject());
michael@0: 
michael@0:   JS::Rooted<JS::Value> data(cx);
michael@0:   if (!buffer.read(cx, &data, WorkerStructuredCloneCallbacks(true))) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   buffer.clear();
michael@0: 
michael@0:   nsRefPtr<MessageEvent> event = new MessageEvent(port, nullptr, nullptr);
michael@0:   nsresult rv =
michael@0:     event->InitMessageEvent(NS_LITERAL_STRING("message"), false, false, data,
michael@0:                             EmptyString(), EmptyString(), nullptr);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     xpc::Throw(cx, rv);
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   event->SetTrusted(true);
michael@0: 
michael@0:   nsTArray<nsRefPtr<MessagePortBase>> ports;
michael@0:   ports.AppendElement(port);
michael@0: 
michael@0:   nsRefPtr<MessagePortList> portList = new MessagePortList(port, ports);
michael@0:   event->SetPorts(portList);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMEvent> domEvent;
michael@0:   CallQueryInterface(event.get(), getter_AddRefs(domEvent));
michael@0:   NS_ASSERTION(domEvent, "This should never fail!");
michael@0: 
michael@0:   bool ignored;
michael@0:   rv = port->DispatchEvent(domEvent, &ignored);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     xpc::Throw(cx, rv);
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: uint64_t
michael@0: WorkerPrivateParent<Derived>::GetInnerWindowId()
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   NS_ASSERTION(!mLoadInfo.mWindow || mLoadInfo.mWindow->IsInnerWindow(),
michael@0:                "Outer window?");
michael@0:   return mLoadInfo.mWindow ? mLoadInfo.mWindow->WindowID() : 0;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UpdateRuntimeAndContextOptions(
michael@0:                                     JSContext* aCx,
michael@0:                                     const JS::RuntimeOptions& aRuntimeOptions,
michael@0:                                     const JS::ContextOptions& aContentCxOptions,
michael@0:                                     const JS::ContextOptions& aChromeCxOptions)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     mJSSettings.runtimeOptions = aRuntimeOptions;
michael@0:     mJSSettings.content.contextOptions = aContentCxOptions;
michael@0:     mJSSettings.chrome.contextOptions = aChromeCxOptions;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<UpdateRuntimeAndContextOptionsRunnable> runnable =
michael@0:     new UpdateRuntimeAndContextOptionsRunnable(ParentAsWorkerPrivate(),
michael@0:                                                aRuntimeOptions,
michael@0:                                                aContentCxOptions,
michael@0:                                                aChromeCxOptions);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to update worker context options!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UpdatePreference(JSContext* aCx, WorkerPreference aPref, bool aValue)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0:   MOZ_ASSERT(aPref >= 0 && aPref < WORKERPREF_COUNT);
michael@0: 
michael@0:   nsRefPtr<UpdatePreferenceRunnable> runnable =
michael@0:     new UpdatePreferenceRunnable(ParentAsWorkerPrivate(), aPref, aValue);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to update worker preferences!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UpdateJSWorkerMemoryParameter(JSContext* aCx,
michael@0:                                                             JSGCParamKey aKey,
michael@0:                                                             uint32_t aValue)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   bool found = false;
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     found = mJSSettings.ApplyGCSetting(aKey, aValue);
michael@0:   }
michael@0: 
michael@0:   if (found) {
michael@0:     nsRefPtr<UpdateJSWorkerMemoryParameterRunnable> runnable =
michael@0:       new UpdateJSWorkerMemoryParameterRunnable(ParentAsWorkerPrivate(), aKey,
michael@0:                                                 aValue);
michael@0:     if (!runnable->Dispatch(aCx)) {
michael@0:       NS_WARNING("Failed to update memory parameter!");
michael@0:       JS_ClearPendingException(aCx);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: #ifdef JS_GC_ZEAL
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UpdateGCZeal(JSContext* aCx, uint8_t aGCZeal,
michael@0:                                            uint32_t aFrequency)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     mJSSettings.gcZeal = aGCZeal;
michael@0:     mJSSettings.gcZealFrequency = aFrequency;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<UpdateGCZealRunnable> runnable =
michael@0:     new UpdateGCZealRunnable(ParentAsWorkerPrivate(), aGCZeal, aFrequency);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to update worker gczeal!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: #endif
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::GarbageCollect(JSContext* aCx, bool aShrinking)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   nsRefPtr<GarbageCollectRunnable> runnable =
michael@0:     new GarbageCollectRunnable(ParentAsWorkerPrivate(), aShrinking,
michael@0:                                /* collectChildren = */ true);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to GC worker!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::CycleCollect(JSContext* aCx, bool aDummy)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   nsRefPtr<CycleCollectRunnable> runnable =
michael@0:     new CycleCollectRunnable(ParentAsWorkerPrivate(),
michael@0:                              /* collectChildren = */ true);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to CC worker!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::OfflineStatusChangeEvent(JSContext* aCx, bool aIsOffline)
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   nsRefPtr<OfflineStatusChangeRunnable> runnable =
michael@0:     new OfflineStatusChangeRunnable(ParentAsWorkerPrivate(), aIsOffline);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     NS_WARNING("Failed to dispatch offline status change event!");
michael@0:     JS_ClearPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::OfflineStatusChangeEventInternal(JSContext* aCx, bool aIsOffline)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   for (uint32_t index = 0; index < mChildWorkers.Length(); ++index) {
michael@0:     mChildWorkers[index]->OfflineStatusChangeEvent(aCx, aIsOffline);
michael@0:   }
michael@0: 
michael@0:   mOnLine = !aIsOffline;
michael@0:   WorkerGlobalScope* globalScope = GlobalScope();
michael@0:   nsRefPtr<WorkerNavigator> nav = globalScope->GetExistingNavigator();
michael@0:   if (nav) {
michael@0:     nav->SetOnLine(mOnLine);
michael@0:   }
michael@0: 
michael@0:   nsString eventType;
michael@0:   if (aIsOffline) {
michael@0:     eventType.AssignLiteral("offline");
michael@0:   } else {
michael@0:     eventType.AssignLiteral("online");
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDOMEvent> event;
michael@0:   nsresult rv =
michael@0:     NS_NewDOMEvent(getter_AddRefs(event), globalScope, nullptr, nullptr);
michael@0:   NS_ENSURE_SUCCESS_VOID(rv);
michael@0: 
michael@0:   rv = event->InitEvent(eventType, false, false);
michael@0:   NS_ENSURE_SUCCESS_VOID(rv);
michael@0: 
michael@0:   event->SetTrusted(true);
michael@0: 
michael@0:   globalScope->DispatchDOMEvent(nullptr, event, nullptr, nullptr);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: bool
michael@0: WorkerPrivateParent<Derived>::RegisterSharedWorker(JSContext* aCx,
michael@0:                                                    SharedWorker* aSharedWorker)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   MOZ_ASSERT(aSharedWorker);
michael@0:   MOZ_ASSERT(IsSharedWorker());
michael@0:   MOZ_ASSERT(!mSharedWorkers.Get(aSharedWorker->Serial()));
michael@0: 
michael@0:   nsRefPtr<MessagePortRunnable> runnable =
michael@0:     new MessagePortRunnable(ParentAsWorkerPrivate(), aSharedWorker->Serial(),
michael@0:                             true);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   mSharedWorkers.Put(aSharedWorker->Serial(), aSharedWorker);
michael@0: 
michael@0:   // If there were other SharedWorker objects attached to this worker then they
michael@0:   // may all have been suspended and this worker would need to be resumed.
michael@0:   if (mSharedWorkers.Count() > 1 && !Resume(aCx, nullptr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UnregisterSharedWorker(
michael@0:                                                     JSContext* aCx,
michael@0:                                                     SharedWorker* aSharedWorker)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   MOZ_ASSERT(aSharedWorker);
michael@0:   MOZ_ASSERT(IsSharedWorker());
michael@0:   MOZ_ASSERT(mSharedWorkers.Get(aSharedWorker->Serial()));
michael@0: 
michael@0:   nsRefPtr<MessagePortRunnable> runnable =
michael@0:     new MessagePortRunnable(ParentAsWorkerPrivate(), aSharedWorker->Serial(),
michael@0:                             false);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     JS_ReportPendingException(aCx);
michael@0:   }
michael@0: 
michael@0:   mSharedWorkers.Remove(aSharedWorker->Serial());
michael@0: 
michael@0:   // If there are still SharedWorker objects attached to this worker then they
michael@0:   // may all be suspended and this worker would need to be suspended. Otherwise,
michael@0:   // if that was the last SharedWorker then it's time to cancel this worker.
michael@0:   if (mSharedWorkers.Count()) {
michael@0:     if (!Suspend(aCx, nullptr)) {
michael@0:       JS_ReportPendingException(aCx);
michael@0:     }
michael@0:   } else if (!Cancel(aCx)) {
michael@0:     JS_ReportPendingException(aCx);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::BroadcastErrorToSharedWorkers(
michael@0:                                                     JSContext* aCx,
michael@0:                                                     const nsAString& aMessage,
michael@0:                                                     const nsAString& aFilename,
michael@0:                                                     const nsAString& aLine,
michael@0:                                                     uint32_t aLineNumber,
michael@0:                                                     uint32_t aColumnNumber,
michael@0:                                                     uint32_t aFlags)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   nsAutoTArray<nsRefPtr<SharedWorker>, 10> sharedWorkers;
michael@0:   GetAllSharedWorkers(sharedWorkers);
michael@0: 
michael@0:   if (sharedWorkers.IsEmpty()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsAutoTArray<WindowAction, 10> windowActions;
michael@0:   nsresult rv;
michael@0: 
michael@0:   // First fire the error event at all SharedWorker objects. This may include
michael@0:   // multiple objects in a single window as well as objects in different
michael@0:   // windows.
michael@0:   for (uint32_t index = 0; index < sharedWorkers.Length(); index++) {
michael@0:     nsRefPtr<SharedWorker>& sharedWorker = sharedWorkers[index];
michael@0: 
michael@0:     // May be null.
michael@0:     nsPIDOMWindow* window = sharedWorker->GetOwner();
michael@0: 
michael@0:     uint32_t actionsIndex = windowActions.LastIndexOf(WindowAction(window));
michael@0: 
michael@0:     nsIGlobalObject* global = sharedWorker->GetParentObject();
michael@0:     AutoJSAPIWithErrorsReportedToWindow jsapi(global);
michael@0:     JSContext* cx = jsapi.cx();
michael@0:     JSAutoCompartment ac(cx, global->GetGlobalJSObject());
michael@0: 
michael@0:     RootedDictionary<ErrorEventInit> errorInit(aCx);
michael@0:     errorInit.mBubbles = false;
michael@0:     errorInit.mCancelable = true;
michael@0:     errorInit.mMessage = aMessage;
michael@0:     errorInit.mFilename = aFilename;
michael@0:     errorInit.mLineno = aLineNumber;
michael@0:     errorInit.mColno = aColumnNumber;
michael@0: 
michael@0:     nsRefPtr<ErrorEvent> errorEvent =
michael@0:       ErrorEvent::Constructor(sharedWorker, NS_LITERAL_STRING("error"),
michael@0:                               errorInit);
michael@0:     if (!errorEvent) {
michael@0:       Throw(cx, NS_ERROR_UNEXPECTED);
michael@0:       JS_ReportPendingException(cx);
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     errorEvent->SetTrusted(true);
michael@0: 
michael@0:     bool defaultActionEnabled;
michael@0:     nsresult rv = sharedWorker->DispatchEvent(errorEvent, &defaultActionEnabled);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       Throw(cx, rv);
michael@0:       JS_ReportPendingException(cx);
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (defaultActionEnabled) {
michael@0:       // Add the owning window to our list so that we will fire an error event
michael@0:       // at it later.
michael@0:       if (!windowActions.Contains(window)) {
michael@0:         windowActions.AppendElement(WindowAction(window, cx));
michael@0:       }
michael@0:     } else if (actionsIndex != windowActions.NoIndex) {
michael@0:       // Any listener that calls preventDefault() will prevent the window from
michael@0:       // receiving the error event.
michael@0:       windowActions[actionsIndex].mDefaultAction = false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // If there are no windows to consider further then we're done.
michael@0:   if (windowActions.IsEmpty()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   bool shouldLogErrorToConsole = true;
michael@0: 
michael@0:   // Now fire error events at all the windows remaining.
michael@0:   for (uint32_t index = 0; index < windowActions.Length(); index++) {
michael@0:     WindowAction& windowAction = windowActions[index];
michael@0: 
michael@0:     // If there is no window or the script already called preventDefault then
michael@0:     // skip this window.
michael@0:     if (!windowAction.mWindow || !windowAction.mDefaultAction) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     JSContext* cx = windowAction.mJSContext;
michael@0: 
michael@0:     AutoCxPusher autoPush(cx);
michael@0: 
michael@0:     nsCOMPtr<nsIScriptGlobalObject> sgo =
michael@0:       do_QueryInterface(windowAction.mWindow);
michael@0:     MOZ_ASSERT(sgo);
michael@0: 
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     RootedDictionary<ErrorEventInit> init(aCx);
michael@0:     init.mLineno = aLineNumber;
michael@0:     init.mFilename = aFilename;
michael@0:     init.mMessage = aMessage;
michael@0:     init.mCancelable = true;
michael@0:     init.mBubbles = true;
michael@0: 
michael@0:     nsEventStatus status = nsEventStatus_eIgnore;
michael@0:     rv = sgo->HandleScriptError(init, &status);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       Throw(cx, rv);
michael@0:       JS_ReportPendingException(cx);
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (status == nsEventStatus_eConsumeNoDefault) {
michael@0:       shouldLogErrorToConsole = false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Finally log a warning in the console if no window tried to prevent it.
michael@0:   if (shouldLogErrorToConsole) {
michael@0:     LogErrorToConsole(aMessage, aFilename, aLine, aLineNumber, aColumnNumber,
michael@0:                       aFlags, 0);
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::GetAllSharedWorkers(
michael@0:                                nsTArray<nsRefPtr<SharedWorker>>& aSharedWorkers)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   MOZ_ASSERT(IsSharedWorker());
michael@0: 
michael@0:   struct Helper
michael@0:   {
michael@0:     static PLDHashOperator
michael@0:     Collect(const uint64_t& aKey,
michael@0:             SharedWorker* aSharedWorker,
michael@0:             void* aClosure)
michael@0:     {
michael@0:       AssertIsOnMainThread();
michael@0:       MOZ_ASSERT(aSharedWorker);
michael@0:       MOZ_ASSERT(aClosure);
michael@0: 
michael@0:       auto array = static_cast<nsTArray<nsRefPtr<SharedWorker>>*>(aClosure);
michael@0:       array->AppendElement(aSharedWorker);
michael@0: 
michael@0:       return PL_DHASH_NEXT;
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   if (!aSharedWorkers.IsEmpty()) {
michael@0:     aSharedWorkers.Clear();
michael@0:   }
michael@0: 
michael@0:   mSharedWorkers.EnumerateRead(Helper::Collect, &aSharedWorkers);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::CloseSharedWorkersForWindow(
michael@0:                                                          nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   MOZ_ASSERT(IsSharedWorker());
michael@0:   MOZ_ASSERT(aWindow);
michael@0: 
michael@0:   struct Closure
michael@0:   {
michael@0:     nsPIDOMWindow* mWindow;
michael@0:     nsAutoTArray<nsRefPtr<SharedWorker>, 10> mSharedWorkers;
michael@0: 
michael@0:     Closure(nsPIDOMWindow* aWindow)
michael@0:     : mWindow(aWindow)
michael@0:     {
michael@0:       AssertIsOnMainThread();
michael@0:       MOZ_ASSERT(aWindow);
michael@0:     }
michael@0: 
michael@0:     static PLDHashOperator
michael@0:     Collect(const uint64_t& aKey,
michael@0:             SharedWorker* aSharedWorker,
michael@0:             void* aClosure)
michael@0:     {
michael@0:       AssertIsOnMainThread();
michael@0:       MOZ_ASSERT(aSharedWorker);
michael@0:       MOZ_ASSERT(aClosure);
michael@0: 
michael@0:       auto closure = static_cast<Closure*>(aClosure);
michael@0:       MOZ_ASSERT(closure->mWindow);
michael@0: 
michael@0:       if (aSharedWorker->GetOwner() == closure->mWindow) {
michael@0:         closure->mSharedWorkers.AppendElement(aSharedWorker);
michael@0:       } else {
michael@0:         MOZ_ASSERT(!SameCOMIdentity(aSharedWorker->GetOwner(),
michael@0:                                     closure->mWindow));
michael@0:       }
michael@0: 
michael@0:       return PL_DHASH_NEXT;
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   Closure closure(aWindow);
michael@0: 
michael@0:   mSharedWorkers.EnumerateRead(Closure::Collect, &closure);
michael@0: 
michael@0:   for (uint32_t index = 0; index < closure.mSharedWorkers.Length(); index++) {
michael@0:     closure.mSharedWorkers[index]->Close();
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::WorkerScriptLoaded()
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   if (IsSharedWorker()) {
michael@0:     // No longer need to hold references to the window or document we came from.
michael@0:     mLoadInfo.mWindow = nullptr;
michael@0:     mLoadInfo.mScriptContext = nullptr;
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::SetBaseURI(nsIURI* aBaseURI)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   if (!mLoadInfo.mBaseURI) {
michael@0:     NS_ASSERTION(GetParent(), "Shouldn't happen without a parent!");
michael@0:     mLoadInfo.mResolvedScriptURI = aBaseURI;
michael@0:   }
michael@0: 
michael@0:   mLoadInfo.mBaseURI = aBaseURI;
michael@0: 
michael@0:   if (NS_FAILED(aBaseURI->GetSpec(mLocationInfo.mHref))) {
michael@0:     mLocationInfo.mHref.Truncate();
michael@0:   }
michael@0: 
michael@0:   if (NS_FAILED(aBaseURI->GetHost(mLocationInfo.mHostname))) {
michael@0:     mLocationInfo.mHostname.Truncate();
michael@0:   }
michael@0: 
michael@0:   if (NS_FAILED(aBaseURI->GetPath(mLocationInfo.mPathname))) {
michael@0:     mLocationInfo.mPathname.Truncate();
michael@0:   }
michael@0: 
michael@0:   nsCString temp;
michael@0: 
michael@0:   nsCOMPtr<nsIURL> url(do_QueryInterface(aBaseURI));
michael@0:   if (url && NS_SUCCEEDED(url->GetQuery(temp)) && !temp.IsEmpty()) {
michael@0:     mLocationInfo.mSearch.AssignLiteral("?");
michael@0:     mLocationInfo.mSearch.Append(temp);
michael@0:   }
michael@0: 
michael@0:   if (NS_SUCCEEDED(aBaseURI->GetRef(temp)) && !temp.IsEmpty()) {
michael@0:     nsCOMPtr<nsITextToSubURI> converter =
michael@0:       do_GetService(NS_ITEXTTOSUBURI_CONTRACTID);
michael@0:     if (converter) {
michael@0:       nsCString charset;
michael@0:       nsAutoString unicodeRef;
michael@0:       if (NS_SUCCEEDED(aBaseURI->GetOriginCharset(charset)) &&
michael@0:           NS_SUCCEEDED(converter->UnEscapeURIForUI(charset, temp,
michael@0:                                                    unicodeRef))) {
michael@0:         mLocationInfo.mHash.AssignLiteral("#");
michael@0:         mLocationInfo.mHash.Append(NS_ConvertUTF16toUTF8(unicodeRef));
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (mLocationInfo.mHash.IsEmpty()) {
michael@0:       mLocationInfo.mHash.AssignLiteral("#");
michael@0:       mLocationInfo.mHash.Append(temp);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (NS_SUCCEEDED(aBaseURI->GetScheme(mLocationInfo.mProtocol))) {
michael@0:     mLocationInfo.mProtocol.AppendLiteral(":");
michael@0:   }
michael@0:   else {
michael@0:     mLocationInfo.mProtocol.Truncate();
michael@0:   }
michael@0: 
michael@0:   int32_t port;
michael@0:   if (NS_SUCCEEDED(aBaseURI->GetPort(&port)) && port != -1) {
michael@0:     mLocationInfo.mPort.AppendInt(port);
michael@0: 
michael@0:     nsAutoCString host(mLocationInfo.mHostname);
michael@0:     host.AppendLiteral(":");
michael@0:     host.Append(mLocationInfo.mPort);
michael@0: 
michael@0:     mLocationInfo.mHost.Assign(host);
michael@0:   }
michael@0:   else {
michael@0:     mLocationInfo.mHost.Assign(mLocationInfo.mHostname);
michael@0:   }
michael@0: 
michael@0:   nsContentUtils::GetUTFNonNullOrigin(aBaseURI, mLocationInfo.mOrigin);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::SetPrincipal(nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   mLoadInfo.mPrincipal = aPrincipal;
michael@0:   mLoadInfo.mPrincipalIsSystem = nsContentUtils::IsSystemPrincipal(aPrincipal);
michael@0:   uint16_t appStatus = aPrincipal->GetAppStatus();
michael@0:   mLoadInfo.mIsInPrivilegedApp =
michael@0:     (appStatus == nsIPrincipal::APP_STATUS_CERTIFIED ||
michael@0:      appStatus == nsIPrincipal::APP_STATUS_PRIVILEGED);
michael@0:   mLoadInfo.mIsInCertifiedApp = (appStatus == nsIPrincipal::APP_STATUS_CERTIFIED);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: JSContext*
michael@0: WorkerPrivateParent<Derived>::ParentJSContext() const
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   if (mParent) {
michael@0:     return mParent->GetJSContext();
michael@0:   }
michael@0: 
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   return mLoadInfo.mScriptContext ?
michael@0:          mLoadInfo.mScriptContext->GetNativeContext() :
michael@0:          nsContentUtils::GetSafeJSContext();
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::RegisterHostObjectURI(const nsACString& aURI)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   mHostObjectURIs.AppendElement(aURI);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::UnregisterHostObjectURI(const nsACString& aURI)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   mHostObjectURIs.RemoveElement(aURI);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::StealHostObjectURIs(nsTArray<nsCString>& aArray)
michael@0: {
michael@0:   aArray.SwapElements(mHostObjectURIs);
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_ADDREF_INHERITED(WorkerPrivateParent<Derived>, DOMEventTargetHelper)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_RELEASE_INHERITED(WorkerPrivateParent<Derived>, DOMEventTargetHelper)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(WorkerPrivateParent<Derived>)
michael@0: NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WorkerPrivateParent<Derived>,
michael@0:                                                   DOMEventTargetHelper)
michael@0:   tmp->AssertIsOnParentThread();
michael@0: 
michael@0:   // The WorkerPrivate::mSelfRef has a reference to itself, which is really
michael@0:   // held by the worker thread.  We traverse this reference if and only if our
michael@0:   // busy count is zero and we have not released the main thread reference.
michael@0:   // We do not unlink it.  This allows the CC to break cycles involving the
michael@0:   // WorkerPrivate and begin shutting it down (which does happen in unlink) but
michael@0:   // ensures that the WorkerPrivate won't be deleted before we're done shutting
michael@0:   // down the thread.
michael@0: 
michael@0:   if (!tmp->mBusyCount && !tmp->mMainThreadObjectsForgotten) {
michael@0:     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelfRef)
michael@0:   }
michael@0: 
michael@0:   // The various strong references in LoadInfo are managed manually and cannot
michael@0:   // be cycle collected.
michael@0: NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WorkerPrivateParent<Derived>,
michael@0:                                                 DOMEventTargetHelper)
michael@0:   tmp->Terminate(nullptr);
michael@0: NS_IMPL_CYCLE_COLLECTION_UNLINK_END
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WorkerPrivateParent<Derived>,
michael@0:                                                DOMEventTargetHelper)
michael@0:   tmp->AssertIsOnParentThread();
michael@0: NS_IMPL_CYCLE_COLLECTION_TRACE_END
michael@0: 
michael@0: #ifdef DEBUG
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::AssertIsOnParentThread() const
michael@0: {
michael@0:   if (GetParent()) {
michael@0:     GetParent()->AssertIsOnWorkerThread();
michael@0:   }
michael@0:   else {
michael@0:     AssertIsOnMainThread();
michael@0:   }
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: void
michael@0: WorkerPrivateParent<Derived>::AssertInnerWindowIsCorrect() const
michael@0: {
michael@0:   AssertIsOnParentThread();
michael@0: 
michael@0:   // Only care about top level workers from windows.
michael@0:   if (mParent || !mLoadInfo.mWindow) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   AssertIsOnMainThread();
michael@0: 
michael@0:   nsPIDOMWindow* outer = mLoadInfo.mWindow->GetOuterWindow();
michael@0:   NS_ASSERTION(outer && outer->GetCurrentInnerWindow() == mLoadInfo.mWindow,
michael@0:                "Inner window no longer correct!");
michael@0: }
michael@0: 
michael@0: #endif
michael@0: WorkerPrivate::WorkerPrivate(JSContext* aCx,
michael@0:                              WorkerPrivate* aParent,
michael@0:                              const nsAString& aScriptURL,
michael@0:                              bool aIsChromeWorker, WorkerType aWorkerType,
michael@0:                              const nsACString& aSharedWorkerName,
michael@0:                              LoadInfo& aLoadInfo)
michael@0: : WorkerPrivateParent<WorkerPrivate>(aCx, aParent, aScriptURL,
michael@0:                                      aIsChromeWorker, aWorkerType,
michael@0:                                      aSharedWorkerName, aLoadInfo),
michael@0:   mJSContext(nullptr), mErrorHandlerRecursionCount(0), mNextTimeoutId(1),
michael@0:   mStatus(Pending), mSuspended(false), mTimerRunning(false),
michael@0:   mRunningExpiredTimeouts(false), mCloseHandlerStarted(false),
michael@0:   mCloseHandlerFinished(false), mMemoryReporterRunning(false),
michael@0:   mBlockedForMemoryReporter(false), mCancelAllPendingRunnables(false),
michael@0:   mPeriodicGCTimerRunning(false), mIdleGCTimerRunning(false)
michael@0: #ifdef DEBUG
michael@0:   , mPRThread(nullptr)
michael@0: #endif
michael@0: {
michael@0:   MOZ_ASSERT_IF(IsSharedWorker(), !aSharedWorkerName.IsVoid());
michael@0:   MOZ_ASSERT_IF(!IsSharedWorker(), aSharedWorkerName.IsEmpty());
michael@0: 
michael@0:   if (aParent) {
michael@0:     aParent->AssertIsOnWorkerThread();
michael@0:     aParent->GetAllPreferences(mPreferences);
michael@0:     mOnLine = aParent->OnLine();
michael@0:   }
michael@0:   else {
michael@0:     AssertIsOnMainThread();
michael@0:     RuntimeService::GetDefaultPreferences(mPreferences);
michael@0:     mOnLine = !NS_IsOffline();
michael@0:   }
michael@0: }
michael@0: 
michael@0: WorkerPrivate::~WorkerPrivate()
michael@0: {
michael@0: }
michael@0: 
michael@0: // static
michael@0: already_AddRefed<WorkerPrivate>
michael@0: WorkerPrivate::Constructor(const GlobalObject& aGlobal,
michael@0:                            const nsAString& aScriptURL,
michael@0:                            ErrorResult& aRv)
michael@0: {
michael@0:   return WorkerPrivate::Constructor(aGlobal, aScriptURL, false,
michael@0:                                     WorkerTypeDedicated, EmptyCString(),
michael@0:                                     nullptr, aRv);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: WorkerPrivate::WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */)
michael@0: {
michael@0:   // If we're already on a worker workers are clearly enabled.
michael@0:   if (!NS_IsMainThread()) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // If our caller is chrome, workers are always available.
michael@0:   if (nsContentUtils::IsCallerChrome()) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Else check the pref.
michael@0:   return Preferences::GetBool(PREF_WORKERS_ENABLED);
michael@0: }
michael@0: 
michael@0: // static
michael@0: already_AddRefed<ChromeWorkerPrivate>
michael@0: ChromeWorkerPrivate::Constructor(const GlobalObject& aGlobal,
michael@0:                                  const nsAString& aScriptURL,
michael@0:                                  ErrorResult& aRv)
michael@0: {
michael@0:   return WorkerPrivate::Constructor(aGlobal, aScriptURL, true,
michael@0:                                     WorkerTypeDedicated, EmptyCString(),
michael@0:                                     nullptr, aRv)
michael@0:                                     .downcast<ChromeWorkerPrivate>();
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: ChromeWorkerPrivate::WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */)
michael@0: {
michael@0:   // Chrome is always allowed to use workers, and content is never allowed to
michael@0:   // use ChromeWorker, so all we have to check is the caller.
michael@0:   return nsContentUtils::ThreadsafeIsCallerChrome();
michael@0: }
michael@0: 
michael@0: // static
michael@0: already_AddRefed<WorkerPrivate>
michael@0: WorkerPrivate::Constructor(const GlobalObject& aGlobal,
michael@0:                            const nsAString& aScriptURL,
michael@0:                            bool aIsChromeWorker, WorkerType aWorkerType,
michael@0:                            const nsACString& aSharedWorkerName,
michael@0:                            LoadInfo* aLoadInfo, ErrorResult& aRv)
michael@0: {
michael@0:   WorkerPrivate* parent = NS_IsMainThread() ?
michael@0:                           nullptr :
michael@0:                           GetCurrentThreadWorkerPrivate();
michael@0:   if (parent) {
michael@0:     parent->AssertIsOnWorkerThread();
michael@0:   } else {
michael@0:     AssertIsOnMainThread();
michael@0:   }
michael@0: 
michael@0:   JSContext* cx = aGlobal.GetContext();
michael@0: 
michael@0:   MOZ_ASSERT_IF(aWorkerType == WorkerTypeShared,
michael@0:                 !aSharedWorkerName.IsVoid());
michael@0:   MOZ_ASSERT_IF(aWorkerType != WorkerTypeShared,
michael@0:                 aSharedWorkerName.IsEmpty());
michael@0: 
michael@0:   Maybe<LoadInfo> stackLoadInfo;
michael@0:   if (!aLoadInfo) {
michael@0:     stackLoadInfo.construct();
michael@0: 
michael@0:     nsresult rv = GetLoadInfo(cx, nullptr, parent, aScriptURL,
michael@0:                               aIsChromeWorker, stackLoadInfo.addr());
michael@0:     if (NS_FAILED(rv)) {
michael@0:       scriptloader::ReportLoadError(cx, aScriptURL, rv, !parent);
michael@0:       aRv.Throw(rv);
michael@0:       return nullptr;
michael@0:     }
michael@0: 
michael@0:     aLoadInfo = stackLoadInfo.addr();
michael@0:   }
michael@0: 
michael@0:   // NB: This has to be done before creating the WorkerPrivate, because it will
michael@0:   // attempt to use static variables that are initialized in the RuntimeService
michael@0:   // constructor.
michael@0:   RuntimeService* runtimeService;
michael@0: 
michael@0:   if (!parent) {
michael@0:     runtimeService = RuntimeService::GetOrCreateService();
michael@0:     if (!runtimeService) {
michael@0:       JS_ReportError(cx, "Failed to create runtime service!");
michael@0:       aRv.Throw(NS_ERROR_FAILURE);
michael@0:       return nullptr;
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     runtimeService = RuntimeService::GetService();
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(runtimeService);
michael@0: 
michael@0:   nsRefPtr<WorkerPrivate> worker =
michael@0:     new WorkerPrivate(cx, parent, aScriptURL, aIsChromeWorker,
michael@0:                       aWorkerType, aSharedWorkerName, *aLoadInfo);
michael@0: 
michael@0:   if (!runtimeService->RegisterWorker(cx, worker)) {
michael@0:     aRv.Throw(NS_ERROR_UNEXPECTED);
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<CompileScriptRunnable> compiler = new CompileScriptRunnable(worker);
michael@0:   if (!compiler->Dispatch(cx)) {
michael@0:     aRv.Throw(NS_ERROR_UNEXPECTED);
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   worker->mSelfRef = worker;
michael@0: 
michael@0:   return worker.forget();
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: WorkerPrivate::GetLoadInfo(JSContext* aCx, nsPIDOMWindow* aWindow,
michael@0:                            WorkerPrivate* aParent, const nsAString& aScriptURL,
michael@0:                            bool aIsChromeWorker, LoadInfo* aLoadInfo)
michael@0: {
michael@0:   using namespace mozilla::dom::workers::scriptloader;
michael@0: 
michael@0:   MOZ_ASSERT(aCx);
michael@0: 
michael@0:   if (aWindow) {
michael@0:     AssertIsOnMainThread();
michael@0:   }
michael@0: 
michael@0:   LoadInfo loadInfo;
michael@0:   nsresult rv;
michael@0: 
michael@0:   if (aParent) {
michael@0:     aParent->AssertIsOnWorkerThread();
michael@0: 
michael@0:     // If the parent is going away give up now.
michael@0:     Status parentStatus;
michael@0:     {
michael@0:       MutexAutoLock lock(aParent->mMutex);
michael@0:       parentStatus = aParent->mStatus;
michael@0:     }
michael@0: 
michael@0:     if (parentStatus > Running) {
michael@0:       NS_WARNING("Cannot create child workers from the close handler!");
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     // StartAssignment() is used instead getter_AddRefs because, getter_AddRefs
michael@0:     // does QI in debug build and, if this worker runs in a child process,
michael@0:     // HttpChannelChild will crash because it's not thread-safe.
michael@0:     rv = ChannelFromScriptURLWorkerThread(aCx, aParent, aScriptURL,
michael@0:                                           loadInfo.mChannel.StartAssignment());
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Now that we've spun the loop there's no guarantee that our parent is
michael@0:     // still alive.  We may have received control messages initiating shutdown.
michael@0:     {
michael@0:       MutexAutoLock lock(aParent->mMutex);
michael@0:       parentStatus = aParent->mStatus;
michael@0:     }
michael@0: 
michael@0:     if (parentStatus > Running) {
michael@0:       nsCOMPtr<nsIThread> mainThread;
michael@0:       if (NS_FAILED(NS_GetMainThread(getter_AddRefs(mainThread))) ||
michael@0:           NS_FAILED(NS_ProxyRelease(mainThread, loadInfo.mChannel))) {
michael@0:         NS_WARNING("Failed to proxy release of channel, leaking instead!");
michael@0:       }
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     loadInfo.mDomain = aParent->Domain();
michael@0:   } else {
michael@0:     AssertIsOnMainThread();
michael@0: 
michael@0:     nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
michael@0:     MOZ_ASSERT(ssm);
michael@0: 
michael@0:     bool isChrome = nsContentUtils::IsCallerChrome();
michael@0: 
michael@0:     // First check to make sure the caller has permission to make a privileged
michael@0:     // worker if they called the ChromeWorker/ChromeSharedWorker constructor.
michael@0:     if (aIsChromeWorker && !isChrome) {
michael@0:       return NS_ERROR_DOM_SECURITY_ERR;
michael@0:     }
michael@0: 
michael@0:     // Chrome callers (whether ChromeWorker of Worker) always get the system
michael@0:     // principal here as they're allowed to load anything. The script loader may
michael@0:     // change the principal later depending on the script uri.
michael@0:     if (isChrome) {
michael@0:       rv = ssm->GetSystemPrincipal(getter_AddRefs(loadInfo.mPrincipal));
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     // See if we're being called from a window.
michael@0:     nsCOMPtr<nsPIDOMWindow> globalWindow = aWindow;
michael@0:     if (!globalWindow) {
michael@0:       nsCOMPtr<nsIScriptGlobalObject> scriptGlobal =
michael@0:         nsJSUtils::GetStaticScriptGlobal(JS::CurrentGlobalOrNull(aCx));
michael@0:       if (scriptGlobal) {
michael@0:         globalWindow = do_QueryInterface(scriptGlobal);
michael@0:         MOZ_ASSERT(globalWindow);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocument> document;
michael@0: 
michael@0:     if (globalWindow) {
michael@0:       // Only use the current inner window, and only use it if the caller can
michael@0:       // access it.
michael@0:       nsPIDOMWindow* outerWindow = globalWindow->GetOuterWindow();
michael@0:       if (outerWindow) {
michael@0:         loadInfo.mWindow = outerWindow->GetCurrentInnerWindow();
michael@0:       }
michael@0: 
michael@0:       if (!loadInfo.mWindow ||
michael@0:           (globalWindow != loadInfo.mWindow &&
michael@0:             !nsContentUtils::CanCallerAccess(loadInfo.mWindow))) {
michael@0:         return NS_ERROR_DOM_SECURITY_ERR;
michael@0:       }
michael@0: 
michael@0:       nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(loadInfo.mWindow);
michael@0:       MOZ_ASSERT(sgo);
michael@0: 
michael@0:       loadInfo.mScriptContext = sgo->GetContext();
michael@0:       NS_ENSURE_TRUE(loadInfo.mScriptContext, NS_ERROR_FAILURE);
michael@0: 
michael@0:       // If we're called from a window then we can dig out the principal and URI
michael@0:       // from the document.
michael@0:       document = loadInfo.mWindow->GetExtantDoc();
michael@0:       NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
michael@0: 
michael@0:       loadInfo.mBaseURI = document->GetDocBaseURI();
michael@0: 
michael@0:       // Use the document's NodePrincipal as our principal if we're not being
michael@0:       // called from chrome.
michael@0:       if (!loadInfo.mPrincipal) {
michael@0:         loadInfo.mPrincipal = document->NodePrincipal();
michael@0:         NS_ENSURE_TRUE(loadInfo.mPrincipal, NS_ERROR_FAILURE);
michael@0: 
michael@0:         // We use the document's base domain to limit the number of workers
michael@0:         // each domain can create. For sandboxed documents, we use the domain
michael@0:         // of their first non-sandboxed document, walking up until we find
michael@0:         // one. If we can't find one, we fall back to using the GUID of the
michael@0:         // null principal as the base domain.
michael@0:         if (document->GetSandboxFlags() & SANDBOXED_ORIGIN) {
michael@0:           nsCOMPtr<nsIDocument> tmpDoc = document;
michael@0:           do {
michael@0:             tmpDoc = tmpDoc->GetParentDocument();
michael@0:           } while (tmpDoc && tmpDoc->GetSandboxFlags() & SANDBOXED_ORIGIN);
michael@0: 
michael@0:           if (tmpDoc) {
michael@0:             // There was an unsandboxed ancestor, yay!
michael@0:             nsCOMPtr<nsIPrincipal> tmpPrincipal = tmpDoc->NodePrincipal();
michael@0:             rv = tmpPrincipal->GetBaseDomain(loadInfo.mDomain);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:           } else {
michael@0:             // No unsandboxed ancestor, use our GUID.
michael@0:             rv = loadInfo.mPrincipal->GetBaseDomain(loadInfo.mDomain);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:           }
michael@0:         } else {
michael@0:           // Document creating the worker is not sandboxed.
michael@0:           rv = loadInfo.mPrincipal->GetBaseDomain(loadInfo.mDomain);
michael@0:           NS_ENSURE_SUCCESS(rv, rv);
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       nsCOMPtr<nsIPermissionManager> permMgr =
michael@0:         do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       uint32_t perm;
michael@0:       rv = permMgr->TestPermissionFromPrincipal(loadInfo.mPrincipal, "systemXHR",
michael@0:                                                 &perm);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       loadInfo.mXHRParamsAllowed = perm == nsIPermissionManager::ALLOW_ACTION;
michael@0:     } else {
michael@0:       // Not a window
michael@0:       MOZ_ASSERT(isChrome);
michael@0: 
michael@0:       // We're being created outside of a window. Need to figure out the script
michael@0:       // that is creating us in order for us to use relative URIs later on.
michael@0:       JS::AutoFilename fileName;
michael@0:       if (JS::DescribeScriptedCaller(aCx, &fileName)) {
michael@0:         // In most cases, fileName is URI. In a few other cases
michael@0:         // (e.g. xpcshell), fileName is a file path. Ideally, we would
michael@0:         // prefer testing whether fileName parses as an URI and fallback
michael@0:         // to file path in case of error, but Windows file paths have
michael@0:         // the interesting property that they can be parsed as bogus
michael@0:         // URIs (e.g. C:/Windows/Tmp is interpreted as scheme "C",
michael@0:         // hostname "Windows", path "Tmp"), which defeats this algorithm.
michael@0:         // Therefore, we adopt the opposite convention.
michael@0:         nsCOMPtr<nsIFile> scriptFile =
michael@0:           do_CreateInstance("@mozilla.org/file/local;1", &rv);
michael@0:         if (NS_FAILED(rv)) {
michael@0:           return rv;
michael@0:         }
michael@0: 
michael@0:         rv = scriptFile->InitWithPath(NS_ConvertUTF8toUTF16(fileName.get()));
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:           rv = NS_NewFileURI(getter_AddRefs(loadInfo.mBaseURI),
michael@0:                              scriptFile);
michael@0:         }
michael@0:         if (NS_FAILED(rv)) {
michael@0:           // As expected, fileName is not a path, so proceed with
michael@0:           // a uri.
michael@0:           rv = NS_NewURI(getter_AddRefs(loadInfo.mBaseURI),
michael@0:                          fileName.get());
michael@0:         }
michael@0:         if (NS_FAILED(rv)) {
michael@0:           return rv;
michael@0:         }
michael@0:       }
michael@0:       loadInfo.mXHRParamsAllowed = true;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(loadInfo.mPrincipal);
michael@0:     MOZ_ASSERT(isChrome || !loadInfo.mDomain.IsEmpty());
michael@0: 
michael@0:     // XXXbent Use subject principal here instead of the one we already have?
michael@0:     nsCOMPtr<nsIPrincipal> subjectPrincipal = ssm->GetCxSubjectPrincipal(aCx);
michael@0:     MOZ_ASSERT(subjectPrincipal);
michael@0: 
michael@0:     if (!nsContentUtils::GetContentSecurityPolicy(aCx,
michael@0:                                                getter_AddRefs(loadInfo.mCSP))) {
michael@0:       NS_WARNING("Failed to get CSP!");
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     if (loadInfo.mCSP) {
michael@0:       rv = loadInfo.mCSP->GetAllowsEval(&loadInfo.mReportCSPViolations,
michael@0:                                         &loadInfo.mEvalAllowed);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0:     } else {
michael@0:       loadInfo.mEvalAllowed = true;
michael@0:       loadInfo.mReportCSPViolations = false;
michael@0:     }
michael@0: 
michael@0:     rv = ChannelFromScriptURLMainThread(loadInfo.mPrincipal, loadInfo.mBaseURI,
michael@0:                                         document, aScriptURL,
michael@0:                                         getter_AddRefs(loadInfo.mChannel));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     rv = NS_GetFinalChannelURI(loadInfo.mChannel,
michael@0:                                getter_AddRefs(loadInfo.mResolvedScriptURI));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:   }
michael@0: 
michael@0:   aLoadInfo->StealFrom(loadInfo);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::DoRunLoop(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(mThread);
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     mJSContext = aCx;
michael@0: 
michael@0:     MOZ_ASSERT(mStatus == Pending);
michael@0:     mStatus = Running;
michael@0:   }
michael@0: 
michael@0:   EnableMemoryReporter();
michael@0: 
michael@0:   InitializeGCTimers();
michael@0: 
michael@0:   Maybe<JSAutoCompartment> workerCompartment;
michael@0: 
michael@0:   for (;;) {
michael@0:     // Workers lazily create a global object in CompileScriptRunnable. We need
michael@0:     // to enter the global's compartment as soon as it has been created.
michael@0:     if (workerCompartment.empty()) {
michael@0:       if (JSObject* global = js::DefaultObjectForContextOrNull(aCx)) {
michael@0:         workerCompartment.construct(aCx, global);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     Status currentStatus;
michael@0:     bool normalRunnablesPending = false;
michael@0: 
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0: 
michael@0:       while (mControlQueue.IsEmpty() &&
michael@0:              !(normalRunnablesPending = NS_HasPendingEvents(mThread))) {
michael@0:         WaitForWorkerEvents();
michael@0:       }
michael@0: 
michael@0:       ProcessAllControlRunnablesLocked();
michael@0: 
michael@0:       currentStatus = mStatus;
michael@0:     }
michael@0: 
michael@0:     // If the close handler has finished and all features are done then we can
michael@0:     // kill this thread.
michael@0:     if (currentStatus != Running && !HasActiveFeatures()) {
michael@0:       if (mCloseHandlerFinished && currentStatus != Killing) {
michael@0:         if (!NotifyInternal(aCx, Killing)) {
michael@0:           JS_ReportPendingException(aCx);
michael@0:         }
michael@0: #ifdef DEBUG
michael@0:         {
michael@0:           MutexAutoLock lock(mMutex);
michael@0:           currentStatus = mStatus;
michael@0:         }
michael@0:         MOZ_ASSERT(currentStatus == Killing);
michael@0: #else
michael@0:         currentStatus = Killing;
michael@0: #endif
michael@0:       }
michael@0: 
michael@0:       // If we're supposed to die then we should exit the loop.
michael@0:       if (currentStatus == Killing) {
michael@0:         ShutdownGCTimers();
michael@0: 
michael@0:         DisableMemoryReporter();
michael@0: 
michael@0:         {
michael@0:           MutexAutoLock lock(mMutex);
michael@0: 
michael@0:           mStatus = Dead;
michael@0:           mJSContext = nullptr;
michael@0:         }
michael@0: 
michael@0:         // After mStatus is set to Dead there can be no more
michael@0:         // WorkerControlRunnables so no need to lock here.
michael@0:         if (!mControlQueue.IsEmpty()) {
michael@0:           WorkerControlRunnable* runnable;
michael@0:           while (mControlQueue.Pop(runnable)) {
michael@0:             runnable->Cancel();
michael@0:             runnable->Release();
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         // Clear away our MessagePorts.
michael@0:         mWorkerPorts.Clear();
michael@0: 
michael@0:         // Unroot the global
michael@0:         mScope = nullptr;
michael@0: 
michael@0:         return;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Nothing to do here if we don't have any runnables in the main queue.
michael@0:     if (!normalRunnablesPending) {
michael@0:       SetGCTimerMode(IdleTimer);
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(NS_HasPendingEvents(mThread));
michael@0: 
michael@0:     // Start the periodic GC timer if it is not already running.
michael@0:     SetGCTimerMode(PeriodicTimer);
michael@0: 
michael@0:     // Process a single runnable from the main queue.
michael@0:     MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(mThread, false));
michael@0: 
michael@0:     if (NS_HasPendingEvents(mThread)) {
michael@0:       // Now *might* be a good time to GC. Let the JS engine make the decision.
michael@0:       if (!workerCompartment.empty()) {
michael@0:         JS_MaybeGC(aCx);
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       // The normal event queue has been exhausted, cancel the periodic GC timer
michael@0:       // and schedule the idle GC timer.
michael@0:       SetGCTimerMode(IdleTimer);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSUME_UNREACHABLE("Shouldn't get here!");
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::OnProcessNextEvent(uint32_t aRecursionDepth)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(aRecursionDepth);
michael@0: 
michael@0:   // Normally we process control runnables in DoRunLoop or RunCurrentSyncLoop.
michael@0:   // However, it's possible that non-worker C++ could spin its own nested event
michael@0:   // loop, and in that case we must ensure that we continue to process control
michael@0:   // runnables here.
michael@0:   if (aRecursionDepth > 1 &&
michael@0:       mSyncLoopStack.Length() < aRecursionDepth - 1) {
michael@0:     ProcessAllControlRunnables();
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::AfterProcessNextEvent(uint32_t aRecursionDepth)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(aRecursionDepth);
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::InitializeGCTimers()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   // We need a timer for GC. The basic plan is to run a non-shrinking GC
michael@0:   // periodically (PERIODIC_GC_TIMER_DELAY_SEC) while the worker is running.
michael@0:   // Once the worker goes idle we set a short (IDLE_GC_TIMER_DELAY_SEC) timer to
michael@0:   // run a shrinking GC. If the worker receives more messages then the short
michael@0:   // timer is canceled and the periodic timer resumes.
michael@0:   mGCTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
michael@0:   MOZ_ASSERT(mGCTimer);
michael@0: 
michael@0:   nsRefPtr<GarbageCollectRunnable> runnable =
michael@0:     new GarbageCollectRunnable(this, false, false);
michael@0:   mPeriodicGCTimerTarget = new TimerThreadEventTarget(this, runnable);
michael@0: 
michael@0:   runnable = new GarbageCollectRunnable(this, true, false);
michael@0:   mIdleGCTimerTarget = new TimerThreadEventTarget(this, runnable);
michael@0: 
michael@0:   mPeriodicGCTimerRunning = false;
michael@0:   mIdleGCTimerRunning = false;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::SetGCTimerMode(GCTimerMode aMode)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(mGCTimer);
michael@0:   MOZ_ASSERT(mPeriodicGCTimerTarget);
michael@0:   MOZ_ASSERT(mIdleGCTimerTarget);
michael@0: 
michael@0:   if ((aMode == PeriodicTimer && mPeriodicGCTimerRunning) ||
michael@0:       (aMode == IdleTimer && mIdleGCTimerRunning)) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->Cancel()));
michael@0: 
michael@0:   mPeriodicGCTimerRunning = false;
michael@0:   mIdleGCTimerRunning = false;
michael@0: 
michael@0:   LOG(("Worker %p canceled GC timer because %s\n", this,
michael@0:        aMode == PeriodicTimer ?
michael@0:        "periodic" :
michael@0:        aMode == IdleTimer ? "idle" : "none"));
michael@0: 
michael@0:   if (aMode == NoTimer) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(aMode == PeriodicTimer || aMode == IdleTimer);
michael@0: 
michael@0:   nsIEventTarget* target;
michael@0:   uint32_t delay;
michael@0:   int16_t type;
michael@0: 
michael@0:   if (aMode == PeriodicTimer) {
michael@0:     target = mPeriodicGCTimerTarget;
michael@0:     delay = PERIODIC_GC_TIMER_DELAY_SEC * 1000;
michael@0:     type = nsITimer::TYPE_REPEATING_SLACK;
michael@0:   }
michael@0:   else {
michael@0:     target = mIdleGCTimerTarget;
michael@0:     delay = IDLE_GC_TIMER_DELAY_SEC * 1000;
michael@0:     type = nsITimer::TYPE_ONE_SHOT;
michael@0:   }
michael@0: 
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->SetTarget(target)));
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->InitWithFuncCallback(DummyCallback,
michael@0:                                                               nullptr, delay,
michael@0:                                                               type)));
michael@0: 
michael@0:   if (aMode == PeriodicTimer) {
michael@0:     LOG(("Worker %p scheduled periodic GC timer\n", this));
michael@0:     mPeriodicGCTimerRunning = true;
michael@0:   }
michael@0:   else {
michael@0:     LOG(("Worker %p scheduled idle GC timer\n", this));
michael@0:     mIdleGCTimerRunning = true;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::ShutdownGCTimers()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   MOZ_ASSERT(mGCTimer);
michael@0: 
michael@0:   // Always make sure the timer is canceled.
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mGCTimer->Cancel()));
michael@0: 
michael@0:   LOG(("Worker %p killed the GC timer\n", this));
michael@0: 
michael@0:   mGCTimer = nullptr;
michael@0:   mPeriodicGCTimerTarget = nullptr;
michael@0:   mIdleGCTimerTarget = nullptr;
michael@0:   mPeriodicGCTimerRunning = false;
michael@0:   mIdleGCTimerRunning = false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::InterruptCallback(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   bool mayContinue = true;
michael@0:   bool scheduledIdleGC = false;
michael@0: 
michael@0:   for (;;) {
michael@0:     // Run all control events now.
michael@0:     mayContinue = ProcessAllControlRunnables();
michael@0: 
michael@0:     bool maySuspend = mSuspended;
michael@0:     if (maySuspend) {
michael@0:       MutexAutoLock lock(mMutex);
michael@0:       maySuspend = mStatus <= Running;
michael@0:     }
michael@0: 
michael@0:     if (!mayContinue || !maySuspend) {
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     // Cancel the periodic GC timer here before suspending. The idle GC timer
michael@0:     // will clean everything up once it runs.
michael@0:     if (!scheduledIdleGC) {
michael@0:       SetGCTimerMode(IdleTimer);
michael@0:       scheduledIdleGC = true;
michael@0:     }
michael@0: 
michael@0:     while ((mayContinue = MayContinueRunning())) {
michael@0:       MutexAutoLock lock(mMutex);
michael@0:       if (!mControlQueue.IsEmpty()) {
michael@0:         break;
michael@0:       }
michael@0: 
michael@0:       WaitForWorkerEvents(PR_MillisecondsToInterval(RemainingRunTimeMS()));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!mayContinue) {
michael@0:     // We want only uncatchable exceptions here.
michael@0:     NS_ASSERTION(!JS_IsExceptionPending(aCx),
michael@0:                  "Should not have an exception set here!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // Make sure the periodic timer gets turned back on here.
michael@0:   SetGCTimerMode(PeriodicTimer);
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: WorkerPrivate::IsOnCurrentThread(bool* aIsOnCurrentThread)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   MOZ_ASSERT(aIsOnCurrentThread);
michael@0: 
michael@0:   nsCOMPtr<nsIThread> thread;
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     thread = mThread;
michael@0:   }
michael@0: 
michael@0:   if (!thread) {
michael@0:     NS_WARNING("Trying to test thread correctness after the worker has "
michael@0:                "released its thread!");
michael@0:     return NS_ERROR_FAILURE;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = thread->IsOnCurrentThread(aIsOnCurrentThread);
michael@0:   if (NS_WARN_IF(NS_FAILED(rv))) {
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::ScheduleDeletion(WorkerRanOrNot aRanOrNot)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(mChildWorkers.IsEmpty());
michael@0:   MOZ_ASSERT(mSyncLoopStack.IsEmpty());
michael@0: 
michael@0:   ClearMainEventQueue(aRanOrNot);
michael@0: 
michael@0:   if (WorkerPrivate* parent = GetParent()) {
michael@0:     nsRefPtr<WorkerFinishedRunnable> runnable =
michael@0:       new WorkerFinishedRunnable(parent, this);
michael@0:     if (!runnable->Dispatch(nullptr)) {
michael@0:       NS_WARNING("Failed to dispatch runnable!");
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     nsRefPtr<TopLevelWorkerFinishedRunnable> runnable =
michael@0:       new TopLevelWorkerFinishedRunnable(this);
michael@0:     if (NS_FAILED(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL))) {
michael@0:       NS_WARNING("Failed to dispatch runnable!");
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::BlockAndCollectRuntimeStats(JS::RuntimeStats* aRtStats)
michael@0: {
michael@0:   AssertIsOnMainThread();
michael@0:   mMutex.AssertCurrentThreadOwns();
michael@0:   NS_ASSERTION(aRtStats, "Null RuntimeStats!");
michael@0: 
michael@0:   NS_ASSERTION(!mMemoryReporterRunning, "How can we get reentered here?!");
michael@0: 
michael@0:   // This signals the worker that it should block itself as soon as possible.
michael@0:   mMemoryReporterRunning = true;
michael@0: 
michael@0:   NS_ASSERTION(mJSContext, "This must never be null!");
michael@0:   JSRuntime* rt = JS_GetRuntime(mJSContext);
michael@0: 
michael@0:   // If the worker is not already blocked (e.g. waiting for a worker event or
michael@0:   // currently in a ctypes call) then we need to trigger the interrupt
michael@0:   // callback to trap the worker.
michael@0:   if (!mBlockedForMemoryReporter) {
michael@0:     JS_RequestInterruptCallback(rt);
michael@0: 
michael@0:     // Wait until the worker actually blocks.
michael@0:     while (!mBlockedForMemoryReporter) {
michael@0:       mMemoryReportCondVar.Wait();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   bool succeeded = false;
michael@0: 
michael@0:   // If mMemoryReporter is still set then we can do the actual report. Otherwise
michael@0:   // we're trying to shut down and we don't want to do anything but clean up.
michael@0:   if (mMemoryReporter) {
michael@0:     // Don't hold the lock while doing the actual report.
michael@0:     MutexAutoUnlock unlock(mMutex);
michael@0:     succeeded = JS::CollectRuntimeStats(rt, aRtStats, nullptr);
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(mMemoryReporterRunning, "This isn't possible!");
michael@0:   NS_ASSERTION(mBlockedForMemoryReporter, "Somehow we got unblocked!");
michael@0: 
michael@0:   // Tell the worker that it can now continue its execution.
michael@0:   mMemoryReporterRunning = false;
michael@0: 
michael@0:   // The worker may be waiting so we must notify.
michael@0:   mMemoryReportCondVar.Notify();
michael@0: 
michael@0:   return succeeded;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::EnableMemoryReporter()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(!mMemoryReporter);
michael@0: 
michael@0:   // No need to lock here since the main thread can't race until we've
michael@0:   // successfully registered the reporter.
michael@0:   mMemoryReporter = new MemoryReporter(this);
michael@0: 
michael@0:   if (NS_FAILED(RegisterWeakMemoryReporter(mMemoryReporter))) {
michael@0:     NS_WARNING("Failed to register memory reporter!");
michael@0:     // No need to lock here since a failed registration means our memory
michael@0:     // reporter can't start running. Just clean up.
michael@0:     mMemoryReporter = nullptr;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::DisableMemoryReporter()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   nsRefPtr<MemoryReporter> memoryReporter;
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     // There is nothing to do here if the memory reporter was never successfully
michael@0:     // registered.
michael@0:     if (!mMemoryReporter) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     // We don't need this set any longer. Swap it out so that we can unregister
michael@0:     // below.
michael@0:     mMemoryReporter.swap(memoryReporter);
michael@0: 
michael@0:     // Next disable the memory reporter so that the main thread stops trying to
michael@0:     // signal us.
michael@0:     memoryReporter->Disable();
michael@0: 
michael@0:     // If the memory reporter is waiting to start then we need to wait for it to
michael@0:     // finish.
michael@0:     if (mMemoryReporterRunning) {
michael@0:       NS_ASSERTION(!mBlockedForMemoryReporter,
michael@0:                    "Can't be blocked in more than one place at the same time!");
michael@0:       mBlockedForMemoryReporter = true;
michael@0: 
michael@0:       // Tell the main thread that we're blocked.
michael@0:       mMemoryReportCondVar.Notify();
michael@0: 
michael@0:       // Wait for it the main thread to finish. Since we swapped out
michael@0:       // mMemoryReporter above the main thread should respond quickly.
michael@0:       while (mMemoryReporterRunning) {
michael@0:         mMemoryReportCondVar.Wait();
michael@0:       }
michael@0: 
michael@0:       NS_ASSERTION(mBlockedForMemoryReporter, "Somehow we got unblocked!");
michael@0:       mBlockedForMemoryReporter = false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Finally unregister the memory reporter.
michael@0:   if (NS_FAILED(UnregisterWeakMemoryReporter(memoryReporter))) {
michael@0:     NS_WARNING("Failed to unregister memory reporter!");
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::WaitForWorkerEvents(PRIntervalTime aInterval)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   mMutex.AssertCurrentThreadOwns();
michael@0: 
michael@0:   NS_ASSERTION(!mBlockedForMemoryReporter,
michael@0:                 "Can't be blocked in more than one place at the same time!");
michael@0: 
michael@0:   // Let the main thread know that the worker is blocked and that memory
michael@0:   // reporting may proceed.
michael@0:   mBlockedForMemoryReporter = true;
michael@0: 
michael@0:   // The main thread may be waiting so we must notify.
michael@0:   mMemoryReportCondVar.Notify();
michael@0: 
michael@0:   // Now wait for an actual worker event.
michael@0:   mCondVar.Wait(aInterval);
michael@0: 
michael@0:   // We've gotten some kind of signal but we can't continue until the memory
michael@0:   // reporter has finished. Wait again.
michael@0:   while (mMemoryReporterRunning) {
michael@0:     mMemoryReportCondVar.Wait();
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(mBlockedForMemoryReporter, "Somehow we got unblocked!");
michael@0: 
michael@0:   // No need to notify here as the main thread isn't watching for this state.
michael@0:   mBlockedForMemoryReporter = false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::ProcessAllControlRunnablesLocked()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   mMutex.AssertCurrentThreadOwns();
michael@0: 
michael@0:   bool result = true;
michael@0: 
michael@0:   for (;;) {
michael@0:     // Block here if the memory reporter is trying to run.
michael@0:     if (mMemoryReporterRunning) {
michael@0:       MOZ_ASSERT(!mBlockedForMemoryReporter);
michael@0: 
michael@0:       // Let the main thread know that we've received the block request and
michael@0:       // that memory reporting may proceed.
michael@0:       mBlockedForMemoryReporter = true;
michael@0: 
michael@0:       // The main thread is almost certainly waiting so we must notify here.
michael@0:       mMemoryReportCondVar.Notify();
michael@0: 
michael@0:       // Wait for the memory report to finish.
michael@0:       while (mMemoryReporterRunning) {
michael@0:         mMemoryReportCondVar.Wait();
michael@0:       }
michael@0: 
michael@0:       MOZ_ASSERT(mBlockedForMemoryReporter);
michael@0: 
michael@0:       // No need to notify here as the main thread isn't watching for this
michael@0:       // state.
michael@0:       mBlockedForMemoryReporter = false;
michael@0:     }
michael@0: 
michael@0:     WorkerControlRunnable* event;
michael@0:     if (!mControlQueue.Pop(event)) {
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     MutexAutoUnlock unlock(mMutex);
michael@0: 
michael@0:     MOZ_ASSERT(event);
michael@0:     if (NS_FAILED(static_cast<nsIRunnable*>(event)->Run())) {
michael@0:       result = false;
michael@0:     }
michael@0: 
michael@0:     event->Release();
michael@0:   }
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::ClearMainEventQueue(WorkerRanOrNot aRanOrNot)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   MOZ_ASSERT(!mCancelAllPendingRunnables);
michael@0:   mCancelAllPendingRunnables = true;
michael@0: 
michael@0:   if (WorkerNeverRan == aRanOrNot) {
michael@0:     for (uint32_t count = mPreStartRunnables.Length(), index = 0;
michael@0:          index < count;
michael@0:          index++) {
michael@0:       nsRefPtr<WorkerRunnable> runnable = mPreStartRunnables[index].forget();
michael@0:       static_cast<nsIRunnable*>(runnable.get())->Run();
michael@0:     }
michael@0:   } else {
michael@0:     nsIThread* currentThread = NS_GetCurrentThread();
michael@0:     MOZ_ASSERT(currentThread);
michael@0: 
michael@0:     NS_ProcessPendingEvents(currentThread);
michael@0:     MOZ_ASSERT(!NS_HasPendingEvents(currentThread));
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(mCancelAllPendingRunnables);
michael@0:   mCancelAllPendingRunnables = false;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: WorkerPrivate::RemainingRunTimeMS() const
michael@0: {
michael@0:   if (mKillTime.IsNull()) {
michael@0:     return UINT32_MAX;
michael@0:   }
michael@0:   TimeDuration runtime = mKillTime - TimeStamp::Now();
michael@0:   double ms = runtime > TimeDuration(0) ? runtime.ToMilliseconds() : 0;
michael@0:   return ms > double(UINT32_MAX) ? UINT32_MAX : uint32_t(ms);
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::SuspendInternal(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(!mSuspended, "Already suspended!");
michael@0: 
michael@0:   mSuspended = true;
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::ResumeInternal(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(mSuspended, "Not yet suspended!");
michael@0: 
michael@0:   mSuspended = false;
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::TraceTimeouts(const TraceCallbacks& aCallbacks,
michael@0:                              void* aClosure) const
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   for (uint32_t index = 0; index < mTimeouts.Length(); index++) {
michael@0:     TimeoutInfo* info = mTimeouts[index];
michael@0: 
michael@0:     if (info->mTimeoutCallable.isUndefined()) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     aCallbacks.Trace(&info->mTimeoutCallable, "mTimeoutCallable", aClosure);
michael@0:     for (uint32_t index2 = 0; index2 < info->mExtraArgVals.Length(); index2++) {
michael@0:       aCallbacks.Trace(&info->mExtraArgVals[index2], "mExtraArgVals[i]", aClosure);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::ModifyBusyCountFromWorker(JSContext* aCx, bool aIncrease)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     // If we're in shutdown then the busy count is no longer being considered so
michael@0:     // just return now.
michael@0:     if (mStatus >= Killing) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<ModifyBusyCountRunnable> runnable =
michael@0:     new ModifyBusyCountRunnable(this, aIncrease);
michael@0:   return runnable->Dispatch(aCx);
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::AddChildWorker(JSContext* aCx, ParentType* aChildWorker)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   {
michael@0:     Status currentStatus;
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0:       currentStatus = mStatus;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(currentStatus == Running);
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   NS_ASSERTION(!mChildWorkers.Contains(aChildWorker),
michael@0:                "Already know about this one!");
michael@0:   mChildWorkers.AppendElement(aChildWorker);
michael@0: 
michael@0:   return mChildWorkers.Length() == 1 ?
michael@0:          ModifyBusyCountFromWorker(aCx, true) :
michael@0:          true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::RemoveChildWorker(JSContext* aCx, ParentType* aChildWorker)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(mChildWorkers.Contains(aChildWorker),
michael@0:                "Didn't know about this one!");
michael@0:   mChildWorkers.RemoveElement(aChildWorker);
michael@0: 
michael@0:   if (mChildWorkers.IsEmpty() && !ModifyBusyCountFromWorker(aCx, false)) {
michael@0:     NS_WARNING("Failed to modify busy count!");
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::AddFeature(JSContext* aCx, WorkerFeature* aFeature)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mStatus >= Canceling) {
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(!mFeatures.Contains(aFeature), "Already know about this one!");
michael@0:   mFeatures.AppendElement(aFeature);
michael@0: 
michael@0:   return mFeatures.Length() == 1 ?
michael@0:          ModifyBusyCountFromWorker(aCx, true) :
michael@0:          true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::RemoveFeature(JSContext* aCx, WorkerFeature* aFeature)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(mFeatures.Contains(aFeature), "Didn't know about this one!");
michael@0:   mFeatures.RemoveElement(aFeature);
michael@0: 
michael@0:   if (mFeatures.IsEmpty() && !ModifyBusyCountFromWorker(aCx, false)) {
michael@0:     NS_WARNING("Failed to modify busy count!");
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::NotifyFeatures(JSContext* aCx, Status aStatus)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(aStatus > Running, "Bad status!");
michael@0: 
michael@0:   if (aStatus >= Closing) {
michael@0:     CancelAllTimeouts(aCx);
michael@0:   }
michael@0: 
michael@0:   nsAutoTArray<WorkerFeature*, 30> features;
michael@0:   features.AppendElements(mFeatures);
michael@0: 
michael@0:   for (uint32_t index = 0; index < features.Length(); index++) {
michael@0:     if (!features[index]->Notify(aCx, aStatus)) {
michael@0:       NS_WARNING("Failed to notify feature!");
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsAutoTArray<ParentType*, 10> children;
michael@0:   children.AppendElements(mChildWorkers);
michael@0: 
michael@0:   for (uint32_t index = 0; index < children.Length(); index++) {
michael@0:     if (!children[index]->Notify(aCx, aStatus)) {
michael@0:       NS_WARNING("Failed to notify child worker!");
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::CancelAllTimeouts(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   if (mTimerRunning) {
michael@0:     NS_ASSERTION(mTimer, "Huh?!");
michael@0:     NS_ASSERTION(!mTimeouts.IsEmpty(), "Huh?!");
michael@0: 
michael@0:     if (NS_FAILED(mTimer->Cancel())) {
michael@0:       NS_WARNING("Failed to cancel timer!");
michael@0:     }
michael@0: 
michael@0:     for (uint32_t index = 0; index < mTimeouts.Length(); index++) {
michael@0:       mTimeouts[index]->mCanceled = true;
michael@0:     }
michael@0: 
michael@0:     if (!RunExpiredTimeouts(aCx)) {
michael@0:       JS_ReportPendingException(aCx);
michael@0:     }
michael@0: 
michael@0:     mTimerRunning = false;
michael@0:   }
michael@0: #ifdef DEBUG
michael@0:   else if (!mRunningExpiredTimeouts) {
michael@0:     NS_ASSERTION(mTimeouts.IsEmpty(), "Huh?!");
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   mTimer = nullptr;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIEventTarget>
michael@0: WorkerPrivate::CreateNewSyncLoop()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   nsCOMPtr<nsIThreadInternal> thread = do_QueryInterface(NS_GetCurrentThread());
michael@0:   MOZ_ASSERT(thread);
michael@0: 
michael@0:   nsCOMPtr<nsIEventTarget> realEventTarget;
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(thread->PushEventQueue(
michael@0:                                              getter_AddRefs(realEventTarget))));
michael@0: 
michael@0:   nsRefPtr<EventTarget> workerEventTarget =
michael@0:     new EventTarget(this, realEventTarget);
michael@0: 
michael@0:   {
michael@0:     // Modifications must be protected by mMutex in DEBUG builds, see comment
michael@0:     // about mSyncLoopStack in WorkerPrivate.h.
michael@0: #ifdef DEBUG
michael@0:     MutexAutoLock lock(mMutex);
michael@0: #endif
michael@0: 
michael@0:     mSyncLoopStack.AppendElement(new SyncLoopInfo(workerEventTarget));
michael@0:   }
michael@0: 
michael@0:   return workerEventTarget.forget();
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::RunCurrentSyncLoop()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   JSContext* cx = GetJSContext();
michael@0:   MOZ_ASSERT(cx);
michael@0: 
michael@0:   // This should not change between now and the time we finish running this sync
michael@0:   // loop.
michael@0:   uint32_t currentLoopIndex = mSyncLoopStack.Length() - 1;
michael@0: 
michael@0:   SyncLoopInfo* loopInfo = mSyncLoopStack[currentLoopIndex];
michael@0: 
michael@0:   MOZ_ASSERT(loopInfo);
michael@0:   MOZ_ASSERT(!loopInfo->mHasRun);
michael@0:   MOZ_ASSERT(!loopInfo->mCompleted);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   loopInfo->mHasRun = true;
michael@0: #endif
michael@0: 
michael@0:   nsCOMPtr<nsIThreadInternal> thread = do_QueryInterface(mThread);
michael@0:   MOZ_ASSERT(thread);
michael@0: 
michael@0:   while (!loopInfo->mCompleted) {
michael@0:     bool normalRunnablesPending = false;
michael@0: 
michael@0:     // Don't block with the periodic GC timer running.
michael@0:     if (!NS_HasPendingEvents(thread)) {
michael@0:       SetGCTimerMode(IdleTimer);
michael@0:     }
michael@0: 
michael@0:     // Wait for something to do.
michael@0:     {
michael@0:       MutexAutoLock lock(mMutex);
michael@0: 
michael@0:       for (;;) {
michael@0:         while (mControlQueue.IsEmpty() &&
michael@0:                !normalRunnablesPending &&
michael@0:                !(normalRunnablesPending = NS_HasPendingEvents(thread))) {
michael@0:           WaitForWorkerEvents();
michael@0:         }
michael@0: 
michael@0:         ProcessAllControlRunnablesLocked();
michael@0: 
michael@0:         // NB: If we processed a NotifyRunnable, we might have run non-control
michael@0:         // runnables, one of which may have shut down the sync loop.
michael@0:         if (normalRunnablesPending || loopInfo->mCompleted) {
michael@0:           break;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (normalRunnablesPending) {
michael@0:       // Make sure the periodic timer is running before we continue.
michael@0:       SetGCTimerMode(PeriodicTimer);
michael@0: 
michael@0:       MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(thread, false));
michael@0: 
michael@0:       // Now *might* be a good time to GC. Let the JS engine make the decision.
michael@0:       JS_MaybeGC(cx);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Make sure that the stack didn't change underneath us.
michael@0:   MOZ_ASSERT(mSyncLoopStack[currentLoopIndex] == loopInfo);
michael@0: 
michael@0:   return DestroySyncLoop(currentLoopIndex);
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::DestroySyncLoop(uint32_t aLoopIndex, nsIThreadInternal* aThread)
michael@0: {
michael@0:   MOZ_ASSERT(!mSyncLoopStack.IsEmpty());
michael@0:   MOZ_ASSERT(mSyncLoopStack.Length() - 1 == aLoopIndex);
michael@0: 
michael@0:   if (!aThread) {
michael@0:     nsCOMPtr<nsIThreadInternal> thread = do_QueryInterface(mThread);
michael@0:     MOZ_ASSERT(thread);
michael@0: 
michael@0:     aThread = thread.get();
michael@0:   }
michael@0: 
michael@0:   // We're about to delete the loop, stash its event target and result.
michael@0:   SyncLoopInfo* loopInfo = mSyncLoopStack[aLoopIndex];
michael@0:   nsIEventTarget* nestedEventTarget =
michael@0:     loopInfo->mEventTarget->GetWeakNestedEventTarget();
michael@0:   MOZ_ASSERT(nestedEventTarget);
michael@0: 
michael@0:   bool result = loopInfo->mResult;
michael@0: 
michael@0:   {
michael@0:     // Modifications must be protected by mMutex in DEBUG builds, see comment
michael@0:     // about mSyncLoopStack in WorkerPrivate.h.
michael@0: #ifdef DEBUG
michael@0:     MutexAutoLock lock(mMutex);
michael@0: #endif
michael@0: 
michael@0:     // This will delete |loopInfo|!
michael@0:     mSyncLoopStack.RemoveElementAt(aLoopIndex);
michael@0:   }
michael@0: 
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(aThread->PopEventQueue(nestedEventTarget)));
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::StopSyncLoop(nsIEventTarget* aSyncLoopTarget, bool aResult)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   AssertValidSyncLoop(aSyncLoopTarget);
michael@0: 
michael@0:   MOZ_ASSERT(!mSyncLoopStack.IsEmpty());
michael@0: 
michael@0:   for (uint32_t index = mSyncLoopStack.Length(); index > 0; index--) {
michael@0:     nsAutoPtr<SyncLoopInfo>& loopInfo = mSyncLoopStack[index - 1];
michael@0:     MOZ_ASSERT(loopInfo);
michael@0:     MOZ_ASSERT(loopInfo->mEventTarget);
michael@0: 
michael@0:     if (loopInfo->mEventTarget == aSyncLoopTarget) {
michael@0:       // Can't assert |loop->mHasRun| here because dispatch failures can cause
michael@0:       // us to bail out early.
michael@0:       MOZ_ASSERT(!loopInfo->mCompleted);
michael@0: 
michael@0:       loopInfo->mResult = aResult;
michael@0:       loopInfo->mCompleted = true;
michael@0: 
michael@0:       loopInfo->mEventTarget->Disable();
michael@0: 
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(!SameCOMIdentity(loopInfo->mEventTarget, aSyncLoopTarget));
michael@0:   }
michael@0: 
michael@0:   MOZ_CRASH("Unknown sync loop!");
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG
michael@0: void
michael@0: WorkerPrivate::AssertValidSyncLoop(nsIEventTarget* aSyncLoopTarget)
michael@0: {
michael@0:   MOZ_ASSERT(aSyncLoopTarget);
michael@0: 
michael@0:   EventTarget* workerTarget;
michael@0:   nsresult rv =
michael@0:     aSyncLoopTarget->QueryInterface(kDEBUGWorkerEventTargetIID,
michael@0:                                     reinterpret_cast<void**>(&workerTarget));
michael@0:   MOZ_ASSERT(NS_SUCCEEDED(rv));
michael@0:   MOZ_ASSERT(workerTarget);
michael@0: 
michael@0:   bool valid = false;
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     for (uint32_t index = 0; index < mSyncLoopStack.Length(); index++) {
michael@0:       nsAutoPtr<SyncLoopInfo>& loopInfo = mSyncLoopStack[index];
michael@0:       MOZ_ASSERT(loopInfo);
michael@0:       MOZ_ASSERT(loopInfo->mEventTarget);
michael@0: 
michael@0:       if (loopInfo->mEventTarget == aSyncLoopTarget) {
michael@0:         valid = true;
michael@0:         break;
michael@0:       }
michael@0: 
michael@0:       MOZ_ASSERT(!SameCOMIdentity(loopInfo->mEventTarget, aSyncLoopTarget));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(valid);
michael@0: }
michael@0: #endif
michael@0: 
michael@0: void
michael@0: WorkerPrivate::PostMessageToParentInternal(
michael@0:                             JSContext* aCx,
michael@0:                             JS::Handle<JS::Value> aMessage,
michael@0:                             const Optional<Sequence<JS::Value>>& aTransferable,
michael@0:                             bool aToMessagePort,
michael@0:                             uint64_t aMessagePortSerial,
michael@0:                             ErrorResult& aRv)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue());
michael@0:   if (aTransferable.WasPassed()) {
michael@0:     const Sequence<JS::Value>& realTransferable = aTransferable.Value();
michael@0: 
michael@0:     // The input sequence only comes from the generated bindings code, which
michael@0:     // ensures it is rooted.
michael@0:     JS::HandleValueArray elements =
michael@0:       JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(),
michael@0:                                                realTransferable.Elements());
michael@0: 
michael@0:     JSObject* array = JS_NewArrayObject(aCx, elements);
michael@0:     if (!array) {
michael@0:       aRv = NS_ERROR_OUT_OF_MEMORY;
michael@0:       return;
michael@0:     }
michael@0:     transferable.setObject(*array);
michael@0:   }
michael@0: 
michael@0:   JSStructuredCloneCallbacks* callbacks =
michael@0:     IsChromeWorker() ?
michael@0:     &gChromeWorkerStructuredCloneCallbacks :
michael@0:     &gWorkerStructuredCloneCallbacks;
michael@0: 
michael@0:   nsTArray<nsCOMPtr<nsISupports>> clonedObjects;
michael@0: 
michael@0:   JSAutoStructuredCloneBuffer buffer;
michael@0:   if (!buffer.write(aCx, aMessage, transferable, callbacks, &clonedObjects)) {
michael@0:     aRv = NS_ERROR_DOM_DATA_CLONE_ERR;
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<MessageEventRunnable> runnable =
michael@0:     new MessageEventRunnable(this,
michael@0:                              WorkerRunnable::ParentThreadUnchangedBusyCount,
michael@0:                              Move(buffer), clonedObjects, aToMessagePort,
michael@0:                              aMessagePortSerial);
michael@0:   if (!runnable->Dispatch(aCx)) {
michael@0:     aRv = NS_ERROR_FAILURE;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::PostMessageToParentMessagePort(
michael@0:                              JSContext* aCx,
michael@0:                              uint64_t aMessagePortSerial,
michael@0:                              JS::Handle<JS::Value> aMessage,
michael@0:                              const Optional<Sequence<JS::Value>>& aTransferable,
michael@0:                              ErrorResult& aRv)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   if (!mWorkerPorts.GetWeak(aMessagePortSerial)) {
michael@0:     // This port has been closed from the main thread. There's no point in
michael@0:     // sending this message so just bail.
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   PostMessageToParentInternal(aCx, aMessage, aTransferable, true,
michael@0:                               aMessagePortSerial, aRv);
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::NotifyInternal(JSContext* aCx, Status aStatus)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(aStatus > Running && aStatus < Dead, "Bad status!");
michael@0: 
michael@0:   nsRefPtr<EventTarget> eventTarget;
michael@0: 
michael@0:   // Save the old status and set the new status.
michael@0:   Status previousStatus;
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (mStatus >= aStatus) {
michael@0:       MOZ_ASSERT(!mEventTarget);
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     previousStatus = mStatus;
michael@0:     mStatus = aStatus;
michael@0: 
michael@0:     mEventTarget.swap(eventTarget);
michael@0:   }
michael@0: 
michael@0:   // Now that mStatus > Running, no-one can create a new WorkerEventTarget or
michael@0:   // WorkerCrossThreadDispatcher if we don't already have one.
michael@0:   if (eventTarget) {
michael@0:     // Since we'll no longer process events, make sure we no longer allow anyone
michael@0:     // to post them. We have to do this without mMutex held, since our mutex
michael@0:     // must be acquired *after* the WorkerEventTarget's mutex when they're both
michael@0:     // held.
michael@0:     eventTarget->Disable();
michael@0:     eventTarget = nullptr;
michael@0:   }
michael@0: 
michael@0:   if (mCrossThreadDispatcher) {
michael@0:     // Since we'll no longer process events, make sure we no longer allow
michael@0:     // anyone to post them. We have to do this without mMutex held, since our
michael@0:     // mutex must be acquired *after* mCrossThreadDispatcher's mutex when
michael@0:     // they're both held.
michael@0:     mCrossThreadDispatcher->Forget();
michael@0:     mCrossThreadDispatcher = nullptr;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(previousStatus != Pending);
michael@0: 
michael@0:   MOZ_ASSERT(previousStatus >= Canceling || mKillTime.IsNull());
michael@0: 
michael@0:   // Let all our features know the new status.
michael@0:   NotifyFeatures(aCx, aStatus);
michael@0: 
michael@0:   // If this is the first time our status has changed then we need to clear the
michael@0:   // main event queue.
michael@0:   if (previousStatus == Running) {
michael@0:     ClearMainEventQueue(WorkerRan);
michael@0:   }
michael@0: 
michael@0:   // If we've run the close handler, we don't need to do anything else.
michael@0:   if (mCloseHandlerFinished) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // If the worker script never ran, or failed to compile, we don't need to do
michael@0:   // anything else, except pretend that we ran the close handler.
michael@0:   if (!JS::CurrentGlobalOrNull(aCx)) {
michael@0:     mCloseHandlerStarted = true;
michael@0:     mCloseHandlerFinished = true;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // If this is the first time our status has changed we also need to schedule
michael@0:   // the close handler unless we're being shut down.
michael@0:   if (previousStatus == Running && aStatus != Killing) {
michael@0:     MOZ_ASSERT(!mCloseHandlerStarted && !mCloseHandlerFinished);
michael@0: 
michael@0:     nsRefPtr<CloseEventRunnable> closeRunnable = new CloseEventRunnable(this);
michael@0:     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(closeRunnable)));
michael@0:   }
michael@0: 
michael@0:   if (aStatus == Closing) {
michael@0:     // Notify parent to stop sending us messages and balance our busy count.
michael@0:     nsRefPtr<CloseRunnable> runnable = new CloseRunnable(this);
michael@0:     if (!runnable->Dispatch(aCx)) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // Don't abort the script.
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   if (aStatus == Terminating) {
michael@0:     // Only abort the script if we're not yet running the close handler.
michael@0:     return mCloseHandlerStarted;
michael@0:   }
michael@0: 
michael@0:   if (aStatus == Canceling) {
michael@0:     // We need to enforce a timeout on the close handler.
michael@0:     MOZ_ASSERT(previousStatus >= Running && previousStatus <= Terminating);
michael@0: 
michael@0:     uint32_t killSeconds = IsChromeWorker() ?
michael@0:       RuntimeService::GetChromeCloseHandlerTimeoutSeconds() :
michael@0:       RuntimeService::GetContentCloseHandlerTimeoutSeconds();
michael@0: 
michael@0:     if (killSeconds) {
michael@0:       mKillTime = TimeStamp::Now() + TimeDuration::FromSeconds(killSeconds);
michael@0: 
michael@0:       if (!mCloseHandlerFinished && !ScheduleKillCloseEventRunnable(aCx)) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Only abort the script if we're not yet running the close handler.
michael@0:     return mCloseHandlerStarted;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(aStatus == Killing);
michael@0: 
michael@0:   mKillTime = TimeStamp::Now();
michael@0: 
michael@0:   if (mCloseHandlerStarted && !mCloseHandlerFinished) {
michael@0:     ScheduleKillCloseEventRunnable(aCx);
michael@0:   }
michael@0: 
michael@0:   // Always abort the script.
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::ScheduleKillCloseEventRunnable(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(!mKillTime.IsNull());
michael@0: 
michael@0:   nsRefPtr<KillCloseEventRunnable> killCloseEventRunnable =
michael@0:     new KillCloseEventRunnable(this);
michael@0:   if (!killCloseEventRunnable->SetTimeout(aCx, RemainingRunTimeMS())) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToCurrentThread(
michael@0:                                                       killCloseEventRunnable)));
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::ReportError(JSContext* aCx, const char* aMessage,
michael@0:                            JSErrorReport* aReport)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   if (!MayContinueRunning() || mErrorHandlerRecursionCount == 2) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(mErrorHandlerRecursionCount == 0 ||
michael@0:                mErrorHandlerRecursionCount == 1,
michael@0:                "Bad recursion logic!");
michael@0: 
michael@0:   JS_ClearPendingException(aCx);
michael@0: 
michael@0:   nsString message, filename, line;
michael@0:   uint32_t lineNumber, columnNumber, flags, errorNumber;
michael@0: 
michael@0:   if (aReport) {
michael@0:     // ErrorEvent objects don't have a |name| field the way ES |Error| objects
michael@0:     // do. Traditionally (and mostly by accident), the |message| field of
michael@0:     // ErrorEvent has corresponded to |Name: Message| of the original Error
michael@0:     // object. Things have been cleaned up in the JS engine, so now we need to
michael@0:     // format this string explicitly.
michael@0:     JS::Rooted<JSString*> messageStr(aCx,
michael@0:                                      js::ErrorReportToString(aCx, aReport));
michael@0:     if (messageStr) {
michael@0:       nsDependentJSString depStr;
michael@0:       if (depStr.init(aCx, messageStr)) {
michael@0:         message = depStr;
michael@0:       }
michael@0:     }
michael@0:     filename = NS_ConvertUTF8toUTF16(aReport->filename);
michael@0:     line = aReport->uclinebuf;
michael@0:     lineNumber = aReport->lineno;
michael@0:     columnNumber = aReport->uctokenptr - aReport->uclinebuf;
michael@0:     flags = aReport->flags;
michael@0:     errorNumber = aReport->errorNumber;
michael@0:   }
michael@0:   else {
michael@0:     lineNumber = columnNumber = errorNumber = 0;
michael@0:     flags = nsIScriptError::errorFlag | nsIScriptError::exceptionFlag;
michael@0:   }
michael@0: 
michael@0:   if (message.IsEmpty()) {
michael@0:     message = NS_ConvertUTF8toUTF16(aMessage);
michael@0:   }
michael@0: 
michael@0:   mErrorHandlerRecursionCount++;
michael@0: 
michael@0:   // Don't want to run the scope's error handler if this is a recursive error or
michael@0:   // if there was an error in the close handler or if we ran out of memory.
michael@0:   bool fireAtScope = mErrorHandlerRecursionCount == 1 &&
michael@0:                      !mCloseHandlerStarted &&
michael@0:                      errorNumber != JSMSG_OUT_OF_MEMORY;
michael@0: 
michael@0:   if (!ReportErrorRunnable::ReportError(aCx, this, fireAtScope, nullptr, message,
michael@0:                                         filename, line, lineNumber,
michael@0:                                         columnNumber, flags, errorNumber, 0)) {
michael@0:     JS_ReportPendingException(aCx);
michael@0:   }
michael@0: 
michael@0:   mErrorHandlerRecursionCount--;
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: WorkerPrivate::SetTimeout(JSContext* aCx,
michael@0:                           Function* aHandler,
michael@0:                           const nsAString& aStringHandler,
michael@0:                           int32_t aTimeout,
michael@0:                           const Sequence<JS::Value>& aArguments,
michael@0:                           bool aIsInterval,
michael@0:                           ErrorResult& aRv)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   const int32_t timerId = mNextTimeoutId++;
michael@0: 
michael@0:   Status currentStatus;
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0:     currentStatus = mStatus;
michael@0:   }
michael@0: 
michael@0:   // It's a script bug if setTimeout/setInterval are called from a close handler
michael@0:   // so throw an exception.
michael@0:   if (currentStatus == Closing) {
michael@0:     JS_ReportError(aCx, "Cannot schedule timeouts from the close handler!");
michael@0:   }
michael@0: 
michael@0:   // If the worker is trying to call setTimeout/setInterval and the parent
michael@0:   // thread has initiated the close process then just silently fail.
michael@0:   if (currentStatus >= Closing) {
michael@0:     aRv.Throw(NS_ERROR_FAILURE);
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   nsAutoPtr<TimeoutInfo> newInfo(new TimeoutInfo());
michael@0:   newInfo->mIsInterval = aIsInterval;
michael@0:   newInfo->mId = timerId;
michael@0: 
michael@0:   if (MOZ_UNLIKELY(timerId == INT32_MAX)) {
michael@0:     NS_WARNING("Timeout ids overflowed!");
michael@0:     mNextTimeoutId = 1;
michael@0:   }
michael@0: 
michael@0:   // Take care of the main argument.
michael@0:   if (aHandler) {
michael@0:     newInfo->mTimeoutCallable = JS::ObjectValue(*aHandler->Callable());
michael@0:   }
michael@0:   else if (!aStringHandler.IsEmpty()) {
michael@0:     newInfo->mTimeoutString = aStringHandler;
michael@0:   }
michael@0:   else {
michael@0:     JS_ReportError(aCx, "Useless %s call (missing quotes around argument?)",
michael@0:                    aIsInterval ? "setInterval" : "setTimeout");
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   // See if any of the optional arguments were passed.
michael@0:   aTimeout = std::max(0, aTimeout);
michael@0:   newInfo->mInterval = TimeDuration::FromMilliseconds(aTimeout);
michael@0: 
michael@0:   uint32_t argc = aArguments.Length();
michael@0:   if (argc && !newInfo->mTimeoutCallable.isUndefined()) {
michael@0:     nsTArray<JS::Heap<JS::Value>> extraArgVals(argc);
michael@0:     for (uint32_t index = 0; index < argc; index++) {
michael@0:       extraArgVals.AppendElement(aArguments[index]);
michael@0:     }
michael@0:     newInfo->mExtraArgVals.SwapElements(extraArgVals);
michael@0:   }
michael@0: 
michael@0:   newInfo->mTargetTime = TimeStamp::Now() + newInfo->mInterval;
michael@0: 
michael@0:   if (!newInfo->mTimeoutString.IsEmpty()) {
michael@0:     const char* filenameChars;
michael@0:     uint32_t lineNumber;
michael@0:     if (nsJSUtils::GetCallingLocation(aCx, &filenameChars, &lineNumber)) {
michael@0:       newInfo->mFilename = filenameChars;
michael@0:       newInfo->mLineNumber = lineNumber;
michael@0:     }
michael@0:     else {
michael@0:       NS_WARNING("Failed to get calling location!");
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsAutoPtr<TimeoutInfo>* insertedInfo =
michael@0:     mTimeouts.InsertElementSorted(newInfo.forget(), GetAutoPtrComparator(mTimeouts));
michael@0: 
michael@0:   // If the timeout we just made is set to fire next then we need to update the
michael@0:   // timer.
michael@0:   if (insertedInfo == mTimeouts.Elements()) {
michael@0:     nsresult rv;
michael@0: 
michael@0:     if (!mTimer) {
michael@0:       nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
michael@0:       if (NS_FAILED(rv)) {
michael@0:         aRv.Throw(rv);
michael@0:         return 0;
michael@0:       }
michael@0: 
michael@0:       nsRefPtr<TimerRunnable> runnable = new TimerRunnable(this);
michael@0: 
michael@0:       nsRefPtr<TimerThreadEventTarget> target =
michael@0:         new TimerThreadEventTarget(this, runnable);
michael@0: 
michael@0:       rv = timer->SetTarget(target);
michael@0:       if (NS_FAILED(rv)) {
michael@0:         aRv.Throw(rv);
michael@0:         return 0;
michael@0:       }
michael@0: 
michael@0:       timer.swap(mTimer);
michael@0:     }
michael@0: 
michael@0:     if (!mTimerRunning) {
michael@0:       if (!ModifyBusyCountFromWorker(aCx, true)) {
michael@0:         aRv.Throw(NS_ERROR_FAILURE);
michael@0:         return 0;
michael@0:       }
michael@0:       mTimerRunning = true;
michael@0:     }
michael@0: 
michael@0:     if (!RescheduleTimeoutTimer(aCx)) {
michael@0:       aRv.Throw(NS_ERROR_FAILURE);
michael@0:       return 0;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return timerId;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::ClearTimeout(int32_t aId)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   if (!mTimeouts.IsEmpty()) {
michael@0:     NS_ASSERTION(mTimerRunning, "Huh?!");
michael@0: 
michael@0:     for (uint32_t index = 0; index < mTimeouts.Length(); index++) {
michael@0:       nsAutoPtr<TimeoutInfo>& info = mTimeouts[index];
michael@0:       if (info->mId == aId) {
michael@0:         info->mCanceled = true;
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::RunExpiredTimeouts(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   // We may be called recursively (e.g. close() inside a timeout) or we could
michael@0:   // have been canceled while this event was pending, bail out if there is
michael@0:   // nothing to do.
michael@0:   if (mRunningExpiredTimeouts || !mTimerRunning) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(mTimer, "Must have a timer!");
michael@0:   NS_ASSERTION(!mTimeouts.IsEmpty(), "Should have some work to do!");
michael@0: 
michael@0:   bool retval = true;
michael@0: 
michael@0:   AutoPtrComparator<TimeoutInfo> comparator = GetAutoPtrComparator(mTimeouts);
michael@0:   JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
michael@0: 
michael@0:   // We want to make sure to run *something*, even if the timer fired a little
michael@0:   // early. Fudge the value of now to at least include the first timeout.
michael@0:   const TimeStamp now = std::max(TimeStamp::Now(), mTimeouts[0]->mTargetTime);
michael@0: 
michael@0:   nsAutoTArray<TimeoutInfo*, 10> expiredTimeouts;
michael@0:   for (uint32_t index = 0; index < mTimeouts.Length(); index++) {
michael@0:     nsAutoPtr<TimeoutInfo>& info = mTimeouts[index];
michael@0:     if (info->mTargetTime > now) {
michael@0:       break;
michael@0:     }
michael@0:     expiredTimeouts.AppendElement(info);
michael@0:   }
michael@0: 
michael@0:   // Guard against recursion.
michael@0:   mRunningExpiredTimeouts = true;
michael@0: 
michael@0:   // Run expired timeouts.
michael@0:   for (uint32_t index = 0; index < expiredTimeouts.Length(); index++) {
michael@0:     TimeoutInfo*& info = expiredTimeouts[index];
michael@0: 
michael@0:     if (info->mCanceled) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     // Always call JS_ReportPendingException if something fails, and if
michael@0:     // JS_ReportPendingException returns false (i.e. uncatchable exception) then
michael@0:     // break out of the loop.
michael@0: 
michael@0:     if (!info->mTimeoutCallable.isUndefined()) {
michael@0:       JS::Rooted<JS::Value> rval(aCx);
michael@0:       JS::HandleValueArray args =
michael@0:         JS::HandleValueArray::fromMarkedLocation(info->mExtraArgVals.Length(),
michael@0:                                                  info->mExtraArgVals.Elements()->address());
michael@0:       JS::Rooted<JS::Value> callable(aCx, info->mTimeoutCallable);
michael@0:       if (!JS_CallFunctionValue(aCx, global, callable, args, &rval) &&
michael@0:           !JS_ReportPendingException(aCx)) {
michael@0:         retval = false;
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       nsString expression = info->mTimeoutString;
michael@0: 
michael@0:       JS::CompileOptions options(aCx);
michael@0:       options.setFileAndLine(info->mFilename.get(), info->mLineNumber);
michael@0: 
michael@0:       if ((expression.IsEmpty() ||
michael@0:            !JS::Evaluate(aCx, global, options, expression.get(), expression.Length())) &&
michael@0:           !JS_ReportPendingException(aCx)) {
michael@0:         retval = false;
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(mRunningExpiredTimeouts, "Someone changed this!");
michael@0:   }
michael@0: 
michael@0:   // No longer possible to be called recursively.
michael@0:   mRunningExpiredTimeouts = false;
michael@0: 
michael@0:   // Now remove canceled and expired timeouts from the main list.
michael@0:   // NB: The timeouts present in expiredTimeouts must have the same order
michael@0:   // with respect to each other in mTimeouts.  That is, mTimeouts is just
michael@0:   // expiredTimeouts with extra elements inserted.  There may be unexpired
michael@0:   // timeouts that have been inserted between the expired timeouts if the
michael@0:   // timeout event handler called setTimeout/setInterval.
michael@0:   for (uint32_t index = 0, expiredTimeoutIndex = 0,
michael@0:        expiredTimeoutLength = expiredTimeouts.Length();
michael@0:        index < mTimeouts.Length(); ) {
michael@0:     nsAutoPtr<TimeoutInfo>& info = mTimeouts[index];
michael@0:     if ((expiredTimeoutIndex < expiredTimeoutLength &&
michael@0:          info == expiredTimeouts[expiredTimeoutIndex] &&
michael@0:          ++expiredTimeoutIndex) ||
michael@0:         info->mCanceled) {
michael@0:       if (info->mIsInterval && !info->mCanceled) {
michael@0:         // Reschedule intervals.
michael@0:         info->mTargetTime = info->mTargetTime + info->mInterval;
michael@0:         // Don't resort the list here, we'll do that at the end.
michael@0:         ++index;
michael@0:       }
michael@0:       else {
michael@0:         mTimeouts.RemoveElement(info);
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       // If info did not match the current entry in expiredTimeouts, it
michael@0:       // shouldn't be there at all.
michael@0:       NS_ASSERTION(!expiredTimeouts.Contains(info),
michael@0:                    "Our timeouts are out of order!");
michael@0:       ++index;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   mTimeouts.Sort(comparator);
michael@0: 
michael@0:   // Either signal the parent that we're no longer using timeouts or reschedule
michael@0:   // the timer.
michael@0:   if (mTimeouts.IsEmpty()) {
michael@0:     if (!ModifyBusyCountFromWorker(aCx, false)) {
michael@0:       retval = false;
michael@0:     }
michael@0:     mTimerRunning = false;
michael@0:   }
michael@0:   else if (retval && !RescheduleTimeoutTimer(aCx)) {
michael@0:     retval = false;
michael@0:   }
michael@0: 
michael@0:   return retval;
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::RescheduleTimeoutTimer(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   NS_ASSERTION(!mTimeouts.IsEmpty(), "Should have some timeouts!");
michael@0:   NS_ASSERTION(mTimer, "Should have a timer!");
michael@0: 
michael@0:   double delta =
michael@0:     (mTimeouts[0]->mTargetTime - TimeStamp::Now()).ToMilliseconds();
michael@0:   uint32_t delay = delta > 0 ? std::min(delta, double(UINT32_MAX)) : 0;
michael@0: 
michael@0:   nsresult rv = mTimer->InitWithFuncCallback(DummyCallback, nullptr, delay,
michael@0:                                              nsITimer::TYPE_ONE_SHOT);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     JS_ReportError(aCx, "Failed to start timer!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::UpdateRuntimeAndContextOptionsInternal(
michael@0:                                     JSContext* aCx,
michael@0:                                     const JS::RuntimeOptions& aRuntimeOptions,
michael@0:                                     const JS::ContextOptions& aContentCxOptions,
michael@0:                                     const JS::ContextOptions& aChromeCxOptions)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   JS::RuntimeOptionsRef(aCx) = aRuntimeOptions;
michael@0:   JS::ContextOptionsRef(aCx) = IsChromeWorker() ? aChromeCxOptions : aContentCxOptions;
michael@0: 
michael@0:   for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:     mChildWorkers[index]->UpdateRuntimeAndContextOptions(aCx, aRuntimeOptions,
michael@0:                                                          aContentCxOptions,
michael@0:                                                          aChromeCxOptions);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::UpdatePreferenceInternal(JSContext* aCx, WorkerPreference aPref, bool aValue)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0:   MOZ_ASSERT(aPref >= 0 && aPref < WORKERPREF_COUNT);
michael@0: 
michael@0:   mPreferences[aPref] = aValue;
michael@0: 
michael@0:   for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:     mChildWorkers[index]->UpdatePreference(aCx, aPref, aValue);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::UpdateJSWorkerMemoryParameterInternal(JSContext* aCx,
michael@0:                                                      JSGCParamKey aKey,
michael@0:                                                      uint32_t aValue)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   // XXX aValue might be 0 here (telling us to unset a previous value for child
michael@0:   // workers). Calling JS_SetGCParameter with a value of 0 isn't actually
michael@0:   // supported though. We really need some way to revert to a default value
michael@0:   // here.
michael@0:   if (aValue) {
michael@0:     JS_SetGCParameter(JS_GetRuntime(aCx), aKey, aValue);
michael@0:   }
michael@0: 
michael@0:   for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:     mChildWorkers[index]->UpdateJSWorkerMemoryParameter(aCx, aKey, aValue);
michael@0:   }
michael@0: }
michael@0: 
michael@0: #ifdef JS_GC_ZEAL
michael@0: void
michael@0: WorkerPrivate::UpdateGCZealInternal(JSContext* aCx, uint8_t aGCZeal,
michael@0:                                     uint32_t aFrequency)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   JS_SetGCZeal(aCx, aGCZeal, aFrequency);
michael@0: 
michael@0:   for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:     mChildWorkers[index]->UpdateGCZeal(aCx, aGCZeal, aFrequency);
michael@0:   }
michael@0: }
michael@0: #endif
michael@0: 
michael@0: void
michael@0: WorkerPrivate::GarbageCollectInternal(JSContext* aCx, bool aShrinking,
michael@0:                                       bool aCollectChildren)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   if (!JS::CurrentGlobalOrNull(aCx)) {
michael@0:     // We haven't compiled anything yet. Just bail out.
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (aShrinking || aCollectChildren) {
michael@0:     JSRuntime* rt = JS_GetRuntime(aCx);
michael@0:     JS::PrepareForFullGC(rt);
michael@0: 
michael@0:     if (aShrinking) {
michael@0:       JS::ShrinkingGC(rt, JS::gcreason::DOM_WORKER);
michael@0: 
michael@0:       if (!aCollectChildren) {
michael@0:         LOG(("Worker %p collected idle garbage\n", this));
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       JS::GCForReason(rt, JS::gcreason::DOM_WORKER);
michael@0:       LOG(("Worker %p collected garbage\n", this));
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     JS_MaybeGC(aCx);
michael@0:     LOG(("Worker %p collected periodic garbage\n", this));
michael@0:   }
michael@0: 
michael@0:   if (aCollectChildren) {
michael@0:     for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:       mChildWorkers[index]->GarbageCollect(aCx, aShrinking);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::CycleCollectInternal(JSContext* aCx, bool aCollectChildren)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   nsCycleCollector_collect(nullptr);
michael@0: 
michael@0:   if (aCollectChildren) {
michael@0:     for (uint32_t index = 0; index < mChildWorkers.Length(); index++) {
michael@0:       mChildWorkers[index]->CycleCollect(aCx, /* dummy = */ false);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::SetThread(nsIThread* aThread)
michael@0: {
michael@0: #ifdef DEBUG
michael@0:   if (aThread) {
michael@0:     bool isOnCurrentThread;
michael@0:     MOZ_ASSERT(NS_SUCCEEDED(aThread->IsOnCurrentThread(&isOnCurrentThread)));
michael@0:     MOZ_ASSERT(isOnCurrentThread);
michael@0: 
michael@0:     MOZ_ASSERT(!mPRThread);
michael@0:     mPRThread = PRThreadFromThread(aThread);
michael@0:     MOZ_ASSERT(mPRThread);
michael@0:   }
michael@0:   else {
michael@0:     MOZ_ASSERT(mPRThread);
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   nsCOMPtr<nsIThread> doomedThread;
michael@0: 
michael@0:   { // Scope so that |doomedThread| is released without holding the lock.
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     if (aThread) {
michael@0:       MOZ_ASSERT(!mThread);
michael@0:       MOZ_ASSERT(mStatus == Pending);
michael@0: 
michael@0:       mThread = aThread;
michael@0: 
michael@0:       if (!mPreStartRunnables.IsEmpty()) {
michael@0:         for (uint32_t index = 0; index < mPreStartRunnables.Length(); index++) {
michael@0:           MOZ_ALWAYS_TRUE(NS_SUCCEEDED(mThread->Dispatch(
michael@0:                                                       mPreStartRunnables[index],
michael@0:                                                       NS_DISPATCH_NORMAL)));
michael@0:         }
michael@0:         mPreStartRunnables.Clear();
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       MOZ_ASSERT(mThread);
michael@0:       mThread.swap(doomedThread);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: WorkerCrossThreadDispatcher*
michael@0: WorkerPrivate::GetCrossThreadDispatcher()
michael@0: {
michael@0:   MutexAutoLock lock(mMutex);
michael@0: 
michael@0:   if (!mCrossThreadDispatcher && mStatus <= Running) {
michael@0:     mCrossThreadDispatcher = new WorkerCrossThreadDispatcher(this);
michael@0:   }
michael@0: 
michael@0:   return mCrossThreadDispatcher;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::BeginCTypesCall()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   // Don't try to GC while we're blocked in a ctypes call.
michael@0:   SetGCTimerMode(NoTimer);
michael@0: 
michael@0:   MutexAutoLock lock(mMutex);
michael@0: 
michael@0:   NS_ASSERTION(!mBlockedForMemoryReporter,
michael@0:                "Can't be blocked in more than one place at the same time!");
michael@0: 
michael@0:   // Let the main thread know that the worker is effectively blocked while in
michael@0:   // this ctypes call. It isn't technically true (obviously the call could do
michael@0:   // non-blocking things), but we're assuming that ctypes can't call back into
michael@0:   // JSAPI here and therefore any work the ctypes call does will not alter the
michael@0:   // data structures of this JS runtime.
michael@0:   mBlockedForMemoryReporter = true;
michael@0: 
michael@0:   // The main thread may be waiting on us so it must be notified.
michael@0:   mMemoryReportCondVar.Notify();
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::EndCTypesCall()
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   {
michael@0:     MutexAutoLock lock(mMutex);
michael@0: 
michael@0:     NS_ASSERTION(mBlockedForMemoryReporter, "Somehow we got unblocked!");
michael@0: 
michael@0:     // Don't continue until the memory reporter has finished.
michael@0:     while (mMemoryReporterRunning) {
michael@0:       mMemoryReportCondVar.Wait();
michael@0:     }
michael@0: 
michael@0:     // No need to notify the main thread here as it shouldn't be waiting to see
michael@0:     // this state.
michael@0:     mBlockedForMemoryReporter = false;
michael@0:   }
michael@0: 
michael@0:   // Make sure the periodic timer is running before we start running JS again.
michael@0:   SetGCTimerMode(PeriodicTimer);
michael@0: }
michael@0: 
michael@0: bool
michael@0: WorkerPrivate::ConnectMessagePort(JSContext* aCx, uint64_t aMessagePortSerial)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   NS_ASSERTION(!mWorkerPorts.GetWeak(aMessagePortSerial),
michael@0:                "Already have this port registered!");
michael@0: 
michael@0:   WorkerGlobalScope* globalScope = GlobalScope();
michael@0: 
michael@0:   JS::Rooted<JSObject*> jsGlobal(aCx, globalScope->GetWrapper());
michael@0:   MOZ_ASSERT(jsGlobal);
michael@0: 
michael@0:   nsRefPtr<MessagePort> port = new MessagePort(this, aMessagePortSerial);
michael@0: 
michael@0:   GlobalObject globalObject(aCx, jsGlobal);
michael@0:   if (globalObject.Failed()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   RootedDictionary<MessageEventInit> init(aCx);
michael@0:   init.mBubbles = false;
michael@0:   init.mCancelable = false;
michael@0:   init.mSource.SetValue().SetAsMessagePort() = port;
michael@0: 
michael@0:   ErrorResult rv;
michael@0: 
michael@0:   nsRefPtr<MessageEvent> event =
michael@0:     MessageEvent::Constructor(globalObject, aCx,
michael@0:                               NS_LITERAL_STRING("connect"), init, rv);
michael@0: 
michael@0:   event->SetTrusted(true);
michael@0: 
michael@0:   nsTArray<nsRefPtr<MessagePortBase>> ports;
michael@0:   ports.AppendElement(port);
michael@0: 
michael@0:   nsRefPtr<MessagePortList> portList =
michael@0:     new MessagePortList(static_cast<nsIDOMEventTarget*>(globalScope), ports);
michael@0:   event->SetPorts(portList);
michael@0: 
michael@0:   mWorkerPorts.Put(aMessagePortSerial, port);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMEvent> domEvent = do_QueryObject(event);
michael@0: 
michael@0:   nsEventStatus dummy = nsEventStatus_eIgnore;
michael@0:   globalScope->DispatchDOMEvent(nullptr, domEvent, nullptr, &dummy);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: WorkerPrivate::DisconnectMessagePort(uint64_t aMessagePortSerial)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   mWorkerPorts.Remove(aMessagePortSerial);
michael@0: }
michael@0: 
michael@0: workers::MessagePort*
michael@0: WorkerPrivate::GetMessagePort(uint64_t aMessagePortSerial)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   nsRefPtr<MessagePort> port;
michael@0:   if (mWorkerPorts.Get(aMessagePortSerial, getter_AddRefs(port))) {
michael@0:     return port;
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: JSObject*
michael@0: WorkerPrivate::CreateGlobalScope(JSContext* aCx)
michael@0: {
michael@0:   AssertIsOnWorkerThread();
michael@0: 
michael@0:   nsRefPtr<WorkerGlobalScope> globalScope;
michael@0:   if (IsSharedWorker()) {
michael@0:     globalScope = new SharedWorkerGlobalScope(this, SharedWorkerName());
michael@0:   }
michael@0:   else {
michael@0:     globalScope = new DedicatedWorkerGlobalScope(this);
michael@0:   }
michael@0: 
michael@0:   JS::Rooted<JSObject*> global(aCx, globalScope->WrapGlobalObject(aCx));
michael@0:   NS_ENSURE_TRUE(global, nullptr);
michael@0: 
michael@0:   JSAutoCompartment ac(aCx, global);
michael@0: 
michael@0:   if (!RegisterBindings(aCx, global)) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   mScope = globalScope.forget();
michael@0: 
michael@0:   JS_FireOnNewGlobalObject(aCx, global);
michael@0: 
michael@0:   return global;
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG
michael@0: 
michael@0: void
michael@0: WorkerPrivate::AssertIsOnWorkerThread() const
michael@0: {
michael@0:   // This is much more complicated than it needs to be but we can't use mThread
michael@0:   // because it must be protected by mMutex and sometimes this method is called
michael@0:   // when mMutex is already locked. This method should always work.
michael@0:   MOZ_ASSERT(mPRThread,
michael@0:              "AssertIsOnWorkerThread() called before a thread was assigned!");
michael@0: 
michael@0:   MOZ_ASSERT(nsThreadManager::get());
michael@0: 
michael@0:   nsCOMPtr<nsIThread> thread;
michael@0:   nsresult rv =
michael@0:     nsThreadManager::get()->GetThreadFromPRThread(mPRThread,
michael@0:                                                   getter_AddRefs(thread));
michael@0:   MOZ_ASSERT(NS_SUCCEEDED(rv));
michael@0:   MOZ_ASSERT(thread);
michael@0: 
michael@0:   bool current;
michael@0:   rv = thread->IsOnCurrentThread(&current);
michael@0:   MOZ_ASSERT(NS_SUCCEEDED(rv));
michael@0:   MOZ_ASSERT(current, "Wrong thread!");
michael@0: }
michael@0: 
michael@0: #endif // DEBUG
michael@0: 
michael@0: NS_IMPL_ISUPPORTS_INHERITED0(ExternalRunnableWrapper, WorkerRunnable)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_ADDREF(WorkerPrivateParent<Derived>::EventTarget)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMPL_RELEASE(WorkerPrivateParent<Derived>::EventTarget)
michael@0: 
michael@0: template <class Derived>
michael@0: NS_INTERFACE_MAP_BEGIN(WorkerPrivateParent<Derived>::EventTarget)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIEventTarget)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsISupports)
michael@0: #ifdef DEBUG
michael@0:   // kDEBUGWorkerEventTargetIID is special in that it does not AddRef its
michael@0:   // result.
michael@0:   if (aIID.Equals(kDEBUGWorkerEventTargetIID)) {
michael@0:     *aInstancePtr = this;
michael@0:     return NS_OK;
michael@0:   }
michael@0:   else
michael@0: #endif
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMETHODIMP
michael@0: WorkerPrivateParent<Derived>::
michael@0: EventTarget::Dispatch(nsIRunnable* aRunnable, uint32_t aFlags)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   // Workers only support asynchronous dispatch for now.
michael@0:   if (NS_WARN_IF(aFlags != NS_DISPATCH_NORMAL)) {
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<WorkerRunnable> workerRunnable;
michael@0: 
michael@0:   MutexAutoLock lock(mMutex);
michael@0: 
michael@0:   if (!mWorkerPrivate) {
michael@0:     NS_WARNING("A runnable was posted to a worker that is already shutting "
michael@0:                "down!");
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0:   }
michael@0: 
michael@0:   if (aRunnable) {
michael@0:     workerRunnable = mWorkerPrivate->MaybeWrapAsWorkerRunnable(aRunnable);
michael@0:   }
michael@0: 
michael@0:   nsresult rv =
michael@0:     mWorkerPrivate->DispatchPrivate(workerRunnable, mNestedEventTarget);
michael@0:   if (NS_WARN_IF(NS_FAILED(rv))) {
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: template <class Derived>
michael@0: NS_IMETHODIMP
michael@0: WorkerPrivateParent<Derived>::
michael@0: EventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread)
michael@0: {
michael@0:   // May be called on any thread!
michael@0: 
michael@0:   MOZ_ASSERT(aIsOnCurrentThread);
michael@0: 
michael@0:   MutexAutoLock lock(mMutex);
michael@0: 
michael@0:   if (!mWorkerPrivate) {
michael@0:     NS_WARNING("A worker's event target was used after the worker has !");
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = mWorkerPrivate->IsOnCurrentThread(aIsOnCurrentThread);
michael@0:   if (NS_WARN_IF(NS_FAILED(rv))) {
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: BEGIN_WORKERS_NAMESPACE
michael@0: 
michael@0: WorkerCrossThreadDispatcher*
michael@0: GetWorkerCrossThreadDispatcher(JSContext* aCx, JS::Value aWorker)
michael@0: {
michael@0:   if (!aWorker.isObject()) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   WorkerPrivate* w = nullptr;
michael@0:   UNWRAP_OBJECT(Worker, &aWorker.toObject(), w);
michael@0:   MOZ_ASSERT(w);
michael@0:   return w->GetCrossThreadDispatcher();
michael@0: }
michael@0: 
michael@0: JSStructuredCloneCallbacks*
michael@0: WorkerStructuredCloneCallbacks(bool aMainRuntime)
michael@0: {
michael@0:   return aMainRuntime ?
michael@0:          &gMainThreadWorkerStructuredCloneCallbacks :
michael@0:          &gWorkerStructuredCloneCallbacks;
michael@0: }
michael@0: 
michael@0: JSStructuredCloneCallbacks*
michael@0: ChromeWorkerStructuredCloneCallbacks(bool aMainRuntime)
michael@0: {
michael@0:   return aMainRuntime ?
michael@0:          &gMainThreadChromeWorkerStructuredCloneCallbacks :
michael@0:          &gChromeWorkerStructuredCloneCallbacks;
michael@0: }
michael@0: 
michael@0: // Force instantiation.
michael@0: template class WorkerPrivateParent<WorkerPrivate>;
michael@0: 
michael@0: END_WORKERS_NAMESPACE