dom/workers/ScriptLoader.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_workers_scriptloader_h__
   8 #define mozilla_dom_workers_scriptloader_h__
   9
  10 #include "js/loader/ScriptLoadRequest.h"
  11 #include "js/loader/ModuleLoadRequest.h"
  12 #include "js/loader/ModuleLoaderBase.h"
  13 #include "mozilla/dom/WorkerBinding.h"
  14 #include "mozilla/dom/WorkerCommon.h"
  15 #include "mozilla/dom/WorkerLoadContext.h"
  16 #include "mozilla/dom/WorkerRef.h"
  17 #include "mozilla/dom/workerinternals/WorkerModuleLoader.h"
  18 #include "mozilla/Maybe.h"
  19 #include "nsIContentPolicy.h"
  20 #include "nsStringFwd.h"
  21 #include "nsTArrayForwardDeclare.h"
  22
  23 class nsIChannel;
  24 class nsICookieJarSettings;
  25 class nsILoadGroup;
  26 class nsIPrincipal;
  27 class nsIReferrerInfo;
  28 class nsIURI;
  29
  30 namespace mozilla {
  31
  32 class ErrorResult;
  33
  34 namespace dom {
  35
  36 class ClientInfo;
  37 class Document;
  38 struct WorkerLoadInfo;
  39 class WorkerPrivate;
  40 class SerializedStackHolder;
  41
  42 enum WorkerScriptType { WorkerScript, DebuggerScript };
  43
  44 namespace workerinternals {
  45
  46 namespace loader {
  47 class ScriptExecutorRunnable;
  48 class ScriptLoaderRunnable;
  49 class CachePromiseHandler;
  50 class CacheLoadHandler;
  51 class CacheCreator;
  52 class NetworkLoadHandler;
  53
  54 /*
  55  * [DOMDOC] WorkerScriptLoader
  56  *
  57  * The WorkerScriptLoader is the primary class responsible for loading all
  58  * Workers, including: ServiceWorkers, SharedWorkers, RemoteWorkers, and
  59  * dedicated Workers. Our implementation also includes a subtype of dedicated
  60  * workers: ChromeWorker, which exposes information that isn't normally
  61  * accessible on a dedicated worker. See [1] for more information.
  62  *
  63  * Due to constraints around fetching, this class currently delegates the
  64  * "Fetch" portion of its work load to the main thread. Unlike the DOM
  65  * ScriptLoader, the WorkerScriptLoader is not persistent and is not reused for
  66  * subsequent loads. That means for each iteration of loading (for example,
  67  * loading the main script, followed by a load triggered by ImportScripts), we
  68  * recreate this class, and handle the case independently.
  69  *
  70  * The flow of requests across the boundaries looks like this:
  71  *
  72  *    +----------------------------+
  73  *    | new WorkerScriptLoader(..) |
  74  *    +----------------------------+
  75  *                   |
  76  *                   V
  77  *            +-------------------------------------------+
  78  *            | WorkerScriptLoader::DispatchLoadScripts() |
  79  *            +-------------------------------------------+
  80  *                   |
  81  *                   V
  82  *            +............................+
  83  *            | new ScriptLoaderRunnable() |
  84  *            +............................+
  85  *                   :
  86  *                   V
  87  *  #####################################################################
  88  *                             Enter Main thread
  89  *  #####################################################################
  90  *                   :
  91  *                   V
  92  *  +.............................+     For each: Is a normal Worker?
  93  *  | ScriptLoaderRunnable::Run() |----------------------------------+
  94  *  +.............................+                                  |
  95  *                   |                                               V
  96  *                   |               +----------------------------------+
  97  *                   |               | WorkerScriptLoader::LoadScript() |
  98  *                   |               +----------------------------------+
  99  *                   |                                               |
 100  *                   | For each request: Is a ServiceWorker?         |
 101  *                   |                                               |
 102  *                   V                                               V
 103  *   +==================+   No script in cache?   +====================+
 104  *   | CacheLoadHandler |------------------------>| NetworkLoadHandler |
 105  *   +==================+                         +====================+
 106  *      :                                                    :
 107  *      : Loaded from Cache                                  : Loaded by Network
 108  *      :   +..........................................+     :
 109  *      +---| ScriptLoaderRunnable::OnStreamComplete() |<----+
 110  *          +..........................................+
 111  *                             |
 112  *                             | A request is ready, is it in post order?
 113  *                             |
 114  *                             | call DispatchPendingProcessRequests()
 115  *                             | This creates ScriptExecutorRunnable
 116  *            +..............................+
 117  *            | new ScriptLoaderExecutable() |
 118  *            +..............................+
 119  *                             :
 120  *                             V
 121  *  #####################################################################
 122  *                           Enter worker thread
 123  *  #####################################################################
 124  *                             :
 125  *                             V
 126  *          +...............................+         All Scripts Executed?
 127  *          | ScriptLoaderExecutable::Run() | -------------+
 128  *          +...............................+              :
 129  *                                                         :
 130  *                                                         : yes. Do execution
 131  *                                                         : then shutdown.
 132  *                                                         :
 133  *                                                         V
 134  *                       +--------------------------------------------+
 135  *                       | WorkerScriptLoader::ShutdownScriptLoader() |
 136  *                       +--------------------------------------------+
 137  */
 138
 139 class WorkerScriptLoader : public JS::loader::ScriptLoaderInterface,
 140                            public nsINamed {
 141   friend class ScriptExecutorRunnable;
 142   friend class ScriptLoaderRunnable;
 143   friend class CachePromiseHandler;
 144   friend class CacheLoadHandler;
 145   friend class CacheCreator;
 146   friend class NetworkLoadHandler;
 147   friend class WorkerModuleLoader;
 148
 149   RefPtr<ThreadSafeWorkerRef> mWorkerRef;
 150   UniquePtr<SerializedStackHolder> mOriginStack;
 151   nsString mOriginStackJSON;
 152   nsCOMPtr<nsISerialEventTarget> mSyncLoopTarget;
 153   ScriptLoadRequestList mLoadingRequests;
 154   ScriptLoadRequestList mLoadedRequests;
 155   Maybe<ServiceWorkerDescriptor> mController;
 156   WorkerScriptType mWorkerScriptType;
 157   ErrorResult& mRv;
 158   bool mExecutionAborted = false;
 159   bool mMutedErrorFlag = false;
 160
 161   // Count of loading module requests. mLoadingRequests doesn't keep track of
 162   // child module requests.
 163   // This member should be accessed on worker thread.
 164   uint32_t mLoadingModuleRequestCount;
 165
 166   // Worker cancellation related Mutex
 167   //
 168   // Modified on the worker thread.
 169   // It is ok to *read* this without a lock on the worker.
 170   // Main thread must always acquire a lock.
 171   bool mCleanedUp MOZ_GUARDED_BY(
 172       mCleanUpLock);  // To specify if the cleanUp() has been done.
 173
 174   Mutex& CleanUpLock() MOZ_RETURN_CAPABILITY(mCleanUpLock) {
 175     return mCleanUpLock;
 176   }
 177
 178   bool CleanedUp() const MOZ_REQUIRES(mCleanUpLock) {
 179     mCleanUpLock.AssertCurrentThreadOwns();
 180     return mCleanedUp;
 181   }
 182
 183   // Ensure the worker and the main thread won't race to access |mCleanedUp|.
 184   // Should be a MutexSingleWriter, but that causes a lot of issues when you
 185   // expose the lock via Lock().
 186   Mutex mCleanUpLock;
 187
 188  public:
 189   NS_DECL_THREADSAFE_ISUPPORTS
 190
 191   WorkerScriptLoader(WorkerPrivate* aWorkerPrivate,
 192                      UniquePtr<SerializedStackHolder> aOriginStack,
 193                      nsISerialEventTarget* aSyncLoopTarget,
 194                      WorkerScriptType aWorkerScriptType, ErrorResult& aRv);
 195
 196   bool CreateScriptRequests(const nsTArray<nsString>& aScriptURLs,
 197                             const mozilla::Encoding* aDocumentEncoding,
 198                             bool aIsMainScript);
 199
 200   ScriptLoadRequest* GetMainScript();
 201
 202   already_AddRefed<ScriptLoadRequest> CreateScriptLoadRequest(
 203       const nsString& aScriptURL, const mozilla::Encoding* aDocumentEncoding,
 204       bool aIsMainScript);
 205
 206   bool DispatchLoadScript(ScriptLoadRequest* aRequest);
 207
 208   bool DispatchLoadScripts();
 209
 210   void TryShutdown();
 211
 212   WorkerScriptType GetWorkerScriptType() { return mWorkerScriptType; }
 213
 214  protected:
 215   nsIURI* GetBaseURI() const override;
 216
 217   nsIURI* GetInitialBaseURI();
 218
 219   nsIGlobalObject* GetGlobal();
 220
 221   void MaybeMoveToLoadedList(ScriptLoadRequest* aRequest);
 222
 223   bool StoreCSP();
 224
 225   bool ProcessPendingRequests(JSContext* aCx);
 226
 227   bool AllScriptsExecuted() {
 228     return mLoadingRequests.isEmpty() && mLoadedRequests.isEmpty();
 229   }
 230
 231   bool IsDebuggerScript() const { return mWorkerScriptType == DebuggerScript; }
 232
 233   void SetController(const Maybe<ServiceWorkerDescriptor>& aDescriptor) {
 234     mController = aDescriptor;
 235   }
 236
 237   Maybe<ServiceWorkerDescriptor>& GetController() { return mController; }
 238
 239   nsresult LoadScript(ThreadSafeRequestHandle* aRequestHandle);
 240
 241   void ShutdownScriptLoader(bool aResult, bool aMutedError);
 242
 243  private:
 244   ~WorkerScriptLoader() = default;
 245
 246   NS_IMETHOD
 247   GetName(nsACString& aName) override {
 248     aName.AssignLiteral("WorkerScriptLoader");
 249     return NS_OK;
 250   }
 251
 252   void InitModuleLoader();
 253
 254   nsTArray<RefPtr<ThreadSafeRequestHandle>> GetLoadingList();
 255
 256   bool IsDynamicImport(ScriptLoadRequest* aRequest);
 257
 258   nsContentPolicyType GetContentPolicyType(ScriptLoadRequest* aRequest);
 259
 260   bool EvaluateScript(JSContext* aCx, ScriptLoadRequest* aRequest);
 261
 262   nsresult FillCompileOptionsForRequest(
 263       JSContext* cx, ScriptLoadRequest* aRequest, JS::CompileOptions* aOptions,
 264       JS::MutableHandle<JSScript*> aIntroductionScript) override;
 265
 266   void ReportErrorToConsole(ScriptLoadRequest* aRequest,
 267                             nsresult aResult) const override;
 268
 269   // Only used by import maps, crash if we get here.
 270   void ReportWarningToConsole(
 271       ScriptLoadRequest* aRequest, const char* aMessageName,
 272       const nsTArray<nsString>& aParams = nsTArray<nsString>()) const override {
 273     MOZ_CRASH("Import maps have not been implemented for this context");
 274   }
 275
 276   void LogExceptionToConsole(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 277
 278   bool AllModuleRequestsLoaded() const;
 279   void IncreaseLoadingModuleRequestCount();
 280   void DecreaseLoadingModuleRequestCount();
 281 };
 282
 283 /* ScriptLoaderRunnable
 284  *
 285  * Responsibilities of this class:
 286  *   - the actual dispatch
 287  *   - delegating the load back to WorkerScriptLoader
 288  *   - handling the collections of scripts being requested
 289  *   - handling main thread cancellation
 290  *   - dispatching back to the worker thread
 291  */
 292 class ScriptLoaderRunnable final : public nsIRunnable, public nsINamed {
 293   RefPtr<WorkerScriptLoader> mScriptLoader;
 294   RefPtr<ThreadSafeWorkerRef> mWorkerRef;
 295   nsTArrayView<RefPtr<ThreadSafeRequestHandle>> mLoadingRequests;
 296   Maybe<nsresult> mCancelMainThread;
 297   RefPtr<CacheCreator> mCacheCreator;
 298
 299  public:
 300   NS_DECL_THREADSAFE_ISUPPORTS
 301
 302   explicit ScriptLoaderRunnable(
 303       WorkerScriptLoader* aScriptLoader,
 304       nsTArray<RefPtr<ThreadSafeRequestHandle>> aLoadingRequests);
 305
 306   nsresult OnStreamComplete(ThreadSafeRequestHandle* aRequestHandle,
 307                             nsresult aStatus);
 308
 309   void LoadingFinished(ThreadSafeRequestHandle* aRequestHandle, nsresult aRv);
 310
 311   void MaybeExecuteFinishedScripts(ThreadSafeRequestHandle* aRequestHandle);
 312
 313   bool IsCancelled() { return mCancelMainThread.isSome(); }
 314
 315   nsresult GetCancelResult() {
 316     return (IsCancelled()) ? mCancelMainThread.ref() : NS_OK;
 317   }
 318
 319   void CancelMainThreadWithBindingAborted();
 320
 321   CacheCreator* GetCacheCreator() { return mCacheCreator; };
 322
 323  private:
 324   ~ScriptLoaderRunnable() = default;
 325
 326   void CancelMainThread(nsresult aCancelResult);
 327
 328   void DispatchProcessPendingRequests();
 329
 330   NS_IMETHOD
 331   Run() override;
 332
 333   NS_IMETHOD
 334   GetName(nsACString& aName) override {
 335     aName.AssignLiteral("ScriptLoaderRunnable");
 336     return NS_OK;
 337   }
 338 };
 339
 340 }  // namespace loader
 341
 342 nsresult ChannelFromScriptURLMainThread(
 343     nsIPrincipal* aPrincipal, Document* aParentDoc, nsILoadGroup* aLoadGroup,
 344     nsIURI* aScriptURL, const WorkerType& aWorkerType,
 345     const RequestCredentials& aCredentials,
 346     const Maybe<ClientInfo>& aClientInfo,
 347     nsContentPolicyType aContentPolicyType,
 348     nsICookieJarSettings* aCookieJarSettings, nsIReferrerInfo* aReferrerInfo,
 349     nsIChannel** aChannel);
 350
 351 nsresult ChannelFromScriptURLWorkerThread(
 352     JSContext* aCx, WorkerPrivate* aParent, const nsAString& aScriptURL,
 353     const WorkerType& aWorkerType, const RequestCredentials& aCredentials,
 354     WorkerLoadInfo& aLoadInfo);
 355
 356 void ReportLoadError(ErrorResult& aRv, nsresult aLoadResult,
 357                      const nsAString& aScriptURL);
 358
 359 void LoadMainScript(WorkerPrivate* aWorkerPrivate,
 360                     UniquePtr<SerializedStackHolder> aOriginStack,
 361                     const nsAString& aScriptURL,
 362                     WorkerScriptType aWorkerScriptType, ErrorResult& aRv,
 363                     const mozilla::Encoding* aDocumentEncoding);
 364
 365 void Load(WorkerPrivate* aWorkerPrivate,
 366           UniquePtr<SerializedStackHolder> aOriginStack,
 367           const nsTArray<nsString>& aScriptURLs,
 368           WorkerScriptType aWorkerScriptType, ErrorResult& aRv);
 369
 370 }  // namespace workerinternals
 371
 372 }  // namespace dom
 373 }  // namespace mozilla
 374
 375 #endif /* mozilla_dom_workers_scriptloader_h__ */