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