Bug 1897564 - Add wpt test scenarios for BucketFS folder moves with open WritableFileStream. r=jesup,dom-storage-reviewers

Based on the discussions at whatwg/fs#59
and whatwg/fs#10
moves should overwrite unconditionally and the developers should use
WebLocks if this is not acceptable.

However, currently we block moves and removes whenever there are
any exclusive or shared locks and this behavior is required to
comply with the current wpt tests. The problem with this is that
another tab holding the lock can the make the site unusable.

The current spec state is
WICG/file-system-access#413 , therefore
these wpt tests are under the mozilla directory.

The tests are meant to provide answers to how the current
implementation handles cases where parent directory is moved,
renamed or removed while writable file streams are present.

Differential Revision: https://phabricator.services.mozilla.com/D228287

Author: jjjalkanen

testing/web-platform/mozilla/meta/dom/fs/fs-writable_lifecycle_after_parent_dir_change.https.window.js.ini

@@ -0,0 +1,16 @@
+[fs-writable_lifecycle_after_parent_dir_change.https.window.html]
+  type: testharness
+  prefs: [dom.fs.enabled:true]
+  expected: [ERROR, OK]
+
+  [closing writable yields error on move of the parent directory]
+    expected: FAIL
+
+  [closing writable yields error on rename of the parent directory]
+    expected: FAIL
+
+  [after overwriting directory with move check that no files are left behind]
+    expected: FAIL
+
+  [after overwriting directory with rename check that no files are left behind]
+    expected: FAIL

testing/web-platform/mozilla/tests/dom/fs/fs-writable_lifecycle_after_parent_dir_change.https.window.js

@@ -0,0 +1,318 @@
+// META: title=Origin private file system used from multiple tabs
+// META: script=support/testHelpers.js
+// META: timeout=long
+
+const okResponse = "200 OK";
+const firstTabContent = "Hello from the first tab!";
+
+const expectCloseIsOk = async (t, ev, aSubDir, aName) => {
+  if (ev.data != okResponse) {
+    throw new Error("Expect close is ok callback failed");
+  }
+
+  const fileHandle = await aSubDir.getFileHandle(aName, { create: false });
+  const file = await fileHandle.getFile();
+  const text = await file.text();
+
+  t.step(() => {
+    assert_equals(firstTabContent, text, "Does the content look good?");
+  });
+};
+
+const expectErrorCallback = errorMsg => {
+  return async (t, ev) => {
+    if (ev.data != errorMsg) {
+      t.step(() => {
+        assert_equals(ev.data, errorMsg, "Expect error callback failed");
+      });
+    }
+  };
+};
+
+const expectInternalError = expectErrorCallback(
+  "Internal error closing file stream"
+);
+
+const expectModificationError = expectErrorCallback("No modification allowed");
+
+const expectNotFoundError = expectErrorCallback("Entry not found");
+
+function addWritableClosingTest(testName, secondTabURL, expectationChecks) {
+  promise_test(async t => {
+    const firstTabURL =
+      "support/fs-create_writables_and_close_on_trigger.sub.html";
+    const channelName = crypto.randomUUID(); // Avoid cross-talk between tests
+    const dirHandleName = "dusty-dir-handle-" + channelName;
+    const fileHandleName = "funky-file-handle-" + channelName;
+
+    const params = new URLSearchParams(
+      secondTabURL.slice(secondTabURL.lastIndexOf("?"))
+    );
+    t.step(() => {
+      assert_true(params.size > 0, "Missing search parameters");
+    });
+
+    const channelParams = "channel=" + channelName;
+    const bc = new BroadcastChannel(channelName);
+    t.add_cleanup(() => {
+      bc.close();
+    });
+
+    const rootDir = await navigator.storage.getDirectory();
+    const subDir = await rootDir.getDirectoryHandle(dirHandleName, {
+      create: true,
+    });
+    await subDir.getFileHandle(fileHandleName, { create: true });
+
+    async function firstReady(win) {
+      return new Promise((resolve, reject) => {
+        bc.onmessage = e => {
+          if (e.data === "First window ready!") {
+            resolve(win);
+          } else {
+            t.step(() => {
+              reject(e.data);
+              assert_equals(
+                "First window ready!",
+                e.data,
+                "Is first window ready?"
+              );
+            });
+          }
+        };
+      });
+    }
+
+    const firstTabLocation = firstTabURL + "?" + channelParams;
+    const firstTab = await firstReady(window.open(firstTabLocation));
+    t.step(() => {
+      assert_true(!!firstTab, "Is the first tab fine?");
+      assert_false(firstTab.closed, "Is the first tab open?");
+    });
+
+    let secondTab = null;
+    async function secondReady(secondTabLocation) {
+      let win = null;
+      return new Promise((resolve, reject) => {
+        bc.onmessage = async ev => {
+          if (expectationChecks.length > 1) {
+            try {
+              await expectationChecks.shift()(t, ev, subDir, fileHandleName);
+            } catch (err) {
+              reject(err);
+              return;
+            }
+          }
+
+          resolve(win);
+        };
+
+        try {
+          win = window.open(secondTabLocation);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    }
+    const secondTabLocation = secondTabURL + "&" + channelParams;
+    try {
+      secondTab = await secondReady(secondTabLocation);
+    } catch (err) {
+      if (expectationChecks.length > 1) {
+        await expectationChecks.shift()(t, { data: err.message });
+      } else {
+        t.step_func(() => {
+          throw err;
+        });
+      }
+    } finally {
+      try {
+        const closeHandles = async () => {
+          return new Promise((resolve, reject) => {
+            bc.onmessage = async ev => {
+              try {
+                if (expectationChecks) {
+                  await expectationChecks.shift()(
+                    t,
+                    ev,
+                    subDir,
+                    fileHandleName
+                  );
+                } else {
+                  t.step_func(() => {
+                    throw err;
+                  });
+                }
+                resolve();
+              } catch (err) {
+                reject(err);
+              }
+            };
+
+            bc.postMessage("trigger");
+          });
+        };
+
+        await closeHandles();
+      } catch (err) {
+        if (expectationChecks) {
+          await expectationChecks.shift()(t, { data: err.message });
+        }
+      } finally {
+        const waitForCleanup = async () => {
+          return new Promise((resolve, reject) => {
+            let firstDone = false;
+            let secondDone = !secondTab;
+
+            bc.onmessage = ev => {
+              if (ev.data == "first done") {
+                firstDone = true;
+              } else if (ev.data == "done") {
+                secondDone = true;
+              } else {
+                t.step(() => {
+                  assert_false(
+                    true,
+                    "We got a cleanup message " + JSON.stringify(ev.data)
+                  );
+                });
+                reject(new Error(ev.data));
+              }
+
+              if (firstDone && secondDone) {
+                resolve();
+              }
+            };
+
+            firstTab.postMessage("cleanup");
+            if (secondTab) {
+              bc.postMessage("cleanup");
+            }
+          });
+        };
+
+        try {
+          await waitForCleanup();
+
+          for await (let entry of rootDir.values()) {
+            console.log(entry.name);
+            await rootDir.removeEntry(entry.name, { recursive: true });
+          }
+        } catch (err) {
+          t.step_func(() => {
+            assert_unreached(err.message);
+          });
+        } finally {
+          t.done();
+        }
+      }
+    }
+  }, testName);
+}
+
+addWritableClosingTest(
+  `closing writable in single tab is success`,
+  "support/fs-noop.sub.html?op=move",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing writable fails silently on move of the parent directory`,
+  "support/fs-relocate_dir_to_trash.sub.html?op=move",
+  [expectCloseIsOk, expectNotFoundError, expectCloseIsOk, expectNotFoundError]
+);
+
+addWritableClosingTest(
+  `closing writable fails silently on rename of the parent directory`,
+  "support/fs-relocate_dir_to_trash.sub.html?op=rename",
+  [expectCloseIsOk, expectNotFoundError, expectCloseIsOk, expectNotFoundError]
+);
+
+addWritableClosingTest(
+  `closing writable succeeds after move of the parent directory is rolled back`,
+  "support/fs-relocate_dir_to_trash_and_back.sub.html?op=move",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing writable succeeds after rename of the parent directory is rolled back`,
+  "support/fs-relocate_dir_to_trash_and_back.sub.html?op=rename",
+  [expectCloseIsOk]
+);
+
+/**
+ * Test case
+ * `removeEntry() of a directory while a containing file has an open writable fails`
+ * in web platform test /fs/FileSystemDirectoryHandle-removeEntry.https.any.html
+ * currently requires that directory cannot be moved while it contains open
+ * writable file streams, even if they are not owner by the current context.
+ *
+ * Without this limitation, the test should yield
+ * "Internal error closing file stream" because the requested close cannot be completed
+ * because the required file path no longer exists, and the request is aborted.
+ */
+addWritableClosingTest(
+  `closing writable yields error on removal of the parent directory`,
+  "support/fs-remove_dir.sub.html?op=remove",
+  [expectModificationError, expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is moved and created again`,
+  "support/fs-relocate_dir_to_trash_and_recreate.sub.html?op=move",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is renamed and created again`,
+  "support/fs-relocate_dir_to_trash_and_recreate.sub.html?op=rename",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is moved, created again and the new file has shared lock open`,
+  "support/fs-relocate_dir_to_trash_and_recreate.sub.html?op=move&keep_open=true",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable fails after directory tree is renamed and created again and the new file has shared lock open`,
+  "support/fs-relocate_dir_to_trash_and_recreate.sub.html?op=rename&keep_open=true",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is overwritten by move`,
+  "support/fs-overwrite_existing_dir.sub.html?op=move",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is overwritten by rename`,
+  "support/fs-overwrite_existing_dir.sub.html?op=rename",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is overwritten by move with new writable open`,
+  "support/fs-overwrite_existing_dir.sub.html?op=move&keep_open=true",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `closing old writable succeeds after directory tree is overwritten by rename with new writable open`,
+  "support/fs-overwrite_existing_dir.sub.html?op=rename&keep_open=true",
+  [expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `after overwriting directory with move check that no files are left behind`,
+  "support/fs-overwrite_leaves_no_files_behind.sub.html?op=move",
+  [expectNotFoundError, expectCloseIsOk]
+);
+
+addWritableClosingTest(
+  `after overwriting directory with rename check that no files are left behind`,
+  "support/fs-overwrite_leaves_no_files_behind.sub.html?op=rename",
+  [expectNotFoundError, expectCloseIsOk]
+);

testing/web-platform/mozilla/tests/dom/fs/support/fs-create_writables_and_close_on_trigger.sub.html

@@ -0,0 +1,69 @@
+<!doctype html>
+<html>
+  <title>Create a file and keep it locked until a trigger is received</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      const params = new URLSearchParams(window.location.search);
+      const channelName = params.get("channel");
+      if (!channelName) {
+        // On irrecoverable errors, window is closed: parent should check this.
+        window.close();
+
+        throw new Error("Unknown channel name");
+      }
+
+      const channel = new BroadcastChannel(channelName);
+      const dirHandleName = "dusty-dir-handle-" + channelName;
+      const fileHandleName = "funky-file-handle-" + channelName;
+
+      var writable = null;
+
+      window.addEventListener("message", async ev => {
+        if (ev.data === "cleanup") {
+          if (writable && !writable.getWriter().closed) {
+            await writable.abort();
+            writable = null;
+          }
+        }
+
+        channel.postMessage("first done");
+      });
+
+      window.addEventListener("load", async () => {
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+          const opts = { create: false };
+          const subDir = await rootDir.getDirectoryHandle(dirHandleName, opts);
+          const file = await subDir.getFileHandle(fileHandleName, opts);
+
+          writable = await file.createWritable({});
+
+          const encoder = new TextEncoder();
+          const writeBuffer = encoder.encode("Hello from the first tab!");
+          await writable.write(writeBuffer);
+
+          channel.onmessage = async ev => {
+            let message = "200 OK";
+            if (ev.data === "trigger") {
+              try {
+                await writable.close();
+                writable = null;
+              } catch (err) {
+                message = err.message;
+              }
+              channel.postMessage(message);
+            }
+          };
+
+          channel.postMessage("First window ready!");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-noop.sub.html

@@ -0,0 +1,32 @@
+<!doctype html>
+<html>
+  <title>No-op window</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      window.addEventListener("load", () => {
+        const params = new URLSearchParams(window.location.search);
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            channel.postMessage("done");
+          }
+        };
+
+        channel.postMessage("200 OK");
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-overwrite_existing_dir.sub.html

@@ -0,0 +1,97 @@
+<!doctype html>
+<html>
+  <title>Overwrite dusty-dir-handle</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      var writable = null;
+
+      window.addEventListener("load", async () => {
+        const params = new URLSearchParams(window.location.search);
+
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const opName = params.get("op");
+        if (!opName || !["move", "rename"].includes(opName)) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown operation name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+        const dirHandleName = "dusty-dir-handle-" + channelName;
+        const fileHandleName = "funky-file-handle-" + channelName;
+        const trashBinName = "trash-bin-" + channelName;
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            if (writable && !writable.getWriter().closed) {
+              try {
+                await writable.abort();
+              } finally {
+                writable = null;
+              }
+            }
+
+            channel.postMessage("done");
+          }
+        };
+
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+          const trashBin = await rootDir.getDirectoryHandle(trashBinName, {
+            create: true,
+          });
+          const trashId = crypto.randomUUID();
+
+          // Let's start from scratch
+          let subDir = null;
+          if (opName == "move") {
+            subDir = await trashBin.getDirectoryHandle(dirHandleName, {
+              create: true,
+            });
+          } else {
+            subDir = await rootDir.getDirectoryHandle(trashId, {
+              create: true,
+            });
+          }
+          const file = await subDir.getFileHandle(fileHandleName, {
+            create: true,
+          });
+          writable = await file.createWritable({});
+
+          const encoder = new TextEncoder();
+          const writeBuffer = encoder.encode("Hello from the second tab!");
+          await writable.write(writeBuffer);
+
+          const keep_open = params.has("keep_open") && params.get("keep_open");
+          if (!keep_open) {
+            await writable.close();
+            writable = null;
+          }
+
+          // Let's overwrite the originals
+          if (opName == "move") {
+            await subDir.move(rootDir);
+          } else {
+            await subDir.move(dirHandleName);
+          }
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-overwrite_leaves_no_files_behind.sub.html

@@ -0,0 +1,138 @@
+<!doctype html>
+<html>
+  <title>Overwrite dusty-dir-handle with a better one from the trash-bin</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      var writable = null;
+      var otherWritable = null;
+
+      window.addEventListener("load", async () => {
+        const params = new URLSearchParams(window.location.search);
+
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const opName = params.get("op");
+        if (!opName || !["move", "rename"].includes(opName)) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown operation name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+        const dirHandleName = "dusty-dir-handle-" + channelName;
+        const fileHandleName = "funky-file-handle-" + channelName;
+        const otherFileHandleName = "other-file-handle-" + channelName;
+        const trashBinName = "trash-bin-" + channelName;
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            if (writable && !writable.getWriter().closed) {
+              try {
+                await writable.abort();
+              } finally {
+                writable = null;
+              }
+            }
+
+            if (otherWritable && !otherWritable.getWriter().closed) {
+              try {
+                await otherWritable.abort();
+              } finally {
+                otherWritable = null;
+              }
+            }
+
+            channel.postMessage("done");
+          }
+        };
+
+        try {
+          const encoder = new TextEncoder();
+          const rootDir = await navigator.storage.getDirectory();
+
+          {
+            const originalDir = await rootDir.getDirectoryHandle(
+              dirHandleName,
+              { create: true }
+            );
+            const otherFile = await originalDir.getFileHandle(
+              otherFileHandleName,
+              { create: true }
+            );
+            otherWritable = await otherFile.createWritable({});
+
+            const otherBuffer = encoder.encode("Hello from the second tab!");
+            await otherWritable.write(otherBuffer);
+            await otherWritable.close();
+            otherWritable = null;
+          }
+
+          const trashBin = await rootDir.getDirectoryHandle(trashBinName, {
+            create: true,
+          });
+          const trashId = crypto.randomUUID();
+
+          // Let's create a new but identical directory tree in the trash bin
+          let subDir = null;
+          if (opName == "move") {
+            subDir = await trashBin.getDirectoryHandle(dirHandleName, {
+              create: true,
+            });
+          } else {
+            subDir = await rootDir.getDirectoryHandle(trashId, {
+              create: true,
+            });
+          }
+
+          const file = await subDir.getFileHandle(fileHandleName, {
+            create: true,
+          });
+          writable = await file.createWritable({});
+
+          const writeBuffer = encoder.encode("Hello from the second tab!");
+          await writable.write(writeBuffer);
+
+          const keep_open = params.has("keep_open") && params.get("keep_open");
+          if (!keep_open) {
+            await writable.close();
+            writable = null;
+          }
+
+          // Let's overwrite the originals!
+          if (opName == "move") {
+            await subDir.move(rootDir);
+          } else {
+            await subDir.move(dirHandleName);
+          }
+
+          {
+            const originalDir = await rootDir.getDirectoryHandle(
+              dirHandleName,
+              { create: false }
+            );
+
+            // The next line should throw, the file should be gone!
+            await originalDir.getFileHandle(otherFileHandleName, {
+              create: false,
+            });
+          }
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-relocate_dir_to_trash.sub.html

@@ -0,0 +1,63 @@
+<!doctype html>
+<html>
+  <title>Move dusty-dir-handle to trash-bin!</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      window.addEventListener("load", async () => {
+        const params = new URLSearchParams(window.location.search);
+
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const opName = params.get("op");
+        if (!opName || !["move", "rename"].includes(opName)) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown operation name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+        const dirHandleName = "dusty-dir-handle-" + channelName;
+        const trashBinName = "trash-bin-" + channelName;
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            channel.postMessage("done");
+          }
+        };
+
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+          const trashBin = await rootDir.getDirectoryHandle(trashBinName, {
+            create: true,
+          });
+          const subDir = await rootDir.getDirectoryHandle(dirHandleName, {
+            create: false,
+          });
+          const trashId = crypto.randomUUID();
+
+          // Let's do some clean up!
+          if (opName == "move") {
+            await subDir.move(trashBin);
+          } else {
+            await subDir.move(trashId);
+          }
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-relocate_dir_to_trash_and_back.sub.html

@@ -0,0 +1,78 @@
+<!doctype html>
+<html>
+  <title>Move dusty-dir-handle to trash-bin and back!</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      window.addEventListener("load", async () => {
+        const params = new URLSearchParams(window.location.search);
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const opName = params.get("op");
+        if (!opName || !["move", "rename"].includes(opName)) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown operation name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+        const dirHandleName = "dusty-dir-handle-" + channelName;
+        const trashBinName = "trash-bin-" + channelName;
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            channel.postMessage("done");
+          }
+        };
+
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+          const trashBin = await rootDir.getDirectoryHandle(trashBinName, {
+            create: true,
+          });
+          const trashId = crypto.randomUUID();
+
+          {
+            const subDir = await rootDir.getDirectoryHandle(dirHandleName, {
+              create: false,
+            });
+
+            // Let's do some clean up!
+            if (opName == "move") {
+              await subDir.move(trashBin);
+            } else {
+              await subDir.move(trashId);
+            }
+          }
+
+          // Oops! Didn't really mean to throw that to the trash bin!
+          if (opName == "move") {
+            const subDir = await trashBin.getDirectoryHandle(dirHandleName, {
+              create: false,
+            });
+            await subDir.move(rootDir);
+          } else {
+            const subDir = await rootDir.getDirectoryHandle(trashId, {
+              create: false,
+            });
+            await subDir.move(dirHandleName);
+          }
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-relocate_dir_to_trash_and_recreate.sub.html

@@ -0,0 +1,98 @@
+<!doctype html>
+<html>
+  <title>Move dusty-dir-handle to trash-bin and start from scratch!</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      var writable = null;
+
+      window.addEventListener("load", async () => {
+        const params = new URLSearchParams(window.location.search);
+
+        const channelName = params.get("channel");
+        if (!channelName) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown channel name");
+        }
+
+        const opName = params.get("op");
+        if (!opName || !["move", "rename"].includes(opName)) {
+          // On irrecoverable errors, window is closed: parent should check this.
+          window.close();
+
+          throw new Error("Unknown operation name");
+        }
+
+        const channel = new BroadcastChannel(channelName);
+        const dirHandleName = "dusty-dir-handle-" + channelName;
+        const fileHandleName = "funky-file-handle-" + channelName;
+        const trashBinName = "trash-bin-" + channelName;
+
+        channel.onmessage = async ev => {
+          if (ev.data == "cleanup") {
+            if (writable && !writable.getWriter().closed) {
+              try {
+                await writable.abort();
+              } finally {
+                writable = null;
+              }
+            }
+
+            channel.postMessage("done");
+          }
+        };
+
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+          const trashBin = await rootDir.getDirectoryHandle(trashBinName, {
+            create: true,
+          });
+          const trashId = crypto.randomUUID();
+          {
+            const subDir = await rootDir.getDirectoryHandle(dirHandleName, {
+              create: false,
+            });
+
+            // Let's do some clean up!
+            if (opName == "move") {
+              await subDir.move(trashBin);
+            } else {
+              await subDir.move(trashId);
+            }
+          }
+
+          {
+            // Let's start from scratch!
+            const subDir = await rootDir.getDirectoryHandle(dirHandleName, {
+              create: true,
+            });
+            const file = await subDir.getFileHandle(fileHandleName, {
+              create: true,
+            });
+            writable = await file.createWritable({});
+
+            const encoder = new TextEncoder();
+            const writeBuffer = encoder.encode("Hello from the second tab!");
+            await writable.write(writeBuffer);
+
+            const keep_open =
+              params.has("keep_open") && params.get("keep_open");
+            if (!keep_open) {
+              await writable.close();
+              writable = null;
+            }
+          }
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>

testing/web-platform/mozilla/tests/dom/fs/support/fs-remove_dir.sub.html

@@ -0,0 +1,51 @@
+<!doctype html>
+<html>
+  <title>Remove dusty-dir-handle</title>
+  <head>
+    <script src="/resources/testharness.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+      const params = new URLSearchParams(window.location.search);
+
+      const channelName = params.get("channel");
+      if (!channelName) {
+        // On irrecoverable errors, window is closed: parent should check this.
+        window.close();
+
+        throw new Error("Unknown channel name");
+      }
+
+      const opName = params.get("op");
+      if (!opName || "remove" != opName) {
+        // On irrecoverable errors, window is closed: parent should check this.
+        window.close();
+
+        throw new Error("Unknown operation name");
+      }
+
+      const channel = new BroadcastChannel(channelName);
+      const dirHandleName = "dusty-dir-handle-" + channelName;
+
+      channel.onmessage = async ev => {
+        if (ev.data == "cleanup") {
+          channel.postMessage("done");
+        }
+      };
+
+      window.addEventListener("load", async () => {
+        try {
+          const rootDir = await navigator.storage.getDirectory();
+
+          // Let's do some clean up!
+          await rootDir.removeEntry(dirHandleName, { recursive: true });
+
+          channel.postMessage("200 OK");
+        } catch (err) {
+          channel.postMessage(err.message);
+        }
+      });
+    </script>
+  </body>
+</html>