From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/workers/Workers.h | 383 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 383 insertions(+) create mode 100644 dom/workers/Workers.h (limited to 'dom/workers/Workers.h') diff --git a/dom/workers/Workers.h b/dom/workers/Workers.h new file mode 100644 index 0000000000..89e2ccfca6 --- /dev/null +++ b/dom/workers/Workers.h @@ -0,0 +1,383 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_workers_workers_h__ +#define mozilla_dom_workers_workers_h__ + +#include "jsapi.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" +#include +#include "nsAutoPtr.h" +#include "nsCOMPtr.h" +#include "nsDebug.h" +#include "nsString.h" +#include "nsTArray.h" + +#include "nsILoadContext.h" +#include "nsIWeakReferenceUtils.h" +#include "nsIInterfaceRequestor.h" +#include "mozilla/dom/ChannelInfo.h" +#include "mozilla/net/ReferrerPolicy.h" + +#define BEGIN_WORKERS_NAMESPACE \ + namespace mozilla { namespace dom { namespace workers { +#define END_WORKERS_NAMESPACE \ + } /* namespace workers */ } /* namespace dom */ } /* namespace mozilla */ +#define USING_WORKERS_NAMESPACE \ + using namespace mozilla::dom::workers; + +#define WORKERS_SHUTDOWN_TOPIC "web-workers-shutdown" + +class nsIContentSecurityPolicy; +class nsIScriptContext; +class nsIGlobalObject; +class nsPIDOMWindowInner; +class nsIPrincipal; +class nsILoadGroup; +class nsITabChild; +class nsIChannel; +class nsIRunnable; +class nsIURI; + +namespace mozilla { +namespace ipc { +class PrincipalInfo; +} // namespace ipc + +namespace dom { +// If you change this, the corresponding list in nsIWorkerDebugger.idl needs to +// be updated too. +enum WorkerType +{ + WorkerTypeDedicated, + WorkerTypeShared, + WorkerTypeService +}; + +} // namespace dom +} // namespace mozilla + +BEGIN_WORKERS_NAMESPACE + +class WorkerPrivate; + +struct PrivatizableBase +{ }; + +#ifdef DEBUG +void +AssertIsOnMainThread(); +#else +inline void +AssertIsOnMainThread() +{ } +#endif + +struct JSSettings +{ + enum { + // All the GC parameters that we support. + JSSettings_JSGC_MAX_BYTES = 0, + JSSettings_JSGC_MAX_MALLOC_BYTES, + JSSettings_JSGC_HIGH_FREQUENCY_TIME_LIMIT, + JSSettings_JSGC_LOW_FREQUENCY_HEAP_GROWTH, + JSSettings_JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN, + JSSettings_JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX, + JSSettings_JSGC_HIGH_FREQUENCY_LOW_LIMIT, + JSSettings_JSGC_HIGH_FREQUENCY_HIGH_LIMIT, + JSSettings_JSGC_ALLOCATION_THRESHOLD, + JSSettings_JSGC_SLICE_TIME_BUDGET, + JSSettings_JSGC_DYNAMIC_HEAP_GROWTH, + JSSettings_JSGC_DYNAMIC_MARK_SLICE, + JSSettings_JSGC_REFRESH_FRAME_SLICES, + // JSGC_MODE not supported + + // This must be last so that we get an accurate count. + kGCSettingsArraySize + }; + + struct JSGCSetting + { + JSGCParamKey key; + uint32_t value; + + JSGCSetting() + : key(static_cast(-1)), value(0) + { } + + bool + IsSet() const + { + return key != static_cast(-1); + } + + void + Unset() + { + key = static_cast(-1); + value = 0; + } + }; + + // There are several settings that we know we need so it makes sense to + // preallocate here. + typedef JSGCSetting JSGCSettingsArray[kGCSettingsArraySize]; + + // Settings that change based on chrome/content context. + struct JSContentChromeSettings + { + JS::CompartmentOptions compartmentOptions; + int32_t maxScriptRuntime; + + JSContentChromeSettings() + : compartmentOptions(), maxScriptRuntime(0) + { } + }; + + JSContentChromeSettings chrome; + JSContentChromeSettings content; + JSGCSettingsArray gcSettings; + JS::ContextOptions contextOptions; + +#ifdef JS_GC_ZEAL + uint8_t gcZeal; + uint32_t gcZealFrequency; +#endif + + JSSettings() +#ifdef JS_GC_ZEAL + : gcZeal(0), gcZealFrequency(0) +#endif + { + for (uint32_t index = 0; index < ArrayLength(gcSettings); index++) { + new (gcSettings + index) JSGCSetting(); + } + } + + bool + ApplyGCSetting(JSGCParamKey aKey, uint32_t aValue) + { + JSSettings::JSGCSetting* firstEmptySetting = nullptr; + JSSettings::JSGCSetting* foundSetting = nullptr; + + for (uint32_t index = 0; index < ArrayLength(gcSettings); index++) { + JSSettings::JSGCSetting& setting = gcSettings[index]; + if (setting.key == aKey) { + foundSetting = &setting; + break; + } + if (!firstEmptySetting && !setting.IsSet()) { + firstEmptySetting = &setting; + } + } + + if (aValue) { + if (!foundSetting) { + foundSetting = firstEmptySetting; + if (!foundSetting) { + NS_ERROR("Not enough space for this value!"); + return false; + } + } + foundSetting->key = aKey; + foundSetting->value = aValue; + return true; + } + + if (foundSetting) { + foundSetting->Unset(); + return true; + } + + return false; + } +}; + +enum WorkerPreference +{ +#define WORKER_SIMPLE_PREF(name, getter, NAME) WORKERPREF_ ## NAME, +#define WORKER_PREF(name, callback) +#include "mozilla/dom/WorkerPrefs.h" +#undef WORKER_SIMPLE_PREF +#undef WORKER_PREF + WORKERPREF_COUNT +}; + +// Implemented in WorkerPrivate.cpp + +struct WorkerLoadInfo +{ + // All of these should be released in WorkerPrivateParent::ForgetMainThreadObjects. + nsCOMPtr mBaseURI; + nsCOMPtr mResolvedScriptURI; + nsCOMPtr mPrincipal; + nsCOMPtr mScriptContext; + nsCOMPtr mWindow; + nsCOMPtr mCSP; + nsCOMPtr mChannel; + nsCOMPtr mLoadGroup; + + // mLoadFailedAsyncRunnable will execute on main thread if script loading + // fails during script loading. If script loading is never started due to + // a synchronous error, then the runnable is never executed. The runnable + // is guaranteed to be released on the main thread. + nsCOMPtr mLoadFailedAsyncRunnable; + + class InterfaceRequestor final : public nsIInterfaceRequestor + { + NS_DECL_ISUPPORTS + + public: + InterfaceRequestor(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup); + void MaybeAddTabChild(nsILoadGroup* aLoadGroup); + NS_IMETHOD GetInterface(const nsIID& aIID, void** aSink) override; + + private: + ~InterfaceRequestor() { } + + already_AddRefed GetAnyLiveTabChild(); + + nsCOMPtr mLoadContext; + nsCOMPtr mOuterRequestor; + + // Array of weak references to nsITabChild. We do not want to keep TabChild + // actors alive for long after their ActorDestroy() methods are called. + nsTArray mTabChildList; + }; + + // Only set if we have a custom overriden load group + RefPtr mInterfaceRequestor; + + nsAutoPtr mPrincipalInfo; + nsCString mDomain; + + nsString mServiceWorkerCacheName; + + ChannelInfo mChannelInfo; + + uint64_t mWindowID; + uint64_t mServiceWorkerID; + + net::ReferrerPolicy mReferrerPolicy; + bool mFromWindow; + bool mEvalAllowed; + bool mReportCSPViolations; + bool mXHRParamsAllowed; + bool mPrincipalIsSystem; + bool mStorageAllowed; + bool mServiceWorkersTestingInWindow; + PrincipalOriginAttributes mOriginAttributes; + + WorkerLoadInfo(); + ~WorkerLoadInfo(); + + void StealFrom(WorkerLoadInfo& aOther); +}; + +// All of these are implemented in RuntimeService.cpp + +void +CancelWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +FreezeWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +ThawWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +SuspendWorkersForWindow(nsPIDOMWindowInner* aWindow); + +void +ResumeWorkersForWindow(nsPIDOMWindowInner* aWindow); + +// A class that can be used with WorkerCrossThreadDispatcher to run a +// bit of C++ code on the worker thread. +class WorkerTask +{ +protected: + WorkerTask() + { } + + virtual ~WorkerTask() + { } + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerTask) + + // The return value here has the same semantics as the return value + // of WorkerRunnable::WorkerRun. + virtual bool + RunTask(JSContext* aCx) = 0; +}; + +class WorkerCrossThreadDispatcher +{ + friend class WorkerPrivate; + + // Must be acquired *before* the WorkerPrivate's mutex, when they're both + // held. + Mutex mMutex; + WorkerPrivate* mWorkerPrivate; + +private: + // Only created by WorkerPrivate. + explicit WorkerCrossThreadDispatcher(WorkerPrivate* aWorkerPrivate); + + // Only called by WorkerPrivate. + void + Forget() + { + MutexAutoLock lock(mMutex); + mWorkerPrivate = nullptr; + } + + ~WorkerCrossThreadDispatcher() {} + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerCrossThreadDispatcher) + + // Generically useful function for running a bit of C++ code on the worker + // thread. + bool + PostTask(WorkerTask* aTask); +}; + +WorkerCrossThreadDispatcher* +GetWorkerCrossThreadDispatcher(JSContext* aCx, const JS::Value& aWorker); + +// Random unique constant to facilitate JSPrincipal debugging +const uint32_t kJSPrincipalsDebugToken = 0x7e2df9d2; + +namespace exceptions { + +// Implemented in Exceptions.cpp +void +ThrowDOMExceptionForNSResult(JSContext* aCx, nsresult aNSResult); + +} // namespace exceptions + +bool +IsWorkerGlobal(JSObject* global); + +bool +IsDebuggerGlobal(JSObject* global); + +bool +IsDebuggerSandbox(JSObject* object); + +// Throws the JSMSG_GETTER_ONLY exception. This shouldn't be used going +// forward -- getter-only properties should just use JS_PSG for the setter +// (implying no setter at all), which will not throw when set in non-strict +// code but will in strict code. Old code should use this only for temporary +// compatibility reasons. +extern bool +GetterOnlyJSNative(JSContext* aCx, unsigned aArgc, JS::Value* aVp); + +END_WORKERS_NAMESPACE + +#endif // mozilla_dom_workers_workers_h__ -- cgit v1.2.3