Update web-platform-tests to revision 9d5d9aa80785d9726ed0a5eaab1a8d144fd4b560

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/016-1.html

@@ -11,7 +11,7 @@ onload = function() {
 
   setTimeout(function() {
     parent.tests[0].step(function() {
-      parent.assert_equals(test_prop, 1, "Global scope from original window timeout");
+      parent.assert_equals(test_prop, 2, "Global scope from original window timeout");
       parent.assert_equals(window.test_prop, 2, "Window property from original window timeout")
     });
     parent.tests[1].step(function() {
@@ -23,7 +23,7 @@ onload = function() {
 
   window.setTimeout(function() {
     parent.tests[2].step(function() {
-      parent.assert_equals(test_prop, 1, "Global scope from original window timeout");
+      parent.assert_equals(test_prop, 2, "Global scope from original window timeout");
       parent.assert_equals(window.test_prop, 2, "Window property from original window timeout")
     });
     parent.tests[3].step(function() {

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/abort-refresh-immediate.window.js

@@ -0,0 +1,119 @@
+// The following tests deal with the <meta http-equiv=refresh> pragma and the
+// `Refresh` header. The spec is still hazy on the precise behavior in those
+// cases but we use https://github.com/whatwg/html/issues/4003 as a guideline.
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onabort = t.step_func_done();
+    client.send();
+
+    frame.contentDocument.open();
+  });
+  frame.src = "resources/meta-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through <meta> refresh with timeout 0 (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.unreached_func("Fetch should have been aborted"),
+      t.step_func_done());
+
+    frame.contentDocument.open();
+  });
+  frame.src = "resources/meta-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through <meta> refresh with timeout 0 (fetch())");
+
+// We cannot test for img element's error event for this test, as Firefox does
+// not fire the event if the fetch is aborted while Chrome does.
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.unreached_func("Image loading should not have succeeded");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentDocument.open();
+      happened = true;
+    });
+    // If 3 seconds have passed and the image has still not loaded, we consider
+    // it aborted. slow-png.py only sleeps for 2 wallclock seconds.
+    t.step_timeout(t.step_func_done(() => {
+      assert_true(happened);
+    }), 3000);
+  });
+  frame.src = "resources/meta-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through <meta> refresh with timeout 0 (image loading)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onabort = t.step_func_done();
+    client.send();
+
+    frame.contentDocument.open();
+  });
+  frame.src = "resources/http-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through Refresh header with timeout 0 (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.unreached_func("Fetch should have been aborted"),
+      t.step_func_done());
+
+    frame.contentDocument.open();
+  });
+  frame.src = "resources/http-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through Refresh header with timeout 0 (fetch())");
+
+// We cannot test for img element's error event for this test, as Firefox does
+// not fire the event if the fetch is aborted while Chrome does.
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.unreached_func("Image loading should not have succeeded");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentDocument.open();
+      happened = true;
+    });
+    // If 3 seconds have passed and the image has still not loaded, we consider
+    // it aborted. slow-png.py only sleeps for 2 wallclock seconds.
+    t.step_timeout(t.step_func_done(() => {
+      assert_true(happened);
+    }), 3000);
+  });
+  frame.src = "resources/http-refresh.py?0";
+}, "document.open() aborts documents that are queued for navigation through Refresh header with timeout 0 (image loading)");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/abort-refresh-multisecond-header.window.js

@@ -0,0 +1,69 @@
+// The following tests deal with the <meta http-equiv=refresh> pragma and the
+// `Refresh` header. The spec is still hazy on the precise behavior in those
+// cases but we use https://github.com/whatwg/html/issues/4003 as a guideline.
+//
+// This is separate from abort-refresh-multisecond-meta.window.js to avoid
+// browser interventions that limit the number of connections in a tab.
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onload = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    client.onerror = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.onabort = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.ontimeout = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.send();
+
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "resources/http-refresh.py?1";
+}, "document.open() does NOT abort documents that are queued for navigation through Refresh header with 1-sec timeout (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.step_func_done(() => {
+        assert_true(happened);
+      }),
+      t.unreached_func("Fetch should have succeeded")
+    );
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "resources/http-refresh.py?1";
+}, "document.open() does NOT abort documents that are queued for navigation through Refresh header with 1-sec timeout (fetch())");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    img.onerror = t.unreached_func("Image loading should not have errored");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentDocument.open();
+      happened = true;
+    });
+  });
+  frame.src = "resources/http-refresh.py?4";
+}, "document.open() does NOT abort documents that are queued for navigation through Refresh header with 4-sec timeout (image loading)");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/abort-refresh-multisecond-meta.window.js

@@ -0,0 +1,69 @@
+// The following tests deal with the <meta http-equiv=refresh> pragma and the
+// `Refresh` header. The spec is still hazy on the precise behavior in those
+// cases but we use https://github.com/whatwg/html/issues/4003 as a guideline.
+//
+// This is separate from abort-refresh-multisecond-header.window.js to avoid
+// browser interventions that limit the number of connections in a tab.
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onload = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    client.onerror = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.onabort = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.ontimeout = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.send();
+
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "resources/meta-refresh.py?1";
+}, "document.open() does NOT abort documents that are queued for navigation through <meta> refresh with 1-sec timeout (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.step_func_done(() => {
+        assert_true(happened);
+      }),
+      t.unreached_func("Fetch should have succeeded")
+    );
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "resources/meta-refresh.py?1";
+}, "document.open() does NOT abort documents that are queued for navigation through <meta> refresh with 1-sec timeout (fetch())");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    img.onerror = t.unreached_func("Image loading should not have errored");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentDocument.open();
+      happened = true;
+    });
+  });
+  frame.src = "resources/meta-refresh.py?4";
+}, "document.open() does NOT abort documents that are queued for navigation through <meta> refresh with 4-sec timeout (image loading)");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/abort-while-navigating.window.js

@@ -0,0 +1,179 @@
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    // The abort event handler is called synchronously in Chrome but
+    // asynchronously in Firefox. See https://crbug.com/879620.
+    client.onabort = t.step_func_done();
+    client.send();
+    frame.contentWindow.location.href = new URL("resources/dummy.html", document.URL);
+    frame.contentDocument.open();
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are navigating through Location (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.unreached_func("Fetch should have been aborted"),
+      t.step_func_done(() => {
+        assert_true(happened);
+      }));
+    frame.contentWindow.location.href = new URL("resources/dummy.html", document.URL);
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are navigating through Location (fetch())");
+
+// We cannot test for img element's error event for this test, as Firefox does
+// not fire the event if the fetch is aborted while Chrome does.
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.unreached_func("Image loading should not have succeeded");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentWindow.location.href = new URL("resources/dummy.html", document.URL);
+      frame.contentDocument.open();
+      happened = true;
+    });
+    // If 3 seconds have passed and the image has still not loaded, we consider
+    // it aborted. slow-png.py only sleeps for 2 wallclock seconds.
+    t.step_timeout(t.step_func_done(() => {
+      assert_true(happened);
+    }), 3000);
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are navigating through Location (image loading)");
+
+async_test(t => {
+  const div = document.body.appendChild(document.createElement("div"));
+  t.add_cleanup(() => div.remove());
+  div.innerHTML = "<iframe src='/common/slow.py'></iframe>";
+  const frame = div.childNodes[0];
+  const client = new frame.contentWindow.XMLHttpRequest();
+  client.open("GET", "/common/blank.html");
+  client.onabort = t.step_func_done();
+  client.send();
+  frame.contentDocument.open();
+}, "document.open() aborts documents that are navigating through iframe loading (XMLHttpRequest)");
+
+async_test(t => {
+  const div = document.body.appendChild(document.createElement("div"));
+  t.add_cleanup(() => div.remove());
+  div.innerHTML = "<iframe src='/common/slow.py'></iframe>";
+  const frame = div.childNodes[0];
+  frame.contentWindow.fetch("/common/blank.html").then(
+    t.unreached_func("Fetch should have been aborted"),
+    t.step_func_done());
+  frame.contentDocument.open();
+}, "document.open() aborts documents that are navigating through iframe loading (fetch())");
+
+// We cannot test for img element's error event for this test, as Firefox does
+// not fire the event if the fetch is aborted while Chrome does.
+//
+// We use /common/slow.py here as the source of the iframe, to prevent the
+// situation where when document.open() is called the initial about:blank
+// document has already become inactive.
+async_test(t => {
+  const div = document.body.appendChild(document.createElement("div"));
+  t.add_cleanup(() => div.remove());
+  div.innerHTML = "<iframe src='/common/slow.py'></iframe>";
+  const frame = div.childNodes[0];
+  let happened = false;
+  const img = frame.contentDocument.createElement("img");
+  img.src = new URL("resources/slow-png.py", document.URL);
+  img.onload = t.unreached_func("Image loading should not have succeeded");
+  // The image fetch starts in a microtask, so let's be sure to test after
+  // the fetch has started.
+  t.step_timeout(() => {
+    frame.contentDocument.open();
+    happened = true;
+  });
+  // If 3 seconds have passed and the image has still not loaded, we consider
+  // it aborted. slow-png.py only sleeps for 2 wallclock seconds.
+  t.step_timeout(t.step_func_done(() => {
+    assert_true(happened);
+  }), 3000);
+}, "document.open() aborts documents that are navigating through iframe loading (image loading)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    const link = frame.contentDocument.body.appendChild(frame.contentDocument.createElement("a"));
+    link.href = new URL("resources/dummy.html", document.URL);
+
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onabort = t.step_func_done();
+    client.send();
+
+    link.click();
+    frame.contentDocument.open();
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are queued for navigation through .click() (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    const link = frame.contentDocument.body.appendChild(frame.contentDocument.createElement("a"));
+    link.href = new URL("resources/dummy.html", document.URL);
+
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.unreached_func("Fetch should have been aborted"),
+      t.step_func_done());
+
+    link.click();
+    frame.contentDocument.open();
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are queued for navigation through .click() (fetch())");
+
+// We cannot test for img element's error event for this test, as Firefox does
+// not fire the event if the fetch is aborted while Chrome does.
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    const link = frame.contentDocument.body.appendChild(frame.contentDocument.createElement("a"));
+    link.href = new URL("resources/dummy.html", document.URL);
+
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.unreached_func("Image loading should not have succeeded");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      link.click();
+      frame.contentDocument.open();
+      happened = true;
+    });
+    // If 3 seconds have passed and the image has still not loaded, we consider
+    // it aborted. slow-png.py only sleeps for 2 wallclock seconds.
+    t.step_timeout(t.step_func_done(() => {
+      assert_true(happened);
+    }), 3000);
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() aborts documents that are queued for navigation through .click() (image loading)");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/abort.sub.window.js

@@ -0,0 +1,104 @@
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const client = new frame.contentWindow.XMLHttpRequest();
+    client.open("GET", "/common/blank.html");
+    client.onload = t.step_func_done(e => {
+      assert_true(happened);
+    });
+    client.onerror = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.onabort = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.ontimeout = t.unreached_func("XMLHttpRequest should have succeeded");
+    client.send();
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() does not abort documents that are not navigating (XMLHttpRequest)");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    frame.contentWindow.fetch("/common/blank.html").then(
+      t.step_func_done(() => {
+        assert_true(happened);
+      }),
+      t.unreached_func("Fetch should have succeeded")
+    );
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() does not abort documents that are not navigating (fetch())");
+
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const img = frame.contentDocument.createElement("img");
+    img.src = new URL("resources/slow-png.py", document.URL);
+    img.onload = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    img.onerror = t.unreached_func("Image loading should not have errored");
+    // The image fetch starts in a microtask, so let's be sure to test after
+    // the fetch has started.
+    t.step_timeout(() => {
+      frame.contentDocument.open();
+      happened = true;
+    });
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() does not abort documents that are not navigating (image loading)");
+
+async_test(t => {
+  const __SERVER__NAME = "{{host}}";
+  const __PORT = {{ports[ws][0]}};
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const ws = new frame.contentWindow.WebSocket(`ws://${__SERVER__NAME}:${__PORT}/echo`);
+    ws.onopen = t.step_func_done(() => {
+      assert_true(happened);
+    });
+    ws.onclose = t.unreached_func("WebSocket fetch should have succeeded");
+    ws.onerror = t.unreached_func("WebSocket should have no error");
+    frame.contentDocument.open();
+    happened = true;
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() does not abort documents that are not navigating (establish a WebSocket connection)");
+
+// An already established WebSocket connection shouldn't be terminated during
+// an "abort a document" anyway. Test just for completeness.
+async_test(t => {
+  const __SERVER__NAME = "{{host}}";
+  const __PORT = {{ports[ws][0]}};
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => frame.remove());
+  frame.onload = t.step_func(() => {
+    frame.onload = null;
+    let happened = false;
+    const ws = new frame.contentWindow.WebSocket(`ws://${__SERVER__NAME}:${__PORT}/echo`);
+    ws.onopen = t.step_func(() => {
+      t.step_timeout(t.step_func_done(() => {
+        assert_true(happened);
+      }), 100);
+      frame.contentDocument.open();
+      happened = true;
+    });
+    ws.onclose = t.unreached_func("WebSocket should not be closed");
+    ws.onerror = t.unreached_func("WebSocket should have no error");
+  });
+  frame.src = "/common/blank.html";
+}, "document.open() does not abort documents that are not navigating (already established WebSocket connection)");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/mutation-observer.window.js

@@ -0,0 +1,19 @@
+async_test(t => {
+  const frame = document.body.appendChild(document.createElement("iframe"));
+  t.add_cleanup(() => { frame.remove(); });
+  const originalHTMLElement = frame.contentDocument.documentElement;
+  assert_equals(originalHTMLElement.localName, "html");
+  const observer = new frame.contentWindow.MutationObserver(t.step_func_done(records => {
+    // Even though we passed `subtree: true` to observer.observe, due to the
+    // fact that "replace all" algorithm removes children with the "suppress
+    // observers flag" set, we still only get the html element as the sole
+    // removed node.
+    assert_equals(records.length, 1);
+    assert_equals(records[0].type, "childList");
+    assert_equals(records[0].target, frame.contentDocument);
+    assert_array_equals(records[0].addedNodes, []);
+    assert_array_equals(records[0].removedNodes, [originalHTMLElement]);
+  }));
+  observer.observe(frame.contentDocument, { childList: true, subtree: true });
+  assert_equals(frame.contentDocument.open(), frame.contentDocument);
+}, "document.open() should inform mutation observer of node removal");

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/reload.window.js

@@ -12,16 +12,16 @@
 // that restriction.
 //
 // In any case, this test as the caller of `document.open()` would be used both
-// as the test file and as part of the test file. The `if (!opener)` condition
-// controls what role this file plays.
+// as the test file and as part of the test file. The `if (window.name !==
+// "opened-dummy-window")` condition controls what role this file plays.
 
-if (!opener) {
+if (window.name !== "opened-dummy-window") {
   async_test(t => {
     const testURL = document.URL;
     const dummyURL = new URL("resources/dummy.html", document.URL).href;
 
     // 1. Open an auxiliary window.
-    const win = window.open("resources/dummy.html");
+    const win = window.open("resources/dummy.html", "opened-dummy-window");
     t.add_cleanup(() => { win.close(); });
 
     win.addEventListener("load", t.step_func(() => {

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/resources/http-refresh.py

@@ -0,0 +1,3 @@
+def main(request, response):
+    time = request.url_parts.query if request.url_parts.query else '0'
+    return 200, [['Refresh', time]], ''

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/resources/meta-refresh.py

@@ -0,0 +1,5 @@
+import time
+
+def main(request, response):
+    time = request.url_parts.query if request.url_parts.query else '0'
+    return 200, [['Content-Type', 'text/html']], '<meta http-equiv=refresh content=%s>' % time

tests/wpt/web-platform-tests/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/resources/slow-png.py

@@ -0,0 +1,8 @@
+from base64 import decodestring
+import time
+
+png_response = decodestring('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR4nGNiAAAABgADNjd8qAAAAABJRU5ErkJggg==')
+
+def main(request, response):
+    time.sleep(2)
+    return 200, [], png_response