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