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 "mozilla/Attributes.h"
  11 #include "mozilla/dom/WorkerCommon.h"
  12 #include "mozilla/DOMEventTargetHelper.h"
  13 #include "mozilla/dom/DebuggerNotificationManager.h"
  14 #include "mozilla/dom/Headers.h"
  15 #include "mozilla/dom/RequestBinding.h"
  16 #include "nsWeakReference.h"
  17 #include "mozilla/dom/ImageBitmapSource.h"
  18
  19 #ifdef XP_WIN
  20 #  undef PostMessage
  21 #endif
  22
  23 namespace mozilla {
  24 namespace dom {
  25
  26 class AnyCallback;
  27 struct ChannelPixelLayout;
  28 class ClientInfo;
  29 class Clients;
  30 class ClientState;
  31 class Console;
  32 class Crypto;
  33 class Function;
  34 class IDBFactory;
  35 enum class ImageBitmapFormat : uint8_t;
  36 class Performance;
  37 struct PostMessageOptions;
  38 class Promise;
  39 class RequestOrUSVString;
  40 class WorkerLocation;
  41 class WorkerNavigator;
  42 class WorkerPrivate;
  43 enum class CallerType : uint32_t;
  44
  45 namespace cache {
  46
  47 class CacheStorage;
  48
  49 }  // namespace cache
  50
  51 class WorkerGlobalScope : public DOMEventTargetHelper,
  52                           public nsIGlobalObject,
  53                           public nsSupportsWeakReference {
  54   typedef mozilla::dom::IDBFactory IDBFactory;
  55
  56   RefPtr<Console> mConsole;
  57   RefPtr<Crypto> mCrypto;
  58   RefPtr<WorkerLocation> mLocation;
  59   RefPtr<WorkerNavigator> mNavigator;
  60   RefPtr<Performance> mPerformance;
  61   RefPtr<IDBFactory> mIndexedDB;
  62   RefPtr<cache::CacheStorage> mCacheStorage;
  63   nsCOMPtr<nsISerialEventTarget> mSerialEventTarget;
  64   RefPtr<mozilla::dom::DebuggerNotificationManager>
  65       mDebuggerNotificationManager;
  66
  67   uint32_t mWindowInteractionsAllowed;
  68
  69  protected:
  70   WorkerPrivate* mWorkerPrivate;
  71
  72   explicit WorkerGlobalScope(WorkerPrivate* aWorkerPrivate);
  73   virtual ~WorkerGlobalScope();
  74
  75   MOZ_CAN_RUN_SCRIPT
  76   int32_t SetTimeoutOrInterval(JSContext* aCx, Function& aHandler,
  77                                const int32_t aTimeout,
  78                                const Sequence<JS::Value>& aArguments,
  79                                bool aIsInterval, ErrorResult& aRv);
  80   MOZ_CAN_RUN_SCRIPT
  81   int32_t SetTimeoutOrInterval(JSContext* aCx, const nsAString& aHandler,
  82                                const int32_t aTimeout, bool aIsInterval,
  83                                ErrorResult& aRv);
  84
  85  public:
  86   virtual JSObject* WrapObject(JSContext* aCx,
  87                                JS::Handle<JSObject*> aGivenProto) override;
  88
  89   virtual bool WrapGlobalObject(JSContext* aCx,
  90                                 JS::MutableHandle<JSObject*> aReflector) = 0;
  91
  92   JSObject* GetGlobalJSObject() override { return GetWrapper(); }
  93   JSObject* GetGlobalJSObjectPreserveColor() const override {
  94     return GetWrapperPreserveColor();
  95   }
  96
  97   NS_DECL_ISUPPORTS_INHERITED
  98   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerGlobalScope,
  99                                                          DOMEventTargetHelper)
 100
 101   WorkerGlobalScope* Self() { return this; }
 102
 103   void NoteTerminating();
 104
 105   already_AddRefed<Console> GetConsole(ErrorResult& aRv);
 106
 107   Console* GetConsoleIfExists() const { return mConsole; }
 108
 109   Crypto* GetCrypto(ErrorResult& aError);
 110
 111   already_AddRefed<WorkerLocation> Location();
 112
 113   already_AddRefed<WorkerNavigator> Navigator();
 114
 115   already_AddRefed<WorkerNavigator> GetExistingNavigator() const;
 116
 117   OnErrorEventHandlerNonNull* GetOnerror();
 118   void SetOnerror(OnErrorEventHandlerNonNull* aHandler);
 119
 120   void ImportScripts(JSContext* aCx, const Sequence<nsString>& aScriptURLs,
 121                      ErrorResult& aRv);
 122
 123   MOZ_CAN_RUN_SCRIPT
 124   int32_t SetTimeout(JSContext* aCx, Function& aHandler, const int32_t aTimeout,
 125                      const Sequence<JS::Value>& aArguments, ErrorResult& aRv);
 126   MOZ_CAN_RUN_SCRIPT
 127   int32_t SetTimeout(JSContext* aCx, const nsAString& aHandler,
 128                      const int32_t aTimeout,
 129                      const Sequence<JS::Value>& /* unused */, ErrorResult& aRv);
 130   MOZ_CAN_RUN_SCRIPT
 131   void ClearTimeout(int32_t aHandle);
 132   MOZ_CAN_RUN_SCRIPT
 133   int32_t SetInterval(JSContext* aCx, Function& aHandler,
 134                       const int32_t aTimeout,
 135                       const Sequence<JS::Value>& aArguments, ErrorResult& aRv);
 136   MOZ_CAN_RUN_SCRIPT
 137   int32_t SetInterval(JSContext* aCx, const nsAString& aHandler,
 138                       const int32_t aTimeout,
 139                       const Sequence<JS::Value>& /* unused */,
 140                       ErrorResult& aRv);
 141   MOZ_CAN_RUN_SCRIPT
 142   void ClearInterval(int32_t aHandle);
 143
 144   void GetOrigin(nsAString& aOrigin) const;
 145   bool CrossOriginIsolated() const;
 146
 147   void Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const;
 148   void Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const;
 149
 150   IMPL_EVENT_HANDLER(online)
 151   IMPL_EVENT_HANDLER(offline)
 152   IMPL_EVENT_HANDLER(languagechange)
 153   IMPL_EVENT_HANDLER(rejectionhandled)
 154   IMPL_EVENT_HANDLER(unhandledrejection)
 155
 156   void Dump(const Optional<nsAString>& aString) const;
 157
 158   Performance* GetPerformance();
 159
 160   Performance* GetPerformanceIfExists() const { return mPerformance; }
 161
 162   static bool IsInAutomation(JSContext* aCx, JSObject* /* unused */);
 163   void GetJSTestingFunctions(JSContext* aCx,
 164                              JS::MutableHandle<JSObject*> aFunctions,
 165                              ErrorResult& aRv);
 166
 167   already_AddRefed<Promise> Fetch(const RequestOrUSVString& aInput,
 168                                   const RequestInit& aInit,
 169                                   CallerType aCallerType, ErrorResult& aRv);
 170
 171   already_AddRefed<IDBFactory> GetIndexedDB(ErrorResult& aErrorResult);
 172
 173   already_AddRefed<cache::CacheStorage> GetCaches(ErrorResult& aRv);
 174
 175   bool IsSecureContext() const;
 176
 177   already_AddRefed<Promise> CreateImageBitmap(JSContext* aCx,
 178                                               const ImageBitmapSource& aImage,
 179                                               ErrorResult& aRv);
 180
 181   already_AddRefed<Promise> CreateImageBitmap(JSContext* aCx,
 182                                               const ImageBitmapSource& aImage,
 183                                               int32_t aSx, int32_t aSy,
 184                                               int32_t aSw, int32_t aSh,
 185                                               ErrorResult& aRv);
 186
 187   bool WindowInteractionAllowed() const {
 188     return mWindowInteractionsAllowed > 0;
 189   }
 190
 191   void AllowWindowInteraction() { mWindowInteractionsAllowed++; }
 192
 193   void ConsumeWindowInteraction() {
 194     MOZ_ASSERT(mWindowInteractionsAllowed > 0);
 195     mWindowInteractionsAllowed--;
 196   }
 197
 198   // Override DispatchTrait API to target the worker thread.  Dispatch may
 199   // return failure if the worker thread is not alive.
 200   nsresult Dispatch(TaskCategory aCategory,
 201                     already_AddRefed<nsIRunnable>&& aRunnable) override;
 202
 203   nsISerialEventTarget* EventTargetFor(TaskCategory aCategory) const override;
 204
 205   AbstractThread* AbstractMainThreadFor(TaskCategory aCategory) override;
 206
 207   mozilla::dom::DebuggerNotificationManager*
 208   GetOrCreateDebuggerNotificationManager() override;
 209
 210   mozilla::dom::DebuggerNotificationManager*
 211   GetExistingDebuggerNotificationManager() override;
 212
 213   mozilla::Maybe<mozilla::dom::EventCallbackDebuggerNotificationType>
 214   GetDebuggerNotificationType() const override {
 215     return mozilla::Some(
 216         mozilla::dom::EventCallbackDebuggerNotificationType::Global);
 217   }
 218
 219   Maybe<ClientInfo> GetClientInfo() const override;
 220
 221   Maybe<ClientState> GetClientState() const;
 222
 223   Maybe<ServiceWorkerDescriptor> GetController() const override;
 224
 225   RefPtr<mozilla::dom::ServiceWorkerRegistration> GetServiceWorkerRegistration(
 226       const ServiceWorkerRegistrationDescriptor& aDescriptor) const override;
 227
 228   RefPtr<mozilla::dom::ServiceWorkerRegistration>
 229   GetOrCreateServiceWorkerRegistration(
 230       const ServiceWorkerRegistrationDescriptor& aDescriptor) override;
 231
 232   uint64_t WindowID() const;
 233
 234   void FirstPartyStorageAccessGranted();
 235 };
 236
 237 class DedicatedWorkerGlobalScope final : public WorkerGlobalScope {
 238   const nsString mName;
 239
 240   ~DedicatedWorkerGlobalScope() {}
 241
 242  public:
 243   DedicatedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate,
 244                              const nsString& aName);
 245
 246   virtual bool WrapGlobalObject(
 247       JSContext* aCx, JS::MutableHandle<JSObject*> aReflector) override;
 248
 249   void GetName(DOMString& aName) const { aName.AsAString() = mName; }
 250
 251   void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 252                    const Sequence<JSObject*>& aTransferable, ErrorResult& aRv);
 253   void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 254                    const PostMessageOptions& aOptions, ErrorResult& aRv);
 255
 256   void Close();
 257
 258   IMPL_EVENT_HANDLER(message)
 259   IMPL_EVENT_HANDLER(messageerror)
 260 };
 261
 262 class SharedWorkerGlobalScope final : public WorkerGlobalScope {
 263   const nsString mName;
 264
 265   ~SharedWorkerGlobalScope() {}
 266
 267  public:
 268   SharedWorkerGlobalScope(WorkerPrivate* aWorkerPrivate, const nsString& aName);
 269
 270   virtual bool WrapGlobalObject(
 271       JSContext* aCx, JS::MutableHandle<JSObject*> aReflector) override;
 272
 273   void GetName(DOMString& aName) const { aName.AsAString() = mName; }
 274
 275   void Close();
 276
 277   IMPL_EVENT_HANDLER(connect)
 278 };
 279
 280 class ServiceWorkerGlobalScope final : public WorkerGlobalScope {
 281   const nsString mScope;
 282   RefPtr<Clients> mClients;
 283   RefPtr<ServiceWorkerRegistration> mRegistration;
 284
 285   ~ServiceWorkerGlobalScope();
 286
 287  public:
 288   NS_DECL_ISUPPORTS_INHERITED
 289   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ServiceWorkerGlobalScope,
 290                                            WorkerGlobalScope)
 291   IMPL_EVENT_HANDLER(notificationclick)
 292   IMPL_EVENT_HANDLER(notificationclose)
 293
 294   ServiceWorkerGlobalScope(
 295       WorkerPrivate* aWorkerPrivate,
 296       const ServiceWorkerRegistrationDescriptor& aRegistrationDescriptor);
 297
 298   virtual bool WrapGlobalObject(
 299       JSContext* aCx, JS::MutableHandle<JSObject*> aReflector) override;
 300
 301   void GetScope(nsString& aScope) const { aScope = mScope; }
 302
 303   already_AddRefed<Clients> GetClients();
 304
 305   ServiceWorkerRegistration* Registration();
 306
 307   already_AddRefed<Promise> SkipWaiting(ErrorResult& aRv);
 308
 309   IMPL_EVENT_HANDLER(activate)
 310   IMPL_EVENT_HANDLER(install)
 311   IMPL_EVENT_HANDLER(message)
 312   IMPL_EVENT_HANDLER(messageerror)
 313
 314   IMPL_EVENT_HANDLER(push)
 315   IMPL_EVENT_HANDLER(pushsubscriptionchange)
 316
 317   EventHandlerNonNull* GetOnfetch();
 318
 319   void SetOnfetch(mozilla::dom::EventHandlerNonNull* aCallback);
 320
 321   void EventListenerAdded(nsAtom* aType) override;
 322 };
 323
 324 class WorkerDebuggerGlobalScope final : public DOMEventTargetHelper,
 325                                         public nsIGlobalObject {
 326   WorkerPrivate* mWorkerPrivate;
 327   RefPtr<Console> mConsole;
 328   nsCOMPtr<nsISerialEventTarget> mSerialEventTarget;
 329
 330  public:
 331   explicit WorkerDebuggerGlobalScope(WorkerPrivate* aWorkerPrivate);
 332
 333   NS_DECL_ISUPPORTS_INHERITED
 334   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(
 335       WorkerDebuggerGlobalScope, DOMEventTargetHelper)
 336
 337   virtual JSObject* WrapObject(JSContext* aCx,
 338                                JS::Handle<JSObject*> aGivenProto) override {
 339     MOZ_CRASH("Shouldn't get here!");
 340   }
 341
 342   virtual bool WrapGlobalObject(JSContext* aCx,
 343                                 JS::MutableHandle<JSObject*> aReflector);
 344
 345   JSObject* GetGlobalJSObject(void) override { return GetWrapper(); }
 346   JSObject* GetGlobalJSObjectPreserveColor(void) const override {
 347     return GetWrapperPreserveColor();
 348   }
 349
 350   void GetGlobal(JSContext* aCx, JS::MutableHandle<JSObject*> aGlobal,
 351                  ErrorResult& aRv);
 352
 353   void CreateSandbox(JSContext* aCx, const nsAString& aName,
 354                      JS::Handle<JSObject*> aPrototype,
 355                      JS::MutableHandle<JSObject*> aResult, ErrorResult& aRv);
 356
 357   void LoadSubScript(JSContext* aCx, const nsAString& aURL,
 358                      const Optional<JS::Handle<JSObject*>>& aSandbox,
 359                      ErrorResult& aRv);
 360
 361   MOZ_CAN_RUN_SCRIPT void EnterEventLoop();
 362
 363   void LeaveEventLoop();
 364
 365   void PostMessage(const nsAString& aMessage);
 366
 367   IMPL_EVENT_HANDLER(message)
 368   IMPL_EVENT_HANDLER(messageerror)
 369
 370   void SetImmediate(Function& aHandler, ErrorResult& aRv);
 371
 372   void ReportError(JSContext* aCx, const nsAString& aMessage);
 373
 374   void RetrieveConsoleEvents(JSContext* aCx, nsTArray<JS::Value>& aEvents,
 375                              ErrorResult& aRv);
 376
 377   void SetConsoleEventHandler(JSContext* aCx, AnyCallback* aHandler,
 378                               ErrorResult& aRv);
 379
 380   already_AddRefed<Console> GetConsole(ErrorResult& aRv);
 381
 382   Console* GetConsoleIfExists() const { return mConsole; }
 383
 384   void Dump(JSContext* aCx, const Optional<nsAString>& aString) const;
 385
 386   void Atob(const nsAString& aAtob, nsAString& aOutput, ErrorResult& aRv) const;
 387   void Btoa(const nsAString& aBtoa, nsAString& aOutput, ErrorResult& aRv) const;
 388
 389   // Override DispatchTrait API to target the worker thread.  Dispatch may
 390   // return failure if the worker thread is not alive.
 391   nsresult Dispatch(TaskCategory aCategory,
 392                     already_AddRefed<nsIRunnable>&& aRunnable) override;
 393
 394   nsISerialEventTarget* EventTargetFor(TaskCategory aCategory) const override;
 395
 396   AbstractThread* AbstractMainThreadFor(TaskCategory aCategory) override;
 397
 398  private:
 399   virtual ~WorkerDebuggerGlobalScope();
 400 };
 401
 402 }  // namespace dom
 403 }  // namespace mozilla
 404
 405 inline nsISupports* ToSupports(mozilla::dom::WorkerGlobalScope* aScope) {
 406   return static_cast<mozilla::dom::EventTarget*>(aScope);
 407 }
 408
 409 #endif /* mozilla_dom_workerscope_h__ */