dom/workers/RuntimeService.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_runtimeservice_h__
   8 #define mozilla_dom_workers_runtimeservice_h__
   9
  10 #include "mozilla/dom/WorkerCommon.h"
  11
  12 #include "nsIObserver.h"
  13
  14 #include "js/ContextOptions.h"
  15 #include "MainThreadUtils.h"
  16 #include "mozilla/dom/BindingDeclarations.h"
  17 #include "mozilla/dom/SafeRefPtr.h"
  18 #include "mozilla/dom/workerinternals/JSSettings.h"
  19 #include "mozilla/Atomics.h"
  20 #include "mozilla/Mutex.h"
  21 #include "nsClassHashtable.h"
  22 #include "nsHashKeys.h"
  23 #include "nsTArray.h"
  24
  25 class nsPIDOMWindowInner;
  26
  27 namespace mozilla::dom {
  28 struct WorkerLoadInfo;
  29 class WorkerThread;
  30
  31 namespace workerinternals {
  32
  33 class RuntimeService final : public nsIObserver {
  34   struct WorkerDomainInfo {
  35     nsCString mDomain;
  36     nsTArray<WorkerPrivate*> mActiveWorkers;
  37     nsTArray<WorkerPrivate*> mActiveServiceWorkers;
  38     nsTArray<WorkerPrivate*> mQueuedWorkers;
  39     uint32_t mChildWorkerCount;
  40
  41     WorkerDomainInfo() : mActiveWorkers(1), mChildWorkerCount(0) {}
  42
  43     uint32_t ActiveWorkerCount() const {
  44       return mActiveWorkers.Length() + mChildWorkerCount;
  45     }
  46
  47     uint32_t ActiveServiceWorkerCount() const {
  48       return mActiveServiceWorkers.Length();
  49     }
  50
  51     bool HasNoWorkers() const {
  52       return ActiveWorkerCount() == 0 && ActiveServiceWorkerCount() == 0;
  53     }
  54   };
  55
  56   mozilla::Mutex mMutex;
  57
  58   // Protected by mMutex.
  59   nsClassHashtable<nsCStringHashKey, WorkerDomainInfo> mDomainMap
  60       MOZ_GUARDED_BY(mMutex);
  61
  62   // *Not* protected by mMutex.
  63   nsClassHashtable<nsPtrHashKey<const nsPIDOMWindowInner>,
  64                    nsTArray<WorkerPrivate*> >
  65       mWindowMap;
  66
  67   static UniquePtr<workerinternals::JSSettings> sDefaultJSSettings;
  68
  69  public:
  70   struct NavigatorProperties {
  71     nsString mAppVersion;
  72     nsString mAppVersionOverridden;
  73     nsString mPlatform;
  74     nsString mPlatformOverridden;
  75     CopyableTArray<nsString> mLanguages;
  76   };
  77
  78  private:
  79   NavigatorProperties mNavigatorProperties;
  80
  81   // True when the observer service holds a reference to this object.
  82   bool mObserved;
  83   bool mShuttingDown;
  84   bool mNavigatorPropertiesLoaded;
  85
  86  public:
  87   NS_DECL_ISUPPORTS
  88   NS_DECL_NSIOBSERVER
  89
  90   static RuntimeService* GetOrCreateService();
  91
  92   static RuntimeService* GetService();
  93
  94   bool RegisterWorker(WorkerPrivate& aWorkerPrivate);
  95
  96   void UnregisterWorker(WorkerPrivate& aWorkerPrivate);
  97
  98   void CancelWorkersForWindow(const nsPIDOMWindowInner& aWindow);
  99
 100   void FreezeWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 101
 102   void ThawWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 103
 104   void SuspendWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 105
 106   void ResumeWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 107
 108   void PropagateStorageAccessPermissionGranted(
 109       const nsPIDOMWindowInner& aWindow);
 110
 111   const NavigatorProperties& GetNavigatorProperties() const {
 112     return mNavigatorProperties;
 113   }
 114
 115   static void GetDefaultJSSettings(workerinternals::JSSettings& aSettings) {
 116     AssertIsOnMainThread();
 117     aSettings = *sDefaultJSSettings;
 118   }
 119
 120   static void SetDefaultContextOptions(
 121       const JS::ContextOptions& aContextOptions) {
 122     AssertIsOnMainThread();
 123     sDefaultJSSettings->contextOptions = aContextOptions;
 124   }
 125
 126   void UpdateAppVersionOverridePreference(const nsAString& aValue);
 127
 128   void UpdatePlatformOverridePreference(const nsAString& aValue);
 129
 130   void UpdateAllWorkerContextOptions();
 131
 132   void UpdateAllWorkerLanguages(const nsTArray<nsString>& aLanguages);
 133
 134   static void SetDefaultJSGCSettings(JSGCParamKey aKey,
 135                                      Maybe<uint32_t> aValue) {
 136     AssertIsOnMainThread();
 137     sDefaultJSSettings->ApplyGCSetting(aKey, aValue);
 138   }
 139
 140   void UpdateAllWorkerMemoryParameter(JSGCParamKey aKey,
 141                                       Maybe<uint32_t> aValue);
 142
 143 #ifdef JS_GC_ZEAL
 144   static void SetDefaultGCZeal(uint8_t aGCZeal, uint32_t aFrequency) {
 145     AssertIsOnMainThread();
 146     sDefaultJSSettings->gcZeal = aGCZeal;
 147     sDefaultJSSettings->gcZealFrequency = aFrequency;
 148   }
 149
 150   void UpdateAllWorkerGCZeal();
 151 #endif
 152
 153   void SetLowMemoryStateAllWorkers(bool aState);
 154
 155   void GarbageCollectAllWorkers(bool aShrinking);
 156
 157   void CycleCollectAllWorkers();
 158
 159   void SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline);
 160
 161   void MemoryPressureAllWorkers();
 162
 163   uint32_t ClampedHardwareConcurrency(bool aShouldResistFingerprinting) const;
 164
 165   void CrashIfHanging();
 166
 167   bool IsShuttingDown() const { return mShuttingDown; }
 168
 169   void DumpRunningWorkers();
 170
 171  private:
 172   RuntimeService();
 173   ~RuntimeService();
 174
 175   nsresult Init();
 176
 177   void Shutdown();
 178
 179   void Cleanup();
 180
 181   void AddAllTopLevelWorkersToArray(nsTArray<WorkerPrivate*>& aWorkers)
 182       MOZ_REQUIRES(mMutex);
 183
 184   nsTArray<WorkerPrivate*> GetWorkersForWindow(
 185       const nsPIDOMWindowInner& aWindow) const;
 186
 187   bool ScheduleWorker(WorkerPrivate& aWorkerPrivate);
 188
 189   template <typename Func>
 190   void BroadcastAllWorkers(const Func& aFunc);
 191 };
 192
 193 }  // namespace workerinternals
 194 }  // namespace mozilla::dom
 195
 196 #endif /* mozilla_dom_workers_runtimeservice_h__ */