Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 132 insertions, 0 deletions

diff --git a/browser/components/sessionstore/test/browser_500328.js b/browser/components/sessionstore/test/browser_500328.js
new file mode 100644
index 0000000000..a32917c9c2
--- /dev/null
+++ b/browser/components/sessionstore/test/browser_500328.js
@@ -0,0 +1,132 @@
+/* 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/. */
+
+async function checkState(browser) {
+  await SpecialPowers.spawn(browser, [], () => {
+    // Go back and then forward, and make sure that the state objects received
+    // from the popState event are as we expect them to be.
+    //
+    // We also add a node to the document's body when after going back and make
+    // sure it's still there after we go forward -- this is to test that the two
+    // history entries correspond to the same document.
+
+    // Set some state in the page's window.  When we go back(), the page should
+    // be retrieved from bfcache, and this state should still be there.
+    content.testState = "foo";
+  });
+
+  // Now go back.  This should trigger the popstate event handler.
+  let popstatePromise = SpecialPowers.spawn(browser, [], async () => {
+    let event = await ContentTaskUtils.waitForEvent(content, "popstate", true);
+    ok(event.state, "Event should have a state property.");
+
+    is(content.testState, "foo", "testState after going back");
+    is(
+      JSON.stringify(content.history.state),
+      JSON.stringify({ obj1: 1 }),
+      "first popstate object."
+    );
+
+    // Add a node with id "new-elem" to the document.
+    let doc = content.document;
+    ok(
+      !doc.getElementById("new-elem"),
+      "doc shouldn't contain new-elem before we add it."
+    );
+    let elem = doc.createElement("div");
+    elem.id = "new-elem";
+    doc.body.appendChild(elem);
+  });
+
+  // Ensure that the message manager has processed the previous task before
+  // going back to prevent racing with it in non-e10s mode.
+  await SpecialPowers.spawn(browser, [], () => {});
+  browser.goBack();
+
+  await popstatePromise;
+
+  popstatePromise = SpecialPowers.spawn(browser, [], async () => {
+    let event = await ContentTaskUtils.waitForEvent(content, "popstate", true);
+
+    // When content fires a PopStateEvent and we observe it from a chrome event
+    // listener (as we do here, and, thankfully, nowhere else in the tree), the
+    // state object will be a cross-compartment wrapper to an object that was
+    // deserialized in the content scope. And in this case, since RegExps are
+    // not currently Xrayable (see bug 1014991), trying to pull |obj3| (a RegExp)
+    // off of an Xrayed Object won't work. So we need to waive.
+    Assert.equal(
+      Cu.waiveXrays(event.state).obj3.toString(),
+      "/^a$/",
+      "second popstate object."
+    );
+
+    // Make sure that the new-elem node is present in the document.  If it's
+    // not, then this history entry has a different doc identifier than the
+    // previous entry, which is bad.
+    let doc = content.document;
+    let newElem = doc.getElementById("new-elem");
+    ok(newElem, "doc should contain new-elem.");
+    newElem.remove();
+    ok(!doc.getElementById("new-elem"), "new-elem should be removed.");
+  });
+
+  // Ensure that the message manager has processed the previous task before
+  // going forward to prevent racing with it in non-e10s mode.
+  await SpecialPowers.spawn(browser, [], () => {});
+  browser.goForward();
+  await popstatePromise;
+}
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.navigation.requireUserInteraction", false]],
+  });
+
+  // Tests session restore functionality of history.pushState and
+  // history.replaceState().  (Bug 500328)
+
+  // We open a new blank window, let it load, and then load in
+  // http://example.com.  We need to load the blank window first, otherwise the
+  // docshell gets confused and doesn't have a current history entry.
+  let state;
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function (browser) {
+      BrowserTestUtils.loadURIString(browser, "http://example.com");
+      await BrowserTestUtils.browserLoaded(browser);
+
+      // After these push/replaceState calls, the window should have three
+      // history entries:
+      //   testURL        (state object: null)          <-- oldest
+      //   testURL        (state object: {obj1:1})
+      //   testURL?page2  (state object: {obj3:/^a$/})  <-- newest
+      function contentTest() {
+        let history = content.window.history;
+        history.pushState({ obj1: 1 }, "title-obj1");
+        history.pushState({ obj2: 2 }, "title-obj2", "?page2");
+        history.replaceState({ obj3: /^a$/ }, "title-obj3");
+      }
+      await SpecialPowers.spawn(browser, [], contentTest);
+      await TabStateFlusher.flush(browser);
+
+      state = ss.getTabState(gBrowser.getTabForBrowser(browser));
+    }
+  );
+
+  // Restore the state into a new tab.  Things don't work well when we
+  // restore into the old tab, but that's not a real use case anyway.
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function (browser) {
+      let tab2 = gBrowser.getTabForBrowser(browser);
+
+      let tabRestoredPromise = promiseTabRestored(tab2);
+      ss.setTabState(tab2, state, true);
+
+      // Run checkState() once the tab finishes loading its restored state.
+      await tabRestoredPromise;
+      await checkState(browser);
+    }
+  );
+});