Add m-esr52 at 52.6.0

author: Matt A. Tobin <mattatobin@localhost.localdomain> 2018-02-02 04:16:08 -0500
committer: Matt A. Tobin <mattatobin@localhost.localdomain> 2018-02-02 04:16:08 -0500
commit: 5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree: 10027f336435511475e392454359edea8e25895d /toolkit/components/startup/tests
parent: 49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
download: UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
11 files changed, 520 insertions, 0 deletions
diff --git a/toolkit/components/startup/tests/browser/.eslintrc.js b/toolkit/components/startup/tests/browser/.eslintrc.js
new file mode 100644
index 000000000..7c8021192
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/mochitest/browser.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/startup/tests/browser/beforeunload.html b/toolkit/components/startup/tests/browser/beforeunload.html
new file mode 100644
index 000000000..93ddd5f14
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/beforeunload.html
@@ -0,0 +1,10 @@
+<html>
+  <script>
+  window.onbeforeunload = function(event) {
+    event.returnValue = 'Test beforeunload handler';
+  }
+  </script>
+  <body>
+    Test page
+  </body>
+</html>
diff --git a/toolkit/components/startup/tests/browser/browser.ini b/toolkit/components/startup/tests/browser/browser.ini
new file mode 100644
index 000000000..0c02f73b6
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+support-files =
+  head.js
+  beforeunload.html
+
+[browser_bug511456.js]
+[browser_bug537449.js]
+[browser_crash_detection.js]
diff --git a/toolkit/components/startup/tests/browser/browser_bug511456.js b/toolkit/components/startup/tests/browser/browser_bug511456.js
new file mode 100644
index 000000000..652a34ea2
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug511456.js
@@ -0,0 +1,47 @@
+/* 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";
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+function test() {
+  waitForExplicitFinish();
+  ignoreAllUncaughtExceptions();
+
+  let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+  win2.addEventListener("load", function onLoad() {
+    win2.removeEventListener("load", onLoad);
+
+    gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+    let browser = gBrowser.selectedBrowser;
+
+    whenBrowserLoaded(browser, function () {
+      let seenDialog = false;
+
+      // Cancel the prompt the first time.
+      waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+        seenDialog = true;
+        btnStay.click();
+      });
+
+      let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+                         getService(Ci.nsIAppStartup);
+      appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+      ok(seenDialog, "Should have seen a prompt dialog");
+      ok(!win2.closed, "Shouldn't have closed the additional window");
+      win2.close();
+
+      // Leave the page the second time.
+      waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+        btnLeave.click();
+      });
+
+      gBrowser.removeTab(gBrowser.selectedTab);
+      executeSoon(finish);
+    });
+  });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_bug537449.js b/toolkit/components/startup/tests/browser/browser_bug537449.js
new file mode 100644
index 000000000..ed3446f8d
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug537449.js
@@ -0,0 +1,53 @@
+/* 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";
+
+//
+// Whitelisting this test.
+// As part of bug 1077403, the leaking uncaught rejection should be fixed.
+//
+thisTestLeaksUncaughtRejectionsAndShouldBeFixed("TypeError: this.docShell is null");
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+function test() {
+  waitForExplicitFinish();
+
+  gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+  let browser = gBrowser.selectedBrowser;
+
+  whenBrowserLoaded(browser, function () {
+    let seenDialog = false;
+
+    // Cancel the prompt the first time.
+    waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+      seenDialog = true;
+      btnStay.click();
+    });
+
+    let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+                       getService(Ci.nsIAppStartup);
+    appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+    ok(seenDialog, "Should have seen a prompt dialog");
+    ok(!window.closed, "Shouldn't have closed the window");
+
+    let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+    ok(win2 != null, "Should have been able to open a new window");
+    win2.addEventListener("load", function onLoad() {
+      win2.removeEventListener("load", onLoad);
+      win2.close();
+
+      // Leave the page the second time.
+      waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+        btnLeave.click();
+      });
+
+      gBrowser.removeTab(gBrowser.selectedTab);
+      executeSoon(finish);
+    });
+  });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_crash_detection.js b/toolkit/components/startup/tests/browser/browser_crash_detection.js
new file mode 100644
index 000000000..039f80dde
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_crash_detection.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+ *    http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  function checkLastSuccess() {
+    let lastSuccess = Services.prefs.getIntPref("toolkit.startup.last_success");
+    let si = Services.startup.getStartupInfo();
+    is(lastSuccess, parseInt(si["main"].getTime() / 1000, 10),
+       "Startup tracking pref should be set after a delay at the end of startup");
+    finish();
+  }
+
+  if (Services.prefs.getPrefType("toolkit.startup.max_resumed_crashes") == Services.prefs.PREF_INVALID) {
+    info("Skipping this test since startup crash detection is disabled");
+    return;
+  }
+
+  const startupCrashEndDelay = 35 * 1000;
+  waitForExplicitFinish();
+  requestLongerTimeout(2);
+  setTimeout(checkLastSuccess, startupCrashEndDelay);
+}
diff --git a/toolkit/components/startup/tests/browser/head.js b/toolkit/components/startup/tests/browser/head.js
new file mode 100644
index 000000000..c17da2ff7
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/head.js
@@ -0,0 +1,29 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+function whenBrowserLoaded(browser, callback) {
+  return BrowserTestUtils.browserLoaded(browser).then(callback);
+}
+
+function waitForOnBeforeUnloadDialog(browser, callback) {
+  browser.addEventListener("DOMWillOpenModalDialog", function onModalDialog(event) {
+    if (Cu.isCrossProcessWrapper(event.target)) {
+      // This event fires in both the content and chrome processes. We
+      // want to ignore the one in the content process.
+      return;
+    }
+
+    browser.removeEventListener("DOMWillOpenModalDialog", onModalDialog, true);
+
+    executeSoon(() => {
+      let stack = browser.parentNode;
+      let dialogs = stack.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
+      let {button0, button1} = dialogs[0].ui;
+      callback(button0, button1);
+    });
+  }, true);
+}
diff --git a/toolkit/components/startup/tests/unit/.eslintrc.js b/toolkit/components/startup/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/startup/tests/unit/head_startup.js b/toolkit/components/startup/tests/unit/head_startup.js
new file mode 100644
index 000000000..2466f70ee
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/head_startup.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const XULRUNTIME_CONTRACTID = "@mozilla.org/xre/runtime;1";
+const XULRUNTIME_CID = Components.ID("7685dac8-3637-4660-a544-928c5ec0e714}");
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var gAppInfo = null;
+
+function createAppInfo(ID, name, version, platformVersion="1.0") {
+  let tmp = {};
+  Components.utils.import("resource://testing-common/AppInfo.jsm", tmp);
+  gAppInfo = tmp.newAppInfo({
+    ID, name, version, platformVersion,
+    crashReporter: true,
+    replacedLockTime: 0,
+  });
+
+  let XULAppInfoFactory = {
+    createInstance: function (outer, iid) {
+      if (outer != null)
+        throw Components.results.NS_ERROR_NO_AGGREGATION;
+      return gAppInfo.QueryInterface(iid);
+    }
+  };
+  let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+  registrar.registerFactory(XULRUNTIME_CID, "XULRuntime",
+                            XULRUNTIME_CONTRACTID, XULAppInfoFactory);
+}
diff --git a/toolkit/components/startup/tests/unit/test_startup_crash.js b/toolkit/components/startup/tests/unit/test_startup_crash.js
new file mode 100644
index 000000000..283633086
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/test_startup_crash.js
@@ -0,0 +1,300 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+
+createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "10.0");
+
+var prefService = Services.prefs;
+var appStartup = Cc["@mozilla.org/toolkit/app-startup;1"].
+                 getService(Ci.nsIAppStartup);
+
+const pref_last_success = "toolkit.startup.last_success";
+const pref_recent_crashes = "toolkit.startup.recent_crashes";
+const pref_max_resumed_crashes = "toolkit.startup.max_resumed_crashes";
+const pref_always_use_safe_mode = "toolkit.startup.always_use_safe_mode";
+
+function run_test() {
+  prefService.setBoolPref(pref_always_use_safe_mode, true);
+
+  resetTestEnv(0);
+
+  test_trackStartupCrashBegin();
+  test_trackStartupCrashEnd();
+  test_trackStartupCrashBegin_safeMode();
+  test_trackStartupCrashEnd_safeMode();
+  test_maxResumed();
+  resetTestEnv(0);
+
+  prefService.clearUserPref(pref_always_use_safe_mode);
+}
+
+// reset prefs to default
+function resetTestEnv(replacedLockTime) {
+  try {
+    // call begin to reset mStartupCrashTrackingEnded
+    appStartup.trackStartupCrashBegin();
+  } catch (x) { }
+  prefService.setIntPref(pref_max_resumed_crashes, 2);
+  prefService.clearUserPref(pref_recent_crashes);
+  gAppInfo.replacedLockTime = replacedLockTime;
+  prefService.clearUserPref(pref_last_success);
+}
+
+function now_seconds() {
+  return ms_to_s(Date.now());
+}
+
+function ms_to_s(ms) {
+  return Math.floor(ms / 1000);
+}
+
+function test_trackStartupCrashBegin() {
+  let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+  do_check_false(gAppInfo.inSafeMode);
+
+  // first run with startup crash tracking - existing profile lock
+  let replacedLockTime = Date.now();
+  resetTestEnv(replacedLockTime);
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(prefService.prefHasUserValue(pref_last_success));
+  do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+  try {
+    do_check_false(appStartup.trackStartupCrashBegin());
+    do_throw("Should have thrown since last_success is not set");
+  } catch (x) { }
+
+  do_check_false(prefService.prefHasUserValue(pref_last_success));
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // first run with startup crash tracking - no existing profile lock
+  replacedLockTime = 0;
+  resetTestEnv(replacedLockTime);
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(prefService.prefHasUserValue(pref_last_success));
+  do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+  try {
+    do_check_false(appStartup.trackStartupCrashBegin());
+    do_throw("Should have thrown since last_success is not set");
+  } catch (x) { }
+
+  do_check_false(prefService.prefHasUserValue(pref_last_success));
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup - last startup was success
+  replacedLockTime = Date.now();
+  resetTestEnv(replacedLockTime);
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+  do_check_false(appStartup.trackStartupCrashBegin());
+  do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup with 1 recent crash
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_recent_crashes, 1);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  do_check_false(appStartup.trackStartupCrashBegin());
+  do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+  do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup with max_resumed_crashes crash
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_recent_crashes, max_resumed);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  do_check_false(appStartup.trackStartupCrashBegin());
+  do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+  do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup with too many recent crashes
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  do_check_true(appStartup.trackStartupCrashBegin());
+  // should remain the same since the last startup was not a crash
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  do_check_true(appStartup.automaticSafeModeNecessary);
+
+  // normal startup with too many recent crashes and startup crash tracking disabled
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_max_resumed_crashes, -1);
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  do_check_false(appStartup.trackStartupCrashBegin());
+  // should remain the same since the last startup was not a crash
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  // returns false when disabled
+  do_check_false(appStartup.automaticSafeModeNecessary);
+  do_check_eq(-1, prefService.getIntPref(pref_max_resumed_crashes));
+
+  // normal startup after 1 non-recent crash (1 year ago), no other recent
+  replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60);
+  do_check_false(appStartup.trackStartupCrashBegin());
+  // recent crash count pref should be unset since the last crash was not recent
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup after 1 crash (1 minute ago), no other recent
+  replacedLockTime = Date.now() - 60 * 1000;
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+  do_check_false(appStartup.trackStartupCrashBegin());
+  // recent crash count pref should be created with value 1
+  do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup after another crash (1 minute ago), 1 already
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+  replacedLockTime = Date.now() - 60 * 1000;
+  gAppInfo.replacedLockTime = replacedLockTime;
+  do_check_false(appStartup.trackStartupCrashBegin());
+  // recent crash count pref should be incremented by 1
+  do_check_eq(2, prefService.getIntPref(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // normal startup after another crash (1 minute ago), 2 already
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+  do_check_true(appStartup.trackStartupCrashBegin());
+  // recent crash count pref should be incremented by 1
+  do_check_eq(3, prefService.getIntPref(pref_recent_crashes));
+  do_check_true(appStartup.automaticSafeModeNecessary);
+
+  // normal startup after 1 non-recent crash (1 year ago), 3 crashes already
+  replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+  do_check_false(appStartup.trackStartupCrashBegin());
+  // recent crash count should be unset since the last crash was not recent
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd() {
+  // successful startup with no last_success (upgrade test)
+  let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+  resetTestEnv(replacedLockTime);
+  try {
+    appStartup.trackStartupCrashBegin(); // required to be called before end
+    do_throw("Should have thrown since last_success is not set");
+  } catch (x) { }
+  appStartup.trackStartupCrashEnd();
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_false(prefService.prefHasUserValue(pref_last_success));
+
+  // successful startup - should set last_success
+  replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  appStartup.trackStartupCrashBegin(); // required to be called before end
+  appStartup.trackStartupCrashEnd();
+  // ensure last_success was set since we have declared a succesful startup
+  // main timestamp doesn't get set in XPCShell so approximate with now
+  do_check_true(prefService.getIntPref(pref_last_success) <= now_seconds());
+  do_check_true(prefService.getIntPref(pref_last_success) >= now_seconds() - 4 * 60 * 60);
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+
+  // successful startup with 1 recent crash
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  prefService.setIntPref(pref_recent_crashes, 1);
+  appStartup.trackStartupCrashBegin(); // required to be called before end
+  appStartup.trackStartupCrashEnd();
+  // ensure recent_crashes was cleared since we have declared a succesful startup
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+}
+
+function test_trackStartupCrashBegin_safeMode() {
+  gAppInfo.inSafeMode = true;
+  resetTestEnv(0);
+  let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+
+  // check manual safe mode doesn't change prefs without crash
+  let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_true(prefService.prefHasUserValue(pref_last_success));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+  do_check_false(appStartup.trackStartupCrashBegin());
+  do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+  do_check_true(prefService.prefHasUserValue(pref_last_success));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+
+  // check forced safe mode doesn't change prefs without crash
+  replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  do_check_true(prefService.prefHasUserValue(pref_last_success));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+  do_check_true(appStartup.trackStartupCrashBegin());
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  do_check_true(prefService.prefHasUserValue(pref_last_success));
+  do_check_true(appStartup.automaticSafeModeNecessary);
+
+  // check forced safe mode after old crash
+  replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+  resetTestEnv(replacedLockTime);
+  // one year ago
+  let last_success = ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60;
+  prefService.setIntPref(pref_last_success, last_success);
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  do_check_true(prefService.prefHasUserValue(pref_last_success));
+  do_check_true(appStartup.automaticSafeModeNecessary);
+  do_check_true(appStartup.trackStartupCrashBegin());
+  do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+  do_check_eq(last_success, prefService.getIntPref(pref_last_success));
+  do_check_true(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd_safeMode() {
+  gAppInfo.inSafeMode = true;
+  let replacedLockTime = Date.now();
+  resetTestEnv(replacedLockTime);
+  let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+
+  // ensure recent_crashes were not cleared in manual safe mode
+  prefService.setIntPref(pref_recent_crashes, 1);
+  appStartup.trackStartupCrashBegin(); // required to be called before end
+  appStartup.trackStartupCrashEnd();
+  do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+
+  // recent_crashes should be set to max_resumed in forced safe mode to allow the user
+  // to try and start in regular mode after making changes.
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+  appStartup.trackStartupCrashBegin(); // required to be called before end
+  appStartup.trackStartupCrashEnd();
+  do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+}
+
+function test_maxResumed() {
+  resetTestEnv(0);
+  gAppInfo.inSafeMode = false;
+  let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+  let replacedLockTime = Date.now();
+  resetTestEnv(replacedLockTime);
+  prefService.setIntPref(pref_max_resumed_crashes, -1);
+
+  prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+  prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+  appStartup.trackStartupCrashBegin();
+  // should remain the same since the last startup was not a crash
+  do_check_eq(max_resumed + 2, prefService.getIntPref(pref_recent_crashes));
+  do_check_false(appStartup.automaticSafeModeNecessary);
+}
diff --git a/toolkit/components/startup/tests/unit/xpcshell.ini b/toolkit/components/startup/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..294800ee3
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/xpcshell.ini
@@ -0,0 +1,6 @@
+[DEFAULT]
+head = head_startup.js
+tail =
+skip-if = toolkit == 'android'
+
+[test_startup_crash.js]
author	Matt A. Tobin <mattatobin@localhost.localdomain>	2018-02-02 04:16:08 -0500
committer	Matt A. Tobin <mattatobin@localhost.localdomain>	2018-02-02 04:16:08 -0500
commit	5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree	10027f336435511475e392454359edea8e25895d /toolkit/components/startup/tests
parent	49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
download	UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip