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