dom/workers/WorkerScope.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_workerscope_h__
   8 #define mozilla_dom_workerscope_h__
   9
  10 #include "js/TypeDecls.h"
  11 #include "js/loader/ModuleLoaderBase.h"
  12 #include "mozilla/Assertions.h"
  13 #include "mozilla/Attributes.h"
  14 #include "mozilla/DOMEventTargetHelper.h"
  15 #include "mozilla/Maybe.h"
  16 #include "mozilla/NotNull.h"
  17 #include "mozilla/RefPtr.h"
  18 #include "mozilla/UniquePtr.h"
  19 #include "mozilla/TimeStamp.h"
  20 #include "mozilla/dom/AnimationFrameProvider.h"
  21 #include "mozilla/dom/ImageBitmapBinding.h"
  22 #include "mozilla/dom/ImageBitmapSource.h"
  23 #include "mozilla/dom/PerformanceWorker.h"
  24 #include "mozilla/dom/SafeRefPtr.h"
  25 #include "mozilla/dom/TrustedTypePolicyFactory.h"
  26 #include "mozilla/dom/WorkerPrivate.h"
  27 #include "nsCOMPtr.h"
  28 #include "nsCycleCollectionParticipant.h"
  29 #include "nsIGlobalObject.h"
  30 #include "nsISupports.h"
  31 #include "nsWeakReference.h"
  32
  33 #ifdef XP_WIN
  34 #  undef PostMessage
  35 #endif
  36
  37 class nsAtom;
  38 class nsISerialEventTarget;
  39
  40 namespace mozilla {
  41 class ErrorResult;
  42 struct VsyncEvent;
  43
  44 namespace extensions {
  45
  46 class ExtensionBrowser;
  47
  48 }  // namespace extensions
  49
  50 namespace dom {
  51
  52 class AnyCallback;
  53 enum class CallerType : uint32_t;
  54 class ClientInfo;
  55 class ClientSource;
  56 class Clients;
  57 class Console;
  58 class Crypto;
  59 class DOMString;
  60 class DebuggerNotificationManager;
  61 enum class EventCallbackDebuggerNotificationType : uint8_t;
  62 class EventHandlerNonNull;
  63 class FontFaceSet;
  64 class Function;
  65 class IDBFactory;
  66 class OnErrorEventHandlerNonNull;
  67 template <typename T>
  68 class Optional;
  69 class Performance;
  70 class Promise;
  71 class RequestOrUSVString;
  72 template <typename T>
  73 class Sequence;
  74 class ServiceWorkerDescriptor;
  75 class ServiceWorkerRegistration;
  76 class ServiceWorkerRegistrationDescriptor;
  77 struct StructuredSerializeOptions;
  78 class WorkerDocumentListener;
  79 class WorkerLocation;
  80 class WorkerNavigator;
  81 class WorkerPrivate;
  82 class VsyncWorkerChild;
  83 class WebTaskScheduler;
  84 class WebTaskSchedulerWorker;
  85 struct RequestInit;
  86
  87 namespace cache {
  88
  89 class CacheStorage;
  90
  91 }  // namespace cache
  92
  93 class WorkerGlobalScopeBase : public DOMEventTargetHelper,
  94                               public nsSupportsWeakReference,
  95                               public nsIGlobalObject {
  96   friend class WorkerPrivate;
  97
  98  public:
  99   NS_DECL_ISUPPORTS_INHERITED
 100   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerGlobalScopeBase,
 101                                                          DOMEventTargetHelper)
 102
 103   WorkerGlobalScopeBase(WorkerPrivate* aWorkerPrivate,
 104                         UniquePtr<ClientSource> aClientSource);
 105
 106   virtual bool WrapGlobalObject(JSContext* aCx,
 107                                 JS::MutableHandle<JSObject*> aReflector) = 0;
 108
 109   // EventTarget implementation
 110   JSObject* WrapObject(JSContext* aCx,
 111                        JS::Handle<JSObject*> aGivenProto) final {
 112     MOZ_CRASH("WrapObject not supported; use WrapGlobalObject.");
 113   }
 114
 115   // nsIGlobalObject implementation
 116   JSObject* GetGlobalJSObject() final;
 117
 118   JSObject* GetGlobalJSObjectPreserveColor() const final;
 119
 120   bool IsSharedMemoryAllowed() const final;
 121
 122   bool ShouldResistFingerprinting(RFPTarget aTarget) const final;
 123
 124   OriginTrials Trials() const final;
 125
 126   StorageAccess GetStorageAccess() final;
 127
 128   Maybe<ClientInfo> GetClientInfo() const final;
 129
 130   Maybe<ServiceWorkerDescriptor> GetController() const final;
 131
 132   mozilla::Result<mozilla::ipc::PrincipalInfo, nsresult> GetStorageKey() final;
 133
 134   virtual void Control(const ServiceWorkerDescriptor& aServiceWorker);
 135
 136   // DispatcherTrait implementation
 137   nsresult Dispatch(already_AddRefed<nsIRunnable>&& aRunnable) const final;
 138   nsISerialEventTarget* SerialEventTarget() const final;
 139
 140   MOZ_CAN_RUN_SCRIPT
 141   void ReportError(JSContext* aCx, JS::Handle<JS::Value> aError,
 142                    CallerType aCallerType, ErrorResult& aRv);
 143
 144   // atob, btoa, and dump are declared (separately) by both WorkerGlobalScope
 145   // and WorkerDebuggerGlobalScope WebIDL interfaces
 146   void Atob(const nsAString& aAtob, nsAString& aOut, ErrorResult& aRv) const;
 147
 148   void Btoa(const nsAString& aBtoa, nsAString& aOut, ErrorResult& aRv) const;
 149
 150   already_AddRefed<Console> GetConsole(ErrorResult& aRv);
 151
 152   Console* GetConsoleIfExists() const { return mConsole; }
 153
 154   void InitModuleLoader(JS::loader::ModuleLoaderBase* aModuleLoader) {
 155     if (!mModuleLoader) {
 156       mModuleLoader = aModuleLoader;
 157     }
 158   }
 159
 160   // The nullptr here is not used, but is required to make the override method
 161   // have the same signature as other GetModuleLoader methods on globals.
 162   JS::loader::ModuleLoaderBase* GetModuleLoader(
 163       JSContext* aCx = nullptr) override {
 164     return mModuleLoader;
 165   };
 166
 167   uint64_t WindowID() const;
 168
 169   // Usually global scope dies earlier than the WorkerPrivate, but if we see
 170   // it leak at least we can tell it to not carry away a dead pointer.
 171   void NoteWorkerTerminated() { mWorkerPrivate = nullptr; }
 172
 173   ClientSource& MutableClientSourceRef() const { return *mClientSource; }
 174
 175   // WorkerPrivate wants to be able to forbid script when its state machine
 176   // demands it.
 177   void WorkerPrivateSaysForbidScript() { StartForbiddingScript(); }
 178   void WorkerPrivateSaysAllowScript() { StopForbiddingScript(); }
 179
 180  protected:
 181   ~WorkerGlobalScopeBase();
 182
 183   CheckedUnsafePtr<WorkerPrivate> mWorkerPrivate;
 184
 185   void AssertIsOnWorkerThread() const {
 186     MOZ_ASSERT(mWorkerThreadUsedOnlyForAssert == PR_GetCurrentThread());
 187   }
 188
 189  private:
 190   RefPtr<Console> mConsole;
 191   RefPtr<JS::loader::ModuleLoaderBase> mModuleLoader;
 192   const UniquePtr<ClientSource> mClientSource;
 193   nsCOMPtr<nsISerialEventTarget> mSerialEventTarget;
 194 #ifdef DEBUG
 195   PRThread* mWorkerThreadUsedOnlyForAssert;
 196 #endif
 197 };
 198
 199 namespace workerinternals {
 200
 201 class NamedWorkerGlobalScopeMixin {
 202  public:
 203   explicit NamedWorkerGlobalScopeMixin(const nsAString& aName) : mName(aName) {}
 204
 205   void GetName(DOMString& aName) const;
 206
 207  protected:
 208   ~NamedWorkerGlobalScopeMixin() = default;
 209
 210  private:
 211   const nsString mName;
 212 };
 213
 214 }  // namespace workerinternals
 215
 216 class WorkerGlobalScope : public WorkerGlobalScopeBase {
 217  public:
 218   NS_DECL_ISUPPORTS_INHERITED
 219   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WorkerGlobalScope,
 220                                            WorkerGlobalScopeBase)
 221
 222   using WorkerGlobalScopeBase::WorkerGlobalScopeBase;
 223
 224   void NoteTerminating();
 225
 226   void NoteShuttingDown();
 227
 228   // nsIGlobalObject implementation
 229   RefPtr<ServiceWorkerRegistration> GetServiceWorkerRegistration(
 230       const ServiceWorkerRegistrationDescriptor& aDescriptor) const final;
 231
 232   RefPtr<ServiceWorkerRegistration> GetOrCreateServiceWorkerRegistration(
 233       const ServiceWorkerRegistrationDescriptor& aDescriptor) final;
 234
 235   DebuggerNotificationManager* GetOrCreateDebuggerNotificationManager() final;
 236
 237   DebuggerNotificationManager* GetExistingDebuggerNotificationManager() final;
 238
 239   Maybe<EventCallbackDebuggerNotificationType> GetDebuggerNotificationType()
 240       const final;
 241
 242   mozilla::dom::StorageManager* GetStorageManager() final;
 243
 244   void SetIsNotEligibleForMessaging() { mIsEligibleForMessaging = false; }
 245
 246   bool IsEligibleForMessaging() final;
 247
 248   // WorkerGlobalScope WebIDL implementation
 249   WorkerGlobalScope* Self() { return this; }
 250
 251   already_AddRefed<WorkerLocation> Location();
 252
 253   already_AddRefed<WorkerNavigator> Navigator();
 254
 255   already_AddRefed<WorkerNavigator> GetExistingNavigator() const;
 256
 257   FontFaceSet* GetFonts(ErrorResult&);
 258   FontFaceSet* GetFonts() final { return GetFonts(IgnoreErrors()); }
 259
 260   void ImportScripts(JSContext* aCx, const Sequence<nsString>& aScriptURLs,
 261                      ErrorResult& aRv);
 262
 263   OnErrorEventHandlerNonNull* GetOnerror();
 264
 265   void SetOnerror(OnErrorEventHandlerNonNull* aHandler);
 266
 267   IMPL_EVENT_HANDLER(languagechange)
 268   IMPL_EVENT_HANDLER(offline)
 269   IMPL_EVENT_HANDLER(online)
 270   IMPL_EVENT_HANDLER(rejectionhandled)
 271   IMPL_EVENT_HANDLER(unhandledrejection)
 272
 273   void Dump(const Optional<nsAString>& aString) const;
 274
 275   Performance* GetPerformance();
 276
 277   Performance* GetPerformanceIfExists() const { return mPerformance; }
 278
 279   static bool IsInAutomation(JSContext* aCx, JSObject*);
 280
 281   void GetJSTestingFunctions(JSContext* aCx,
 282                              JS::MutableHandle<JSObject*> aFunctions,
 283                              ErrorResult& aRv);
 284
 285   // GlobalCrypto WebIDL implementation
 286   Crypto* GetCrypto(ErrorResult& aError);
 287
 288   // WindowOrWorkerGlobalScope WebIDL implementation
 289   void GetOrigin(nsAString& aOrigin) const;
 290
 291   bool CrossOriginIsolated() const final;
 292
 293   MOZ_CAN_RUN_SCRIPT
 294   int32_t SetTimeout(JSContext* aCx, Function& aHandler, int32_t aTimeout,
 295                      const Sequence<JS::Value>& aArguments, ErrorResult& aRv);
 296
 297   MOZ_CAN_RUN_SCRIPT
 298   int32_t SetTimeout(JSContext* aCx, const nsAString& aHandler,
 299                      int32_t aTimeout, const Sequence<JS::Value>&,
 300                      ErrorResult& aRv);
 301
 302   MOZ_CAN_RUN_SCRIPT
 303   void ClearTimeout(int32_t aHandle);
 304
 305   MOZ_CAN_RUN_SCRIPT
 306   int32_t SetInterval(JSContext* aCx, Function& aHandler, int32_t aTimeout,
 307                       const Sequence<JS::Value>& aArguments, ErrorResult& aRv);
 308   MOZ_CAN_RUN_SCRIPT
 309   int32_t SetInterval(JSContext* aCx, const nsAString& aHandler,
 310                       int32_t aTimeout, const Sequence<JS::Value>&,
 311                       ErrorResult& aRv);
 312
 313   MOZ_CAN_RUN_SCRIPT
 314   void ClearInterval(int32_t aHandle);
 315
 316   already_AddRefed<Promise> CreateImageBitmap(
 317       const ImageBitmapSource& aImage, const ImageBitmapOptions& aOptions,
 318       ErrorResult& aRv);
 319
 320   already_AddRefed<Promise> CreateImageBitmap(
 321       const ImageBitmapSource& aImage, int32_t aSx, int32_t aSy, int32_t aSw,
 322       int32_t aSh, const ImageBitmapOptions& aOptions, ErrorResult& aRv);
 323
 324   void StructuredClone(JSContext* aCx, JS::Handle<JS::Value> aValue,
 325                        const StructuredSerializeOptions& aOptions,
 326                        JS::MutableHandle<JS::Value> aRetval,
 327                        ErrorResult& aError);
 328
 329   already_AddRefed<Promise> Fetch(const RequestOrUSVString& aInput,
 330                                   const RequestInit& aInit,
 331                                   CallerType aCallerType, ErrorResult& aRv);
 332
 333   bool IsSecureContext() const;
 334
 335   already_AddRefed<IDBFactory> GetIndexedDB(JSContext* aCx,
 336                                             ErrorResult& aErrorResult);
 337
 338   already_AddRefed<cache::CacheStorage> GetCaches(ErrorResult& aRv);
 339
 340   WebTaskScheduler* Scheduler();
 341   WebTaskScheduler* GetExistingScheduler() const;
 342
 343   bool WindowInteractionAllowed() const;
 344
 345   void AllowWindowInteraction();
 346
 347   void ConsumeWindowInteraction();
 348
 349   void StorageAccessPermissionGranted();
 350
 351   virtual void OnDocumentVisible(bool aVisible) {}
 352
 353   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 354   virtual void OnVsync(const VsyncEvent& aVsync) {}
 355
 356   TrustedTypePolicyFactory* TrustedTypes();
 357
 358  protected:
 359   ~WorkerGlobalScope();
 360
 361  private:
 362   MOZ_CAN_RUN_SCRIPT
 363   int32_t SetTimeoutOrInterval(JSContext* aCx, Function& aHandler,
 364                                int32_t aTimeout,
 365                                const Sequence<JS::Value>& aArguments,
 366                                bool aIsInterval, ErrorResult& aRv);
 367
 368   MOZ_CAN_RUN_SCRIPT
 369   int32_t SetTimeoutOrInterval(JSContext* aCx, const nsAString& aHandler,
 370                                int32_t aTimeout, bool aIsInterval,
 371                                ErrorResult& aRv);
 372
 373   RefPtr<Crypto> mCrypto;
 374   RefPtr<WorkerLocation> mLocation;
 375   RefPtr<WorkerNavigator> mNavigator;
 376   RefPtr<FontFaceSet> mFontFaceSet;
 377   RefPtr<Performance> mPerformance;
 378   RefPtr<IDBFactory> mIndexedDB;
 379   RefPtr<cache::CacheStorage> mCacheStorage;
 380   RefPtr<DebuggerNotificationManager> mDebuggerNotificationManager;
 381   RefPtr<WebTaskSchedulerWorker> mWebTaskScheduler;
 382   RefPtr<TrustedTypePolicyFactory> mTrustedTypePolicyFactory;
 383   uint32_t mWindowInteractionsAllowed = 0;
 384   bool mIsEligibleForMessaging{true};
 385 };
 386
 387 class DedicatedWorkerGlobalScope final
 388     : public WorkerGlobalScope,
 389       public workerinternals::NamedWorkerGlobalScopeMixin {
 390  public:
 391   NS_DECL_ISUPPORTS_INHERITED
 392   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(
 393       DedicatedWorkerGlobalScope, WorkerGlobalScope)
 394
 395   DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate,
 396                              UniquePtr<ClientSource> aClientSource,
 397                              const nsString& aName);
 398
 399   bool WrapGlobalObject(JSContext* aCx,
 400                         JS::MutableHandle<JSObject*> aReflector) override;
 401
 402   void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 403                    const Sequence<JSObject*>& aTransferable, ErrorResult& aRv);
 404
 405   void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 406                    const StructuredSerializeOptions& aOptions,
 407                    ErrorResult& aRv);
 408
 409   void Close();
 410
 411   MOZ_CAN_RUN_SCRIPT
 412   int32_t RequestAnimationFrame(FrameRequestCallback& aCallback,
 413                                 ErrorResult& aError);
 414
 415   MOZ_CAN_RUN_SCRIPT
 416   void CancelAnimationFrame(int32_t aHandle, ErrorResult& aError);
 417
 418   void OnDocumentVisible(bool aVisible) override;
 419
 420   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 421   void OnVsync(const VsyncEvent& aVsync) override;
 422
 423   IMPL_EVENT_HANDLER(message)
 424   IMPL_EVENT_HANDLER(messageerror)
 425   IMPL_EVENT_HANDLER(rtctransform)
 426
 427  private:
 428   ~DedicatedWorkerGlobalScope() = default;
 429
 430   FrameRequestManager mFrameRequestManager;
 431   RefPtr<VsyncWorkerChild> mVsyncChild;
 432   RefPtr<WorkerDocumentListener> mDocListener;
 433   bool mDocumentVisible = false;
 434 };
 435
 436 class SharedWorkerGlobalScope final
 437     : public WorkerGlobalScope,
 438       public workerinternals::NamedWorkerGlobalScopeMixin {
 439  public:
 440   SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate,
 441                           UniquePtr<ClientSource> aClientSource,
 442                           const nsString& aName);
 443
 444   bool WrapGlobalObject(JSContext* aCx,
 445                         JS::MutableHandle<JSObject*> aReflector) override;
 446
 447   void Close();
 448
 449   IMPL_EVENT_HANDLER(connect)
 450
 451  private:
 452   ~SharedWorkerGlobalScope() = default;
 453 };
 454
 455 class ServiceWorkerGlobalScope final : public WorkerGlobalScope {
 456  public:
 457   NS_DECL_ISUPPORTS_INHERITED
 458   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerGlobalScope,
 459                                            WorkerGlobalScope)
 460
 461   ServiceWorkerGlobalScope(
 462       WorkerPrivate* aWorkerPrivate, UniquePtr<ClientSource> aClientSource,
 463       const ServiceWorkerRegistrationDescriptor& aRegistrationDescriptor);
 464
 465   bool WrapGlobalObject(JSContext* aCx,
 466                         JS::MutableHandle<JSObject*> aReflector) override;
 467
 468   already_AddRefed<Clients> GetClients();
 469
 470   ServiceWorkerRegistration* Registration();
 471
 472   already_AddRefed<Promise> SkipWaiting(ErrorResult& aRv);
 473
 474   SafeRefPtr<extensions::ExtensionBrowser> AcquireExtensionBrowser();
 475
 476   IMPL_EVENT_HANDLER(install)
 477   IMPL_EVENT_HANDLER(activate)
 478
 479   EventHandlerNonNull* GetOnfetch();
 480
 481   void SetOnfetch(EventHandlerNonNull* aCallback);
 482
 483   void EventListenerAdded(nsAtom* aType) override;
 484
 485   IMPL_EVENT_HANDLER(message)
 486   IMPL_EVENT_HANDLER(messageerror)
 487
 488   IMPL_EVENT_HANDLER(notificationclick)
 489   IMPL_EVENT_HANDLER(notificationclose)
 490
 491   IMPL_EVENT_HANDLER(push)
 492   IMPL_EVENT_HANDLER(pushsubscriptionchange)
 493
 494  private:
 495   ~ServiceWorkerGlobalScope();
 496
 497   void NoteFetchHandlerWasAdded() const;
 498
 499   RefPtr<Clients> mClients;
 500   const nsString mScope;
 501   RefPtr<ServiceWorkerRegistration> mRegistration;
 502   SafeRefPtr<extensions::ExtensionBrowser> mExtensionBrowser;
 503 };
 504
 505 class WorkerDebuggerGlobalScope final : public WorkerGlobalScopeBase {
 506  public:
 507   using WorkerGlobalScopeBase::WorkerGlobalScopeBase;
 508
 509   bool WrapGlobalObject(JSContext* aCx,
 510                         JS::MutableHandle<JSObject*> aReflector) override;
 511
 512   void Control(const ServiceWorkerDescriptor& aServiceWorker) override {
 513     MOZ_CRASH("Can't control debugger workers.");
 514   }
 515
 516   void GetGlobal(JSContext* aCx, JS::MutableHandle<JSObject*> aGlobal,
 517                  ErrorResult& aRv);
 518
 519   void CreateSandbox(JSContext* aCx, const nsAString& aName,
 520                      JS::Handle<JSObject*> aPrototype,
 521                      JS::MutableHandle<JSObject*> aResult, ErrorResult& aRv);
 522
 523   void LoadSubScript(JSContext* aCx, const nsAString& aUrl,
 524                      const Optional<JS::Handle<JSObject*>>& aSandbox,
 525                      ErrorResult& aRv);
 526
 527   MOZ_CAN_RUN_SCRIPT void EnterEventLoop();
 528
 529   void LeaveEventLoop();
 530
 531   void PostMessage(const nsAString& aMessage);
 532
 533   void SetImmediate(Function& aHandler, ErrorResult& aRv);
 534
 535   void ReportError(JSContext* aCx, const nsAString& aMessage);
 536
 537   void RetrieveConsoleEvents(JSContext* aCx, nsTArray<JS::Value>& aEvents,
 538                              ErrorResult& aRv);
 539
 540   void ClearConsoleEvents(JSContext* aCx, ErrorResult& aRv);
 541
 542   void SetConsoleEventHandler(JSContext* aCx, AnyCallback* aHandler,
 543                               ErrorResult& aRv);
 544
 545   void Dump(JSContext* aCx, const Optional<nsAString>& aString) const;
 546
 547   IMPL_EVENT_HANDLER(message)
 548   IMPL_EVENT_HANDLER(messageerror)
 549
 550  private:
 551   ~WorkerDebuggerGlobalScope() = default;
 552 };
 553
 554 }  // namespace dom
 555 }  // namespace mozilla
 556
 557 inline nsISupports* ToSupports(mozilla::dom::WorkerGlobalScope* aScope) {
 558   return static_cast<mozilla::dom::EventTarget*>(aScope);
 559 }
 560
 561 #endif /* mozilla_dom_workerscope_h__ */