From ebdfc5ad46bd97c4315bed6d99e366335b5e24ab Mon Sep 17 00:00:00 2001
From: Blink WPT Bot <blink-w3c-test-autoroller@chromium.org>
Date: Sat, 17 Jul 2021 09:46:22 +0000
Subject: [PATCH] Bug 1718698 [wpt PR 29538] - Move app history tests to public
 WPT, a=testonly

Automatic update from web-platform-tests
Move app history tests to public WPT (#29538)

Bug: 1183545
Change-Id: Ie06b392f1982227946a118d16982dff8dd9a4051
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2991902
Auto-Submit: Domenic Denicola <domenic@chromium.org>
Reviewed-by: Nate Chapin <japhet@chromium.org>
Commit-Queue: Domenic Denicola <domenic@chromium.org>
Cr-Commit-Position: refs/heads/master@{#897133}

Co-authored-by: Domenic Denicola <domenic@chromium.org>
--

wpt-commits: 86c19366cdacbeca332982dbd6fd3c7c496f92f2
wpt-pr: 29538
---
 .../web-platform/tests/app-history/META.yml   |   4 +
 .../app-history-entry/after-detach.html       |  20 ++++
 .../current-after-detach.html                 |  17 +++
 .../app-history-entry/current-basic.html      | 107 ++++++++++++++++++
 .../entries-across-origins.html               |  33 ++++++
 .../entries-after-blank-navigation.html       |  25 ++++
 .../entries-after-blob-navigation.html        |  25 ++++
 .../entries-after-data-url-navigation.html    |  23 ++++
 ...tries-after-javascript-url-navigation.html |  38 +++++++
 ...after-navigations-in-multiple-windows.html |  34 ++++++
 .../entries-after-srcdoc-navigation.html      |  25 ++++
 .../entries-array-equality.html               |   8 ++
 .../entries-when-inactive.html                |  16 +++
 .../index-not-in-entries.html                 |  24 ++++
 .../key-navigate-back-cross-document.html     |  15 +++
 .../key-navigate-back-same-document.html      |  24 ++++
 .../key-navigate-location-reload.html         |  18 +++
 ...avigate-location-replace-cross-origin.html |  17 +++
 .../key-navigate-location-replace.html        |  18 +++
 .../app-history-entry/resources/is_uuid.js    |   3 +
 ...y-navigate-back-cross-document-helper.html |  27 +++++
 .../resources/post-entries-length-to-top.html |   7 ++
 .../resources/post-key-to-top.html            |   3 +
 .../sameDocument-after-fragment-navigate.html |  30 +++++
 .../sameDocument-after-navigate.html          |  14 +++
 .../navigate-anchor-cross-origin.html         |  19 ++++
 .../navigate-anchor-fragment.html             |  20 ++++
 ...ate-anchor-same-origin-cross-document.html |  20 ++++
 .../navigate-anchor-userInitiated.html        |  24 ++++
 .../navigate-anchor-with-target.html          |  26 +++++
 ...vigate-appHistory-back-cross-document.html |  25 ++++
 ...avigate-appHistory-back-same-document.html |  25 ++++
 .../navigate-appHistory-navigate.html         |  17 +++
 ...navigate-cross-origin-iframe-location.html |  24 ++++
 ...ate-destination-getState-back-forward.html |  20 ++++
 ...avigate-destination-getState-navigate.html |  19 ++++
 .../navigate-form-userInitiated.html          |  24 ++++
 .../navigate-form-with-target.html            |  27 +++++
 .../navigate-event/navigate-form.html         |  19 ++++
 .../navigate-history-back-after-fragment.html |  24 ++++
 ...navigate-history-back-after-pushState.html |  24 ++++
 .../navigate-event/navigate-history-go-0.html |  22 ++++
 .../navigate-history-pushState.html           |  24 ++++
 .../navigate-history-replaceState.html        |  24 ++++
 .../navigate-iframe-location.html             |  25 ++++
 .../navigate-event/navigate-location.html     |  18 +++
 .../navigate-event/navigate-meta-refresh.html |  22 ++++
 .../navigate-window-open-self.html            |  18 +++
 .../navigate-event/navigate-window-open.html  |  25 ++++
 .../navigate-within-onnavigate.html           |  16 +++
 .../navigatesuccess-cross-document.html       |  14 +++
 .../navigatesuccess-same-document.html        |  10 ++
 .../resources/cross-origin-iframe-helper.html |  17 +++
 .../resources/meta-refresh.html               |   4 +
 ...navigatesuccess-cross-document-helper.html |   6 +
 .../respondWith-appHistory-back.html          |  19 ++++
 ...espondWith-cross-document-same-origin.html |  19 ++++
 .../respondWith-cross-origin.html             |  18 +++
 .../navigate-event/respondWith-detach.html    |  17 +++
 .../respondWith-history-pushState.html        |  23 ++++
 .../respondWith-history-replaceState.html     |  23 ++++
 .../respondWith-multiple-times.html           |  14 +++
 .../respondWith-on-synthetic-event.html       |   8 ++
 .../navigate-event/respondWith-reject.html    |  26 +++++
 .../navigate-event/respondWith-resolve.html   |  20 ++++
 ...espondWith-same-document-history-back.html |  40 +++++++
 .../navigate/back-forward-out-of-bounds.html  |  13 +++
 .../navigate/disambigaute-back.html           |  32 ++++++
 .../navigate/disambigaute-forward.html        |  40 +++++++
 .../disambigaute-goto-back-multiple.html      |  35 ++++++
 .../disambigaute-goto-forward-multiple.html   |  43 +++++++
 .../navigate/goTo-after-adding-iframe.html    |  34 ++++++
 .../navigate/goTo-after-data-url.html         |  33 ++++++
 ...-document-deatch-iframe-in-onnavigate.html |  22 ++++
 .../goTo-cross-document-preventDefault.html   |  22 ++++
 .../navigate/goTo-cross-document.html         |  41 +++++++
 .../app-history/navigate/goTo-current.html    |  18 +++
 .../navigate/goTo-detach-in-onnavigate.html   |  19 ++++
 .../navigate/goTo-in-detached-window.html     |  16 +++
 .../navigate/goTo-invalid-key.html            |   8 ++
 .../navigate/goTo-multiple-steps.html         |  30 +++++
 .../app-history/navigate/goTo-repeated.html   |  18 +++
 .../navigate/goTo-same-document.html          |  43 +++++++
 .../goTo-with-cross-origin-in-history.html    |  37 ++++++
 .../navigate-cross-document-event-order.html  |  32 ++++++
 .../navigate/navigate-cross-document.html     |  17 +++
 .../app-history/navigate/navigate-detach.html |  12 ++
 .../navigate-history-state-replace.html       |  16 +++
 .../navigate/navigate-history-state.html      |  16 +++
 .../navigate/navigate-in-detached-window.html |  12 ++
 .../navigate/navigate-info-and-state.html     |  18 +++
 .../navigate/navigate-invalid-url.html        |  10 ++
 .../navigate/navigate-no-args.html            |  10 ++
 .../navigate/navigate-preventDefault.html     |   9 ++
 .../navigate/navigate-relative-url.html       |  16 +++
 .../navigate-replace-cross-document.html      |  29 +++++
 .../navigate-replace-same-document.html       |  21 ++++
 .../navigate-respondWith-history-state.html   |  15 +++
 ...vigate-respondWith-reject-event-order.html |  27 +++++
 .../navigate/navigate-respondWith-reject.html |  13 +++
 .../navigate/navigate-respondWith.html        |  13 +++
 .../navigate-same-document-event-order.html   |  23 ++++
 .../navigate/navigate-same-document.html      |  23 ++++
 .../navigate-without-url-arg-replace.html     |  25 ++++
 .../navigate/navigate-without-url-arg.html    |  27 +++++
 .../navigate/resources/notify-top-early.html  |   6 +
 ...avigate-state-after-history-pushState.html |  11 ++
 ...gate-state-after-history-replaceState.html |  11 ++
 .../state/navigate-state-after-reload.html    |  19 ++++
 ...same-document-location-api-navigation.html |  49 ++++++++
 ...-state-after-same-document-navigation.html |  53 +++++++++
 ...tate-cross-document-location-navigate.html |  20 ++++
 ...navigate-state-cross-document-restore.html |  31 +++++
 .../state/navigate-state-invalid.html         |  18 +++
 114 files changed, 2510 insertions(+)
 create mode 100644 testing/web-platform/tests/app-history/META.yml
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/after-detach.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/current-after-detach.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/current-basic.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-across-origins.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-blank-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-blob-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-data-url-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-javascript-url-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-navigations-in-multiple-windows.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-after-srcdoc-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-array-equality.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/entries-when-inactive.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/index-not-in-entries.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-reload.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace-cross-origin.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/resources/is_uuid.js
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/resources/key-navigate-back-cross-document-helper.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/resources/post-entries-length-to-top.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/resources/post-key-to-top.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-fragment-navigate.html
 create mode 100644 testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-navigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-anchor-cross-origin.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-anchor-fragment.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-anchor-same-origin-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-anchor-userInitiated.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-anchor-with-target.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-navigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-cross-origin-iframe-location.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-back-forward.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-navigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-form-userInitiated.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-form-with-target.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-form.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-fragment.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-pushState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-history-go-0.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-history-pushState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-history-replaceState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-iframe-location.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-location.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-meta-refresh.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-window-open-self.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-window-open.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigate-within-onnavigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigatesuccess-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/navigatesuccess-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/resources/cross-origin-iframe-helper.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/resources/meta-refresh.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/resources/navigatesuccess-cross-document-helper.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-appHistory-back.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-cross-document-same-origin.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-cross-origin.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-detach.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-history-pushState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-history-replaceState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-multiple-times.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-on-synthetic-event.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-reject.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-resolve.html
 create mode 100644 testing/web-platform/tests/app-history/navigate-event/respondWith-same-document-history-back.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/back-forward-out-of-bounds.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/disambigaute-back.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/disambigaute-forward.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/disambigaute-goto-back-multiple.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/disambigaute-goto-forward-multiple.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-after-adding-iframe.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-after-data-url.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-cross-document-deatch-iframe-in-onnavigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-cross-document-preventDefault.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-current.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-detach-in-onnavigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-in-detached-window.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-invalid-key.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-multiple-steps.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-repeated.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/goTo-with-cross-origin-in-history.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-cross-document-event-order.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-detach.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-history-state-replace.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-history-state.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-in-detached-window.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-info-and-state.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-invalid-url.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-no-args.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-preventDefault.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-relative-url.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-replace-cross-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-replace-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-respondWith-history-state.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject-event-order.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-respondWith.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-same-document-event-order.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-same-document.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-without-url-arg-replace.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/navigate-without-url-arg.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/resources/notify-top-early.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-pushState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-replaceState.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-after-reload.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-location-api-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-navigation.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-location-navigate.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-restore.html
 create mode 100644 testing/web-platform/tests/app-history/navigate/state/navigate-state-invalid.html

diff --git a/testing/web-platform/tests/app-history/META.yml b/testing/web-platform/tests/app-history/META.yml
new file mode 100644
index 000000000000..ec4e3701cc73
--- /dev/null
+++ b/testing/web-platform/tests/app-history/META.yml
@@ -0,0 +1,4 @@
+spec: https://wicg.github.io/app-history/
+suggested_reviewers:
+  - domenic
+  - natechapin
diff --git a/testing/web-platform/tests/app-history/app-history-entry/after-detach.html b/testing/web-platform/tests/app-history/app-history-entry/after-detach.html
new file mode 100644
index 000000000000..9d99918c5b26
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/after-detach.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func_done(() => {
+    let i_entry = i.contentWindow.appHistory.current;
+    assert_true(i_entry.sameDocument);
+    assert_not_equals(i_entry.url, "");
+    assert_not_equals(i_entry.key, "");
+    assert_not_equals(i_entry.id, "");
+    i.remove();
+    assert_false(i_entry.sameDocument);
+    assert_equals(i_entry.url, "");
+    assert_equals(i_entry.key, "");
+    assert_equals(i_entry.id, "");
+  });
+}, "AppHistoryEntry attributes after detach");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/current-after-detach.html b/testing/web-platform/tests/app-history/app-history-entry/current-after-detach.html
new file mode 100644
index 000000000000..97302251a9e4
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/current-after-detach.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func_done(() => {
+    let i_appHistory = i.contentWindow.appHistory;
+    assert_not_equals(i_appHistory, null);
+    assert_not_equals(i_appHistory.current, null);
+    assert_equals(i_appHistory.entries().length, 1);
+    i.remove();
+    assert_equals(i_appHistory.current, null);
+    assert_equals(i_appHistory.entries().length, 0);
+  });
+}, "appHistory.current should be null after iframe removal");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/current-basic.html b/testing/web-platform/tests/app-history/app-history-entry/current-basic.html
new file mode 100644
index 000000000000..102fbbb270d7
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/current-basic.html
@@ -0,0 +1,107 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/is_uuid.js"></script>
+<script>
+test(() => {
+  let first_entry = appHistory.current;
+  assert_not_equals(first_entry, null);
+  assert_not_equals(first_entry.key, null);
+  assert_true(isUUID(first_entry.key));
+  assert_not_equals(first_entry.id, null);
+  assert_true(isUUID(first_entry.id));
+  assert_equals(first_entry.url, location.href);
+  assert_true(first_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 1);
+  assert_equals(first_entry, appHistory.entries()[0]);
+
+  history.replaceState(2, "", "#2");
+  let second_entry = appHistory.current;
+  assert_not_equals(second_entry, first_entry);
+  assert_equals(second_entry.key, first_entry.key);
+  assert_true(isUUID(second_entry.key));
+  assert_not_equals(second_entry.id, first_entry.id);
+  assert_true(isUUID(second_entry.id));
+  assert_equals(second_entry.url, location.href);
+  assert_true(second_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 1);
+  assert_equals(second_entry, appHistory.entries()[0]);
+
+  history.pushState(3, "", "#3");
+  let third_entry = appHistory.current;
+  assert_not_equals(third_entry, second_entry);
+  assert_not_equals(third_entry.key, second_entry.key);
+  assert_true(isUUID(third_entry.key));
+  assert_not_equals(third_entry.id, second_entry.id);
+  assert_true(isUUID(third_entry.id));
+  assert_equals(third_entry.url, location.href);
+  assert_true(third_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 2);
+  assert_equals(third_entry, appHistory.entries()[1]);
+
+  history.pushState(4, "");
+  let fourth_entry = appHistory.current;
+  assert_not_equals(fourth_entry, third_entry);
+  assert_not_equals(fourth_entry.key, third_entry.key);
+  assert_true(isUUID(fourth_entry.key));
+  assert_not_equals(fourth_entry.id, third_entry.id);
+  assert_true(isUUID(fourth_entry.id));
+  assert_equals(fourth_entry.url, third_entry.url);
+  assert_true(fourth_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 3);
+  assert_equals(fourth_entry, appHistory.entries()[2]);
+
+  history.replaceState(5, "");
+  let fifth_entry = appHistory.current;
+  assert_not_equals(fifth_entry, fourth_entry);
+  assert_equals(fifth_entry.key, fourth_entry.key);
+  assert_true(isUUID(fifth_entry.key));
+  assert_not_equals(fifth_entry.id, fourth_entry.id);
+  assert_true(isUUID(fifth_entry.id));
+  assert_equals(fifth_entry.url, fourth_entry.url);
+  assert_true(fifth_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 3);
+  assert_equals(fifth_entry, appHistory.entries()[2]);
+
+  history.pushState(5, "");
+  let fifth_entry_after_push = appHistory.current;
+  assert_not_equals(fifth_entry_after_push, fifth_entry);
+  assert_not_equals(fifth_entry_after_push.key, fifth_entry.key);
+  assert_true(isUUID(fifth_entry_after_push.key));
+  assert_not_equals(fifth_entry_after_push.id, fifth_entry.id);
+  assert_true(isUUID(fifth_entry_after_push.id));
+  assert_equals(fifth_entry_after_push.url, fifth_entry.url);
+  assert_true(fifth_entry_after_push.sameDocument);
+  assert_equals(appHistory.entries().length, 4);
+  assert_equals(fifth_entry_after_push, appHistory.entries()[3]);
+
+  history.replaceState(5, "");
+  let fifth_entry_after_replace = appHistory.current;
+  assert_not_equals(fifth_entry_after_replace, fifth_entry_after_push);
+  assert_equals(fifth_entry_after_replace.key, fifth_entry_after_push.key);
+  assert_true(isUUID(fifth_entry_after_replace.key));
+  assert_not_equals(fifth_entry_after_replace.id, fifth_entry_after_push.id);
+  assert_true(isUUID(fifth_entry_after_replace.id));
+  assert_equals(fifth_entry_after_replace.url, fifth_entry_after_push.url);
+  assert_true(fifth_entry_after_replace.sameDocument);
+  assert_equals(appHistory.entries().length, 4);
+  assert_equals(fifth_entry_after_replace, appHistory.entries()[3]);
+
+  location.hash = "6";
+  let sixth_entry = appHistory.current;
+  assert_not_equals(sixth_entry, fifth_entry_after_replace);
+  assert_equals(sixth_entry.key, fifth_entry_after_replace.key);
+  assert_true(isUUID(sixth_entry.key));
+  assert_not_equals(sixth_entry.id, fifth_entry_after_replace.id);
+  assert_true(isUUID(sixth_entry.id));
+  assert_not_equals(sixth_entry.url, fifth_entry_after_replace.url);
+  assert_true(sixth_entry.sameDocument);
+  assert_equals(appHistory.entries().length, 4);
+  assert_equals(sixth_entry, appHistory.entries()[3]);
+
+  appHistory.entries().forEach(entry => {
+    assert_true(isUUID(entry.id));
+    assert_true(isUUID(entry.key));
+  });
+}, "Basic tests for appHistory.current");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-across-origins.html b/testing/web-platform/tests/app-history/app-history-entry/entries-across-origins.html
new file mode 100644
index 000000000000..b6e8e9ee7340
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-across-origins.html
@@ -0,0 +1,33 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<script src="resources/is_uuid.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let start_key = i.contentWindow.appHistory.current.key;
+    let start_id = i.contentWindow.appHistory.current.id;
+
+    let cross_origin_url = new URL("resources/post-entries-length-to-top.html", location.href);
+    cross_origin_url.hostname = get_host_info().REMOTE_HOST;
+    i.contentWindow.location.assign(cross_origin_url.href);
+
+    window.onmessage = t.step_func(e => {
+      assert_equals(e.data, 1);
+
+      i.src = "/common/blank.html?2";
+      i.onload = t.step_func_done(() => {
+        let entries = i.contentWindow.appHistory.entries();
+        assert_equals(entries.length, 1);
+        assert_equals(new URL(entries[0].url).search, "?2");
+        assert_not_equals(entries[0].key, start_key);
+        assert_not_equals(entries[0].id, start_id);
+        assert_true(isUUID(entries[0].key));
+        assert_true(isUUID(entries[0].id));
+      });
+    });
+  });
+}, "appHistory.entries() should only contain entries that are both same-origin and contiguous");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-blank-navigation.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-blank-navigation.html
new file mode 100644
index 000000000000..60068561d14c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-blank-navigation.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/is_uuid.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.onload = t.step_func_done(() => {
+      let entries = i.contentWindow.appHistory.entries();
+      assert_equals(entries.length, 2);
+      assert_not_equals(entries[1].key, entries[0].key);
+      assert_not_equals(entries[1].url, entries[0].url);
+      assert_equals(entries[1].url, "about:blank");
+      assert_not_equals(entries[1].id, entries[0].id);
+
+      assert_true(isUUID(entries[0].key));
+      assert_true(isUUID(entries[0].id));
+      assert_true(isUUID(entries[1].key));
+      assert_true(isUUID(entries[1].id));
+    });
+    i.src = "about:blank";
+  });
+}, "AppHistory behavior after navigation to about:blank");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-blob-navigation.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-blob-navigation.html
new file mode 100644
index 000000000000..c1ce46d1fbd3
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-blob-navigation.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/is_uuid.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.onload = t.step_func_done(() => {
+      let entries = i.contentWindow.appHistory.entries();
+      assert_equals(entries.length, 2);
+      assert_not_equals(entries[1].key, entries[0].key);
+      assert_not_equals(entries[1].url, entries[0].url);
+      assert_equals(new URL(entries[1].url).protocol, "blob:");
+      assert_not_equals(entries[1].id, entries[0].id);
+
+      assert_true(isUUID(entries[0].key));
+      assert_true(isUUID(entries[0].id));
+      assert_true(isUUID(entries[1].key));
+      assert_true(isUUID(entries[1].id));
+    });
+    i.src = URL.createObjectURL(new Blob(["<body></body>"]));
+  });
+}, "AppHistory behavior after navigation to a blob: url");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-data-url-navigation.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-data-url-navigation.html
new file mode 100644
index 000000000000..f57e991efd02
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-data-url-navigation.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let start_key = i.contentWindow.appHistory.current.key;
+    let start_url = i.contentWindow.appHistory.current.url;
+    let start_id = i.contentWindow.appHistory.current.id;
+    window.onmessage = t.step_func_done(e => {
+      assert_equals(e.data.length, 1);
+      assert_not_equals(e.data.key, start_key);
+      assert_equals(e.data.protocol, "data:");
+      assert_not_equals(e.data.id, start_id);
+    });
+    i.src = "data:text/html,<script>top.postMessage({ length: appHistory.entries().length, " +
+        "key: appHistory.current.key, protocol: new URL(appHistory.current.url).protocol," +
+        "id: appHistory.current.id}, '*')</sc" +
+        "ript>";
+  });
+}, "AppHistory behavior after navigation to a data: url");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-javascript-url-navigation.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-javascript-url-navigation.html
new file mode 100644
index 000000000000..2ed1d81fe94e
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-javascript-url-navigation.html
@@ -0,0 +1,38 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let start_key = i.contentWindow.appHistory.current.key;
+    let start_url = i.contentWindow.appHistory.current.url;
+    let start_id = i.contentWindow.appHistory.current.id;
+    let did_js_url_nav = false;
+    i.onload = t.step_func(() => {
+      if (!did_js_url_nav) {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        before_js_nav_key = i.contentWindow.appHistory.current.key;
+        before_js_nav_url = i.contentWindow.appHistory.current.url;
+        before_js_nav_id = i.contentWindow.appHistory.current.id;
+        i.src = "javascript:'new content'";
+        did_js_url_nav = true;
+      } else {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        let first_entry = i.contentWindow.appHistory.entries()[0];
+        let js_url_entry = i.contentWindow.appHistory.entries()[1];
+        assert_equals(first_entry.key, start_key);
+        assert_equals(first_entry.url, start_url);
+        assert_equals(first_entry.id, start_id);
+
+        assert_equals(js_url_entry, i.contentWindow.appHistory.current);
+        assert_equals(js_url_entry.key, before_js_nav_key);
+        assert_equals(js_url_entry.url, before_js_nav_url);
+        assert_not_equals(js_url_entry.id, before_js_nav_id);
+        t.done();
+      }
+    });
+    i.contentWindow.appHistory.navigate("?1");
+  });
+}, "AppHistory behavior after navigation to a javascript: url");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-navigations-in-multiple-windows.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-navigations-in-multiple-windows.html
new file mode 100644
index 000000000000..55cb58ea0022
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-navigations-in-multiple-windows.html
@@ -0,0 +1,34 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/is_uuid.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // The navigations in each window should have only added an appHistory to
+  // their own window.
+  function assertExpectedEntries(entries, expected_url) {
+    assert_equals(entries.length, 2);
+    assert_not_equals(entries[1].key, entries[0].key);
+    assert_not_equals(entries[1].url, entries[0].url);
+    assert_not_equals(entries[1].id, entries[0].id);
+    assert_true(isUUID(entries[0].key));
+    assert_true(isUUID(entries[0].id));
+    assert_true(isUUID(entries[1].key));
+    assert_true(isUUID(entries[1].id));
+
+    assert_equals(entries[1].url, expected_url);
+  }
+
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(t.step_func(() => {
+    location.hash = "#1";
+    i.onload = t.step_func_done(() => {
+      assertExpectedEntries(appHistory.entries(), location.href);
+      assertExpectedEntries(i.contentWindow.appHistory.entries(), i.contentWindow.location.href);
+    });
+    i.contentWindow.location = "/common/blank.html?2";
+  }), 0);
+}, "appHistory.entries() behavior when multiple windows navigate.");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-after-srcdoc-navigation.html b/testing/web-platform/tests/app-history/app-history-entry/entries-after-srcdoc-navigation.html
new file mode 100644
index 000000000000..cfb1337cabfb
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-after-srcdoc-navigation.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/is_uuid.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.onload = t.step_func_done(() => {
+      let entries = i.contentWindow.appHistory.entries();
+      assert_equals(entries.length, 2);
+      assert_not_equals(entries[1].key, entries[0].key);
+      assert_not_equals(entries[1].url, entries[0].url);
+      assert_equals(entries[1].url, "about:srcdoc");
+      assert_not_equals(entries[1].id, entries[0].id);
+
+      assert_true(isUUID(entries[0].key));
+      assert_true(isUUID(entries[0].id));
+      assert_true(isUUID(entries[1].key));
+      assert_true(isUUID(entries[1].id));
+    });
+    i.srcdoc = "new";
+  });
+}, "AppHistory behavior after setting a srcdoc attribute");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-array-equality.html b/testing/web-platform/tests/app-history/app-history-entry/entries-array-equality.html
new file mode 100644
index 000000000000..e6eb99863d03
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-array-equality.html
@@ -0,0 +1,8 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  assert_not_equals(appHistory.entries(), appHistory.entries());
+}, "appHistory.entries() should not return an identical object on repeated invocations");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/entries-when-inactive.html b/testing/web-platform/tests/app-history/app-history-entry/entries-when-inactive.html
new file mode 100644
index 000000000000..a7073778fb5a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/entries-when-inactive.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  const first_entry = appHistory.entries()[0];
+  history.pushState(1, "", "#1");
+  assert_equals(appHistory.entries()[0], first_entry);
+  history.back();
+  window.onpopstate = t.step_func_done(() => {
+    const second_entry = appHistory.entries()[1];
+    history.replaceState(0, "", "#0");
+    assert_equals(appHistory.entries()[1], second_entry);
+  });
+}, "A non-active entry in appHistory.entries() should not be modified when a different entry is modified");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/index-not-in-entries.html b/testing/web-platform/tests/app-history/app-history-entry/index-not-in-entries.html
new file mode 100644
index 000000000000..394dfa976368
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/index-not-in-entries.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(t.step_func_done(() => {
+    // Remove the entry by replacing it.
+    let replaced_entry = appHistory.current;
+    assert_equals(replaced_entry.index, 0);
+    appHistory.navigate("#0", { replace: true });
+    assert_equals(replaced_entry.index, -1);
+
+    // Remove the entry by detaching its window.
+    let iframe_entry = i.contentWindow.appHistory.current;
+    assert_equals(iframe_entry.index, 0);
+    i.remove();
+    assert_equals(iframe_entry.index, -1);
+    t.done();
+  }), 0);
+}, "AppHistoryEntry.index should return -1 when not in AppHistory.entries");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-cross-document.html b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-cross-document.html
new file mode 100644
index 000000000000..a581c0100cc3
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-cross-document.html
@@ -0,0 +1,15 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="resources/key-navigate-back-cross-document-helper.html"></iframe>
+<script>
+async_test(t => {
+  window.finish = t.step_func_done((end_key, end_id) => {
+    assert_equals(window.start_key, end_key);
+    assert_equals(window.start_id, end_id);
+    // The new history entry in the iframe should not add any entries to
+    // this window's appHistory.
+    assert_equals(appHistory.entries().length, 1);
+  });
+}, "AppHistoryEntry.key behavior on cross-document back navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-same-document.html b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-same-document.html
new file mode 100644
index 000000000000..e3eeb15b2e44
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-back-same-document.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let key = appHistory.current.key;
+  let id = appHistory.current.id;
+  assert_equals(appHistory.entries().length, 1);
+
+  history.pushState("hash", "", "#hash");
+  assert_not_equals(key, appHistory.current.key);
+  assert_not_equals(id, appHistory.current.id);
+  assert_equals(appHistory.entries().length, 2);
+  assert_equals(appHistory.current.index, 1);
+
+  window.onpopstate = t.step_func_done(() => {
+    assert_equals(key, appHistory.current.key);
+    assert_equals(id, appHistory.current.id);
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 0);
+  });
+  history.back();
+}, "AppHistoryEntry.key behavior on same-document back navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-reload.html b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-reload.html
new file mode 100644
index 000000000000..8770f1624f8d
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-reload.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let key = i.contentWindow.appHistory.current.key;
+    let id = i.contentWindow.appHistory.current.id;
+    i.contentWindow.location.reload();
+    i.onload = t.step_func_done(() => {
+      assert_equals(key, i.contentWindow.appHistory.current.key);
+      assert_not_equals(id, i.contentWindow.appHistory.current.id);
+      assert_equals(appHistory.entries().length, 1);
+    });
+  });
+}, "AppHistoryEntry.key behavior after location.reload()");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace-cross-origin.html b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace-cross-origin.html
new file mode 100644
index 000000000000..dabe55e8bf7c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace-cross-origin.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let key_before_replace = i.contentWindow.appHistory.current.key;
+    window.onmessage = t.step_func_done(e => assert_not_equals(key_before_replace, e.data));
+
+    let cross_origin_url = new URL("resources/post-key-to-top.html", location.href);
+    cross_origin_url.hostname = get_host_info().REMOTE_HOST;
+    i.contentWindow.location.replace(cross_origin_url.href);
+  });
+}, "AppHistoryEntry.key behavior after location.replace()");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace.html b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace.html
new file mode 100644
index 000000000000..4c5060da4155
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/key-navigate-location-replace.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let key = i.contentWindow.appHistory.current.key;
+    let id = i.contentWindow.appHistory.current.id;
+    i.contentWindow.location.replace("/common/blank.html?query");
+    i.onload = t.step_func_done(() => {
+      assert_equals(key, i.contentWindow.appHistory.current.key);
+      assert_not_equals(id, i.contentWindow.appHistory.current.id);
+      assert_equals(appHistory.entries().length, 1);
+    });
+  });
+}, "AppHistoryEntry.key behavior after location.replace()");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/resources/is_uuid.js b/testing/web-platform/tests/app-history/app-history-entry/resources/is_uuid.js
new file mode 100644
index 000000000000..3b855c01b075
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/resources/is_uuid.js
@@ -0,0 +1,3 @@
+function isUUID(key) {
+  return /[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}/.test(key);
+}
diff --git a/testing/web-platform/tests/app-history/app-history-entry/resources/key-navigate-back-cross-document-helper.html b/testing/web-platform/tests/app-history/app-history-entry/resources/key-navigate-back-cross-document-helper.html
new file mode 100644
index 000000000000..f61f9a829820
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/resources/key-navigate-back-cross-document-helper.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script>
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+window.onload = () => step_timeout(() => {
+  if (location.search == "?go-back") {
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 1);
+    // Step 2: Navigate back.
+    history.back();
+    return;
+  }
+  if (top.start_key) {
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 0);
+    // Step 3: Notify parent, which will ensure the same key is used after back navigation.
+    top.finish(appHistory.current.key, appHistory.current.id);
+    return;
+  }
+  // Step 1: Record initial key and navigate.
+  assert_equals(appHistory.entries().length, 1);
+  top.start_key = appHistory.current.key;
+  top.start_id = appHistory.current.id;
+  location.search = "go-back";
+}, 0);
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/resources/post-entries-length-to-top.html b/testing/web-platform/tests/app-history/app-history-entry/resources/post-entries-length-to-top.html
new file mode 100644
index 000000000000..348a8984fe10
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/resources/post-entries-length-to-top.html
@@ -0,0 +1,7 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script>
+// Wait for after the load event so that the navigation doesn't get converted
+// into a replace navigation.
+window.onload = () => step_timeout(() => top.postMessage(appHistory.entries().length, "*"), 0);
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/resources/post-key-to-top.html b/testing/web-platform/tests/app-history/app-history-entry/resources/post-key-to-top.html
new file mode 100644
index 000000000000..023141f76a3a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/resources/post-key-to-top.html
@@ -0,0 +1,3 @@
+<script>
+top.postMessage(appHistory.current.key, "*");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-fragment-navigate.html b/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-fragment-navigate.html
new file mode 100644
index 000000000000..732b10964efe
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-fragment-navigate.html
@@ -0,0 +1,30 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(t.step_func_done(() => {
+    let entry1 = appHistory.current;
+    assert_true(entry1.sameDocument);
+
+    location = "#hash";
+    let entry2 = appHistory.current;
+    assert_not_equals(entry1, entry2);
+    assert_true(entry1.sameDocument);
+
+    history.pushState("push", "", "#push");
+    let entry3 = appHistory.current;
+    assert_not_equals(entry1, entry3);
+    assert_not_equals(entry2, entry3);
+    assert_true(entry1.sameDocument);
+    assert_true(entry2.sameDocument);
+
+    assert_equals(appHistory.entries().length, 3);
+    assert_equals(appHistory.entries()[0], entry1);
+    assert_equals(appHistory.entries()[1], entry2);
+    assert_equals(appHistory.entries()[2], entry3);
+  }), 0);
+}, "AppHistoryEntry.sameDocument after same-document navigations");
+</script>
diff --git a/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-navigate.html b/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-navigate.html
new file mode 100644
index 000000000000..1e984b336a67
--- /dev/null
+++ b/testing/web-platform/tests/app-history/app-history-entry/sameDocument-after-navigate.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let i_entry = i.contentWindow.appHistory.current;
+    assert_true(i_entry.sameDocument);
+    i.onload = t.step_func_done(() => assert_false(i_entry.sameDocument));
+    i.contentWindow.location = "about:blank";
+  });
+}, "AppHistoryEntry.sameDocument after cross-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-cross-origin.html b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-cross-origin.html
new file mode 100644
index 000000000000..ff007261714a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-cross-origin.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<a id="a" href="https://does-not-exist/foo.html"></a>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_false(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(e.formData, null);
+    assert_equals(e.destination.url, "https://does-not-exist/foo.html");
+    assert_false(e.destination.sameDocument);
+    e.preventDefault();
+  });
+  a.click();
+}, "<a> cross-origin navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-fragment.html b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-fragment.html
new file mode 100644
index 000000000000..3ed125c194fa
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-fragment.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<a id="a" href="#1"></a>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_true(e.hashChange);
+    assert_equals(e.formData, null);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    e.preventDefault();
+    t.step_timeout(t.step_func_done(() => assert_equals(location.hash, "")), 0);
+  });
+  a.click();
+}, "Fragment <a> click fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-same-origin-cross-document.html b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-same-origin-cross-document.html
new file mode 100644
index 000000000000..21f5c065fb0d
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-same-origin-cross-document.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<a id="a" href="foo.html"></a>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(e.formData, null);
+    assert_equals(new URL(e.destination.url).pathname,
+                  "/app-history/navigate-event/foo.html");
+    assert_false(e.destination.sameDocument);
+    e.preventDefault();
+  });
+  a.click();
+}, "<a> cross-document (but same-origin) navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-userInitiated.html b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-userInitiated.html
new file mode 100644
index 000000000000..2b930cb9c299
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-userInitiated.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/resources/testdriver.js"></script>
+<script src="/resources/testdriver-vendor.js"></script>
+<script src="/resources/testdriver-actions.js"></script>
+<a id="a" href="#1">Click me</a>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_true(e.userInitiated);
+    assert_true(e.hashChange);
+    assert_equals(e.formData, null);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    e.preventDefault();
+    t.step_timeout(t.step_func_done(() => assert_equals(location.hash, "")), 0);
+  });
+
+  test_driver.click(a);
+}, "Fragment <a> click fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-with-target.html b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-with-target.html
new file mode 100644
index 000000000000..247011e07df4
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-anchor-with-target.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="iframe" name="i" src="/common/blank.html"></iframe>
+<a id="a" href="foo.html" target="i"></a>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    appHistory.onnavigate = t.step_func_done(() => {
+      assert_unreached("onnavigate should not have fired in source window");
+    });
+    iframe.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_false(e.hashChange);
+      assert_equals(e.formData, null);
+      assert_equals(new URL(e.destination.url).pathname,
+                    "/app-history/navigate-event/foo.html");
+      assert_false(e.destination.sameDocument);
+      e.preventDefault();
+    });
+    a.click();
+  });
+}, "<a> with a target fires navigate event in target window but not source");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-cross-document.html b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-cross-document.html
new file mode 100644
index 000000000000..321fa899b632
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-cross-document.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.navigate("?foo");
+    i.onload = t.step_func(() => {
+      i.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+        assert_true(e.cancelable);
+        assert_false(e.canRespond);
+        assert_false(e.userInitiated);
+        assert_false(e.hashChange);
+        assert_equals(new URL(e.destination.url).pathname, "/common/blank.html");
+        assert_false(e.destination.sameDocument);
+        assert_equals(e.formData, null);
+        assert_equals(e.info, "hi");
+      });
+      assert_true(i.contentWindow.appHistory.canGoBack);
+      i.contentWindow.appHistory.back({ navigateInfo: "hi" });
+    })
+  });
+}, "navigate event for appHistory.back() - cross-document");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-same-document.html b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-same-document.html
new file mode 100644
index 000000000000..a67201d0d369
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-back-same-document.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    appHistory.navigate("#foo").then(() => {
+      appHistory.onnavigate = t.step_func_done(e => {
+        assert_true(e.cancelable);
+        assert_true(e.canRespond);
+        assert_false(e.userInitiated);
+        assert_true(e.hashChange);
+        assert_equals(new URL(e.destination.url).hash, "");
+        assert_true(e.destination.sameDocument);
+        assert_equals(e.formData, null);
+        assert_equals(e.info, "hi");
+      });
+      assert_true(appHistory.canGoBack);
+      appHistory.back({ navigateInfo: "hi" });
+    });
+  }, 0);
+}, "navigate event for appHistory.back() - same-document");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-navigate.html b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-navigate.html
new file mode 100644
index 000000000000..552bc2e501ed
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-appHistory-navigate.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_true(e.hashChange);
+    assert_equals(new URL(e.destination.url).hash, "#foo");
+    assert_true(e.destination.sameDocument);
+    assert_equals(e.formData, null);
+  });
+  appHistory.navigate("#foo");
+}, "navigate event for appHistory.navigate()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-cross-origin-iframe-location.html b/testing/web-platform/tests/app-history/navigate-event/navigate-cross-origin-iframe-location.html
new file mode 100644
index 000000000000..55fc53b91a1e
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-cross-origin-iframe-location.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<body>
+<script>
+async_test(t => {
+  let iframe_url = new URL("resources/cross-origin-iframe-helper.html", location.href);
+  iframe_url.hostname = get_host_info().REMOTE_HOST;
+  let iframe = document.createElement("iframe")
+  iframe.src = iframe_url;
+  document.body.appendChild(iframe);
+
+  window.onmessage = t.step_func_done(e => {
+    assert_equals(e.data, "cancelable,canRespond,hashChange,");
+  });
+
+  appHistory.onnavigate = t.step_func_done(() => {
+    assert_unreached("onnavigate should not have fired in source window");
+  });
+  window.onload = t.step_func(() => iframe.contentWindow.location = iframe_url + "#");
+}, "location API on another window fires navigate event even if the target window is cross-origin");
+</script>
+<body>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-back-forward.html b/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-back-forward.html
new file mode 100644
index 000000000000..d754fb5595d4
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-back-forward.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(t.step_func_done(() => {
+    let navState = { statevar: "state" };
+    appHistory.navigate("#foo", { replace: true, state: navState });
+    appHistory.navigate("#bar");
+    appHistory.onnavigate = t.step_func_done(e => {
+      assert_not_equals(e.destination, null);
+      assert_not_equals(e.destination.getState(), undefined);
+      assert_not_equals(e.destination.getState(), e.destination.getState());
+    });
+    appHistory.back();
+  }), 0);
+}, "navigate event destination.getState() on back/forward navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-navigate.html b/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-navigate.html
new file mode 100644
index 000000000000..890b56ae8996
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-destination-getState-navigate.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    let navState = { statevar: "state" };
+    appHistory.onnavigate = t.step_func_done(e => {
+      assert_not_equals(e.destination, null);
+      assert_not_equals(e.destination.getState(), undefined);
+      assert_equals(e.destination.getState().statevar, "state");
+      assert_not_equals(e.destination.getState(), e.destination.getState());
+    });
+    appHistory.navigate("#foo", { state: navState });
+  }, 0);
+}, "navigate event destination.getState() should be the state given to navigate()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-form-userInitiated.html b/testing/web-platform/tests/app-history/navigate-event/navigate-form-userInitiated.html
new file mode 100644
index 000000000000..23e0a6b0a4d0
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-form-userInitiated.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/resources/testdriver.js"></script>
+<script src="/resources/testdriver-vendor.js"></script>
+<script src="/resources/testdriver-actions.js"></script>
+<form id="form" action="">
+<input id="submit" type="submit" value="Submit">
+</form>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_true(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(e.destination.url, location.href + "?");
+    assert_false(e.destination.sameDocument);
+    assert_not_equals(e.formData, null);
+    e.preventDefault();
+  });
+  window.onload = t.step_func(() => test_driver.click(submit));
+}, "<form> submission fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-form-with-target.html b/testing/web-platform/tests/app-history/navigate-event/navigate-form-with-target.html
new file mode 100644
index 000000000000..1ea661d591af
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-form-with-target.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="iframe" name="i" src="/common/blank.html"></iframe>
+<form id="form" action="foo.html" target="i"></form>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    appHistory.onnavigate = t.step_func_done(() => {
+      assert_unreached("onnavigate should not have fired in source window");
+    });
+    iframe.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      e.preventDefault();
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_false(e.hashChange);
+      assert_equals(new URL(e.destination.url).pathname,
+                    "/app-history/navigate-event/foo.html");
+      assert_false(e.destination.sameDocument);
+      assert_not_equals(e.formData, null);
+      e.preventDefault();
+    });
+    form.submit();
+  });
+}, "<form> submission with a target fires navigate event in target window but not source");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-form.html b/testing/web-platform/tests/app-history/navigate-event/navigate-form.html
new file mode 100644
index 000000000000..3e221ba0a15c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-form.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<form id="form" action=""></form>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(e.destination.url, location.href + "?");
+    assert_false(e.destination.sameDocument);
+    assert_not_equals(e.formData, null);
+    e.preventDefault();
+  });
+  window.onload = t.step_func(() => form.submit());
+}, "<form> submission fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-fragment.html b/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-fragment.html
new file mode 100644
index 000000000000..7e74186cff7a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-fragment.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  window.onload = t.step_timeout(() => {
+    let start_length = history.length;
+    location.hash = "#1";
+    assert_equals(history.length, start_length + 1);
+
+    appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_true(e.hashChange);
+      assert_equals(new URL(e.destination.url).hash, "");
+      assert_true(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+    });
+
+    history.back();
+  }, 0);
+}, "history.back() fires the navigate event and sets hashChange when reversing a fragment navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-pushState.html b/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-pushState.html
new file mode 100644
index 000000000000..e9fe19a7f4b7
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-history-back-after-pushState.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  window.onload = t.step_timeout(() => {
+    let start_length = history.length;
+    history.pushState(1, "", "pushState.html");
+    assert_equals(history.length, start_length + 1);
+
+    appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_false(e.hashChange);
+      assert_equals(new URL(e.destination.url).hash, "");
+      assert_true(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+    });
+
+    history.back();
+  }, 0);
+}, "history.back() fires the navigate event when reversing a pushState()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-history-go-0.html b/testing/web-platform/tests/app-history/navigate-event/navigate-history-go-0.html
new file mode 100644
index 000000000000..2a3dbf28064e
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-history-go-0.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_false(e.hashChange);
+      assert_equals(new URL(e.destination.url).pathname, "/common/blank.html");
+      assert_false(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+      e.preventDefault();
+    });
+
+    i.contentWindow.history.go(0);
+  });
+}, "history.go(0) fires the navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-history-pushState.html b/testing/web-platform/tests/app-history/navigate-event/navigate-history-pushState.html
new file mode 100644
index 000000000000..ab69a53ee483
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-history-pushState.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let start_length = history.length;
+  appHistory.onnavigate = t.step_func(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    assert_equals(e.formData, null);
+    e.preventDefault();
+    t.step_timeout(t.step_func_done(() => {
+      assert_equals(location.hash, "");
+      assert_equals(history.state, null);
+      assert_equals(history.length, start_length);
+    }), 0);
+  });
+  history.pushState(1, null, "#1");
+}, "history.pushState() fires the navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-history-replaceState.html b/testing/web-platform/tests/app-history/navigate-event/navigate-history-replaceState.html
new file mode 100644
index 000000000000..ba32b6108a28
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-history-replaceState.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let start_length = history.length;
+  appHistory.onnavigate = t.step_func(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    assert_equals(e.formData, null);
+    e.preventDefault();
+    t.step_timeout(t.step_func_done(() => {
+      assert_equals(location.hash, "");
+      assert_equals(history.state, null);
+      assert_equals(history.length, start_length);
+    }), 0);
+  });
+  history.replaceState(1, null, "#1");
+}, "history.replaceState() fires the navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-iframe-location.html b/testing/web-platform/tests/app-history/navigate-event/navigate-iframe-location.html
new file mode 100644
index 000000000000..7eb4c1e86aea
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-iframe-location.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="iframe" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    appHistory.onnavigate = t.step_func_done(() => {
+      assert_unreached("onnavigate should not have fired in source window");
+    });
+    iframe.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_true(e.hashChange);
+      assert_equals(new URL(e.destination.url).hash, "#1");
+      assert_true(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+      e.preventDefault();
+      t.step_timeout(t.step_func_done(() => assert_equals(location.hash, "")), 0);
+    });
+    iframe.contentWindow.location.hash = "#1";
+  });
+}, "location API on another window fires navigate event in the target window only");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-location.html b/testing/web-platform/tests/app-history/navigate-event/navigate-location.html
new file mode 100644
index 000000000000..58771540f0bd
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-location.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<form id="form" action=""></form>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_true(e.hashChange);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    assert_equals(e.formData, null);
+  });
+  location.href = "#1";
+}, "location API fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-meta-refresh.html b/testing/web-platform/tests/app-history/navigate-event/navigate-meta-refresh.html
new file mode 100644
index 000000000000..aaff923de298
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-meta-refresh.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<head>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="resources/meta-refresh.html"></iframe>
+</head>
+<script>
+async_test(t => {
+  i.onload = t.step_func(() => {
+    i.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_false(e.hashChange);
+      assert_equals(e.destination.url, i.contentWindow.location.href);
+      assert_false(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+      e.preventDefault();
+    });
+  });
+}, "<meta> refresh fires navigate event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-window-open-self.html b/testing/web-platform/tests/app-history/navigate-event/navigate-window-open-self.html
new file mode 100644
index 000000000000..8d231ffc20bb
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-window-open-self.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_true(e.hashChange);
+    assert_equals(new URL(e.destination.url).hash, "#1");
+    assert_true(e.destination.sameDocument);
+    assert_equals(e.formData, null);
+    e.preventDefault();
+  });
+  window.onload = t.step_func(() => window.open("#1", "_self"));
+}, "window.open() fires navigate event when targeting self");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-window-open.html b/testing/web-platform/tests/app-history/navigate-event/navigate-window-open.html
new file mode 100644
index 000000000000..c24516d7b61d
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-window-open.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="iframe" name="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    appHistory.onnavigate = t.step_func_done(() => {
+      assert_unreached("onnavigate should not have fired in source window");
+    });
+    iframe.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      assert_true(e.cancelable);
+      assert_true(e.canRespond);
+      assert_false(e.userInitiated);
+      assert_true(e.hashChange);
+      assert_equals(new URL(e.destination.url).hash, "#1");
+      assert_true(e.destination.sameDocument);
+      assert_equals(e.formData, null);
+      e.preventDefault();
+    });
+
+    window.open("/common/blank.html#1", "i");
+  });
+}, "window.open() fires navigate event in target window but not source");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigate-within-onnavigate.html b/testing/web-platform/tests/app-history/navigate-event/navigate-within-onnavigate.html
new file mode 100644
index 000000000000..b28b184cf3f7
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigate-within-onnavigate.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<form id="form" action=""></form>
+<script>
+promise_test(async t => {
+  appHistory.onnavigate = t.step_func(e => {
+    if (e.info == 1) {
+      appHistory.navigate("#2", { navigateInfo: 2 });
+      assert_true(e.defaultPrevented);
+    }
+  });
+  await promise_rejects_dom(t, 'AbortError', appHistory.navigate("#1", { navigateInfo: 1 }));
+  assert_equals(location.hash, "#2");
+}, "if navigate() is called inside onnavigate, the previous navigation and navigate event are cancelled");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-cross-document.html b/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-cross-document.html
new file mode 100644
index 000000000000..aacaf3bc49f3
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-cross-document.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="resources/navigatesuccess-cross-document-helper.html"></iframe>
+<script>
+async_test(t => {
+  // The iframe will post a message if it receives a navigatesuccess.
+  window.onmessage = t.unreached_func("navigatesuccess received");
+  window.onload = t.step_func(() => {
+    i.contentWindow.location.search = "?1";
+    i.onload = t.step_func_done(() => assert_equals(i.contentWindow.location.search, "?1"));
+  });
+}, "navigatesucess does not fire for a cross-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-same-document.html b/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-same-document.html
new file mode 100644
index 000000000000..32beddeff5b2
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/navigatesuccess-same-document.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<a id="a" href="#1"></a>
+<script>
+async_test(t => {
+  appHistory.onnavigatesuccess = t.step_func_done(() => assert_equals(location.hash, "#1"));
+  a.click();
+}, "navigatesucess fires for a same-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/resources/cross-origin-iframe-helper.html b/testing/web-platform/tests/app-history/navigate-event/resources/cross-origin-iframe-helper.html
new file mode 100644
index 000000000000..bbb2de47b21c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/resources/cross-origin-iframe-helper.html
@@ -0,0 +1,17 @@
+<script>
+appHistory.onnavigate = e => {
+  let message = "";
+  if (e.cancelable)
+    message += "cancelable,";
+  if (e.canRespond)
+    message += "canRespond,";
+  if (e.userInitiated)
+    message += "userInitiated,";
+  if (e.hashChange)
+    message += "hashChange,";
+  if (e.formData != null)
+    message += "formData,";
+  e.preventDefault();
+  top.postMessage(message, "*");
+};
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/resources/meta-refresh.html b/testing/web-platform/tests/app-history/navigate-event/resources/meta-refresh.html
new file mode 100644
index 000000000000..fd453e663f94
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/resources/meta-refresh.html
@@ -0,0 +1,4 @@
+<head>
+<meta http-equiv="refresh" content="0"></meta>
+</head>
+<body></body>
diff --git a/testing/web-platform/tests/app-history/navigate-event/resources/navigatesuccess-cross-document-helper.html b/testing/web-platform/tests/app-history/navigate-event/resources/navigatesuccess-cross-document-helper.html
new file mode 100644
index 000000000000..b3dad703ca5a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/resources/navigatesuccess-cross-document-helper.html
@@ -0,0 +1,6 @@
+<!doctype html>
+<head>
+<script>
+appHistory.onnavigatesuccess = () => top.postMessage("navigatesucess received");
+</script>
+</head>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-appHistory-back.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-appHistory-back.html
new file mode 100644
index 000000000000..ed0efbae881b
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-appHistory-back.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    appHistory.navigate("#foo").then(() => {
+      assert_true(appHistory.canGoBack);
+      appHistory.onnavigate = t.step_func(e => e.respondWith(Promise.resolve()));
+      appHistory.back().then(t.step_func_done(() => {
+        assert_equals(appHistory.entries().length, 2);
+        assert_equals(appHistory.current, appHistory.entries()[0]);
+      }));
+    });
+  }, 0);
+}, "AppHistoryNavigateEvent.respondWith can intercept appHistory.back()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-document-same-origin.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-document-same-origin.html
new file mode 100644
index 000000000000..a481a0925f09
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-document-same-origin.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<script>
+async_test(t => {
+  let target_url = location.href + "?1";
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_true(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    e.respondWith(Promise.resolve().then(
+      t.step_func_done(() => assert_equals(location.href, target_url))));
+  });
+
+  window.onload = t.step_func(() => location.href = target_url);
+}, "AppHistoryNavigateEvent.respondWith intercepts a same-origin cross-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-origin.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-origin.html
new file mode 100644
index 000000000000..ee29f287be94
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-cross-origin.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    assert_true(e.cancelable);
+    assert_false(e.canRespond);
+    assert_false(e.userInitiated);
+    assert_false(e.hashChange);
+    assert_throws_dom("SecurityError", () => e.respondWith(Promise.resolve()));
+    e.preventDefault();
+  });
+
+  window.onload = t.step_func(() => location.href = get_host_info().HTTPS_REMOTE_ORIGIN);
+}, "AppHistoryNavigateEvent.respondWith should throw if called for a cross origin navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-detach.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-detach.html
new file mode 100644
index 000000000000..1626857e1bc2
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-detach.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.onnavigate = t.step_func_done(e => {
+      let iframe_constructor = i.contentWindow.DOMException;
+      i.remove();
+      assert_throws_dom("InvalidStateError", iframe_constructor, () => e.respondWith(Promise.resolve()));
+    });
+
+    i.contentWindow.location.href = "#1";
+  });
+});
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-history-pushState.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-history-pushState.html
new file mode 100644
index 000000000000..490622953b7d
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-history-pushState.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let start_length = history.length;
+  appHistory.onnavigate = t.step_func(e => {
+    e.respondWith(new Promise(resolve => t.step_timeout(() => {
+      resolve();
+      t.step_timeout(t.step_func_done(() => {
+        assert_equals(location.hash, "#1");
+        assert_equals(history.state, "update");
+        assert_equals(history.length, start_length + 1);
+      }, 0));
+    }, 0)));
+  });
+
+  history.pushState("update", "", "#1");
+  assert_equals(location.hash, "#1");
+  assert_equals(history.state, "update");
+  assert_equals(history.length, start_length + 1);
+}, "AppHistoryNavigateEvent.respondWith should proceed if the given promise resolves");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-history-replaceState.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-history-replaceState.html
new file mode 100644
index 000000000000..b42d4dc9c13a
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-history-replaceState.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let start_length = history.length;
+  appHistory.onnavigate = t.step_func(e => {
+    e.respondWith(new Promise(resolve => t.step_timeout(() => {
+      resolve();
+      t.step_timeout(t.step_func_done(() => {
+        assert_equals(location.hash, "#1");
+        assert_equals(history.state, "update");
+        assert_equals(history.length, start_length);
+      }, 0));
+    }, 0)));
+  });
+
+  history.replaceState("update", "", "#1");
+  assert_equals(location.hash, "#1");
+  assert_equals(history.state, "update");
+  assert_equals(history.length, start_length);
+}, "AppHistoryNavigateEvent.respondWith should proceed if the given promise resolves");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-multiple-times.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-multiple-times.html
new file mode 100644
index 000000000000..f1694432d59c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-multiple-times.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  appHistory.onnavigate = t.step_func_done(e => {
+    e.respondWith(Promise.resolve());
+    assert_throws_dom("InvalidStateError", () => e.respondWith(Promise.resolve()));
+  });
+
+  location.href = "#1";
+  assert_equals(location.hash, "");
+}, "AppHistoryNavigateEvent.respondWith throws if invoked more than once");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-on-synthetic-event.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-on-synthetic-event.html
new file mode 100644
index 000000000000..bfdd6a823657
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-on-synthetic-event.html
@@ -0,0 +1,8 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  assert_throws_dom("SecurityError", () => new AppHistoryNavigateEvent("navigate").respondWith(Promise.resolve()));
+}, "AppHistoryNavigateEvent.respondWith throws if invoked on a synthetic event");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-reject.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-reject.html
new file mode 100644
index 000000000000..5340d87415df
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-reject.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  const err = new TypeError("a message");
+  let start_href = location.href;
+
+  appHistory.onnavigatesuccess = t.step_func_done(assert_unreached);
+  appHistory.onnavigateerror = t.step_func_done(e => {
+    assert_equals(location.hash, "#1");
+    assert_equals(e.constructor, ErrorEvent);
+    assert_true(e.error === err);
+    assert_equals(e.message, "Uncaught TypeError: a message");
+    assert_equals(e.filename, start_href);
+    assert_greater_than(e.colno, 0);
+    assert_greater_than(e.lineno, 0);
+  });
+  appHistory.onnavigate = e => {
+    e.respondWith(new Promise((resolve, reject) => t.step_timeout(() => reject(err), 0)));
+  };
+
+  location.href = "#1";
+  assert_equals(location.hash, "#1");
+}, "AppHistoryNavigateEvent.respondWith should abort if the given promise rejects");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-resolve.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-resolve.html
new file mode 100644
index 000000000000..6bc08759abd4
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-resolve.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  appHistory.onnavigatesuccess = t.step_func_done(e => {
+    assert_equals(location.hash, "#1");
+    assert_equals(e.constructor, Event);
+    assert_false(e.bubbles);
+    assert_false(e.cancelable);
+  });
+  appHistory.onnavigateerror = t.step_func_done(assert_unreached);
+  appHistory.onnavigate = e => {
+    e.respondWith(new Promise(resolve => t.step_timeout(resolve, 0)));
+  };
+
+  location.href = "#1";
+  assert_equals(location.hash, "#1");
+}, "AppHistoryNavigateEvent.respondWith should proceed if the given promise resolves");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate-event/respondWith-same-document-history-back.html b/testing/web-platform/tests/app-history/navigate-event/respondWith-same-document-history-back.html
new file mode 100644
index 000000000000..ae69cba7df04
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate-event/respondWith-same-document-history-back.html
@@ -0,0 +1,40 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    let onnavigate_calls = 0;
+    let onnavigatesuccess_calls = 0;
+    appHistory.onnavigate = e => {
+      onnavigate_calls++;
+      e.respondWith(Promise.resolve());
+    }
+    appHistory.onnavigatesuccess = t.step_func(e => {
+      onnavigatesuccess_calls++;
+      if (onnavigatesuccess_calls == 3) {
+        assert_equals(appHistory.entries().length, 3);
+        assert_equals(appHistory.current.index, 1);
+        assert_equals(onnavigate_calls, 3);
+        history.back();
+      } else if (onnavigatesuccess_calls == 4) {
+        assert_equals(appHistory.entries().length, 3);
+        assert_equals(appHistory.current.index, 0);
+        assert_equals(onnavigate_calls, 4);
+        t.done();
+      }
+    });
+
+    appHistory.navigate("?foo")
+      .then(t.step_func(() => appHistory.navigate("?bar")))
+      .then(t.step_func(() => {
+        assert_equals(appHistory.entries().length, 3);
+        assert_equals(appHistory.current.index, 2);
+        assert_equals(onnavigate_calls, 2);
+        history.back();
+      }));
+  }, 0);
+}, "AppHistoryNavigateEvent.respondWith can intercept same-document history.back()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/back-forward-out-of-bounds.html b/testing/web-platform/tests/app-history/navigate/back-forward-out-of-bounds.html
new file mode 100644
index 000000000000..90f0e114ce41
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/back-forward-out-of-bounds.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  assert_equals(appHistory.entries().length, 1);
+  assert_equals(appHistory.entries()[0], appHistory.current);
+  assert_false(appHistory.canGoBack);
+  assert_false(appHistory.canGoForward);
+  await promise_rejects_dom(t, 'InvalidStateError', appHistory.back());
+  await promise_rejects_dom(t, 'InvalidStateError', appHistory.forward());
+}, "back() and forward() out of bounds");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/disambigaute-back.html b/testing/web-platform/tests/app-history/navigate/disambigaute-back.html
new file mode 100644
index 000000000000..aa2b644b2724
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/disambigaute-back.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    appHistory.navigate("#top");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    i.contentWindow.appHistory.navigate("#1");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 1);
+    assert_equals(i.contentWindow.appHistory.current.index, 1);
+    assert_true(appHistory.canGoBack);
+    assert_true(i.contentWindow.appHistory.canGoBack);
+
+    // There are 2 joint session history entries containing the iframe's
+    // previous key. Navigate to the nearest one (which navigates the iframe
+    // but not the top window).
+    i.contentWindow.appHistory.back().then(t.step_func_done(() => {
+      assert_equals(appHistory.current.index, 1);
+      assert_equals(i.contentWindow.appHistory.current.index, 0);
+    }));
+  }, 0);
+}, "appHistory.back() goes to the nearest back entry");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/disambigaute-forward.html b/testing/web-platform/tests/app-history/navigate/disambigaute-forward.html
new file mode 100644
index 000000000000..cdfb832d93ee
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/disambigaute-forward.html
@@ -0,0 +1,40 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    appHistory.navigate("#top");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    i.contentWindow.appHistory.navigate("#1");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 1);
+    assert_equals(i.contentWindow.appHistory.current.index, 1);
+    assert_true(appHistory.canGoBack);
+    assert_true(i.contentWindow.appHistory.canGoBack);
+
+    i.contentWindow.appHistory.back().then(t.step_func(() => {
+      assert_equals(appHistory.current.index, 1);
+      assert_equals(i.contentWindow.appHistory.current.index, 0);
+      appHistory.back().then(t.step_func(() => {
+        assert_equals(appHistory.current.index, 0);
+        assert_equals(i.contentWindow.appHistory.current.index, 0);
+        // There are 2 joint session history entries containing the top window's
+        // final key. Navigate to the nearest one (which navigates only the
+        // top window).
+        appHistory.forward().then(t.step_func_done(() => {
+          assert_equals(appHistory.current.index, 1);
+          assert_equals(i.contentWindow.appHistory.current.index, 0);
+        }));
+      }));
+    }));
+  }, 0);
+}, "appHistory.forward() goes to the nearest forward entry");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/disambigaute-goto-back-multiple.html b/testing/web-platform/tests/app-history/navigate/disambigaute-goto-back-multiple.html
new file mode 100644
index 000000000000..12afa6c4f8c9
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/disambigaute-goto-back-multiple.html
@@ -0,0 +1,35 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    appHistory.navigate("#top");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+
+    let iframe_initial_key = i.contentWindow.appHistory.current.key;
+    i.contentWindow.appHistory.navigate("#1");
+    i.contentWindow.appHistory.navigate("#2");
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(i.contentWindow.appHistory.entries().length, 3);
+    assert_equals(appHistory.current.index, 1);
+    assert_equals(i.contentWindow.appHistory.current.index, 2);
+    assert_true(appHistory.canGoBack);
+    assert_true(i.contentWindow.appHistory.canGoBack);
+
+    // There are 2 joint session history entries containing the iframe's
+    // initial key.  Navigate to the nearest one (which navigates the iframe
+    // but not the top window).
+    i.contentWindow.appHistory.goTo(iframe_initial_key).then(t.step_func_done(() => {
+      assert_equals(appHistory.current.index, 1);
+      assert_equals(i.contentWindow.appHistory.current.index, 0);
+    }));
+  }, 0);
+}, "appHistory.goTo() goes to the nearest entry when going back");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/disambigaute-goto-forward-multiple.html b/testing/web-platform/tests/app-history/navigate/disambigaute-goto-forward-multiple.html
new file mode 100644
index 000000000000..b1378b66a785
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/disambigaute-goto-forward-multiple.html
@@ -0,0 +1,43 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    let initial_key = appHistory.current.key;
+    appHistory.navigate("#top1");
+    appHistory.navigate("#top2");
+    assert_equals(appHistory.entries().length, 3);
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    i.contentWindow.appHistory.navigate("#1");
+    assert_equals(appHistory.entries().length, 3);
+    assert_equals(i.contentWindow.appHistory.entries().length, 2);
+    assert_equals(appHistory.current.index, 2);
+    assert_equals(i.contentWindow.appHistory.current.index, 1);
+    assert_true(appHistory.canGoBack);
+    assert_true(i.contentWindow.appHistory.canGoBack);
+    let final_key = appHistory.current.key;
+
+    i.contentWindow.appHistory.back().then(t.step_func(() => {
+      assert_equals(appHistory.current.index, 2);
+      assert_equals(i.contentWindow.appHistory.current.index, 0);
+      appHistory.goTo(initial_key).then(t.step_func(() => {
+        assert_equals(appHistory.current.index, 0);
+        assert_equals(i.contentWindow.appHistory.current.index, 0);
+        // There are 2 joint session history entries containing the top window's
+        // final key. Navigate to the nearest one (which navigates only the
+        // top window).
+        appHistory.goTo(final_key).then(t.step_func_done(() => {
+          assert_equals(appHistory.current.index, 2);
+          assert_equals(i.contentWindow.appHistory.current.index, 0);
+        }));
+      }));
+    }));
+  }, 0);
+}, "appHistory.goTo() goes to the nearest entry when going forward");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-after-adding-iframe.html b/testing/web-platform/tests/app-history/navigate/goTo-after-adding-iframe.html
new file mode 100644
index 000000000000..d55d0403e913
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-after-adding-iframe.html
@@ -0,0 +1,34 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+async_test(t => {
+  let start_length = history.length;
+
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    appHistory.navigate("#top");
+    assert_equals(appHistory.entries().length, 2);
+
+    let i = document.createElement("iframe");
+    i.src = "/common/blank.html";
+    document.body.appendChild(i);
+    i.onload = () => t.step_timeout(() => {
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+      i.contentWindow.appHistory.navigate("#fragment");
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      i.contentWindow.appHistory.back().then(t.step_func(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 0);
+        return i.contentWindow.appHistory.forward();
+      })).then(t.step_func_done(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 1);
+      }));
+    }, 0);
+  }, 0);
+}, "appHistory.goTo() should work in an iframe that is not present in all history entries");
+</script>
+</body>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-after-data-url.html b/testing/web-platform/tests/app-history/navigate/goTo-after-data-url.html
new file mode 100644
index 000000000000..c79132899bc6
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-after-data-url.html
@@ -0,0 +1,33 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+async_test(t => {
+  let i = document.createElement("iframe");
+  i.src = "data:text/html,";
+  document.body.appendChild(i);
+  let start_length = history.length;
+
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    i.contentWindow.location = "/common/blank.html";
+    i.onload = () => t.step_timeout(() => {
+      assert_equals(history.length, start_length + 1);
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+      i.contentWindow.appHistory.navigate("#fragment");
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      i.contentWindow.appHistory.back().then(t.step_func(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 0);
+        return i.contentWindow.appHistory.forward();
+      })).then(t.step_func_done(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 1);
+      }));
+    }, 0);
+  }, 0);
+}, "appHistory.goTo() should work in an iframe that started at a data: url");
+</script>
+</body>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-cross-document-deatch-iframe-in-onnavigate.html b/testing/web-platform/tests/app-history/navigate/goTo-cross-document-deatch-iframe-in-onnavigate.html
new file mode 100644
index 000000000000..573bde399216
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-cross-document-deatch-iframe-in-onnavigate.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    let key = i.contentWindow.appHistory.current.key;
+    i.contentWindow.appHistory.navigate("?1");
+    i.onload = t.step_func(async () => {
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[1]);
+      i.contentWindow.appHistory.onnavigate = () => i.remove();
+      await promise_rejects_dom(t, 'AbortError', i.contentWindow.DOMException, i.contentWindow.appHistory.goTo(key));
+      t.done();
+    });
+  }, 0);
+}, "detach iframe inside onnavigate during cross-document appHistory.goTo()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-cross-document-preventDefault.html b/testing/web-platform/tests/app-history/navigate/goTo-cross-document-preventDefault.html
new file mode 100644
index 000000000000..b8a2e9403e9c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-cross-document-preventDefault.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    let key = i.contentWindow.appHistory.current.key;
+    i.contentWindow.appHistory.navigate("?1");
+    i.onload = t.step_func(async () => {
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[1]);
+      i.contentWindow.appHistory.onnavigate = e => e.preventDefault();
+      await promise_rejects_dom(t, 'AbortError', i.contentWindow.DOMException, i.contentWindow.appHistory.goTo(key));
+      t.done();
+    });
+  }, 0);
+}, "preventDefault on cross-document appHistory.goTo()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-cross-document.html b/testing/web-platform/tests/app-history/navigate/goTo-cross-document.html
new file mode 100644
index 000000000000..0a7bbbe1bf97
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-cross-document.html
@@ -0,0 +1,41 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    let next_step = "goto";
+    let key = i.contentWindow.appHistory.current.key;
+    i.contentWindow.appHistory.navigate("?1");
+    i.onload = t.step_func(() => {
+      if (next_step == "goto") {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[1]);
+        i.contentWindow.appHistory.goTo(key);
+        next_step = "forward";
+      } else if (next_step == "forward") {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(key, i.contentWindow.appHistory.current.key);
+        assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[0]);
+        assert_true(i.contentWindow.appHistory.canGoForward);
+        i.contentWindow.appHistory.forward();
+        next_step = "back";
+      } else if (next_step == "back") {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[1]);
+        assert_true(i.contentWindow.appHistory.canGoBack);
+        i.contentWindow.appHistory.back();
+        next_step = "finish";
+      } else if (next_step == "finish") {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[0]);
+        t.done();
+      }
+    });
+  }, 0);
+}, "cross-document navigate.goTo(), back(), and forward()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-current.html b/testing/web-platform/tests/app-history/navigate/goTo-current.html
new file mode 100644
index 000000000000..30ea3983f83f
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-current.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  assert_equals(appHistory.entries().length, 1);
+  let current_url = location.href;
+  let current_history_state = history.state;
+  let current_id = appHistory.current.id;
+  let current_state = appHistory.current.getState();
+  await appHistory.goTo(appHistory.current.key);
+  assert_equals(appHistory.entries().length, 1);
+  assert_equals(current_url, location.href);
+  assert_equals(current_history_state, history.state);
+  assert_equals(current_id, appHistory.current.id);
+  assert_equals(current_state, appHistory.current.getState());
+}, "goTo() with current key");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-detach-in-onnavigate.html b/testing/web-platform/tests/app-history/navigate/goTo-detach-in-onnavigate.html
new file mode 100644
index 000000000000..b8f12c2978eb
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-detach-in-onnavigate.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(async () => {
+    let iframe_constructor = i.contentWindow.DOMException;
+    let i_win = i.contentWindow;
+    i.contentWindow.history.pushState(1, "", "#1");
+    assert_equals(i.contentWindow.appHistory.entries().length, 2);
+    let key = i.contentWindow.appHistory.entries()[0].key;
+
+    i.contentWindow.appHistory.onnavigate = () => i.remove();
+    await promise_rejects_dom(t, 'AbortError', iframe_constructor, i.contentWindow.appHistory.goTo(key));
+    t.done();
+  });
+}, "goTo() in a detached window");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-in-detached-window.html b/testing/web-platform/tests/app-history/navigate/goTo-in-detached-window.html
new file mode 100644
index 000000000000..065c26fe61d7
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-in-detached-window.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(async () => {
+    let iframe_constructor = i.contentWindow.DOMException;
+    let i_win = i.contentWindow;
+    let key = i_win.appHistory.current.key;
+    i.remove();
+    await promise_rejects_dom(t, 'InvalidStateError', iframe_constructor, i_win.appHistory.goTo(key));
+    t.done();
+  });
+}, "goTo() in a detached window");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-invalid-key.html b/testing/web-platform/tests/app-history/navigate/goTo-invalid-key.html
new file mode 100644
index 000000000000..2eec6e2875d3
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-invalid-key.html
@@ -0,0 +1,8 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  await promise_rejects_dom(t, 'InvalidStateError', appHistory.goTo("not-a-real-key"));
+}, "goTo() with invalid key");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-multiple-steps.html b/testing/web-platform/tests/app-history/navigate/goTo-multiple-steps.html
new file mode 100644
index 000000000000..c827fef09820
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-multiple-steps.html
@@ -0,0 +1,30 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+    let key0 = appHistory.current.key;
+    appHistory.navigate("#1");
+    appHistory.navigate("#2");
+    let key2 = appHistory.current.key;
+    assert_equals(appHistory.entries().length, 3);
+
+    appHistory.goTo(key0)
+      .then(t.step_func(() => {
+        assert_equals(appHistory.entries().length, 3);
+        assert_equals(appHistory.current, appHistory.entries()[0]);
+        assert_equals(key0, appHistory.current.key);
+        return appHistory.goTo(key2);
+      }))
+      .then(t.step_func_done(() => {
+        assert_equals(appHistory.entries().length, 3);
+        assert_equals(appHistory.current, appHistory.entries()[2]);
+        assert_equals(key2, appHistory.current.key);
+      }));
+  }, 0);
+}, "goto() can precisely traverse multiple steps in the joint session history");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-repeated.html b/testing/web-platform/tests/app-history/navigate/goTo-repeated.html
new file mode 100644
index 000000000000..cfc035a9b568
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-repeated.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(async () => {
+    let key = appHistory.current.key;
+    await appHistory.navigate("#1");
+
+    let first_promise = appHistory.goTo(key);
+    appHistory.goTo(key);
+    await promise_rejects_dom(t, 'AbortError', first_promise);
+    t.done();
+  }, 0);
+}, "Repeated navigate.goTo()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-same-document.html b/testing/web-platform/tests/app-history/navigate/goTo-same-document.html
new file mode 100644
index 000000000000..7b685ac5c09e
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-same-document.html
@@ -0,0 +1,43 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    assert_equals(appHistory.entries().length, 1);
+
+    let onnavigate_count = 0;
+    appHistory.onnavigate = () => onnavigate_count++;
+
+    let key = appHistory.current.key;
+    appHistory.navigate("#")
+      .then(t.step_func(() => {
+        assert_equals(appHistory.entries().length, 2);
+        assert_equals(appHistory.current, appHistory.entries()[1]);
+        assert_not_equals(key, appHistory.current.key);
+        return appHistory.goTo(key);
+      }))
+      .then(t.step_func(() => {
+        assert_equals(appHistory.entries().length, 2);
+        assert_equals(appHistory.current, appHistory.entries()[0]);
+        assert_equals(key, appHistory.current.key);
+        assert_true(appHistory.canGoForward);
+        return appHistory.forward();
+      }))
+      .then(t.step_func(() => {
+        assert_equals(appHistory.entries().length, 2);
+        assert_equals(appHistory.current, appHistory.entries()[1]);
+        assert_true(appHistory.canGoBack);
+        return appHistory.back();
+      }))
+      .then(t.step_func_done(() => {
+        assert_equals(appHistory.entries().length, 2);
+        assert_equals(appHistory.current, appHistory.entries()[0]);
+        assert_equals(key, appHistory.current.key);
+        assert_equals(onnavigate_count, 4);
+      }));
+  }, 0);
+}, "same-document navigate.goTo(), back(), and forward()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/goTo-with-cross-origin-in-history.html b/testing/web-platform/tests/app-history/navigate/goTo-with-cross-origin-in-history.html
new file mode 100644
index 000000000000..ffcb870b8895
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/goTo-with-cross-origin-in-history.html
@@ -0,0 +1,37 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<body>
+<script>
+async_test(t => {
+  let cross_origin_url = new URL(get_host_info().HTTPS_REMOTE_ORIGIN);
+  cross_origin_url.pathname = "/common/blank.html";
+  let i = document.createElement("iframe");
+  i.src = cross_origin_url;
+  document.body.appendChild(i);
+
+  let start_length = history.length;
+
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(() => {
+    i.contentWindow.location = "/common/blank.html";
+    i.onload = () => t.step_timeout(() => {
+      assert_equals(history.length, start_length + 1);
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+      i.contentWindow.appHistory.navigate("#fragment");
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      i.contentWindow.appHistory.back().then(t.step_func(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 0);
+        return i.contentWindow.appHistory.forward();
+      })).then(t.step_func_done(() => {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current.index, 1);
+      }));
+    }, 0);
+  }, 0);
+}, "appHistory.goTo() should work in an iframe that has navigated across origins");
+</script>
+</body>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-cross-document-event-order.html b/testing/web-platform/tests/app-history/navigate/navigate-cross-document-event-order.html
new file mode 100644
index 000000000000..70fc90a907a5
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-cross-document-event-order.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="resources/notify-top-early.html"></iframe>
+<script>
+async_test(t => {
+  let events = [];
+  function finish() {
+    assert_array_equals(events, ["onnavigate", "readystateinteractive", "domcontentloaded", "readystatecomplete", "onload", "onpageshow"]);
+    t.done();
+  };
+
+  window.onload = t.step_func(() => {
+    window.childStarted = () => {
+      i.contentWindow.appHistory.onnavigatesuccess = () => events.push("onnavigatesuccess");
+      i.contentWindow.appHistory.onnavigateerror = () => events.push("onnavigateerror");
+      i.contentWindow.onpageshow = () => events.push("onpageshow");
+      i.contentWindow.onhashchange = () => events.push("onhashchange");
+      i.contentWindow.onpopstate = () => events.push("onpopstate");
+      i.onload = t.step_func(() => {
+        events.push("onload");
+        t.step_timeout(finish, 0);
+      });
+      i.contentDocument.addEventListener("DOMContentLoaded", () => events.push("domcontentloaded"));
+      i.contentDocument.onreadystatechange = () => events.push("readystate" + i.contentDocument.readyState);
+    };
+    i.contentWindow.appHistory.onnavigate = () => events.push("onnavigate");
+    i.contentWindow.appHistory.navigate("?1").then(
+        () => events.push("promisefulfilled"), () => events.push("promiserejected"));
+  });
+}, "navigate() event ordering for cross-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-cross-document.html b/testing/web-platform/tests/app-history/navigate/navigate-cross-document.html
new file mode 100644
index 000000000000..c9963320c37d
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-cross-document.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let onnavigate_called = false;
+    i.contentWindow.appHistory.onnavigate = () => onnavigate_called = true;
+    // The promise returned by appHistory.navigate() will not resolve on a
+    // cross-document navigation.
+    i.contentWindow.appHistory.navigate("?1")
+        .then(t.unreached_func("fulfilled"), t.unreached_func("rejected"));
+    i.onload = t.step_func(() => t.step_timeout(() => t.done(), 0));
+  });
+}, "navigate() navigates cross-document and fires onnavigate");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-detach.html b/testing/web-platform/tests/app-history/navigate/navigate-detach.html
new file mode 100644
index 000000000000..a3d5f35c7d79
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-detach.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+promise_test(async t => {
+  await new Promise(resolve => window.onload = resolve);
+  let iframe_exception = i.contentWindow.DOMException;
+  i.contentWindow.appHistory.onnavigate = () => i.remove();
+  await promise_rejects_dom(t, 'AbortError', iframe_exception, i.contentWindow.appHistory.navigate("#"));
+}, "Detach inside onnavigate");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-history-state-replace.html b/testing/web-platform/tests/app-history/navigate/navigate-history-state-replace.html
new file mode 100644
index 000000000000..ef7fe7bf89dd
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-history-state-replace.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async () => {
+  history.replaceState("state1", "", "#1");
+  assert_equals(history.state, "state1");
+
+  let onnavigate_called = false;
+  appHistory.onnavigate = () => onnavigate_called = true;
+  await appHistory.navigate("#2", { replace: true });
+  assert_equals(location.hash, "#2");
+  assert_true(onnavigate_called);
+  assert_equals(history.state, null);
+}, "history.state should be nulled by navigate()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-history-state.html b/testing/web-platform/tests/app-history/navigate/navigate-history-state.html
new file mode 100644
index 000000000000..aacdb2a37e71
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-history-state.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async () => {
+  history.replaceState("state1", "", "#1");
+  assert_equals(history.state, "state1");
+
+  let onnavigate_called = false;
+  appHistory.onnavigate = () => onnavigate_called = true;
+  await appHistory.navigate("#2");
+  assert_equals(location.hash, "#2");
+  assert_true(onnavigate_called);
+  assert_equals(history.state, null);
+}, "history.state should be nulled by navigate()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-in-detached-window.html b/testing/web-platform/tests/app-history/navigate/navigate-in-detached-window.html
new file mode 100644
index 000000000000..578c833d3ed8
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-in-detached-window.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i"></iframe>
+<script>
+promise_test(async t => {
+  let iframe_constructor = i.contentWindow.DOMException;
+  let i_win = i.contentWindow;
+  i.remove();
+  await promise_rejects_dom(t, 'InvalidStateError', iframe_constructor, i_win.appHistory.navigate("#"));
+}, "navigate() in a detached window");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-info-and-state.html b/testing/web-platform/tests/app-history/navigate/navigate-info-and-state.html
new file mode 100644
index 000000000000..394541fb1abd
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-info-and-state.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  let navInfo = { nav : "info" };
+  let navState = { statevar: "state" };
+  let onnavigated_called = false;
+  appHistory.onnavigate = t.step_func(e => {
+    onnavigated_called = true;
+    assert_equals(e.info, navInfo)
+  });
+  await appHistory.navigate("#1", { navigateInfo: navInfo, state: navState });
+  assert_true(onnavigated_called);
+  assert_not_equals(appHistory.current.getState(), navState);
+  assert_equals(appHistory.current.getState().statevar, navState.statevar);
+}, "navigate() with info and state");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-invalid-url.html b/testing/web-platform/tests/app-history/navigate/navigate-invalid-url.html
new file mode 100644
index 000000000000..13ccfdda89f8
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-invalid-url.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  let navInfo = { nav : "info" };
+  appHistory.onnavigate = t.unreached_func("onnavigate");
+  await promise_rejects_dom(t, "SyntaxError", appHistory.navigate("https://example.com\u0000mozilla.org"));
+}, "navigate() with invalid url");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-no-args.html b/testing/web-platform/tests/app-history/navigate/navigate-no-args.html
new file mode 100644
index 000000000000..09197f6562b5
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-no-args.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  await promise_rejects_js(t, TypeError, appHistory.navigate());
+  await promise_rejects_js(t, TypeError, appHistory.navigate({}));
+  await promise_rejects_js(t, TypeError, appHistory.navigate({ replace : true }));
+}, "navigate() with no args or empty options");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-preventDefault.html b/testing/web-platform/tests/app-history/navigate/navigate-preventDefault.html
new file mode 100644
index 000000000000..25d6a1ec4ce2
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-preventDefault.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  appHistory.onnavigate = e => e.preventDefault();
+  await promise_rejects_dom(t, 'AbortError', appHistory.navigate("#"));
+}, "navigate() promise rejects when the navigation is aborted");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-relative-url.html b/testing/web-platform/tests/app-history/navigate/navigate-relative-url.html
new file mode 100644
index 000000000000..b426da595088
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-relative-url.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.navigate("?1");
+    i.onload = t.step_func_done(() => {
+      let iframe_url = new URL(i.contentWindow.appHistory.current.url);
+      assert_equals(iframe_url.search, "?1");
+      assert_equals(iframe_url.pathname, "/common/blank.html");
+    });
+  });
+}, "navigate() should resolve urls relative to appHistory object, not the caller");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-replace-cross-document.html b/testing/web-platform/tests/app-history/navigate/navigate-replace-cross-document.html
new file mode 100644
index 000000000000..0b20dc850863
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-replace-cross-document.html
@@ -0,0 +1,29 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation (which would defeat the point of the test).
+  window.onload = () => t.step_timeout(() => {
+    let start_history_length = history.length;
+    let start_entry_top = appHistory.current;
+    let start_entry_iframe_id = i.contentWindow.appHistory.current.id;
+    let start_entry_iframe_key = i.contentWindow.appHistory.current.key;
+
+    i.contentWindow.appHistory.navigate("?1", { replace: true });
+    i.onload = t.step_func_done(() => {
+      assert_equals(history.length, start_history_length);
+
+      assert_equals(appHistory.entries().length, 1);
+      assert_equals(appHistory.current, start_entry_top);
+
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+      let iframe_entry = i.contentWindow.appHistory.current;
+      assert_not_equals(start_entry_iframe_id, iframe_entry.id);
+      assert_equals(start_entry_iframe_key, iframe_entry.key);
+    });
+  }, 0);
+}, "navigate() with replace option");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-replace-same-document.html b/testing/web-platform/tests/app-history/navigate/navigate-replace-same-document.html
new file mode 100644
index 000000000000..c0ecd2641253
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-replace-same-document.html
@@ -0,0 +1,21 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(t.step_func_done(async () => {
+    let start_history_length = history.length;
+    let key1 = appHistory.current.key;
+    await appHistory.navigate("#1");
+    let key2 = appHistory.current.key;
+    assert_not_equals(key1, key2);
+    await appHistory.navigate("#2", { replace: true });
+    let key3 = appHistory.current.key;
+    assert_equals(key2, key3);
+    assert_equals(appHistory.entries().length, 2);
+    assert_equals(history.length, start_history_length + 1);
+  }), 0);
+}, "navigate() with replace option");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-respondWith-history-state.html b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-history-state.html
new file mode 100644
index 000000000000..e0031d510486
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-history-state.html
@@ -0,0 +1,15 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async () => {
+  history.replaceState("state1", "", "#1");
+  assert_equals(history.state, "state1");
+
+  appHistory.onnavigate = e => e.respondWith(Promise.resolve("r"));
+  let result = await appHistory.navigate("#2");
+  assert_equals(result, "r");
+  assert_equals(location.hash, "#2");
+  assert_equals(history.state, null);
+}, "history.story should be nulled by navigate() handled by respondWith()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject-event-order.html b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject-event-order.html
new file mode 100644
index 000000000000..327b1b4e2e77
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject-event-order.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let events = [];
+  function finish() {
+    assert_array_equals(events, ["onnavigate", "onnavigateerror", "promiserejected"]);
+    t.done();
+  }
+
+  appHistory.onnavigate = e => {
+    events.push("onnavigate");
+    e.respondWith(Promise.reject());
+  };
+  appHistory.onnavigatesuccess = () => events.push("onnavigatesuccess");
+  appHistory.onnavigateerror = () => events.push("onnavigateerror");
+  window.onhashchange = () => events.push("onhashchange");
+  window.onpopstate = () => events.push("onpopstate");
+  appHistory.navigate("#1").then(
+      () => events.push("promisefulfilled"),
+      () => {
+        events.push("promiserejected");
+        t.step_timeout(finish, 0);
+      });
+}, "navigate() event ordering for same-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject.html b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject.html
new file mode 100644
index 000000000000..d214f31c199c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-respondWith-reject.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  let promise_value = { abc: 'def' };
+  let promise = Promise.reject(promise_value);
+  appHistory.onnavigate = e => e.respondWith(promise);
+  let returned_promise = appHistory.navigate("#1");
+  assert_not_equals(promise, returned_promise);
+  return promise_rejects_exactly(t, promise_value, returned_promise);
+}, "navigate() and respondWith with a reject promise");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-respondWith.html b/testing/web-platform/tests/app-history/navigate/navigate-respondWith.html
new file mode 100644
index 000000000000..70a560d9b496
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-respondWith.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async () => {
+  let promise_value = { abc: 'def' };
+  let promise = Promise.resolve(promise_value);
+  appHistory.onnavigate = e => e.respondWith(promise);
+  let returned_promise = appHistory.navigate("#1");
+  assert_not_equals(promise, returned_promise);
+  assert_equals(promise_value, await returned_promise);
+}, "navigate() and respondWith");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-same-document-event-order.html b/testing/web-platform/tests/app-history/navigate/navigate-same-document-event-order.html
new file mode 100644
index 000000000000..c051363d8cdd
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-same-document-event-order.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  let events = [];
+  function finish() {
+    assert_array_equals(events, ["onnavigate", "onnavigatesuccess", "promisefulfilled", "onpopstate", "onhashchange"]);
+    t.done();
+  }
+
+  appHistory.onnavigate = () => events.push("onnavigate");
+  appHistory.onnavigatesuccess = () => events.push("onnavigatesuccess");
+  appHistory.onnavigateerror = () => events.push("onnavigateerror");
+  window.onhashchange = t.step_func(() => {
+    events.push("onhashchange");
+    t.step_timeout(finish, 0);
+  });
+  window.onpopstate = () => events.push("onpopstate");
+  appHistory.navigate("#1").then(
+      () => events.push("promisefulfilled"), () => events.push("promiserejected"));
+}, "navigate() event ordering for same-document navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-same-document.html b/testing/web-platform/tests/app-history/navigate/navigate-same-document.html
new file mode 100644
index 000000000000..f1aa00291982
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-same-document.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="d"></div>
+<script>
+promise_test(async () => {
+  let onnavigate_called = false;
+  appHistory.onnavigate = () => onnavigate_called = true;
+  await appHistory.navigate("#d");
+  assert_equals(location.hash, "#d");
+  assert_true(onnavigate_called);
+  assert_equals(document.querySelector(":target"), d);
+}, "navigate() navigates same-document and fires onnavigate (async)");
+
+test(() => {
+  let onnavigate_called = false;
+  appHistory.onnavigate = () => onnavigate_called = true;
+  appHistory.navigate("#d");
+  assert_equals(location.hash, "#d");
+  assert_true(onnavigate_called);
+  assert_equals(document.querySelector(":target"), d);
+}, "navigate() navigates same-document and fires onnavigate (sync)");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg-replace.html b/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg-replace.html
new file mode 100644
index 000000000000..081a29eac706
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg-replace.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let navInfo = { nav: "info" };
+    let start_url = i.contentWindow.location.href;
+    let start_key = i.contentWindow.appHistory.current.key;
+    let onnavigate_called = false;
+    i.contentWindow.appHistory.onnavigate = t.step_func(e => {
+      onnavigate_called = true;
+      assert_equals(e.info, navInfo);
+    });
+    i.contentWindow.appHistory.navigate({ replace: true, navigateInfo: navInfo });
+    i.onload = t.step_func_done(() => {
+      assert_true(onnavigate_called);
+      assert_equals(start_url, i.contentWindow.location.href);
+      assert_equals(start_key, i.contentWindow.appHistory.current.key);
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    });
+  });
+}, "navigate() variant with no url, replacing");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg.html b/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg.html
new file mode 100644
index 000000000000..8b60123608f2
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/navigate-without-url-arg.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    let navInfo = { nav: "info" };
+    let start_url = i.contentWindow.location.href;
+    let start_key = i.contentWindow.appHistory.current.key;
+    let start_id = i.contentWindow.appHistory.current.id;
+    let onnavigate_called = false;
+    i.contentWindow.appHistory.onnavigate = t.step_func(e => {
+      onnavigate_called = true;
+      assert_equals(e.info, navInfo);
+    });
+    i.contentWindow.appHistory.navigate({ navigateInfo: navInfo });
+    i.onload = t.step_func_done(() => {
+      assert_true(onnavigate_called);
+      assert_equals(start_url, i.contentWindow.location.href);
+      assert_equals(start_key, i.contentWindow.appHistory.current.key);
+      assert_not_equals(start_id, i.contentWindow.appHistory.current.id);
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    });
+  });
+}, "navigate() variant with no url");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/resources/notify-top-early.html b/testing/web-platform/tests/app-history/navigate/resources/notify-top-early.html
new file mode 100644
index 000000000000..0dd796f609c0
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/resources/notify-top-early.html
@@ -0,0 +1,6 @@
+<head>
+<script>
+if (top.childStarted)
+  top.childStarted();
+</script>
+</head>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-pushState.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-pushState.html
new file mode 100644
index 000000000000..e24fc0f31c14
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-pushState.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  appHistory.navigate("#", { replace : true, state : { data : "value" } });
+  assert_equals(appHistory.current.getState().data, "value");
+  history.pushState(1, "", "#push");
+  assert_equals(appHistory.current.getState(), undefined);
+}, "appHistoryEntry.getState() after history.pushState()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-replaceState.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-replaceState.html
new file mode 100644
index 000000000000..23f037e57a0c
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-history-replaceState.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  appHistory.navigate("#", { replace : true, state : { data : "value" } });
+  assert_equals(appHistory.current.getState().data, "value");
+  history.replaceState(1, "", "#replace");
+  assert_equals(appHistory.current.getState(), undefined);
+}, "appHistoryEntry.getState() after history.replaceState()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-reload.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-reload.html
new file mode 100644
index 000000000000..28b2424e93ab
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-reload.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.navigate("#", { replace : true, state : { data : "value" } });
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.current.getState().data, "value");
+
+    i.contentWindow.location.reload();
+    i.onload = t.step_func_done(() => {
+      assert_equals(i.contentWindow.appHistory.entries().length, 1);
+      assert_equals(i.contentWindow.appHistory.current.getState().data, "value");
+    });
+  });
+}, "appHistoryEntry.getState() after location.reload()");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-location-api-navigation.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-location-api-navigation.html
new file mode 100644
index 000000000000..a56568b0a5b4
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-location-api-navigation.html
@@ -0,0 +1,49 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(async () => {
+    let entry0 = appHistory.current;
+
+    let navState = { statevar: "state" };
+    await appHistory.navigate("#1", { state: navState });
+    let entry1 = appHistory.current;
+
+    location.href = "#2";
+    let entry2 = appHistory.current;
+
+    t.step_func(() => {
+      assert_equals(appHistory.entries().length, 3);
+      assert_equals(entry0, appHistory.entries()[0]);
+      assert_equals(entry1, appHistory.entries()[1]);
+      assert_equals(entry2, appHistory.entries()[2]);
+
+      assert_equals(entry0.getState(), undefined);
+
+      let state1 = entry1.getState();
+      assert_not_equals(state1, undefined);
+      assert_not_equals(state1, navState);
+      assert_equals(state1.statevar, "state");
+
+      let state2 = entry2.getState();
+      assert_not_equals(state2, undefined);
+      assert_not_equals(state2, navState);
+      assert_equals(state2.statevar, "state");
+
+      history.back();
+      window.onpopstate = t.step_func_done(() => {
+        assert_equals(appHistory.entries().length, 3);
+        let back_entry = appHistory.current;
+        assert_equals(back_entry, appHistory.entries()[1]);
+        let back_state = back_entry.getState();
+        assert_not_equals(back_state, state1);
+        assert_not_equals(back_state, state2);
+        assert_equals(back_state.statevar, "state");
+      });
+    })();
+  }, 0);
+}, "appHistoryEntry.getState() behavior after navigating away and back via a fragment change");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-navigation.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-navigation.html
new file mode 100644
index 000000000000..6e6bdb0ac29f
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-after-same-document-navigation.html
@@ -0,0 +1,53 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+async_test(t => {
+  // Wait for after the load event so that the navigation doesn't get converted
+  // into a replace navigation.
+  window.onload = () => t.step_timeout(async () => {
+    let entry0 = appHistory.current;
+
+    let navState = { statevar: "state" };
+    await appHistory.navigate("#1", { state: navState });
+    let entry1 = appHistory.current;
+
+    navState.startvar2 = "otherstate";
+    await appHistory.navigate("#2", { state: navState });
+    let entry2 = appHistory.current;
+
+    t.step_func(() => {
+      assert_equals(appHistory.entries().length, 3);
+      assert_equals(entry0, appHistory.entries()[0]);
+      assert_equals(entry1, appHistory.entries()[1]);
+      assert_equals(entry2, appHistory.entries()[2]);
+
+      assert_equals(entry0.getState(), undefined);
+
+      let state1 = entry1.getState();
+      assert_not_equals(state1, undefined);
+      assert_not_equals(state1, navState);
+      assert_equals(state1.statevar, "state");
+      assert_equals(state1.startvar2, undefined);
+
+      let state2 = entry2.getState();
+      assert_not_equals(state2, undefined);
+      assert_not_equals(state2, navState);
+      assert_equals(state2.statevar, "state");
+      assert_equals(state2.startvar2, "otherstate");
+
+      history.back();
+      window.onpopstate = t.step_func_done(() => {
+        assert_equals(appHistory.entries().length, 3);
+        let back_entry = appHistory.current;
+        assert_equals(back_entry, appHistory.entries()[1]);
+        let back_state = back_entry.getState();
+        assert_not_equals(back_state, state1);
+        assert_not_equals(back_state, state2);
+        assert_equals(back_state.statevar, "state");
+        assert_equals(back_state.startvar2, undefined);
+      });
+    })();
+  }, 0);
+}, "appHistoryEntry.getState() behavior after navigating away and back");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-location-navigate.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-location-navigate.html
new file mode 100644
index 000000000000..384d8d940eeb
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-location-navigate.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.navigate("#", { replace : true, state : { data : "value" } });
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.current.getState().data, "value");
+
+    i.contentWindow.location.href = "?1";
+    i.onload = t.step_func_done(() => {
+      assert_equals(i.contentWindow.appHistory.entries().length, 2);
+      assert_equals(i.contentWindow.appHistory.current.index, 1);
+      assert_equals(i.contentWindow.appHistory.current.getState(), undefined);
+    });
+  });
+}, "appHistoryEntry.getState() behavior after cross-document location API navigation");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-restore.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-restore.html
new file mode 100644
index 000000000000..e1f70dc27bed
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-cross-document-restore.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe id="i" src="/common/blank.html"></iframe>
+<script>
+async_test(t => {
+  window.onload = t.step_func(() => {
+    i.contentWindow.appHistory.navigate("#", { replace : true, state : { data : "value" } });
+    assert_equals(i.contentWindow.appHistory.entries().length, 1);
+    assert_equals(i.contentWindow.appHistory.current.getState().data, "value");
+
+    let navigated_back = false;
+    i.contentWindow.appHistory.navigate("?1");
+    i.onload = t.step_func(() => {
+      if (navigated_back) {
+        let back_entry = i.contentWindow.appHistory.current;
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(back_entry.index, 0);
+        assert_equals(back_entry.getState().data, "value");
+        t.done();
+      } else {
+        assert_equals(i.contentWindow.appHistory.entries().length, 2);
+        assert_equals(i.contentWindow.appHistory.current, i.contentWindow.appHistory.entries()[1]);
+        assert_equals(i.contentWindow.appHistory.current.getState(), undefined);
+        history.back();
+        navigated_back = true;
+      }
+    });
+  });
+}, "appHistoryEntry.getState() behavior after navigating away and back");
+</script>
diff --git a/testing/web-platform/tests/app-history/navigate/state/navigate-state-invalid.html b/testing/web-platform/tests/app-history/navigate/state/navigate-state-invalid.html
new file mode 100644
index 000000000000..9cdcd58f86b2
--- /dev/null
+++ b/testing/web-platform/tests/app-history/navigate/state/navigate-state-invalid.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(async t => {
+  await promise_rejects_dom(t, 'DataCloneError', appHistory.navigate("#1", { state : new WritableStream()}));
+  assert_equals(appHistory.current.getState(), undefined);
+  assert_equals(location.hash, "");
+}, "navigate() with an unserializable state object (WriteableStream)");
+
+promise_test(async t => {
+  // See https://github.com/whatwg/html/issues/5380 for why not `new SharedArrayBuffer()`
+  const buffer = new WebAssembly.Memory({ shared:true, initial:1, maximum:1 }).buffer;
+  await promise_rejects_dom(t, 'DataCloneError', appHistory.navigate("#1", { state : buffer}));
+  assert_equals(appHistory.current.getState(), undefined);
+  assert_equals(location.hash, "");
+}, "navigate() with an unserializable state object (SharedArrayBuffer)");
+</script>