From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 11:22:09 +0200
Subject: Adding upstream version 110.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../web-platform/tests/navigation-timing/META.yml  |   5 +
 .../navigation-timing/buffered-flag.window.js      |  16 +++
 .../dom-interactive-image-document.html            |  25 ++++
 .../dom-interactive-media-document.html            |  25 ++++
 .../tests/navigation-timing/idlharness.window.js   |  20 +++
 .../tests/navigation-timing/nav2-data-uri.html     |  12 ++
 .../nav2-test-attributes-exist.html                |  67 ++++++++++
 .../nav2-test-attributes-values.html               | 137 +++++++++++++++++++++
 .../navigation-timing/nav2-test-document-open.html | 102 +++++++++++++++
 .../nav2-test-document-replaced.html               |  60 +++++++++
 .../navigation-timing/nav2-test-frame-removed.html |  27 ++++
 ...v2-test-instance-accessible-from-the-start.html |  13 ++
 .../nav2-test-instance-accessors.html              |  78 ++++++++++++
 .../nav2-test-navigate-iframe.html                 |  40 ++++++
 .../nav2-test-navigate-within-document.html        |  85 +++++++++++++
 .../nav2-test-navigation-type-backforward.html     |  82 ++++++++++++
 .../nav2-test-navigation-type-navigate.html        |  32 +++++
 .../nav2-test-navigation-type-reload.html          |  54 ++++++++
 ...direct-chain-xserver-final-original-origin.html |  53 ++++++++
 ...test-redirect-chain-xserver-partial-opt-in.html |  52 ++++++++
 .../navigation-timing/nav2-test-redirect-none.html |  33 +++++
 .../nav2-test-redirect-server.html                 |  49 ++++++++
 .../nav2-test-redirect-xserver.html                |  50 ++++++++
 ...uration-before-during-and-after-load-event.html |  27 ++++
 .../nav2-test-unique-nav-instances.html            |  76 ++++++++++++
 .../navigation-type-post-backforward.html          |  64 ++++++++++
 .../navigation-timing/nested-unload-timing.html    |  62 ++++++++++
 .../tests/navigation-timing/po-navigation.html     |  29 +++++
 .../prefetch-transfer-size-executor.html           |  66 ++++++++++
 .../prefetch-transfer-size-iframe.html             |  51 ++++++++
 .../resources/blank-page-green-with-onunload.html  |  11 ++
 .../resources/blank-page-green.html                |  10 ++
 .../resources/blank-page-meta-redirect.html        |  11 ++
 .../resources/blank-page-unload.html               |  25 ++++
 .../resources/blank-page-yellow-with-onunload.html |  11 ++
 .../resources/blank-page-yellow.html               |  10 ++
 .../resources/blank_page_prefetch.html             |  27 ++++
 .../resources/blank_page_prefetch.html.headers     |   1 +
 .../resources/iframe-prefetch-transfer-size.html   |  31 +++++
 .../resources/navigation-type-post-back.html       |  10 ++
 .../resources/navigation_type_post_back.py         |  12 ++
 .../resources/performance-attribute-sender.html    |  13 ++
 .../navigation-timing/resources/respond-slowly.py  |  29 +++++
 .../resources/secure-connection-interim.html       |   8 ++
 .../secure-connection-interim.html.headers         |   3 +
 .../resources/secure-connection-test.html          |  13 ++
 .../resources/webperftestharness.js                | 113 +++++++++++++++++
 .../secure-connection-start-non-zero.https.html    |  22 ++++
 .../secure-connection-start-reuse.https.html       |  15 +++
 .../supported-navigation-type.window.js            |  20 +++
 .../navigation-timing/test-document-onload.html    |  48 ++++++++
 .../navigation-timing/test-document-open.html      |  83 +++++++++++++
 .../test-document-readiness-exist.html             |  49 ++++++++
 .../test-navigate-within-document.html             |  67 ++++++++++
 .../test-navigation-attributes-exist.html          |  26 ++++
 .../test-navigation-redirectCount-none.html        |  31 +++++
 .../test-navigation-type-backforward.html          |  96 +++++++++++++++
 .../test-navigation-type-enums.html                |  28 +++++
 .../test-navigation-type-reload.html               | 109 ++++++++++++++++
 .../test-no-previous-document.html                 |  42 +++++++
 ...est-performance-attributes-exist-in-object.html |  29 +++++
 .../test-performance-attributes-exist.html         |  23 ++++
 .../test-performance-attributes.sub.html           |  29 +++++
 .../tests/navigation-timing/test-readwrite.html    |  28 +++++
 .../test-timing-attributes-exist.html              |  28 +++++
 .../test-timing-attributes-order.html              | 111 +++++++++++++++++
 .../test-timing-client-redirect.html               |  56 +++++++++
 .../navigation-timing/test-timing-reload.html      |  92 ++++++++++++++
 .../test-timing-server-redirect.html               |  49 ++++++++
 .../test-timing-xserver-redirect.html              |  72 +++++++++++
 .../test-unique-performance-objects.html           |  30 +++++
 .../unload-event-same-origin-check.html            | 125 +++++++++++++++++++
 72 files changed, 3138 insertions(+)
 create mode 100644 testing/web-platform/tests/navigation-timing/META.yml
 create mode 100644 testing/web-platform/tests/navigation-timing/buffered-flag.window.js
 create mode 100644 testing/web-platform/tests/navigation-timing/dom-interactive-image-document.html
 create mode 100644 testing/web-platform/tests/navigation-timing/dom-interactive-media-document.html
 create mode 100644 testing/web-platform/tests/navigation-timing/idlharness.window.js
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-data-uri.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-attributes-exist.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-attributes-values.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-document-open.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-document-replaced.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-frame-removed.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-instance-accessible-from-the-start.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-instance-accessors.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-navigate-iframe.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-navigate-within-document.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-backforward.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-navigate.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-reload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-final-original-origin.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-partial-opt-in.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-redirect-none.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-redirect-server.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-redirect-xserver.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-response-end-and-duration-before-during-and-after-load-event.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nav2-test-unique-nav-instances.html
 create mode 100644 testing/web-platform/tests/navigation-timing/navigation-type-post-backforward.html
 create mode 100644 testing/web-platform/tests/navigation-timing/nested-unload-timing.html
 create mode 100644 testing/web-platform/tests/navigation-timing/po-navigation.html
 create mode 100644 testing/web-platform/tests/navigation-timing/prefetch-transfer-size-executor.html
 create mode 100644 testing/web-platform/tests/navigation-timing/prefetch-transfer-size-iframe.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-green-with-onunload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-green.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-meta-redirect.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-unload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-yellow-with-onunload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank-page-yellow.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html.headers
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/iframe-prefetch-transfer-size.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/navigation-type-post-back.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/navigation_type_post_back.py
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/performance-attribute-sender.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/respond-slowly.py
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html.headers
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/secure-connection-test.html
 create mode 100644 testing/web-platform/tests/navigation-timing/resources/webperftestharness.js
 create mode 100644 testing/web-platform/tests/navigation-timing/secure-connection-start-non-zero.https.html
 create mode 100644 testing/web-platform/tests/navigation-timing/secure-connection-start-reuse.https.html
 create mode 100644 testing/web-platform/tests/navigation-timing/supported-navigation-type.window.js
 create mode 100644 testing/web-platform/tests/navigation-timing/test-document-onload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-document-open.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-document-readiness-exist.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigate-within-document.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigation-attributes-exist.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigation-redirectCount-none.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigation-type-backforward.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigation-type-enums.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-navigation-type-reload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-no-previous-document.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-performance-attributes-exist-in-object.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-performance-attributes-exist.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-performance-attributes.sub.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-readwrite.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-attributes-exist.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-attributes-order.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-client-redirect.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-reload.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-server-redirect.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-timing-xserver-redirect.html
 create mode 100644 testing/web-platform/tests/navigation-timing/test-unique-performance-objects.html
 create mode 100644 testing/web-platform/tests/navigation-timing/unload-event-same-origin-check.html

(limited to 'testing/web-platform/tests/navigation-timing')

diff --git a/testing/web-platform/tests/navigation-timing/META.yml b/testing/web-platform/tests/navigation-timing/META.yml
new file mode 100644
index 0000000000..bfb0e0f1f6
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/META.yml
@@ -0,0 +1,5 @@
+spec: https://w3c.github.io/navigation-timing/
+suggested_reviewers:
+  - plehegar
+  - igrigorik
+  - yoavweiss
diff --git a/testing/web-platform/tests/navigation-timing/buffered-flag.window.js b/testing/web-platform/tests/navigation-timing/buffered-flag.window.js
new file mode 100644
index 0000000000..c6b1e0bc85
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/buffered-flag.window.js
@@ -0,0 +1,16 @@
+async_test(t => {
+  function checkEntryList(entries) {
+    assert_equals(entries.length, 1, "Only one navigation timing entry");
+    assert_equals(entries[0].entryType, "navigation", "entryType is \"navigation\"");
+    assert_equals(entries[0].name, window.location.toString(), "name is the address of the document");
+  }
+  // First observer creates second in callback to ensure the entry has been dispatched by the time
+  // the second observer begins observing.
+  new PerformanceObserver(t.step_func(entryList => {
+    checkEntryList(entryList.getEntries());
+    // Second observer requires 'buffered: true' to see the navigation entry.
+    new PerformanceObserver(t.step_func_done(list => {
+      checkEntryList(list.getEntries());
+    })).observe({type: 'navigation', buffered: true});
+  })).observe({entryTypes: ["navigation"]});
+}, "PerformanceObserver with buffered flag sees previous navigation entry.");
diff --git a/testing/web-platform/tests/navigation-timing/dom-interactive-image-document.html b/testing/web-platform/tests/navigation-timing/dom-interactive-image-document.html
new file mode 100644
index 0000000000..36742f0eff
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/dom-interactive-image-document.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Test domInteractive on image document.</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="https://html.spec.whatwg.org/multipage/browsing-the-web.html#read-media"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <script>
+        const t = async_test("Test domInteractive on image document");
+        function frameLoaded() {
+            const timing = document.querySelector("iframe").contentWindow.performance.timing;
+            assert_greater_than(timing.domInteractive, 0,
+                "Expect domInteractive to be positive value.");
+            t.done();
+        }
+    </script>
+    <body>
+        <h1>Description</h1>
+        <p>This tests that a image document has positive-value domInteractive.</p>
+        <iframe src="../images/smiley.png" onload="frameLoaded()"></iframe>
+    </body>
+</html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/navigation-timing/dom-interactive-media-document.html b/testing/web-platform/tests/navigation-timing/dom-interactive-media-document.html
new file mode 100644
index 0000000000..e4e45725d8
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/dom-interactive-media-document.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Test domInteractive on media document.</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="https://html.spec.whatwg.org/multipage/browsing-the-web.html#read-media"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <script>
+        const t = async_test("Test domInteractive on media document");
+        function frameLoaded() {
+            const timing = document.querySelector("iframe").contentWindow.performance.timing;
+            assert_greater_than(timing.domInteractive, 0,
+                "Expect domInteractive to be positive value.");
+            t.done();
+        }
+    </script>
+    <body>
+        <h1>Description</h1>
+        <p>This tests that a media document has positive-value domInteractive.</p>
+        <iframe src="../media/A4.mp4" onload="frameLoaded()"></iframe>
+    </body>
+</html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/navigation-timing/idlharness.window.js b/testing/web-platform/tests/navigation-timing/idlharness.window.js
new file mode 100644
index 0000000000..72cf0c3a3d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/idlharness.window.js
@@ -0,0 +1,20 @@
+// META: script=/resources/WebIDLParser.js
+// META: script=/resources/idlharness.js
+// META: timeout=long
+
+'use strict';
+
+// http://www.w3.org/TR/navigation-timing/
+
+idl_test(
+  ['navigation-timing', 'hr-time'],
+  ['resource-timing', 'performance-timeline', 'dom', 'html'],
+  idlArray => {
+    idlArray.add_objects({
+      Performance: ['performance'],
+      PerformanceNavigation: ['performance.navigation'],
+      PerformanceTiming: ['performance.timing'],
+      PerformanceNavigationTiming: ['performance.getEntriesByType("navigation")[0]']
+    });
+  }
+);
diff --git a/testing/web-platform/tests/navigation-timing/nav2-data-uri.html b/testing/web-platform/tests/navigation-timing/nav2-data-uri.html
new file mode 100644
index 0000000000..851691d6c4
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-data-uri.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<title>data URL source for navigation-timing/nav2_test_open_data_uri.html</title>
+<!-- NB: this file isn't actually used any where! -->
+<link rel="author" title="Google" href="http://www.google.com/" />
+<script>
+var observer = new PerformanceObserver(
+    function (entryList) {
+        parent.postMessage("observed", "*");
+        observer.disconnect();
+    });
+observer.observe({entryTypes: ["navigation"]});
+</script>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-attributes-exist.html b/testing/web-platform/tests/navigation-timing/nav2-test-attributes-exist.html
new file mode 100644
index 0000000000..b6048e061b
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-attributes-exist.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that PerformanceObserver can observe nav timing 2 instance and that the expected attributes in nav timing 2 instance exist (but does not validate that the values are correct).</p>
+
+        <script>
+        var navTiming2Attributes = [
+            'connectEnd',
+            'connectStart',
+            'decodedBodySize',
+            'domComplete',
+            'domContentLoadedEventEnd',
+            'domContentLoadedEventStart',
+            'domInteractive',
+            'domainLookupEnd',
+            'domainLookupStart',
+            'duration',
+            'encodedBodySize',
+            'entryType',
+            'fetchStart',
+            'initiatorType',
+            'loadEventEnd',
+            'loadEventStart',
+            'name',
+            'nextHopProtocol',
+            'redirectCount',
+            'redirectEnd',
+            'redirectStart',
+            'requestStart',
+            'responseEnd',
+            'responseStart',
+            'secureConnectionStart',
+            'transferSize',
+            'type',
+            'unloadEventEnd',
+            'unloadEventStart',
+            'workerStart'
+        ];
+        async_test(function (t) {
+            var observer = new PerformanceObserver(
+                t.step_func(function (entryList) {
+                    var entries = entryList.getEntries();
+                    assert_equals(entries.length, 1,
+                        "There should be only one navigation timing instance.");
+                    for (var i = 0; i < navTiming2Attributes.length; i++) {
+                        assert_true(navTiming2Attributes[i] in entries[0],
+                            "Expected attribute: " + navTiming2Attributes[i] + ".");
+                    }
+                    observer.disconnect();
+                    t.done();
+                })
+            );
+            observer.observe({entryTypes: ["navigation"]});
+
+        }, "Performance navigation timing entries are observable.");
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-attributes-values.html b/testing/web-platform/tests/navigation-timing/nav2-test-attributes-values.html
new file mode 100644
index 0000000000..f13a8988fc
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-attributes-values.html
@@ -0,0 +1,137 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/get-host-info.sub.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the values of nav timing 2 instance's timing-related attributes are in certain order and the others are of expected values.</p>
+
+        <script>
+        // Host names and ports may be configured at test execution time. The
+        // web-platform-tests server offers two mechanisms for retrieving these
+        // values dynamically: direct text substitution and the `get-host-info`
+        // script. The former is inapproprate for this test because it
+        // influences the size of the document, and this test includes static
+        // assertions for that value.
+        var host_info = get_host_info();
+        var expectedUrl = "http://" + host_info.ORIGINAL_HOST + ":" +
+            host_info.HTTP_PORT +
+          "/navigation-timing/nav2-test-attributes-values.html";
+        var navTiming2EventOrder1 = [
+            'startTime',
+            'redirectStart',
+            //'unloadEventStart',
+            'redirectEnd',
+            //'unloadEventEnd',
+            'fetchStart',
+            'domainLookupStart',
+            'domainLookupEnd',
+            'connectStart',
+            //'secureConnectionStart',
+            'connectEnd',
+            'requestStart',
+            'responseStart',
+            'responseEnd',
+            'domInteractive',
+            'domContentLoadedEventStart',
+            'domContentLoadedEventEnd',
+            'domComplete',
+            'loadEventStart',
+            'loadEventEnd'
+        ];
+
+        var navTiming2EventOrder2 = [
+            'redirectStart',
+            'unloadEventStart',
+            'redirectEnd',
+            'unloadEventEnd',
+            'fetchStart'
+        ];
+
+        var navTiming2EventOrder3 = [
+            'connectStart',
+            'secureConnectionStart',
+            'connectEnd'
+        ];
+
+        // Navigation Timing attributes for comparison.
+        var navTiming1EventOrder = [
+            'fetchStart',
+            'domainLookupStart',
+            'domainLookupEnd',
+            'connectStart',
+            'connectEnd',
+            'requestStart',
+            'responseStart',
+            'responseEnd',
+            'domInteractive',
+            'domContentLoadedEventStart',
+            'domContentLoadedEventEnd',
+            'domComplete',
+            'loadEventStart',
+            'loadEventEnd'
+        ];
+
+        function verifyTimingEventOrder(eventOrder, timingEntry) {
+            for (var i = 0; i < eventOrder.length - 1; i++) {
+                assert_true(timingEntry[eventOrder[i]] <= timingEntry[eventOrder[i + 1]],
+                    "Expected " + eventOrder[i] + " to be no greater than " + eventOrder[i + 1] + ".");
+            }
+        }
+
+        async_test(function (t) {
+            var observer = new PerformanceObserver(
+                t.step_func(function (entryList) {
+                    var entries = entryList.getEntries();
+                    assert_equals(entries[0].entryType, "navigation",
+                        "Expected entryType to be: navigation.");
+                    assert_equals(entries[0].name, expectedUrl);
+                    assert_equals(entries[0].startTime, 0,
+                        "Expected startTime to be: 0.");
+                    assert_equals(entries[0].duration, entries[0].loadEventEnd,
+                        "Expected duration to be equal to loadEventEnd.");
+                    assert_equals(entries[0].initiatorType, "navigation",
+                        "Expected initiatorType to be: navigation.");
+                    assert_equals(entries[0].nextHopProtocol, "http/1.1");
+                    // This test may fail when response is from cach. Disable or clean cach before
+                    // running this test.
+                    assert_true(entries[0].transferSize > entries[0].encodedBodySize,
+                        "Expected transferSize to be greater than encodedBodySize in uncached navigation.");
+                  assert_equals(entries[0].encodedBodySize, 5949);
+                  assert_equals(entries[0].decodedBodySize, 5949);
+                    verifyTimingEventOrder(entries[0], navTiming2EventOrder1);
+                    // Verify if the reported timing is not that different
+                    // from what is reported by Navigation Timing 1.
+                    navTiming1EventOrder.forEach(
+                      function(event) {
+                        if (window.performance.timing[event] -
+                            window.performance.timing.navigationStart > 0) {
+                          assert_greater_than(entries[0][event], 0,
+                              "Expected " + event + " to be greater than 0");
+                        }
+                    });
+                    // When unloadEvent happens
+                    if (entries[0]["unloadEventStart"] != 0) {
+                        verifyTimingEventOrder(entries[0], navTiming2EventOrder2);
+                    }
+                    // When a secure transport is used
+                    if (entries[0]["secureConnectionStart"] != 0) {
+                        verifyTimingEventOrder(entries[0], navTiming2EventOrder3);
+                    }
+                    observer.disconnect();
+                    t.done();
+                })
+            );
+            observer.observe({entryTypes: ["navigation"]});
+
+        }, "Performance navigation timing instance's value is reasonable.");
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-document-open.html b/testing/web-platform/tests/navigation-timing/nav2-test-document-open.html
new file mode 100644
index 0000000000..aa1097248d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-document-open.html
@@ -0,0 +1,102 @@
+  <!DOCTYPE html>
+  <html>
+      <head>
+          <meta charset="utf-8" />
+          <title>Navigation Timing 2 WPT</title>
+          <link rel="author" title="Google" href="http://www.google.com/" />
+          <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+          <script src="/resources/testharness.js"></script>
+          <script src="/resources/testharnessreport.js"></script>
+          <script>
+              setup({ single_test: true });
+
+              var navTiming2Attributes = [
+                  'connectEnd',
+                  'connectStart',
+                  'decodedBodySize',
+                  'domComplete',
+                  'domContentLoadedEventEnd',
+                  'domContentLoadedEventStart',
+                  'domInteractive',
+                  'domainLookupEnd',
+                  'domainLookupStart',
+                  'duration',
+                  'encodedBodySize',
+                  'entryType',
+                  'fetchStart',
+                  'initiatorType',
+                  'loadEventEnd',
+                  'loadEventStart',
+                  'name',
+                  'redirectCount',
+                  'redirectEnd',
+                  'redirectStart',
+                  'requestStart',
+                  'responseEnd',
+                  'responseStart',
+                  'secureConnectionStart',
+                  'transferSize',
+                  'type',
+                  'unloadEventEnd',
+                  'unloadEventStart',
+                  'workerStart'
+              ];
+
+              var originalTiming = {};
+              var didOpen = false;
+
+              function onload_test()
+              {
+                  if (!didOpen) {
+                      setTimeout(testTimingWithDocumentOpen, 0);
+                      didOpen = true;
+                  }
+              }
+
+              function testTimingWithDocumentOpen()
+              {
+                  var subcontentWindow = document.getElementById("frameContext").contentWindow;
+
+                  var timing = subcontentWindow.performance.getEntriesByType("navigation")[0];
+                  for (i in navTiming2Attributes) {
+                      originalTiming[navTiming2Attributes[i]] = timing[navTiming2Attributes[i]];
+                  }
+
+                  var subdocument = subcontentWindow.document;
+                  subdocument.open();
+                  subdocument.write('<!DOCTYPE HTML>');
+                  subdocument.write('<html>');
+                  subdocument.write('<head>');
+                  subdocument.write('<meta charset="utf-8" />');
+                  subdocument.write('<title><Green Test Page</title>');
+                  subdocument.write('</head>');
+                  subdocument.write('<body style="background-color:#00FF00;">');
+                  subdocument.write('</body>');
+                  subdocument.write('</html>');
+                  subdocument.close();
+
+                  setTimeout(function() {
+                      var timing = subcontentWindow.performance.getEntriesByType("navigation")[0];
+                      for (var i in navTiming2Attributes) {
+                          assert_equals(originalTiming[navTiming2Attributes[i]], timing[navTiming2Attributes[i]],
+                            navTiming2Attributes[i] + " is the same after document open.");
+                      }
+                      done();
+                  }, 0);
+              }
+          </script>
+      </head>
+      <body>
+          <h1>Description</h1>
+          <p>This test validates window.performance.getEntriesByType("navigation") remains constant when a
+          document is replaced using document.open.</p>
+
+          <p>This page should be loaded with a yellow frame below. It then replaces the
+          document in that frame with a green document.</p>
+
+          <p>The test passes if all of the checks to performance.getEntriesByType("navigation") are correct and
+          the frame below ends with a green background.</p>
+
+          <iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow.html" style="width: 250px; height: 250px;"></iframe>
+      </body>
+  </html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-document-replaced.html b/testing/web-platform/tests/navigation-timing/nav2-test-document-replaced.html
new file mode 100644
index 0000000000..5972f20e9b
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-document-replaced.html
@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            var navigation_frame;
+            var pnt1;
+            var step = 1;
+            function onload_test()
+            {
+                navigation_frame = document.getElementById("frameContext").contentWindow;
+                setTimeout("nav_frame();", 0);
+            }
+
+            function nav_frame()
+            {
+                switch (step)
+                {
+                    case 1:
+                    {
+                        pnt1 = navigation_frame.performance.getEntriesByType("navigation")[0];
+                        navigation_frame.location.href = '/navigation-timing/resources/blank_page_green_with_onunload.html';
+                        step++;
+                        break;
+                    }
+                    case 2:
+                    {
+                        navigation_frame.history.back();
+                        step++;
+                        break;
+                    }
+                    case 3:
+                    {
+                        var pnt2 = navigation_frame.performance.getEntriesByType("navigation")[0];
+                        assert_equals(pnt1.type, "navigate");
+                        assert_equals(pnt2.type, "back_forward");
+                        done();
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        </script>
+    </head>
+    <body>
+        <h1>
+            Description</h1>
+        <p>
+            This test validates that a PerformanceNavigatingTiming corresponding to a detached document can't access a different document's state. </p>
+        <iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow_with_onunload.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-frame-removed.html b/testing/web-platform/tests/navigation-timing/nav2-test-frame-removed.html
new file mode 100644
index 0000000000..0bef297d4e
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-frame-removed.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script>
+            function onload_test()
+            {   test(function() {
+                    var pnt = window.frames[0].performance.getEntriesByType("navigation")[0];
+                    document.getElementById("frameContext").remove();
+                    assert_equals(pnt.type, "navigate");
+                });
+            }
+        </script>
+    </head>
+    <body>
+        <h1>
+            Description</h1>
+        <p>
+            This test validates that PerformanceNavigationTiming::type()'s default value is navigate </p>
+        <iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow_with_onunload.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessible-from-the-start.html b/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessible-from-the-start.html
new file mode 100644
index 0000000000..ad50c6a87d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessible-from-the-start.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(function() {
+  var navigationTiming2 = window.performance.getEntriesByType('navigation')[0];
+  assert_not_equals(navigationTiming2, undefined);
+  assert_equals(navigationTiming2.entryType, "navigation");
+  assert_equals(navigationTiming2.startTime, 0);
+  assert_equals(navigationTiming2.initiatorType, "navigation");
+  done();
+}, "PerformanceNavigationTiming instance exists with reasonable values.");
+</script>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessors.html b/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessors.html
new file mode 100644
index 0000000000..17f36832c9
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-instance-accessors.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/get-host-info.sub.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that nav timing 2 instance can be accessed by three different accessors once available: window.performance.getEntries()/getEntriesByType("navigation")/getEntriesByName("document")</p>
+
+        <script>
+        var host_info = get_host_info();
+        var expectedUrl = "http://" + host_info.ORIGINAL_HOST + ":" +
+          host_info.HTTP_PORT + "/navigation-timing/nav2-test-instance-accessors.html";
+        var navTiming2Attributes = [
+            'connectEnd',
+            'connectStart',
+            'decodedBodySize',
+            'domComplete',
+            'domContentLoadedEventEnd',
+            'domContentLoadedEventStart',
+            'domInteractive',
+            'domainLookupEnd',
+            'domainLookupStart',
+            'duration',
+            'encodedBodySize',
+            'entryType',
+            'fetchStart',
+            'initiatorType',
+            'loadEventEnd',
+            'loadEventStart',
+            'name',
+            'redirectCount',
+            'redirectEnd',
+            'redirectStart',
+            'requestStart',
+            'responseEnd',
+            'responseStart',
+            'secureConnectionStart',
+            'transferSize',
+            'type',
+            'unloadEventEnd',
+            'unloadEventStart',
+            'workerStart'
+        ];
+
+        async_test(function (t) {
+            var observer = new PerformanceObserver(
+                t.step_func(function (entryList) {
+                    var instance1 = performance.getEntries()[0];
+                    var instance2 = performance.getEntriesByType("navigation")[0];
+                    var instance3 = performance.getEntriesByName(expectedUrl)[0];
+
+                    assert_equals(performance.getEntriesByType("navigation").length, 1, "Expected there is only one navigation timing instance.");
+                    assert_equals(performance.getEntriesByName(expectedUrl).length, 1, "Expected there is only one navigation timing instance.");
+
+                    for (var i = 0; i < navTiming2Attributes.length; i++) {
+                        assert_equals(instance1[navTiming2Attributes[i]], instance2[navTiming2Attributes[i]]);
+                    }
+
+                    for (var i = 0; i < navTiming2Attributes.length; i++) {
+                        assert_equals(instance1[navTiming2Attributes[i]], instance3[navTiming2Attributes[i]]);
+                    }
+                    observer.disconnect();
+                    t.done();
+                })
+            );
+            observer.observe({entryTypes: ["navigation"]});
+
+        }, "Performance navigation timing entries are accessible through three different accessors.");
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-navigate-iframe.html b/testing/web-platform/tests/navigation-timing/nav2-test-navigate-iframe.html
new file mode 100644
index 0000000000..0c144bda45
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-navigate-iframe.html
@@ -0,0 +1,40 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <meta charset=utf-8>
+    <title>PerformanceNavigationTiming.name updated in iframes</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+promise_test(async function (t) {
+  var ifr = document.createElement("iframe");
+  document.body.appendChild(ifr);
+
+  ifr.src="resources/blank_page_green.html";
+  await new Promise(resolve => {
+    ifr.onload = function() {
+      assert_equals(ifr.contentWindow.performance.getEntriesByType("navigation").length, 1, "Only one navigation time entry");
+      assert_equals(ifr.contentWindow.performance.getEntriesByType("navigation")[0].name, ifr.contentWindow.location.toString(), "navigation name matches the window.location");
+      assert_true(ifr.contentWindow.performance.getEntriesByType("navigation")[0].name.endsWith("blank_page_green.html"), "navigation name is blank_page_green.html");
+      resolve();
+    }
+  });
+
+
+  await new Promise(resolve => { setTimeout(resolve, 100); });
+  ifr.src ="resources/blank_page_yellow.html";
+
+  await new Promise(resolve => {
+    ifr.onload = function() {
+      assert_equals(ifr.contentWindow.performance.getEntriesByType("navigation").length, 1, "Only one navigation time entry");
+      assert_equals(ifr.contentWindow.performance.getEntriesByType("navigation")[0].name, ifr.contentWindow.location.toString(), "navigation name matches the window.location");
+      assert_true(ifr.contentWindow.performance.getEntriesByType("navigation")[0].name.endsWith("blank_page_yellow.html"), "navigation name is blank_page_yellow.html");
+      resolve();
+    }
+  });
+}, "navigation.name updated when iframe URL changes");
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-navigate-within-document.html b/testing/web-platform/tests/navigation-timing/nav2-test-navigate-within-document.html
new file mode 100644
index 0000000000..75e6e113b6
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-navigate-within-document.html
@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" >
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that all of the window.performance.getEntriesByType("navigation") attributes remain unchanged after an in document navigation (URL fragment change).</p>
+
+        <script>
+            setup({ single_test: true });
+
+            var navTiming2Attributes = [
+                'connectEnd',
+                'connectStart',
+                'decodedBodySize',
+                'domComplete',
+                'domContentLoadedEventEnd',
+                'domContentLoadedEventStart',
+                'domInteractive',
+                'domainLookupEnd',
+                'domainLookupStart',
+                'duration',
+                'encodedBodySize',
+                'entryType',
+                'fetchStart',
+                'initiatorType',
+                'loadEventEnd',
+                'loadEventStart',
+                'name',
+                'redirectCount',
+                'redirectEnd',
+                'redirectStart',
+                'requestStart',
+                'responseEnd',
+                'responseStart',
+                'secureConnectionStart',
+                'transferSize',
+                'type',
+                'unloadEventEnd',
+                'unloadEventStart',
+                'workerStart'
+            ];
+
+            var initial_timing = {};
+
+            function check_timing_not_changed()
+            {
+                var timing = window.performance.getEntriesByType("navigation")[0];
+                for (var i = 0; i < navTiming2Attributes.length; ++i)
+                {
+                    var property = navTiming2Attributes[i];
+                    assert_equals(timing[property], initial_timing[property],
+                                property + " is the same after in document navigation.");
+                }
+                done();
+            }
+
+            function save_timing_after_load()
+            {
+                var timing = window.performance.getEntriesByType("navigation")[0];
+                for (var i = 0; i < navTiming2Attributes.length; ++i)
+                {
+                    var property = navTiming2Attributes[i];
+                    initial_timing[property] = timing[property];
+                }
+                window.location.href = "#1";
+                setTimeout("check_timing_not_changed()", 0);
+            }
+
+            function load_handler()
+            {
+                window.removeEventListener("load", load_handler);
+                setTimeout("save_timing_after_load()", 0);
+            }
+
+            window.addEventListener("load", load_handler, false);
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-backforward.html b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-backforward.html
new file mode 100644
index 0000000000..d0045415b8
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-backforward.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            function onload_test()
+            {
+                // do this with a timeout to see the visuals of the navigations.
+                setTimeout("nav_frame();", 100);
+            }
+
+            var step = 1;
+            function nav_frame()
+            {
+                var navigation_frame = document.getElementById("frameContext").contentWindow;
+                switch (step)
+                {
+                    case 1:
+                    {
+                        navigation_frame.location.href = '/navigation-timing/resources/blank_page_green_with_onunload.html';
+                        step++;
+                        break;
+                    }
+                    case 2:
+                    {
+                        assert_equals(navigation_frame.performance.getEntriesByType("navigation")[0].type,
+                                "navigate",
+                                'Expected navigation type to be navigate.');
+                        navigation_frame.history.back();
+                        step++;
+                        break;
+                    }
+                    case 3:
+                    {
+                        assert_equals(navigation_frame.performance.getEntriesByType("navigation")[0].type,
+                                "back_forward",
+                                'Expected navigation type to be back_forward.');
+                        step++;
+                        navigation_frame.history.forward();
+                        break;
+                    }
+                    case 4:
+                    {
+                        assert_equals(navigation_frame.performance.getEntriesByType("navigation")[0].type,
+                                "back_forward",
+                                'Expected navigation type to be back_forward.');
+                        done();
+                        step++;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>
+            Description</h1>
+        <p>
+            This test validates the value of window.performance.getEntriesByType("navigation")[0].type with a forward
+            and back navigation.</p>
+
+        <p>This page should be loaded with a yellow background frame below.  It should turn green for a starting
+            navigation, back to yellow for a back navigation and then back to green again for a forward navigation.</p>
+
+        <p>Along the navigation timeline the window.performance.getEntriesByType("navigation")[0].type is checked for back_forward.</p>
+
+        <p>This test passes if all of the checks to the window.performance.getEntriesByType("navigation")[0].type are correct throughout the navigation
+            scenario and the frame below ends with a green background.  Otherwise, this test fails.</p>
+
+        <iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow_with_onunload.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-navigate.html b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-navigate.html
new file mode 100644
index 0000000000..efaef1ec0b
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-navigate.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script>
+            async_test(function (t) {
+                var observer = new PerformanceObserver(
+                    t.step_func(function (entryList) {
+                        assert_equals(entryList.getEntries()[0].type, "navigate", "Expected navigation type to be navigate.");
+                        observer.disconnect();
+                        t.done();
+                    })
+                );
+                observer.observe({entryTypes: ["navigation"]});
+
+            }, "Navigation type to be navigate.");
+        </script>
+
+    </head>
+    <body>
+        <h1>
+            Description</h1>
+        <p>
+            This test validates the value of window.performance.getEntriesByType("navigation")[0].type to be navigate.</p>
+
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-reload.html b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-reload.html
new file mode 100644
index 0000000000..0f03f07c57
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-navigation-type-reload.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            var reload_frame;
+
+            function onload_test()
+            {
+                reload_frame = document.getElementById("frameContext");
+                reload_frame.onload = function() {
+                    setTimeout(do_test, 0);
+                }
+                setTimeout("reload_the_frame();", 100);
+            }
+
+            function reload_the_frame()
+            {
+                reload_frame.contentWindow.location.reload(true);
+            }
+
+            function do_test()
+            {
+                var newNavTiming = document.getElementById("frameContext").contentWindow.performance.getEntriesByType("navigation")[0];
+                assert_equals(newNavTiming.type, "reload", "Expected navigation type to be reload.");
+                assert_true(newNavTiming.unloadEventStart > 0, "Expected unloadEventStart to be greater than 0.");
+                assert_true(newNavTiming.unloadEventEnd > 0, "Expected unloadEventEnd to be greater than 0.");
+                done();
+            }
+        </script>
+    </head>
+    <body onload="onload_test();">
+        <h1>Description</h1>
+        <p>This test validates the value of window.performance.getEntriesByType("navigation")[0].(type/unloadEventEnd/unloadEventStart) with a reloaded navigation.</p>
+
+        <p>This page should be loaded with a green background frame below. The frame will be automatically reloaded
+        and then verified that
+        <ul>
+            <li>The window.performance.getEntriesByType("navigation").type = "reload" after reload</li>
+            <li>The window.performance.getEntriesByType("navigation").unloadEventStart > 0 after reload</li>
+            <li>The window.performance.getEntriesByType("navigation").unloadEventEnd > 0 after reload</li>
+        </ul>
+        </p>
+
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-final-original-origin.html b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-final-original-origin.html
new file mode 100644
index 0000000000..fdefa20250
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-final-original-origin.html
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/utils.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            function onload_test()
+            {
+                const frame_performance = document.getElementById("frameContext").contentWindow.performance;
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].type,
+                    "navigate",
+                    "Expected navigation type to be navigate.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectCount, 0,
+                    "Expected redirectCount to be 0.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectStart, 0,
+                    "Expected redirectStart to be 0.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectEnd, 0,
+                    "Expected redirectEnd to be 0.");
+                done();
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.getEntriesByType("navigation")[0].redirectCount and the
+           window.performance.getEntriesByType("navigation")[0].redirectStart/End times for a cross-origin server side redirect navigation when the final
+           document is the same as the original origin.</p>
+
+        <iframe id="frameContext" src="" style="width: 250px; height: 250px;"></iframe>
+        <script>
+            // combine the page origin and redirect origin into the IFRAME's src URL
+            const destUrl_first = make_absolute_url({subdomain: "www",
+                                             path: "/common/redirect-opt-in.py",
+                                             query: "location=" + make_absolute_url(
+                                                         {path: "/navigation-timing/resources/blank_page_green.html"})
+                                             });
+            const destUrl = make_absolute_url({
+                                             path: "/common/redirect.py",
+                                             query: "location=" + destUrl_first});
+            let frameContext = document.getElementById("frameContext");
+            frameContext.onload = onload_test;
+            frameContext.src = destUrl;
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-partial-opt-in.html b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-partial-opt-in.html
new file mode 100644
index 0000000000..0feb3bfa7f
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-chain-xserver-partial-opt-in.html
@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/utils.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            function onload_test()
+            {
+                const frame_performance = document.getElementById("frameContext").contentWindow.performance;
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].type,
+                    "navigate",
+                    "Expected navigation type to be navigate.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectCount, 0,
+                    "Expected redirectCount to be 0.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectStart, 0,
+                    "Expected redirectStart to be 0.");
+                assert_equals(frame_performance.getEntriesByType("navigation")[0].redirectEnd, 0,
+                    "Expected redirectEnd to be 0.");
+                done();
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.getEntriesByType("navigation")[0].redirectCount and the
+           window.performance.getEntriesByType("navigation")[0].redirectStart/End times for a cross-origin server side redirect navigation when the redirect chooses to opt-in.</p>
+
+        <iframe id="frameContext" src="" style="width: 250px; height: 250px;"></iframe>
+        <script>
+            // combine the page origin and redirect origin into the IFRAME's src URL
+            const destUrl_first = make_absolute_url({subdomain: "www",
+                                             path: "/common/redirect-opt-in.py",
+                                             query: "location=" + make_absolute_url(
+                                                         {path: "/navigation-timing/resources/blank_page_green.html"})
+                                             });
+            const destUrl = make_absolute_url({subdomain: "www",
+                                             path: "/common/redirect.py",
+                                             query: "location=" + destUrl_first});
+            let frameContext = document.getElementById("frameContext");
+            frameContext.onload = onload_test;
+            frameContext.src = destUrl;
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-redirect-none.html b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-none.html
new file mode 100644
index 0000000000..97437e1a5e
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-none.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the value of the window.performance.getEntriesByType("navigation")[0].redirectCount attribute, as well as the window.performance.getEntriesByType("navigation")[0].redirectStart and redirectEnd attributes on a non-redirected navigation.</p>
+
+        <script>
+
+        async_test(function (t) {
+            var observer = new PerformanceObserver(
+                t.step_func(function (entryList) {
+                    var navTiming = performance.getEntriesByType("navigation")[0];
+                    assert_equals(navTiming.redirectCount, 0, "Expected redirectCount to be 0.");
+                    assert_equals(navTiming.redirectStart, 0, "Expected redirectStart to be 0.");
+                    assert_equals(navTiming.redirectEnd, 0, "Expected redirectEnd to be 0.");
+                    observer.disconnect();
+                    t.done();
+                })
+            );
+            observer.observe({entryTypes: ["navigation"]});
+
+        }, "Naivation without redirects.");
+        </script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-redirect-server.html b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-server.html
new file mode 100644
index 0000000000..9ec2992bef
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-server.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+
+        <script>
+            setup({ single_test: true });
+
+            function verifyTimingEventOrder(eventOrder, timingEntry) {
+                for (let i = 0; i < eventOrder.length - 1; i++) {
+                    assert_true(timingEntry[eventOrder[i]] < timingEntry[eventOrder[i + 1]],
+                        "Expected " + eventOrder[i] + " to be no greater than " + eventOrder[i + 1] + ".");
+                }
+            }
+
+            function onload_test()
+            {
+                const frame_performance = document.getElementById("frameContext").contentWindow.performance;
+                const navigation_entry = frame_performance.getEntriesByType("navigation")[0];
+                assert_equals(navigation_entry.type,
+                        "navigate",
+                        "Expected navigation type  to be navigate.");
+                assert_equals(navigation_entry.redirectCount, 1, "Expected redirectCount to be 1.");
+                assert_equals(navigation_entry.name, 'http://' + document.location.host + '/navigation-timing/resources/blank_page_green.html');
+
+                var timgingEvents = [
+                    'startTime',
+                    'redirectStart',
+                    'redirectEnd',
+                ];
+                verifyTimingEventOrder(timgingEvents, frame_performance.getEntriesByType("navigation")[0]);
+                done();
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.redirectCount and the
+           window.performance.timing.redirectStart/End times for a same-origin server side redirect navigation.</p>
+
+        <iframe id="frameContext" onload="onload_test();" src="/common/redirect.py?location=/navigation-timing/resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-redirect-xserver.html b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-xserver.html
new file mode 100644
index 0000000000..d8acc8054d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-redirect-xserver.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/utils.js"></script>
+        <script>
+            setup({ single_test: true });
+
+            function onload_test()
+            {
+                var performanceNamespace = document.getElementById("frameContext").contentWindow.performance;
+                assert_equals(performanceNamespace.getEntriesByType("navigation")[0].type,
+                    "navigate",
+                    "Expected navigation type to be navigate.");
+                assert_equals(performanceNamespace.getEntriesByType("navigation")[0].redirectCount, 0,
+                    "Expected redirectCount to be 0.");
+                assert_equals(performanceNamespace.getEntriesByType("navigation")[0].redirectStart, 0,
+                    "Expected redirectStart to be 0.");
+                assert_equals(performanceNamespace.getEntriesByType("navigation")[0].redirectEnd, 0,
+                    "Expected redirectEnd to be 0.");
+
+                done();
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.getEntriesByType("navigation")[0].redirectCount and the
+           window.performance.getEntriesByType("navigation")[0].redirectStart/End times for a cross-origin server side redirect navigation.</p>
+
+        <iframe id="frameContext" src="" style="width: 250px; height: 250px;"></iframe>
+        <script>
+            // combine the page origin and redirect origin into the IFRAME's src URL
+            var destUrl = make_absolute_url({subdomain: "www",
+                                             path: "/common/redirect.py",
+                                             query: "location=" + make_absolute_url(
+                                                         {path: "/navigation-timing/resources/blank_page_green.html"})
+                                             });
+            var frameContext = document.getElementById("frameContext");
+            frameContext.onload = onload_test;
+            frameContext.src = destUrl;
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-response-end-and-duration-before-during-and-after-load-event.html b/testing/web-platform/tests/navigation-timing/nav2-test-response-end-and-duration-before-during-and-after-load-event.html
new file mode 100644
index 0000000000..3876ce7e86
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-response-end-and-duration-before-during-and-after-load-event.html
@@ -0,0 +1,27 @@
+<!DOCTYPE HTML>
+<html>
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<iframe src="resources/respond-slowly.py"></iframe>
+<body>
+<script>
+async_test(function(t) {
+  window.addEventListener('message', t.step_func_done(function(event) {
+    let originalResponseEnd = event.data[0];
+    let originalDuration = event.data[1];
+    let responseEndDuringLoadEvent = event.data[2];
+    let durationDuringLoadEvent = event.data[3];
+    let responseEndAfterLoadEvent = event.data[4];
+    let durationAfterLoadEvent = event.data[5];
+    assert_equals(originalResponseEnd, 0, "PerformanceNavigationTiming.responseEnd == 0 before load event");
+    assert_equals(originalDuration, 0, "PerformanceNavigationTiming.duration is 0 before load event");
+    assert_greater_than(responseEndDuringLoadEvent, 500, "PerformanceNavigationTiming.responseEnd is reasonable during load event");
+    assert_equals(durationDuringLoadEvent, 0, "PerformanceNavigationTiming.duration is 0 during load event");
+    assert_greater_than(responseEndAfterLoadEvent, 500, "PerformanceNavigationTiming.responseEnd is reasonable after load event");
+    assert_greater_than(durationAfterLoadEvent, 500, "PerformanceNavigationTiming.duration is reasonable after load event");
+  }));
+}, "Check that performance.getEntriesByType('navigation')[0].responseEnd has reasonable values before and after the load has finished");
+</script>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nav2-test-unique-nav-instances.html b/testing/web-platform/tests/navigation-timing/nav2-test-unique-nav-instances.html
new file mode 100644
index 0000000000..1d77ab6bae
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nav2-test-unique-nav-instances.html
@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that each window has a unique nav timing 2 instance.</p>
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="display:none;";></iframe>
+        <script>
+
+            var navTiming2Attributes = [
+                'connectEnd',
+                'connectStart',
+                'decodedBodySize',
+                'domComplete',
+                'domContentLoadedEventEnd',
+                'domContentLoadedEventStart',
+                'domInteractive',
+                'domainLookupEnd',
+                'domainLookupStart',
+                'duration',
+                'encodedBodySize',
+                'entryType',
+                'fetchStart',
+                'initiatorType',
+                'loadEventEnd',
+                'loadEventStart',
+                'name',
+                'redirectCount',
+                'redirectEnd',
+                'redirectStart',
+                'requestStart',
+                'responseEnd',
+                'responseStart',
+                'secureConnectionStart',
+                'transferSize',
+                'type',
+                'unloadEventEnd',
+                'unloadEventStart',
+                'workerStart'
+            ];
+
+            function not_same_instance(instance1, instance2, attributes) {
+                for (var i in attributes) {
+                    if (instance1[attributes[i]] != instance2[attributes[i]])
+                        return true;
+                }
+                return false;
+            }
+
+            async_test(function (t) {
+                var observer = new PerformanceObserver(
+                    t.step_func(function (entryList) {
+                        assert_equals(entryList.getEntriesByType("navigation").length, 1, "Only one nav timing instance exists.");
+                        assert_equals(document.getElementById("frameContext").contentWindow.performance.getEntriesByType("navigation").length, 1,
+                            "Only one nav timing instance exists.");
+                        var main_frame_instance = entryList.getEntriesByType("navigation")[0];
+                        var iframe_instance = document.getElementById("frameContext").contentWindow.performance.getEntriesByType("navigation")[0];
+                        assert_true(not_same_instance(main_frame_instance, iframe_instance, navTiming2Attributes),
+                            "Two nav timing instances are not the same instance.");
+                        observer.disconnect();
+                        t.done();
+                    })
+                );
+                observer.observe({entryTypes: ["navigation"]});
+
+            }, "Each window has a unique nav timing 2 instance.");
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/navigation-type-post-backforward.html b/testing/web-platform/tests/navigation-timing/navigation-type-post-backforward.html
new file mode 100644
index 0000000000..1fbdf1ae9b
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/navigation-type-post-backforward.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>Navigation Type Post Back Forward</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+</head>
+
+<body>
+  <script>
+    function execute_helper(fn, args) {
+      return new Promise(resolve => {
+        frame.addEventListener('load', () => {
+          resolve(frame);
+        }, { once: true });
+        fn.apply(null, args);
+      });
+    }
+
+    // Create an iframe.
+    function create_iframe(url) {
+      const frame = document.createElement('iframe');
+      frame.src = url;
+      return frame;
+    }
+
+    // Attach an iframe.
+    function attach_iframe(frame) {
+      document.body.appendChild(frame);
+    }
+
+    // Post by submit method.
+    function submit_form(frame) {
+      frame.contentWindow.document.getElementsByTagName("form")[0].submit();
+    }
+
+    // Navigate away by simulating a click on the link.
+    function navigate_away(frame) {
+      frame.contentWindow.document.getElementsByTagName("a")[0].click();
+    }
+
+    // Navigate back.
+    function navigate_back(frame) {
+      frame.contentWindow.history.back();
+    }
+
+    promise_test(async t => {
+      // Add an iframe and Load page in the iframe.
+      let url = 'resources/navigation-type-post-back.html';
+
+      frame = create_iframe(url);
+      await execute_helper(attach_iframe, [frame]);
+      await execute_helper(submit_form, [frame]);
+      await execute_helper(navigate_away, [frame]);
+      await execute_helper(navigate_back, [frame]);
+
+      assert_equals(frame.contentWindow.performance.getEntriesByType('navigation')[0].type,
+        'back_forward');
+    }, "Navigation type after posting and navigating away and back should be back_forward.");
+  </script>
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/nested-unload-timing.html b/testing/web-platform/tests/navigation-timing/nested-unload-timing.html
new file mode 100644
index 0000000000..1130fb6840
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/nested-unload-timing.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8" />
+    <meta name="timeout" content="long">
+    <title>Navigation Timing: unload event with nested contexts</title>
+    <link rel="help" href="https://w3c.github.io/navigation-timing/"/>
+    <script src="/common/utils.js"></script>
+    <script src="/common/dispatcher/dispatcher.js"></script>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+<script>
+
+    const dummyURL = () => `/navigation-timing/resources/blank_page_green.html?uid=${token()}`;
+
+    promise_test(async t => {
+        const mainWindowUnloadDuration = 100;
+        const iframeUnloadDuration = 400;
+        /*
+            We create 3 contexts: One for a popup window that will load a document and then later
+            unload it, one for an iframe inside that popup window, that will unload with the parent
+            document as well, and one for document the popup window will load in order to trigger
+            those previous unload events.
+
+            The iframe is going to busy-wait on unload for 400ms, and the unloading top-level
+            document is going to busy-wait on unload for 100ms.
+
+            We verify that the total unloadEvent duration measured at the final document is ~100 but
+            less than 500ms - does not include the unload event duration from the iframe.
+        */
+        const popupContext = new RemoteContext(token());
+        const iframeContext = new RemoteContext(token());
+        const finalContext = new RemoteContext(token());
+        const popup = window.open(remoteExecutorUrl(popupContext.context_id));
+        t.add_cleanup(() => popup.close());
+        const registerBusyWaitUnload = duration => window.addEventListener('unload', () => {
+            const buffer = 3;
+            const timeoutEnd = performance.now() + duration + buffer;
+            while (timeoutEnd > performance.now()) {}
+        });
+
+        await popupContext.execute_script(registerBusyWaitUnload, [mainWindowUnloadDuration]);
+
+        const unloadIframe = iframeContext.execute_script(registerBusyWaitUnload, [iframeUnloadDuration]);
+        const loadPopup = popupContext.execute_script(async iframeUid => {
+            const iframe = document.createElement('iframe');
+            iframe.src = `/common/dispatcher/remote-executor.html?uuid=${iframeUid}`;
+            document.body.appendChild(iframe);
+            await new Promise(resolve => iframe.addEventListener('load', resolve));
+        }, [iframeContext.context_id]);
+
+        await Promise.all([unloadIframe, loadPopup]);
+        await popupContext.execute_script((uid) => location.href = `/common/dispatcher/remote-executor.html?uuid=${uid}`, [finalContext.context_id]);
+        const navigationTimingEntry = await finalContext.execute_script(() => performance.getEntriesByType('navigation')[0].toJSON());
+        const unloadDuration = navigationTimingEntry.unloadEventEnd - navigationTimingEntry.unloadEventStart;
+        assert_greater_than_equal(unloadDuration, mainWindowUnloadDuration);
+        assert_less_than(unloadDuration, mainWindowUnloadDuration + iframeUnloadDuration);
+    });
+</script>
+</body>
diff --git a/testing/web-platform/tests/navigation-timing/po-navigation.html b/testing/web-platform/tests/navigation-timing/po-navigation.html
new file mode 100644
index 0000000000..a54fb2aff8
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/po-navigation.html
@@ -0,0 +1,29 @@
+<!DOCTYPE HTML>
+<meta charset=utf-8>
+<title>PerformanceObservers: navigation</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<h1>PerformanceObservers: navigation</h1>
+<p>
+Navigation will <a href="https://w3c.github.io/performance-timeline/#dfn-queue-a-performanceentry">queue a PerformanceEntry</a>.
+</p>
+<div id="log"></div>
+<script>
+  async_test(function (t) {
+    function checkEntry(pes) {
+      assert_equals(pes.length, 1, "Only one navigation timing entry");
+      assert_equals(pes[0].entryType, "navigation", "entryType is \"navigation\"");
+      assert_equals(pes[0].name, window.location.toString(), "name is the address of the document");
+    }
+    var observer = new PerformanceObserver(
+        t.step_func(function (entryList, obs) {
+          checkEntry(entryList.getEntries());
+          checkEntry(entryList.getEntriesByType("navigation"));
+          checkEntry(entryList.getEntriesByName(window.location.toString()));
+          observer.disconnect();
+          t.done();
+        })
+      );
+    observer.observe({entryTypes: ["navigation"]});
+  }, "navigation entry is observable");
+</script>
diff --git a/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-executor.html b/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-executor.html
new file mode 100644
index 0000000000..b791fd89b6
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-executor.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>Navigation Timing Transfert Size of Prefetched Page</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script src="/common/utils.js"></script>
+  <script src="/common/dispatcher/dispatcher.js"></script>
+</head>
+<!--
+  This test uses RemoteContext and Executor to execute JavaScript in another
+  page opened by this test page. This is because we need to simulate
+  navigating away from current page in this test. It will cause all Javascript
+  code on the test page to be lost if we do it in the test page. We can't do it
+  in an iframe because currently the prefetch behaves differently in an iframe
+  in this particular test case. For detailed information about RemoteContext and
+  Executor, see /common/dispatcher/README.md.
+-->
+<body>
+  <script>
+    const addLink = (url) => {
+      return new Promise(resolve => {
+        const link = document.createElement('link');
+        link.onload = function () { resolve(); };
+        link.rel = 'prefetch';
+        link.as = 'document';
+        link.href = url;
+        document.body.appendChild(link);
+      });
+    }
+
+    const navigateToPrefetchedUrl = (url) => {
+      document.location.href = url;
+    }
+
+    const getTransferSize = () => window.performance.getEntriesByType('navigation')[0].transferSize;
+
+    promise_test(async t => {
+      const testPage = new RemoteContext(token());
+
+      // Function remoteExecutorUrl is defined in /common/dispatcher/dispatcher.js
+      const url = remoteExecutorUrl(testPage.context_id);
+      const handler = window.open(url);
+      t.add_cleanup(() => handler.close());
+
+      const prefetchedPage = new RemoteContext(token());
+
+      const url_to_prefetch = '/navigation-timing/resources/blank_page_prefetch.html?uuid='
+        + prefetchedPage.context_id;
+
+      // Prefetch link.
+      await testPage.execute_script(addLink, [url_to_prefetch]);
+
+      // Navigate to the prefetched link.
+      await testPage.execute_script(navigateToPrefetchedUrl, [url_to_prefetch]);
+
+      // Get navigation timing transfer size.
+      const size = await prefetchedPage.execute_script(getTransferSize);
+
+      assert_equals(0, size);
+    }, "Navigation timing transfer size for a prefetched navigation should be 0.");
+  </script>
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-iframe.html b/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-iframe.html
new file mode 100644
index 0000000000..316f78b955
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/prefetch-transfer-size-iframe.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>Navigation Timing Transfert Size of Prefetched Page</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script src="/common/utils.js"></script>
+  <script src="/common/dispatcher/dispatcher.js"></script>
+</head>
+
+<body>
+  <script>
+    function add_iframe(url) {
+      return new Promise(resolve => {
+        const frame = document.createElement('iframe');
+        frame.src = url;
+        frame.addEventListener('load', () => {
+          resolve(frame);
+        }, { once: true });
+        document.body.appendChild(frame);
+      });
+    };
+
+    promise_test(async t => {
+      // Add an iframe
+      let iframe_url = 'resources/iframe-prefetch-transfer-size.html';
+      frame = await add_iframe(iframe_url)
+
+      // Prefetch a url as link element.
+      await frame.contentWindow.addLink();
+
+      // navigate to the prefetched url.
+      await new Promise(resolve => {
+        frame.addEventListener('load', () => {
+          resolve();
+        }, { once: true });
+        frame.contentWindow.navigateToPrefetchedUrl();
+      });
+
+      // Verify navigation timing transfer size is 0.;
+      let transferSize =
+        frame.contentWindow.performance.getEntriesByType('navigation')[0].transferSize;
+
+      assert_equals(transferSize, 0);
+
+    }, "Navigation timing transfer size for a prefetched navigation should be 0.");
+  </script>
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-green-with-onunload.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-green-with-onunload.html
new file mode 100644
index 0000000000..2f401747b0
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-green-with-onunload.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+        <title>Green Test Page</title>
+    </head>
+    <!-- use onunload to ensure this does not trigger bfcache -->
+    <body style="background-color:#00FF00;" onunload="1;">
+        <h1>Placeholder</h1>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-green.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-green.html
new file mode 100644
index 0000000000..b8a1947b77
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-green.html
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+        <title>Green Test Page</title>
+    </head>
+    <body style="background-color:#00FF00;">
+        <h1>Placeholder</h1>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-meta-redirect.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-meta-redirect.html
new file mode 100644
index 0000000000..4b4bda096c
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-meta-redirect.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+        <meta http-equiv="refresh" content="1;URL='blank-page-green.html'" />
+        <title>Redirect Placeholder</title>
+    </head>
+    <body style="background-color:#FFFF00";>
+        <h1>Placeholder</h1>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-unload.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-unload.html
new file mode 100644
index 0000000000..bb2a27f168
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-unload.html
@@ -0,0 +1,25 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+
+        <title>Yellow Test Page</title>
+
+        <script type="text/javascript">
+            function onbeforeunload_handler()
+            {
+                var temp = "onbeforeunload";
+            }
+
+            function onunload_handler()
+            {
+                var temp = "onunload";
+            }
+        </script>
+    </head>
+    <body onbeforeunload="onbeforeunload_handler();"
+          onunload="onunload_handler();"
+          style="background-color:#FFFF00;">
+        <h1>Unload</h1>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow-with-onunload.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow-with-onunload.html
new file mode 100644
index 0000000000..771e0701d9
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow-with-onunload.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+        <title>Yellow Test Page</title>
+    </head>
+    <!-- use onunload to ensure this does not trigger bfcache -->
+    <body style="background-color:#FFFF00;" onunload="1;">
+        <h1>Placeholder</h1>
+    </body>
+</html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow.html b/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow.html
new file mode 100644
index 0000000000..4e5e1a000c
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank-page-yellow.html
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+        <title>Yellow Test Page</title>
+    </head>
+    <body style="background-color:#FFFF00;">
+        <h1>Placeholder</h1>
+    </body>
+</html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html b/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html
new file mode 100644
index 0000000000..1112ca28ec
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html
@@ -0,0 +1,27 @@
+<!DOCTYPE HTML>
+<html>
+
+<head>
+  <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+  <title>Page to be Prefetched</title>
+  <script src="/common/dispatcher/dispatcher.js"></script>
+</head>
+
+<body>
+  <script>
+    const pageshowPromise = new Promise(resolve => {
+      window.addEventListener('pageshow', resolve, { once: true });
+    });
+
+    async function getTransferSize() {
+      await pageshowPromise;
+      return window.performance.getEntriesByType('navigation')[0].transferSize;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const uuid = params.get("uuid");
+    const executor = new Executor(uuid);
+  </script>
+
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html.headers b/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html.headers
new file mode 100644
index 0000000000..771aba7f94
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/blank_page_prefetch.html.headers
@@ -0,0 +1 @@
+Cache-Control: max-age=300
diff --git a/testing/web-platform/tests/navigation-timing/resources/iframe-prefetch-transfer-size.html b/testing/web-platform/tests/navigation-timing/resources/iframe-prefetch-transfer-size.html
new file mode 100644
index 0000000000..fde01775b7
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/iframe-prefetch-transfer-size.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8" />
+  <title>Iframe Transfer Size Prefetch</title>
+</head>
+
+<body>
+  <p>Placeholder</p>
+  <script>
+    const urlToPrefetch = 'blank_page_prefetch.html';
+
+    function addLink() {
+      return new Promise(resolve => {
+        const link = document.createElement('link');
+        link.onload = function () { resolve(); };
+        link.rel = 'prefetch';
+        link.as = 'document';
+        link.href = urlToPrefetch;
+        document.body.appendChild(link);
+      });
+    };
+
+    function navigateToPrefetchedUrl() {
+      document.location.href = urlToPrefetch;
+    }
+  </script>
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/navigation-type-post-back.html b/testing/web-platform/tests/navigation-timing/resources/navigation-type-post-back.html
new file mode 100644
index 0000000000..8c19a2f5a5
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/navigation-type-post-back.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+  <form action="navigation_type_post_back.py" method="post">
+    Post to page <button type="submit">Press to POST page</button>
+  </form>
+</body>
+
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/navigation_type_post_back.py b/testing/web-platform/tests/navigation-timing/resources/navigation_type_post_back.py
new file mode 100644
index 0000000000..9da06f4f03
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/navigation_type_post_back.py
@@ -0,0 +1,12 @@
+# Accoridng to routes.py in the wpt server implementation, POST method is
+# handled by a Python script handler which requires this file to return an html.
+def main(request, response):
+    content = """
+    <!DOCTYPE html>
+      <html>
+        <body>
+            <a href="blank_page_green.html">navigate away</a>.
+        </body>
+      </html>
+    """
+    return content
diff --git a/testing/web-platform/tests/navigation-timing/resources/performance-attribute-sender.html b/testing/web-platform/tests/navigation-timing/resources/performance-attribute-sender.html
new file mode 100644
index 0000000000..99f544690d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/performance-attribute-sender.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+<script>
+parent.postMessage([
+  performance.timing.connectStart,
+  performance.timing.navigationStart,
+  performance.timing.secureConnectionStart,
+  performance.timing.connectEnd
+], '*');
+</script>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/resources/respond-slowly.py b/testing/web-platform/tests/navigation-timing/resources/respond-slowly.py
new file mode 100644
index 0000000000..e58e16f1f0
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/respond-slowly.py
@@ -0,0 +1,29 @@
+import time
+
+
+def main(request, response):
+    head = b"""<script>
+    let navigationTiming = performance.getEntriesByType('navigation')[0];
+    let originalResponseEnd = navigationTiming.responseEnd;
+    let originalDuration = navigationTiming.duration;
+    function checkResponseEnd() {
+        let responseEndDuringLoadEvent = navigationTiming.responseEnd;
+        let durationDuringLoadEvent = navigationTiming.duration;
+        setTimeout(function() {
+            parent.postMessage([
+                originalResponseEnd,
+                originalDuration,
+                responseEndDuringLoadEvent,
+                durationDuringLoadEvent,
+                navigationTiming.responseEnd,
+                navigationTiming.duration], '*');
+        }, 0);
+    }
+    </script><body onload='checkResponseEnd()'>"""
+    response.headers.set(b"Content-Length", str(len(head) + 1000))
+    response.headers.set(b"Content-Type", b"text/html")
+    response.write_status_headers()
+    response.writer.write_content(head)
+    for i in range(100):
+        response.writer.write_content(b"1234567890")
+        time.sleep(0.01)
diff --git a/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html b/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html
new file mode 100644
index 0000000000..e40b00bedb
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html
@@ -0,0 +1,8 @@
+<!doctype html>
+<script>
+  window.addEventListener("message", e => {
+    window.top.postMessage(e.data, "*");
+  });
+</script>
+<iframe src="secure-connection-test.html">
+
diff --git a/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html.headers b/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html.headers
new file mode 100644
index 0000000000..b70fbaf3b0
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/secure-connection-interim.html.headers
@@ -0,0 +1,3 @@
+Connection: Keep-Alive
+Content-Length: 170
+
diff --git a/testing/web-platform/tests/navigation-timing/resources/secure-connection-test.html b/testing/web-platform/tests/navigation-timing/resources/secure-connection-test.html
new file mode 100644
index 0000000000..63a80e062b
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/secure-connection-test.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<script>
+const entries =  performance.getEntriesByType("navigation");
+if (!entries) {
+  window.top.postMessage("FAIL - not supported", "*");
+}
+const entry = entries[0];
+if (entry.secureConnectionStart != entry.fetchStart) {
+  window.top.postMessage("FAIL - unexpected secureConnectionStart value of " +
+    entry.secureConnectionStart + " does not equal " + entry.fetchStart, "*");
+}
+window.top.postMessage("PASS", "*");
+</script>
diff --git a/testing/web-platform/tests/navigation-timing/resources/webperftestharness.js b/testing/web-platform/tests/navigation-timing/resources/webperftestharness.js
new file mode 100644
index 0000000000..afe09530d7
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/resources/webperftestharness.js
@@ -0,0 +1,113 @@
+//
+// Helper functions for Navigation Timing tests
+//
+
+var timingAttributes = [
+    'connectEnd',
+    'connectStart',
+    'domComplete',
+    'domContentLoadedEventEnd',
+    'domContentLoadedEventStart',
+    'domInteractive',
+    'domLoading',
+    'domainLookupEnd',
+    'domainLookupStart',
+    'fetchStart',
+    'loadEventEnd',
+    'loadEventStart',
+    'navigationStart',
+    'redirectEnd',
+    'redirectStart',
+    'requestStart',
+    'responseEnd',
+    'responseStart',
+    'unloadEventEnd',
+    'unloadEventStart'
+];
+
+function test_namespace(child_name, skip_root)
+{
+    if (skip_root === undefined) {
+        var msg = 'window.performance is defined';
+        wp_test(function () { assert_not_equals(performanceNamespace, undefined, msg); }, msg);
+    }
+
+    if (child_name !== undefined) {
+        var msg2 = 'window.performance.' + child_name + ' is defined';
+        wp_test(function() { assert_not_equals(performanceNamespace[child_name], undefined, msg2); }, msg2);
+    }
+}
+
+function test_attribute_exists(parent_name, attribute_name, properties)
+{
+    var msg = 'window.performance.' + parent_name + '.' + attribute_name + ' is defined.';
+    wp_test(function() { assert_not_equals(performanceNamespace[parent_name][attribute_name], undefined, msg); }, msg, properties);
+}
+
+function test_enum(parent_name, enum_name, value, properties)
+{
+    var msg = 'window.performance.' + parent_name + '.' + enum_name + ' is defined.';
+    wp_test(function() { assert_not_equals(performanceNamespace[parent_name][enum_name], undefined, msg); }, msg, properties);
+
+    msg = 'window.performance.' + parent_name + '.' + enum_name + ' = ' + value;
+    wp_test(function() { assert_equals(performanceNamespace[parent_name][enum_name], value, msg); }, msg, properties);
+}
+
+function test_timing_order(attribute_name, greater_than_attribute, properties)
+{
+    // ensure it's not 0 first
+    var msg = "window.performance.timing." + attribute_name + " > 0";
+    wp_test(function() { assert_true(performanceNamespace.timing[attribute_name] > 0, msg); }, msg, properties);
+
+    // ensure it's in the right order
+    msg = "window.performance.timing." + attribute_name + " >= window.performance.timing." + greater_than_attribute;
+    wp_test(function() { assert_true(performanceNamespace.timing[attribute_name] >= performanceNamespace.timing[greater_than_attribute], msg); }, msg, properties);
+
+    // ensure we have at least 5 microseconds difference or it's 0
+    msg = "window.performance.timing." + attribute_name + " difference with window.performance.timing." + greater_than_attribute + " is 0 or at least 5 microseconds";
+    var diff = performanceNamespace.timing[attribute_name] - performanceNamespace.timing[greater_than_attribute];
+    wp_test(function() { assert_true((diff === 0) || ((diff * 1000) >= 5), msg); }, msg, properties);
+}
+
+function test_timing_greater_than(attribute_name, greater_than, properties)
+{
+    var msg = "window.performance.timing." + attribute_name + " > " + greater_than;
+    test_greater_than(performanceNamespace.timing[attribute_name], greater_than, msg, properties);
+}
+
+function test_timing_equals(attribute_name, equals, msg, properties)
+{
+    var test_msg = msg || "window.performance.timing." + attribute_name + " == " + equals;
+    test_equals(performanceNamespace.timing[attribute_name], equals, test_msg, properties);
+}
+
+//
+// Non-test related helper functions
+//
+
+function sleep_milliseconds(n)
+{
+    var start = new Date().getTime();
+    while (true) {
+        if ((new Date().getTime() - start) >= n) break;
+    }
+}
+
+//
+// Common helper functions
+//
+
+function test_greater_than(value, greater_than, msg, properties)
+{
+    wp_test(function () { assert_true(value > greater_than, msg); }, msg, properties);
+}
+
+function test_greater_or_equals(value, greater_than, msg, properties)
+{
+    wp_test(function () { assert_true(value >= greater_than, msg); }, msg, properties);
+}
+
+function test_not_equals(value, notequals, msg, properties)
+{
+    wp_test(function() { assert_not_equals(value, notequals, msg); }, msg, properties);
+}
diff --git a/testing/web-platform/tests/navigation-timing/secure-connection-start-non-zero.https.html b/testing/web-platform/tests/navigation-timing/secure-connection-start-non-zero.https.html
new file mode 100644
index 0000000000..e95468ef91
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/secure-connection-start-non-zero.https.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8" />
+    <title>secureConnectionStart non-zero value test</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+    <h1>Description</h1>
+    <p>The tests that secureConnectionStart has a non-zero value.</p>
+<script>
+    window.onload = () => {
+        test(t => {
+            const entry = performance.getEntriesByType("navigation")[0];
+            assert_greater_than(entry.secureConnectionStart, 0, "secureConnectionStart is non-zero");
+        }, "Test that secureConnectionStart is not zero");
+    };
+
+</script>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/secure-connection-start-reuse.https.html b/testing/web-platform/tests/navigation-timing/secure-connection-start-reuse.https.html
new file mode 100644
index 0000000000..f52a259ecd
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/secure-connection-start-reuse.https.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>Navigation Timing secureconnectionstart reuse</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+const t = async_test("Test that secureConnectionStart value is as expected when reused");
+window.addEventListener("message", t.step_func_done(e => {
+  assert_equals(e.data, "PASS");
+}));
+</script>
+<iframe src="resources/secure-connection-interim.html">
+
diff --git a/testing/web-platform/tests/navigation-timing/supported-navigation-type.window.js b/testing/web-platform/tests/navigation-timing/supported-navigation-type.window.js
new file mode 100644
index 0000000000..3239c7d29f
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/supported-navigation-type.window.js
@@ -0,0 +1,20 @@
+test(() => {
+  if (typeof PerformanceObserver.supportedEntryTypes === "undefined")
+    assert_unreached("supportedEntryTypes is not supported.");
+  assert_true(PerformanceObserver.supportedEntryTypes.includes("navigation"),
+    "There should be an entry 'navigation' in PerformanceObserver.supportedEntryTypes");
+}, "supportedEntryTypes contains 'navigation'.");
+
+if (typeof PerformanceObserver.supportedEntryTypes !== "undefined") {
+  const entryType = "navigation";
+  if (PerformanceObserver.supportedEntryTypes.includes(entryType)) {
+    promise_test(async() => {
+      await new Promise((resolve) => {
+        new PerformanceObserver(function (list, observer) {
+          observer.disconnect();
+          resolve();
+        }).observe({entryTypes: [entryType]});
+      })
+    }, `'${entryType}' entries should be observable.`)
+  }
+}
diff --git a/testing/web-platform/tests/navigation-timing/test-document-onload.html b/testing/web-platform/tests/navigation-timing/test-document-onload.html
new file mode 100644
index 0000000000..7cc18491d6
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-document-onload.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>window.performance.navigation attributes</title>
+        <link rel="author" title="Mozilla" href="https://www.mozilla.org/" />
+        <link rel="help" href="https://www.w3.org/TR/navigation-timing-2/#processing-model"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test checks that the transferSize, encodedBodySize and decodedBodySize attributes have correct values when checked in the onload handler</p>
+
+        <div id="log"></div>
+
+        <script>
+            async_test(function (t) {
+                document.addEventListener("DOMContentLoaded", t.step_func_done(() => {
+                    let entry = window.performance.getEntriesByType("navigation")[0];
+                    assert_greater_than(entry.transferSize, 1000, "descr");
+                    assert_greater_than(entry.encodedBodySize, 1000, "descr");
+                    assert_greater_than(entry.decodedBodySize, 1000, "descr");
+                }));
+            }, "Test that the attributes have a proper value during DOMContentLoaded");
+
+            async_test(function (t) {
+                window.addEventListener("load", t.step_func_done(() => {
+                    let entry = window.performance.getEntriesByType("navigation")[0];
+                    assert_greater_than(entry.transferSize, 1000, "descr");
+                    assert_greater_than(entry.encodedBodySize, 1000, "descr");
+                    assert_greater_than(entry.decodedBodySize, 1000, "descr");
+                    async_test(function (t) {
+                        setTimeout(t.step_func_done(() => {
+                          let entry = window.performance.getEntriesByType("navigation")[0];
+                          assert_greater_than(entry.transferSize, 1000, "descr");
+                          assert_greater_than(entry.encodedBodySize, 1000, "descr");
+                          assert_greater_than(entry.decodedBodySize, 1000, "descr");
+                        }), 0);
+                    }, "Test that the attributes have a proper value during a task after onload");
+                }));
+            }, "Test that the attributes have a proper value during onload");
+
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-document-open.html b/testing/web-platform/tests/navigation-timing/test-document-open.html
new file mode 100644
index 0000000000..1986b3fb98
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-document-open.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>window.performance.timing for dynamically created documents</title>
+<link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+<link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/performance-timeline-utils.js"></script>
+<script src="resources/webperftestharness.js"></script>
+<script>
+setup({explicit_done: true});
+
+// explicitly test the namespace before we start testing
+test_namespace();
+
+var originalTiming = {};
+var didOpen = false;
+
+function onload_test() {
+  if (!didOpen) {
+    step_timeout(testTimingWithDocumentOpen, 0);
+    didOpen = true;
+  }
+}
+
+function testTimingWithDocumentOpen() {
+  var subcontentWindow = document.getElementById("frameContext").contentWindow;
+
+  if (subcontentWindow.performance === undefined)
+  {
+    // avoid script errors
+    done();
+    return;
+  }
+
+  var timing = subcontentWindow.performance.timing;
+  for (i in timingAttributes) {
+    originalTiming[timingAttributes[i]] = timing[timingAttributes[i]];
+  }
+
+  var subdocument = subcontentWindow.document;
+  subdocument.open();
+  subdocument.write('<!DOCTYPE HTML>');
+  subdocument.write('<html>');
+  subdocument.write('<head>');
+  subdocument.write('<meta charset="utf-8" />');
+  subdocument.write('<title><Green Test Page</title>');
+  subdocument.write('</head>');
+  subdocument.write('<body style="background-color:#00FF00;">');
+  subdocument.write('</body>');
+  subdocument.write('</html>');
+  subdocument.close();
+
+  step_timeout(function() {
+    var timing = subcontentWindow.performance.timing;
+    for (var i in timingAttributes) {
+      test_equals(timing[timingAttributes[i]],
+                  originalTiming[timingAttributes[i]],
+                  timingAttributes[i] + " is the same after document open.");
+    }
+    done();
+  }, 0);
+}
+</script>
+</head>
+<body>
+<h1>Description</h1>
+<p>This test validates window.performance.timing remains constant when a
+document is replaced using document.open.</p>
+
+<p>This page should be loaded with a yellow frame below. It then replaces the
+document in that frame with a green document.</p>
+
+<p>The test passes if all of the checks to performance.timing are correct and
+the frame below ends with a green background.</p>
+
+<div id="log"></div>
+<br />
+<iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow.html" style="width: 250px; height: 250px;"></iframe>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-document-readiness-exist.html b/testing/web-platform/tests/navigation-timing/test-document-readiness-exist.html
new file mode 100644
index 0000000000..58f5659a09
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-document-readiness-exist.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8" />
+    <title>document.readyState values exist during a navigation</title>
+    <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+    <link rel="help" href="http://www.w3.org/TR/html5/dom.html#resource-metadata-management"/>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script>
+        setup({ explicit_done: true });
+        var has_loading = (document.readyState == "loading");
+        var has_interactive = (document.readyState == "interactive");
+        var has_complete = (document.readyState == "complete");
+
+        document.onreadystatechange = function()
+        {
+            if (document.readyState == "loading")
+            {
+                has_loading = true;
+            }
+            if (document.readyState == "interactive")
+            {
+                has_interactive = true;
+            }
+            if (document.readyState = "complete")
+            {
+                has_complete = true;
+            }
+        };
+
+        function onload_test()
+        {
+            test(function () { assert_true(has_loading); }, "Document readiness has loading state.");
+            test(function () { assert_true(has_interactive); }, "Document readiness has interactive state.");
+            test(function () { assert_true(has_complete); }, "Document readiness has complete state.");
+            done();
+        }
+    </script>
+
+</head>
+<body onload="onload_test();">
+    <h1>Description</h1>
+    <p>This test validates that the "loading", "interactive" and "complete"
+       document.readyState states are available during a navigation.</p>
+    <p>Refresh this page to guarantee all readyState phases.</p>
+    <div id="log"></div>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigate-within-document.html b/testing/web-platform/tests/navigation-timing/test-navigate-within-document.html
new file mode 100644
index 0000000000..e17020b7bb
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigate-within-document.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" >
+        <title>window.performance.timing in document navigation</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that all of the window.performance.timing attributes remain unchanged after an in document navigation (URL fragment change).</p>
+
+        <div id="log"></div>
+        <script>
+            setup({explicit_done: true});
+
+            // explicitly test the namespace before we start testing
+            test_namespace('timing');
+
+            var timing;
+
+            function check_timing_not_changed()
+            {
+                for (var i = 0; i < timingAttributes.length; ++i)
+                {
+                    var property = timingAttributes[i];
+                    test_equals(timing[property], initial_timing[property],
+                                property + " is the same after in document navigation.");
+                }
+                done();
+            }
+
+            var initial_timing = {};
+            function save_timing_after_load()
+            {
+                for (var i = 0; i < timingAttributes.length; ++i)
+                {
+                    var property = timingAttributes[i];
+                    initial_timing[property] = timing[property];
+                }
+                window.location.href = "#1";
+                step_timeout(check_timing_not_changed, 0);
+            }
+
+            function load_handler()
+            {
+                if (performanceNamespace === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                timing = performanceNamespace.timing;
+
+                window.removeEventListener("load", load_handler);
+                step_timeout(save_timing_after_load, 0);
+            }
+
+            window.addEventListener("load", load_handler, false);
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigation-attributes-exist.html b/testing/web-platform/tests/navigation-timing/test-navigation-attributes-exist.html
new file mode 100644
index 0000000000..845523d1a2
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigation-attributes-exist.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>window.performance.navigation attributes</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that all of the window.performance.navigation attributes exist (but does not validate that their values are correct).</p>
+
+        <div id="log"></div>
+
+        <script>
+        test_namespace('navigation');
+
+        test_attribute_exists('navigation', 'type');
+        test_attribute_exists('navigation', 'redirectCount');
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigation-redirectCount-none.html b/testing/web-platform/tests/navigation-timing/test-navigation-redirectCount-none.html
new file mode 100644
index 0000000000..da94d24c74
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigation-redirectCount-none.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.navigation.redirectCount on a non-redirected navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the value of the window.performance.navigation.redirectCount attribute, as well as the window.performance.timing.redirectStart and redirectEnd attributes on a non-redirected navigation.</p>
+
+        <div id="log"></div>
+
+        <script>
+        test_namespace('navigation');
+
+        if (performanceNamespace !== undefined)
+        {
+            test_equals(performanceNamespace.timing.redirectStart, 0, 'timing.redirectStart on an non-redirected navigation');
+            test_equals(performanceNamespace.timing.redirectEnd, 0, 'timing.redirectEnd on an non-redirected navigation');
+            test_equals(performanceNamespace.navigation.redirectCount, 0, 'navigation.redirectCount on an non-redirected navigation');
+        }
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigation-type-backforward.html b/testing/web-platform/tests/navigation-timing/test-navigation-type-backforward.html
new file mode 100644
index 0000000000..b5920953cb
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigation-type-backforward.html
@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.navigation.type for back and forward navigations</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            // explicitly test the namespace before we start testing
+            test_namespace('navigation');
+
+            function onload_test()
+            {
+                if (performanceNamespace === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                // do this with a timeout to see the visuals of the navigations.
+                step_timeout(nav_frame, 100);
+            }
+
+            var step = 1;
+            function nav_frame()
+            {
+                var navigation_frame = document.getElementById("frameContext").contentWindow;
+                switch (step)
+                {
+                    case 1:
+                    {
+                        navigation_frame.location.href = '/navigation-timing/resources/blank_page_green_with_onunload.html';
+                        step++;
+                        break;
+                    }
+                    case 2:
+                    {
+                        test_equals(navigation_frame.performance.navigation.type,
+                                performanceNamespace.navigation.TYPE_NAVIGATE,
+                                'window.performance.navigation.type == TYPE_NAVIGATE');
+                        navigation_frame.history.back();
+                        step++;
+                        break;
+                    }
+                    case 3:
+                    {
+                        test_equals(navigation_frame.performance.navigation.type,
+                                performanceNamespace.navigation.TYPE_BACK_FORWARD,
+                                'window.performance.navigation.type == TYPE_BACK_FORWARD after history.back()');
+                        step++;
+                        navigation_frame.history.forward();
+                        break;
+                    }
+                    case 4:
+                    {
+                        test_equals(navigation_frame.performance.navigation.type,
+                                performanceNamespace.navigation.TYPE_BACK_FORWARD,
+                                'window.performance.navigation.type == TYPE_BACK_FORWARD after history.forward()');
+                        done();
+                        step++;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>
+            Description</h1>
+        <p>
+            This test validates the value of window.performance.navigation.type with a forward
+            and back navigation.</p>
+
+        <p>This page should be loaded with a yellow background frame below.  It should turn green for a starting
+            navigation, back to yellow for a back navigation and then back to green again for a forward navigation.</p>
+
+        <p>Along the navigation timeline the frame.window.performance.type is checked for TYPE_BACK_FORWARD.</p>
+
+        <p>This test passes if all of the checks to the navigation.type are correct throughout the navigation
+            scenario and the frame below ends with a green background.  Otherwise, this test fails.</p>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext" onload="onload_test();" src="resources/blank_page_yellow_with_onunload.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigation-type-enums.html b/testing/web-platform/tests/navigation-timing/test-navigation-type-enums.html
new file mode 100644
index 0000000000..ecf6ddc89d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigation-type-enums.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.navigation enums</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+   </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the TYPE_* enumerations of window.performance.navigation exist and their values are correct.</p>
+
+        <div id="log"></div>
+
+        <script>
+        test_namespace('navigation');
+
+        test_enum('navigation', 'TYPE_NAVIGATE', 0);
+        test_enum('navigation', 'TYPE_RELOAD', 1);
+        test_enum('navigation', 'TYPE_BACK_FORWARD', 2);
+        test_enum('navigation', 'TYPE_RESERVED', 255);
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-navigation-type-reload.html b/testing/web-platform/tests/navigation-timing/test-navigation-type-reload.html
new file mode 100644
index 0000000000..d3331b8197
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-navigation-type-reload.html
@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.navigation.type with a reloaded navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            // explicitly test the namespace before we start testing
+            test_namespace('navigation');
+            var reload_frame;
+            var startingTime;
+
+            function deepCopy(p, c)
+            {
+                var c = c || {};
+                for (var i in p)
+                {
+                    if (typeof p[i] === 'object')
+                    {
+                        c[i] = (p[i].constructor === Array) ? [] : {};
+                        deepCopy(p[i], c[i]);
+                    } else c[i] = p[i];
+                }
+                return c;
+            }
+
+
+            function onload_test()
+            {
+                reload_frame = document.getElementById("frameContext");
+                reload_frame.onload = function() {
+                    /* Need to make sure we don't examine loadEventEnd
+                     until after the load event has finished firing */
+                    step_timeout(do_test, 0);
+                }
+                step_timeout(reload_the_frame, 100);
+            }
+
+            function reload_the_frame()
+            {
+                //Before reloading, save the current timing
+                startingTime = deepCopy(reload_frame.contentWindow.performance.timing);
+                reload_frame.contentWindow.location.reload(true);
+            }
+
+            function do_test()
+            {
+                reload_frame.onload = null;
+                if (performanceNamespace)
+                {
+                    //Verify that the navigation type has updated to reload
+                    test_equals(reload_frame.contentWindow.performance.navigation.type,
+                            performanceNamespace.navigation.TYPE_RELOAD,
+                            'window.performance.navigation.type == TYPE_RELOAD');
+
+                    //Verify that the timing data has been updated into the future
+                    var reloadTime = reload_frame.contentWindow.performance.timing;
+                    for (attribute in timingAttributes)
+                    {
+                        var time = timingAttributes[attribute];
+                        if (reloadTime[time] === 0)
+                        {
+                            test_equals(reloadTime[time],
+                                        startingTime[time],
+                                        "Reload " + time + "(" + reloadTime[time] + ")" +
+                                        " == " +
+                                        "Original " + time + "(" + startingTime[time] + ")");
+                        }
+                        else
+                        {
+                            test_greater_than(reloadTime[time],
+                                              startingTime[time],
+                                              "Reload " + time +
+                                              " > " +
+                                              "Original " + time);
+                        }
+                    }
+                }
+
+                done();
+            }
+        </script>
+    </head>
+    <body onload="onload_test();">
+        <h1>Description</h1>
+        <p>This test validates the value of window.performance.navigation.type and the values of
+            window.performance.timing.* with a reloaded navigation.</p>
+
+        <p>This page should be loaded with a green background frame below.  The frame will be automatically reloaded
+        and then verified that
+        <ul>
+            <li>The window.performance.navigation.type = TYPE_RELOAD</li>
+            <li>All of the widow.performance.timing.* values after reload are > all of the window.performance.timing.* values
+                prior to reload.</li>
+        </ul>
+        </p>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-no-previous-document.html b/testing/web-platform/tests/navigation-timing/test-no-previous-document.html
new file mode 100644
index 0000000000..0bce16525c
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-no-previous-document.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing attributes on an initial navigation</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+
+        <script>
+            setup({explicit_done: true});
+
+            var frame;
+            function onload_test()
+            {
+                frame = document.getElementById("frameContext");
+                test_namespace('navigation');
+                if (performanceNamespace)
+                {
+                    test_true(frame.contentWindow.performance.navigation.type == performanceNamespace.navigation.TYPE_NAVIGATE,
+                              'timing.navigation.type is TYPE_NAVIGATE');
+
+                    test_equals(frame.contentWindow.performance.timing.unloadEventStart, 0, 'timing.unloadEventStart == 0 on navigation with no previous document');
+                    test_equals(frame.contentWindow.performance.timing.unloadEventEnd, 0, 'timing.unloadEventEnd == 0 navigation with no previous document');
+                }
+                done();
+            }
+        </script>
+
+    </head>
+    <body onload="onload_test();">
+        <h1>Description</h1>
+        <p>This test validates the unload event times are 0 when there is no previous document.</p>
+
+        <div id="log"></div><br />
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist-in-object.html b/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist-in-object.html
new file mode 100644
index 0000000000..25fa6b782e
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist-in-object.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance attribute exists in an object</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-window.performance-attribute"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+          function onload_test() {
+            var objWindow =
+                document.getElementById("objectContext").contentDocument.defaultView;
+            performanceNamespace = objWindow.performance;
+            test_namespace('timing');
+            test_namespace('navigation', true);
+          }
+        </script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the window.performance object exists in an
+        object element (but does not validate that their values are correct).</p>
+        <object id="objectContext" onload="onload_test();" data="resources/blank-page-green.html"></object>
+        <div id="log"></div>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist.html b/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist.html
new file mode 100644
index 0000000000..ca3a6be5aa
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-performance-attributes-exist.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance attributes</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-window.performance-attribute"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the navigation and timing attributes exist for window.performance
+        (but does not validate that their values are correct).</p>
+        <div id="log"></div>
+        <script>
+            test_namespace('navigation');
+            test_namespace('timing', true);
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-performance-attributes.sub.html b/testing/web-platform/tests/navigation-timing/test-performance-attributes.sub.html
new file mode 100644
index 0000000000..50d027e80c
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-performance-attributes.sub.html
@@ -0,0 +1,29 @@
+<!DOCTYPE HTML>
+<html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<!-- Use https to ensure secureConnectionStart is nontrivial, if it is supported. -->
+<iframe src="https://{{host}}:{{ports[https][0]}}/navigation-timing/resources/performance-attribute-sender.html"></iframe>
+<body>
+<script>
+async_test(function(t) {
+  window.addEventListener('message', t.step_func_done(function(event) {
+    const connectStart = event.data[0];
+    const navigationStart = event.data[1];
+    const secureConnectionStart = event.data[2];
+    const connectEnd = event.data[3];
+    assert_greater_than_equal(connectStart, navigationStart,
+      'performance.timing.connectStart >= performance.timing.navigationStart');
+    // secureConnectionStart is an optional attribute.
+    if (secureConnectionStart == undefined) {
+      return;
+    }
+    assert_greater_than_equal(secureConnectionStart, connectStart,
+      'performance.timing.secureConnectionStart >= performance.timing.connectStart');
+    assert_greater_than_equal(connectEnd, secureConnectionStart,
+      'performance.timing.connectEnd >= performance.timing.secureConnectionStart');
+  }));
+}, 'Check that performance.timing has reasonable values for secureConnectionStart and other attributes');
+</script>
+</body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-readwrite.html b/testing/web-platform/tests/navigation-timing/test-readwrite.html
new file mode 100644
index 0000000000..a078329dd4
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-readwrite.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance is read/write</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-window.performance-attribute"/>
+        <meta name="assert" content="The window.performance attribute provides a hosting area for performance related attributes. "/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that the window.performance object is read/write.</p>
+        <div id="log"></div>
+        <script>
+            test_namespace();
+
+            window.performance = 'foo';
+            test_equals(window.performance, 'foo', 'window.performance is read/write');
+
+            var performance = 'bar';
+            test_equals(performance, 'bar', 'var performance is read/write');
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-attributes-exist.html b/testing/web-platform/tests/navigation-timing/test-timing-attributes-exist.html
new file mode 100644
index 0000000000..5db07459b4
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-attributes-exist.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing attributes</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that all of the window.performance.timing attributes exist (but does not validate that their values are correct).</p>
+
+        <div id="log"></div>
+
+        <script>
+        test_namespace('timing');
+
+        for (var i = 0; i < timingAttributes.length; ++i)
+        {
+            test_attribute_exists('timing', timingAttributes[i]);
+        }
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-attributes-order.html b/testing/web-platform/tests/navigation-timing/test-timing-attributes-order.html
new file mode 100644
index 0000000000..5e885ea7ec
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-attributes-order.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing attribute ordering on a simple navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            test_namespace('timing');
+
+            var step = 1;
+            function onload_test()
+            {
+                if (step === 1 && window.performance === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                var navigation_frame = document.getElementById("frameContext").contentWindow;
+                performanceNamespace = navigation_frame.performance;
+                switch (step)
+                {
+                    case 1:
+                    {
+                        navigation_frame.location.href = '/navigation-timing/resources/blank_page_green.html';
+                        step++;
+                        break;
+                    }
+                case 2:
+                    {
+                        test_namespace('navigation', true);
+
+                        //
+                        // Tests
+                        //
+                        test_equals(performanceNamespace.navigation.type,
+                                performanceNamespace.navigation.TYPE_NAVIGATE,
+                                'window.performance.navigation.type == TYPE_NAVIGATE');
+
+                        // navigiation must be non-0
+                        test_timing_greater_than('navigationStart', 0);
+
+                        // must be no redirection for this test case
+                        test_timing_equals('redirectStart', 0);
+                        test_timing_equals('redirectEnd', 0);
+
+                        // validate attribute ordering
+                        test_timing_order('fetchStart', 'navigationStart');
+                        test_timing_order('domainLookupStart', 'fetchStart');
+                        test_timing_order('domainLookupEnd', 'domainLookupStart');
+                        test_timing_order('connectStart', 'domainLookupEnd');
+                        test_timing_order('connectEnd', 'connectStart');
+                        test_timing_order('requestStart', 'connectEnd');
+                        test_timing_order('responseStart', 'requestStart');
+                        test_timing_order('responseEnd', 'responseStart');
+                        test_timing_order('domLoading', 'fetchStart');
+                        test_timing_order('domInteractive', 'responseEnd');
+                        test_timing_order('domContentLoadedEventStart', 'domInteractive');
+                        test_timing_order('domContentLoadedEventEnd', 'domContentLoadedEventStart');
+                        test_timing_order('domComplete', 'domContentLoadedEventEnd');
+                        test_timing_order('loadEventStart', 'domContentLoadedEventEnd');
+                        test_timing_order('loadEventEnd', 'loadEventStart');
+
+                        // setup requires the frame to have a previous page with an onunload event handler.
+                        test_timing_order('unloadEventStart', 'navigationStart');
+                        test_timing_order('unloadEventEnd', 'unloadEventStart');
+
+                        step++;
+                        done();
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        </script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the ordering of the window.performance.timing attributes.</p>
+
+        <p>This page should be loaded with a yellow background frame below which contains an unload event
+           handler.</p>
+
+        <p>After the page loads, the frame is navigated to a new blank page with a green background.  At this point, the navigation timeline is verified</p>
+
+        <p>This test passes if all of the checks to the frame.window.performance.timing attributes are
+           correct throughout the navigation scenario and the frame below ends with a green background.
+           Otherwise, this test fails.</p>
+
+        <h1>Setup</h1>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext"
+                onload="/* Need to make sure we don't examine loadEventEnd
+                           until after the load event has finished firing */
+                        step_timeout(onload_test, 0);"
+                src="resources/blank_page_unload.html"
+                style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-client-redirect.html b/testing/web-platform/tests/navigation-timing/test-timing-client-redirect.html
new file mode 100644
index 0000000000..c376f42bb7
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-client-redirect.html
@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing.redirect attributes on a client redirect navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            test_namespace('navigation');
+            test_namespace('timing', true);
+
+            var redirect_frame;
+            function onload_test()
+            {
+                if (performanceNamespace === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                redirect_frame = document.getElementById("frameContext");
+                redirect_frame.onload = do_test;
+            }
+
+            function do_test()
+            {
+                redirect_frame.onload = "";
+                test_true(redirect_frame.contentWindow.performance.navigation.type == performanceNamespace.navigation.TYPE_NAVIGATE,
+                          'timing.navigation.type is TYPE_NAVIGATE');
+
+                test_equals(redirect_frame.contentWindow.performance.navigation.redirectCount, 0, 'navigation.redirectCount == 0 on an client redirected navigation');
+                test_equals(redirect_frame.contentWindow.performance.timing.redirectStart, 0, 'timing.redirectStart == 0 on an client redirected navigation');
+                test_equals(redirect_frame.contentWindow.performance.timing.redirectEnd, 0, 'timing.redirectEnd == 0 on an client redirected navigation');
+
+                done();
+            }
+        </script>
+
+    </head>
+    <body onload="onload_test();">
+        <h1>Description</h1>
+        <p>This test validates the values of the window.navigation.redirectCount and the
+           window.performance.timing.redirectStart/End times on a client side redirect.</p>
+
+        <div id="log"></div><br />
+        <iframe id="frameContext" src="resources/blank-page-meta-redirect.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-reload.html b/testing/web-platform/tests/navigation-timing/test-timing-reload.html
new file mode 100644
index 0000000000..a660caf4ef
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-reload.html
@@ -0,0 +1,92 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing attributes after a reloaded navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            // explicitly test the namespace before we start testing
+            test_namespace('navigation');
+
+            var reload_frame;
+            var initial_timing;
+
+            function onload_test()
+            {
+                reload_frame = document.getElementById("frameContext");
+
+                if (reload_frame.contentWindow.performance === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                reload_frame.onload = do_test;
+
+                // save frame's initial timings
+                initial_timing = {};
+                var timing = reload_frame.contentWindow.performance.timing;
+
+                for (var i = 0; i < timingAttributes.length; ++i)
+                {
+                    var property = timingAttributes[i];
+                    initial_timing[property] = timing[property];
+                }
+
+                step_timeout(reload_the_frame, 100);
+            }
+
+            function reload_the_frame()
+            {
+                reload_frame.contentWindow.location.reload(true);
+            }
+
+            function do_test()
+            {
+                reload_frame.onload = "";
+
+                // ensure the frame reloaded
+                test_equals(reload_frame.contentWindow.performance.navigation.type,
+                            performanceNamespace.navigation.TYPE_RELOAD,
+                            "window.performance.navigation.type == TYPE_RELOAD");
+
+                // ensure reload timings changed
+                var timing = reload_frame.contentWindow.performance.timing;
+                for (var i = 0; i < timingAttributes.length; ++i)
+                {
+                    var property = timingAttributes[i];
+
+                    // ignore any timings that were zero initially
+                    if (initial_timing[property] !== 0)
+                    {
+                        test_not_equals(timing[property], initial_timing[property],
+                                property + " is different after the reload.");
+                    }
+                }
+
+                done();
+            }
+        </script>
+    </head>
+    <body onload="onload_test();">
+        <h1>Description</h1>
+        <p>This test validates that the window.performance.timing attributes change when a page is reloaded.</p>
+
+        <p>This page should be loaded with a green background frame below.  The frame will be automatically reloaded
+        and then verified that the window.performance.timing attributes have been updated to the new reloaded navigation timings.</p>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-server-redirect.html b/testing/web-platform/tests/navigation-timing/test-timing-server-redirect.html
new file mode 100644
index 0000000000..16567e8997
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-server-redirect.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing.redirect attributes on a same-origin server redirected navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+
+        <script>
+            function onload_test()
+            {
+                test_namespace('navigation');
+                if (performanceNamespace === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                performanceNamespace = document.getElementById("frameContext").contentWindow.performance;
+                test_equals(performanceNamespace.navigation.type,
+                        performanceNamespace.navigation.TYPE_NAVIGATE,
+                        'timing.navigation.type is TYPE_NAVIGATE');
+                test_equals(performanceNamespace.navigation.redirectCount, 1, 'navigation.redirectCount == 1 on an server redirected navigation');
+
+                test_timing_greater_than('navigationStart', 0);
+
+                test_timing_order('redirectStart', 'navigationStart');
+                test_timing_order('redirectEnd', 'redirectStart');
+                test_timing_order('fetchStart', 'redirectEnd');
+                test_timing_order('requestStart', 'fetchStart');
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.redirectCount and the
+           window.performance.timing.redirectStart/End times for a same-origin server side redirect navigation.</p>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext" onload="onload_test();" src="/common/redirect.py?location=/navigation-timing/resources/blank_page_green.html" style="width: 250px; height: 250px;"></iframe>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-timing-xserver-redirect.html b/testing/web-platform/tests/navigation-timing/test-timing-xserver-redirect.html
new file mode 100644
index 0000000000..a39f7c2642
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-timing-xserver-redirect.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>window.performance.timing.redirect attributes on a cross-origin server redirected navigation</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface"/>
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-navigation-info-interface"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+        <script src="/common/utils.js"></script>
+        <script>
+            setup({explicit_done: true});
+
+            //
+            // Test configuration
+            //
+
+            var subdomain = "www";
+
+            //
+            // Tests
+            //
+            function onload_test()
+            {
+                test_namespace('navigation');
+                if (performanceNamespace === undefined)
+                {
+                    // avoid script errors
+                    done();
+                    return;
+                }
+
+                performanceNamespace = document.getElementById("frameContext").contentWindow.performance;
+                test_equals(performanceNamespace.navigation.type,
+                        performanceNamespace.navigation.TYPE_NAVIGATE,
+                        'timing.navigation.type is TYPE_NAVIGATE');
+                test_equals(performanceNamespace.navigation.redirectCount, 0, 'navigation.redirectCount == 0 on a cross-origin server redirected navigation');
+
+                test_timing_greater_than('navigationStart', 0);
+
+                test_equals(performanceNamespace.timing.redirectStart, 0, 'timing.redirectStart == 0 on a server redirected navigation from another domain');
+                test_equals(performanceNamespace.timing.redirectEnd, 0, 'timing.redirectEnd == 0 on a server redirected navigation from another domain');
+
+                done();
+            }
+        </script>
+
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates the values of the window.performance.redirectCount and the
+           window.performance.timing.redirectStart/End times for a cross-origin server side redirect navigation.</p>
+
+        <div id="log"></div>
+        <br />
+        <iframe id="frameContext" src="" style="width: 250px; height: 250px;"></iframe>
+        <script>
+            // combine the page origin and redirect origin into the IFRAME's src URL
+            var destUrl = make_absolute_url({subdomain: subdomain,
+                                             path: "/common/redirect.py",
+                                             query: "location=" + make_absolute_url(
+                                                         {path: "/navigation-timing/resources/blank_page_green.html"})
+                                             });
+            var frameContext = document.getElementById("frameContext");
+            frameContext.onload = onload_test;
+            frameContext.src = destUrl;
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/test-unique-performance-objects.html b/testing/web-platform/tests/navigation-timing/test-unique-performance-objects.html
new file mode 100644
index 0000000000..a8f7e6002d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/test-unique-performance-objects.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Each window object has a unique performance object</title>
+        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing/#sec-window.performance-attribute" />
+        <meta name="assert" content="Each browsing context must have a unique window.performance.timing attribute."/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/performance-timeline-utils.js"></script>
+        <script src="resources/webperftestharness.js"></script>
+    </head>
+    <body>
+        <h1>Description</h1>
+        <p>This test validates that each window has a unique window.performance object.</p>
+        <iframe id="frameContext" src="resources/blank_page_green.html" style="display:none;";></iframe>
+        <div id="log"></div>
+        <script>
+            test_namespace('timing');
+
+            if (performanceNamespace !== undefined)
+            {
+                test_not_equals(performanceNamespace.timing,
+                                document.getElementById("frameContext").contentWindow.performance.timing,
+                                "Different window objects have unique performance objects");
+            }
+        </script>
+    </body>
+</html>
diff --git a/testing/web-platform/tests/navigation-timing/unload-event-same-origin-check.html b/testing/web-platform/tests/navigation-timing/unload-event-same-origin-check.html
new file mode 100644
index 0000000000..319d04462d
--- /dev/null
+++ b/testing/web-platform/tests/navigation-timing/unload-event-same-origin-check.html
@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation Timing 2 WPT</title>
+        <link rel="author" title="Google" href="http://www.google.com/" />
+        <link rel="help" href="http://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming"/>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="/common/get-host-info.sub.js"></script>
+    </head>
+    <body>
+        <script>
+
+            const start_page = "/navigation-timing/resources/blank_page_green.html";
+            const end_page = "/navigation-timing/resources/blank_page_yellow.html";
+            const host_info = get_host_info();
+            const redirect_chain_partial_tao = () => {
+                let url = host_info["HTTP_REMOTE_ORIGIN"];
+                url += "/common/redirect.py";
+                url += "?location=";
+                url += host_info["HTTP_REMOTE_ORIGIN"];
+                url += "/common/redirect-opt-in.py";
+                url += "?location=";
+                url += host_info["ORIGIN"];
+                url += end_page;
+                return url;
+            };
+            const redirect_chain_full_tao = () => {
+                let url = host_info["HTTP_REMOTE_ORIGIN"];
+                url += "/common/redirect-opt-in.py";
+                url += "?location=";
+                url += host_info["ORIGIN"];
+                url += end_page;
+                return url;
+            };
+            const redirect_chain_no_tao = () => {
+                let url = host_info["HTTP_REMOTE_ORIGIN"];
+                url += "/common/redirect.py";
+                url += "?location=";
+                url += host_info["ORIGIN"];
+                url += end_page;
+                return url;
+            };
+            const same_origin_redirect_chain = () => {
+                let url = host_info["ORIGIN"];
+                url += "/common/redirect.py";
+                url += "?location=";
+                url += host_info["ORIGIN"];
+                url += end_page;
+                return url;
+            };
+            const cross_origin_start = host_info["HTTP_REMOTE_ORIGIN"] + start_page;
+            const test_cases = [
+                { start_url : start_page, end_url: redirect_chain_partial_tao(), unload_exposed: false, redirects: 0, name: "Redirect chain with a partial TAO opt-in" },
+                { start_url : start_page, end_url: redirect_chain_full_tao(), unload_exposed: false, redirects: 0, name: "Redirect chain with full TAO opt-in" },
+                { start_url : start_page, end_url: redirect_chain_no_tao(), unload_exposed: false, redirects: 0, name: "Same-cross-same redirect chain with no TAO opt-in" },
+                { start_url : cross_origin_start, end_url: redirect_chain_no_tao(), unload_exposed: false, redirects: 0, name: "cross-cross-same Redirect chain with no TAO opt-in" },
+                { start_url : cross_origin_start, end_url: end_page, unload_exposed: false, redirects: 0, name: "Previous document cross origin" },
+                { start_url : start_page, end_url: end_page, unload_exposed: true, redirects: 0, name: "Previous document same origin" },
+                { start_url : start_page, end_url: null, unload_exposed: false, redirects: 0, name: "No previous document" },
+                { start_url : start_page, end_url: same_origin_redirect_chain(), unload_exposed: true, redirects: 1, name: "Same origin previous document with same origin redirect" },
+                { start_url : same_origin_redirect_chain(), end_url: null, unload_exposed: false, redirects: 1, name: "No previous document with same origin redirect" },
+                { start_url : redirect_chain_no_tao(), end_url: null, unload_exposed: false, redirects: 0, name: "No previous document with cross origin redirect" },
+                { start_url : redirect_chain_full_tao(), end_url: null, unload_exposed: false, redirects: 0, name: "No previous document with cross origin redirect with partial TAO" },
+                { start_url : redirect_chain_partial_tao(), end_url: null, unload_exposed: false, redirects: 0, name: "No previous document with cross origin redirect with TAO" },
+            ];
+
+            const frame_id = "frameContext";
+            const create_frame = (start_url, end_url) => {
+                return new Promise(resolve => {
+                    let frame = document.getElementById("frameContext");
+                    if (frame) {
+                        document.body.removeChild(frame);
+                    }
+                    frame = document.createElement("iframe");
+                    frame.onload = () => {
+                        if (end_url) {
+                            frame.onload = resolve;
+                            step_timeout(() => {frame.contentWindow.location.href = end_url;}, 10);
+                        } else {
+                            resolve();
+                        }
+                    };
+                    frame.id = "frameContext";
+                    frame.src = start_url;
+                    document.body.appendChild(frame);
+                });
+            };
+
+            const run_test = (unload_exposed, redirects) => {
+                const entry = document.getElementById("frameContext").contentWindow.performance.getEntriesByType("navigation")[0];
+                assert_equals(entry.type, "navigate", "Expected navigation type to be navigate.");
+                if (!unload_exposed) {
+                    assert_equals(entry.unloadEventStart, 0, "Expected unloadEventStart to be 0.");
+                    assert_equals(entry.unloadEventEnd, 0, "Expected unloadEventEnd to be 0.");
+                } else {
+                    assert_greater_than(entry.unloadEventStart, 0, "Expected unloadEventStart to not be 0.");
+                    assert_greater_than(entry.unloadEventEnd, 0, "Expected unloadEventEnd to not be 0.");
+                }
+                assert_equals(entry.redirectCount, redirects, "Expected redirectCount to be " + redirects);
+            };
+
+            const create_test = async test_case => {
+                return new Promise(async (resolve, reject) => {
+                    await create_frame(test_case.start_url, test_case.end_url);
+                    try {
+                        run_test(test_case.unload_exposed, test_case.redirects);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            };
+
+            for (const test_case of test_cases) {
+                promise_test(() => { return create_test(test_case)}, test_case.name);
+            }
+
+
+        </script>
+        <h1>Description</h1>
+        <p>This test validates that the values of window.performance.getEntriesByType("navigation")[0].(type/unloadEventEnd/unloadEventStart) are only exposed when the same-origin test passes.</p>
+    </body>
+</html>
-- 
cgit v1.2.3