summaryrefslogtreecommitdiffstats
path: root/browser/components/sessionstore/test/browser_522545.js
diff options
context:
space:
mode:
Diffstat (limited to 'browser/components/sessionstore/test/browser_522545.js')
-rw-r--r--browser/components/sessionstore/test/browser_522545.js443
1 files changed, 443 insertions, 0 deletions
diff --git a/browser/components/sessionstore/test/browser_522545.js b/browser/components/sessionstore/test/browser_522545.js
new file mode 100644
index 0000000000..5ebe3b9d5f
--- /dev/null
+++ b/browser/components/sessionstore/test/browser_522545.js
@@ -0,0 +1,443 @@
+/* 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/. */
+
+function test() {
+ /** Test for Bug 522545 **/
+
+ waitForExplicitFinish();
+ requestLongerTimeout(4);
+
+ // This tests the following use case:
+ // User opens a new tab which gets focus. The user types something into the
+ // address bar, then crashes or quits.
+ function test_newTabFocused() {
+ let state = {
+ windows: [
+ {
+ tabs: [
+ { entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }] },
+ { entries: [], userTypedValue: "example.com", userTypedClear: 0 },
+ ],
+ selected: 2,
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.selectedBrowser;
+ is(
+ browser.currentURI.spec,
+ "about:blank",
+ "No history entries still sets currentURI to about:blank"
+ );
+ is(
+ browser.userTypedValue,
+ "example.com",
+ "userTypedValue was correctly restored"
+ );
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "We still know that no load is ongoing"
+ );
+ is(
+ gURLBar.value,
+ "example.com",
+ "Address bar's value correctly restored"
+ );
+
+ // Change tabs to make sure address bar value gets updated. If tab is
+ // lazy, wait for SSTabRestored to ensure address bar has time to update.
+ let tabToSelect = gBrowser.tabContainer.getItemAtIndex(0);
+ if (tabToSelect.linkedBrowser.isConnected) {
+ gBrowser.selectedTab = tabToSelect;
+ is(
+ gURLBar.value,
+ "about:mozilla",
+ "Address bar's value correctly updated"
+ );
+ runNextTest();
+ } else {
+ gBrowser.tabContainer.addEventListener(
+ "SSTabRestored",
+ function SSTabRestored(event) {
+ if (event.target == tabToSelect) {
+ gBrowser.tabContainer.removeEventListener(
+ "SSTabRestored",
+ SSTabRestored,
+ true
+ );
+ is(
+ gURLBar.value,
+ "about:mozilla",
+ "Address bar's value correctly updated"
+ );
+ runNextTest();
+ }
+ },
+ true
+ );
+ gBrowser.selectedTab = tabToSelect;
+ }
+ });
+ }
+
+ // This tests the following use case:
+ // User opens a new tab which gets focus. The user types something into the
+ // address bar, switches back to the first tab, then crashes or quits.
+ function test_newTabNotFocused() {
+ let state = {
+ windows: [
+ {
+ tabs: [
+ { entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }] },
+ { entries: [], userTypedValue: "example.org", userTypedClear: 0 },
+ ],
+ selected: 1,
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.getBrowserAtIndex(1);
+ is(
+ browser.currentURI.spec,
+ "about:blank",
+ "No history entries still sets currentURI to about:blank"
+ );
+ is(
+ browser.userTypedValue,
+ "example.org",
+ "userTypedValue was correctly restored"
+ );
+ // didStartLoadSinceLastUserTyping does not exist on lazy tabs.
+ if (browser.didStartLoadSinceLastUserTyping) {
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "We still know that no load is ongoing"
+ );
+ }
+ is(
+ gURLBar.value,
+ "about:mozilla",
+ "Address bar's value correctly restored"
+ );
+
+ // Change tabs to make sure address bar value gets updated. If tab is
+ // lazy, wait for SSTabRestored to ensure address bar has time to update.
+ let tabToSelect = gBrowser.tabContainer.getItemAtIndex(1);
+ if (tabToSelect.linkedBrowser.isConnected) {
+ gBrowser.selectedTab = tabToSelect;
+ is(
+ gURLBar.value,
+ "example.org",
+ "Address bar's value correctly updated"
+ );
+ runNextTest();
+ } else {
+ gBrowser.tabContainer.addEventListener(
+ "SSTabRestored",
+ function SSTabRestored(event) {
+ if (event.target == tabToSelect) {
+ gBrowser.tabContainer.removeEventListener(
+ "SSTabRestored",
+ SSTabRestored,
+ true
+ );
+ is(
+ gURLBar.value,
+ "example.org",
+ "Address bar's value correctly updated"
+ );
+ runNextTest();
+ }
+ },
+ true
+ );
+ gBrowser.selectedTab = tabToSelect;
+ }
+ });
+ }
+
+ // This tests the following use case:
+ // User is in a tab with session history, then types something in the
+ // address bar, then crashes or quits.
+ function test_existingSHEnd_noClear() {
+ let state = {
+ windows: [
+ {
+ tabs: [
+ {
+ entries: [
+ { url: "about:mozilla", triggeringPrincipal_base64 },
+ { url: "about:config", triggeringPrincipal_base64 },
+ ],
+ index: 2,
+ userTypedValue: "example.com",
+ userTypedClear: 0,
+ },
+ ],
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.selectedBrowser;
+ is(
+ browser.currentURI.spec,
+ "about:config",
+ "browser.currentURI set to current entry in SH"
+ );
+ is(
+ browser.userTypedValue,
+ "example.com",
+ "userTypedValue was correctly restored"
+ );
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "We still know that no load is ongoing"
+ );
+ is(
+ gURLBar.value,
+ "example.com",
+ "Address bar's value correctly restored to userTypedValue"
+ );
+ runNextTest();
+ });
+ }
+
+ // This tests the following use case:
+ // User is in a tab with session history, presses back at some point, then
+ // types something in the address bar, then crashes or quits.
+ function test_existingSHMiddle_noClear() {
+ let state = {
+ windows: [
+ {
+ tabs: [
+ {
+ entries: [
+ { url: "about:mozilla", triggeringPrincipal_base64 },
+ { url: "about:config", triggeringPrincipal_base64 },
+ ],
+ index: 1,
+ userTypedValue: "example.org",
+ userTypedClear: 0,
+ },
+ ],
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.selectedBrowser;
+ is(
+ browser.currentURI.spec,
+ "about:mozilla",
+ "browser.currentURI set to current entry in SH"
+ );
+ is(
+ browser.userTypedValue,
+ "example.org",
+ "userTypedValue was correctly restored"
+ );
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "We still know that no load is ongoing"
+ );
+ is(
+ gURLBar.value,
+ "example.org",
+ "Address bar's value correctly restored to userTypedValue"
+ );
+ runNextTest();
+ });
+ }
+
+ // This test simulates lots of tabs opening at once and then quitting/crashing.
+ function test_getBrowserState_lotsOfTabsOpening() {
+ gBrowser.stop();
+
+ let uris = [];
+ for (let i = 0; i < 25; i++) {
+ uris.push("http://example.com/" + i);
+ }
+
+ // We're waiting for the first location change, which should indicate
+ // one of the tabs has loaded and the others haven't. So one should
+ // be in a non-userTypedValue case, while others should still have
+ // userTypedValue and userTypedClear set.
+ gBrowser.addTabsProgressListener({
+ onLocationChange(aBrowser) {
+ if (uris.indexOf(aBrowser.currentURI.spec) > -1) {
+ gBrowser.removeTabsProgressListener(this);
+ firstLocationChange();
+ }
+ },
+ });
+
+ function firstLocationChange() {
+ let state = JSON.parse(ss.getBrowserState());
+ let hasUTV = state.windows[0].tabs.some(function (aTab) {
+ return (
+ aTab.userTypedValue && aTab.userTypedClear && !aTab.entries.length
+ );
+ });
+
+ ok(
+ hasUTV,
+ "At least one tab has a userTypedValue with userTypedClear with no loaded URL"
+ );
+
+ BrowserTestUtils.waitForMessage(
+ gBrowser.selectedBrowser.messageManager,
+ "SessionStore:update"
+ ).then(firstLoad);
+ }
+
+ function firstLoad() {
+ let state = JSON.parse(ss.getTabState(gBrowser.selectedTab));
+ let hasSH = !("userTypedValue" in state) && state.entries[0].url;
+ ok(hasSH, "The selected tab has its entry in SH");
+
+ runNextTest();
+ }
+
+ gBrowser.loadTabs(uris, {
+ triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+ });
+ }
+
+ // This simulates setting a userTypedValue and ensures that just typing in the
+ // URL bar doesn't set userTypedClear as well.
+ function test_getBrowserState_userTypedValue() {
+ let state = {
+ windows: [
+ {
+ tabs: [{ entries: [] }],
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.selectedBrowser;
+ // Make sure this tab isn't loading and state is clear before we test.
+ is(browser.userTypedValue, null, "userTypedValue is empty to start");
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "Initially, no load should be ongoing"
+ );
+
+ let inputText = "example.org";
+ gURLBar.focus();
+ gURLBar.value = inputText.slice(0, -1);
+ EventUtils.sendString(inputText.slice(-1));
+
+ executeSoon(function () {
+ is(
+ browser.userTypedValue,
+ "example.org",
+ "userTypedValue was set when changing URLBar value"
+ );
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "No load started since changing URLBar value"
+ );
+
+ // Now make sure ss gets these values too
+ let newState = JSON.parse(ss.getBrowserState());
+ is(
+ newState.windows[0].tabs[0].userTypedValue,
+ "example.org",
+ "sessionstore got correct userTypedValue"
+ );
+ is(
+ newState.windows[0].tabs[0].userTypedClear,
+ 0,
+ "sessionstore got correct userTypedClear"
+ );
+ runNextTest();
+ });
+ });
+ }
+
+ // test_getBrowserState_lotsOfTabsOpening tested userTypedClear in a few cases,
+ // but not necessarily any that had legitimate URIs in the state of loading
+ // (eg, "http://example.com"), so this test will cover that case.
+ function test_userTypedClearLoadURI() {
+ let state = {
+ windows: [
+ {
+ tabs: [
+ {
+ entries: [],
+ userTypedValue: "http://example.com",
+ userTypedClear: 2,
+ },
+ ],
+ },
+ ],
+ };
+
+ waitForBrowserState(state, function () {
+ let browser = gBrowser.selectedBrowser;
+ is(
+ browser.currentURI.spec,
+ "http://example.com/",
+ "userTypedClear=2 caused userTypedValue to be loaded"
+ );
+ is(
+ browser.userTypedValue,
+ null,
+ "userTypedValue was null after loading a URI"
+ );
+ ok(
+ !browser.didStartLoadSinceLastUserTyping(),
+ "We should have reset the load state when the tab loaded"
+ );
+ is(
+ gURLBar.value,
+ BrowserUIUtils.trimURL("http://example.com/"),
+ "Address bar's value set after loading URI"
+ );
+ runNextTest();
+ });
+ }
+
+ let tests = [
+ test_newTabFocused,
+ test_newTabNotFocused,
+ test_existingSHEnd_noClear,
+ test_existingSHMiddle_noClear,
+ test_getBrowserState_lotsOfTabsOpening,
+ test_getBrowserState_userTypedValue,
+ test_userTypedClearLoadURI,
+ ];
+ let originalState = JSON.parse(ss.getBrowserState());
+ let state = {
+ windows: [
+ {
+ tabs: [
+ { entries: [{ url: "about:blank", triggeringPrincipal_base64 }] },
+ ],
+ },
+ ],
+ };
+ function runNextTest() {
+ if (tests.length) {
+ waitForBrowserState(state, function () {
+ gBrowser.selectedBrowser.userTypedValue = null;
+ gURLBar.setURI();
+ tests.shift()();
+ });
+ } else {
+ waitForBrowserState(originalState, function () {
+ gBrowser.selectedBrowser.userTypedValue = null;
+ gURLBar.setURI();
+ finish();
+ });
+ }
+ }
+
+ // Run the tests!
+ runNextTest();
+}