6 files changed, 966 insertions, 0 deletions
diff --git a/dom/filesystem/compat/tests/mochitest.ini b/dom/filesystem/compat/tests/mochitest.ini
new file mode 100644
index 0000000000..2b6eafb550
--- /dev/null
+++ b/dom/filesystem/compat/tests/mochitest.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+support-files =
+  script_entries.js
+  !/dom/html/test/form_submit_server.sjs
+
+[test_basic.html]
+[test_no_dnd.html]
+[test_formSubmission.html]
diff --git a/dom/filesystem/compat/tests/moz.build b/dom/filesystem/compat/tests/moz.build
new file mode 100644
index 0000000000..7c990fbc62
--- /dev/null
+++ b/dom/filesystem/compat/tests/moz.build
@@ -0,0 +1,7 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+MOCHITEST_MANIFESTS += ["mochitest.ini"]
diff --git a/dom/filesystem/compat/tests/script_entries.js b/dom/filesystem/compat/tests/script_entries.js
new file mode 100644
index 0000000000..7f52fe6bf2
--- /dev/null
+++ b/dom/filesystem/compat/tests/script_entries.js
@@ -0,0 +1,47 @@
+/* eslint-env mozilla/chrome-script */
+// eslint-disable-next-line mozilla/reject-importGlobalProperties
+Cu.importGlobalProperties(["File", "Directory"]);
+var tmpFile, tmpDir;
+
+addMessageListener("entries.open", function (e) {
+  tmpFile = Services.dirsvc
+    .QueryInterface(Ci.nsIProperties)
+    .get("TmpD", Ci.nsIFile);
+  tmpFile.append("file.txt");
+  tmpFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+  tmpDir = Services.dirsvc
+    .QueryInterface(Ci.nsIProperties)
+    .get("TmpD", Ci.nsIFile);
+
+  tmpDir.append("dir-test");
+  tmpDir.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+
+  var file1 = tmpDir.clone();
+  file1.append("foo.txt");
+  file1.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+  var dir1 = tmpDir.clone();
+  dir1.append("subdir");
+  dir1.create(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+
+  var file2 = dir1.clone();
+  file2.append("bar..txt"); // Note the double ..
+  file2.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+  var dir2 = dir1.clone();
+  dir2.append("subsubdir");
+  dir2.create(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+
+  File.createFromNsIFile(tmpFile).then(function (file) {
+    sendAsyncMessage("entries.opened", {
+      data: [new Directory(tmpDir.path), file],
+    });
+  });
+});
+
+addMessageListener("entries.delete", function (e) {
+  tmpFile.remove(true);
+  tmpDir.remove(true);
+  sendAsyncMessage("entries.deleted");
+});
diff --git a/dom/filesystem/compat/tests/test_basic.html b/dom/filesystem/compat/tests/test_basic.html
new file mode 100644
index 0000000000..4ad0c37d67
--- /dev/null
+++ b/dom/filesystem/compat/tests/test_basic.html
@@ -0,0 +1,549 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Blink FileSystem API - subset</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<input id="entries" type="file"></input>
+<script type="application/javascript">
+var fileEntry;
+var directoryEntry;
+var script;
+
+function setup_tests() {
+  SpecialPowers.pushPrefEnv({"set": [["dom.webkitBlink.dirPicker.enabled", true],
+                                     ["dom.filesystem.pathcheck.disabled", true],
+                                     ["dom.webkitBlink.filesystem.enabled", true]]}, next);
+}
+
+function populate_entries() {
+  var url = SimpleTest.getTestFileURL("script_entries.js");
+  script = SpecialPowers.loadChromeScript(url);
+
+  function onOpened(message) {
+    var entries = document.getElementById("entries");
+    SpecialPowers.wrap(entries).mozSetDndFilesAndDirectories(message.data);
+    next();
+  }
+
+  script.addMessageListener("entries.opened", onOpened);
+  script.sendAsyncMessage("entries.open");
+}
+
+function test_entries() {
+  var entries = document.getElementById("entries");
+  ok("webkitEntries" in entries, "HTMLInputElement.webkitEntries");
+  is(entries.webkitEntries.length, 2, "HTMLInputElement.webkitEntries.length == 2");
+  is(entries.files.length, 1, "HTMLInputElement.files is still populated");
+
+  for (var i = 0; i < entries.webkitEntries.length; ++i) {
+    if (entries.webkitEntries[i].isFile) {
+      ok(!fileEntry, "We just want 1 fileEntry");
+      fileEntry = entries.webkitEntries[i];
+    } else {
+      ok(entries.webkitEntries[i].isDirectory, "If not a file, we have a directory.");
+      ok(!directoryEntry, "We just want 1 directoryEntry");
+      directoryEntry = entries.webkitEntries[i];
+    }
+  }
+
+  next();
+}
+
+function test_fileEntry() {
+  ok("name" in fileEntry, "We have a name.");
+  ok("fullPath" in fileEntry, "We have a fullPath.");
+  ok("filesystem" in fileEntry, "We have a filesystem.");
+
+  next();
+}
+
+function test_fileEntry_file() {
+  fileEntry.file(function(file) {
+    ok(file, "We have a file here!");
+    is(file.name, fileEntry.name, "Same file name.");
+    next();
+  }, function() {
+    ok(false, "Something when wrong!");
+  });
+}
+
+function test_fileEntry_getParent() {
+  fileEntry.getParent(function(entry) {
+    is(fileEntry.fullPath, entry.fullPath, "Top level FileEntry should return itself as parent.");
+    next();
+  }, function() {
+    ok(false, "This is wrong.");
+  });
+}
+
+function test_directoryEntry() {
+  ok("name" in directoryEntry, "We have a name.");
+  ok("fullPath" in directoryEntry, "We have a fullPath.");
+  ok("filesystem" in directoryEntry, "We have a filesystem.");
+
+  next();
+}
+
+function test_directoryEntry_createReader() {
+  var reader = directoryEntry.createReader();
+  ok(reader, "We have a DirectoryReader");
+
+  reader.readEntries(function(a) {
+    ok(Array.isArray(a), "We want an array.");
+    is(a.length, 2, "reader.readyEntries returns 2 elements.");
+
+    for (var i = 0; i < 2; ++i) {
+      ok(a[i].name == "subdir" || a[i].name == "foo.txt", "Correct names");
+      is(a[i].fullPath, directoryEntry.fullPath + "/" + a[i].name, "FullPath is correct");
+    }
+
+    // Called twice:
+    reader.readEntries(function(a1) {
+      ok(Array.isArray(a1), "We want an array.");
+      is(a1.length, 0, "reader.readyEntries returns 0 elements.");
+      next();
+    }, function() {
+      ok(false, "Something when wrong!");
+    });
+  }, function() {
+    ok(false, "Something when wrong!");
+  });
+}
+
+function test_directoryEntry_getParent() {
+  directoryEntry.getParent(function(entry) {
+    is(directoryEntry.fullPath, entry.fullPath, "Top level FileEntry should return itself as parent.");
+    next();
+  }, function() {
+    ok(false, "This is wrong.");
+  });
+}
+
+function test_directoryEntry_getFile_securityError() {
+  directoryEntry.getFile("foo", { create: true },
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "SecurityError", "This must generate a SecurityError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getFile_typeMismatchError() {
+  directoryEntry.getFile("subdir", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "TypeMismatchError", "This must generate a TypeMismatchError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getFile_nonValidPath() {
+  directoryEntry.getFile("../../", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getFile_nonExistingPath() {
+  directoryEntry.getFile("foo_bar.txt", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getFile_simple() {
+  directoryEntry.getFile("foo.txt", {},
+  function(e) {
+    is(e.name, "foo.txt", "We have the right FileEntry.");
+    test_getParent(e, directoryEntry, /* nested */ false);
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_directoryEntry_getFile_deep() {
+  directoryEntry.getFile("subdir/bar..txt", {},
+  function(e) {
+    is(e.name, "bar..txt", "We have the right FileEntry.");
+    test_getParent(e, directoryEntry, /* nested */ true);
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_directoryEntry_getDirectory_securityError() {
+  directoryEntry.getDirectory("foo", { create: true },
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "SecurityError", "This must generate a SecurityError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getDirectory_typeMismatchError() {
+  directoryEntry.getDirectory("foo.txt", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "TypeMismatchError", "This must generate a TypeMismatchError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getDirectory_nonValidPath() {
+  directoryEntry.getDirectory("../../", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getDirectory_nonExistingPath() {
+  directoryEntry.getDirectory("non_existing_dir", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_directoryEntry_getDirectory_simple() {
+  directoryEntry.getDirectory("subdir", {},
+  function(e) {
+    is(e.name, "subdir", "We have the right DirectoryEntry.");
+    test_getParent(e, directoryEntry, /* nested */ false);
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_directoryEntry_getDirectory_deep() {
+  directoryEntry.getDirectory("subdir/subsubdir", {},
+  function(e) {
+    is(e.name, "subsubdir", "We have the right DirectoryEntry.");
+    test_getParent(e, directoryEntry, /* nested */ true);
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_filesystem() {
+  is(fileEntry.filesystem, directoryEntry.filesystem, "FileSystem object is shared.");
+
+  var fs = fileEntry.filesystem;
+  ok(fs.name, "FileSystem.name exists.");
+  ok(fs.root, "FileSystem has a root.");
+
+  is(fs.root.name, "", "FileSystem.root.name must be an empty string.");
+  is(fs.root.fullPath, "/", "FileSystem.root.fullPath must be '/'");
+
+  var reader = fs.root.createReader();
+  reader.readEntries(function(a) {
+    ok(Array.isArray(a), "We want an array.");
+    is(a.length, 2, "reader.readyEntries returns 2 elements.");
+    next();
+  }, function() {
+    ok(false, "Something when wrong!");
+  });
+}
+
+function test_root_getFile_securityError() {
+  fileEntry.filesystem.root.getFile("foo", { create: true },
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "SecurityError", "This must generate a SecurityError.");
+    next();
+  });
+}
+
+function test_root_getFile_typeMismatchError() {
+  fileEntry.filesystem.root.getFile(directoryEntry.name, {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "TypeMismatchError", "This must generate a TypeMismatchError.");
+    next();
+  });
+}
+
+function test_root_getFile_nonValidPath() {
+  fileEntry.filesystem.root.getFile("../../", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_root_getFile_nonExistingPath() {
+  fileEntry.filesystem.root.getFile("existing.txt", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_root_getFile_simple() {
+  fileEntry.filesystem.root.getFile(fileEntry.name, {},
+  function(e) {
+    is(e.name, fileEntry.name, "We have the right FileEntry.");
+    next();
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_root_getFile_deep() {
+  fileEntry.filesystem.root.getFile(directoryEntry.name + "/subdir/bar..txt", {},
+  function(e) {
+    is(e.name, "bar..txt", "We have the right FileEntry.");
+    next();
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_root_getDirectory_securityError() {
+  fileEntry.filesystem.root.getDirectory("foo", { create: true },
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "SecurityError", "This must generate a SecurityError.");
+    next();
+  });
+}
+
+function test_root_getDirectory_typeMismatchError() {
+  fileEntry.filesystem.root.getDirectory(fileEntry.name, {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "TypeMismatchError", "This must generate a TypeMismatchError.");
+    next();
+  });
+}
+
+function test_root_getDirectory_nonValidPath() {
+  fileEntry.filesystem.root.getDirectory("../../", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_root_getDirectory_nonExistingPath() {
+  fileEntry.filesystem.root.getDirectory("404", {},
+  function() {
+    ok(false, "This should not happen.");
+  }, function(e) {
+    is(e.name, "NotFoundError", "This must generate a NotFoundError.");
+    next();
+  });
+}
+
+function test_root_getDirectory_simple() {
+  fileEntry.filesystem.root.getDirectory(directoryEntry.name, {},
+  function(e) {
+    is(e.name, directoryEntry.name, "We have the right DirectoryEntry.");
+    next();
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_root_getDirectory_deep() {
+  fileEntry.filesystem.root.getDirectory(directoryEntry.name + "/subdir/subsubdir", {},
+  function(e) {
+    is(e.name, "subsubdir", "We have the right DirectoryEntry.");
+    next();
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function cleanUpTestingFiles() {
+  script.addMessageListener("entries.deleted", function onDeleted() {
+    script.removeMessageListener("entries.deleted");
+    script.destroy();
+    next();
+  });
+
+  script.sendAsyncMessage("entries.delete");
+}
+
+function test_getParent(entry, parentEntry, nested) {
+  entry.getParent(function(e) {
+    ok(e, "We have a parent Entry.");
+    if (!nested) {
+      is(e, parentEntry, "Parent entry matches");
+      next();
+    } else {
+      test_getParent(e, parentEntry, false);
+    }
+  }, function(e) {
+    ok(false, "This should not happen.");
+  });
+}
+
+function test_webkitRelativePath() {
+  fileEntry.file(function(file1) {
+    ok(file1, "We have a file here!");
+    ok(!file1.webkitRelativePath, "webkitRelativePath is an empty string");
+
+    fileEntry.file(function(file2) {
+      ok(file2, "We have a file here!");
+      ok(!file2.webkitRelativePath, "webkitRelativePath is an empty string");
+      isnot(file1, file2, "The 2 files are not the same");
+
+      next();
+    }, function() {
+      ok(false, "Something when wrong!");
+    });
+  }, function() {
+    ok(false, "Something when wrong!");
+  });
+}
+
+function test_deprecatedCallbacks() {
+  try {
+    fileEntry.file({ handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "fileEntry.file() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "fileEntry.file() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  try {
+    fileEntry.getParent({ handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "fileEntry.getParent() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "fileEntry.getParent() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  try {
+    directoryEntry.getFile("file.txt", {}, { handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "directoryEntry.getFile() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "directoryEntry.getFile() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  try {
+    directoryEntry.getDirectory("foo", { create: true }, { handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "directoryEntry.getDirectory() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "directoryEntry.getDirectory() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  try {
+    directoryEntry.getParent({ handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "directoryEntry.getParent() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "directoryEntry.getParent() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  let reader = directoryEntry.createReader();
+  ok(reader, "We have a DirectoryReader");
+
+  try {
+    reader.readEntries({ handleEvent: _ => { ok(false, "This function should not be called!"); }});
+    ok(false, "reader.readEntries() should throw with wrong arguments");
+  } catch (e) {
+    ok(true, "reader.readEntries() should throw with wrong arguments");
+    is(e.name, "TypeError", "Correct exception");
+  }
+
+  next();
+}
+
+var tests = [
+  setup_tests,
+  populate_entries,
+
+  test_entries,
+
+  test_fileEntry,
+  test_fileEntry_file,
+  test_fileEntry_getParent,
+
+  test_directoryEntry,
+  test_directoryEntry_createReader,
+  test_directoryEntry_getParent,
+
+  test_directoryEntry_getFile_securityError,
+  test_directoryEntry_getFile_typeMismatchError,
+  test_directoryEntry_getFile_nonValidPath,
+  test_directoryEntry_getFile_nonExistingPath,
+  test_directoryEntry_getFile_simple,
+  test_directoryEntry_getFile_deep,
+
+  test_directoryEntry_getDirectory_securityError,
+  test_directoryEntry_getDirectory_typeMismatchError,
+  test_directoryEntry_getDirectory_nonValidPath,
+  test_directoryEntry_getDirectory_nonExistingPath,
+  test_directoryEntry_getDirectory_simple,
+  test_directoryEntry_getDirectory_deep,
+
+  test_filesystem,
+
+  test_root_getFile_securityError,
+  test_root_getFile_typeMismatchError,
+  test_root_getFile_nonValidPath,
+  test_root_getFile_nonExistingPath,
+  test_root_getFile_simple,
+  test_root_getFile_deep,
+
+  test_root_getDirectory_securityError,
+  test_root_getDirectory_typeMismatchError,
+  test_root_getDirectory_nonValidPath,
+  test_root_getDirectory_nonExistingPath,
+  test_root_getDirectory_simple,
+  test_root_getDirectory_deep,
+
+  test_webkitRelativePath,
+
+  test_deprecatedCallbacks,
+
+  cleanUpTestingFiles,
+];
+
+function next() {
+  if (!tests.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/compat/tests/test_formSubmission.html b/dom/filesystem/compat/tests/test_formSubmission.html
new file mode 100644
index 0000000000..2447e7a071
--- /dev/null
+++ b/dom/filesystem/compat/tests/test_formSubmission.html
@@ -0,0 +1,271 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Directory form submission</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+  <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
+</head>
+<body onload="return next();">
+
+<iframe name="target_iframe" id="target_iframe"></iframe>
+
+<form action="../../../html/test/form_submit_server.sjs" target="target_iframe" id="form"
+      method="POST" enctype="multipart/form-data">
+</form>
+
+<script class="testbody" type="text/javascript">
+var form;
+var iframe;
+var input;
+var script;
+var xhr;
+
+function setup_tests() {
+  form = document.getElementById("form");
+
+  iframe = document.getElementById("target_iframe");
+  iframe.onload = function() {
+    info("Frame loaded!");
+    next();
+  };
+
+  SpecialPowers.pushPrefEnv({"set": [["dom.webkitBlink.dirPicker.enabled", true],
+                                     ["dom.filesystem.pathcheck.disabled", true],
+                                     ["dom.webkitBlink.filesystem.enabled", true]]}, next);
+}
+
+function populate_entries(webkitDirectory) {
+  var url = SimpleTest.getTestFileURL("script_entries.js");
+  script = SpecialPowers.loadChromeScript(url);
+
+  if (input) {
+    form.removeChild(input);
+  }
+
+  input = document.createElement("input");
+  input.setAttribute("id", "input");
+  input.setAttribute("type", "file");
+  input.setAttribute("name", "input");
+
+  if (webkitDirectory) {
+    input.setAttribute("webkitdirectory", "true");
+  }
+
+  form.appendChild(input);
+
+  function onOpened(message) {
+    input.addEventListener("change", function() {
+      next();
+    }, {once: true});
+
+    SpecialPowers.wrap(input).mozSetDndFilesAndDirectories([message.data[0]]);
+  }
+
+  script.addMessageListener("entries.opened", onOpened);
+  script.sendAsyncMessage("entries.open");
+}
+
+function delete_entries() {
+  script.sendAsyncMessage("entries.delete");
+  script.addMessageListener("entries.deleted", function() {
+    script.destroy();
+    next();
+  });
+}
+
+function setup_plain() {
+  info("Preparing for a plain text submission...");
+  form.action = "../../../html/test/form_submit_server.sjs?plain";
+  form.method = "POST";
+  form.enctype = "text/plain";
+  form.submit();
+}
+
+function test_plain() {
+  var content = iframe.contentDocument.documentElement.textContent;
+  var submission = JSON.parse(content);
+  info(submission);
+  is(submission, input.webkitEntries.map(function(v) {
+     return "input=" + v.name + "\r\n";
+  }).join(""), "Data match");
+
+  next();
+}
+
+function setup_urlencoded() {
+  info("Preparing for a urlencoded submission...");
+  form.action = "../../../html/test/form_submit_server.sjs?url";
+  form.method = "POST";
+  form.enctype = "application/x-www-form-urlencoded";
+  form.submit();
+}
+
+function setup_urlencoded_get() {
+  info("Preparing for a urlencoded+GET submission...");
+  form.action = "../../../html/test/form_submit_server.sjs?xxyy";
+  form.method = "GET";
+  form.enctype = "";
+  form.submit();
+}
+
+function setup_urlencoded_empty() {
+  info("Preparing for a urlencoded+default values submission...");
+  form.action = "../../../html/test/form_submit_server.sjs";
+  form.method = "";
+  form.enctype = "";
+  form.submit();
+}
+
+function test_urlencoded() {
+  var content = iframe.contentDocument.documentElement.textContent;
+  var submission = JSON.parse(content);
+  info(submission);
+  is(submission, input.webkitEntries.map(function(v) {
+     return "input=" + v.name;
+  }).join("&"), "Data match");
+
+  next();
+}
+
+function setup_formData() {
+  info("Preparing for a fromData submission...");
+
+  xhr = new XMLHttpRequest();
+  xhr.onload = next;
+  xhr.open("POST", "../../../html/test/form_submit_server.sjs");
+  xhr.send(new FormData(form));
+}
+
+function test_multipart() {
+  var submission = JSON.parse(xhr.responseText);
+
+  var array = input.webkitEntries;
+  is(submission.length, array.length, "Same length");
+  info(submission);
+
+  for (var i = 0; i < array.length; ++i) {
+    if (array[i].isDirectory) {
+      is(submission[i].headers["Content-Disposition"],
+         "form-data; name=\"input\"; filename=\"/" + array[i].name + "\"",
+         "Correct Content-Disposition");
+      is(submission[i].headers["Content-Type"], "application/octet-stream",
+         "Correct Content-Type");
+      is(submission[i].body, "", "Correct body");
+    } else {
+      ok(array[i].isFile);
+      is(submission[i].headers["Content-Disposition"],
+         "form-data; name=\"input\"; filename=\"" + array[i].name + "\"",
+         "Correct Content-Disposition");
+      is(submission[i].headers["Content-Type"], array[i].type,
+         "Correct Content-Type");
+      is(submission[i].body, "", "Correct body");
+    }
+  }
+
+  next();
+}
+
+function getInputFiles(inputElement) {
+  var array = [];
+  for (var i = 0; i < inputElement.files.length; ++i) {
+    array.push(inputElement.files[i]);
+  }
+  return array;
+}
+
+function test_webkit_plain() {
+  var content = iframe.contentDocument.documentElement.textContent;
+  var submission = JSON.parse(content);
+
+  is(submission, getInputFiles(input).map(function(v) {
+    return "input=" + v.name + "\r\n";
+  }).join(""), "Data match");
+
+  next();
+}
+
+function test_webkit_urlencoded() {
+  var content = iframe.contentDocument.documentElement.textContent;
+  var submission = JSON.parse(content);
+  is(submission, getInputFiles(input).map(function(v) {
+     return "input=" + v.name;
+  }).join("&"), "Data match");
+
+  next();
+}
+
+function test_webkit_multipart() {
+  var submission = JSON.parse(xhr.responseText);
+  var array = getInputFiles(input);
+  is(submission.length, array.length, "Same length");
+
+  for (var i = 0; i < array.length; ++i) {
+    ok(array[i] instanceof File);
+    is(submission[i].headers["Content-Disposition"],
+       "form-data; name=\"input\"; filename=\"" + array[i].webkitRelativePath + "\"",
+       "Correct Content-Disposition");
+    is(submission[i].headers["Content-Type"], array[i].type,
+       "Correct Content-Type");
+    is(submission[i].body, "", "Correct body");
+  }
+  next();
+}
+
+var tests = [
+  setup_tests,
+
+  function() { populate_entries(false); },
+
+  setup_plain,
+  test_plain,
+
+  setup_urlencoded,
+  test_urlencoded,
+
+  setup_urlencoded_get,
+  test_urlencoded,
+
+  setup_urlencoded_empty,
+  test_urlencoded,
+
+  setup_formData,
+  test_multipart,
+
+  delete_entries,
+
+  function() { populate_entries(true); },
+
+  setup_plain,
+  test_webkit_plain,
+
+  setup_urlencoded,
+  test_webkit_urlencoded,
+
+  setup_urlencoded_get,
+  test_webkit_urlencoded,
+
+  setup_urlencoded_empty,
+  test_webkit_urlencoded,
+
+  setup_formData,
+  test_webkit_multipart,
+
+  delete_entries,
+];
+
+function next() {
+  if (!tests.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/compat/tests/test_no_dnd.html b/dom/filesystem/compat/tests/test_no_dnd.html
new file mode 100644
index 0000000000..c49dd5d40f
--- /dev/null
+++ b/dom/filesystem/compat/tests/test_no_dnd.html
@@ -0,0 +1,84 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Blink FileSystem API - no DND == no webkitEntries</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<script type="application/javascript">
+var fileEntry;
+var directoryEntry;
+var script;
+var entries;
+
+function setup_tests() {
+  SpecialPowers.pushPrefEnv({"set": [["dom.webkitBlink.dirPicker.enabled", true],
+                                     ["dom.filesystem.pathcheck.disabled", true],
+                                     ["dom.webkitBlink.filesystem.enabled", true]]}, next);
+}
+
+function populate_entries() {
+  entries = document.createElement("input");
+  entries.setAttribute("type", "file");
+  document.body.appendChild(entries);
+
+  var url = SimpleTest.getTestFileURL("script_entries.js");
+  script = SpecialPowers.loadChromeScript(url);
+
+  function onOpened(message) {
+    for (var i = 0 ; i < message.data.length; ++i) {
+      if (message.data[i] instanceof File) {
+        SpecialPowers.wrap(entries).mozSetFileArray([message.data[i]]);
+        next();
+      }
+    }
+  }
+
+  script.addMessageListener("entries.opened", onOpened);
+  script.sendAsyncMessage("entries.open");
+}
+
+function test_entries() {
+  ok("webkitEntries" in entries, "HTMLInputElement.webkitEntries");
+  is(entries.webkitEntries.length, 0, "HTMLInputElement.webkitEntries.length == 0");
+  is(entries.files.length, 1, "HTMLInputElement.files is still populated");
+
+  next();
+}
+
+function cleanUpTestingFiles() {
+  script.addMessageListener("entries.deleted", function onDeleted() {
+    script.removeMessageListener("entries.deleted");
+    script.destroy();
+    next();
+  });
+
+  script.sendAsyncMessage("entries.delete");
+}
+
+var tests = [
+  setup_tests,
+  populate_entries,
+
+  test_entries,
+
+  cleanUpTestingFiles,
+];
+
+function next() {
+  if (!tests.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>