The Tor Browser: dom/workers/RuntimeService.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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/. */

     7 #ifndef mozilla_dom_workers_runtimeservice_h__

     8 #define mozilla_dom_workers_runtimeservice_h__

    10 #include "Workers.h"

    12 #include "nsIObserver.h"

    14 #include "mozilla/TimeStamp.h"

    15 #include "mozilla/dom/BindingDeclarations.h"

    16 #include "nsClassHashtable.h"

    17 #include "nsHashKeys.h"

    18 #include "nsTArray.h"

    20 class nsIRunnable;

    21 class nsIThread;

    22 class nsITimer;

    23 class nsPIDOMWindow;

    25 BEGIN_WORKERS_NAMESPACE

    27 class SharedWorker;

    28 class WorkerPrivate;

    30 class RuntimeService MOZ_FINAL : public nsIObserver

    31 {

    32 public:

    33   class WorkerThread;

    35 private:

    36   struct SharedWorkerInfo

    37   {

    38     WorkerPrivate* mWorkerPrivate;

    39     nsCString mScriptSpec;

    40     nsCString mName;

    42     SharedWorkerInfo(WorkerPrivate* aWorkerPrivate,

    43                      const nsACString& aScriptSpec,

    44                      const nsACString& aName)

    45     : mWorkerPrivate(aWorkerPrivate), mScriptSpec(aScriptSpec), mName(aName)

    46     { }

    47   };

    49   struct WorkerDomainInfo

    50   {

    51     nsCString mDomain;

    52     nsTArray<WorkerPrivate*> mActiveWorkers;

    53     nsTArray<WorkerPrivate*> mQueuedWorkers;

    54     nsClassHashtable<nsCStringHashKey, SharedWorkerInfo> mSharedWorkerInfos;

    55     uint32_t mChildWorkerCount;

    57     WorkerDomainInfo()

    58     : mActiveWorkers(1), mChildWorkerCount(0)

    59     { }

    61     uint32_t

    62     ActiveWorkerCount() const

    63     {

    64       return mActiveWorkers.Length() + mChildWorkerCount;

    65     }

    66   };

    68   struct IdleThreadInfo

    69   {

    70     nsRefPtr<WorkerThread> mThread;

    71     mozilla::TimeStamp mExpirationTime;

    72   };

    74   struct MatchSharedWorkerInfo

    75   {

    76     WorkerPrivate* mWorkerPrivate;

    77     SharedWorkerInfo* mSharedWorkerInfo;

    79     MatchSharedWorkerInfo(WorkerPrivate* aWorkerPrivate)

    80     : mWorkerPrivate(aWorkerPrivate), mSharedWorkerInfo(nullptr)

    81     { }

    82   };

    84   mozilla::Mutex mMutex;

    86   // Protected by mMutex.

    87   nsClassHashtable<nsCStringHashKey, WorkerDomainInfo> mDomainMap;

    89   // Protected by mMutex.

    90   nsTArray<IdleThreadInfo> mIdleThreadArray;

    92   // *Not* protected by mMutex.

    93   nsClassHashtable<nsPtrHashKey<nsPIDOMWindow>,

    94                    nsTArray<WorkerPrivate*> > mWindowMap;

    96   // Only used on the main thread.

    97   nsCOMPtr<nsITimer> mIdleThreadTimer;

    99   static JSSettings sDefaultJSSettings;

   100   static bool sDefaultPreferences[WORKERPREF_COUNT];

   102 public:

   103   struct NavigatorProperties

   104   {

   105     nsString mAppName;

   106     nsString mAppNameOverridden;

   107     nsString mAppVersion;

   108     nsString mAppVersionOverridden;

   109     nsString mPlatform;

   110     nsString mPlatformOverridden;

   111     nsString mUserAgent;

   112   };

   114 private:

   115   NavigatorProperties mNavigatorProperties;

   117   // True when the observer service holds a reference to this object.

   118   bool mObserved;

   119   bool mShuttingDown;

   120   bool mNavigatorPropertiesLoaded;

   122 public:

   123   NS_DECL_ISUPPORTS

   124   NS_DECL_NSIOBSERVER

   126   static RuntimeService*

   127   GetOrCreateService();

   129   static RuntimeService*

   130   GetService();

   132   bool

   133   RegisterWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);

   135   void

   136   UnregisterWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);

   138   void

   139   CancelWorkersForWindow(nsPIDOMWindow* aWindow);

   141   void

   142   SuspendWorkersForWindow(nsPIDOMWindow* aWindow);

   144   void

   145   ResumeWorkersForWindow(nsPIDOMWindow* aWindow);

   147   nsresult

   148   CreateSharedWorker(const GlobalObject& aGlobal,

   149                      const nsAString& aScriptURL,

   150                      const nsACString& aName,

   151                      SharedWorker** aSharedWorker);

   153   void

   154   ForgetSharedWorker(WorkerPrivate* aWorkerPrivate);

   156   const NavigatorProperties&

   157   GetNavigatorProperties() const

   158   {

   159     return mNavigatorProperties;

   160   }

   162   void

   163   NoteIdleThread(WorkerThread* aThread);

   165   static void

   166   GetDefaultJSSettings(JSSettings& aSettings)

   167   {

   168     AssertIsOnMainThread();

   169     aSettings = sDefaultJSSettings;

   170   }

   172   static void

   173   GetDefaultPreferences(bool aPreferences[WORKERPREF_COUNT])

   174   {

   175     AssertIsOnMainThread();

   176     memcpy(aPreferences, sDefaultPreferences, WORKERPREF_COUNT * sizeof(bool));

   177   }

   179   static void

   180   SetDefaultRuntimeAndContextOptions(

   181                                     const JS::RuntimeOptions& aRuntimeOptions,

   182                                     const JS::ContextOptions& aContentCxOptions,

   183                                     const JS::ContextOptions& aChromeCxOptions)

   184   {

   185     AssertIsOnMainThread();

   186     sDefaultJSSettings.runtimeOptions = aRuntimeOptions;

   187     sDefaultJSSettings.content.contextOptions = aContentCxOptions;

   188     sDefaultJSSettings.chrome.contextOptions = aChromeCxOptions;

   189   }

   191   void

   192   UpdateAppNameOverridePreference(const nsAString& aValue);

   194   void

   195   UpdateAppVersionOverridePreference(const nsAString& aValue);

   197   void

   198   UpdatePlatformOverridePreference(const nsAString& aValue);

   200   void

   201   UpdateAllWorkerRuntimeAndContextOptions();

   203   void

   204   UpdateAllWorkerPreference(WorkerPreference aPref, bool aValue);

   206   static void

   207   SetDefaultJSGCSettings(JSGCParamKey aKey, uint32_t aValue)

   208   {

   209     AssertIsOnMainThread();

   210     sDefaultJSSettings.ApplyGCSetting(aKey, aValue);

   211   }

   213   void

   214   UpdateAllWorkerMemoryParameter(JSGCParamKey aKey, uint32_t aValue);

   216   static uint32_t

   217   GetContentCloseHandlerTimeoutSeconds()

   218   {

   219     return sDefaultJSSettings.content.maxScriptRuntime;

   220   }

   222   static uint32_t

   223   GetChromeCloseHandlerTimeoutSeconds()

   224   {

   225     return sDefaultJSSettings.chrome.maxScriptRuntime;

   226   }

   228 #ifdef JS_GC_ZEAL

   229   static void

   230   SetDefaultGCZeal(uint8_t aGCZeal, uint32_t aFrequency)

   231   {

   232     AssertIsOnMainThread();

   233     sDefaultJSSettings.gcZeal = aGCZeal;

   234     sDefaultJSSettings.gcZealFrequency = aFrequency;

   235   }

   237   void

   238   UpdateAllWorkerGCZeal();

   239 #endif

   241   void

   242   GarbageCollectAllWorkers(bool aShrinking);

   244   void

   245   CycleCollectAllWorkers();

   247   void

   248   SendOfflineStatusChangeEventToAllWorkers(bool aIsOffline);

   250 private:

   251   RuntimeService();

   252   ~RuntimeService();

   254   nsresult

   255   Init();

   257   void

   258   Shutdown();

   260   void

   261   Cleanup();

   263   static PLDHashOperator

   264   AddAllTopLevelWorkersToArray(const nsACString& aKey,

   265                                WorkerDomainInfo* aData,

   266                                void* aUserArg);

   268   static PLDHashOperator

   269   RemoveSharedWorkerFromWindowMap(nsPIDOMWindow* aKey,

   270                                   nsAutoPtr<nsTArray<WorkerPrivate*> >& aData,

   271                                   void* aUserArg);

   273   static PLDHashOperator

   274   FindSharedWorkerInfo(const nsACString& aKey,

   275                        SharedWorkerInfo* aData,

   276                        void* aUserArg);

   278   void

   279   GetWorkersForWindow(nsPIDOMWindow* aWindow,

   280                       nsTArray<WorkerPrivate*>& aWorkers);

   282   bool

   283   ScheduleWorker(JSContext* aCx, WorkerPrivate* aWorkerPrivate);

   285   static void

   286   ShutdownIdleThreads(nsITimer* aTimer, void* aClosure);

   288   static void

   289   WorkerPrefChanged(const char* aPrefName, void* aClosure);

   291   static void

   292   JSVersionChanged(const char* aPrefName, void* aClosure);

   293 };

   295 END_WORKERS_NAMESPACE

   297 #endif /* mozilla_dom_workers_runtimeservice_h__ */

The Tor Browser / file revision

dom/workers/RuntimeService.h@6474c204b198

dom/workers/RuntimeService.h