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