dom/workers/WorkerPrivate.h

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_dom_workers_workerprivate_h__
   7 #define mozilla_dom_workers_workerprivate_h__
   8
   9 #include "Workers.h"
  10
  11 #include "nsIContentSecurityPolicy.h"
  12 #include "nsIRunnable.h"
  13 #include "nsIThread.h"
  14 #include "nsIThreadInternal.h"
  15 #include "nsPIDOMWindow.h"
  16
  17 #include "mozilla/Assertions.h"
  18 #include "mozilla/CondVar.h"
  19 #include "mozilla/TimeStamp.h"
  20 #include "mozilla/dom/BindingDeclarations.h"
  21 #include "nsCycleCollectionParticipant.h"
  22 #include "nsDataHashtable.h"
  23 #include "nsDOMEventTargetHelper.h"
  24 #include "nsEventQueue.h"
  25 #include "nsHashKeys.h"
  26 #include "nsRefPtrHashtable.h"
  27 #include "nsString.h"
  28 #include "nsTArray.h"
  29 #include "nsThreadUtils.h"
  30 #include "nsTPriorityQueue.h"
  31 #include "StructuredCloneTags.h"
  32
  33 #include "Queue.h"
  34 #include "WorkerFeature.h"
  35
  36 class JSAutoStructuredCloneBuffer;
  37 class nsIChannel;
  38 class nsIDocument;
  39 class nsIPrincipal;
  40 class nsIScriptContext;
  41 class nsITimer;
  42 class nsIURI;
  43
  44 namespace JS {
  45 class RuntimeStats;
  46 }
  47
  48 namespace mozilla {
  49 namespace dom {
  50 class Function;
  51 }
  52 }
  53
  54 BEGIN_WORKERS_NAMESPACE
  55
  56 class MessagePort;
  57 class SharedWorker;
  58 class WorkerGlobalScope;
  59 class WorkerPrivate;
  60
  61 class WorkerRunnable : public nsIRunnable
  62 {
  63 public:
  64   enum Target { ParentThread, WorkerThread };
  65   enum BusyBehavior { ModifyBusyCount, UnchangedBusyCount };
  66   enum ClearingBehavior { SkipWhenClearing, RunWhenClearing };
  67
  68 protected:
  69   WorkerPrivate* mWorkerPrivate;
  70   Target mTarget;
  71   BusyBehavior mBusyBehavior;
  72   ClearingBehavior mClearingBehavior;
  73
  74 public:
  75   NS_DECL_THREADSAFE_ISUPPORTS
  76
  77   bool
  78   Dispatch(JSContext* aCx);
  79
  80   static bool
  81   DispatchToMainThread(nsIRunnable*);
  82
  83   bool
  84   WantsToRunDuringClear()
  85   {
  86     return mClearingBehavior == RunWhenClearing;
  87   }
  88
  89 protected:
  90   WorkerRunnable(WorkerPrivate* aWorkerPrivate, Target aTarget,
  91                  BusyBehavior aBusyBehavior,
  92                  ClearingBehavior aClearingBehavior)
  93 #ifdef DEBUG
  94   ;
  95 #else
  96   : mWorkerPrivate(aWorkerPrivate), mTarget(aTarget),
  97     mBusyBehavior(aBusyBehavior), mClearingBehavior(aClearingBehavior)
  98   { }
  99 #endif
 100
 101   virtual ~WorkerRunnable()
 102   { }
 103
 104   virtual bool
 105   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
 106
 107   virtual void
 108   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
 109                bool aDispatchResult);
 110
 111   virtual bool
 112   DispatchInternal();
 113
 114   virtual bool
 115   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) = 0;
 116
 117   virtual void
 118   PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult);
 119
 120 public:
 121   NS_DECL_NSIRUNNABLE
 122 };
 123
 124 class WorkerSyncRunnable : public WorkerRunnable
 125 {
 126 protected:
 127   uint32_t mSyncQueueKey;
 128   bool mBypassSyncQueue;
 129
 130 protected:
 131   friend class WorkerPrivate;
 132
 133   WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate, uint32_t aSyncQueueKey,
 134                      bool aBypassSyncQueue = false,
 135                      ClearingBehavior aClearingBehavior = SkipWhenClearing)
 136   : WorkerRunnable(aWorkerPrivate, WorkerThread, UnchangedBusyCount,
 137                    aClearingBehavior),
 138     mSyncQueueKey(aSyncQueueKey), mBypassSyncQueue(aBypassSyncQueue)
 139   { }
 140
 141   virtual ~WorkerSyncRunnable()
 142   { }
 143
 144   virtual bool
 145   DispatchInternal() MOZ_OVERRIDE;
 146 };
 147
 148 class MainThreadSyncRunnable : public WorkerSyncRunnable
 149 {
 150 public:
 151   MainThreadSyncRunnable(WorkerPrivate* aWorkerPrivate,
 152                          ClearingBehavior aClearingBehavior,
 153                          uint32_t aSyncQueueKey,
 154                          bool aBypassSyncEventQueue)
 155   : WorkerSyncRunnable(aWorkerPrivate, aSyncQueueKey, aBypassSyncEventQueue,
 156                        aClearingBehavior)
 157   {
 158     AssertIsOnMainThread();
 159   }
 160
 161   bool
 162   PreDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate) MOZ_OVERRIDE
 163   {
 164     AssertIsOnMainThread();
 165     return true;
 166   }
 167
 168   void
 169   PostDispatch(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
 170                bool aDispatchResult) MOZ_OVERRIDE
 171   {
 172     AssertIsOnMainThread();
 173   }
 174 };
 175
 176 class WorkerControlRunnable : public WorkerRunnable
 177 {
 178 protected:
 179   WorkerControlRunnable(WorkerPrivate* aWorkerPrivate, Target aTarget,
 180                         BusyBehavior aBusyBehavior)
 181   : WorkerRunnable(aWorkerPrivate, aTarget, aBusyBehavior, SkipWhenClearing)
 182   { }
 183
 184   virtual ~WorkerControlRunnable()
 185   { }
 186
 187   virtual bool
 188   DispatchInternal() MOZ_OVERRIDE;
 189 };
 190
 191 // SharedMutex is a small wrapper around an (internal) reference-counted Mutex
 192 // object. It exists to avoid changing a lot of code to use Mutex* instead of
 193 // Mutex&.
 194 class SharedMutex
 195 {
 196   typedef mozilla::Mutex Mutex;
 197
 198   class RefCountedMutex : public Mutex
 199   {
 200   public:
 201     RefCountedMutex(const char* aName)
 202     : Mutex(aName)
 203     { }
 204
 205     NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RefCountedMutex)
 206
 207   private:
 208     ~RefCountedMutex()
 209     { }
 210   };
 211
 212   nsRefPtr<RefCountedMutex> mMutex;
 213
 214 public:
 215   SharedMutex(const char* aName)
 216   : mMutex(new RefCountedMutex(aName))
 217   { }
 218
 219   SharedMutex(SharedMutex& aOther)
 220   : mMutex(aOther.mMutex)
 221   { }
 222
 223   operator Mutex&()
 224   {
 225     MOZ_ASSERT(mMutex);
 226     return *mMutex;
 227   }
 228
 229   operator const Mutex&() const
 230   {
 231     MOZ_ASSERT(mMutex);
 232     return *mMutex;
 233   }
 234
 235   void
 236   AssertCurrentThreadOwns() const
 237   {
 238     MOZ_ASSERT(mMutex);
 239     mMutex->AssertCurrentThreadOwns();
 240   }
 241 };
 242
 243 template <class Derived>
 244 class WorkerPrivateParent : public nsDOMEventTargetHelper
 245 {
 246   class SynchronizeAndResumeRunnable;
 247
 248 public:
 249   struct LocationInfo
 250   {
 251     nsCString mHref;
 252     nsCString mProtocol;
 253     nsCString mHost;
 254     nsCString mHostname;
 255     nsCString mPort;
 256     nsCString mPathname;
 257     nsCString mSearch;
 258     nsCString mHash;
 259   };
 260
 261   struct LoadInfo
 262   {
 263     // All of these should be released in ForgetMainThreadObjects.
 264     nsCOMPtr<nsIURI> mBaseURI;
 265     nsCOMPtr<nsIURI> mResolvedScriptURI;
 266     nsCOMPtr<nsIPrincipal> mPrincipal;
 267     nsCOMPtr<nsIScriptContext> mScriptContext;
 268     nsCOMPtr<nsPIDOMWindow> mWindow;
 269     nsCOMPtr<nsIContentSecurityPolicy> mCSP;
 270     nsCOMPtr<nsIChannel> mChannel;
 271
 272     nsCString mDomain;
 273
 274     bool mEvalAllowed;
 275     bool mReportCSPViolations;
 276     bool mXHRParamsAllowed;
 277     bool mPrincipalIsSystem;
 278
 279     LoadInfo()
 280     : mEvalAllowed(false), mReportCSPViolations(false),
 281       mXHRParamsAllowed(false), mPrincipalIsSystem(false)
 282     { }
 283
 284     void
 285     StealFrom(LoadInfo& aOther)
 286     {
 287       mBaseURI = aOther.mBaseURI.forget();
 288       mResolvedScriptURI = aOther.mResolvedScriptURI.forget();
 289       mPrincipal = aOther.mPrincipal.forget();
 290       mScriptContext = aOther.mScriptContext.forget();
 291       mWindow = aOther.mWindow.forget();
 292       mCSP = aOther.mCSP.forget();
 293       mChannel = aOther.mChannel.forget();
 294       mDomain = aOther.mDomain;
 295       mEvalAllowed = aOther.mEvalAllowed;
 296       mReportCSPViolations = aOther.mReportCSPViolations;
 297       mXHRParamsAllowed = aOther.mXHRParamsAllowed;
 298       mPrincipalIsSystem = aOther.mPrincipalIsSystem;
 299     }
 300   };
 301
 302   enum WorkerType
 303   {
 304     WorkerTypeDedicated,
 305     WorkerTypeShared
 306   };
 307
 308 protected:
 309   typedef mozilla::ErrorResult ErrorResult;
 310
 311   SharedMutex mMutex;
 312   mozilla::CondVar mCondVar;
 313   mozilla::CondVar mMemoryReportCondVar;
 314
 315 private:
 316   WorkerPrivate* mParent;
 317   nsString mScriptURL;
 318   nsString mSharedWorkerName;
 319   LocationInfo mLocationInfo;
 320   // The lifetime of these objects within LoadInfo is managed explicitly;
 321   // they do not need to be cycle collected.
 322   LoadInfo mLoadInfo;
 323
 324   // Only used for top level workers.
 325   nsTArray<nsRefPtr<WorkerRunnable> > mQueuedRunnables;
 326   nsRevocableEventPtr<SynchronizeAndResumeRunnable> mSynchronizeRunnable;
 327
 328   // Only for ChromeWorkers without window and only touched on the main thread.
 329   nsTArray<nsCString> mHostObjectURIs;
 330
 331   // Protected by mMutex.
 332   JSSettings mJSSettings;
 333
 334   // Only touched on the parent thread (currently this is always the main
 335   // thread as SharedWorkers are always top-level).
 336   nsDataHashtable<nsUint64HashKey, SharedWorker*> mSharedWorkers;
 337
 338   uint64_t mBusyCount;
 339   uint64_t mMessagePortSerial;
 340   Status mParentStatus;
 341   bool mRooted;
 342   bool mParentSuspended;
 343   bool mIsChromeWorker;
 344   bool mMainThreadObjectsForgotten;
 345   WorkerType mWorkerType;
 346
 347 protected:
 348   WorkerPrivateParent(JSContext* aCx, WorkerPrivate* aParent,
 349                       const nsAString& aScriptURL, bool aIsChromeWorker,
 350                       WorkerType aWorkerType,
 351                       const nsAString& aSharedWorkerName, LoadInfo& aLoadInfo);
 352
 353   ~WorkerPrivateParent();
 354
 355 private:
 356   Derived*
 357   ParentAsWorkerPrivate() const
 358   {
 359     return static_cast<Derived*>(const_cast<WorkerPrivateParent*>(this));
 360   }
 361
 362   // aCx is null when called from the finalizer
 363   bool
 364   NotifyPrivate(JSContext* aCx, Status aStatus);
 365
 366   // aCx is null when called from the finalizer
 367   bool
 368   TerminatePrivate(JSContext* aCx)
 369   {
 370     return NotifyPrivate(aCx, Terminating);
 371   }
 372
 373   void
 374   PostMessageInternal(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 375                       const Optional<Sequence<JS::Value> >& aTransferable,
 376                       bool aToMessagePort, uint64_t aMessagePortSerial,
 377                       ErrorResult& aRv);
 378
 379 public:
 380
 381   virtual JSObject*
 382   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope) MOZ_OVERRIDE;
 383
 384   NS_DECL_ISUPPORTS_INHERITED
 385   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WorkerPrivateParent,
 386                                                          nsDOMEventTargetHelper)
 387
 388   // May be called on any thread...
 389   bool
 390   Start();
 391
 392   // Called on the parent thread.
 393   bool
 394   Notify(JSContext* aCx, Status aStatus)
 395   {
 396     return NotifyPrivate(aCx, aStatus);
 397   }
 398
 399   bool
 400   Cancel(JSContext* aCx)
 401   {
 402     return Notify(aCx, Canceling);
 403   }
 404
 405   bool
 406   Kill(JSContext* aCx)
 407   {
 408     return Notify(aCx, Killing);
 409   }
 410
 411   bool
 412   Suspend(JSContext* aCx, nsPIDOMWindow* aWindow);
 413
 414   bool
 415   Resume(JSContext* aCx, nsPIDOMWindow* aWindow);
 416
 417   bool
 418   SynchronizeAndResume(JSContext* aCx, nsPIDOMWindow* aWindow,
 419                        nsIScriptContext* aScriptContext);
 420
 421   void
 422   _finalize(JSFreeOp* aFop);
 423
 424   void
 425   Finish(JSContext* aCx)
 426   {
 427     Root(false);
 428   }
 429
 430   bool
 431   Terminate(JSContext* aCx)
 432   {
 433     AssertIsOnParentThread();
 434     Root(false);
 435     return TerminatePrivate(aCx);
 436   }
 437
 438   bool
 439   Close(JSContext* aCx);
 440
 441   bool
 442   ModifyBusyCount(JSContext* aCx, bool aIncrease);
 443
 444   void
 445   Root(bool aRoot);
 446
 447   void
 448   ForgetMainThreadObjects(nsTArray<nsCOMPtr<nsISupports> >& aDoomed);
 449
 450   void
 451   PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 452               const Optional<Sequence<JS::Value> >& aTransferable,
 453               ErrorResult& aRv)
 454   {
 455     PostMessageInternal(aCx, aMessage, aTransferable, false, 0, aRv);
 456   }
 457
 458   void
 459   PostMessageToMessagePort(JSContext* aCx,
 460                            uint64_t aMessagePortSerial,
 461                            JS::Handle<JS::Value> aMessage,
 462                            const Optional<Sequence<JS::Value> >& aTransferable,
 463                            ErrorResult& aRv);
 464
 465   bool
 466   DispatchMessageEventToMessagePort(
 467                                JSContext* aCx,
 468                                uint64_t aMessagePortSerial,
 469                                JSAutoStructuredCloneBuffer& aBuffer,
 470                                nsTArray<nsCOMPtr<nsISupports>>& aClonedObjects);
 471
 472   uint64_t
 473   GetInnerWindowId();
 474
 475   void
 476   UpdateJSContextOptions(JSContext* aCx, const JS::ContextOptions& aChromeOptions,
 477                          const JS::ContextOptions& aContentOptions);
 478
 479   void
 480   UpdatePreference(JSContext* aCx, WorkerPreference aPref, bool aValue);
 481
 482   void
 483   UpdateJSWorkerMemoryParameter(JSContext* aCx, JSGCParamKey key,
 484                                 uint32_t value);
 485
 486 #ifdef JS_GC_ZEAL
 487   void
 488   UpdateGCZeal(JSContext* aCx, uint8_t aGCZeal, uint32_t aFrequency);
 489 #endif
 490
 491   void
 492   UpdateJITHardening(JSContext* aCx, bool aJITHardening);
 493
 494   void
 495   GarbageCollect(JSContext* aCx, bool aShrinking);
 496
 497   void
 498   CycleCollect(JSContext* aCx, bool aDummy);
 499
 500   bool
 501   RegisterSharedWorker(JSContext* aCx, SharedWorker* aSharedWorker);
 502
 503   void
 504   UnregisterSharedWorker(JSContext* aCx, SharedWorker* aSharedWorker);
 505
 506   void
 507   BroadcastErrorToSharedWorkers(JSContext* aCx,
 508                                 const nsAString& aMessage,
 509                                 const nsAString& aFilename,
 510                                 const nsAString& aLine,
 511                                 uint32_t aLineNumber,
 512                                 uint32_t aColumnNumber,
 513                                 uint32_t aFlags);
 514
 515   void
 516   WorkerScriptLoaded();
 517
 518   void
 519   QueueRunnable(WorkerRunnable* aRunnable)
 520   {
 521     AssertIsOnMainThread();
 522     mQueuedRunnables.AppendElement(aRunnable);
 523   }
 524
 525   WorkerPrivate*
 526   GetParent() const
 527   {
 528     return mParent;
 529   }
 530
 531   bool
 532   IsSuspended() const
 533   {
 534     AssertIsOnParentThread();
 535     return mParentSuspended;
 536   }
 537
 538   bool
 539   IsAcceptingEvents()
 540   {
 541     AssertIsOnParentThread();
 542     bool acceptingEvents;
 543     {
 544       mozilla::MutexAutoLock lock(mMutex);
 545       acceptingEvents = mParentStatus < Terminating;
 546     }
 547     return acceptingEvents;
 548   }
 549
 550   Status
 551   ParentStatus() const
 552   {
 553     mMutex.AssertCurrentThreadOwns();
 554     return mParentStatus;
 555   }
 556
 557   JSContext*
 558   ParentJSContext() const;
 559
 560   nsIScriptContext*
 561   GetScriptContext() const
 562   {
 563     AssertIsOnMainThread();
 564     return mLoadInfo.mScriptContext;
 565   }
 566
 567   const nsString&
 568   ScriptURL() const
 569   {
 570     return mScriptURL;
 571   }
 572
 573   const nsCString&
 574   Domain() const
 575   {
 576     return mLoadInfo.mDomain;
 577   }
 578
 579   nsIURI*
 580   GetBaseURI() const
 581   {
 582     AssertIsOnMainThread();
 583     return mLoadInfo.mBaseURI;
 584   }
 585
 586   void
 587   SetBaseURI(nsIURI* aBaseURI);
 588
 589   nsIURI*
 590   GetResolvedScriptURI() const
 591   {
 592     AssertIsOnMainThread();
 593     return mLoadInfo.mResolvedScriptURI;
 594   }
 595
 596   nsIPrincipal*
 597   GetPrincipal() const
 598   {
 599     AssertIsOnMainThread();
 600     return mLoadInfo.mPrincipal;
 601   }
 602
 603   void
 604   SetPrincipal(nsIPrincipal* aPrincipal);
 605
 606   bool
 607   UsesSystemPrincipal() const
 608   {
 609     return mLoadInfo.mPrincipalIsSystem;
 610   }
 611
 612   already_AddRefed<nsIChannel>
 613   ForgetWorkerChannel()
 614   {
 615     AssertIsOnMainThread();
 616     return mLoadInfo.mChannel.forget();
 617   }
 618
 619   nsIDocument*
 620   GetDocument() const
 621   {
 622     AssertIsOnMainThread();
 623     return mLoadInfo.mWindow ? mLoadInfo.mWindow->GetExtantDoc() : nullptr;
 624   }
 625
 626   nsPIDOMWindow*
 627   GetWindow()
 628   {
 629     AssertIsOnMainThread();
 630     return mLoadInfo.mWindow;
 631   }
 632
 633   nsIContentSecurityPolicy*
 634   GetCSP() const
 635   {
 636     AssertIsOnMainThread();
 637     return mLoadInfo.mCSP;
 638   }
 639
 640   void
 641   SetCSP(nsIContentSecurityPolicy* aCSP)
 642   {
 643     AssertIsOnMainThread();
 644     mLoadInfo.mCSP = aCSP;
 645   }
 646
 647   bool
 648   IsEvalAllowed() const
 649   {
 650     return mLoadInfo.mEvalAllowed;
 651   }
 652
 653   void
 654   SetEvalAllowed(bool aEvalAllowed)
 655   {
 656     mLoadInfo.mEvalAllowed = aEvalAllowed;
 657   }
 658
 659   bool
 660   GetReportCSPViolations() const
 661   {
 662     return mLoadInfo.mReportCSPViolations;
 663   }
 664
 665   bool
 666   XHRParamsAllowed() const
 667   {
 668     return mLoadInfo.mXHRParamsAllowed;
 669   }
 670
 671   void
 672   SetXHRParamsAllowed(bool aAllowed)
 673   {
 674     mLoadInfo.mXHRParamsAllowed = aAllowed;
 675   }
 676
 677   LocationInfo&
 678   GetLocationInfo()
 679   {
 680     return mLocationInfo;
 681   }
 682
 683   void
 684   CopyJSSettings(JSSettings& aSettings)
 685   {
 686     mozilla::MutexAutoLock lock(mMutex);
 687     aSettings = mJSSettings;
 688   }
 689
 690   // The ability to be a chrome worker is orthogonal to the type of
 691   // worker [Dedicated|Shared].
 692   bool
 693   IsChromeWorker() const
 694   {
 695     return mIsChromeWorker;
 696   }
 697
 698   bool
 699   IsDedicatedWorker() const
 700   {
 701     return mWorkerType == WorkerTypeDedicated;
 702   }
 703
 704   bool
 705   IsSharedWorker() const
 706   {
 707     return mWorkerType == WorkerTypeShared;
 708   }
 709
 710   const nsString&
 711   SharedWorkerName() const
 712   {
 713     return mSharedWorkerName;
 714   }
 715
 716   uint64_t
 717   NextMessagePortSerial()
 718   {
 719     AssertIsOnMainThread();
 720     return mMessagePortSerial++;
 721   }
 722
 723   void
 724   GetAllSharedWorkers(nsTArray<nsRefPtr<SharedWorker>>& aSharedWorkers);
 725
 726   void
 727   CloseSharedWorkersForWindow(nsPIDOMWindow* aWindow);
 728
 729   void
 730   RegisterHostObjectURI(const nsACString& aURI);
 731
 732   void
 733   UnregisterHostObjectURI(const nsACString& aURI);
 734
 735   void
 736   StealHostObjectURIs(nsTArray<nsCString>& aArray);
 737
 738   IMPL_EVENT_HANDLER(message)
 739   IMPL_EVENT_HANDLER(error)
 740
 741 #ifdef DEBUG
 742   void
 743   AssertIsOnParentThread() const;
 744
 745   void
 746   AssertInnerWindowIsCorrect() const;
 747 #else
 748   void
 749   AssertIsOnParentThread() const
 750   { }
 751
 752   void
 753   AssertInnerWindowIsCorrect() const
 754   { }
 755 #endif
 756 };
 757
 758 class WorkerPrivate : public WorkerPrivateParent<WorkerPrivate>
 759 {
 760   friend class WorkerPrivateParent<WorkerPrivate>;
 761   typedef WorkerPrivateParent<WorkerPrivate> ParentType;
 762
 763   struct TimeoutInfo;
 764
 765   typedef Queue<WorkerRunnable*, 50> EventQueue;
 766   EventQueue mQueue;
 767   EventQueue mControlQueue;
 768
 769   struct SyncQueue
 770   {
 771     Queue<WorkerRunnable*, 10> mQueue;
 772     bool mComplete;
 773     bool mResult;
 774
 775     SyncQueue()
 776     : mComplete(false), mResult(false)
 777     { }
 778
 779     ~SyncQueue()
 780     {
 781       WorkerRunnable* event;
 782       while (mQueue.Pop(event)) {
 783         event->Release();
 784       }
 785     }
 786   };
 787
 788   class MemoryReporter;
 789   friend class MemoryReporter;
 790
 791   nsTArray<nsAutoPtr<SyncQueue> > mSyncQueues;
 792
 793   // Touched on multiple threads, protected with mMutex.
 794   JSContext* mJSContext;
 795   nsRefPtr<WorkerCrossThreadDispatcher> mCrossThreadDispatcher;
 796
 797   // Things touched on worker thread only.
 798   nsRefPtr<WorkerGlobalScope> mScope;
 799   nsTArray<ParentType*> mChildWorkers;
 800   nsTArray<WorkerFeature*> mFeatures;
 801   nsTArray<nsAutoPtr<TimeoutInfo> > mTimeouts;
 802
 803   nsCOMPtr<nsITimer> mTimer;
 804   nsRefPtr<MemoryReporter> mMemoryReporter;
 805
 806   nsRefPtrHashtable<nsUint64HashKey, MessagePort> mWorkerPorts;
 807
 808   mozilla::TimeStamp mKillTime;
 809   uint32_t mErrorHandlerRecursionCount;
 810   uint32_t mNextTimeoutId;
 811   Status mStatus;
 812   bool mSuspended;
 813   bool mTimerRunning;
 814   bool mRunningExpiredTimeouts;
 815   bool mCloseHandlerStarted;
 816   bool mCloseHandlerFinished;
 817   bool mMemoryReporterRunning;
 818   bool mBlockedForMemoryReporter;
 819
 820 #ifdef DEBUG
 821   nsCOMPtr<nsIThread> mThread;
 822 #endif
 823
 824   bool mPreferences[WORKERPREF_COUNT];
 825
 826 protected:
 827   ~WorkerPrivate();
 828
 829 public:
 830   static already_AddRefed<WorkerPrivate>
 831   Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL,
 832               ErrorResult& aRv);
 833
 834   static already_AddRefed<WorkerPrivate>
 835   Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL,
 836               bool aIsChromeWorker, WorkerType aWorkerType,
 837               const nsAString& aSharedWorkerName,
 838               LoadInfo* aLoadInfo, ErrorResult& aRv);
 839
 840   static bool
 841   WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */);
 842
 843   static nsresult
 844   GetLoadInfo(JSContext* aCx, nsPIDOMWindow* aWindow, WorkerPrivate* aParent,
 845               const nsAString& aScriptURL, bool aIsChromeWorker,
 846               LoadInfo* aLoadInfo);
 847
 848   void
 849   DoRunLoop(JSContext* aCx);
 850
 851   bool
 852   OperationCallback(JSContext* aCx);
 853
 854   bool
 855   Dispatch(WorkerRunnable* aEvent)
 856   {
 857     return Dispatch(aEvent, &mQueue);
 858   }
 859
 860   bool
 861   Dispatch(WorkerSyncRunnable* aEvent)
 862   {
 863     if (aEvent->mBypassSyncQueue) {
 864       return Dispatch(aEvent, &mQueue);
 865     }
 866
 867     return DispatchToSyncQueue(aEvent);
 868   }
 869
 870   bool
 871   Dispatch(WorkerControlRunnable* aEvent)
 872   {
 873     return Dispatch(aEvent, &mControlQueue);
 874   }
 875
 876   bool
 877   CloseInternal(JSContext* aCx)
 878   {
 879     AssertIsOnWorkerThread();
 880     return NotifyInternal(aCx, Closing);
 881   }
 882
 883   bool
 884   SuspendInternal(JSContext* aCx);
 885
 886   bool
 887   ResumeInternal(JSContext* aCx);
 888
 889   void
 890   TraceTimeouts(const TraceCallbacks& aCallbacks, void* aClosure) const;
 891
 892   bool
 893   ModifyBusyCountFromWorker(JSContext* aCx, bool aIncrease);
 894
 895   bool
 896   AddChildWorker(JSContext* aCx, ParentType* aChildWorker);
 897
 898   void
 899   RemoveChildWorker(JSContext* aCx, ParentType* aChildWorker);
 900
 901   bool
 902   AddFeature(JSContext* aCx, WorkerFeature* aFeature);
 903
 904   void
 905   RemoveFeature(JSContext* aCx, WorkerFeature* aFeature);
 906
 907   void
 908   NotifyFeatures(JSContext* aCx, Status aStatus);
 909
 910   bool
 911   HasActiveFeatures()
 912   {
 913     return !(mChildWorkers.IsEmpty() && mTimeouts.IsEmpty() &&
 914              mFeatures.IsEmpty());
 915   }
 916
 917   uint32_t
 918   CreateNewSyncLoop();
 919
 920   bool
 921   RunSyncLoop(JSContext* aCx, uint32_t aSyncLoopKey);
 922
 923   void
 924   StopSyncLoop(uint32_t aSyncLoopKey, bool aSyncResult);
 925
 926   void
 927   DestroySyncLoop(uint32_t aSyncLoopKey);
 928
 929   void
 930   PostMessageToParent(JSContext* aCx,
 931                       JS::Handle<JS::Value> aMessage,
 932                       const Optional<Sequence<JS::Value>>& aTransferable,
 933                       ErrorResult& aRv)
 934   {
 935     PostMessageToParentInternal(aCx, aMessage, aTransferable, false, 0, aRv);
 936   }
 937
 938   void
 939   PostMessageToParentMessagePort(
 940                              JSContext* aCx,
 941                              uint64_t aMessagePortSerial,
 942                              JS::Handle<JS::Value> aMessage,
 943                              const Optional<Sequence<JS::Value>>& aTransferable,
 944                              ErrorResult& aRv);
 945
 946   bool
 947   NotifyInternal(JSContext* aCx, Status aStatus);
 948
 949   void
 950   ReportError(JSContext* aCx, const char* aMessage, JSErrorReport* aReport);
 951
 952   int32_t
 953   SetTimeout(JSContext* aCx,
 954              Function* aHandler,
 955              const nsAString& aStringHandler,
 956              int32_t aTimeout,
 957              const Sequence<JS::Value>& aArguments,
 958              bool aIsInterval,
 959              ErrorResult& aRv);
 960
 961   void
 962   ClearTimeout(int32_t aId);
 963
 964   bool
 965   RunExpiredTimeouts(JSContext* aCx);
 966
 967   bool
 968   RescheduleTimeoutTimer(JSContext* aCx);
 969
 970   void
 971   CloseHandlerStarted()
 972   {
 973     AssertIsOnWorkerThread();
 974     mCloseHandlerStarted = true;
 975   }
 976
 977   void
 978   CloseHandlerFinished()
 979   {
 980     AssertIsOnWorkerThread();
 981     mCloseHandlerFinished = true;
 982   }
 983
 984   void
 985   UpdateJSContextOptionsInternal(JSContext* aCx, const JS::ContextOptions& aContentOptions,
 986                                  const JS::ContextOptions& aChromeOptions);
 987
 988   void
 989   UpdatePreferenceInternal(JSContext* aCx, WorkerPreference aPref, bool aValue);
 990
 991   void
 992   UpdateJSWorkerMemoryParameterInternal(JSContext* aCx, JSGCParamKey key, uint32_t aValue);
 993
 994   void
 995   ScheduleDeletion(bool aWasPending);
 996
 997   bool
 998   BlockAndCollectRuntimeStats(JS::RuntimeStats* aRtStats);
 999
1000 #ifdef JS_GC_ZEAL
1001   void
1002   UpdateGCZealInternal(JSContext* aCx, uint8_t aGCZeal, uint32_t aFrequency);
1003 #endif
1004
1005   void
1006   UpdateJITHardeningInternal(JSContext* aCx, bool aJITHardening);
1007
1008   void
1009   GarbageCollectInternal(JSContext* aCx, bool aShrinking,
1010                          bool aCollectChildren);
1011
1012   void
1013   CycleCollectInternal(JSContext* aCx, bool aCollectChildren);
1014
1015   JSContext*
1016   GetJSContext() const
1017   {
1018     AssertIsOnWorkerThread();
1019     return mJSContext;
1020   }
1021
1022   WorkerGlobalScope*
1023   GlobalScope() const
1024   {
1025     AssertIsOnWorkerThread();
1026     return mScope;
1027   }
1028
1029 #ifdef DEBUG
1030   void
1031   AssertIsOnWorkerThread() const;
1032
1033   void
1034   SetThread(nsIThread* aThread)
1035   {
1036     mThread = aThread;
1037   }
1038 #else
1039   void
1040   AssertIsOnWorkerThread() const
1041   { }
1042 #endif
1043
1044   WorkerCrossThreadDispatcher*
1045   GetCrossThreadDispatcher();
1046
1047   // This may block!
1048   void
1049   BeginCTypesCall();
1050
1051   // This may block!
1052   void
1053   EndCTypesCall();
1054
1055   void
1056   BeginCTypesCallback()
1057   {
1058     // If a callback is beginning then we need to do the exact same thing as
1059     // when a ctypes call ends.
1060     EndCTypesCall();
1061   }
1062
1063   void
1064   EndCTypesCallback()
1065   {
1066     // If a callback is ending then we need to do the exact same thing as
1067     // when a ctypes call begins.
1068     BeginCTypesCall();
1069   }
1070
1071   bool
1072   ConnectMessagePort(JSContext* aCx, uint64_t aMessagePortSerial);
1073
1074   void
1075   DisconnectMessagePort(uint64_t aMessagePortSerial);
1076
1077   MessagePort*
1078   GetMessagePort(uint64_t aMessagePortSerial);
1079
1080   JSObject*
1081   CreateGlobalScope(JSContext* aCx);
1082
1083   bool
1084   RegisterBindings(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
1085
1086   bool
1087   DumpEnabled() const
1088   {
1089     AssertIsOnWorkerThread();
1090     return mPreferences[WORKERPREF_DUMP];
1091   }
1092
1093   bool
1094   PromiseEnabled() const
1095   {
1096     AssertIsOnWorkerThread();
1097     return mPreferences[WORKERPREF_PROMISE];
1098   }
1099
1100 private:
1101   WorkerPrivate(JSContext* aCx, WorkerPrivate* aParent,
1102                 const nsAString& aScriptURL, bool aIsChromeWorker,
1103                 WorkerType aWorkerType, const nsAString& aSharedWorkerName,
1104                 LoadInfo& aLoadInfo);
1105
1106   bool
1107   Dispatch(WorkerRunnable* aEvent, EventQueue* aQueue);
1108
1109   bool
1110   DispatchToSyncQueue(WorkerSyncRunnable* aEvent);
1111
1112   void
1113   ClearQueue(EventQueue* aQueue);
1114
1115   bool
1116   MayContinueRunning()
1117   {
1118     AssertIsOnWorkerThread();
1119
1120     Status status;
1121     {
1122       mozilla::MutexAutoLock lock(mMutex);
1123       status = mStatus;
1124     }
1125
1126     if (status >= Killing) {
1127       return false;
1128     }
1129     if (status >= Running) {
1130       return mKillTime.IsNull() || RemainingRunTimeMS() > 0;
1131     }
1132     return true;
1133   }
1134
1135   uint32_t
1136   RemainingRunTimeMS() const;
1137
1138   void
1139   CancelAllTimeouts(JSContext* aCx);
1140
1141   bool
1142   ScheduleKillCloseEventRunnable(JSContext* aCx);
1143
1144   void
1145   StopAcceptingEvents()
1146   {
1147     AssertIsOnWorkerThread();
1148
1149     mozilla::MutexAutoLock lock(mMutex);
1150
1151     mStatus = Dead;
1152     mJSContext = nullptr;
1153
1154     ClearQueue(&mControlQueue);
1155     ClearQueue(&mQueue);
1156   }
1157
1158   bool
1159   ProcessAllControlRunnables();
1160
1161   void
1162   EnableMemoryReporter();
1163
1164   void
1165   DisableMemoryReporter();
1166
1167   void
1168   WaitForWorkerEvents(PRIntervalTime interval = PR_INTERVAL_NO_TIMEOUT);
1169
1170   void
1171   PostMessageToParentInternal(JSContext* aCx,
1172                               JS::Handle<JS::Value> aMessage,
1173                               const Optional<Sequence<JS::Value>>& aTransferable,
1174                               bool aToMessagePort,
1175                               uint64_t aMessagePortSerial,
1176                               ErrorResult& aRv);
1177
1178   void
1179   GetAllPreferences(bool aPreferences[WORKERPREF_COUNT]) const
1180   {
1181     AssertIsOnWorkerThread();
1182     memcpy(aPreferences, mPreferences, WORKERPREF_COUNT * sizeof(bool));
1183   }
1184 };
1185
1186 // This class is only used to trick the DOM bindings.  We never create
1187 // instances of it, and static_casting to it is fine since it doesn't add
1188 // anything to WorkerPrivate.
1189 class ChromeWorkerPrivate : public WorkerPrivate
1190 {
1191 public:
1192   static already_AddRefed<ChromeWorkerPrivate>
1193   Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL,
1194               ErrorResult& rv);
1195
1196   static bool
1197   WorkerAvailable(JSContext* /* unused */, JSObject* /* unused */);
1198
1199 private:
1200   ChromeWorkerPrivate() MOZ_DELETE;
1201   ChromeWorkerPrivate(const ChromeWorkerPrivate& aRHS) MOZ_DELETE;
1202   ChromeWorkerPrivate& operator =(const ChromeWorkerPrivate& aRHS) MOZ_DELETE;
1203 };
1204
1205 WorkerPrivate*
1206 GetWorkerPrivateFromContext(JSContext* aCx);
1207
1208 WorkerPrivate*
1209 GetCurrentThreadWorkerPrivate();
1210
1211 bool
1212 IsCurrentThreadRunningChromeWorker();
1213
1214 JSContext*
1215 GetCurrentThreadJSContext();
1216
1217 enum WorkerStructuredDataType
1218 {
1219   DOMWORKER_SCTAG_FILE = SCTAG_DOM_MAX,
1220   DOMWORKER_SCTAG_BLOB,
1221
1222   DOMWORKER_SCTAG_END
1223 };
1224
1225 JSStructuredCloneCallbacks*
1226 WorkerStructuredCloneCallbacks(bool aMainRuntime);
1227
1228 JSStructuredCloneCallbacks*
1229 ChromeWorkerStructuredCloneCallbacks(bool aMainRuntime);
1230
1231 class AutoSyncLoopHolder
1232 {
1233 public:
1234   AutoSyncLoopHolder(WorkerPrivate* aWorkerPrivate)
1235   : mWorkerPrivate(aWorkerPrivate), mSyncLoopKey(UINT32_MAX)
1236   {
1237     mSyncLoopKey = mWorkerPrivate->CreateNewSyncLoop();
1238   }
1239
1240   ~AutoSyncLoopHolder()
1241   {
1242     if (mWorkerPrivate) {
1243       mWorkerPrivate->StopSyncLoop(mSyncLoopKey, false);
1244       mWorkerPrivate->DestroySyncLoop(mSyncLoopKey);
1245     }
1246   }
1247
1248   bool
1249   RunAndForget(JSContext* aCx)
1250   {
1251     WorkerPrivate* workerPrivate = mWorkerPrivate;
1252     mWorkerPrivate = nullptr;
1253     return workerPrivate->RunSyncLoop(aCx, mSyncLoopKey);
1254   }
1255
1256   uint32_t
1257   SyncQueueKey() const
1258   {
1259     return mSyncLoopKey;
1260   }
1261
1262 private:
1263   WorkerPrivate* mWorkerPrivate;
1264   uint32_t mSyncLoopKey;
1265 };
1266
1267 END_WORKERS_NAMESPACE
1268
1269 #endif /* mozilla_dom_workers_workerprivate_h__ */