ProcessHangMonitor.jsm
/* -*- mode: js; indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
let Cc = Components.classes;
let Ci = Components.interfaces;
let Cu = Components.utils;
this.EXPORTED_SYMBOLS = ["ProcessHangMonitor"];
Cu.import("resource://gre/modules/Services.jsm");
/**
* This JSM is responsible for observing content process hang reports
* and asking the user what to do about them. See nsIHangReport for
* the platform interface.
*/
/**
* If a hang hasn't been reported for more than 10 seconds, assume the
* content process has gotten unstuck (and hide the hang notification).
*/
const HANG_EXPIRATION_TIME = 10000;
let ProcessHangMonitor = {
/**
* Collection of hang reports that haven't expired or been dismissed
* by the user. The keys are nsIHangReports and values keys are
* timers. Each time the hang is reported, the timer is refreshed so
* it expires after HANG_EXPIRATION_TIME.
*/
_activeReports: new Map(),
/**
* Initialize hang reporting. Called once in the parent process.
*/
init: function() {
Services.obs.addObserver(this, "process-hang-report", false);
Services.obs.addObserver(this, "xpcom-shutdown", false);
Services.ww.registerNotification(this);
},
/**
* Terminate JavaScript associated with the hang being reported for
* the selected browser in |win|.
*/
terminateScript: function(win) {
this.handleUserInput(win, report => report.terminateScript());
},
/**
* Start devtools debugger for JavaScript associated with the hang
* being reported for the selected browser in |win|.
*/
debugScript: function(win) {
this.handleUserInput(win, report => {
function callback() {
report.endStartingDebugger();
}
report.beginStartingDebugger();
let svc = Cc["@mozilla.org/dom/slow-script-debug;1"].getService(Ci.nsISlowScriptDebug);
let handler = svc.remoteActivationHandler;
handler.handleSlowScriptDebug(report.scriptBrowser, callback);
});
},
/**
* Kill the plugin process causing the hang being reported for the
* selected browser in |win|.
*/
terminatePlugin: function(win) {
this.handleUserInput(win, report => report.terminatePlugin());
},
/**
* Kill the content process causing the hang being reported for the selected
* browser in |win|.
*/
terminateProcess: function(win) {
this.handleUserInput(win, report => report.terminateProcess());
},
/**
* Update the "Options" pop-up menu for the hang notification
* associated with the selected browser in |win|. The menu should
* display only options that are relevant to the given report.
*/
refreshMenu: function(win) {
let report = this.findReport(win.gBrowser.selectedBrowser);
if (!report) {
return;
}
function setVisible(id, visible) {
let item = win.document.getElementById(id);
item.hidden = !visible;
}
if (report.hangType == report.SLOW_SCRIPT) {
setVisible("processHangTerminateScript", true);
setVisible("processHangDebugScript", true);
setVisible("processHangTerminatePlugin", false);
} else if (report.hangType == report.PLUGIN_HANG) {
setVisible("processHangTerminateScript", false);
setVisible("processHangDebugScript", false);
setVisible("processHangTerminatePlugin", true);
}
},
/**
* If there is a hang report associated with the selected browser in
* |win|, invoke |func| on that report and stop notifying the user
* about it.
*/
handleUserInput: function(win, func) {
let report = this.findReport(win.gBrowser.selectedBrowser);
if (!report) {
return;
}
this.removeReport(report);
return func(report);
},
observe: function(subject, topic, data) {
switch (topic) {
case "xpcom-shutdown":
Services.obs.removeObserver(this, "xpcom-shutdown");
Services.obs.removeObserver(this, "process-hang-report");
Services.ww.unregisterNotification(this);
break;
case "process-hang-report":
this.reportHang(subject.QueryInterface(Ci.nsIHangReport));
break;
case "domwindowopened":
// Install event listeners on the new window in case one of
// its tabs is already hung.
let win = subject.QueryInterface(Ci.nsIDOMWindow);
let listener = (ev) => {
win.removeEventListener("load", listener, true);
this.updateWindows();
};
win.addEventListener("load", listener, true);
break;
}
},
/**
* Find any active hang reports for the given <browser> element.
*/
findReport: function(browser) {
let frameLoader = browser.QueryInterface(Ci.nsIFrameLoaderOwner).frameLoader;
for (let [report, timer] of this._activeReports) {
if (report.isReportForBrowser(frameLoader)) {
return report;
}
}
return null;
},
/**
* Iterate over all XUL windows and ensure that the proper hang
* reports are shown for each one. Also install event handlers in
* each window to watch for events that would cause a different hang
* report to be displayed.
*/
updateWindows: function() {
let e = Services.wm.getEnumerator("navigator:browser");
while (e.hasMoreElements()) {
let win = e.getNext();
this.updateWindow(win);
// Only listen for these events if there are active hang reports.
if (this._activeReports.size) {
this.trackWindow(win);
} else {
this.untrackWindow(win);
}
}
},
/**
* If there is a hang report for the current tab in |win|, display it.
*/
updateWindow: function(win) {
let report = this.findReport(win.gBrowser.selectedBrowser);
if (report) {
this.showNotification(win, report);
} else {
this.hideNotification(win);
}
},
/**
* Show the notification for a hang.
*/
showNotification: function(win, report) {
let nb = win.document.getElementById("high-priority-global-notificationbox");
let notification = nb.getNotificationWithValue("process-hang");
if (notification) {
return;
}
let bundle = win.gNavigatorBundle;
let brandBundle = win.document.getElementById("bundle_brand");
let appName = brandBundle.getString("brandShortName");
let message = bundle.getFormattedString(
"processHang.message",
[appName]);
let buttons = [{
label: bundle.getString("processHang.button.label"),
accessKey: bundle.getString("processHang.button.accessKey"),
popup: "processHangOptions",
callback: null,
}];
nb.appendNotification(message, "process-hang",
"chrome://browser/content/aboutRobots-icon.png",
nb.PRIORITY_WARNING_HIGH, buttons);
},
/**
* Ensure that no hang notifications are visible in |win|.
*/
hideNotification: function(win) {
let nb = win.document.getElementById("high-priority-global-notificationbox");
let notification = nb.getNotificationWithValue("process-hang");
if (notification) {
nb.removeNotification(notification);
}
},
/**
* Install event handlers on |win| to watch for events that would
* cause a different hang report to be displayed.
*/
trackWindow: function(win) {
win.gBrowser.tabContainer.addEventListener("TabSelect", this, true);
win.gBrowser.tabContainer.addEventListener("TabRemotenessChange", this, true);
},
untrackWindow: function(win) {
win.gBrowser.tabContainer.removeEventListener("TabSelect", this, true);
win.gBrowser.tabContainer.removeEventListener("TabRemotenessChange", this, true);
},
handleEvent: function(event) {
let win = event.target.ownerDocument.defaultView;
// If a new tab is selected or if a tab changes remoteness, then
// we may need to show or hide a hang notification.
if (event.type == "TabSelect" || event.type == "TabRemotenessChange") {
this.updateWindow(win);
}
},
/**
* Handle a potentially new hang report. If it hasn't been seen
* before, show a notification for it in all open XUL windows.
*/
reportHang: function(report) {
// If this hang was already reported, then reset the timer for it.
if (this._activeReports.has(report)) {
let timer = this._activeReports.get(report);
timer.cancel();
timer.initWithCallback(this, HANG_EXPIRATION_TIME, timer.TYPE_ONE_SHOT);
return;
}
// On e10s this counts slow-script/hanged-plugin notice only once.
// This code is not reached on non-e10s.
if (report.hangType == report.SLOW_SCRIPT) {
// On non-e10s, SLOW_SCRIPT_NOTICE_COUNT is probed at nsGlobalWindow.cpp
Services.telemetry.getHistogramById("SLOW_SCRIPT_NOTICE_COUNT").add();
} else if (report.hangType == report.PLUGIN_HANG) {
// On non-e10s we have sufficient plugin telemetry probes,
// so PLUGIN_HANG_NOTICE_COUNT is only probed on e10s.
Services.telemetry.getHistogramById("PLUGIN_HANG_NOTICE_COUNT").add();
}
// Otherwise create a new timer and display the report.
let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
timer.initWithCallback(this, HANG_EXPIRATION_TIME, timer.TYPE_ONE_SHOT);
this._activeReports.set(report, timer);
this.updateWindows();
},
/**
* Dismiss a hang report because the user closed the notification
* for it or the report expired.
*/
removeReport: function(report) {
this._activeReports.delete(report);
this.updateWindows();
},
/**
* Callback for when HANG_EXPIRATION_TIME has elapsed.
*/
notify: function(timer) {
for (let [otherReport, otherTimer] of this._activeReports) {
if (otherTimer === timer) {
this.removeReport(otherReport);
otherReport.userCanceled();
break;
}
}
},
};
