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