/* -*- 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";

var EXPORTED_SYMBOLS = ["ProcessHangMonitor"];

const { AppConstants } = ChromeUtils.importESModule(
  "resource://gre/modules/AppConstants.sys.mjs"
);

/**
 * Elides the middle of a string by replacing it with an elipsis if it is
 * longer than `threshold` characters. Does its best to not break up grapheme
 * clusters.
 */
function elideMiddleOfString(str, threshold) {
  const searchDistance = 5;
  const stubLength = threshold / 2 - searchDistance;
  if (str.length <= threshold || stubLength < searchDistance) {
    return str;
  }

  function searchElisionPoint(position) {
    let unsplittableCharacter = c => /[\p{M}\uDC00-\uDFFF]/u.test(c);
    for (let i = 0; i < searchDistance; i++) {
      if (!unsplittableCharacter(str[position + i])) {
        return position + i;
      }

      if (!unsplittableCharacter(str[position - i])) {
        return position - i;
      }
    }
    return position;
  }

  let elisionStart = searchElisionPoint(stubLength);
  let elisionEnd = searchElisionPoint(str.length - stubLength);
  if (elisionStart < elisionEnd) {
    str = str.slice(0, elisionStart) + "\u2026" + str.slice(elisionEnd);
  }
  return str;
}

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

var ProcessHangMonitor = {
  /**
   * This timeout is the wait period applied after a user selects "Wait" in
   * an existing notification.
   */
  get WAIT_EXPIRATION_TIME() {
    try {
      return Services.prefs.getIntPref("browser.hangNotification.waitPeriod");
    } catch (ex) {
      return 10000;
    }
  },

  /**
   * Should only be set to true once the quit-application-granted notification
   * has been fired.
   */
  _shuttingDown: false,

  /**
   * Collection of hang reports that haven't expired or been dismissed
   * by the user. These are nsIHangReports. They are mapped to objects
   * containing:
   * - notificationTime: when (Cu.now()) we first showed a notification
   * - waitCount: how often the user asked to wait for the script to finish
   * - lastReportFromChild: when (Cu.now()) we last got hang info from the
   *   child.
   */
  _activeReports: new Map(),

  /**
   * Collection of hang reports that have been suppressed for a short
   * period of time. Value is an object like in _activeReports, but also
   * including a `timer` prop, which is an nsITimer for when the wait time
   * expires.
   */
  _pausedReports: new Map(),

  /**
   * Initialize hang reporting. Called once in the parent process.
   */
  init() {
    Services.obs.addObserver(this, "process-hang-report");
    Services.obs.addObserver(this, "clear-hang-report");
    Services.obs.addObserver(this, "quit-application-granted");
    Services.obs.addObserver(this, "xpcom-shutdown");
    Services.ww.registerNotification(this);
    Services.telemetry.setEventRecordingEnabled("slow_script_warning", true);
  },

  /**
   * Terminate JavaScript associated with the hang being reported for
   * the selected browser in |win|.
   */
  terminateScript(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(win) {
    this.handleUserInput(win, report => {
      function callback() {
        report.endStartingDebugger();
      }

      this._recordTelemetryForReport(report, "debugging");
      report.beginStartingDebugger();

      let svc = Cc["@mozilla.org/dom/slow-script-debug;1"].getService(
        Ci.nsISlowScriptDebug
      );
      let handler = svc.remoteActivationHandler;
      handler.handleSlowScriptDebug(report.scriptBrowser, callback);
    });
  },

  /**
   * Dismiss the browser notification and invoke an appropriate action based on
   * the hang type.
   */
  stopIt(win) {
    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
    if (!report) {
      return;
    }

    this._recordTelemetryForReport(report, "user-aborted");
    this.terminateScript(win);
  },

  /**
   * Terminate the script causing this report. This is done without
   * updating any report notifications.
   */
  stopHang(report, endReason, backupInfo) {
    this._recordTelemetryForReport(report, endReason, backupInfo);
    report.terminateScript();
  },

  /**
   * Dismiss the notification, clear the report from the active list and set up
   * a new timer to track a wait period during which we won't notify.
   */
  waitLonger(win) {
    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
    if (!report) {
      return;
    }
    // Update the other info we keep.
    let reportInfo = this._activeReports.get(report);
    reportInfo.waitCount++;

    // Remove the report from the active list.
    this.removeActiveReport(report);

    // NOTE, we didn't call userCanceled on nsIHangReport here. This insures
    // we don't repeatedly generate and cache crash report data for this hang
    // in the process hang reporter. It already has one report for the browser
    // process we want it hold onto.

    // Create a new wait timer with notify callback
    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
    timer.initWithCallback(
      () => {
        for (let [stashedReport, pausedInfo] of this._pausedReports) {
          if (pausedInfo.timer === timer) {
            this.removePausedReport(stashedReport);

            // We're still hung, so move the report back to the active
            // list and update the UI.
            this._activeReports.set(report, pausedInfo);
            this.updateWindows();
            break;
          }
        }
      },
      this.WAIT_EXPIRATION_TIME,
      timer.TYPE_ONE_SHOT
    );

    reportInfo.timer = timer;
    this._pausedReports.set(report, reportInfo);

    // remove the browser notification associated with this hang
    this.updateWindows();
  },

  /**
   * 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(win, func) {
    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
    if (!report) {
      return null;
    }
    this.removeActiveReport(report);

    return func(report);
  },

  observe(subject, topic, data) {
    switch (topic) {
      case "xpcom-shutdown": {
        Services.obs.removeObserver(this, "xpcom-shutdown");
        Services.obs.removeObserver(this, "process-hang-report");
        Services.obs.removeObserver(this, "clear-hang-report");
        Services.obs.removeObserver(this, "quit-application-granted");
        Services.ww.unregisterNotification(this);
        break;
      }

      case "quit-application-granted": {
        this.onQuitApplicationGranted();
        break;
      }

      case "process-hang-report": {
        this.reportHang(subject.QueryInterface(Ci.nsIHangReport));
        break;
      }

      case "clear-hang-report": {
        this.clearHang(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;
        let listener = ev => {
          win.removeEventListener("load", listener, true);
          this.updateWindows();
        };
        win.addEventListener("load", listener, true);
        break;
      }

      case "domwindowclosed": {
        let win = subject;
        this.onWindowClosed(win);
        break;
      }
    }
  },

  /**
   * Called early on in the shutdown sequence. We take this opportunity to
   * take any pre-existing hang reports, and terminate them. We also put
   * ourselves in a state so that if any more hang reports show up while
   * we're shutting down, we terminate them immediately.
   */
  onQuitApplicationGranted() {
    this._shuttingDown = true;
    this.stopAllHangs("quit-application-granted");
    this.updateWindows();
  },

  onWindowClosed(win) {
    let maybeStopHang = report => {
      let hungBrowserWindow = null;
      try {
        hungBrowserWindow = report.scriptBrowser.ownerGlobal;
      } catch (e) {
        // Ignore failures to get the script browser - we'll be
        // conservative, and assume that if we cannot access the
        // window that belongs to this report that we should stop
        // the hang.
      }
      if (!hungBrowserWindow || hungBrowserWindow == win) {
        this.stopHang(report, "window-closed");
        return true;
      }
      return false;
    };

    // If there are any script hangs for browsers that are in this window
    // that is closing, we can stop them now.
    for (let [report] of this._activeReports) {
      if (maybeStopHang(report)) {
        this._activeReports.delete(report);
      }
    }

    for (let [pausedReport] of this._pausedReports) {
      if (maybeStopHang(pausedReport)) {
        this.removePausedReport(pausedReport);
      }
    }

    this.updateWindows();
  },

  stopAllHangs(endReason) {
    for (let [report] of this._activeReports) {
      this.stopHang(report, endReason);
    }

    this._activeReports = new Map();

    for (let [pausedReport] of this._pausedReports) {
      this.stopHang(pausedReport, endReason);
      this.removePausedReport(pausedReport);
    }
  },

  /**
   * Find a active hang report for the given <browser> element.
   */
  findActiveReport(browser) {
    let frameLoader = browser.frameLoader;
    for (let report of this._activeReports.keys()) {
      if (report.isReportForBrowserOrChildren(frameLoader)) {
        return report;
      }
    }
    return null;
  },

  /**
   * Find a paused hang report for the given <browser> element.
   */
  findPausedReport(browser) {
    let frameLoader = browser.frameLoader;
    for (let [report] of this._pausedReports) {
      if (report.isReportForBrowserOrChildren(frameLoader)) {
        return report;
      }
    }
    return null;
  },

  /**
   * Tell telemetry about the report.
   */
  _recordTelemetryForReport(report, endReason, backupInfo) {
    let info =
      this._activeReports.get(report) ||
      this._pausedReports.get(report) ||
      backupInfo;
    if (!info) {
      return;
    }
    try {
      let uri_type;
      if (report.addonId) {
        uri_type = "extension";
      } else if (report.scriptFileName?.startsWith("debugger")) {
        uri_type = "devtools";
      } else {
        try {
          let url = new URL(report.scriptFileName);
          if (url.protocol == "chrome:" || url.protocol == "resource:") {
            uri_type = "browser";
          } else {
            uri_type = "content";
          }
        } catch (ex) {
          console.error(ex);
          uri_type = "unknown";
        }
      }
      let uptime = 0;
      if (info.notificationTime) {
        uptime = Cu.now() - info.notificationTime;
      }
      uptime = "" + uptime;
      // We combine the duration of the hang in the content process with the
      // time since we were last told about the hang in the parent. This is
      // not the same as the time we showed a notification, as we only do that
      // for the currently selected browser. It's as messy as it is because
      // there is no cross-process monotonically increasing timestamp we can
      // use. :-(
      let hangDuration =
        report.hangDuration + Cu.now() - info.lastReportFromChild;
      Services.telemetry.recordEvent(
        "slow_script_warning",
        "shown",
        "content",
        null,
        {
          end_reason: endReason,
          hang_duration: "" + hangDuration,
          n_tab_deselect: "" + info.deselectCount,
          uri_type,
          uptime,
          wait_count: "" + info.waitCount,
        }
      );
    } catch (ex) {
      console.error(ex);
    }
  },

  /**
   * Remove an active hang report from the active list and cancel the timer
   * associated with it.
   */
  removeActiveReport(report) {
    this._activeReports.delete(report);
    this.updateWindows();
  },

  /**
   * Remove a paused hang report from the paused list and cancel the timer
   * associated with it.
   */
  removePausedReport(report) {
    let info = this._pausedReports.get(report);
    info?.timer?.cancel();
    this._pausedReports.delete(report);
  },

  /**
   * 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() {
    let e = Services.wm.getEnumerator("navigator:browser");

    // If it turns out we have no windows (this can happen on macOS),
    // we have no opportunity to ask the user whether or not they want
    // to stop the hang or wait, so we'll opt for stopping the hang.
    if (!e.hasMoreElements()) {
      this.stopAllHangs("no-windows-left");
      return;
    }

    for (let win of e) {
      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(win) {
    let report = this.findActiveReport(win.gBrowser.selectedBrowser);

    if (report) {
      let info = this._activeReports.get(report);
      if (info && !info.notificationTime) {
        info.notificationTime = Cu.now();
      }
      this.showNotification(win, report);
    } else {
      this.hideNotification(win);
    }
  },

  /**
   * Show the notification for a hang.
   */
  showNotification(win, report) {
    let bundle = win.gNavigatorBundle;

    let buttons = [
      {
        label: bundle.getString("processHang.button_stop2.label"),
        accessKey: bundle.getString("processHang.button_stop2.accessKey"),
        callback() {
          ProcessHangMonitor.stopIt(win);
        },
      },
    ];

    let message;
    let doc = win.document;
    let brandShortName = doc
      .getElementById("bundle_brand")
      .getString("brandShortName");
    let notificationTag;
    if (report.addonId) {
      notificationTag = report.addonId;
      let aps = Cc["@mozilla.org/addons/policy-service;1"].getService(
        Ci.nsIAddonPolicyService
      );

      let addonName = aps.getExtensionName(report.addonId);

      message = bundle.getFormattedString("processHang.add-on.label2", [
        addonName,
        brandShortName,
      ]);

      buttons.unshift({
        label: bundle.getString("processHang.add-on.learn-more.text"),
        link:
          "https://support.mozilla.org/kb/warning-unresponsive-script#w_other-causes",
      });
    } else {
      let scriptBrowser = report.scriptBrowser;
      if (scriptBrowser == win.gBrowser?.selectedBrowser) {
        notificationTag = "selected-tab";
        message = bundle.getFormattedString("processHang.selected_tab.label", [
          brandShortName,
        ]);
      } else {
        let tab = scriptBrowser?.ownerGlobal.gBrowser?.getTabForBrowser(
          scriptBrowser
        );
        if (!tab) {
          notificationTag = "nonspecific_tab";
          message = bundle.getFormattedString(
            "processHang.nonspecific_tab.label",
            [brandShortName]
          );
        } else {
          notificationTag = scriptBrowser.browserId.toString();
          let title = tab.getAttribute("label");
          title = elideMiddleOfString(title, 60);
          message = bundle.getFormattedString(
            "processHang.specific_tab.label",
            [title, brandShortName]
          );
        }
      }
    }

    let notification = win.gNotificationBox.getNotificationWithValue(
      "process-hang"
    );
    if (notificationTag == notification?.getAttribute("notification-tag")) {
      return;
    }

    if (notification) {
      notification.label = message;
      notification.setAttribute("notification-tag", notificationTag);
      return;
    }

    // Show the "debug script" button unconditionally if we are in Developer edition,
    // or, if DevTools are opened on the slow tab.
    if (
      AppConstants.MOZ_DEV_EDITION ||
      report.scriptBrowser.browsingContext.watchedByDevTools
    ) {
      buttons.push({
        label: bundle.getString("processHang.button_debug.label"),
        accessKey: bundle.getString("processHang.button_debug.accessKey"),
        callback() {
          ProcessHangMonitor.debugScript(win);
        },
      });
    }

    win.gNotificationBox
      .appendNotification(
        "process-hang",
        {
          label: message,
          image: "chrome://browser/content/aboutRobots-icon.png",
          priority: win.gNotificationBox.PRIORITY_INFO_HIGH,
          eventCallback: event => {
            if (event == "dismissed") {
              ProcessHangMonitor.waitLonger(win);
            }
          },
        },
        buttons
      )
      .setAttribute("notification-tag", notificationTag);
  },

  /**
   * Ensure that no hang notifications are visible in |win|.
   */
  hideNotification(win) {
    let notification = win.gNotificationBox.getNotificationWithValue(
      "process-hang"
    );
    if (notification) {
      win.gNotificationBox.removeNotification(notification);
    }
  },

  /**
   * Install event handlers on |win| to watch for events that would
   * cause a different hang report to be displayed.
   */
  trackWindow(win) {
    win.gBrowser.tabContainer.addEventListener("TabSelect", this, true);
    win.gBrowser.tabContainer.addEventListener(
      "TabRemotenessChange",
      this,
      true
    );
  },

  untrackWindow(win) {
    win.gBrowser.tabContainer.removeEventListener("TabSelect", this, true);
    win.gBrowser.tabContainer.removeEventListener(
      "TabRemotenessChange",
      this,
      true
    );
  },

  handleEvent(event) {
    let win = event.target.ownerGlobal;

    // 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") {
      if (event.type == "TabSelect" && event.detail.previousTab) {
        // If we've got a notification, check the previous tab's report and
        // indicate the user switched tabs while the notification was up.
        let r =
          this.findActiveReport(event.detail.previousTab.linkedBrowser) ||
          this.findPausedReport(event.detail.previousTab.linkedBrowser);
        if (r) {
          let info = this._activeReports.get(r) || this._pausedReports.get(r);
          info.deselectCount++;
        }
      }
      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(report) {
    let now = Cu.now();
    if (this._shuttingDown) {
      this.stopHang(report, "shutdown-in-progress", {
        lastReportFromChild: now,
        waitCount: 0,
        deselectCount: 0,
      });
      return;
    }

    // If this hang was already reported reset the timer for it.
    if (this._activeReports.has(report)) {
      this._activeReports.get(report).lastReportFromChild = now;
      // if this report is in active but doesn't have a notification associated
      // with it, display a notification.
      this.updateWindows();
      return;
    }

    // If this hang was already reported and paused by the user ignore it.
    if (this._pausedReports.has(report)) {
      this._pausedReports.get(report).lastReportFromChild = now;
      return;
    }

    // On e10s this counts slow-script notice only once.
    // This code is not reached on non-e10s.
    Services.telemetry.getHistogramById("SLOW_SCRIPT_NOTICE_COUNT").add();

    this._activeReports.set(report, {
      deselectCount: 0,
      lastReportFromChild: now,
      waitCount: 0,
    });
    this.updateWindows();
  },

  clearHang(report) {
    this._recordTelemetryForReport(report, "cleared");

    this.removeActiveReport(report);
    this.removePausedReport(report);
    report.userCanceled();
  },
};