dom/workers/RuntimeService.h

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=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 "Workers.h"
  11
  12 #include "nsIObserver.h"
  13
  14 #include "jsapi.h"
  15 #include "mozilla/Attributes.h"
  16 #include "mozilla/Mutex.h"
  17 #include "mozilla/TimeStamp.h"
  18 #include "nsAutoPtr.h"
  19 #include "nsClassHashtable.h"
  20 #include "nsCOMPtr.h"
  21 #include "nsHashKeys.h"
  22 #include "nsStringGlue.h"
  23 #include "nsTArray.h"
  24
  25 class nsIThread;
  26 class nsITimer;
  27 class nsPIDOMWindow;
  28
  29 BEGIN_WORKERS_NAMESPACE
  30
  31 class WorkerPrivate;
  32
  33 class RuntimeService MOZ_FINAL : public nsIObserver
  34 {
  35   struct WorkerDomainInfo
  36   {
  37     nsCString mDomain;
  38     nsTArray<WorkerPrivate*> mActiveWorkers;
  39     nsTArray<WorkerPrivate*> mQueuedWorkers;
  40     uint32_t mChildWorkerCount;
  41
  42     WorkerDomainInfo() : mActiveWorkers(1), mChildWorkerCount(0) { }
  43
  44     uint32_t
  45     ActiveWorkerCount() const
  46     {
  47       return mActiveWorkers.Length() + mChildWorkerCount;
  48     }
  49   };
  50
  51   struct IdleThreadInfo
  52   {
  53     nsCOMPtr<nsIThread> mThread;
  54     mozilla::TimeStamp mExpirationTime;
  55   };
  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<nsPIDOMWindow>, nsTArray<WorkerPrivate*> > mWindowMap;
  67
  68   // Only used on the main thread.
  69   nsCOMPtr<nsITimer> mIdleThreadTimer;
  70
  71   nsCString mDetectorName;
  72   nsCString mSystemCharset;
  73
  74   static JSSettings sDefaultJSSettings;
  75
  76 public:
  77   struct NavigatorStrings
  78   {
  79     nsString mAppName;
  80     nsString mAppVersion;
  81     nsString mPlatform;
  82     nsString mUserAgent;
  83   };
  84
  85 private:
  86   NavigatorStrings mNavigatorStrings;
  87
  88   // True when the observer service holds a reference to this object.
  89   bool mObserved;
  90   bool mShuttingDown;
  91   bool mNavigatorStringsLoaded;
  92
  93 public:
  94   NS_DECL_ISUPPORTS
  95   NS_DECL_NSIOBSERVER
  96
  97   static RuntimeService*
  98   GetOrCreateService();
  99
 100   static RuntimeService*
 101   GetService();
 102
 103   bool
 104   RegisterWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 105
 106   void
 107   UnregisterWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 108
 109   void
 110   CancelWorkersForWindow(JSContext* aCx, nsPIDOMWindow* aWindow);
 111
 112   void
 113   SuspendWorkersForWindow(JSContext* aCx, nsPIDOMWindow* aWindow);
 114
 115   void
 116   ResumeWorkersForWindow(nsIScriptContext* aCx, nsPIDOMWindow* aWindow);
 117
 118   const nsACString&
 119   GetDetectorName() const
 120   {
 121     return mDetectorName;
 122   }
 123
 124   const nsACString&
 125   GetSystemCharset() const
 126   {
 127     return mSystemCharset;
 128   }
 129
 130   const NavigatorStrings&
 131   GetNavigatorStrings() const
 132   {
 133     return mNavigatorStrings;
 134   }
 135
 136   void
 137   NoteIdleThread(nsIThread* aThread);
 138
 139   static void
 140   GetDefaultJSSettings(JSSettings& aSettings)
 141   {
 142     AssertIsOnMainThread();
 143     aSettings = sDefaultJSSettings;
 144   }
 145
 146   static void
 147   SetDefaultJSContextOptions(uint32_t aContentOptions, uint32_t aChromeOptions)
 148   {
 149     AssertIsOnMainThread();
 150     sDefaultJSSettings.content.options = aContentOptions;
 151     sDefaultJSSettings.chrome.options = aChromeOptions;
 152   }
 153
 154   void
 155   UpdateAllWorkerJSContextOptions();
 156
 157   static void
 158   SetDefaultJSGCSettings(JSGCParamKey aKey, uint32_t aValue)
 159   {
 160     AssertIsOnMainThread();
 161     sDefaultJSSettings.ApplyGCSetting(aKey, aValue);
 162   }
 163
 164   void
 165   UpdateAllWorkerMemoryParameter(JSGCParamKey aKey, uint32_t aValue);
 166
 167   static uint32_t
 168   GetContentCloseHandlerTimeoutSeconds()
 169   {
 170     return sDefaultJSSettings.content.maxScriptRuntime;
 171   }
 172
 173   static uint32_t
 174   GetChromeCloseHandlerTimeoutSeconds()
 175   {
 176     return sDefaultJSSettings.chrome.maxScriptRuntime;
 177   }
 178
 179 #ifdef JS_GC_ZEAL
 180   static void
 181   SetDefaultGCZeal(uint8_t aGCZeal, uint32_t aFrequency)
 182   {
 183     AssertIsOnMainThread();
 184     sDefaultJSSettings.gcZeal = aGCZeal;
 185     sDefaultJSSettings.gcZealFrequency = aFrequency;
 186   }
 187
 188   void
 189   UpdateAllWorkerGCZeal();
 190 #endif
 191
 192   static void
 193   SetDefaultJITHardening(bool aJITHardening)
 194   {
 195     AssertIsOnMainThread();
 196     sDefaultJSSettings.jitHardening = aJITHardening;
 197   }
 198
 199   void
 200   UpdateAllWorkerJITHardening(bool aJITHardening);
 201
 202   void
 203   GarbageCollectAllWorkers(bool aShrinking);
 204
 205 private:
 206   RuntimeService();
 207   ~RuntimeService();
 208
 209   nsresult
 210   Init();
 211
 212   void
 213   Cleanup();
 214
 215   static PLDHashOperator
 216   AddAllTopLevelWorkersToArray(const nsACString& aKey,
 217                                WorkerDomainInfo* aData,
 218                                void* aUserArg);
 219
 220   void
 221   GetWorkersForWindow(nsPIDOMWindow* aWindow,
 222                       nsTArray<WorkerPrivate*>& aWorkers);
 223
 224   bool
 225   ScheduleWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 226
 227   static void
 228   ShutdownIdleThreads(nsITimer* aTimer, void* aClosure);
 229 };
 230
 231 END_WORKERS_NAMESPACE
 232
 233 #endif /* mozilla_dom_workers_runtimeservice_h__ */