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/Mutex.h"
  20 #include "nsClassHashtable.h"
  21 #include "nsHashKeys.h"
  22 #include "nsTArray.h"
  23
  24 class nsITimer;
  25 class nsPIDOMWindowInner;
  26
  27 namespace mozilla {
  28 namespace 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   struct IdleThreadInfo {
  58     SafeRefPtr<WorkerThread> mThread;
  59     mozilla::TimeStamp mExpirationTime;
  60   };
  61
  62   mozilla::Mutex mMutex;
  63
  64   // Protected by mMutex.
  65   nsClassHashtable<nsCStringHashKey, WorkerDomainInfo> mDomainMap;
  66
  67   // Protected by mMutex.
  68   nsTArray<IdleThreadInfo> mIdleThreadArray;
  69
  70   // *Not* protected by mMutex.
  71   nsClassHashtable<nsPtrHashKey<const nsPIDOMWindowInner>,
  72                    nsTArray<WorkerPrivate*> >
  73       mWindowMap;
  74
  75   // Only used on the main thread.
  76   nsCOMPtr<nsITimer> mIdleThreadTimer;
  77
  78   static UniquePtr<workerinternals::JSSettings> sDefaultJSSettings;
  79
  80  public:
  81   struct NavigatorProperties {
  82     nsString mAppName;
  83     nsString mAppNameOverridden;
  84     nsString mAppVersion;
  85     nsString mAppVersionOverridden;
  86     nsString mPlatform;
  87     nsString mPlatformOverridden;
  88     CopyableTArray<nsString> mLanguages;
  89   };
  90
  91  private:
  92   NavigatorProperties mNavigatorProperties;
  93
  94   // True when the observer service holds a reference to this object.
  95   bool mObserved;
  96   bool mShuttingDown;
  97   bool mNavigatorPropertiesLoaded;
  98
  99  public:
 100   NS_DECL_ISUPPORTS
 101   NS_DECL_NSIOBSERVER
 102
 103   static RuntimeService* GetOrCreateService();
 104
 105   static RuntimeService* GetService();
 106
 107   bool RegisterWorker(WorkerPrivate& aWorkerPrivate);
 108
 109   void UnregisterWorker(WorkerPrivate& aWorkerPrivate);
 110
 111   void CancelWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 112
 113   void FreezeWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 114
 115   void ThawWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 116
 117   void SuspendWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 118
 119   void ResumeWorkersForWindow(const nsPIDOMWindowInner& aWindow);
 120
 121   void PropagateStorageAccessPermissionGranted(
 122       const nsPIDOMWindowInner& aWindow);
 123
 124   const NavigatorProperties& GetNavigatorProperties() const {
 125     return mNavigatorProperties;
 126   }
 127
 128   void NoteIdleThread(SafeRefPtr<WorkerThread> aThread);
 129
 130   static void GetDefaultJSSettings(workerinternals::JSSettings& aSettings) {
 131     AssertIsOnMainThread();
 132     aSettings = *sDefaultJSSettings;
 133   }
 134
 135   static void SetDefaultContextOptions(
 136       const JS::ContextOptions& aContextOptions) {
 137     AssertIsOnMainThread();
 138     sDefaultJSSettings->contextOptions = aContextOptions;
 139   }
 140
 141   void UpdateAppNameOverridePreference(const nsAString& aValue);
 142
 143   void UpdateAppVersionOverridePreference(const nsAString& aValue);
 144
 145   void UpdatePlatformOverridePreference(const nsAString& aValue);
 146
 147   void UpdateAllWorkerContextOptions();
 148
 149   void UpdateAllWorkerLanguages(const nsTArray<nsString>& aLanguages);
 150
 151   static void SetDefaultJSGCSettings(JSGCParamKey aKey,
 152                                      Maybe<uint32_t> aValue) {
 153     AssertIsOnMainThread();
 154     sDefaultJSSettings->ApplyGCSetting(aKey, aValue);
 155   }
 156
 157   void UpdateAllWorkerMemoryParameter(JSGCParamKey aKey,
 158                                       Maybe<uint32_t> aValue);
 159
 160 #ifdef JS_GC_ZEAL
 161   static void SetDefaultGCZeal(uint8_t aGCZeal, uint32_t aFrequency) {
 162     AssertIsOnMainThread();
 163     sDefaultJSSettings->gcZeal = aGCZeal;
 164     sDefaultJSSettings->gcZealFrequency = aFrequency;
 165   }
 166
 167   void UpdateAllWorkerGCZeal();
 168 #endif
 169
 170   void SetLowMemoryStateAllWorkers(bool aState);
 171
 172   void GarbageCollectAllWorkers(bool aShrinking);
 173
 174   void CycleCollectAllWorkers();
 175
 176   void SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline);
 177
 178   void MemoryPressureAllWorkers();
 179
 180   uint32_t ClampedHardwareConcurrency() const;
 181
 182   void CrashIfHanging();
 183
 184  private:
 185   RuntimeService();
 186   ~RuntimeService();
 187
 188   nsresult Init();
 189
 190   void Shutdown();
 191
 192   void Cleanup();
 193
 194   void AddAllTopLevelWorkersToArray(nsTArray<WorkerPrivate*>& aWorkers);
 195
 196   nsTArray<WorkerPrivate*> GetWorkersForWindow(
 197       const nsPIDOMWindowInner& aWindow) const;
 198
 199   bool ScheduleWorker(WorkerPrivate& aWorkerPrivate);
 200
 201   static void ShutdownIdleThreads(nsITimer* aTimer, void* aClosure);
 202
 203   template <typename Func>
 204   void BroadcastAllWorkers(const Func& aFunc);
 205 };
 206
 207 }  // namespace workerinternals
 208 }  // namespace dom
 209 }  // namespace mozilla
 210
 211 #endif /* mozilla_dom_workers_runtimeservice_h__ */