dom/ipc/ProcessHangMonitor.cpp

   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 #include "mozilla/ProcessHangMonitor.h"
   8 #include "mozilla/ProcessHangMonitorIPC.h"
   9
  10 #include "jsapi.h"
  11 #include "xpcprivate.h"
  12
  13 #include "mozilla/Atomics.h"
  14 #include "mozilla/BackgroundHangMonitor.h"
  15 #include "mozilla/BasePrincipal.h"
  16 #include "mozilla/dom/CancelContentJSOptionsBinding.h"
  17 #include "mozilla/dom/CanonicalBrowsingContext.h"
  18 #include "mozilla/dom/ContentParent.h"
  19 #include "mozilla/dom/Document.h"
  20 #include "mozilla/dom/Element.h"
  21 #include "mozilla/dom/ScriptSettings.h"
  22 #include "mozilla/dom/BrowserChild.h"
  23 #include "mozilla/dom/BrowserParent.h"
  24 #include "mozilla/ipc/Endpoint.h"
  25 #include "mozilla/ipc/ProcessChild.h"
  26 #include "mozilla/ipc/TaskFactory.h"
  27 #include "mozilla/Monitor.h"
  28 #include "mozilla/Preferences.h"
  29 #include "mozilla/StaticMonitor.h"
  30 #include "mozilla/StaticPrefs_browser.h"
  31 #include "mozilla/StaticPrefs_dom.h"
  32 #include "mozilla/StaticPtr.h"
  33 #include "mozilla/Unused.h"
  34 #include "mozilla/WeakPtr.h"
  35
  36 #include "MainThreadUtils.h"
  37 #include "nsExceptionHandler.h"
  38 #include "nsFrameLoader.h"
  39 #include "nsIHangReport.h"
  40 #include "nsIRemoteTab.h"
  41 #include "nsNetUtil.h"
  42 #include "nsQueryObject.h"
  43 #include "nsThreadUtils.h"
  44
  45 #include "base/task.h"
  46 #include "base/thread.h"
  47
  48 #ifdef XP_WIN
  49 // For IsDebuggerPresent()
  50 #  include <windows.h>
  51 #endif
  52
  53 #ifdef XP_MACOSX
  54 // for qos controls
  55 #  include <sys/qos.h>
  56 #endif
  57
  58 using namespace mozilla;
  59 using namespace mozilla::dom;
  60 using namespace mozilla::ipc;
  61
  62 /*
  63  * Basic architecture:
  64  *
  65  * Each process has its own ProcessHangMonitor singleton. This singleton exists
  66  * as long as there is at least one content process in the system. Each content
  67  * process has a HangMonitorChild and the chrome process has one
  68  * HangMonitorParent per process. Each process (including the chrome process)
  69  * runs a hang monitoring thread. The PHangMonitor actors are bound to this
  70  * thread so that they never block on the main thread.
  71  *
  72  * When the content process detects a hang, it posts a task to its hang thread,
  73  * which sends an IPC message to the hang thread in the parent. The parent
  74  * cancels any ongoing CPOW requests and then posts a runnable to the main
  75  * thread that notifies Firefox frontend code of the hang. The frontend code is
  76  * passed an nsIHangReport, which can be used to terminate the hang.
  77  *
  78  * If the user chooses to terminate a script, a task is posted to the chrome
  79  * process's hang monitoring thread, which sends an IPC message to the hang
  80  * thread in the content process. That thread sets a flag to indicate that JS
  81  * execution should be terminated the next time it hits the interrupt
  82  * callback. A similar scheme is used for debugging slow scripts. If a content
  83  * process or plug-in needs to be terminated, the chrome process does so
  84  * directly, without messaging the content process.
  85  */
  86
  87 namespace {
  88
  89 /* Child process objects */
  90
  91 class HangMonitorChild : public PProcessHangMonitorChild,
  92                          public BackgroundHangAnnotator {
  93  public:
  94   NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(
  95       HangMonitorChild, override)
  96
  97   void Bind(Endpoint<PProcessHangMonitorChild>&& aEndpoint);
  98
  99   using SlowScriptAction = ProcessHangMonitor::SlowScriptAction;
 100   SlowScriptAction NotifySlowScript(nsIBrowserChild* aBrowserChild,
 101                                     const char* aFileName,
 102                                     const nsString& aAddonId,
 103                                     const double aDuration);
 104   void NotifySlowScriptAsync(TabId aTabId, const nsCString& aFileName,
 105                              const nsString& aAddonId, const double aDuration);
 106
 107   bool IsDebuggerStartupComplete();
 108
 109   void ClearHang();
 110   void ClearHangAsync();
 111   void ClearPaintWhileInterruptingJS();
 112
 113   // MaybeStartPaintWhileInterruptingJS will notify the background hang monitor
 114   // of activity if this is the first time calling it since
 115   // ClearPaintWhileInterruptingJS. It should be callable from any thread, but
 116   // you must be holding mMonitor if using it off the main thread, since it
 117   // could race with ClearPaintWhileInterruptingJS.
 118   void MaybeStartPaintWhileInterruptingJS();
 119
 120   mozilla::ipc::IPCResult RecvTerminateScript() override;
 121   mozilla::ipc::IPCResult RecvRequestContentJSInterrupt() override;
 122   mozilla::ipc::IPCResult RecvBeginStartingDebugger() override;
 123   mozilla::ipc::IPCResult RecvEndStartingDebugger() override;
 124
 125   mozilla::ipc::IPCResult RecvPaintWhileInterruptingJS(
 126       const TabId& aTabId) override;
 127
 128   mozilla::ipc::IPCResult RecvUnloadLayersWhileInterruptingJS(
 129       const TabId& aTabId) override;
 130
 131   mozilla::ipc::IPCResult RecvCancelContentJSExecutionIfRunning(
 132       const TabId& aTabId, const nsIRemoteTab::NavigationType& aNavigationType,
 133       const int32_t& aNavigationIndex,
 134       const mozilla::Maybe<nsCString>& aNavigationURI,
 135       const int32_t& aEpoch) override;
 136
 137   mozilla::ipc::IPCResult RecvSetMainThreadQoSPriority(
 138       const nsIThread::QoSPriority& aQoSPriority) override;
 139
 140   void ActorDestroy(ActorDestroyReason aWhy) override;
 141
 142   bool InterruptCallback();
 143   void Shutdown();
 144
 145   static HangMonitorChild* Get() MOZ_REQUIRES(sMainThreadCapability) {
 146     return sInstance;
 147   }
 148
 149   static void CreateAndBind(ProcessHangMonitor* aMonitor,
 150                             Endpoint<PProcessHangMonitorChild>&& aEndpoint);
 151
 152   void Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
 153     mHangMonitor->Dispatch(std::move(aRunnable));
 154   }
 155   bool IsOnThread() { return mHangMonitor->IsOnThread(); }
 156
 157   void AnnotateHang(BackgroundHangAnnotations& aAnnotations) override;
 158
 159  protected:
 160   friend class mozilla::ProcessHangMonitor;
 161
 162  private:
 163   explicit HangMonitorChild(ProcessHangMonitor* aMonitor);
 164   ~HangMonitorChild() override;
 165
 166   void ShutdownOnThread();
 167
 168   static StaticRefPtr<HangMonitorChild> sInstance
 169       MOZ_GUARDED_BY(sMainThreadCapability);
 170
 171   const RefPtr<ProcessHangMonitor> mHangMonitor;
 172
 173 #ifdef XP_MACOSX
 174   // On macOS, the pthread_t is required to start a QoS class override. As we
 175   // can't recover this from a PRThread*, we need to record it when the
 176   // HangMonitorChild is initially created on the main thread.
 177   const pthread_t mMainPThread;
 178 #endif
 179
 180   Monitor mMonitor;
 181
 182   // Main thread-only.
 183   bool mSentReport;
 184
 185   // These fields must be accessed with mMonitor held.
 186   bool mTerminateScript MOZ_GUARDED_BY(mMonitor);
 187   bool mStartDebugger MOZ_GUARDED_BY(mMonitor);
 188   bool mFinishedStartingDebugger MOZ_GUARDED_BY(mMonitor);
 189
 190   // this variable is used to paint/unload layers
 191   // if not set, no action required
 192   // true means, we will paint. false - unload layers
 193   Maybe<bool> mPaintWhileInterruptingJS MOZ_GUARDED_BY(mMonitor);
 194   TabId mPaintWhileInterruptingJSTab MOZ_GUARDED_BY(mMonitor);
 195   bool mCancelContentJS MOZ_GUARDED_BY(mMonitor);
 196   TabId mCancelContentJSTab MOZ_GUARDED_BY(mMonitor);
 197   nsIRemoteTab::NavigationType mCancelContentJSNavigationType
 198       MOZ_GUARDED_BY(mMonitor);
 199   int32_t mCancelContentJSNavigationIndex MOZ_GUARDED_BY(mMonitor);
 200   mozilla::Maybe<nsCString> mCancelContentJSNavigationURI
 201       MOZ_GUARDED_BY(mMonitor);
 202   int32_t mCancelContentJSEpoch MOZ_GUARDED_BY(mMonitor);
 203   bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
 204
 205   JSContext* mContext;  // const after constructor
 206
 207   // This field is only accessed on the hang thread.
 208   bool mIPCOpen;
 209
 210   // Allows us to ensure we NotifyActivity only once, allowing
 211   // either thread to do so.
 212   Atomic<bool> mPaintWhileInterruptingJSActive;
 213 };
 214
 215 StaticRefPtr<HangMonitorChild> HangMonitorChild::sInstance;
 216
 217 /* Parent process objects */
 218
 219 class HangMonitorParent;
 220
 221 class HangMonitoredProcess final : public nsIHangReport {
 222  public:
 223   NS_DECL_THREADSAFE_ISUPPORTS
 224
 225   HangMonitoredProcess(HangMonitorParent* aActor, ContentParent* aContentParent)
 226       : mActor(aActor), mContentParent(aContentParent) {}
 227
 228   NS_DECL_NSIHANGREPORT
 229
 230   // Called when a content process shuts down.
 231   void Clear() {
 232     mContentParent = nullptr;
 233     mActor = nullptr;
 234   }
 235
 236   /**
 237    * Sets the information associated with this hang: this includes the tab ID,
 238    * filename, duration, and an add-on ID if it was caused by an add-on.
 239    *
 240    * @param aDumpId The ID of a minidump taken when the hang occurred
 241    */
 242   void SetSlowScriptData(const SlowScriptData& aSlowScriptData,
 243                          const nsAString& aDumpId) {
 244     mSlowScriptData = aSlowScriptData;
 245     mDumpId = aDumpId;
 246   }
 247
 248   void ClearHang() {
 249     mSlowScriptData = SlowScriptData();
 250     mDumpId.Truncate();
 251   }
 252
 253  private:
 254   ~HangMonitoredProcess() = default;
 255
 256   // Everything here is main thread-only.
 257   HangMonitorParent* mActor;
 258   ContentParent* mContentParent;
 259   SlowScriptData mSlowScriptData;
 260   nsAutoString mDumpId;
 261 };
 262
 263 class HangMonitorParent : public PProcessHangMonitorParent {
 264  public:
 265   NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(
 266       HangMonitorParent, override)
 267
 268   explicit HangMonitorParent(ProcessHangMonitor* aMonitor);
 269
 270   void Bind(Endpoint<PProcessHangMonitorParent>&& aEndpoint);
 271
 272   mozilla::ipc::IPCResult RecvHangEvidence(
 273       const SlowScriptData& aSlowScriptData) override;
 274   mozilla::ipc::IPCResult RecvClearHang() override;
 275
 276   void ActorDestroy(ActorDestroyReason aWhy) override;
 277
 278   void SetProcess(HangMonitoredProcess* aProcess) { mProcess = aProcess; }
 279
 280   void Shutdown();
 281
 282   void PaintWhileInterruptingJS(dom::BrowserParent* aTab);
 283
 284   void UnloadLayersWhileInterruptingJS(dom::BrowserParent* aTab);
 285   void CancelContentJSExecutionIfRunning(
 286       dom::BrowserParent* aBrowserParent,
 287       nsIRemoteTab::NavigationType aNavigationType,
 288       const dom::CancelContentJSOptions& aCancelContentJSOptions);
 289
 290   void SetMainThreadQoSPriority(nsIThread::QoSPriority aQoSPriority);
 291
 292   void TerminateScript();
 293   void BeginStartingDebugger();
 294   void EndStartingDebugger();
 295
 296   nsresult Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
 297     return mHangMonitor->Dispatch(std::move(aRunnable));
 298   }
 299   bool IsOnThread() { return mHangMonitor->IsOnThread(); }
 300
 301  private:
 302   ~HangMonitorParent() override = default;
 303
 304   void SendHangNotification(const SlowScriptData& aSlowScriptData,
 305                             const nsString& aBrowserDumpId);
 306
 307   void ClearHangNotification();
 308
 309   void PaintOrUnloadLayersWhileInterruptingJSOnThread(bool aPaint,
 310                                                       TabId aTabId);
 311   void CancelContentJSExecutionIfRunningOnThread(
 312       TabId aTabId, nsIRemoteTab::NavigationType aNavigationType,
 313       int32_t aNavigationIndex, nsIURI* aNavigationURI, int32_t aEpoch);
 314
 315 #ifdef XP_MACOSX
 316   void SetMainThreadQoSPriorityOnThread(nsIThread::QoSPriority aQoSPriority);
 317 #endif
 318
 319   void ShutdownOnThread();
 320
 321   const RefPtr<ProcessHangMonitor> mHangMonitor;
 322
 323   // This field is only accessed on the hang thread.
 324   bool mIPCOpen;
 325
 326   Monitor mMonitor;
 327
 328   // MainThread only
 329   RefPtr<HangMonitoredProcess> mProcess;
 330
 331   // Must be accessed with mMonitor held.
 332   bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
 333   mozilla::ipc::TaskFactory<HangMonitorParent> mMainThreadTaskFactory
 334       MOZ_GUARDED_BY(mMonitor);
 335 };
 336
 337 }  // namespace
 338
 339 /* HangMonitorChild implementation */
 340
 341 HangMonitorChild::HangMonitorChild(ProcessHangMonitor* aMonitor)
 342     : mHangMonitor(aMonitor),
 343 #ifdef XP_MACOSX
 344       mMainPThread(pthread_self()),
 345 #endif
 346       mMonitor("HangMonitorChild lock"),
 347       mSentReport(false),
 348       mTerminateScript(false),
 349       mStartDebugger(false),
 350       mFinishedStartingDebugger(false),
 351       mCancelContentJS(false),
 352       mCancelContentJSNavigationType(nsIRemoteTab::NAVIGATE_BACK),
 353       mCancelContentJSNavigationIndex(0),
 354       mCancelContentJSEpoch(0),
 355       mShutdownDone(false),
 356       mIPCOpen(true),
 357       mPaintWhileInterruptingJSActive(false) {
 358   ReleaseAssertIsOnMainThread();
 359   MOZ_ASSERT(!sInstance);
 360
 361   mContext = danger::GetJSContext();
 362 }
 363
 364 HangMonitorChild::~HangMonitorChild() {
 365   ReleaseAssertIsOnMainThread();
 366   MOZ_ASSERT(sInstance != this);
 367 }
 368
 369 void HangMonitorChild::CreateAndBind(
 370     ProcessHangMonitor* aMonitor,
 371     Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
 372   ReleaseAssertIsOnMainThread();
 373   MOZ_ASSERT(!sInstance);
 374
 375   sInstance = new HangMonitorChild(aMonitor);
 376
 377   BackgroundHangMonitor::RegisterAnnotator(*sInstance);
 378
 379   aMonitor->Dispatch(NewRunnableMethod<Endpoint<PProcessHangMonitorChild>&&>(
 380       "HangMonitorChild::Bind", sInstance.get(), &HangMonitorChild::Bind,
 381       std::move(aEndpoint)));
 382 }
 383
 384 bool HangMonitorChild::InterruptCallback() {
 385   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 386
 387   if (StaticPrefs::dom_abort_script_on_child_shutdown() &&
 388       mozilla::ipc::ProcessChild::ExpectingShutdown()) {
 389     // We preserve chrome JS from cancel, but not extension content JS.
 390     if (!nsContentUtils::IsCallerChrome()) {
 391       NS_WARNING(
 392           "HangMonitorChild::InterruptCallback: ExpectingShutdown, "
 393           "canceling content JS execution.\n");
 394       return false;
 395     }
 396     return true;
 397   }
 398
 399   // Don't start painting if we're not in a good place to run script. We run
 400   // chrome script during layout and such, and it wouldn't be good to interrupt
 401   // painting code from there.
 402   if (!nsContentUtils::IsSafeToRunScript()) {
 403     return true;
 404   }
 405
 406   Maybe<bool> paintWhileInterruptingJS;
 407   TabId paintWhileInterruptingJSTab;
 408
 409   {
 410     MonitorAutoLock lock(mMonitor);
 411     paintWhileInterruptingJS = mPaintWhileInterruptingJS;
 412     paintWhileInterruptingJSTab = mPaintWhileInterruptingJSTab;
 413
 414     mPaintWhileInterruptingJS.reset();
 415   }
 416
 417   if (paintWhileInterruptingJS.isSome()) {
 418     RefPtr<BrowserChild> browserChild =
 419         BrowserChild::FindBrowserChild(paintWhileInterruptingJSTab);
 420     if (browserChild) {
 421       js::AutoAssertNoContentJS nojs(mContext);
 422       if (paintWhileInterruptingJS.value()) {
 423         browserChild->PaintWhileInterruptingJS();
 424       } else {
 425         browserChild->UnloadLayersWhileInterruptingJS();
 426       }
 427     }
 428   }
 429
 430   // Only handle the interrupt for cancelling content JS if we have a
 431   // non-privileged script (i.e. not part of Gecko or an add-on).
 432   JS::Rooted<JSObject*> global(mContext, JS::CurrentGlobalOrNull(mContext));
 433   nsIPrincipal* principal = xpc::GetObjectPrincipal(global);
 434   if (principal && (principal->IsSystemPrincipal() ||
 435                     principal->GetIsAddonOrExpandedAddonPrincipal())) {
 436     return true;
 437   }
 438
 439   nsCOMPtr<nsPIDOMWindowInner> win = xpc::WindowOrNull(global);
 440   if (!win) {
 441     return true;
 442   }
 443
 444   bool cancelContentJS;
 445   TabId cancelContentJSTab;
 446   nsIRemoteTab::NavigationType cancelContentJSNavigationType;
 447   int32_t cancelContentJSNavigationIndex;
 448   mozilla::Maybe<nsCString> cancelContentJSNavigationURI;
 449   int32_t cancelContentJSEpoch;
 450
 451   {
 452     MonitorAutoLock lock(mMonitor);
 453     cancelContentJS = mCancelContentJS;
 454     cancelContentJSTab = mCancelContentJSTab;
 455     cancelContentJSNavigationType = mCancelContentJSNavigationType;
 456     cancelContentJSNavigationIndex = mCancelContentJSNavigationIndex;
 457     cancelContentJSNavigationURI = std::move(mCancelContentJSNavigationURI);
 458     cancelContentJSEpoch = mCancelContentJSEpoch;
 459
 460     mCancelContentJS = false;
 461   }
 462
 463   if (cancelContentJS) {
 464     js::AutoAssertNoContentJS nojs(mContext);
 465
 466     RefPtr<BrowserChild> browserChild =
 467         BrowserChild::FindBrowserChild(cancelContentJSTab);
 468     RefPtr<BrowserChild> browserChildFromWin = BrowserChild::GetFrom(win);
 469     if (!browserChild || !browserChildFromWin) {
 470       return true;
 471     }
 472
 473     TabId tabIdFromWin = browserChildFromWin->GetTabId();
 474     if (tabIdFromWin != cancelContentJSTab) {
 475       // The currently-executing content JS doesn't belong to the tab that
 476       // requested cancellation of JS. Just return and let the JS continue.
 477       return true;
 478     }
 479
 480     nsresult rv;
 481     nsCOMPtr<nsIURI> uri;
 482
 483     if (cancelContentJSNavigationURI) {
 484       rv = NS_NewURI(getter_AddRefs(uri), cancelContentJSNavigationURI.value());
 485       if (NS_FAILED(rv)) {
 486         return true;
 487       }
 488     }
 489
 490     bool canCancel;
 491     rv = browserChild->CanCancelContentJS(cancelContentJSNavigationType,
 492                                           cancelContentJSNavigationIndex, uri,
 493                                           cancelContentJSEpoch, &canCancel);
 494     if (NS_SUCCEEDED(rv) && canCancel) {
 495       // Don't add this page to the BF cache, since we're cancelling its JS.
 496       if (Document* doc = win->GetExtantDoc()) {
 497         doc->DisallowBFCaching();
 498       }
 499
 500       return false;
 501     }
 502   }
 503
 504   return true;
 505 }
 506
 507 void HangMonitorChild::AnnotateHang(BackgroundHangAnnotations& aAnnotations) {
 508   if (mPaintWhileInterruptingJSActive) {
 509     aAnnotations.AddAnnotation(u"PaintWhileInterruptingJS"_ns, true);
 510   }
 511 }
 512
 513 void HangMonitorChild::Shutdown() {
 514   ReleaseAssertIsOnMainThread();
 515
 516   BackgroundHangMonitor::UnregisterAnnotator(*this);
 517
 518   {
 519     MonitorAutoLock lock(mMonitor);
 520     while (!mShutdownDone) {
 521       mMonitor.Wait();
 522     }
 523   }
 524
 525   MOZ_ASSERT(sInstance == this);
 526   sInstance = nullptr;
 527 }
 528
 529 void HangMonitorChild::ShutdownOnThread() {
 530   MOZ_RELEASE_ASSERT(IsOnThread());
 531
 532   MonitorAutoLock lock(mMonitor);
 533   mShutdownDone = true;
 534   mMonitor.Notify();
 535 }
 536
 537 void HangMonitorChild::ActorDestroy(ActorDestroyReason aWhy) {
 538   MOZ_RELEASE_ASSERT(IsOnThread());
 539
 540   mIPCOpen = false;
 541
 542   // We use a task here to ensure that IPDL is finished with this
 543   // HangMonitorChild before it gets deleted on the main thread.
 544   Dispatch(NewNonOwningRunnableMethod("HangMonitorChild::ShutdownOnThread",
 545                                       this,
 546                                       &HangMonitorChild::ShutdownOnThread));
 547 }
 548
 549 mozilla::ipc::IPCResult HangMonitorChild::RecvTerminateScript() {
 550   MOZ_RELEASE_ASSERT(IsOnThread());
 551
 552   MonitorAutoLock lock(mMonitor);
 553   mTerminateScript = true;
 554   return IPC_OK();
 555 }
 556
 557 mozilla::ipc::IPCResult HangMonitorChild::RecvRequestContentJSInterrupt() {
 558   MOZ_RELEASE_ASSERT(IsOnThread());
 559
 560   // In order to cancel JS execution on shutdown, we expect that
 561   // ProcessChild::NotifiedImpendingShutdown has been called before.
 562   if (mozilla::ipc::ProcessChild::ExpectingShutdown()) {
 563     CrashReporter::AppendToCrashReportAnnotation(
 564         CrashReporter::Annotation::IPCShutdownState,
 565         "HangMonitorChild::RecvRequestContentJSInterrupt (expected)"_ns);
 566   } else {
 567     CrashReporter::AppendToCrashReportAnnotation(
 568         CrashReporter::Annotation::IPCShutdownState,
 569         "HangMonitorChild::RecvRequestContentJSInterrupt (unexpected)"_ns);
 570   }
 571   JS_RequestInterruptCallback(mContext);
 572   return IPC_OK();
 573 }
 574
 575 mozilla::ipc::IPCResult HangMonitorChild::RecvBeginStartingDebugger() {
 576   MOZ_RELEASE_ASSERT(IsOnThread());
 577
 578   MonitorAutoLock lock(mMonitor);
 579   mStartDebugger = true;
 580   return IPC_OK();
 581 }
 582
 583 mozilla::ipc::IPCResult HangMonitorChild::RecvEndStartingDebugger() {
 584   MOZ_RELEASE_ASSERT(IsOnThread());
 585
 586   MonitorAutoLock lock(mMonitor);
 587   mFinishedStartingDebugger = true;
 588   return IPC_OK();
 589 }
 590
 591 mozilla::ipc::IPCResult HangMonitorChild::RecvPaintWhileInterruptingJS(
 592     const TabId& aTabId) {
 593   MOZ_RELEASE_ASSERT(IsOnThread());
 594
 595   {
 596     MonitorAutoLock lock(mMonitor);
 597     MaybeStartPaintWhileInterruptingJS();
 598     mPaintWhileInterruptingJS = Some(true);
 599     mPaintWhileInterruptingJSTab = aTabId;
 600   }
 601
 602   JS_RequestInterruptCallback(mContext);
 603
 604   return IPC_OK();
 605 }
 606
 607 mozilla::ipc::IPCResult HangMonitorChild::RecvUnloadLayersWhileInterruptingJS(
 608     const TabId& aTabId) {
 609   MOZ_RELEASE_ASSERT(IsOnThread());
 610
 611   {
 612     MonitorAutoLock lock(mMonitor);
 613     MaybeStartPaintWhileInterruptingJS();
 614     mPaintWhileInterruptingJS = Some(false);
 615     mPaintWhileInterruptingJSTab = aTabId;
 616   }
 617
 618   JS_RequestInterruptCallback(mContext);
 619
 620   return IPC_OK();
 621 }
 622
 623 void HangMonitorChild::MaybeStartPaintWhileInterruptingJS() {
 624   mPaintWhileInterruptingJSActive = true;
 625 }
 626
 627 void HangMonitorChild::ClearPaintWhileInterruptingJS() {
 628   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 629   MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
 630   mPaintWhileInterruptingJSActive = false;
 631 }
 632
 633 mozilla::ipc::IPCResult HangMonitorChild::RecvCancelContentJSExecutionIfRunning(
 634     const TabId& aTabId, const nsIRemoteTab::NavigationType& aNavigationType,
 635     const int32_t& aNavigationIndex,
 636     const mozilla::Maybe<nsCString>& aNavigationURI, const int32_t& aEpoch) {
 637   MOZ_RELEASE_ASSERT(IsOnThread());
 638
 639   {
 640     MonitorAutoLock lock(mMonitor);
 641     mCancelContentJS = true;
 642     mCancelContentJSTab = aTabId;
 643     mCancelContentJSNavigationType = aNavigationType;
 644     mCancelContentJSNavigationIndex = aNavigationIndex;
 645     mCancelContentJSNavigationURI = aNavigationURI;
 646     mCancelContentJSEpoch = aEpoch;
 647   }
 648
 649   JS_RequestInterruptCallback(mContext);
 650
 651   return IPC_OK();
 652 }
 653
 654 mozilla::ipc::IPCResult HangMonitorChild::RecvSetMainThreadQoSPriority(
 655     const nsIThread::QoSPriority& aQoSPriority) {
 656   MOZ_RELEASE_ASSERT(IsOnThread());
 657
 658 #ifdef XP_MACOSX
 659   // If the new priority is the background (low) priority, we can tell the OS to
 660   // put the main thread on low-power cores. Alternately, if we are changing
 661   // from the background to a higher priority, we change the main thread back to
 662   // the |user-interactive| state, defined in MacOS's QoS documentation as
 663   // reserved for main threads.
 664   qos_class_t qosClass = aQoSPriority == nsIThread::QOS_PRIORITY_LOW
 665                              ? QOS_CLASS_BACKGROUND
 666                              : QOS_CLASS_USER_INTERACTIVE;
 667
 668   // We can't directly set the main thread's QoS class from off-main-thread.
 669   // However, we can start a QoS class override to raise the QoS, then dispatch
 670   // a runnable to set the QoS class and clear the override once complete.
 671   pthread_override_t qosOverride =
 672       pthread_override_qos_class_start_np(mMainPThread, qosClass, 0);
 673   if (NS_FAILED(NS_DispatchToMainThread(NS_NewRunnableFunction(
 674           "HangMonitorChild::RecvSetMainThreadQoSPriority",
 675           [qosClass, qosOverride] {
 676             pthread_set_qos_class_self_np(qosClass, 0);
 677             if (qosOverride) {
 678               pthread_override_qos_class_end_np(qosOverride);
 679             }
 680           })))) {
 681     // If we fail to dispatch, go ahead and end the override anyway.
 682     pthread_override_qos_class_end_np(qosOverride);
 683   }
 684 #endif
 685
 686   return IPC_OK();
 687 }
 688
 689 void HangMonitorChild::Bind(Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
 690   MOZ_RELEASE_ASSERT(IsOnThread());
 691
 692   DebugOnly<bool> ok = aEndpoint.Bind(this);
 693   MOZ_ASSERT(ok);
 694 }
 695
 696 void HangMonitorChild::NotifySlowScriptAsync(TabId aTabId,
 697                                              const nsCString& aFileName,
 698                                              const nsString& aAddonId,
 699                                              const double aDuration) {
 700   if (mIPCOpen) {
 701     Unused << SendHangEvidence(
 702         SlowScriptData(aTabId, aFileName, aAddonId, aDuration));
 703   }
 704 }
 705
 706 HangMonitorChild::SlowScriptAction HangMonitorChild::NotifySlowScript(
 707     nsIBrowserChild* aBrowserChild, const char* aFileName,
 708     const nsString& aAddonId, const double aDuration) {
 709   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 710
 711   mSentReport = true;
 712
 713   {
 714     MonitorAutoLock lock(mMonitor);
 715
 716     if (mTerminateScript) {
 717       mTerminateScript = false;
 718       return SlowScriptAction::Terminate;
 719     }
 720
 721     if (mStartDebugger) {
 722       mStartDebugger = false;
 723       return SlowScriptAction::StartDebugger;
 724     }
 725   }
 726
 727   TabId id;
 728   if (aBrowserChild) {
 729     RefPtr<BrowserChild> browserChild =
 730         static_cast<BrowserChild*>(aBrowserChild);
 731     id = browserChild->GetTabId();
 732   }
 733   nsAutoCString filename(aFileName);
 734
 735   Dispatch(NewNonOwningRunnableMethod<TabId, nsCString, nsString, double>(
 736       "HangMonitorChild::NotifySlowScriptAsync", this,
 737       &HangMonitorChild::NotifySlowScriptAsync, id, filename, aAddonId,
 738       aDuration));
 739   return SlowScriptAction::Continue;
 740 }
 741
 742 bool HangMonitorChild::IsDebuggerStartupComplete() {
 743   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 744
 745   MonitorAutoLock lock(mMonitor);
 746
 747   if (mFinishedStartingDebugger) {
 748     mFinishedStartingDebugger = false;
 749     return true;
 750   }
 751
 752   return false;
 753 }
 754
 755 void HangMonitorChild::ClearHang() {
 756   MOZ_ASSERT(NS_IsMainThread());
 757
 758   if (mSentReport) {
 759     // bounce to background thread
 760     Dispatch(NewNonOwningRunnableMethod("HangMonitorChild::ClearHangAsync",
 761                                         this,
 762                                         &HangMonitorChild::ClearHangAsync));
 763
 764     MonitorAutoLock lock(mMonitor);
 765     mSentReport = false;
 766     mTerminateScript = false;
 767     mStartDebugger = false;
 768     mFinishedStartingDebugger = false;
 769   }
 770 }
 771
 772 void HangMonitorChild::ClearHangAsync() {
 773   MOZ_RELEASE_ASSERT(IsOnThread());
 774
 775   // bounce back to parent on background thread
 776   if (mIPCOpen) {
 777     Unused << SendClearHang();
 778   }
 779 }
 780
 781 /* HangMonitorParent implementation */
 782
 783 HangMonitorParent::HangMonitorParent(ProcessHangMonitor* aMonitor)
 784     : mHangMonitor(aMonitor),
 785       mIPCOpen(true),
 786       mMonitor("HangMonitorParent lock"),
 787       mShutdownDone(false),
 788       mMainThreadTaskFactory(this) {
 789   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 790 }
 791
 792 void HangMonitorParent::Shutdown() {
 793   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 794
 795   MonitorAutoLock lock(mMonitor);
 796
 797   if (mProcess) {
 798     mProcess->Clear();
 799     mProcess = nullptr;
 800   }
 801
 802   nsresult rv = Dispatch(
 803       NewNonOwningRunnableMethod("HangMonitorParent::ShutdownOnThread", this,
 804                                  &HangMonitorParent::ShutdownOnThread));
 805   if (NS_WARN_IF(NS_FAILED(rv))) {
 806     return;
 807   }
 808
 809   while (!mShutdownDone) {
 810     mMonitor.Wait();
 811   }
 812 }
 813
 814 void HangMonitorParent::ShutdownOnThread() {
 815   MOZ_RELEASE_ASSERT(IsOnThread());
 816
 817   // mIPCOpen is only written from this thread, so need need to take the lock
 818   // here. We'd be shooting ourselves in the foot, because ActorDestroy takes
 819   // it.
 820   if (mIPCOpen) {
 821     Close();
 822   }
 823
 824   MonitorAutoLock lock(mMonitor);
 825   mShutdownDone = true;
 826   mMonitor.Notify();
 827 }
 828
 829 void HangMonitorParent::PaintWhileInterruptingJS(dom::BrowserParent* aTab) {
 830   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 831   if (StaticPrefs::browser_tabs_remote_force_paint()) {
 832     TabId id = aTab->GetTabId();
 833     Dispatch(NewNonOwningRunnableMethod<bool, TabId>(
 834         "HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread ",
 835         this,
 836         &HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread,
 837         true, id));
 838   }
 839 }
 840
 841 void HangMonitorParent::UnloadLayersWhileInterruptingJS(
 842     dom::BrowserParent* aTab) {
 843   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 844   TabId id = aTab->GetTabId();
 845   Dispatch(NewNonOwningRunnableMethod<bool, TabId>(
 846       "HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread ",
 847       this, &HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread,
 848       false, id));
 849 }
 850
 851 void HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread(
 852     const bool aPaint, TabId aTabId) {
 853   MOZ_RELEASE_ASSERT(IsOnThread());
 854
 855   if (mIPCOpen) {
 856     if (aPaint) {
 857       Unused << SendPaintWhileInterruptingJS(aTabId);
 858     } else {
 859       Unused << SendUnloadLayersWhileInterruptingJS(aTabId);
 860     }
 861   }
 862 }
 863
 864 void HangMonitorParent::CancelContentJSExecutionIfRunning(
 865     dom::BrowserParent* aBrowserParent,
 866     nsIRemoteTab::NavigationType aNavigationType,
 867     const dom::CancelContentJSOptions& aCancelContentJSOptions) {
 868   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 869
 870   if (!aBrowserParent->CanCancelContentJS(aNavigationType,
 871                                           aCancelContentJSOptions.mIndex,
 872                                           aCancelContentJSOptions.mUri)) {
 873     return;
 874   }
 875
 876   TabId id = aBrowserParent->GetTabId();
 877   Dispatch(NewNonOwningRunnableMethod<TabId, nsIRemoteTab::NavigationType,
 878                                       int32_t, nsIURI*, int32_t>(
 879       "HangMonitorParent::CancelContentJSExecutionIfRunningOnThread", this,
 880       &HangMonitorParent::CancelContentJSExecutionIfRunningOnThread, id,
 881       aNavigationType, aCancelContentJSOptions.mIndex,
 882       aCancelContentJSOptions.mUri, aCancelContentJSOptions.mEpoch));
 883 }
 884
 885 void HangMonitorParent::CancelContentJSExecutionIfRunningOnThread(
 886     TabId aTabId, nsIRemoteTab::NavigationType aNavigationType,
 887     int32_t aNavigationIndex, nsIURI* aNavigationURI, int32_t aEpoch) {
 888   MOZ_RELEASE_ASSERT(IsOnThread());
 889
 890   mozilla::Maybe<nsCString> spec;
 891   if (aNavigationURI) {
 892     nsAutoCString tmp;
 893     nsresult rv = aNavigationURI->GetSpec(tmp);
 894     if (NS_SUCCEEDED(rv)) {
 895       spec.emplace(tmp);
 896     }
 897   }
 898
 899   if (mIPCOpen) {
 900     Unused << SendCancelContentJSExecutionIfRunning(
 901         aTabId, aNavigationType, aNavigationIndex, spec, aEpoch);
 902   }
 903 }
 904
 905 void HangMonitorParent::SetMainThreadQoSPriority(
 906     nsIThread::QoSPriority aQoSPriority) {
 907   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 908 #ifdef XP_MACOSX  // Should not be using outside of MacOS.
 909
 910   Dispatch(NewNonOwningRunnableMethod<nsIThread::QoSPriority>(
 911       "HangMonitorParent::SetMainThreadQoSPriorityOnThread", this,
 912       &HangMonitorParent::SetMainThreadQoSPriorityOnThread, aQoSPriority));
 913 #endif
 914 }
 915
 916 #ifdef XP_MACOSX
 917 void HangMonitorParent::SetMainThreadQoSPriorityOnThread(
 918     nsIThread::QoSPriority aQoSPriority) {
 919   MOZ_RELEASE_ASSERT(IsOnThread());
 920   if (mIPCOpen) {
 921     Unused << SendSetMainThreadQoSPriority(aQoSPriority);
 922   }
 923 }
 924 #endif
 925
 926 void HangMonitorParent::ActorDestroy(ActorDestroyReason aWhy) {
 927   MOZ_RELEASE_ASSERT(IsOnThread());
 928   mIPCOpen = false;
 929 }
 930
 931 void HangMonitorParent::Bind(Endpoint<PProcessHangMonitorParent>&& aEndpoint) {
 932   MOZ_RELEASE_ASSERT(IsOnThread());
 933
 934   DebugOnly<bool> ok = aEndpoint.Bind(this);
 935   MOZ_ASSERT(ok);
 936 }
 937
 938 void HangMonitorParent::SendHangNotification(
 939     const SlowScriptData& aSlowScriptData, const nsString& aBrowserDumpId) {
 940   // chrome process, main thread
 941   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 942
 943   nsString dumpId;
 944
 945   // We already have a full minidump; go ahead and use it.
 946   dumpId = aBrowserDumpId;
 947
 948   mProcess->SetSlowScriptData(aSlowScriptData, dumpId);
 949
 950   nsCOMPtr<nsIObserverService> observerService =
 951       mozilla::services::GetObserverService();
 952   observerService->NotifyObservers(mProcess, "process-hang-report", nullptr);
 953 }
 954
 955 void HangMonitorParent::ClearHangNotification() {
 956   // chrome process, main thread
 957   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 958
 959   nsCOMPtr<nsIObserverService> observerService =
 960       mozilla::services::GetObserverService();
 961   observerService->NotifyObservers(mProcess, "clear-hang-report", nullptr);
 962
 963   mProcess->ClearHang();
 964 }
 965
 966 mozilla::ipc::IPCResult HangMonitorParent::RecvHangEvidence(
 967     const SlowScriptData& aSlowScriptData) {
 968   // chrome process, background thread
 969   MOZ_RELEASE_ASSERT(IsOnThread());
 970
 971   if (!StaticPrefs::dom_ipc_reportProcessHangs()) {
 972     return IPC_OK();
 973   }
 974
 975 #ifdef XP_WIN
 976   // Don't report hangs if we're debugging the process. You can comment this
 977   // line out for testing purposes.
 978   if (IsDebuggerPresent()) {
 979     return IPC_OK();
 980   }
 981 #endif
 982
 983   // Before we wake up the browser main thread we want to take a
 984   // browser minidump.
 985   nsAutoString crashId;
 986
 987   mHangMonitor->InitiateCPOWTimeout();
 988
 989   MonitorAutoLock lock(mMonitor);
 990
 991   NS_DispatchToMainThread(mMainThreadTaskFactory.NewRunnableMethod(
 992       &HangMonitorParent::SendHangNotification, aSlowScriptData, crashId));
 993
 994   return IPC_OK();
 995 }
 996
 997 mozilla::ipc::IPCResult HangMonitorParent::RecvClearHang() {
 998   // chrome process, background thread
 999   MOZ_RELEASE_ASSERT(IsOnThread());
1000
1001   if (!StaticPrefs::dom_ipc_reportProcessHangs()) {
1002     return IPC_OK();
1003   }
1004
1005   mHangMonitor->InitiateCPOWTimeout();
1006
1007   MonitorAutoLock lock(mMonitor);
1008
1009   NS_DispatchToMainThread(mMainThreadTaskFactory.NewRunnableMethod(
1010       &HangMonitorParent::ClearHangNotification));
1011
1012   return IPC_OK();
1013 }
1014
1015 void HangMonitorParent::TerminateScript() {
1016   MOZ_RELEASE_ASSERT(IsOnThread());
1017
1018   if (mIPCOpen) {
1019     Unused << SendTerminateScript();
1020   }
1021 }
1022
1023 void HangMonitorParent::BeginStartingDebugger() {
1024   MOZ_RELEASE_ASSERT(IsOnThread());
1025
1026   if (mIPCOpen) {
1027     Unused << SendBeginStartingDebugger();
1028   }
1029 }
1030
1031 void HangMonitorParent::EndStartingDebugger() {
1032   MOZ_RELEASE_ASSERT(IsOnThread());
1033
1034   if (mIPCOpen) {
1035     Unused << SendEndStartingDebugger();
1036   }
1037 }
1038
1039 /* HangMonitoredProcess implementation */
1040
1041 NS_IMPL_ISUPPORTS(HangMonitoredProcess, nsIHangReport)
1042
1043 NS_IMETHODIMP
1044 HangMonitoredProcess::GetHangDuration(double* aHangDuration) {
1045   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1046   *aHangDuration = mSlowScriptData.duration();
1047   return NS_OK;
1048 }
1049
1050 NS_IMETHODIMP
1051 HangMonitoredProcess::GetScriptBrowser(Element** aBrowser) {
1052   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1053   TabId tabId = mSlowScriptData.tabId();
1054   if (!mContentParent) {
1055     return NS_ERROR_NOT_AVAILABLE;
1056   }
1057
1058   nsTArray<PBrowserParent*> tabs;
1059   mContentParent->ManagedPBrowserParent(tabs);
1060   for (size_t i = 0; i < tabs.Length(); i++) {
1061     BrowserParent* tp = BrowserParent::GetFrom(tabs[i]);
1062     if (tp->GetTabId() == tabId) {
1063       RefPtr<Element> node = tp->GetOwnerElement();
1064       node.forget(aBrowser);
1065       return NS_OK;
1066     }
1067   }
1068
1069   *aBrowser = nullptr;
1070   return NS_OK;
1071 }
1072
1073 NS_IMETHODIMP
1074 HangMonitoredProcess::GetScriptFileName(nsACString& aFileName) {
1075   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1076   aFileName = mSlowScriptData.filename();
1077   return NS_OK;
1078 }
1079
1080 NS_IMETHODIMP
1081 HangMonitoredProcess::GetAddonId(nsAString& aAddonId) {
1082   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1083   aAddonId = mSlowScriptData.addonId();
1084   return NS_OK;
1085 }
1086
1087 NS_IMETHODIMP
1088 HangMonitoredProcess::TerminateScript() {
1089   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1090   if (!mActor) {
1091     return NS_ERROR_UNEXPECTED;
1092   }
1093
1094   ProcessHangMonitor::Get()->Dispatch(
1095       NewNonOwningRunnableMethod("HangMonitorParent::TerminateScript", mActor,
1096                                  &HangMonitorParent::TerminateScript));
1097   return NS_OK;
1098 }
1099
1100 NS_IMETHODIMP
1101 HangMonitoredProcess::BeginStartingDebugger() {
1102   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1103   if (!mActor) {
1104     return NS_ERROR_UNEXPECTED;
1105   }
1106
1107   ProcessHangMonitor::Get()->Dispatch(NewNonOwningRunnableMethod(
1108       "HangMonitorParent::BeginStartingDebugger", mActor,
1109       &HangMonitorParent::BeginStartingDebugger));
1110   return NS_OK;
1111 }
1112
1113 NS_IMETHODIMP
1114 HangMonitoredProcess::EndStartingDebugger() {
1115   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1116   if (!mActor) {
1117     return NS_ERROR_UNEXPECTED;
1118   }
1119
1120   ProcessHangMonitor::Get()->Dispatch(NewNonOwningRunnableMethod(
1121       "HangMonitorParent::EndStartingDebugger", mActor,
1122       &HangMonitorParent::EndStartingDebugger));
1123   return NS_OK;
1124 }
1125
1126 NS_IMETHODIMP
1127 HangMonitoredProcess::IsReportForBrowserOrChildren(nsFrameLoader* aFrameLoader,
1128                                                    bool* aResult) {
1129   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1130   MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
1131
1132   if (!mActor) {
1133     *aResult = false;
1134     return NS_OK;
1135   }
1136
1137   NS_ENSURE_STATE(aFrameLoader);
1138
1139   AutoTArray<RefPtr<BrowsingContext>, 10> bcs;
1140   bcs.AppendElement(aFrameLoader->GetExtantBrowsingContext());
1141   while (!bcs.IsEmpty()) {
1142     RefPtr<BrowsingContext> bc = bcs[bcs.Length() - 1];
1143     bcs.RemoveLastElement();
1144     if (!bc) {
1145       continue;
1146     }
1147     if (mContentParent == bc->Canonical()->GetContentParent()) {
1148       *aResult = true;
1149       return NS_OK;
1150     }
1151     bc->GetChildren(bcs);
1152   }
1153
1154   *aResult = false;
1155   return NS_OK;
1156 }
1157
1158 NS_IMETHODIMP
1159 HangMonitoredProcess::UserCanceled() { return NS_OK; }
1160
1161 NS_IMETHODIMP
1162 HangMonitoredProcess::GetChildID(uint64_t* aChildID) {
1163   if (!mContentParent) {
1164     return NS_ERROR_NOT_AVAILABLE;
1165   }
1166   *aChildID = mContentParent->ChildID();
1167   return NS_OK;
1168 }
1169
1170 static bool InterruptCallback(JSContext* cx) {
1171   AssertIsOnMainThread();
1172   if (HangMonitorChild* child = HangMonitorChild::Get()) {
1173     return child->InterruptCallback();
1174   }
1175
1176   return true;
1177 }
1178
1179 ProcessHangMonitor* ProcessHangMonitor::sInstance;
1180
1181 ProcessHangMonitor::ProcessHangMonitor() : mCPOWTimeout(false) {
1182   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1183
1184   if (XRE_IsContentProcess()) {
1185     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
1186     obs->AddObserver(this, "xpcom-shutdown", false);
1187   }
1188
1189   if (NS_FAILED(NS_NewNamedThread("ProcessHangMon", getter_AddRefs(mThread)))) {
1190     mThread = nullptr;
1191   }
1192 #ifdef XP_MACOSX
1193   // On MacOS, ensure the priority is high enough to handle dispatches at
1194   // high cpu load. USER_INITIATED class threads are prioritized just below
1195   // the main thread.
1196   mThread->Dispatch(NS_NewRunnableFunction(
1197       "ProcessHangMonitor::SetPriority",
1198       [] { pthread_set_qos_class_self_np(QOS_CLASS_USER_INITIATED, 0); }));
1199 #endif
1200 }
1201
1202 ProcessHangMonitor::~ProcessHangMonitor() {
1203   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1204
1205   MOZ_ASSERT(sInstance == this);
1206   sInstance = nullptr;
1207
1208   mThread->Shutdown();
1209   mThread = nullptr;
1210 }
1211
1212 ProcessHangMonitor* ProcessHangMonitor::GetOrCreate() {
1213   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1214   if (!sInstance) {
1215     sInstance = new ProcessHangMonitor();
1216   }
1217   return sInstance;
1218 }
1219
1220 NS_IMPL_ISUPPORTS(ProcessHangMonitor, nsIObserver)
1221
1222 NS_IMETHODIMP
1223 ProcessHangMonitor::Observe(nsISupports* aSubject, const char* aTopic,
1224                             const char16_t* aData) {
1225   ReleaseAssertIsOnMainThread();
1226   if (!strcmp(aTopic, "xpcom-shutdown")) {
1227     if (RefPtr<HangMonitorChild> child = HangMonitorChild::Get()) {
1228       child->Shutdown();
1229     }
1230
1231     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
1232     obs->RemoveObserver(this, "xpcom-shutdown");
1233   }
1234   return NS_OK;
1235 }
1236
1237 ProcessHangMonitor::SlowScriptAction ProcessHangMonitor::NotifySlowScript(
1238     nsIBrowserChild* aBrowserChild, const char* aFileName,
1239     const nsString& aAddonId, const double aDuration) {
1240   ReleaseAssertIsOnMainThread();
1241   return HangMonitorChild::Get()->NotifySlowScript(aBrowserChild, aFileName,
1242                                                    aAddonId, aDuration);
1243 }
1244
1245 bool ProcessHangMonitor::IsDebuggerStartupComplete() {
1246   ReleaseAssertIsOnMainThread();
1247   return HangMonitorChild::Get()->IsDebuggerStartupComplete();
1248 }
1249
1250 bool ProcessHangMonitor::ShouldTimeOutCPOWs() {
1251   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1252
1253   if (mCPOWTimeout) {
1254     mCPOWTimeout = false;
1255     return true;
1256   }
1257   return false;
1258 }
1259
1260 void ProcessHangMonitor::InitiateCPOWTimeout() {
1261   MOZ_RELEASE_ASSERT(IsOnThread());
1262   mCPOWTimeout = true;
1263 }
1264
1265 static already_AddRefed<PProcessHangMonitorParent> CreateHangMonitorParent(
1266     ContentParent* aContentParent,
1267     Endpoint<PProcessHangMonitorParent>&& aEndpoint) {
1268   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1269
1270   ProcessHangMonitor* monitor = ProcessHangMonitor::GetOrCreate();
1271   RefPtr<HangMonitorParent> parent = new HangMonitorParent(monitor);
1272
1273   auto* process = new HangMonitoredProcess(parent, aContentParent);
1274   parent->SetProcess(process);
1275
1276   monitor->Dispatch(
1277       NewNonOwningRunnableMethod<Endpoint<PProcessHangMonitorParent>&&>(
1278           "HangMonitorParent::Bind", parent, &HangMonitorParent::Bind,
1279           std::move(aEndpoint)));
1280
1281   return parent.forget();
1282 }
1283
1284 void mozilla::CreateHangMonitorChild(
1285     Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
1286   ReleaseAssertIsOnMainThread();
1287
1288   JSContext* cx = danger::GetJSContext();
1289   JS_AddInterruptCallback(cx, InterruptCallback);
1290
1291   ProcessHangMonitor* monitor = ProcessHangMonitor::GetOrCreate();
1292   HangMonitorChild::CreateAndBind(monitor, std::move(aEndpoint));
1293 }
1294
1295 nsresult ProcessHangMonitor::Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
1296   return mThread->Dispatch(std::move(aRunnable),
1297                            nsIEventTarget::NS_DISPATCH_NORMAL);
1298 }
1299
1300 bool ProcessHangMonitor::IsOnThread() {
1301   bool on;
1302   return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
1303 }
1304
1305 /* static */
1306 already_AddRefed<PProcessHangMonitorParent> ProcessHangMonitor::AddProcess(
1307     ContentParent* aContentParent) {
1308   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1309
1310   if (!StaticPrefs::dom_ipc_processHangMonitor_AtStartup()) {
1311     return nullptr;
1312   }
1313
1314   Endpoint<PProcessHangMonitorParent> parent;
1315   Endpoint<PProcessHangMonitorChild> child;
1316   nsresult rv;
1317   rv = PProcessHangMonitor::CreateEndpoints(&parent, &child);
1318   if (NS_FAILED(rv)) {
1319     MOZ_ASSERT(false, "PProcessHangMonitor::CreateEndpoints failed");
1320     return nullptr;
1321   }
1322
1323   if (!aContentParent->SendInitProcessHangMonitor(std::move(child))) {
1324     MOZ_ASSERT(false);
1325     return nullptr;
1326   }
1327
1328   return CreateHangMonitorParent(aContentParent, std::move(parent));
1329 }
1330
1331 /* static */
1332 void ProcessHangMonitor::RemoveProcess(PProcessHangMonitorParent* aParent) {
1333   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1334   auto parent = static_cast<HangMonitorParent*>(aParent);
1335   parent->Shutdown();
1336 }
1337
1338 /* static */
1339 void ProcessHangMonitor::ClearHang() {
1340   AssertIsOnMainThread();
1341   if (HangMonitorChild* child = HangMonitorChild::Get()) {
1342     child->ClearHang();
1343   }
1344 }
1345
1346 /* static */
1347 void ProcessHangMonitor::PaintWhileInterruptingJS(
1348     PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab) {
1349   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1350   auto* parent = static_cast<HangMonitorParent*>(aParent);
1351   parent->PaintWhileInterruptingJS(aTab);
1352 }
1353
1354 /* static */
1355 void ProcessHangMonitor::UnloadLayersWhileInterruptingJS(
1356     PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab) {
1357   MOZ_RELEASE_ASSERT(NS_IsMainThread());
1358   auto* parent = static_cast<HangMonitorParent*>(aParent);
1359   parent->UnloadLayersWhileInterruptingJS(aTab);
1360 }
1361
1362 /* static */
1363 void ProcessHangMonitor::ClearPaintWhileInterruptingJS() {
1364   ReleaseAssertIsOnMainThread();
1365   MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
1366
1367   if (HangMonitorChild* child = HangMonitorChild::Get()) {
1368     child->ClearPaintWhileInterruptingJS();
1369   }
1370 }
1371
1372 /* static */
1373 void ProcessHangMonitor::MaybeStartPaintWhileInterruptingJS() {
1374   ReleaseAssertIsOnMainThread();
1375   MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
1376
1377   if (HangMonitorChild* child = HangMonitorChild::Get()) {
1378     child->MaybeStartPaintWhileInterruptingJS();
1379   }
1380 }
1381
1382 /* static */
1383 void ProcessHangMonitor::CancelContentJSExecutionIfRunning(
1384     PProcessHangMonitorParent* aParent, dom::BrowserParent* aBrowserParent,
1385     nsIRemoteTab::NavigationType aNavigationType,
1386     const dom::CancelContentJSOptions& aCancelContentJSOptions) {
1387   ReleaseAssertIsOnMainThread();
1388   auto* parent = static_cast<HangMonitorParent*>(aParent);
1389   parent->CancelContentJSExecutionIfRunning(aBrowserParent, aNavigationType,
1390                                             aCancelContentJSOptions);
1391 }
1392
1393 /* static */
1394 void ProcessHangMonitor::SetMainThreadQoSPriority(
1395     PProcessHangMonitorParent* aParent, nsIThread::QoSPriority aQoSPriority) {
1396   ReleaseAssertIsOnMainThread();
1397   auto* parent = static_cast<HangMonitorParent*>(aParent);
1398   parent->SetMainThreadQoSPriority(aQoSPriority);
1399 }