summaryrefslogtreecommitdiffstats
path: root/dom/filesystem
diff options
context:
space:
mode:
Diffstat (limited to 'dom/filesystem')
-rw-r--r--dom/filesystem/Directory.cpp198
-rw-r--r--dom/filesystem/Directory.h110
-rw-r--r--dom/filesystem/FileSystemBase.cpp143
-rw-r--r--dom/filesystem/FileSystemBase.h80
-rw-r--r--dom/filesystem/FileSystemRequestParent.cpp188
-rw-r--r--dom/filesystem/FileSystemRequestParent.h43
-rw-r--r--dom/filesystem/FileSystemSecurity.cpp106
-rw-r--r--dom/filesystem/FileSystemSecurity.h40
-rw-r--r--dom/filesystem/FileSystemTaskBase.cpp246
-rw-r--r--dom/filesystem/FileSystemTaskBase.h254
-rw-r--r--dom/filesystem/FileSystemUtils.cpp84
-rw-r--r--dom/filesystem/FileSystemUtils.h51
-rw-r--r--dom/filesystem/GetDirectoryListingTask.cpp371
-rw-r--r--dom/filesystem/GetDirectoryListingTask.h91
-rw-r--r--dom/filesystem/GetFileOrDirectoryTask.cpp270
-rw-r--r--dom/filesystem/GetFileOrDirectoryTask.h79
-rw-r--r--dom/filesystem/GetFilesHelper.cpp506
-rw-r--r--dom/filesystem/GetFilesHelper.h161
-rw-r--r--dom/filesystem/GetFilesTask.cpp246
-rw-r--r--dom/filesystem/GetFilesTask.h83
-rw-r--r--dom/filesystem/OSFileSystem.cpp88
-rw-r--r--dom/filesystem/OSFileSystem.h98
-rw-r--r--dom/filesystem/PFileSystemParams.ipdlh48
-rw-r--r--dom/filesystem/PFileSystemRequest.ipdl77
-rw-r--r--dom/filesystem/compat/CallbackRunnables.cpp280
-rw-r--r--dom/filesystem/compat/CallbackRunnables.h118
-rw-r--r--dom/filesystem/compat/FileSystem.cpp60
-rw-r--r--dom/filesystem/compat/FileSystem.h52
-rw-r--r--dom/filesystem/compat/FileSystemDirectoryEntry.cpp92
-rw-r--r--dom/filesystem/compat/FileSystemDirectoryEntry.h73
-rw-r--r--dom/filesystem/compat/FileSystemDirectoryReader.cpp181
-rw-r--r--dom/filesystem/compat/FileSystemDirectoryReader.h60
-rw-r--r--dom/filesystem/compat/FileSystemEntry.cpp80
-rw-r--r--dom/filesystem/compat/FileSystemEntry.h67
-rw-r--r--dom/filesystem/compat/FileSystemFileEntry.cpp94
-rw-r--r--dom/filesystem/compat/FileSystemFileEntry.h49
-rw-r--r--dom/filesystem/compat/FileSystemRootDirectoryEntry.cpp138
-rw-r--r--dom/filesystem/compat/FileSystemRootDirectoryEntry.h48
-rw-r--r--dom/filesystem/compat/FileSystemRootDirectoryReader.cpp93
-rw-r--r--dom/filesystem/compat/FileSystemRootDirectoryReader.h38
-rw-r--r--dom/filesystem/compat/moz.build30
-rw-r--r--dom/filesystem/compat/tests/mochitest.toml11
-rw-r--r--dom/filesystem/compat/tests/moz.build7
-rw-r--r--dom/filesystem/compat/tests/script_entries.js47
-rw-r--r--dom/filesystem/compat/tests/test_basic.html549
-rw-r--r--dom/filesystem/compat/tests/test_formSubmission.html271
-rw-r--r--dom/filesystem/compat/tests/test_no_dnd.html84
-rw-r--r--dom/filesystem/moz.build50
-rw-r--r--dom/filesystem/tests/filesystem_commons.js180
-rw-r--r--dom/filesystem/tests/mochitest.toml16
-rw-r--r--dom/filesystem/tests/moz.build7
-rw-r--r--dom/filesystem/tests/script_fileList.js176
-rw-r--r--dom/filesystem/tests/script_promptHandler.js18
-rw-r--r--dom/filesystem/tests/test_basic.html118
-rw-r--r--dom/filesystem/tests/test_bug1319088.html65
-rw-r--r--dom/filesystem/tests/test_webkitdirectory.html309
-rw-r--r--dom/filesystem/tests/test_worker_basic.html73
-rw-r--r--dom/filesystem/tests/worker_basic.js50
58 files changed, 7245 insertions, 0 deletions
diff --git a/dom/filesystem/Directory.cpp b/dom/filesystem/Directory.cpp
new file mode 100644
index 0000000000..da5d6e5515
--- /dev/null
+++ b/dom/filesystem/Directory.cpp
@@ -0,0 +1,198 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/Directory.h"
+
+#include "GetDirectoryListingTask.h"
+#include "GetFilesTask.h"
+
+#include "nsIFile.h"
+#include "nsString.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/DirectoryBinding.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/OSFileSystem.h"
+#include "mozilla/dom/WorkerPrivate.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(Directory)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Directory)
+ if (tmp->mFileSystem) {
+ tmp->mFileSystem->Unlink();
+ tmp->mFileSystem = nullptr;
+ }
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Directory)
+ if (tmp->mFileSystem) {
+ tmp->mFileSystem->Traverse(cb);
+ }
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Directory)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Directory)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Directory)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/* static */
+already_AddRefed<Directory> Directory::Constructor(const GlobalObject& aGlobal,
+ const nsAString& aRealPath,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIFile> path;
+ aRv = NS_NewLocalFile(aRealPath, true, getter_AddRefs(path));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (NS_WARN_IF(!global)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ return Create(global, path);
+}
+
+/* static */
+already_AddRefed<Directory> Directory::Create(nsIGlobalObject* aGlobal,
+ nsIFile* aFile,
+ FileSystemBase* aFileSystem) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(aFile);
+
+ RefPtr<Directory> directory = new Directory(aGlobal, aFile, aFileSystem);
+ return directory.forget();
+}
+
+Directory::Directory(nsIGlobalObject* aGlobal, nsIFile* aFile,
+ FileSystemBase* aFileSystem)
+ : mGlobal(aGlobal), mFile(aFile) {
+ MOZ_ASSERT(aFile);
+
+ // aFileSystem can be null. In this case we create a OSFileSystem when needed.
+ if (aFileSystem) {
+ // More likely, this is a OSFileSystem. This object keeps a reference of
+ // mGlobal but it's not cycle collectable and to avoid manual
+ // addref/release, it's better to have 1 object per directory. For this
+ // reason we clone it here.
+ mFileSystem = aFileSystem->Clone();
+ }
+}
+
+Directory::~Directory() = default;
+
+nsIGlobalObject* Directory::GetParentObject() const { return mGlobal; }
+
+JSObject* Directory::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return Directory_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void Directory::GetName(nsAString& aRetval, ErrorResult& aRv) {
+ aRetval.Truncate();
+
+ RefPtr<FileSystemBase> fs = GetFileSystem(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ fs->GetDirectoryName(mFile, aRetval, aRv);
+}
+
+void Directory::GetPath(nsAString& aRetval, ErrorResult& aRv) {
+ // This operation is expensive. Better to cache the result.
+ if (mPath.IsEmpty()) {
+ RefPtr<FileSystemBase> fs = GetFileSystem(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ fs->GetDOMPath(mFile, mPath, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+ }
+
+ aRetval = mPath;
+}
+
+nsresult Directory::GetFullRealPath(nsAString& aPath) {
+ nsresult rv = mFile->GetPath(aPath);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+already_AddRefed<Promise> Directory::GetFilesAndDirectories(ErrorResult& aRv) {
+ RefPtr<FileSystemBase> fs = GetFileSystem(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<GetDirectoryListingTaskChild> task =
+ GetDirectoryListingTaskChild::Create(fs, this, mFile, mFilters, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ task->Start();
+
+ return task->GetPromise();
+}
+
+already_AddRefed<Promise> Directory::GetFiles(bool aRecursiveFlag,
+ ErrorResult& aRv) {
+ ErrorResult rv;
+ RefPtr<FileSystemBase> fs = GetFileSystem(rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return nullptr;
+ }
+
+ RefPtr<GetFilesTaskChild> task =
+ GetFilesTaskChild::Create(fs, this, mFile, aRecursiveFlag, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return nullptr;
+ }
+
+ task->Start();
+
+ return task->GetPromise();
+}
+
+void Directory::SetContentFilters(const nsAString& aFilters) {
+ mFilters = aFilters;
+}
+
+FileSystemBase* Directory::GetFileSystem(ErrorResult& aRv) {
+ if (!mFileSystem) {
+ nsAutoString path;
+ aRv = mFile->GetPath(path);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<OSFileSystem> fs = new OSFileSystem(path);
+ fs->Init(mGlobal);
+
+ mFileSystem = fs;
+ }
+
+ return mFileSystem;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/Directory.h b/dom/filesystem/Directory.h
new file mode 100644
index 0000000000..b8ee0e68e1
--- /dev/null
+++ b/dom/filesystem/Directory.h
@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_Directory_h
+#define mozilla_dom_Directory_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/File.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class FileSystemBase;
+class Promise;
+class StringOrFileOrDirectory;
+
+class Directory final : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(Directory)
+
+ static already_AddRefed<Directory> Constructor(const GlobalObject& aGlobal,
+ const nsAString& aRealPath,
+ ErrorResult& aRv);
+
+ static already_AddRefed<Directory> Create(nsIGlobalObject* aGlobal,
+ nsIFile* aDirectory,
+ FileSystemBase* aFileSystem = 0);
+
+ // ========= Begin WebIDL bindings. ===========
+
+ nsIGlobalObject* GetParentObject() const;
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ void GetName(nsAString& aRetval, ErrorResult& aRv);
+
+ // From
+ // https://microsoftedge.github.io/directory-upload/proposal.html#directory-interface
+ // :
+
+ void GetPath(nsAString& aRetval, ErrorResult& aRv);
+
+ nsresult GetFullRealPath(nsAString& aPath);
+
+ already_AddRefed<Promise> GetFilesAndDirectories(ErrorResult& aRv);
+
+ already_AddRefed<Promise> GetFiles(bool aRecursiveFlag, ErrorResult& aRv);
+
+ // =========== End WebIDL bindings.============
+
+ /**
+ * Sets a semi-colon separated list of filters to filter-in or filter-out
+ * certain types of files when the contents of this directory are requested
+ * via a GetFilesAndDirectories() call.
+ *
+ * Currently supported keywords:
+ *
+ * * filter-out-sensitive
+ * This keyword filters out files or directories that we don't wish to
+ * make available to Web content because we are concerned that there is
+ * a risk that users may unwittingly give Web content access to them
+ * and suffer undesirable consequences. The details of what is
+ * filtered out can be found in GetDirectoryListingTask::Work.
+ *
+ * In future, we will likely support filtering based on filename extensions
+ * (for example, aFilters could be "*.jpg; *.jpeg; *.gif"), but that isn't
+ * supported yet. Once supported, files that don't match a specified
+ * extension (if any are specified) would be filtered out. This
+ * functionality would allow us to apply the 'accept' attribute from
+ * <input type=file directory accept="..."> to the results of a directory
+ * picker operation.
+ */
+ void SetContentFilters(const nsAString& aFilters);
+
+ FileSystemBase* GetFileSystem(ErrorResult& aRv);
+
+ nsIFile* GetInternalNsIFile() const { return mFile; }
+
+ private:
+ Directory(nsIGlobalObject* aGlobal, nsIFile* aFile,
+ FileSystemBase* aFileSystem = nullptr);
+ ~Directory();
+
+ /*
+ * Convert relative DOM path to the absolute real path.
+ */
+ nsresult DOMPathToRealPath(const nsAString& aPath, nsIFile** aFile) const;
+
+ nsCOMPtr<nsIGlobalObject> mGlobal;
+ RefPtr<FileSystemBase> mFileSystem;
+ nsCOMPtr<nsIFile> mFile;
+
+ nsString mFilters;
+ nsString mPath;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_Directory_h
diff --git a/dom/filesystem/FileSystemBase.cpp b/dom/filesystem/FileSystemBase.cpp
new file mode 100644
index 0000000000..776ecc9db5
--- /dev/null
+++ b/dom/filesystem/FileSystemBase.cpp
@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/FileSystemBase.h"
+
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "nsIFile.h"
+#include "OSFileSystem.h"
+
+namespace mozilla::dom {
+
+FileSystemBase::FileSystemBase() : mShutdown(false) {}
+
+FileSystemBase::~FileSystemBase() { AssertIsOnOwningThread(); }
+
+void FileSystemBase::Shutdown() {
+ AssertIsOnOwningThread();
+ mShutdown = true;
+}
+
+nsIGlobalObject* FileSystemBase::GetParentObject() const {
+ AssertIsOnOwningThread();
+ return nullptr;
+}
+
+bool FileSystemBase::GetRealPath(BlobImpl* aFile, nsIFile** aPath) const {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aFile, "aFile Should not be null.");
+ MOZ_ASSERT(aPath);
+
+ nsAutoString filePath;
+ ErrorResult rv;
+ aFile->GetMozFullPathInternal(filePath, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ return false;
+ }
+
+ rv = NS_NewLocalFile(filePath, true, aPath);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ return false;
+ }
+
+ return true;
+}
+
+bool FileSystemBase::IsSafeFile(nsIFile* aFile) const {
+ AssertIsOnOwningThread();
+ return false;
+}
+
+bool FileSystemBase::IsSafeDirectory(Directory* aDir) const {
+ AssertIsOnOwningThread();
+ return false;
+}
+
+void FileSystemBase::GetDirectoryName(nsIFile* aFile, nsAString& aRetval,
+ ErrorResult& aRv) const {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aFile);
+
+ aRv = aFile->GetLeafName(aRetval);
+ NS_WARNING_ASSERTION(!aRv.Failed(), "GetLeafName failed");
+}
+
+void FileSystemBase::GetDOMPath(nsIFile* aFile, nsAString& aRetval,
+ ErrorResult& aRv) const {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aFile);
+
+ aRetval.Truncate();
+
+ nsCOMPtr<nsIFile> fileSystemPath;
+ aRv = NS_NewLocalFile(LocalRootPath(), true, getter_AddRefs(fileSystemPath));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ nsCOMPtr<nsIFile> path;
+ aRv = aFile->Clone(getter_AddRefs(path));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ nsTArray<nsString> parts;
+
+ while (true) {
+ nsAutoString leafName;
+ aRv = path->GetLeafName(leafName);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ if (!leafName.IsEmpty()) {
+ parts.AppendElement(leafName);
+ }
+
+ bool equal = false;
+ aRv = fileSystemPath->Equals(path, &equal);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ if (equal) {
+ break;
+ }
+
+ nsCOMPtr<nsIFile> parentPath;
+ aRv = path->GetParent(getter_AddRefs(parentPath));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(parentPath);
+
+ aRv = parentPath->Clone(getter_AddRefs(path));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+ }
+
+ if (parts.IsEmpty()) {
+ aRetval.AppendLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ return;
+ }
+
+ for (int32_t i = parts.Length() - 1; i >= 0; --i) {
+ aRetval.AppendLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ aRetval.Append(parts[i]);
+ }
+}
+
+void FileSystemBase::AssertIsOnOwningThread() const {
+ NS_ASSERT_OWNINGTHREAD(FileSystemBase);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/FileSystemBase.h b/dom/filesystem/FileSystemBase.h
new file mode 100644
index 0000000000..b78fe1736b
--- /dev/null
+++ b/dom/filesystem/FileSystemBase.h
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemBase_h
+#define mozilla_dom_FileSystemBase_h
+
+#include "nsString.h"
+#include "Directory.h"
+
+namespace mozilla::dom {
+
+class BlobImpl;
+
+class FileSystemBase {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(FileSystemBase)
+
+ FileSystemBase();
+
+ virtual void Shutdown();
+
+ // SerializeDOMPath the FileSystem to string.
+ virtual void SerializeDOMPath(nsAString& aOutput) const = 0;
+
+ virtual already_AddRefed<FileSystemBase> Clone() = 0;
+
+ virtual bool ShouldCreateDirectory() = 0;
+
+ virtual nsIGlobalObject* GetParentObject() const;
+
+ virtual void GetDirectoryName(nsIFile* aFile, nsAString& aRetval,
+ ErrorResult& aRv) const;
+
+ void GetDOMPath(nsIFile* aFile, nsAString& aRetval, ErrorResult& aRv) const;
+
+ /*
+ * Return the local root path of the FileSystem implementation.
+ * For OSFileSystem, this is equal to the path of the root Directory;
+ * For DeviceStorageFileSystem, this is the path of the SDCard, parent
+ * directory of the exposed root Directory (per type).
+ */
+ const nsAString& LocalRootPath() const { return mLocalRootPath; }
+
+ bool IsShutdown() const { return mShutdown; }
+
+ virtual bool IsSafeFile(nsIFile* aFile) const;
+
+ virtual bool IsSafeDirectory(Directory* aDir) const;
+
+ bool GetRealPath(BlobImpl* aFile, nsIFile** aPath) const;
+
+ // CC methods
+ virtual void Unlink() {}
+ virtual void Traverse(nsCycleCollectionTraversalCallback& cb) {}
+
+ void AssertIsOnOwningThread() const;
+
+ protected:
+ virtual ~FileSystemBase();
+
+ // The local path of the root (i.e. the OS path, with OS path separators, of
+ // the OS directory that acts as the root of this OSFileSystem).
+ // This path must be set by the FileSystem implementation immediately
+ // because it will be used for the validation of any FileSystemTaskChildBase.
+ // The concept of this path is that, any task will never go out of it and this
+ // must be considered the OS 'root' of the current FileSystem. Different
+ // Directory object can have different OS 'root' path.
+ // To be more clear, any path managed by this FileSystem implementation must
+ // be discendant of this local root path.
+ nsString mLocalRootPath;
+
+ bool mShutdown;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemBase_h
diff --git a/dom/filesystem/FileSystemRequestParent.cpp b/dom/filesystem/FileSystemRequestParent.cpp
new file mode 100644
index 0000000000..25211dbd23
--- /dev/null
+++ b/dom/filesystem/FileSystemRequestParent.cpp
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/FileSystemRequestParent.h"
+#include "mozilla/dom/PFileSystemParams.h"
+
+#include "GetDirectoryListingTask.h"
+#include "GetFileOrDirectoryTask.h"
+#include "GetFilesTask.h"
+
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemSecurity.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/dom/OSFileSystem.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Unused.h"
+#include "nsProxyRelease.h"
+
+using namespace mozilla::ipc;
+
+namespace mozilla::dom {
+
+FileSystemRequestParent::FileSystemRequestParent() : mDestroyed(false) {
+ AssertIsOnBackgroundThread();
+}
+
+FileSystemRequestParent::~FileSystemRequestParent() {
+ AssertIsOnBackgroundThread();
+}
+
+#define FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(name) \
+ case FileSystemParams::TFileSystem##name##Params: { \
+ const FileSystem##name##Params& p = aParams; \
+ mFileSystem = new OSFileSystemParent(p.filesystem()); \
+ MOZ_ASSERT(mFileSystem); \
+ mTask = name##TaskParent::Create(mFileSystem, p, this, rv); \
+ if (NS_WARN_IF(rv.Failed())) { \
+ rv.SuppressException(); \
+ return false; \
+ } \
+ break; \
+ }
+
+bool FileSystemRequestParent::Initialize(const FileSystemParams& aParams) {
+ AssertIsOnBackgroundThread();
+
+ ErrorResult rv;
+
+ switch (aParams.type()) {
+ FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetDirectoryListing)
+ FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetFileOrDirectory)
+ FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetFiles)
+
+ default: {
+ MOZ_CRASH("not reached");
+ break;
+ }
+ }
+
+ if (NS_WARN_IF(!mTask || !mFileSystem)) {
+ // Should never reach here.
+ return false;
+ }
+
+ return true;
+}
+
+namespace {
+
+class CheckPermissionRunnable final : public Runnable {
+ public:
+ CheckPermissionRunnable(
+ already_AddRefed<ThreadsafeContentParentHandle> aParent,
+ FileSystemRequestParent* aActor, FileSystemTaskParentBase* aTask,
+ const nsAString& aPath)
+ : Runnable("dom::CheckPermissionRunnable"),
+ mContentHandle(aParent),
+ mActor(aActor),
+ mTask(aTask),
+ mPath(aPath),
+ mBackgroundEventTarget(GetCurrentSerialEventTarget()) {
+ AssertIsInMainProcess();
+ AssertIsOnBackgroundThread();
+
+ MOZ_ASSERT(mContentHandle);
+ MOZ_ASSERT(mActor);
+ MOZ_ASSERT(mTask);
+ MOZ_ASSERT(mBackgroundEventTarget);
+ }
+
+ NS_IMETHOD
+ Run() override {
+ if (NS_IsMainThread()) {
+ if (!mozilla::Preferences::GetBool("dom.filesystem.pathcheck.disabled",
+ false)) {
+ RefPtr<FileSystemSecurity> fss = FileSystemSecurity::Get();
+ if (NS_WARN_IF(!fss || !fss->ContentProcessHasAccessTo(
+ mContentHandle->ChildID(), mPath))) {
+ AssertIsOnMainThread();
+ if (RefPtr<ContentParent> contentParent =
+ mContentHandle->GetContentParent()) {
+ contentParent->KillHard("This path is not allowed.");
+ }
+ return NS_OK;
+ }
+ }
+
+ return mBackgroundEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
+ }
+
+ AssertIsOnBackgroundThread();
+
+ // It can happen that this actor has been destroyed in the meantime we were
+ // on the main-thread.
+ if (!mActor->Destroyed()) {
+ mTask->Start();
+ }
+
+ return NS_OK;
+ }
+
+ private:
+ ~CheckPermissionRunnable() {
+ NS_ProxyRelease("CheckPermissionRunnable::mActor", mBackgroundEventTarget,
+ mActor.forget());
+ }
+
+ RefPtr<ThreadsafeContentParentHandle> mContentHandle;
+ RefPtr<FileSystemRequestParent> mActor;
+ RefPtr<FileSystemTaskParentBase> mTask;
+ const nsString mPath;
+
+ nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
+};
+
+} // namespace
+
+void FileSystemRequestParent::Start() {
+ AssertIsInMainProcess();
+ AssertIsOnBackgroundThread();
+
+ MOZ_ASSERT(!mDestroyed);
+ MOZ_ASSERT(mFileSystem);
+ MOZ_ASSERT(mTask);
+
+ nsAutoString path;
+ if (NS_WARN_IF(NS_FAILED(mTask->GetTargetPath(path)))) {
+ (void)Send__delete__(this,
+ FileSystemErrorResponse(NS_ERROR_DOM_SECURITY_ERR));
+ return;
+ }
+
+ RefPtr<ThreadsafeContentParentHandle> parent =
+ BackgroundParent::GetContentParentHandle(Manager());
+
+ // If the ThreadsafeContentParentHandle is null we are dealing with a
+ // same-process actor.
+ if (!parent) {
+ mTask->Start();
+ return;
+ }
+
+ RefPtr<Runnable> runnable =
+ new CheckPermissionRunnable(parent.forget(), this, mTask, path);
+ NS_DispatchToMainThread(runnable);
+}
+
+void FileSystemRequestParent::ActorDestroy(ActorDestroyReason aWhy) {
+ AssertIsOnBackgroundThread();
+ MOZ_ASSERT(!mDestroyed);
+
+ if (!mFileSystem) {
+ return;
+ }
+
+ mFileSystem->Shutdown();
+ mFileSystem = nullptr;
+ mTask = nullptr;
+ mDestroyed = true;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/FileSystemRequestParent.h b/dom/filesystem/FileSystemRequestParent.h
new file mode 100644
index 0000000000..7ac1547d27
--- /dev/null
+++ b/dom/filesystem/FileSystemRequestParent.h
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemRequestParent_h
+#define mozilla_dom_FileSystemRequestParent_h
+
+#include "mozilla/dom/PFileSystemRequestParent.h"
+#include "mozilla/dom/FileSystemBase.h"
+
+namespace mozilla::dom {
+
+class FileSystemParams;
+class FileSystemTaskParentBase;
+
+class FileSystemRequestParent final : public PFileSystemRequestParent {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FileSystemRequestParent, final)
+
+ public:
+ FileSystemRequestParent();
+
+ bool Initialize(const FileSystemParams& aParams);
+
+ void Start();
+
+ bool Destroyed() const { return mDestroyed; }
+
+ virtual void ActorDestroy(ActorDestroyReason why) override;
+
+ private:
+ ~FileSystemRequestParent();
+
+ RefPtr<FileSystemBase> mFileSystem;
+ RefPtr<FileSystemTaskParentBase> mTask;
+
+ bool mDestroyed;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemRequestParent_h
diff --git a/dom/filesystem/FileSystemSecurity.cpp b/dom/filesystem/FileSystemSecurity.cpp
new file mode 100644
index 0000000000..b9468270d4
--- /dev/null
+++ b/dom/filesystem/FileSystemSecurity.cpp
@@ -0,0 +1,106 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemSecurity.h"
+#include "FileSystemUtils.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/StaticPtr.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+StaticRefPtr<FileSystemSecurity> gFileSystemSecurity;
+
+} // namespace
+
+/* static */
+already_AddRefed<FileSystemSecurity> FileSystemSecurity::Get() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+
+ RefPtr<FileSystemSecurity> service = gFileSystemSecurity.get();
+ return service.forget();
+}
+
+/* static */
+already_AddRefed<FileSystemSecurity> FileSystemSecurity::GetOrCreate() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+
+ if (!gFileSystemSecurity) {
+ gFileSystemSecurity = new FileSystemSecurity();
+ ClearOnShutdown(&gFileSystemSecurity);
+ }
+
+ RefPtr<FileSystemSecurity> service = gFileSystemSecurity.get();
+ return service.forget();
+}
+
+FileSystemSecurity::FileSystemSecurity() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+}
+
+FileSystemSecurity::~FileSystemSecurity() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+}
+
+void FileSystemSecurity::GrantAccessToContentProcess(
+ ContentParentId aId, const nsAString& aDirectoryPath) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+
+ mPaths.WithEntryHandle(aId, [&](auto&& entry) {
+ if (entry && entry.Data()->Contains(aDirectoryPath)) {
+ return;
+ }
+
+ entry.OrInsertWith([] { return MakeUnique<nsTArray<nsString>>(); })
+ ->AppendElement(aDirectoryPath);
+ });
+}
+
+void FileSystemSecurity::Forget(ContentParentId aId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+
+ mPaths.Remove(aId);
+}
+
+bool FileSystemSecurity::ContentProcessHasAccessTo(ContentParentId aId,
+ const nsAString& aPath) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mozilla::ipc::AssertIsInMainProcess();
+
+#if defined(XP_WIN)
+ if (StringBeginsWith(aPath, u"..\\"_ns) ||
+ FindInReadable(u"\\..\\"_ns, aPath)) {
+ return false;
+ }
+#elif defined(XP_UNIX)
+ if (StringBeginsWith(aPath, u"../"_ns) || FindInReadable(u"/../"_ns, aPath)) {
+ return false;
+ }
+#endif
+
+ nsTArray<nsString>* paths;
+ if (!mPaths.Get(aId, &paths)) {
+ return false;
+ }
+
+ for (uint32_t i = 0, len = paths->Length(); i < len; ++i) {
+ if (FileSystemUtils::IsDescendantPath(paths->ElementAt(i), aPath)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/FileSystemSecurity.h b/dom/filesystem/FileSystemSecurity.h
new file mode 100644
index 0000000000..381d156777
--- /dev/null
+++ b/dom/filesystem/FileSystemSecurity.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemSecurity_h
+#define mozilla_dom_FileSystemSecurity_h
+
+#include "mozilla/dom/ipc/IdType.h"
+#include "nsClassHashtable.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla::dom {
+
+class FileSystemSecurity final {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(FileSystemSecurity)
+
+ static already_AddRefed<FileSystemSecurity> Get();
+
+ static already_AddRefed<FileSystemSecurity> GetOrCreate();
+
+ void GrantAccessToContentProcess(ContentParentId aId,
+ const nsAString& aDirectoryPath);
+
+ void Forget(ContentParentId aId);
+
+ bool ContentProcessHasAccessTo(ContentParentId aId, const nsAString& aPath);
+
+ private:
+ FileSystemSecurity();
+ ~FileSystemSecurity();
+
+ nsClassHashtable<nsUint64HashKey, nsTArray<nsString>> mPaths;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemSecurity_h
diff --git a/dom/filesystem/FileSystemTaskBase.cpp b/dom/filesystem/FileSystemTaskBase.cpp
new file mode 100644
index 0000000000..34cfd8f018
--- /dev/null
+++ b/dom/filesystem/FileSystemTaskBase.cpp
@@ -0,0 +1,246 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/FileSystemTaskBase.h"
+
+#include "nsNetCID.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemRequestParent.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "mozilla/Unused.h"
+#include "nsProxyRelease.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+nsresult FileSystemErrorFromNsError(const nsresult& aErrorValue) {
+ uint16_t module = NS_ERROR_GET_MODULE(aErrorValue);
+ if (module == NS_ERROR_MODULE_DOM_FILESYSTEM ||
+ module == NS_ERROR_MODULE_DOM_FILE || module == NS_ERROR_MODULE_DOM) {
+ return aErrorValue;
+ }
+
+ switch (aErrorValue) {
+ case NS_OK:
+ return NS_OK;
+
+ case NS_ERROR_FILE_INVALID_PATH:
+ case NS_ERROR_FILE_UNRECOGNIZED_PATH:
+ return NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR;
+
+ case NS_ERROR_FILE_DESTINATION_NOT_DIR:
+ return NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR;
+
+ case NS_ERROR_FILE_ACCESS_DENIED:
+ case NS_ERROR_FILE_DIR_NOT_EMPTY:
+ return NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR;
+
+ case NS_ERROR_FILE_NOT_FOUND:
+ case NS_ERROR_NOT_AVAILABLE:
+ return NS_ERROR_DOM_FILE_NOT_FOUND_ERR;
+
+ case NS_ERROR_FILE_ALREADY_EXISTS:
+ return NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR;
+
+ case NS_ERROR_FILE_NOT_DIRECTORY:
+ return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;
+
+ case NS_ERROR_UNEXPECTED:
+ default:
+ return NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR;
+ }
+}
+
+nsresult DispatchToIOThread(nsIRunnable* aRunnable) {
+ MOZ_ASSERT(aRunnable);
+
+ nsCOMPtr<nsIEventTarget> target =
+ do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+ MOZ_ASSERT(target);
+
+ return target->Dispatch(aRunnable, NS_DISPATCH_NORMAL);
+}
+
+} // anonymous namespace
+
+/**
+ * FileSystemTaskBase class
+ */
+
+FileSystemTaskChildBase::FileSystemTaskChildBase(nsIGlobalObject* aGlobalObject,
+ FileSystemBase* aFileSystem)
+ : mErrorValue(NS_OK),
+ mFileSystem(aFileSystem),
+ mGlobalObject(aGlobalObject) {
+ MOZ_ASSERT(aFileSystem, "aFileSystem should not be null.");
+ aFileSystem->AssertIsOnOwningThread();
+ MOZ_ASSERT(aGlobalObject);
+}
+
+FileSystemTaskChildBase::~FileSystemTaskChildBase() {
+ mFileSystem->AssertIsOnOwningThread();
+}
+
+FileSystemBase* FileSystemTaskChildBase::GetFileSystem() const {
+ mFileSystem->AssertIsOnOwningThread();
+ return mFileSystem.get();
+}
+
+void FileSystemTaskChildBase::Start() {
+ mFileSystem->AssertIsOnOwningThread();
+
+ mozilla::ipc::PBackgroundChild* actor =
+ mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
+ if (NS_WARN_IF(!actor)) {
+ // We are probably shutting down.
+ return;
+ }
+
+ nsAutoString serialization;
+ mFileSystem->SerializeDOMPath(serialization);
+
+ ErrorResult rv;
+ FileSystemParams params = GetRequestParams(serialization, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ return;
+ }
+
+ actor->SendPFileSystemRequestConstructor(this, params);
+}
+
+void FileSystemTaskChildBase::SetRequestResult(
+ const FileSystemResponseValue& aValue) {
+ mFileSystem->AssertIsOnOwningThread();
+
+ if (aValue.type() == FileSystemResponseValue::TFileSystemErrorResponse) {
+ FileSystemErrorResponse r = aValue;
+ mErrorValue = r.error();
+ } else {
+ ErrorResult rv;
+ SetSuccessRequestResult(aValue, rv);
+ mErrorValue = rv.StealNSResult();
+ }
+}
+
+mozilla::ipc::IPCResult FileSystemTaskChildBase::Recv__delete__(
+ const FileSystemResponseValue& aValue) {
+ mFileSystem->AssertIsOnOwningThread();
+
+ SetRequestResult(aValue);
+ HandlerCallback();
+ return IPC_OK();
+}
+
+void FileSystemTaskChildBase::SetError(const nsresult& aErrorValue) {
+ mErrorValue = FileSystemErrorFromNsError(aErrorValue);
+}
+
+/**
+ * FileSystemTaskParentBase class
+ */
+
+FileSystemTaskParentBase::FileSystemTaskParentBase(
+ FileSystemBase* aFileSystem, const FileSystemParams& aParam,
+ FileSystemRequestParent* aParent)
+ : Runnable("dom::FileSystemTaskParentBase"),
+ mErrorValue(NS_OK),
+ mFileSystem(aFileSystem),
+ mRequestParent(aParent),
+ mBackgroundEventTarget(GetCurrentSerialEventTarget()) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ MOZ_ASSERT(aFileSystem, "aFileSystem should not be null.");
+ MOZ_ASSERT(aParent);
+ MOZ_ASSERT(mBackgroundEventTarget);
+ mozilla::ipc::AssertIsOnBackgroundThread();
+}
+
+FileSystemTaskParentBase::~FileSystemTaskParentBase() {
+ // This task can be released on different threads because we dispatch it (as
+ // runnable) to main-thread, I/O and then back to the PBackground thread.
+ NS_ProxyRelease("FileSystemTaskParentBase::mFileSystem",
+ mBackgroundEventTarget, mFileSystem.forget());
+ NS_ProxyRelease("FileSystemTaskParentBase::mRequestParent",
+ mBackgroundEventTarget, mRequestParent.forget());
+}
+
+void FileSystemTaskParentBase::Start() {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ mFileSystem->AssertIsOnOwningThread();
+
+ DebugOnly<nsresult> rv = DispatchToIOThread(this);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "DispatchToIOThread failed");
+}
+
+void FileSystemTaskParentBase::HandleResult() {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ mFileSystem->AssertIsOnOwningThread();
+
+ if (mFileSystem->IsShutdown()) {
+ return;
+ }
+
+ MOZ_ASSERT(mRequestParent);
+ (void)mRequestParent->Send__delete__(mRequestParent, GetRequestResult());
+}
+
+FileSystemResponseValue FileSystemTaskParentBase::GetRequestResult() const {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ mFileSystem->AssertIsOnOwningThread();
+
+ if (HasError()) {
+ return FileSystemErrorResponse(mErrorValue);
+ }
+
+ ErrorResult rv;
+ FileSystemResponseValue value = GetSuccessRequestResult(rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return FileSystemErrorResponse(rv.StealNSResult());
+ }
+
+ return value;
+}
+
+void FileSystemTaskParentBase::SetError(const nsresult& aErrorValue) {
+ mErrorValue = FileSystemErrorFromNsError(aErrorValue);
+}
+
+NS_IMETHODIMP
+FileSystemTaskParentBase::Run() {
+ // This method can run in 2 different threads. Here why:
+ // 1. We are are on the I/O thread and we call IOWork().
+ // 2. After step 1, it returns back to the PBackground thread.
+
+ // Run I/O thread tasks
+ if (!mozilla::ipc::IsOnBackgroundThread()) {
+ nsresult rv = IOWork();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ SetError(rv);
+ }
+
+ // Let's go back to PBackground thread to finish the work.
+ rv = mBackgroundEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+ }
+
+ // If we are here, it's because the I/O work has been done and we have to
+ // handle the result back via IPC.
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ HandleResult();
+ return NS_OK;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/FileSystemTaskBase.h b/dom/filesystem/FileSystemTaskBase.h
new file mode 100644
index 0000000000..3d440403cc
--- /dev/null
+++ b/dom/filesystem/FileSystemTaskBase.h
@@ -0,0 +1,254 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemTaskBase_h
+#define mozilla_dom_FileSystemTaskBase_h
+
+#include "mozilla/dom/FileSystemRequestParent.h"
+#include "mozilla/dom/PFileSystemRequestChild.h"
+#include "nsIGlobalObject.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class BlobImpl;
+class FileSystemBase;
+class FileSystemParams;
+
+/*
+ * The base class to implement a Task class.
+ * The file system operations can only be performed in the parent process. In
+ * order to avoid duplicated code, we used PBackground for child-parent and
+ * parent-parent communications.
+ *
+ * The following diagram illustrates the how a API call from the content page
+ * starts a task and gets call back results.
+ *
+ * The left block is the call sequence inside any process loading content, while
+ * the right block is the call sequence only inside the parent process.
+ *
+ * Page
+ * |
+ * | (1)
+ * ______|_________________________ | _________________________________
+ * | | | | | |
+ * | | | | | |
+ * | V | IPC | PBackground thread on |
+ * | [new FileSystemTaskChildBase()] | | | the parent process |
+ * | | | | | |
+ * | | (2) | | |
+ * | V | (3) | |
+ * | [GetRequestParams]------------------->[new FileSystemTaskParentBase()] |
+ * | | | | |
+ * | | | | | (4) _____________ |
+ * | | | | | | | |
+ * | | | | | | I/O Thread | |
+ * | | | | | | | |
+ * | | | | ---------> [IOWork] | |
+ * | | IPC | | | | |
+ * | | | | | | (5) | |
+ * | | | | -------------- | |
+ * | | | | | |_____________| |
+ * | | | | | |
+ * | | | | V |
+ * | | | | [HandleResult] |
+ * | | | | | |
+ * | | | | (6) |
+ * | | (7) | V |
+ * | [SetRequestResult]<---------------------[GetRequestResult] |
+ * | | | | |
+ * | | (8) | | | |
+ * | V | | | |
+ * |[HandlerCallback] | IPC | |
+ * |_______|_________________________| | |_________________________________|
+ * | |
+ * V
+ * Page
+ *
+ * 1. From the process that is handling the request
+ * Child/Parent (it can be in any process):
+ * (1) Call FileSystem API from content page with JS. Create a task and run.
+ * The base constructor [FileSystemTaskChildBase()] of the task should be
+ * called.
+ * (2) Forward the task to the parent process through the IPC and call
+ * [GetRequestParams] to prepare the parameters of the IPC.
+ * Parent:
+ * (3) The parent process receives IPC and handle it in
+ * FileystemRequestParent. Get the IPC parameters and create a task to run the
+ * IPC task.
+ * (4) The task operation will be performed in the member function of
+ * [IOWork]. A I/O thread will be created to run that function. If error occurs
+ * during the operation, call [SetError] to record the error and then abort.
+ * (5) After finishing the task operation, call [HandleResult] to send the
+ * result back to the child process though the IPC.
+ * (6) Call [GetRequestResult] request result to prepare the parameters of the
+ * IPC. Because the formats of the error result for different task are the
+ * same, FileSystemTaskChildBase can handle the error message without
+ * interfering.
+ * Each task only needs to implement its specific success result preparation
+ * function -[GetSuccessRequestResult].
+ * Child/Parent:
+ * (7) The process receives IPC and calls [SetRequestResult] to get the
+ * task result. Each task needs to implement its specific success result
+ * parsing function [SetSuccessRequestResult] to get the success result.
+ * (8) Call [HandlerCallback] to send the task result to the content page.
+ */
+class FileSystemTaskChildBase : public PFileSystemRequestChild {
+ friend class PFileSystemRequestChild;
+
+ public:
+ NS_INLINE_DECL_REFCOUNTING(FileSystemTaskChildBase, final)
+
+ /*
+ * Start the task. It will dispatch all the information to the parent process,
+ * PBackground thread. This method must be called from the owning thread.
+ */
+ void Start();
+
+ /*
+ * The error codes are defined in xpcom/base/ErrorList.h and their
+ * corresponding error name and message are defined in dom/base/domerr.msg.
+ */
+ void SetError(const nsresult& aErrorCode);
+
+ FileSystemBase* GetFileSystem() const;
+
+ /*
+ * After the task is completed, this function will be called to pass the task
+ * result to the content page. This method is called in the owning thread.
+ * Override this function to handle the call back to the content page.
+ */
+ virtual void HandlerCallback() = 0;
+
+ bool HasError() const { return NS_FAILED(mErrorValue); }
+
+ protected:
+ /*
+ * To create a task to handle the page content request.
+ */
+ FileSystemTaskChildBase(nsIGlobalObject* aGlobalObject,
+ FileSystemBase* aFileSystem);
+
+ virtual ~FileSystemTaskChildBase();
+
+ /*
+ * Wrap the task parameter to FileSystemParams for sending it through IPC.
+ * It will be called when we need to forward a task from the child process to
+ * the parent process. This method runs in the owning thread.
+ * @param filesystem The string representation of the file system.
+ */
+ virtual FileSystemParams GetRequestParams(const nsString& aSerializedDOMPath,
+ ErrorResult& aRv) const = 0;
+
+ /*
+ * Unwrap the IPC message to get the task success result.
+ * It will be called when the task is completed successfully and an IPC
+ * message is received in the child process and we want to get the task
+ * success result. This method runs in the owning thread.
+ */
+ virtual void SetSuccessRequestResult(const FileSystemResponseValue& aValue,
+ ErrorResult& aRv) = 0;
+
+ // Overrides PFileSystemRequestChild
+ virtual mozilla::ipc::IPCResult Recv__delete__(
+ const FileSystemResponseValue& value) final;
+
+ nsresult mErrorValue;
+ RefPtr<FileSystemBase> mFileSystem;
+ nsCOMPtr<nsIGlobalObject> mGlobalObject;
+
+ private:
+ /*
+ * Unwrap the IPC message to get the task result.
+ * It will be called when the task is completed and an IPC message is received
+ * in the content process and we want to get the task result. This runs on the
+ * owning thread.
+ */
+ void SetRequestResult(const FileSystemResponseValue& aValue);
+};
+
+// This class is the 'alter ego' of FileSystemTaskChildBase in the PBackground
+// world.
+class FileSystemTaskParentBase : public Runnable {
+ public:
+ FileSystemTaskParentBase()
+ : Runnable("FileSystemTaskParentBase"),
+ mErrorValue(NS_ERROR_NOT_INITIALIZED) {}
+
+ /*
+ * Start the task. This must be called from the PBackground thread only.
+ */
+ void Start();
+
+ /*
+ * The error codes are defined in xpcom/base/ErrorList.h and their
+ * corresponding error name and message are defined in dom/base/domerr.msg.
+ */
+ void SetError(const nsresult& aErrorCode);
+
+ /*
+ * The function to perform task operation. It will be run on the I/O
+ * thread of the parent process.
+ * Overrides this function to define the task operation for individual task.
+ */
+ virtual nsresult IOWork() = 0;
+
+ /*
+ * Wrap the task success result to FileSystemResponseValue for sending it
+ * through IPC. This method runs in the PBackground thread.
+ * It will be called when the task is completed successfully and we need to
+ * send the task success result back to the child process.
+ */
+ virtual FileSystemResponseValue GetSuccessRequestResult(
+ ErrorResult& aRv) const = 0;
+
+ /*
+ * After finishing the task operation, handle the task result.
+ * If it is an IPC task, send back the IPC result. It runs on the PBackground
+ * thread.
+ */
+ void HandleResult();
+
+ bool HasError() const { return NS_FAILED(mErrorValue); }
+
+ NS_IMETHOD
+ Run() override;
+
+ virtual nsresult GetTargetPath(nsAString& aPath) const = 0;
+
+ private:
+ /*
+ * Wrap the task result to FileSystemResponseValue for sending it through IPC.
+ * It will be called when the task is completed and we need to
+ * send the task result back to the content. This runs on the PBackground
+ * thread.
+ */
+ FileSystemResponseValue GetRequestResult() const;
+
+ protected:
+ /*
+ * To create a parent process task delivered from the child process through
+ * IPC.
+ */
+ FileSystemTaskParentBase(FileSystemBase* aFileSystem,
+ const FileSystemParams& aParam,
+ FileSystemRequestParent* aParent);
+
+ virtual ~FileSystemTaskParentBase();
+
+ nsresult mErrorValue;
+ RefPtr<FileSystemBase> mFileSystem;
+ RefPtr<FileSystemRequestParent> mRequestParent;
+ nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_FileSystemTaskBase_h
diff --git a/dom/filesystem/FileSystemUtils.cpp b/dom/filesystem/FileSystemUtils.cpp
new file mode 100644
index 0000000000..136f683e5e
--- /dev/null
+++ b/dom/filesystem/FileSystemUtils.cpp
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/FileSystemUtils.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "nsIEventTarget.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla::dom {
+
+/* static */
+bool FileSystemUtils::IsDescendantPath(const nsAString& aPath,
+ const nsAString& aDescendantPath) {
+ // Check the sub-directory path to see if it has the parent path as prefix.
+ if (!aDescendantPath.Equals(aPath) &&
+ !StringBeginsWith(aDescendantPath, aPath)) {
+ return false;
+ }
+
+ return true;
+}
+
+/* static */
+bool FileSystemUtils::IsValidRelativeDOMPath(const nsAString& aPath,
+ nsTArray<nsString>& aParts) {
+ // We don't allow empty relative path to access the root.
+ if (aPath.IsEmpty()) {
+ return false;
+ }
+
+ // Leading and trailing "/" are not allowed.
+ if (aPath.First() == FILESYSTEM_DOM_PATH_SEPARATOR_CHAR ||
+ aPath.Last() == FILESYSTEM_DOM_PATH_SEPARATOR_CHAR) {
+ return false;
+ }
+
+ constexpr auto kCurrentDir = u"."_ns;
+ constexpr auto kParentDir = u".."_ns;
+
+ // Split path and check each path component.
+ for (const nsAString& pathComponent :
+ nsCharSeparatedTokenizerTemplate<NS_TokenizerIgnoreNothing>{
+ aPath, FILESYSTEM_DOM_PATH_SEPARATOR_CHAR}
+ .ToRange()) {
+ // The path containing empty components, such as "foo//bar", is invalid.
+ // We don't allow paths, such as "../foo", "foo/./bar" and "foo/../bar",
+ // to walk up the directory.
+ if (pathComponent.IsEmpty() || pathComponent.Equals(kCurrentDir) ||
+ pathComponent.Equals(kParentDir)) {
+ return false;
+ }
+
+ aParts.AppendElement(pathComponent);
+ }
+
+ return true;
+}
+
+/* static */
+nsresult FileSystemUtils::DispatchRunnable(
+ nsIGlobalObject* aGlobal, already_AddRefed<nsIRunnable>&& aRunnable) {
+ nsCOMPtr<nsIRunnable> runnable = aRunnable;
+
+ nsCOMPtr<nsIEventTarget> target;
+ if (!aGlobal) {
+ target = GetMainThreadSerialEventTarget();
+ } else {
+ target = aGlobal->SerialEventTarget();
+ }
+
+ MOZ_ASSERT(target);
+
+ nsresult rv = target->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/FileSystemUtils.h b/dom/filesystem/FileSystemUtils.h
new file mode 100644
index 0000000000..7f82e8474f
--- /dev/null
+++ b/dom/filesystem/FileSystemUtils.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemUtils_h
+#define mozilla_dom_FileSystemUtils_h
+
+#include "nsIGlobalObject.h"
+#include "nsStringFwd.h"
+#include "nsTArray.h"
+
+class nsIFile;
+class nsIRunnable;
+
+namespace mozilla::dom {
+
+#define FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL "/"
+#define FILESYSTEM_DOM_PATH_SEPARATOR_CHAR '/'
+
+/*
+ * This class is for error handling.
+ * All methods in this class are static.
+ */
+class FileSystemUtils {
+ public:
+ /*
+ * Return true if aDescendantPath is a descendant of aPath.
+ */
+ static bool IsDescendantPath(const nsAString& aPath,
+ const nsAString& aDescendantPath);
+
+ /**
+ * Return true if this is valid DOMPath. It also splits the path in
+ * subdirectories and stores them in aParts.
+ */
+ static bool IsValidRelativeDOMPath(const nsAString& aPath,
+ nsTArray<nsString>& aParts);
+
+ /**
+ * Helper method. If aGlobal is null, the SystemGroup EventTarget will be
+ * used.
+ */
+ static nsresult DispatchRunnable(nsIGlobalObject* aGlobal,
+ already_AddRefed<nsIRunnable>&& aRunnable);
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemUtils_h
diff --git a/dom/filesystem/GetDirectoryListingTask.cpp b/dom/filesystem/GetDirectoryListingTask.cpp
new file mode 100644
index 0000000000..f78a04a9d0
--- /dev/null
+++ b/dom/filesystem/GetDirectoryListingTask.cpp
@@ -0,0 +1,371 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "GetDirectoryListingTask.h"
+
+#include "HTMLSplitOnSpacesTokenizer.h"
+#include "js/Value.h"
+#include "mozilla/dom/FileBlobImpl.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/dom/PFileSystemParams.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "nsIFile.h"
+#include "nsString.h"
+
+namespace mozilla::dom {
+
+/**
+ * GetDirectoryListingTaskChild
+ */
+
+/* static */
+already_AddRefed<GetDirectoryListingTaskChild>
+GetDirectoryListingTaskChild::Create(FileSystemBase* aFileSystem,
+ Directory* aDirectory,
+ nsIFile* aTargetPath,
+ const nsAString& aFilters,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(aFileSystem);
+ MOZ_ASSERT(aDirectory);
+ aFileSystem->AssertIsOnOwningThread();
+
+ nsCOMPtr<nsIGlobalObject> globalObject = aFileSystem->GetParentObject();
+ MOZ_ASSERT(globalObject);
+
+ RefPtr<GetDirectoryListingTaskChild> task = new GetDirectoryListingTaskChild(
+ globalObject, aFileSystem, aDirectory, aTargetPath, aFilters);
+
+ // aTargetPath can be null. In this case SetError will be called.
+
+ task->mPromise = Promise::Create(globalObject, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetDirectoryListingTaskChild::GetDirectoryListingTaskChild(
+ nsIGlobalObject* aGlobalObject, FileSystemBase* aFileSystem,
+ Directory* aDirectory, nsIFile* aTargetPath, const nsAString& aFilters)
+ : FileSystemTaskChildBase(aGlobalObject, aFileSystem),
+ mDirectory(aDirectory),
+ mTargetPath(aTargetPath),
+ mFilters(aFilters) {
+ MOZ_ASSERT(aFileSystem);
+ aFileSystem->AssertIsOnOwningThread();
+}
+
+GetDirectoryListingTaskChild::~GetDirectoryListingTaskChild() {
+ mFileSystem->AssertIsOnOwningThread();
+}
+
+already_AddRefed<Promise> GetDirectoryListingTaskChild::GetPromise() {
+ mFileSystem->AssertIsOnOwningThread();
+ return RefPtr<Promise>(mPromise).forget();
+}
+
+FileSystemParams GetDirectoryListingTaskChild::GetRequestParams(
+ const nsString& aSerializedDOMPath, ErrorResult& aRv) const {
+ mFileSystem->AssertIsOnOwningThread();
+
+ // this is the real path.
+ nsAutoString path;
+ aRv = mTargetPath->GetPath(path);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemGetDirectoryListingParams();
+ }
+
+ // this is the dom path.
+ nsAutoString directoryPath;
+ mDirectory->GetPath(directoryPath, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemGetDirectoryListingParams();
+ }
+
+ return FileSystemGetDirectoryListingParams(aSerializedDOMPath, path,
+ directoryPath, mFilters);
+}
+
+void GetDirectoryListingTaskChild::SetSuccessRequestResult(
+ const FileSystemResponseValue& aValue, ErrorResult& aRv) {
+ mFileSystem->AssertIsOnOwningThread();
+ MOZ_ASSERT(aValue.type() ==
+ FileSystemResponseValue::TFileSystemDirectoryListingResponse);
+
+ FileSystemDirectoryListingResponse r = aValue;
+ for (uint32_t i = 0; i < r.data().Length(); ++i) {
+ const FileSystemDirectoryListingResponseData& data = r.data()[i];
+
+ OwningFileOrDirectory* ofd = mTargetData.AppendElement(fallible);
+ if (!ofd) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return;
+ }
+
+ if (data.type() == FileSystemDirectoryListingResponseData::
+ TFileSystemDirectoryListingResponseFile) {
+ const FileSystemDirectoryListingResponseFile& d =
+ data.get_FileSystemDirectoryListingResponseFile();
+
+ RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(d.blob());
+ MOZ_ASSERT(blobImpl);
+
+ nsCOMPtr<nsIGlobalObject> globalObject = mFileSystem->GetParentObject();
+ MOZ_ASSERT(globalObject);
+
+ RefPtr<File> file = File::Create(globalObject, blobImpl);
+ MOZ_ASSERT(file);
+
+ ofd->SetAsFile() = file;
+ } else {
+ MOZ_ASSERT(data.type() ==
+ FileSystemDirectoryListingResponseData::
+ TFileSystemDirectoryListingResponseDirectory);
+ const FileSystemDirectoryListingResponseDirectory& d =
+ data.get_FileSystemDirectoryListingResponseDirectory();
+
+ nsCOMPtr<nsIFile> path;
+ aRv = NS_NewLocalFile(d.directoryRealPath(), true, getter_AddRefs(path));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ RefPtr<Directory> directory =
+ Directory::Create(mFileSystem->GetParentObject(), path, mFileSystem);
+ MOZ_ASSERT(directory);
+
+ ofd->SetAsDirectory() = directory;
+ }
+ }
+}
+
+void GetDirectoryListingTaskChild::HandlerCallback() {
+ mFileSystem->AssertIsOnOwningThread();
+
+ if (mFileSystem->IsShutdown()) {
+ mPromise = nullptr;
+ return;
+ }
+
+ if (HasError()) {
+ mPromise->MaybeReject(mErrorValue);
+ mPromise = nullptr;
+ return;
+ }
+
+ mPromise->MaybeResolve(mTargetData);
+ mPromise = nullptr;
+}
+
+/**
+ * GetDirectoryListingTaskParent
+ */
+
+/* static */
+already_AddRefed<GetDirectoryListingTaskParent>
+GetDirectoryListingTaskParent::Create(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetDirectoryListingParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+
+ RefPtr<GetDirectoryListingTaskParent> task =
+ new GetDirectoryListingTaskParent(aFileSystem, aParam, aParent);
+
+ aRv = NS_NewLocalFile(aParam.realPath(), true,
+ getter_AddRefs(task->mTargetPath));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetDirectoryListingTaskParent::GetDirectoryListingTaskParent(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetDirectoryListingParams& aParam,
+ FileSystemRequestParent* aParent)
+ : FileSystemTaskParentBase(aFileSystem, aParam, aParent),
+ mDOMPath(aParam.domPath()),
+ mFilters(aParam.filters()) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemResponseValue GetDirectoryListingTaskParent::GetSuccessRequestResult(
+ ErrorResult& aRv) const {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+
+ nsTArray<FileSystemDirectoryListingResponseData> inputs;
+
+ for (unsigned i = 0; i < mTargetData.Length(); i++) {
+ if (mTargetData[i].mType == FileOrDirectoryPath::eFilePath) {
+ nsCOMPtr<nsIFile> path;
+ nsresult rv =
+ NS_NewLocalFile(mTargetData[i].mPath, true, getter_AddRefs(path));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ continue;
+ }
+
+ FileSystemDirectoryListingResponseFile fileData;
+ RefPtr<BlobImpl> blobImpl = new FileBlobImpl(path);
+
+ nsAutoString filePath;
+ filePath.Assign(mDOMPath);
+
+ // This is specific for unix root filesystem.
+ if (!mDOMPath.EqualsLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL)) {
+ filePath.AppendLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ }
+
+ nsAutoString name;
+ blobImpl->GetName(name);
+ filePath.Append(name);
+ blobImpl->SetDOMPath(filePath);
+
+ IPCBlob ipcBlob;
+ rv = IPCBlobUtils::Serialize(blobImpl, ipcBlob);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ continue;
+ }
+
+ fileData.blob() = ipcBlob;
+ inputs.AppendElement(fileData);
+ } else {
+ MOZ_ASSERT(mTargetData[i].mType == FileOrDirectoryPath::eDirectoryPath);
+ FileSystemDirectoryListingResponseDirectory directoryData;
+ directoryData.directoryRealPath() = mTargetData[i].mPath;
+ inputs.AppendElement(directoryData);
+ }
+ }
+
+ FileSystemDirectoryListingResponse response;
+ response.data() = std::move(inputs);
+ return response;
+}
+
+nsresult GetDirectoryListingTaskParent::IOWork() {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ MOZ_ASSERT(!NS_IsMainThread(), "Only call on worker thread!");
+
+ if (mFileSystem->IsShutdown()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ bool exists;
+ nsresult rv = mTargetPath->Exists(&exists);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!exists) {
+ if (!mFileSystem->ShouldCreateDirectory()) {
+ return NS_ERROR_DOM_FILE_NOT_FOUND_ERR;
+ }
+
+ rv = mTargetPath->Create(nsIFile::DIRECTORY_TYPE, 0777);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ // Get isDirectory.
+ bool isDir;
+ rv = mTargetPath->IsDirectory(&isDir);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!isDir) {
+ return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;
+ }
+
+ nsCOMPtr<nsIDirectoryEnumerator> entries;
+ rv = mTargetPath->GetDirectoryEntries(getter_AddRefs(entries));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ bool filterOutSensitive = false;
+ {
+ HTMLSplitOnSpacesTokenizer tokenizer(mFilters, ';');
+ nsAutoString token;
+ while (tokenizer.hasMoreTokens()) {
+ token = tokenizer.nextToken();
+ if (token.EqualsLiteral("filter-out-sensitive")) {
+ filterOutSensitive = true;
+ } else {
+ MOZ_CRASH("Unrecognized filter");
+ }
+ }
+ }
+
+ for (;;) {
+ nsCOMPtr<nsIFile> currFile;
+ if (NS_WARN_IF(NS_FAILED(entries->GetNextFile(getter_AddRefs(currFile)))) ||
+ !currFile) {
+ break;
+ }
+ bool isLink, isSpecial, isFile;
+ if (NS_WARN_IF(NS_FAILED(currFile->IsSymlink(&isLink)) ||
+ NS_FAILED(currFile->IsSpecial(&isSpecial))) ||
+ // Although we allow explicit individual selection of symlinks via the
+ // file picker, we do not process symlinks in directory traversal. Our
+ // specific policy decision is documented at
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1813299#c20
+ isLink || isSpecial) {
+ continue;
+ }
+ if (NS_WARN_IF(NS_FAILED(currFile->IsFile(&isFile)) ||
+ NS_FAILED(currFile->IsDirectory(&isDir))) ||
+ !(isFile || isDir)) {
+ continue;
+ }
+
+ if (filterOutSensitive) {
+ bool isHidden;
+ if (NS_WARN_IF(NS_FAILED(currFile->IsHidden(&isHidden))) || isHidden) {
+ continue;
+ }
+ nsAutoString leafName;
+ if (NS_WARN_IF(NS_FAILED(currFile->GetLeafName(leafName)))) {
+ continue;
+ }
+ if (leafName[0] == char16_t('.')) {
+ continue;
+ }
+ }
+
+ nsAutoString path;
+ if (NS_WARN_IF(NS_FAILED(currFile->GetPath(path)))) {
+ continue;
+ }
+
+ FileOrDirectoryPath element;
+ element.mPath = path;
+ element.mType = isDir ? FileOrDirectoryPath::eDirectoryPath
+ : FileOrDirectoryPath::eFilePath;
+
+ if (!mTargetData.AppendElement(element, fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ return NS_OK;
+}
+
+nsresult GetDirectoryListingTaskParent::GetTargetPath(nsAString& aPath) const {
+ return mTargetPath->GetPath(aPath);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/GetDirectoryListingTask.h b/dom/filesystem/GetDirectoryListingTask.h
new file mode 100644
index 0000000000..afb5296ac5
--- /dev/null
+++ b/dom/filesystem/GetDirectoryListingTask.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_GetDirectoryListing_h
+#define mozilla_dom_GetDirectoryListing_h
+
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileSystemTaskBase.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class BlobImpl;
+class FileSystemGetDirectoryListingParams;
+class OwningFileOrDirectory;
+
+class GetDirectoryListingTaskChild final : public FileSystemTaskChildBase {
+ public:
+ static already_AddRefed<GetDirectoryListingTaskChild> Create(
+ FileSystemBase* aFileSystem, Directory* aDirectory, nsIFile* aTargetPath,
+ const nsAString& aFilters, ErrorResult& aRv);
+
+ virtual ~GetDirectoryListingTaskChild();
+
+ already_AddRefed<Promise> GetPromise();
+
+ private:
+ // If aDirectoryOnly is set, we should ensure that the target is a directory.
+ GetDirectoryListingTaskChild(nsIGlobalObject* aGlobalObject,
+ FileSystemBase* aFileSystem,
+ Directory* aDirectory, nsIFile* aTargetPath,
+ const nsAString& aFilters);
+
+ virtual FileSystemParams GetRequestParams(const nsString& aSerializedDOMPath,
+ ErrorResult& aRv) const override;
+
+ virtual void SetSuccessRequestResult(const FileSystemResponseValue& aValue,
+ ErrorResult& aRv) override;
+
+ virtual void HandlerCallback() override;
+
+ RefPtr<Promise> mPromise;
+ RefPtr<Directory> mDirectory;
+ nsCOMPtr<nsIFile> mTargetPath;
+ nsString mFilters;
+
+ FallibleTArray<OwningFileOrDirectory> mTargetData;
+};
+
+class GetDirectoryListingTaskParent final : public FileSystemTaskParentBase {
+ public:
+ static already_AddRefed<GetDirectoryListingTaskParent> Create(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetDirectoryListingParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv);
+
+ nsresult GetTargetPath(nsAString& aPath) const override;
+
+ private:
+ GetDirectoryListingTaskParent(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetDirectoryListingParams& aParam,
+ FileSystemRequestParent* aParent);
+
+ virtual FileSystemResponseValue GetSuccessRequestResult(
+ ErrorResult& aRv) const override;
+
+ virtual nsresult IOWork() override;
+
+ nsCOMPtr<nsIFile> mTargetPath;
+ nsString mDOMPath;
+ nsString mFilters;
+
+ struct FileOrDirectoryPath {
+ nsString mPath;
+
+ enum { eFilePath, eDirectoryPath } mType;
+ };
+
+ FallibleTArray<FileOrDirectoryPath> mTargetData;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_GetDirectoryListing_h
diff --git a/dom/filesystem/GetFileOrDirectoryTask.cpp b/dom/filesystem/GetFileOrDirectoryTask.cpp
new file mode 100644
index 0000000000..7f7d1c2816
--- /dev/null
+++ b/dom/filesystem/GetFileOrDirectoryTask.cpp
@@ -0,0 +1,270 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "GetFileOrDirectoryTask.h"
+
+#include "js/Value.h"
+#include "mozilla/dom/FileBlobImpl.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/PFileSystemParams.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "nsIFile.h"
+#include "nsString.h"
+
+namespace mozilla::dom {
+
+/**
+ * GetFileOrDirectoryTaskChild
+ */
+
+/* static */
+already_AddRefed<GetFileOrDirectoryTaskChild>
+GetFileOrDirectoryTaskChild::Create(FileSystemBase* aFileSystem,
+ nsIFile* aTargetPath, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+ MOZ_ASSERT(aFileSystem);
+
+ nsCOMPtr<nsIGlobalObject> globalObject = aFileSystem->GetParentObject();
+ if (NS_WARN_IF(!globalObject)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<GetFileOrDirectoryTaskChild> task =
+ new GetFileOrDirectoryTaskChild(globalObject, aFileSystem, aTargetPath);
+
+ // aTargetPath can be null. In this case SetError will be called.
+
+ task->mPromise = Promise::Create(globalObject, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetFileOrDirectoryTaskChild::GetFileOrDirectoryTaskChild(
+ nsIGlobalObject* aGlobalObject, FileSystemBase* aFileSystem,
+ nsIFile* aTargetPath)
+ : FileSystemTaskChildBase(aGlobalObject, aFileSystem),
+ mTargetPath(aTargetPath) {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+ MOZ_ASSERT(aFileSystem);
+}
+
+GetFileOrDirectoryTaskChild::~GetFileOrDirectoryTaskChild() {
+ MOZ_ASSERT(NS_IsMainThread());
+}
+
+already_AddRefed<Promise> GetFileOrDirectoryTaskChild::GetPromise() {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+ return RefPtr<Promise>(mPromise).forget();
+}
+
+FileSystemParams GetFileOrDirectoryTaskChild::GetRequestParams(
+ const nsString& aSerializedDOMPath, ErrorResult& aRv) const {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+
+ nsAutoString path;
+ aRv = mTargetPath->GetPath(path);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemGetFileOrDirectoryParams();
+ }
+
+ return FileSystemGetFileOrDirectoryParams(aSerializedDOMPath, path);
+}
+
+void GetFileOrDirectoryTaskChild::SetSuccessRequestResult(
+ const FileSystemResponseValue& aValue, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+ switch (aValue.type()) {
+ case FileSystemResponseValue::TFileSystemFileResponse: {
+ FileSystemFileResponse r = aValue;
+
+ RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(r.blob());
+ MOZ_ASSERT(blobImpl);
+
+ nsCOMPtr<nsIGlobalObject> globalObject = mFileSystem->GetParentObject();
+ MOZ_ASSERT(globalObject);
+
+ mResultFile = File::Create(globalObject, blobImpl);
+ if (NS_WARN_IF(!mResultFile)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ }
+ break;
+ }
+ case FileSystemResponseValue::TFileSystemDirectoryResponse: {
+ FileSystemDirectoryResponse r = aValue;
+
+ nsCOMPtr<nsIFile> file;
+ aRv = NS_NewLocalFile(r.realPath(), true, getter_AddRefs(file));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ mResultDirectory =
+ Directory::Create(mFileSystem->GetParentObject(), file, mFileSystem);
+ MOZ_ASSERT(mResultDirectory);
+ break;
+ }
+ default: {
+ MOZ_CRASH("not reached");
+ break;
+ }
+ }
+}
+
+void GetFileOrDirectoryTaskChild::HandlerCallback() {
+ MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
+ if (mFileSystem->IsShutdown()) {
+ mPromise = nullptr;
+ return;
+ }
+
+ if (HasError()) {
+ mPromise->MaybeReject(mErrorValue);
+ mPromise = nullptr;
+ return;
+ }
+
+ if (mResultDirectory) {
+ mPromise->MaybeResolve(mResultDirectory);
+ mResultDirectory = nullptr;
+ mPromise = nullptr;
+ return;
+ }
+
+ MOZ_ASSERT(mResultFile);
+ mPromise->MaybeResolve(mResultFile);
+ mResultFile = nullptr;
+ mPromise = nullptr;
+}
+
+/**
+ * GetFileOrDirectoryTaskParent
+ */
+
+/* static */
+already_AddRefed<GetFileOrDirectoryTaskParent>
+GetFileOrDirectoryTaskParent::Create(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetFileOrDirectoryParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+
+ RefPtr<GetFileOrDirectoryTaskParent> task =
+ new GetFileOrDirectoryTaskParent(aFileSystem, aParam, aParent);
+
+ aRv = NS_NewLocalFile(aParam.realPath(), true,
+ getter_AddRefs(task->mTargetPath));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetFileOrDirectoryTaskParent::GetFileOrDirectoryTaskParent(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetFileOrDirectoryParams& aParam,
+ FileSystemRequestParent* aParent)
+ : FileSystemTaskParentBase(aFileSystem, aParam, aParent),
+ mIsDirectory(false) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemResponseValue GetFileOrDirectoryTaskParent::GetSuccessRequestResult(
+ ErrorResult& aRv) const {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+
+ nsAutoString path;
+ aRv = mTargetPath->GetPath(path);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemDirectoryResponse();
+ }
+
+ if (mIsDirectory) {
+ return FileSystemDirectoryResponse(path);
+ }
+
+ RefPtr<BlobImpl> blobImpl = new FileBlobImpl(mTargetPath);
+
+ IPCBlob ipcBlob;
+ aRv = IPCBlobUtils::Serialize(blobImpl, ipcBlob);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemDirectoryResponse();
+ }
+
+ return FileSystemFileResponse(ipcBlob);
+}
+
+nsresult GetFileOrDirectoryTaskParent::IOWork() {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ MOZ_ASSERT(!NS_IsMainThread(), "Only call on worker thread!");
+
+ if (mFileSystem->IsShutdown()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Whether we want to get the root directory.
+ bool exists;
+ nsresult rv = mTargetPath->Exists(&exists);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!exists) {
+ if (!mFileSystem->ShouldCreateDirectory()) {
+ return NS_ERROR_DOM_FILE_NOT_FOUND_ERR;
+ }
+
+ rv = mTargetPath->Create(nsIFile::DIRECTORY_TYPE, 0777);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ // Get isDirectory.
+ rv = mTargetPath->IsDirectory(&mIsDirectory);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (mIsDirectory) {
+ return NS_OK;
+ }
+
+ bool isFile;
+ // Get isFile
+ rv = mTargetPath->IsFile(&isFile);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!isFile) {
+ // Neither directory or file.
+ return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;
+ }
+
+ if (!mFileSystem->IsSafeFile(mTargetPath)) {
+ return NS_ERROR_DOM_SECURITY_ERR;
+ }
+
+ return NS_OK;
+}
+
+nsresult GetFileOrDirectoryTaskParent::GetTargetPath(nsAString& aPath) const {
+ return mTargetPath->GetPath(aPath);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/GetFileOrDirectoryTask.h b/dom/filesystem/GetFileOrDirectoryTask.h
new file mode 100644
index 0000000000..8d15d9804f
--- /dev/null
+++ b/dom/filesystem/GetFileOrDirectoryTask.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_GetFileOrDirectory_h
+#define mozilla_dom_GetFileOrDirectory_h
+
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileSystemTaskBase.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class BlobImpl;
+class FileSystemGetFileOrDirectoryParams;
+
+class GetFileOrDirectoryTaskChild final : public FileSystemTaskChildBase {
+ public:
+ static already_AddRefed<GetFileOrDirectoryTaskChild> Create(
+ FileSystemBase* aFileSystem, nsIFile* aTargetPath, ErrorResult& aRv);
+
+ virtual ~GetFileOrDirectoryTaskChild();
+
+ already_AddRefed<Promise> GetPromise();
+
+ protected:
+ virtual FileSystemParams GetRequestParams(const nsString& aSerializedDOMPath,
+ ErrorResult& aRv) const override;
+
+ virtual void SetSuccessRequestResult(const FileSystemResponseValue& aValue,
+ ErrorResult& aRv) override;
+ virtual void HandlerCallback() override;
+
+ private:
+ GetFileOrDirectoryTaskChild(nsIGlobalObject* aGlobalObject,
+ FileSystemBase* aFileSystem,
+ nsIFile* aTargetPath);
+
+ RefPtr<Promise> mPromise;
+ nsCOMPtr<nsIFile> mTargetPath;
+
+ RefPtr<File> mResultFile;
+ RefPtr<Directory> mResultDirectory;
+};
+
+class GetFileOrDirectoryTaskParent final : public FileSystemTaskParentBase {
+ public:
+ static already_AddRefed<GetFileOrDirectoryTaskParent> Create(
+ FileSystemBase* aFileSystem,
+ const FileSystemGetFileOrDirectoryParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv);
+
+ nsresult GetTargetPath(nsAString& aPath) const override;
+
+ protected:
+ virtual FileSystemResponseValue GetSuccessRequestResult(
+ ErrorResult& aRv) const override;
+
+ virtual nsresult IOWork() override;
+
+ private:
+ GetFileOrDirectoryTaskParent(FileSystemBase* aFileSystem,
+ const FileSystemGetFileOrDirectoryParams& aParam,
+ FileSystemRequestParent* aParent);
+
+ nsCOMPtr<nsIFile> mTargetPath;
+
+ // Whether we get a directory.
+ bool mIsDirectory;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_GetFileOrDirectory_h
diff --git a/dom/filesystem/GetFilesHelper.cpp b/dom/filesystem/GetFilesHelper.cpp
new file mode 100644
index 0000000000..5c91b4cfe5
--- /dev/null
+++ b/dom/filesystem/GetFilesHelper.cpp
@@ -0,0 +1,506 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "GetFilesHelper.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileBlobImpl.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/ipc/IPCStreamUtils.h"
+#include "FileSystemUtils.h"
+#include "nsNetCID.h"
+#include "nsProxyRelease.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+// This class is used in the DTOR of GetFilesHelper to release resources in the
+// correct thread.
+class ReleaseRunnable final : public Runnable {
+ public:
+ static void MaybeReleaseOnMainThread(
+ nsTArray<RefPtr<Promise>>&& aPromises,
+ nsTArray<RefPtr<GetFilesCallback>>&& aCallbacks) {
+ if (NS_IsMainThread()) {
+ return;
+ }
+
+ RefPtr<ReleaseRunnable> runnable =
+ new ReleaseRunnable(std::move(aPromises), std::move(aCallbacks));
+ FileSystemUtils::DispatchRunnable(nullptr, runnable.forget());
+ }
+
+ NS_IMETHOD
+ Run() override {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ mPromises.Clear();
+ mCallbacks.Clear();
+
+ return NS_OK;
+ }
+
+ private:
+ ReleaseRunnable(nsTArray<RefPtr<Promise>>&& aPromises,
+ nsTArray<RefPtr<GetFilesCallback>>&& aCallbacks)
+ : Runnable("dom::ReleaseRunnable"),
+ mPromises(std::move(aPromises)),
+ mCallbacks(std::move(aCallbacks)) {}
+
+ nsTArray<RefPtr<Promise>> mPromises;
+ nsTArray<RefPtr<GetFilesCallback>> mCallbacks;
+};
+
+} // namespace
+
+///////////////////////////////////////////////////////////////////////////////
+// GetFilesHelper Base class
+
+already_AddRefed<GetFilesHelper> GetFilesHelper::Create(
+ const nsTArray<OwningFileOrDirectory>& aFilesOrDirectory,
+ bool aRecursiveFlag, ErrorResult& aRv) {
+ RefPtr<GetFilesHelper> helper;
+
+ if (XRE_IsParentProcess()) {
+ helper = new GetFilesHelper(aRecursiveFlag);
+ } else {
+ helper = new GetFilesHelperChild(aRecursiveFlag);
+ }
+
+ nsAutoString directoryPath;
+
+ for (uint32_t i = 0; i < aFilesOrDirectory.Length(); ++i) {
+ const OwningFileOrDirectory& data = aFilesOrDirectory[i];
+ if (data.IsFile()) {
+ if (!helper->mTargetBlobImplArray.AppendElement(data.GetAsFile()->Impl(),
+ fallible)) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return nullptr;
+ }
+ } else {
+ MOZ_ASSERT(data.IsDirectory());
+
+ // We support the upload of only 1 top-level directory from our
+ // directory picker. This means that we cannot have more than 1
+ // Directory object in aFilesOrDirectory array.
+ MOZ_ASSERT(directoryPath.IsEmpty());
+
+ RefPtr<Directory> directory = data.GetAsDirectory();
+ MOZ_ASSERT(directory);
+
+ aRv = directory->GetFullRealPath(directoryPath);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ }
+ }
+
+ // No directories to explore.
+ if (directoryPath.IsEmpty()) {
+ helper->mListingCompleted = true;
+ return helper.forget();
+ }
+
+ MOZ_ASSERT(helper->mTargetBlobImplArray.IsEmpty());
+ helper->SetDirectoryPath(directoryPath);
+
+ helper->Work(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return helper.forget();
+}
+
+GetFilesHelper::GetFilesHelper(bool aRecursiveFlag)
+ : Runnable("GetFilesHelper"),
+ GetFilesHelperBase(aRecursiveFlag),
+ mListingCompleted(false),
+ mErrorResult(NS_OK),
+ mMutex("GetFilesHelper::mMutex"),
+ mCanceled(false) {}
+
+GetFilesHelper::~GetFilesHelper() {
+ ReleaseRunnable::MaybeReleaseOnMainThread(std::move(mPromises),
+ std::move(mCallbacks));
+}
+
+void GetFilesHelper::AddPromise(Promise* aPromise) {
+ MOZ_ASSERT(aPromise);
+
+ // Still working.
+ if (!mListingCompleted) {
+ mPromises.AppendElement(aPromise);
+ return;
+ }
+
+ MOZ_ASSERT(mPromises.IsEmpty());
+ ResolveOrRejectPromise(aPromise);
+}
+
+void GetFilesHelper::AddCallback(GetFilesCallback* aCallback) {
+ MOZ_ASSERT(aCallback);
+
+ // Still working.
+ if (!mListingCompleted) {
+ mCallbacks.AppendElement(aCallback);
+ return;
+ }
+
+ MOZ_ASSERT(mCallbacks.IsEmpty());
+ RunCallback(aCallback);
+}
+
+void GetFilesHelper::Unlink() {
+ mPromises.Clear();
+ mCallbacks.Clear();
+
+ {
+ MutexAutoLock lock(mMutex);
+ mCanceled = true;
+ }
+
+ Cancel();
+}
+
+void GetFilesHelper::Traverse(nsCycleCollectionTraversalCallback& cb) {
+ GetFilesHelper* tmp = this;
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPromises);
+}
+
+void GetFilesHelper::Work(ErrorResult& aRv) {
+ nsCOMPtr<nsIEventTarget> target =
+ do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+ MOZ_ASSERT(target);
+
+ aRv = target->Dispatch(this, NS_DISPATCH_NORMAL);
+}
+
+NS_IMETHODIMP
+GetFilesHelper::Run() {
+ MOZ_ASSERT(!mDirectoryPath.IsEmpty());
+ MOZ_ASSERT(!mListingCompleted);
+
+ // First step is to retrieve the list of file paths.
+ // This happens in the I/O thread.
+ if (!NS_IsMainThread()) {
+ RunIO();
+
+ // If this operation has been canceled, we don't have to go back to
+ // main-thread.
+ if (IsCanceled()) {
+ return NS_OK;
+ }
+
+ RefPtr<Runnable> runnable = this;
+ return FileSystemUtils::DispatchRunnable(nullptr, runnable.forget());
+ }
+
+ // We are here, but we should not do anything on this thread because, in the
+ // meantime, the operation has been canceled.
+ if (IsCanceled()) {
+ return NS_OK;
+ }
+
+ OperationCompleted();
+ return NS_OK;
+}
+
+void GetFilesHelper::OperationCompleted() {
+ // We mark the operation as completed here.
+ mListingCompleted = true;
+
+ // Let's process the pending promises.
+ nsTArray<RefPtr<Promise>> promises = std::move(mPromises);
+
+ for (uint32_t i = 0; i < promises.Length(); ++i) {
+ ResolveOrRejectPromise(promises[i]);
+ }
+
+ // Let's process the pending callbacks.
+ nsTArray<RefPtr<GetFilesCallback>> callbacks = std::move(mCallbacks);
+
+ for (uint32_t i = 0; i < callbacks.Length(); ++i) {
+ RunCallback(callbacks[i]);
+ }
+}
+
+void GetFilesHelper::RunIO() {
+ MOZ_ASSERT(!NS_IsMainThread());
+ MOZ_ASSERT(!mDirectoryPath.IsEmpty());
+ MOZ_ASSERT(!mListingCompleted);
+
+ nsCOMPtr<nsIFile> file;
+ mErrorResult = NS_NewLocalFile(mDirectoryPath, true, getter_AddRefs(file));
+ if (NS_WARN_IF(NS_FAILED(mErrorResult))) {
+ return;
+ }
+
+ nsAutoString leafName;
+ mErrorResult = file->GetLeafName(leafName);
+ if (NS_WARN_IF(NS_FAILED(mErrorResult))) {
+ return;
+ }
+
+ nsAutoString domPath;
+ domPath.AssignLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ domPath.Append(leafName);
+
+ mErrorResult = ExploreDirectory(domPath, file);
+}
+
+nsresult GetFilesHelperBase::ExploreDirectory(const nsAString& aDOMPath,
+ nsIFile* aFile) {
+ MOZ_ASSERT(!NS_IsMainThread());
+ MOZ_ASSERT(aFile);
+
+ // We check if this operation has to be terminated at each recursion.
+ if (IsCanceled()) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIDirectoryEnumerator> entries;
+ nsresult rv = aFile->GetDirectoryEntries(getter_AddRefs(entries));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ for (;;) {
+ nsCOMPtr<nsIFile> currFile;
+ if (NS_WARN_IF(NS_FAILED(entries->GetNextFile(getter_AddRefs(currFile)))) ||
+ !currFile) {
+ break;
+ }
+ bool isLink, isSpecial, isFile, isDir;
+ if (NS_WARN_IF(NS_FAILED(currFile->IsSymlink(&isLink)) ||
+ NS_FAILED(currFile->IsSpecial(&isSpecial))) ||
+ isSpecial ||
+ // Although we allow explicit individual selection of symlinks via the
+ // file picker, we do not process symlinks in directory traversal. Our
+ // specific policy decision is documented at
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1813299#c20
+ isLink) {
+ continue;
+ }
+
+ if (NS_WARN_IF(NS_FAILED(currFile->IsFile(&isFile)) ||
+ NS_FAILED(currFile->IsDirectory(&isDir))) ||
+ !(isFile || isDir)) {
+ continue;
+ }
+
+ // The new domPath
+ nsAutoString domPath;
+ domPath.Assign(aDOMPath);
+ if (!aDOMPath.EqualsLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL)) {
+ domPath.AppendLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ }
+
+ nsAutoString leafName;
+ if (NS_WARN_IF(NS_FAILED(currFile->GetLeafName(leafName)))) {
+ continue;
+ }
+ domPath.Append(leafName);
+
+ if (isFile) {
+ RefPtr<BlobImpl> blobImpl = new FileBlobImpl(currFile);
+ blobImpl->SetDOMPath(domPath);
+
+ if (!mTargetBlobImplArray.AppendElement(blobImpl, fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ continue;
+ }
+
+ MOZ_ASSERT(isDir);
+ if (!mRecursiveFlag) {
+ continue;
+ }
+
+ // Recursive.
+ rv = ExploreDirectory(domPath, currFile);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ return NS_OK;
+}
+
+void GetFilesHelper::ResolveOrRejectPromise(Promise* aPromise) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(mListingCompleted);
+ MOZ_ASSERT(aPromise);
+
+ Sequence<RefPtr<File>> files;
+
+ if (NS_SUCCEEDED(mErrorResult)) {
+ for (uint32_t i = 0; i < mTargetBlobImplArray.Length(); ++i) {
+ RefPtr<File> domFile =
+ File::Create(aPromise->GetParentObject(), mTargetBlobImplArray[i]);
+ if (NS_WARN_IF(!domFile)) {
+ mErrorResult = NS_ERROR_FAILURE;
+ files.Clear();
+ break;
+ }
+
+ if (!files.AppendElement(domFile, fallible)) {
+ mErrorResult = NS_ERROR_OUT_OF_MEMORY;
+ files.Clear();
+ break;
+ }
+ }
+ }
+
+ // Error propagation.
+ if (NS_FAILED(mErrorResult)) {
+ aPromise->MaybeReject(mErrorResult);
+ return;
+ }
+
+ aPromise->MaybeResolve(files);
+}
+
+void GetFilesHelper::RunCallback(GetFilesCallback* aCallback) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(mListingCompleted);
+ MOZ_ASSERT(aCallback);
+
+ aCallback->Callback(mErrorResult, mTargetBlobImplArray);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GetFilesHelperChild class
+
+void GetFilesHelperChild::Work(ErrorResult& aRv) {
+ ContentChild* cc = ContentChild::GetSingleton();
+ if (NS_WARN_IF(!cc)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ aRv = nsID::GenerateUUIDInPlace(mUUID);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ mPendingOperation = true;
+ cc->CreateGetFilesRequest(mDirectoryPath, mRecursiveFlag, mUUID, this);
+}
+
+void GetFilesHelperChild::Cancel() {
+ if (!mPendingOperation) {
+ return;
+ }
+
+ ContentChild* cc = ContentChild::GetSingleton();
+ if (NS_WARN_IF(!cc)) {
+ return;
+ }
+
+ mPendingOperation = false;
+ cc->DeleteGetFilesRequest(mUUID, this);
+}
+
+bool GetFilesHelperChild::AppendBlobImpl(BlobImpl* aBlobImpl) {
+ MOZ_ASSERT(mPendingOperation);
+ MOZ_ASSERT(aBlobImpl);
+ MOZ_ASSERT(aBlobImpl->IsFile());
+
+ return mTargetBlobImplArray.AppendElement(aBlobImpl, fallible);
+}
+
+void GetFilesHelperChild::Finished(nsresult aError) {
+ MOZ_ASSERT(mPendingOperation);
+ MOZ_ASSERT(NS_SUCCEEDED(mErrorResult));
+
+ mPendingOperation = false;
+ mErrorResult = aError;
+
+ OperationCompleted();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GetFilesHelperParent class
+
+class GetFilesHelperParentCallback final : public GetFilesCallback {
+ public:
+ explicit GetFilesHelperParentCallback(GetFilesHelperParent* aParent)
+ : mParent(aParent) {
+ MOZ_ASSERT(aParent);
+ }
+
+ void Callback(nsresult aStatus,
+ const FallibleTArray<RefPtr<BlobImpl>>& aBlobImpls) override {
+ if (NS_FAILED(aStatus)) {
+ mParent->mContentParent->SendGetFilesResponseAndForget(
+ mParent->mUUID, GetFilesResponseFailure(aStatus));
+ return;
+ }
+
+ GetFilesResponseSuccess success;
+
+ nsTArray<IPCBlob>& ipcBlobs = success.blobs();
+ ipcBlobs.SetLength(aBlobImpls.Length());
+
+ for (uint32_t i = 0; i < aBlobImpls.Length(); ++i) {
+ nsresult rv = IPCBlobUtils::Serialize(aBlobImpls[i], ipcBlobs[i]);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ mParent->mContentParent->SendGetFilesResponseAndForget(
+ mParent->mUUID, GetFilesResponseFailure(NS_ERROR_OUT_OF_MEMORY));
+ return;
+ }
+ }
+
+ mParent->mContentParent->SendGetFilesResponseAndForget(mParent->mUUID,
+ success);
+ }
+
+ private:
+ // Raw pointer because this callback is kept alive by this parent object.
+ GetFilesHelperParent* mParent;
+};
+
+GetFilesHelperParent::GetFilesHelperParent(const nsID& aUUID,
+ ContentParent* aContentParent,
+ bool aRecursiveFlag)
+ : GetFilesHelper(aRecursiveFlag),
+ mContentParent(aContentParent),
+ mUUID(aUUID) {}
+
+GetFilesHelperParent::~GetFilesHelperParent() {
+ NS_ReleaseOnMainThread("GetFilesHelperParent::mContentParent",
+ mContentParent.forget());
+}
+
+/* static */
+already_AddRefed<GetFilesHelperParent> GetFilesHelperParent::Create(
+ const nsID& aUUID, const nsAString& aDirectoryPath, bool aRecursiveFlag,
+ ContentParent* aContentParent, ErrorResult& aRv) {
+ MOZ_ASSERT(aContentParent);
+
+ RefPtr<GetFilesHelperParent> helper =
+ new GetFilesHelperParent(aUUID, aContentParent, aRecursiveFlag);
+ helper->SetDirectoryPath(aDirectoryPath);
+
+ helper->Work(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<GetFilesHelperParentCallback> callback =
+ new GetFilesHelperParentCallback(helper);
+ helper->AddCallback(callback);
+
+ return helper.forget();
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/GetFilesHelper.h b/dom/filesystem/GetFilesHelper.h
new file mode 100644
index 0000000000..2b15e69059
--- /dev/null
+++ b/dom/filesystem/GetFilesHelper.h
@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_GetFilesHelper_h
+#define mozilla_dom_GetFilesHelper_h
+
+#include "mozilla/Mutex.h"
+#include "mozilla/RefPtr.h"
+#include "nsCycleCollectionTraversalCallback.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+
+class nsIGlobalObject;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class BlobImpl;
+class ContentParent;
+class File;
+class GetFilesHelperParent;
+class OwningFileOrDirectory;
+class Promise;
+
+class GetFilesCallback {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(GetFilesCallback);
+
+ virtual void Callback(nsresult aStatus,
+ const FallibleTArray<RefPtr<BlobImpl>>& aBlobImpls) = 0;
+
+ protected:
+ virtual ~GetFilesCallback() = default;
+};
+
+class GetFilesHelperBase {
+ protected:
+ explicit GetFilesHelperBase(bool aRecursiveFlag)
+ : mRecursiveFlag(aRecursiveFlag) {}
+
+ virtual ~GetFilesHelperBase() = default;
+
+ virtual bool IsCanceled() { return false; }
+
+ nsresult ExploreDirectory(const nsAString& aDOMPath, nsIFile* aFile);
+
+ bool mRecursiveFlag;
+
+ // We populate this array in the I/O thread with the BlobImpl.
+ FallibleTArray<RefPtr<BlobImpl>> mTargetBlobImplArray;
+};
+
+// Retrieving the list of files can be very time/IO consuming. We use this
+// helper class to do it just once.
+class GetFilesHelper : public Runnable, public GetFilesHelperBase {
+ friend class GetFilesHelperParent;
+
+ public:
+ static already_AddRefed<GetFilesHelper> Create(
+ const nsTArray<OwningFileOrDirectory>& aFilesOrDirectory,
+ bool aRecursiveFlag, ErrorResult& aRv);
+
+ void AddPromise(Promise* aPromise);
+
+ void AddCallback(GetFilesCallback* aCallback);
+
+ // CC methods
+ void Unlink();
+ void Traverse(nsCycleCollectionTraversalCallback& cb);
+
+ protected:
+ explicit GetFilesHelper(bool aRecursiveFlag);
+
+ virtual ~GetFilesHelper();
+
+ void SetDirectoryPath(const nsAString& aDirectoryPath) {
+ mDirectoryPath = aDirectoryPath;
+ }
+
+ virtual bool IsCanceled() override {
+ MutexAutoLock lock(mMutex);
+ return mCanceled;
+ }
+
+ virtual void Work(ErrorResult& aRv);
+
+ virtual void Cancel(){};
+
+ NS_IMETHOD
+ Run() override;
+
+ void RunIO();
+
+ void OperationCompleted();
+
+ void ResolveOrRejectPromise(Promise* aPromise);
+
+ void RunCallback(GetFilesCallback* aCallback);
+
+ bool mListingCompleted;
+ nsString mDirectoryPath;
+
+ // Error code to propagate.
+ nsresult mErrorResult;
+
+ nsTArray<RefPtr<Promise>> mPromises;
+ nsTArray<RefPtr<GetFilesCallback>> mCallbacks;
+
+ Mutex mMutex MOZ_UNANNOTATED;
+
+ // This variable is protected by mutex.
+ bool mCanceled;
+};
+
+class GetFilesHelperChild final : public GetFilesHelper {
+ public:
+ explicit GetFilesHelperChild(bool aRecursiveFlag)
+ : GetFilesHelper(aRecursiveFlag), mPendingOperation(false) {}
+
+ virtual void Work(ErrorResult& aRv) override;
+
+ virtual void Cancel() override;
+
+ bool AppendBlobImpl(BlobImpl* aBlobImpl);
+
+ void Finished(nsresult aResult);
+
+ private:
+ nsID mUUID;
+ bool mPendingOperation;
+};
+
+class GetFilesHelperParentCallback;
+
+class GetFilesHelperParent final : public GetFilesHelper {
+ friend class GetFilesHelperParentCallback;
+
+ public:
+ static already_AddRefed<GetFilesHelperParent> Create(
+ const nsID& aUUID, const nsAString& aDirectoryPath, bool aRecursiveFlag,
+ ContentParent* aContentParent, ErrorResult& aRv);
+
+ private:
+ GetFilesHelperParent(const nsID& aUUID, ContentParent* aContentParent,
+ bool aRecursiveFlag);
+
+ ~GetFilesHelperParent();
+
+ RefPtr<ContentParent> mContentParent;
+ nsID mUUID;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_GetFilesHelper_h
diff --git a/dom/filesystem/GetFilesTask.cpp b/dom/filesystem/GetFilesTask.cpp
new file mode 100644
index 0000000000..280df0b0bc
--- /dev/null
+++ b/dom/filesystem/GetFilesTask.cpp
@@ -0,0 +1,246 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "GetFilesTask.h"
+
+#include "HTMLSplitOnSpacesTokenizer.h"
+#include "js/Value.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileSystemBase.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/dom/PFileSystemParams.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "nsIFile.h"
+#include "nsString.h"
+
+namespace mozilla::dom {
+
+/**
+ * GetFilesTaskChild
+ */
+
+/* static */
+already_AddRefed<GetFilesTaskChild> GetFilesTaskChild::Create(
+ FileSystemBase* aFileSystem, Directory* aDirectory, nsIFile* aTargetPath,
+ bool aRecursiveFlag, ErrorResult& aRv) {
+ MOZ_ASSERT(aFileSystem);
+ MOZ_ASSERT(aDirectory);
+ aFileSystem->AssertIsOnOwningThread();
+
+ nsCOMPtr<nsIGlobalObject> globalObject = aFileSystem->GetParentObject();
+ if (NS_WARN_IF(!globalObject)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<GetFilesTaskChild> task = new GetFilesTaskChild(
+ globalObject, aFileSystem, aDirectory, aTargetPath, aRecursiveFlag);
+
+ // aTargetPath can be null. In this case SetError will be called.
+
+ task->mPromise = Promise::Create(globalObject, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetFilesTaskChild::GetFilesTaskChild(nsIGlobalObject* aGlobalObject,
+ FileSystemBase* aFileSystem,
+ Directory* aDirectory,
+ nsIFile* aTargetPath, bool aRecursiveFlag)
+ : FileSystemTaskChildBase(aGlobalObject, aFileSystem),
+ mDirectory(aDirectory),
+ mTargetPath(aTargetPath),
+ mRecursiveFlag(aRecursiveFlag) {
+ MOZ_ASSERT(aFileSystem);
+ MOZ_ASSERT(aDirectory);
+ aFileSystem->AssertIsOnOwningThread();
+}
+
+GetFilesTaskChild::~GetFilesTaskChild() {
+ mFileSystem->AssertIsOnOwningThread();
+}
+
+already_AddRefed<Promise> GetFilesTaskChild::GetPromise() {
+ mFileSystem->AssertIsOnOwningThread();
+ return RefPtr<Promise>(mPromise).forget();
+}
+
+FileSystemParams GetFilesTaskChild::GetRequestParams(
+ const nsString& aSerializedDOMPath, ErrorResult& aRv) const {
+ mFileSystem->AssertIsOnOwningThread();
+
+ nsAutoString path;
+ aRv = mTargetPath->GetPath(path);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemGetFilesParams();
+ }
+
+ nsAutoString domPath;
+ mDirectory->GetPath(domPath, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return FileSystemGetFilesParams();
+ }
+
+ return FileSystemGetFilesParams(aSerializedDOMPath, path, domPath,
+ mRecursiveFlag);
+}
+
+void GetFilesTaskChild::SetSuccessRequestResult(
+ const FileSystemResponseValue& aValue, ErrorResult& aRv) {
+ mFileSystem->AssertIsOnOwningThread();
+ MOZ_ASSERT(aValue.type() ==
+ FileSystemResponseValue::TFileSystemFilesResponse);
+
+ FileSystemFilesResponse r = aValue;
+
+ if (!mTargetData.SetLength(r.data().Length(), mozilla::fallible_t())) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return;
+ }
+
+ nsCOMPtr<nsIGlobalObject> globalObject = mFileSystem->GetParentObject();
+ MOZ_ASSERT(globalObject);
+
+ for (uint32_t i = 0; i < r.data().Length(); ++i) {
+ const FileSystemFileResponse& data = r.data()[i];
+ RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(data.blob());
+ MOZ_ASSERT(blobImpl);
+
+ mTargetData[i] = File::Create(globalObject, blobImpl);
+ if (NS_WARN_IF(!mTargetData[i])) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+ }
+}
+
+void GetFilesTaskChild::HandlerCallback() {
+ mFileSystem->AssertIsOnOwningThread();
+ if (mFileSystem->IsShutdown()) {
+ mPromise = nullptr;
+ return;
+ }
+
+ if (HasError()) {
+ mPromise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
+ mPromise = nullptr;
+ return;
+ }
+
+ mPromise->MaybeResolve(mTargetData);
+ mPromise = nullptr;
+}
+
+/**
+ * GetFilesTaskParent
+ */
+
+/* static */
+already_AddRefed<GetFilesTaskParent> GetFilesTaskParent::Create(
+ FileSystemBase* aFileSystem, const FileSystemGetFilesParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+
+ RefPtr<GetFilesTaskParent> task =
+ new GetFilesTaskParent(aFileSystem, aParam, aParent);
+
+ aRv = NS_NewLocalFile(aParam.realPath(), true,
+ getter_AddRefs(task->mTargetPath));
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ return task.forget();
+}
+
+GetFilesTaskParent::GetFilesTaskParent(FileSystemBase* aFileSystem,
+ const FileSystemGetFilesParams& aParam,
+ FileSystemRequestParent* aParent)
+ : FileSystemTaskParentBase(aFileSystem, aParam, aParent),
+ GetFilesHelperBase(aParam.recursiveFlag()),
+ mDirectoryDOMPath(aParam.domPath()) {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemResponseValue GetFilesTaskParent::GetSuccessRequestResult(
+ ErrorResult& aRv) const {
+ mozilla::ipc::AssertIsOnBackgroundThread();
+
+ FallibleTArray<FileSystemFileResponse> inputs;
+ if (!inputs.SetLength(mTargetBlobImplArray.Length(), mozilla::fallible_t())) {
+ FileSystemFilesResponse response;
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return response;
+ }
+
+ for (unsigned i = 0; i < mTargetBlobImplArray.Length(); i++) {
+ IPCBlob ipcBlob;
+ aRv = IPCBlobUtils::Serialize(mTargetBlobImplArray[i], ipcBlob);
+ if (NS_WARN_IF(aRv.Failed())) {
+ FileSystemFilesResponse response;
+ return response;
+ }
+
+ inputs[i] = FileSystemFileResponse(ipcBlob);
+ }
+
+ FileSystemFilesResponse response;
+ response.data() = std::move(inputs);
+ return response;
+}
+
+nsresult GetFilesTaskParent::IOWork() {
+ MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
+ MOZ_ASSERT(!NS_IsMainThread(), "Only call on I/O thread!");
+
+ if (mFileSystem->IsShutdown()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ bool exists;
+ nsresult rv = mTargetPath->Exists(&exists);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!exists) {
+ return NS_OK;
+ }
+
+ bool isDir;
+ rv = mTargetPath->IsDirectory(&isDir);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (!isDir) {
+ return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;
+ }
+
+ // Get isDirectory.
+ rv = ExploreDirectory(mDirectoryDOMPath, mTargetPath);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+nsresult GetFilesTaskParent::GetTargetPath(nsAString& aPath) const {
+ return mTargetPath->GetPath(aPath);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/GetFilesTask.h b/dom/filesystem/GetFilesTask.h
new file mode 100644
index 0000000000..6f6f15e879
--- /dev/null
+++ b/dom/filesystem/GetFilesTask.h
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_GetFilesTask_h
+#define mozilla_dom_GetFilesTask_h
+
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileSystemTaskBase.h"
+#include "mozilla/dom/GetFilesHelper.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class BlobImpl;
+class FileSystemGetFilesParams;
+
+class GetFilesTaskChild final : public FileSystemTaskChildBase {
+ public:
+ static already_AddRefed<GetFilesTaskChild> Create(FileSystemBase* aFileSystem,
+ Directory* aDirectory,
+ nsIFile* aTargetPath,
+ bool aRecursiveFlag,
+ ErrorResult& aRv);
+
+ virtual ~GetFilesTaskChild();
+
+ already_AddRefed<Promise> GetPromise();
+
+ private:
+ // If aDirectoryOnly is set, we should ensure that the target is a directory.
+ GetFilesTaskChild(nsIGlobalObject* aGlobalObject, FileSystemBase* aFileSystem,
+ Directory* aDirectory, nsIFile* aTargetPath,
+ bool aRecursiveFlag);
+
+ virtual FileSystemParams GetRequestParams(const nsString& aSerializedDOMPath,
+ ErrorResult& aRv) const override;
+
+ virtual void SetSuccessRequestResult(const FileSystemResponseValue& aValue,
+ ErrorResult& aRv) override;
+
+ virtual void HandlerCallback() override;
+
+ RefPtr<Promise> mPromise;
+ RefPtr<Directory> mDirectory;
+ nsCOMPtr<nsIFile> mTargetPath;
+ bool mRecursiveFlag;
+
+ // We store the fullpath and the dom path of Files.
+ FallibleTArray<RefPtr<File>> mTargetData;
+};
+
+class GetFilesTaskParent final : public FileSystemTaskParentBase,
+ public GetFilesHelperBase {
+ public:
+ static already_AddRefed<GetFilesTaskParent> Create(
+ FileSystemBase* aFileSystem, const FileSystemGetFilesParams& aParam,
+ FileSystemRequestParent* aParent, ErrorResult& aRv);
+
+ nsresult GetTargetPath(nsAString& aPath) const override;
+
+ private:
+ GetFilesTaskParent(FileSystemBase* aFileSystem,
+ const FileSystemGetFilesParams& aParam,
+ FileSystemRequestParent* aParent);
+
+ virtual FileSystemResponseValue GetSuccessRequestResult(
+ ErrorResult& aRv) const override;
+
+ virtual nsresult IOWork() override;
+
+ nsString mDirectoryDOMPath;
+ nsCOMPtr<nsIFile> mTargetPath;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_GetFilesTask_h
diff --git a/dom/filesystem/OSFileSystem.cpp b/dom/filesystem/OSFileSystem.cpp
new file mode 100644
index 0000000000..2322d07b93
--- /dev/null
+++ b/dom/filesystem/OSFileSystem.cpp
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/dom/OSFileSystem.h"
+
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "nsIGlobalObject.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsIFile.h"
+
+namespace mozilla::dom {
+
+OSFileSystem::OSFileSystem(const nsAString& aRootDir) {
+ mLocalRootPath = aRootDir;
+}
+
+already_AddRefed<FileSystemBase> OSFileSystem::Clone() {
+ AssertIsOnOwningThread();
+
+ RefPtr<OSFileSystem> fs = new OSFileSystem(mLocalRootPath);
+ if (mGlobal) {
+ fs->Init(mGlobal);
+ }
+
+ return fs.forget();
+}
+
+void OSFileSystem::Init(nsIGlobalObject* aGlobal) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(!mGlobal, "No duple Init() calls");
+ MOZ_ASSERT(aGlobal);
+
+ mGlobal = aGlobal;
+}
+
+nsIGlobalObject* OSFileSystem::GetParentObject() const {
+ AssertIsOnOwningThread();
+ return mGlobal;
+}
+
+bool OSFileSystem::IsSafeFile(nsIFile* aFile) const {
+ // The concept of "safe files" is specific to the Device Storage API where
+ // files are only "safe" if they're of a type that is appropriate for the
+ // area of device storage that is being used.
+ MOZ_CRASH("Don't use OSFileSystem with the Device Storage API");
+ return true;
+}
+
+bool OSFileSystem::IsSafeDirectory(Directory* aDir) const {
+ // The concept of "safe directory" is specific to the Device Storage API
+ // where a directory is only "safe" if it belongs to the area of device
+ // storage that it is being used with.
+ MOZ_CRASH("Don't use OSFileSystem with the Device Storage API");
+ return true;
+}
+
+void OSFileSystem::Unlink() {
+ AssertIsOnOwningThread();
+ mGlobal = nullptr;
+}
+
+void OSFileSystem::Traverse(nsCycleCollectionTraversalCallback& cb) {
+ AssertIsOnOwningThread();
+
+ OSFileSystem* tmp = this;
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal);
+}
+
+void OSFileSystem::SerializeDOMPath(nsAString& aOutput) const {
+ AssertIsOnOwningThread();
+ aOutput = mLocalRootPath;
+}
+
+/**
+ * OSFileSystemParent
+ */
+
+OSFileSystemParent::OSFileSystemParent(const nsAString& aRootDir) {
+ mLocalRootPath = aRootDir;
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/OSFileSystem.h b/dom/filesystem/OSFileSystem.h
new file mode 100644
index 0000000000..cb2ade7fc5
--- /dev/null
+++ b/dom/filesystem/OSFileSystem.h
@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_OSFileSystem_h
+#define mozilla_dom_OSFileSystem_h
+
+#include "mozilla/dom/FileSystemBase.h"
+
+namespace mozilla::dom {
+
+class OSFileSystem final : public FileSystemBase {
+ public:
+ explicit OSFileSystem(const nsAString& aRootDir);
+
+ void Init(nsIGlobalObject* aGlobal);
+
+ // Overrides FileSystemBase
+
+ virtual already_AddRefed<FileSystemBase> Clone() override;
+
+ virtual bool ShouldCreateDirectory() override {
+ MOZ_CRASH("This should not be called.");
+ // Because OSFileSystem should not be used when the creation of directories
+ // is needed. For that we have OSFileSystemParent.
+ return false;
+ }
+
+ virtual nsIGlobalObject* GetParentObject() const override;
+
+ virtual bool IsSafeFile(nsIFile* aFile) const override;
+
+ virtual bool IsSafeDirectory(Directory* aDir) const override;
+
+ virtual void SerializeDOMPath(nsAString& aOutput) const override;
+
+ // CC methods
+ virtual void Unlink() override;
+ virtual void Traverse(nsCycleCollectionTraversalCallback& cb) override;
+
+ private:
+ virtual ~OSFileSystem() = default;
+
+ nsCOMPtr<nsIGlobalObject> mGlobal;
+};
+
+class OSFileSystemParent final : public FileSystemBase {
+ public:
+ explicit OSFileSystemParent(const nsAString& aRootDir);
+
+ // Overrides FileSystemBase
+
+ virtual already_AddRefed<FileSystemBase> Clone() override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ return nullptr;
+ }
+
+ virtual bool ShouldCreateDirectory() override { return false; }
+
+ virtual nsIGlobalObject* GetParentObject() const override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ return nullptr;
+ }
+
+ virtual void GetDirectoryName(nsIFile* aFile, nsAString& aRetval,
+ ErrorResult& aRv) const override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ }
+
+ virtual bool IsSafeFile(nsIFile* aFile) const override { return true; }
+
+ virtual bool IsSafeDirectory(Directory* aDir) const override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ return true;
+ }
+
+ virtual void SerializeDOMPath(nsAString& aOutput) const override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ }
+
+ // CC methods
+ virtual void Unlink() override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ }
+
+ virtual void Traverse(nsCycleCollectionTraversalCallback& cb) override {
+ MOZ_CRASH("This should not be called on the PBackground thread.");
+ }
+
+ private:
+ virtual ~OSFileSystemParent() = default;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_OSFileSystem_h
diff --git a/dom/filesystem/PFileSystemParams.ipdlh b/dom/filesystem/PFileSystemParams.ipdlh
new file mode 100644
index 0000000000..40b1e095f1
--- /dev/null
+++ b/dom/filesystem/PFileSystemParams.ipdlh
@@ -0,0 +1,48 @@
+/* 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/. */
+
+namespace mozilla {
+namespace dom {
+
+struct FileSystemGetDirectoryListingParams
+{
+ nsString filesystem;
+ nsString realPath;
+ nsString domPath;
+
+ // 'filters' could be an array rather than a semicolon separated string
+ // (we'd then use nsTArray<nsString> internally), but that is
+ // wasteful. E10s requires us to pass the filters over as a string anyway,
+ // so avoiding using an array avoids serialization on the side passing the
+ // filters. Since an nsString can share its buffer when copied,
+ // using that instead of nsTArray<nsString> makes copying the filters
+ // around in any given process a bit more efficient too, since copying a
+ // single nsString is cheaper than copying nsTArray member data and
+ // each nsString that it contains.
+ nsString filters;
+};
+
+struct FileSystemGetFilesParams
+{
+ nsString filesystem;
+ nsString realPath;
+ nsString domPath;
+ bool recursiveFlag;
+};
+
+struct FileSystemGetFileOrDirectoryParams
+{
+ nsString filesystem;
+ nsString realPath;
+};
+
+union FileSystemParams
+{
+ FileSystemGetDirectoryListingParams;
+ FileSystemGetFilesParams;
+ FileSystemGetFileOrDirectoryParams;
+};
+
+} // dom namespace
+} // mozilla namespace
diff --git a/dom/filesystem/PFileSystemRequest.ipdl b/dom/filesystem/PFileSystemRequest.ipdl
new file mode 100644
index 0000000000..3ae24e269b
--- /dev/null
+++ b/dom/filesystem/PFileSystemRequest.ipdl
@@ -0,0 +1,77 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+include protocol PBackground;
+
+include IPCBlob;
+
+include "mozilla/dom/FileSystemTaskBase.h";
+
+namespace mozilla {
+namespace dom {
+
+struct FileSystemFileResponse
+{
+ IPCBlob blob;
+};
+
+struct FileSystemDirectoryResponse
+{
+ nsString realPath;
+};
+
+struct FileSystemDirectoryListingResponseFile
+{
+ IPCBlob blob;
+};
+
+struct FileSystemDirectoryListingResponseDirectory
+{
+ // This is the full real path for the directory that we are sending via IPC.
+ nsString directoryRealPath;
+};
+
+union FileSystemDirectoryListingResponseData
+{
+ FileSystemDirectoryListingResponseFile;
+ FileSystemDirectoryListingResponseDirectory;
+};
+
+struct FileSystemDirectoryListingResponse
+{
+ FileSystemDirectoryListingResponseData[] data;
+};
+
+struct FileSystemFilesResponse
+{
+ FileSystemFileResponse[] data;
+};
+
+struct FileSystemErrorResponse
+{
+ nsresult error;
+};
+
+union FileSystemResponseValue
+{
+ FileSystemDirectoryResponse;
+ FileSystemDirectoryListingResponse;
+ FileSystemFileResponse;
+ FileSystemFilesResponse;
+ FileSystemErrorResponse;
+};
+
+[ChildImpl="FileSystemTaskChildBase"]
+protocol PFileSystemRequest
+{
+ manager PBackground;
+
+child:
+ async __delete__(FileSystemResponseValue response);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/filesystem/compat/CallbackRunnables.cpp b/dom/filesystem/compat/CallbackRunnables.cpp
new file mode 100644
index 0000000000..cbdd2f2f56
--- /dev/null
+++ b/dom/filesystem/compat/CallbackRunnables.cpp
@@ -0,0 +1,280 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "CallbackRunnables.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/DirectoryBinding.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileBinding.h"
+#include "mozilla/dom/FileSystem.h"
+#include "mozilla/dom/FileSystemDirectoryReaderBinding.h"
+#include "mozilla/dom/FileSystemFileEntry.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/Unused.h"
+#include "nsIGlobalObject.h"
+#include "nsIFile.h"
+#include "nsPIDOMWindow.h"
+
+#include "../GetFileOrDirectoryTask.h"
+
+namespace mozilla::dom {
+
+EntryCallbackRunnable::EntryCallbackRunnable(FileSystemEntryCallback* aCallback,
+ FileSystemEntry* aEntry)
+ : Runnable("EntryCallbackRunnable"), mCallback(aCallback), mEntry(aEntry) {
+ MOZ_ASSERT(aCallback);
+ MOZ_ASSERT(aEntry);
+}
+
+NS_IMETHODIMP
+EntryCallbackRunnable::Run() {
+ mCallback->Call(*mEntry);
+ return NS_OK;
+}
+
+ErrorCallbackRunnable::ErrorCallbackRunnable(nsIGlobalObject* aGlobalObject,
+ ErrorCallback* aCallback,
+ nsresult aError)
+ : Runnable("ErrorCallbackRunnable"),
+ mGlobal(aGlobalObject),
+ mCallback(aCallback),
+ mError(aError) {
+ MOZ_ASSERT(aGlobalObject);
+ MOZ_ASSERT(aCallback);
+ MOZ_ASSERT(NS_FAILED(aError));
+}
+
+NS_IMETHODIMP
+ErrorCallbackRunnable::Run() {
+ RefPtr<DOMException> exception = DOMException::Create(mError);
+ mCallback->Call(*exception);
+ return NS_OK;
+}
+
+EmptyEntriesCallbackRunnable::EmptyEntriesCallbackRunnable(
+ FileSystemEntriesCallback* aCallback)
+ : Runnable("EmptyEntriesCallbackRunnable"), mCallback(aCallback) {
+ MOZ_ASSERT(aCallback);
+}
+
+NS_IMETHODIMP
+EmptyEntriesCallbackRunnable::Run() {
+ Sequence<OwningNonNull<FileSystemEntry>> sequence;
+ mCallback->Call(sequence);
+ return NS_OK;
+}
+
+GetEntryHelper::GetEntryHelper(FileSystemDirectoryEntry* aParentEntry,
+ Directory* aDirectory,
+ nsTArray<nsString>& aParts,
+ FileSystem* aFileSystem,
+ FileSystemEntryCallback* aSuccessCallback,
+ ErrorCallback* aErrorCallback,
+ FileSystemDirectoryEntry::GetInternalType aType)
+ : mParentEntry(aParentEntry),
+ mDirectory(aDirectory),
+ mParts(aParts.Clone()),
+ mFileSystem(aFileSystem),
+ mSuccessCallback(aSuccessCallback),
+ mErrorCallback(aErrorCallback),
+ mType(aType) {
+ MOZ_ASSERT(aParentEntry);
+ MOZ_ASSERT(aDirectory);
+ MOZ_ASSERT(!aParts.IsEmpty());
+ MOZ_ASSERT(aFileSystem);
+ MOZ_ASSERT(aSuccessCallback || aErrorCallback);
+}
+
+GetEntryHelper::~GetEntryHelper() = default;
+
+namespace {
+
+nsresult DOMPathToRealPath(Directory* aDirectory, const nsAString& aPath,
+ nsIFile** aFile) {
+ nsString relativePath;
+ relativePath = aPath;
+
+ // Trim white spaces.
+ static const char kWhitespace[] = "\b\t\r\n ";
+ relativePath.Trim(kWhitespace);
+
+ nsTArray<nsString> parts;
+ if (!FileSystemUtils::IsValidRelativeDOMPath(relativePath, parts)) {
+ return NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR;
+ }
+
+ nsCOMPtr<nsIFile> file;
+ nsresult rv = aDirectory->GetInternalNsIFile()->Clone(getter_AddRefs(file));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ for (uint32_t i = 0; i < parts.Length(); ++i) {
+ rv = file->AppendRelativePath(parts[i]);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ file.forget(aFile);
+ return NS_OK;
+}
+
+} // namespace
+
+void GetEntryHelper::Run() {
+ MOZ_ASSERT(!mParts.IsEmpty());
+
+ nsCOMPtr<nsIFile> realPath;
+ nsresult error =
+ DOMPathToRealPath(mDirectory, mParts[0], getter_AddRefs(realPath));
+
+ ErrorResult rv;
+ RefPtr<FileSystemBase> fs = mDirectory->GetFileSystem(rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ Error(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ RefPtr<GetFileOrDirectoryTaskChild> task =
+ GetFileOrDirectoryTaskChild::Create(fs, realPath, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ Error(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ task->SetError(error);
+ task->Start();
+
+ RefPtr<Promise> promise = task->GetPromise();
+
+ mParts.RemoveElementAt(0);
+ promise->AppendNativeHandler(this);
+}
+
+void GetEntryHelper::ResolvedCallback(JSContext* aCx,
+ JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) {
+ if (NS_WARN_IF(!aValue.isObject())) {
+ return;
+ }
+
+ JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
+
+ // This is not the last part of the path.
+ if (!mParts.IsEmpty()) {
+ ContinueRunning(obj);
+ return;
+ }
+
+ CompleteOperation(obj);
+}
+
+void GetEntryHelper::CompleteOperation(JSObject* aObj) {
+ MOZ_ASSERT(mParts.IsEmpty());
+
+ if (mType == FileSystemDirectoryEntry::eGetFile) {
+ RefPtr<File> file;
+ if (NS_FAILED(UNWRAP_OBJECT(File, aObj, file))) {
+ Error(NS_ERROR_DOM_TYPE_MISMATCH_ERR);
+ return;
+ }
+
+ RefPtr<FileSystemFileEntry> entry = new FileSystemFileEntry(
+ mParentEntry->GetParentObject(), file, mParentEntry, mFileSystem);
+ mSuccessCallback->Call(*entry);
+ return;
+ }
+
+ MOZ_ASSERT(mType == FileSystemDirectoryEntry::eGetDirectory);
+
+ RefPtr<Directory> directory;
+ if (NS_FAILED(UNWRAP_OBJECT(Directory, aObj, directory))) {
+ Error(NS_ERROR_DOM_TYPE_MISMATCH_ERR);
+ return;
+ }
+
+ RefPtr<FileSystemDirectoryEntry> entry = new FileSystemDirectoryEntry(
+ mParentEntry->GetParentObject(), directory, mParentEntry, mFileSystem);
+ mSuccessCallback->Call(*entry);
+}
+
+void GetEntryHelper::ContinueRunning(JSObject* aObj) {
+ MOZ_ASSERT(!mParts.IsEmpty());
+
+ RefPtr<Directory> directory;
+ if (NS_FAILED(UNWRAP_OBJECT(Directory, aObj, directory))) {
+ Error(NS_ERROR_DOM_TYPE_MISMATCH_ERR);
+ return;
+ }
+
+ RefPtr<FileSystemDirectoryEntry> entry = new FileSystemDirectoryEntry(
+ mParentEntry->GetParentObject(), directory, mParentEntry, mFileSystem);
+
+ // Update the internal values.
+ mParentEntry = entry;
+ mDirectory = directory;
+
+ Run();
+}
+
+void GetEntryHelper::RejectedCallback(JSContext* aCx,
+ JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) {
+ Error(NS_ERROR_DOM_NOT_FOUND_ERR);
+}
+
+void GetEntryHelper::Error(nsresult aError) {
+ MOZ_ASSERT(NS_FAILED(aError));
+
+ if (mErrorCallback) {
+ RefPtr<ErrorCallbackRunnable> runnable = new ErrorCallbackRunnable(
+ mParentEntry->GetParentObject(), mErrorCallback, aError);
+
+ FileSystemUtils::DispatchRunnable(mParentEntry->GetParentObject(),
+ runnable.forget());
+ }
+}
+
+NS_IMPL_ISUPPORTS0(GetEntryHelper);
+
+/* static */
+void FileSystemEntryCallbackHelper::Call(
+ nsIGlobalObject* aGlobalObject,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aEntryCallback,
+ FileSystemEntry* aEntry) {
+ MOZ_ASSERT(aGlobalObject);
+ MOZ_ASSERT(aEntry);
+
+ if (aEntryCallback.WasPassed()) {
+ RefPtr<EntryCallbackRunnable> runnable =
+ new EntryCallbackRunnable(&aEntryCallback.Value(), aEntry);
+
+ FileSystemUtils::DispatchRunnable(aGlobalObject, runnable.forget());
+ }
+}
+
+/* static */
+void ErrorCallbackHelper::Call(
+ nsIGlobalObject* aGlobal,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ nsresult aError) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(NS_FAILED(aError));
+
+ if (aErrorCallback.WasPassed()) {
+ RefPtr<ErrorCallbackRunnable> runnable =
+ new ErrorCallbackRunnable(aGlobal, &aErrorCallback.Value(), aError);
+
+ FileSystemUtils::DispatchRunnable(aGlobal, runnable.forget());
+ }
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/CallbackRunnables.h b/dom/filesystem/compat/CallbackRunnables.h
new file mode 100644
index 0000000000..e2e1c47913
--- /dev/null
+++ b/dom/filesystem/compat/CallbackRunnables.h
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_ErrorCallbackRunnable_h
+#define mozilla_dom_ErrorCallbackRunnable_h
+
+#include "FileSystemDirectoryEntry.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+#include "nsThreadUtils.h"
+
+class nsIGlobalObject;
+
+namespace mozilla::dom {
+
+class FileSystemEntriesCallback;
+
+class EntryCallbackRunnable final : public Runnable {
+ public:
+ EntryCallbackRunnable(FileSystemEntryCallback* aCallback,
+ FileSystemEntry* aEntry);
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
+ // bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override;
+
+ private:
+ const RefPtr<FileSystemEntryCallback> mCallback;
+ const RefPtr<FileSystemEntry> mEntry;
+};
+
+class ErrorCallbackRunnable final : public Runnable {
+ public:
+ ErrorCallbackRunnable(nsIGlobalObject* aGlobalObject,
+ ErrorCallback* aCallback, nsresult aError);
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
+ // bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override;
+
+ private:
+ nsCOMPtr<nsIGlobalObject> mGlobal;
+ const RefPtr<ErrorCallback> mCallback;
+ nsresult mError;
+};
+
+class EmptyEntriesCallbackRunnable final : public Runnable {
+ public:
+ explicit EmptyEntriesCallbackRunnable(FileSystemEntriesCallback* aCallback);
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
+ // bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override;
+
+ private:
+ const RefPtr<FileSystemEntriesCallback> mCallback;
+};
+
+class GetEntryHelper final : public PromiseNativeHandler {
+ public:
+ NS_DECL_ISUPPORTS
+
+ GetEntryHelper(FileSystemDirectoryEntry* aParentEntry, Directory* aDirectory,
+ nsTArray<nsString>& aParts, FileSystem* aFileSystem,
+ FileSystemEntryCallback* aSuccessCallback,
+ ErrorCallback* aErrorCallback,
+ FileSystemDirectoryEntry::GetInternalType aType);
+
+ void Run();
+
+ MOZ_CAN_RUN_SCRIPT
+ virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) override;
+
+ virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) override;
+
+ private:
+ ~GetEntryHelper();
+
+ void Error(nsresult aError);
+
+ void ContinueRunning(JSObject* aObj);
+
+ MOZ_CAN_RUN_SCRIPT void CompleteOperation(JSObject* aObj);
+
+ RefPtr<FileSystemDirectoryEntry> mParentEntry;
+ RefPtr<Directory> mDirectory;
+ nsTArray<nsString> mParts;
+ RefPtr<FileSystem> mFileSystem;
+
+ const RefPtr<FileSystemEntryCallback> mSuccessCallback;
+ RefPtr<ErrorCallback> mErrorCallback;
+
+ FileSystemDirectoryEntry::GetInternalType mType;
+};
+
+class FileSystemEntryCallbackHelper {
+ public:
+ static void Call(
+ nsIGlobalObject* aGlobalObject,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aEntryCallback,
+ FileSystemEntry* aEntry);
+};
+
+class ErrorCallbackHelper {
+ public:
+ static void Call(nsIGlobalObject* aGlobal,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ nsresult aError);
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_CallbackRunnables_h
diff --git a/dom/filesystem/compat/FileSystem.cpp b/dom/filesystem/compat/FileSystem.cpp
new file mode 100644
index 0000000000..734b3ec600
--- /dev/null
+++ b/dom/filesystem/compat/FileSystem.cpp
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystem.h"
+#include "FileSystemRootDirectoryEntry.h"
+#include "mozilla/dom/FileSystemBinding.h"
+#include "nsIDUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FileSystem, mParent, mRoot)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(FileSystem)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(FileSystem)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystem)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/* static */
+already_AddRefed<FileSystem> FileSystem::Create(nsIGlobalObject* aGlobalObject)
+
+{
+ MOZ_ASSERT(aGlobalObject);
+
+ nsID id;
+ nsresult rv = nsID::GenerateUUIDInPlace(id);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return nullptr;
+ }
+
+ NSID_TrimBracketsUTF16 name(id);
+
+ RefPtr<FileSystem> fs = new FileSystem(aGlobalObject, name);
+
+ return fs.forget();
+}
+
+FileSystem::FileSystem(nsIGlobalObject* aGlobal, const nsAString& aName)
+ : mParent(aGlobal), mName(aName) {
+ MOZ_ASSERT(aGlobal);
+}
+
+FileSystem::~FileSystem() = default;
+
+JSObject* FileSystem::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return FileSystem_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void FileSystem::CreateRoot(const Sequence<RefPtr<FileSystemEntry>>& aEntries) {
+ MOZ_ASSERT(!mRoot);
+ mRoot = new FileSystemRootDirectoryEntry(mParent, aEntries, this);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystem.h b/dom/filesystem/compat/FileSystem.h
new file mode 100644
index 0000000000..92cb563ef4
--- /dev/null
+++ b/dom/filesystem/compat/FileSystem.h
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystem_h
+#define mozilla_dom_FileSystem_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+class nsIGlobalObject;
+
+namespace mozilla::dom {
+
+class FileSystemDirectoryEntry;
+class FileSystemEntry;
+class OwningFileOrDirectory;
+
+class FileSystem final : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(FileSystem)
+
+ static already_AddRefed<FileSystem> Create(nsIGlobalObject* aGlobalObject);
+
+ nsIGlobalObject* GetParentObject() const { return mParent; }
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ void GetName(nsAString& aName) const { aName = mName; }
+
+ FileSystemDirectoryEntry* Root() const { return mRoot; }
+
+ void CreateRoot(const Sequence<RefPtr<FileSystemEntry>>& aEntries);
+
+ private:
+ explicit FileSystem(nsIGlobalObject* aGlobalObject, const nsAString& aName);
+ ~FileSystem();
+
+ nsCOMPtr<nsIGlobalObject> mParent;
+ RefPtr<FileSystemDirectoryEntry> mRoot;
+ nsString mName;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystem_h
diff --git a/dom/filesystem/compat/FileSystemDirectoryEntry.cpp b/dom/filesystem/compat/FileSystemDirectoryEntry.cpp
new file mode 100644
index 0000000000..7358f997f0
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemDirectoryEntry.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemDirectoryEntry.h"
+#include "CallbackRunnables.h"
+#include "FileSystemDirectoryReader.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileSystemDirectoryEntryBinding.h"
+#include "mozilla/dom/FileSystemUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(FileSystemDirectoryEntry, FileSystemEntry,
+ mDirectory)
+
+NS_IMPL_ADDREF_INHERITED(FileSystemDirectoryEntry, FileSystemEntry)
+NS_IMPL_RELEASE_INHERITED(FileSystemDirectoryEntry, FileSystemEntry)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemDirectoryEntry)
+NS_INTERFACE_MAP_END_INHERITING(FileSystemEntry)
+
+FileSystemDirectoryEntry::FileSystemDirectoryEntry(
+ nsIGlobalObject* aGlobal, Directory* aDirectory,
+ FileSystemDirectoryEntry* aParentEntry, FileSystem* aFileSystem)
+ : FileSystemEntry(aGlobal, aParentEntry, aFileSystem),
+ mDirectory(aDirectory) {
+ MOZ_ASSERT(aGlobal);
+}
+
+FileSystemDirectoryEntry::~FileSystemDirectoryEntry() = default;
+
+JSObject* FileSystemDirectoryEntry::WrapObject(
+ JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+ return FileSystemDirectoryEntry_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void FileSystemDirectoryEntry::GetName(nsAString& aName,
+ ErrorResult& aRv) const {
+ MOZ_ASSERT(mDirectory);
+ mDirectory->GetName(aName, aRv);
+}
+
+void FileSystemDirectoryEntry::GetFullPath(nsAString& aPath,
+ ErrorResult& aRv) const {
+ MOZ_ASSERT(mDirectory);
+ mDirectory->GetPath(aPath, aRv);
+}
+
+already_AddRefed<FileSystemDirectoryReader>
+FileSystemDirectoryEntry::CreateReader() {
+ MOZ_ASSERT(mDirectory);
+
+ RefPtr<FileSystemDirectoryReader> reader =
+ new FileSystemDirectoryReader(this, Filesystem(), mDirectory);
+ return reader.forget();
+}
+
+void FileSystemDirectoryEntry::GetInternal(
+ const nsAString& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ GetInternalType aType) {
+ MOZ_ASSERT(mDirectory);
+
+ if (!aSuccessCallback.WasPassed() && !aErrorCallback.WasPassed()) {
+ return;
+ }
+
+ if (aFlag.mCreate) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_SECURITY_ERR);
+ return;
+ }
+
+ nsTArray<nsString> parts;
+ if (!FileSystemUtils::IsValidRelativeDOMPath(aPath, parts)) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ RefPtr<GetEntryHelper> helper = new GetEntryHelper(
+ this, mDirectory, parts, Filesystem(),
+ aSuccessCallback.WasPassed() ? &aSuccessCallback.Value() : nullptr,
+ aErrorCallback.WasPassed() ? &aErrorCallback.Value() : nullptr, aType);
+ helper->Run();
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemDirectoryEntry.h b/dom/filesystem/compat/FileSystemDirectoryEntry.h
new file mode 100644
index 0000000000..1b772691e1
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemDirectoryEntry.h
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemDirectoryEntry_h
+#define mozilla_dom_FileSystemDirectoryEntry_h
+
+#include "mozilla/dom/FileSystemEntry.h"
+
+namespace mozilla::dom {
+
+class Directory;
+class FileSystemDirectoryReader;
+
+class FileSystemDirectoryEntry : public FileSystemEntry {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FileSystemDirectoryEntry,
+ FileSystemEntry)
+
+ FileSystemDirectoryEntry(nsIGlobalObject* aGlobalObject,
+ Directory* aDirectory,
+ FileSystemDirectoryEntry* aParentEntry,
+ FileSystem* aFileSystem);
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ virtual bool IsDirectory() const override { return true; }
+
+ virtual void GetName(nsAString& aName, ErrorResult& aRv) const override;
+
+ virtual void GetFullPath(nsAString& aFullPath,
+ ErrorResult& aRv) const override;
+
+ virtual already_AddRefed<FileSystemDirectoryReader> CreateReader();
+
+ void GetFile(
+ const Optional<nsAString>& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) {
+ GetInternal(aPath.WasPassed() ? aPath.Value() : u""_ns, aFlag,
+ aSuccessCallback, aErrorCallback, eGetFile);
+ }
+
+ void GetDirectory(
+ const Optional<nsAString>& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) {
+ GetInternal(aPath.WasPassed() ? aPath.Value() : u""_ns, aFlag,
+ aSuccessCallback, aErrorCallback, eGetDirectory);
+ }
+
+ enum GetInternalType { eGetFile, eGetDirectory };
+
+ virtual void GetInternal(
+ const nsAString& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ GetInternalType aType);
+
+ protected:
+ virtual ~FileSystemDirectoryEntry();
+
+ private:
+ RefPtr<Directory> mDirectory;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemDirectoryEntry_h
diff --git a/dom/filesystem/compat/FileSystemDirectoryReader.cpp b/dom/filesystem/compat/FileSystemDirectoryReader.cpp
new file mode 100644
index 0000000000..533faae413
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemDirectoryReader.cpp
@@ -0,0 +1,181 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemDirectoryReader.h"
+#include "CallbackRunnables.h"
+#include "FileSystemFileEntry.h"
+#include "js/Array.h" // JS::NewArrayObject
+#include "js/PropertyAndElement.h" // JS_GetElement
+#include "mozilla/dom/FileBinding.h"
+#include "mozilla/dom/FileSystem.h"
+#include "mozilla/dom/FileSystemDirectoryReaderBinding.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/DirectoryBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+class PromiseHandler final : public PromiseNativeHandler {
+ public:
+ NS_DECL_ISUPPORTS
+
+ PromiseHandler(FileSystemDirectoryEntry* aParentEntry,
+ FileSystem* aFileSystem,
+ FileSystemEntriesCallback* aSuccessCallback,
+ ErrorCallback* aErrorCallback)
+ : mParentEntry(aParentEntry),
+ mFileSystem(aFileSystem),
+ mSuccessCallback(aSuccessCallback),
+ mErrorCallback(aErrorCallback) {
+ MOZ_ASSERT(aParentEntry);
+ MOZ_ASSERT(aFileSystem);
+ MOZ_ASSERT(aSuccessCallback);
+ }
+
+ MOZ_CAN_RUN_SCRIPT
+ virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) override {
+ if (NS_WARN_IF(!aValue.isObject())) {
+ return;
+ }
+
+ JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
+
+ uint32_t length;
+ if (NS_WARN_IF(!JS::GetArrayLength(aCx, obj, &length))) {
+ return;
+ }
+
+ Sequence<OwningNonNull<FileSystemEntry>> sequence;
+ if (NS_WARN_IF(!sequence.SetLength(length, fallible))) {
+ return;
+ }
+
+ for (uint32_t i = 0; i < length; ++i) {
+ JS::Rooted<JS::Value> value(aCx);
+ if (NS_WARN_IF(!JS_GetElement(aCx, obj, i, &value))) {
+ return;
+ }
+
+ if (NS_WARN_IF(!value.isObject())) {
+ return;
+ }
+
+ JS::Rooted<JSObject*> valueObj(aCx, &value.toObject());
+
+ RefPtr<File> file;
+ if (NS_SUCCEEDED(UNWRAP_OBJECT(File, valueObj, file))) {
+ RefPtr<FileSystemFileEntry> entry = new FileSystemFileEntry(
+ mParentEntry->GetParentObject(), file, mParentEntry, mFileSystem);
+ sequence[i] = entry;
+ continue;
+ }
+
+ RefPtr<Directory> directory;
+ if (NS_WARN_IF(
+ NS_FAILED(UNWRAP_OBJECT(Directory, valueObj, directory)))) {
+ return;
+ }
+
+ RefPtr<FileSystemDirectoryEntry> entry =
+ new FileSystemDirectoryEntry(mParentEntry->GetParentObject(),
+ directory, mParentEntry, mFileSystem);
+ sequence[i] = entry;
+ }
+
+ mSuccessCallback->Call(sequence);
+ }
+
+ virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+ ErrorResult& aRv) override {
+ if (mErrorCallback) {
+ RefPtr<ErrorCallbackRunnable> runnable = new ErrorCallbackRunnable(
+ mParentEntry->GetParentObject(), mErrorCallback,
+ NS_ERROR_DOM_INVALID_STATE_ERR);
+
+ FileSystemUtils::DispatchRunnable(mParentEntry->GetParentObject(),
+ runnable.forget());
+ }
+ }
+
+ private:
+ ~PromiseHandler() = default;
+
+ RefPtr<FileSystemDirectoryEntry> mParentEntry;
+ RefPtr<FileSystem> mFileSystem;
+ const RefPtr<FileSystemEntriesCallback> mSuccessCallback;
+ RefPtr<ErrorCallback> mErrorCallback;
+};
+
+NS_IMPL_ISUPPORTS0(PromiseHandler);
+
+} // anonymous namespace
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FileSystemDirectoryReader, mParentEntry,
+ mDirectory, mFileSystem)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(FileSystemDirectoryReader)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(FileSystemDirectoryReader)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemDirectoryReader)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+FileSystemDirectoryReader::FileSystemDirectoryReader(
+ FileSystemDirectoryEntry* aParentEntry, FileSystem* aFileSystem,
+ Directory* aDirectory)
+ : mParentEntry(aParentEntry),
+ mFileSystem(aFileSystem),
+ mDirectory(aDirectory),
+ mAlreadyRead(false) {
+ MOZ_ASSERT(aParentEntry);
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemDirectoryReader::~FileSystemDirectoryReader() = default;
+
+JSObject* FileSystemDirectoryReader::WrapObject(
+ JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+ return FileSystemDirectoryReader_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void FileSystemDirectoryReader::ReadEntries(
+ FileSystemEntriesCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(mDirectory);
+
+ if (mAlreadyRead) {
+ RefPtr<EmptyEntriesCallbackRunnable> runnable =
+ new EmptyEntriesCallbackRunnable(&aSuccessCallback);
+
+ FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
+ return;
+ }
+
+ // This object can be used only once.
+ mAlreadyRead = true;
+
+ ErrorResult rv;
+ RefPtr<Promise> promise = mDirectory->GetFilesAndDirectories(rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ rv.StealNSResult());
+ return;
+ }
+
+ RefPtr<PromiseHandler> handler = new PromiseHandler(
+ mParentEntry, mFileSystem, &aSuccessCallback,
+ aErrorCallback.WasPassed() ? &aErrorCallback.Value() : nullptr);
+ promise->AppendNativeHandler(handler);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemDirectoryReader.h b/dom/filesystem/compat/FileSystemDirectoryReader.h
new file mode 100644
index 0000000000..90274943b4
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemDirectoryReader.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemDirectoryReader_h
+#define mozilla_dom_FileSystemDirectoryReader_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/FileSystemDirectoryEntry.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class Directory;
+class FileSystem;
+class FileSystemEntriesCallback;
+
+class FileSystemDirectoryReader : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(FileSystemDirectoryReader)
+
+ explicit FileSystemDirectoryReader(FileSystemDirectoryEntry* aDirectoryEntry,
+ FileSystem* aFileSystem,
+ Directory* aDirectory);
+
+ nsIGlobalObject* GetParentObject() const {
+ return mParentEntry->GetParentObject();
+ }
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ virtual void ReadEntries(
+ FileSystemEntriesCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ ErrorResult& aRv);
+
+ protected:
+ virtual ~FileSystemDirectoryReader();
+
+ private:
+ RefPtr<FileSystemDirectoryEntry> mParentEntry;
+ RefPtr<FileSystem> mFileSystem;
+ RefPtr<Directory> mDirectory;
+
+ bool mAlreadyRead;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_FileSystemDirectoryReader_h
diff --git a/dom/filesystem/compat/FileSystemEntry.cpp b/dom/filesystem/compat/FileSystemEntry.cpp
new file mode 100644
index 0000000000..3a69e2537a
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemEntry.cpp
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemEntry.h"
+#include "CallbackRunnables.h"
+#include "FileSystem.h"
+#include "FileSystemDirectoryEntry.h"
+#include "FileSystemFileEntry.h"
+#include "mozilla/dom/FileSystemEntryBinding.h"
+#include "mozilla/dom/UnionTypes.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FileSystemEntry, mParent, mParentEntry,
+ mFileSystem)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(FileSystemEntry)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(FileSystemEntry)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemEntry)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/* static */
+already_AddRefed<FileSystemEntry> FileSystemEntry::Create(
+ nsIGlobalObject* aGlobalObject,
+ const OwningFileOrDirectory& aFileOrDirectory, FileSystem* aFileSystem) {
+ MOZ_ASSERT(aGlobalObject);
+ MOZ_ASSERT(aFileSystem);
+
+ RefPtr<FileSystemEntry> entry;
+ if (aFileOrDirectory.IsFile()) {
+ entry = new FileSystemFileEntry(aGlobalObject, aFileOrDirectory.GetAsFile(),
+ nullptr, aFileSystem);
+ } else {
+ MOZ_ASSERT(aFileOrDirectory.IsDirectory());
+ entry = new FileSystemDirectoryEntry(
+ aGlobalObject, aFileOrDirectory.GetAsDirectory(), nullptr, aFileSystem);
+ }
+
+ return entry.forget();
+}
+
+FileSystemEntry::FileSystemEntry(nsIGlobalObject* aGlobal,
+ FileSystemEntry* aParentEntry,
+ FileSystem* aFileSystem)
+ : mParent(aGlobal), mParentEntry(aParentEntry), mFileSystem(aFileSystem) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemEntry::~FileSystemEntry() = default;
+
+JSObject* FileSystemEntry::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return FileSystemEntry_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void FileSystemEntry::GetParent(
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) {
+ if (!aSuccessCallback.WasPassed() && !aErrorCallback.WasPassed()) {
+ return;
+ }
+
+ if (mParentEntry) {
+ FileSystemEntryCallbackHelper::Call(GetParentObject(), aSuccessCallback,
+ mParentEntry);
+ return;
+ }
+
+ FileSystemEntryCallbackHelper::Call(GetParentObject(), aSuccessCallback,
+ this);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemEntry.h b/dom/filesystem/compat/FileSystemEntry.h
new file mode 100644
index 0000000000..2275c600a9
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemEntry.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemEntry_h
+#define mozilla_dom_FileSystemEntry_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/FileSystemBinding.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIGlobalObject.h"
+#include "nsWrapperCache.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class FileSystem;
+class OwningFileOrDirectory;
+
+class FileSystemEntry : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(FileSystemEntry)
+
+ static already_AddRefed<FileSystemEntry> Create(
+ nsIGlobalObject* aGlobalObject,
+ const OwningFileOrDirectory& aFileOrDirectory, FileSystem* aFileSystem);
+
+ nsIGlobalObject* GetParentObject() const { return mParent; }
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ virtual bool IsFile() const { return false; }
+
+ virtual bool IsDirectory() const { return false; }
+
+ virtual void GetName(nsAString& aName, ErrorResult& aRv) const = 0;
+
+ virtual void GetFullPath(nsAString& aFullPath, ErrorResult& aRv) const = 0;
+
+ void GetParent(
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback);
+
+ FileSystem* Filesystem() const { return mFileSystem; }
+
+ protected:
+ FileSystemEntry(nsIGlobalObject* aGlobalObject, FileSystemEntry* aParentEntry,
+ FileSystem* aFileSystem);
+ virtual ~FileSystemEntry();
+
+ private:
+ nsCOMPtr<nsIGlobalObject> mParent;
+ RefPtr<FileSystemEntry> mParentEntry;
+ RefPtr<FileSystem> mFileSystem;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_FileSystemEntry_h
diff --git a/dom/filesystem/compat/FileSystemFileEntry.cpp b/dom/filesystem/compat/FileSystemFileEntry.cpp
new file mode 100644
index 0000000000..59216641cc
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemFileEntry.cpp
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemFileEntry.h"
+#include "CallbackRunnables.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/MultipartBlobImpl.h"
+#include "mozilla/dom/FileSystemFileEntryBinding.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+class FileCallbackRunnable final : public Runnable {
+ public:
+ FileCallbackRunnable(FileCallback* aCallback, File* aFile)
+ : Runnable("FileCallbackRunnable"), mCallback(aCallback), mFile(aFile) {
+ MOZ_ASSERT(aCallback);
+ MOZ_ASSERT(aFile);
+ }
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
+ // bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+ // Here we clone the File object.
+
+ RefPtr<File> file = File::Create(mFile->GetParentObject(), mFile->Impl());
+ mCallback->Call(*file);
+ return NS_OK;
+ }
+
+ private:
+ const RefPtr<FileCallback> mCallback;
+ RefPtr<File> mFile;
+};
+
+} // anonymous namespace
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(FileSystemFileEntry, FileSystemEntry, mFile)
+
+NS_IMPL_ADDREF_INHERITED(FileSystemFileEntry, FileSystemEntry)
+NS_IMPL_RELEASE_INHERITED(FileSystemFileEntry, FileSystemEntry)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemFileEntry)
+NS_INTERFACE_MAP_END_INHERITING(FileSystemEntry)
+
+FileSystemFileEntry::FileSystemFileEntry(nsIGlobalObject* aGlobal, File* aFile,
+ FileSystemDirectoryEntry* aParentEntry,
+ FileSystem* aFileSystem)
+ : FileSystemEntry(aGlobal, aParentEntry, aFileSystem), mFile(aFile) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(mFile);
+}
+
+FileSystemFileEntry::~FileSystemFileEntry() = default;
+
+JSObject* FileSystemFileEntry::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return FileSystemFileEntry_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void FileSystemFileEntry::GetName(nsAString& aName, ErrorResult& aRv) const {
+ mFile->GetName(aName);
+}
+
+void FileSystemFileEntry::GetFullPath(nsAString& aPath,
+ ErrorResult& aRv) const {
+ mFile->Impl()->GetDOMPath(aPath);
+ if (aPath.IsEmpty()) {
+ // We're under the root directory. webkitRelativePath
+ // (implemented as GetPath) is for cases when file is selected because its
+ // ancestor directory is selected. But that is not the case here, so need to
+ // manually prepend '/'.
+ nsAutoString name;
+ mFile->GetName(name);
+ aPath.AssignLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+ aPath.Append(name);
+ }
+}
+
+void FileSystemFileEntry::GetFile(
+ FileCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) const {
+ RefPtr<FileCallbackRunnable> runnable =
+ new FileCallbackRunnable(&aSuccessCallback, mFile);
+
+ FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemFileEntry.h b/dom/filesystem/compat/FileSystemFileEntry.h
new file mode 100644
index 0000000000..1fe244a66b
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemFileEntry.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemFileEntry_h
+#define mozilla_dom_FileSystemFileEntry_h
+
+#include "mozilla/dom/FileSystemEntry.h"
+
+namespace mozilla::dom {
+
+class File;
+class FileCallback;
+class FileSystemDirectoryEntry;
+
+class FileSystemFileEntry final : public FileSystemEntry {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FileSystemFileEntry, FileSystemEntry)
+
+ FileSystemFileEntry(nsIGlobalObject* aGlobalObject, File* aFile,
+ FileSystemDirectoryEntry* aParentEntry,
+ FileSystem* aFileSystem);
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ virtual bool IsFile() const override { return true; }
+
+ virtual void GetName(nsAString& aName, ErrorResult& aRv) const override;
+
+ virtual void GetFullPath(nsAString& aFullPath,
+ ErrorResult& aRv) const override;
+
+ void GetFile(
+ FileCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) const;
+
+ private:
+ ~FileSystemFileEntry();
+
+ RefPtr<File> mFile;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemFileEntry_h
diff --git a/dom/filesystem/compat/FileSystemRootDirectoryEntry.cpp b/dom/filesystem/compat/FileSystemRootDirectoryEntry.cpp
new file mode 100644
index 0000000000..fad6243d15
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemRootDirectoryEntry.cpp
@@ -0,0 +1,138 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemRootDirectoryEntry.h"
+#include "FileSystemRootDirectoryReader.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "CallbackRunnables.h"
+#include "nsReadableUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(FileSystemRootDirectoryEntry,
+ FileSystemDirectoryEntry, mEntries)
+
+NS_IMPL_ADDREF_INHERITED(FileSystemRootDirectoryEntry, FileSystemDirectoryEntry)
+NS_IMPL_RELEASE_INHERITED(FileSystemRootDirectoryEntry,
+ FileSystemDirectoryEntry)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemRootDirectoryEntry)
+NS_INTERFACE_MAP_END_INHERITING(FileSystemDirectoryEntry)
+
+FileSystemRootDirectoryEntry::FileSystemRootDirectoryEntry(
+ nsIGlobalObject* aGlobal, Sequence<RefPtr<FileSystemEntry>> aEntries,
+ FileSystem* aFileSystem)
+ : FileSystemDirectoryEntry(aGlobal, nullptr, nullptr, aFileSystem),
+ mEntries(std::move(aEntries)) {
+ MOZ_ASSERT(aGlobal);
+}
+
+FileSystemRootDirectoryEntry::~FileSystemRootDirectoryEntry() = default;
+
+void FileSystemRootDirectoryEntry::GetName(nsAString& aName,
+ ErrorResult& aRv) const {
+ aName.Truncate();
+}
+
+void FileSystemRootDirectoryEntry::GetFullPath(nsAString& aPath,
+ ErrorResult& aRv) const {
+ aPath.AssignLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
+}
+
+already_AddRefed<FileSystemDirectoryReader>
+FileSystemRootDirectoryEntry::CreateReader() {
+ RefPtr<FileSystemDirectoryReader> reader =
+ new FileSystemRootDirectoryReader(this, Filesystem(), mEntries);
+ return reader.forget();
+}
+
+void FileSystemRootDirectoryEntry::GetInternal(
+ const nsAString& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ GetInternalType aType) {
+ if (!aSuccessCallback.WasPassed() && !aErrorCallback.WasPassed()) {
+ return;
+ }
+
+ if (aFlag.mCreate) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_SECURITY_ERR);
+ return;
+ }
+
+ nsTArray<nsString> parts;
+ if (!FileSystemUtils::IsValidRelativeDOMPath(aPath, parts)) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ MOZ_ASSERT(!parts.IsEmpty());
+
+ RefPtr<FileSystemEntry> entry;
+ for (uint32_t i = 0; i < mEntries.Length(); ++i) {
+ ErrorResult rv;
+ nsAutoString name;
+ mEntries[i]->GetName(name, rv);
+
+ if (NS_WARN_IF(rv.Failed())) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ rv.StealNSResult());
+ return;
+ }
+
+ if (name == parts[0]) {
+ entry = mEntries[i];
+ break;
+ }
+ }
+
+ // Not found.
+ if (!entry) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ // No subdirectory in the path.
+ if (parts.Length() == 1) {
+ if ((entry->IsFile() && aType == eGetDirectory) ||
+ (entry->IsDirectory() && aType == eGetFile)) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_TYPE_MISMATCH_ERR);
+ return;
+ }
+
+ if (aSuccessCallback.WasPassed()) {
+ RefPtr<EntryCallbackRunnable> runnable =
+ new EntryCallbackRunnable(&aSuccessCallback.Value(), entry);
+
+ FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
+ }
+ return;
+ }
+
+ // Subdirectories, but this is a file.
+ if (entry->IsFile()) {
+ ErrorCallbackHelper::Call(GetParentObject(), aErrorCallback,
+ NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ // Let's recreate a path without the first directory.
+ nsAutoString path;
+ StringJoinAppend(
+ path,
+ NS_LITERAL_STRING_FROM_CSTRING(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL),
+ Span{parts}.From(1));
+
+ auto* directoryEntry = static_cast<FileSystemDirectoryEntry*>(entry.get());
+ directoryEntry->GetInternal(path, aFlag, aSuccessCallback, aErrorCallback,
+ aType);
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemRootDirectoryEntry.h b/dom/filesystem/compat/FileSystemRootDirectoryEntry.h
new file mode 100644
index 0000000000..b6ffb976b8
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemRootDirectoryEntry.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemRootDirectoryEntry_h
+#define mozilla_dom_FileSystemRootDirectoryEntry_h
+
+#include "mozilla/dom/FileSystemDirectoryEntry.h"
+
+namespace mozilla::dom {
+
+class FileSystemRootDirectoryEntry final : public FileSystemDirectoryEntry {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FileSystemRootDirectoryEntry,
+ FileSystemDirectoryEntry)
+
+ FileSystemRootDirectoryEntry(nsIGlobalObject* aGlobalObject,
+ Sequence<RefPtr<FileSystemEntry>> aEntries,
+ FileSystem* aFileSystem);
+
+ virtual void GetName(nsAString& aName, ErrorResult& aRv) const override;
+
+ virtual void GetFullPath(nsAString& aFullPath,
+ ErrorResult& aRv) const override;
+
+ virtual already_AddRefed<FileSystemDirectoryReader> CreateReader() override;
+
+ private:
+ ~FileSystemRootDirectoryEntry();
+
+ virtual void GetInternal(
+ const nsAString& aPath, const FileSystemFlags& aFlag,
+ const Optional<OwningNonNull<FileSystemEntryCallback>>& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ GetInternalType aType) override;
+
+ void Error(const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ nsresult aError) const;
+
+ Sequence<RefPtr<FileSystemEntry>> mEntries;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemRootDirectoryEntry_h
diff --git a/dom/filesystem/compat/FileSystemRootDirectoryReader.cpp b/dom/filesystem/compat/FileSystemRootDirectoryReader.cpp
new file mode 100644
index 0000000000..5d30f0c1cb
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemRootDirectoryReader.cpp
@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "FileSystemRootDirectoryReader.h"
+#include "CallbackRunnables.h"
+#include "nsIGlobalObject.h"
+#include "mozilla/dom/FileSystemDirectoryReaderBinding.h"
+#include "mozilla/dom/FileSystemUtils.h"
+
+namespace mozilla::dom {
+
+namespace {
+
+class EntriesCallbackRunnable final : public Runnable {
+ public:
+ EntriesCallbackRunnable(FileSystemEntriesCallback* aCallback,
+ const Sequence<RefPtr<FileSystemEntry>>& aEntries)
+ : Runnable("EntriesCallbackRunnable"),
+ mCallback(aCallback),
+ mEntries(aEntries) {
+ MOZ_ASSERT(aCallback);
+ }
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See
+ // bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+ Sequence<OwningNonNull<FileSystemEntry>> entries;
+ for (uint32_t i = 0; i < mEntries.Length(); ++i) {
+ if (!entries.AppendElement(mEntries[i].forget(), fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ mCallback->Call(entries);
+ return NS_OK;
+ }
+
+ private:
+ const RefPtr<FileSystemEntriesCallback> mCallback;
+ Sequence<RefPtr<FileSystemEntry>> mEntries;
+};
+
+} // anonymous namespace
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(FileSystemRootDirectoryReader,
+ FileSystemDirectoryReader, mEntries)
+
+NS_IMPL_ADDREF_INHERITED(FileSystemRootDirectoryReader,
+ FileSystemDirectoryReader)
+NS_IMPL_RELEASE_INHERITED(FileSystemRootDirectoryReader,
+ FileSystemDirectoryReader)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystemRootDirectoryReader)
+NS_INTERFACE_MAP_END_INHERITING(FileSystemDirectoryReader)
+
+FileSystemRootDirectoryReader::FileSystemRootDirectoryReader(
+ FileSystemDirectoryEntry* aParentEntry, FileSystem* aFileSystem,
+ const Sequence<RefPtr<FileSystemEntry>>& aEntries)
+ : FileSystemDirectoryReader(aParentEntry, aFileSystem, nullptr),
+ mEntries(aEntries),
+ mAlreadyRead(false) {
+ MOZ_ASSERT(aParentEntry);
+ MOZ_ASSERT(aFileSystem);
+}
+
+FileSystemRootDirectoryReader::~FileSystemRootDirectoryReader() = default;
+
+void FileSystemRootDirectoryReader::ReadEntries(
+ FileSystemEntriesCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ ErrorResult& aRv) {
+ if (mAlreadyRead) {
+ RefPtr<EmptyEntriesCallbackRunnable> runnable =
+ new EmptyEntriesCallbackRunnable(&aSuccessCallback);
+
+ aRv =
+ FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
+ return;
+ }
+
+ // This object can be used only once.
+ mAlreadyRead = true;
+
+ RefPtr<EntriesCallbackRunnable> runnable =
+ new EntriesCallbackRunnable(&aSuccessCallback, mEntries);
+
+ aRv = FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
+}
+
+} // namespace mozilla::dom
diff --git a/dom/filesystem/compat/FileSystemRootDirectoryReader.h b/dom/filesystem/compat/FileSystemRootDirectoryReader.h
new file mode 100644
index 0000000000..7429de8a9c
--- /dev/null
+++ b/dom/filesystem/compat/FileSystemRootDirectoryReader.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_FileSystemRootDirectoryReader_h
+#define mozilla_dom_FileSystemRootDirectoryReader_h
+
+#include "FileSystemDirectoryReader.h"
+
+namespace mozilla::dom {
+
+class FileSystemRootDirectoryReader final : public FileSystemDirectoryReader {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FileSystemRootDirectoryReader,
+ FileSystemDirectoryReader)
+
+ explicit FileSystemRootDirectoryReader(
+ FileSystemDirectoryEntry* aParentEntry, FileSystem* aFileSystem,
+ const Sequence<RefPtr<FileSystemEntry>>& aEntries);
+
+ virtual void ReadEntries(
+ FileSystemEntriesCallback& aSuccessCallback,
+ const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
+ ErrorResult& aRv) override;
+
+ private:
+ ~FileSystemRootDirectoryReader();
+
+ Sequence<RefPtr<FileSystemEntry>> mEntries;
+ bool mAlreadyRead;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_FileSystemRootDirectoryReader_h
diff --git a/dom/filesystem/compat/moz.build b/dom/filesystem/compat/moz.build
new file mode 100644
index 0000000000..6757a73d9e
--- /dev/null
+++ b/dom/filesystem/compat/moz.build
@@ -0,0 +1,30 @@
+# -*- 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/.
+
+TEST_DIRS += ["tests"]
+
+EXPORTS.mozilla.dom += [
+ "FileSystem.h",
+ "FileSystemDirectoryEntry.h",
+ "FileSystemDirectoryReader.h",
+ "FileSystemEntry.h",
+ "FileSystemFileEntry.h",
+]
+
+UNIFIED_SOURCES += [
+ "CallbackRunnables.cpp",
+ "FileSystem.cpp",
+ "FileSystemDirectoryEntry.cpp",
+ "FileSystemDirectoryReader.cpp",
+ "FileSystemEntry.cpp",
+ "FileSystemFileEntry.cpp",
+ "FileSystemRootDirectoryEntry.cpp",
+ "FileSystemRootDirectoryReader.cpp",
+]
+
+FINAL_LIBRARY = "xul"
+
+include("/ipc/chromium/chromium-config.mozbuild")
diff --git a/dom/filesystem/compat/tests/mochitest.toml b/dom/filesystem/compat/tests/mochitest.toml
new file mode 100644
index 0000000000..3414a7433a
--- /dev/null
+++ b/dom/filesystem/compat/tests/mochitest.toml
@@ -0,0 +1,11 @@
+[DEFAULT]
+support-files = [
+ "script_entries.js",
+ "!/dom/html/test/form_submit_server.sjs",
+]
+
+["test_basic.html"]
+
+["test_formSubmission.html"]
+
+["test_no_dnd.html"]
diff --git a/dom/filesystem/compat/tests/moz.build b/dom/filesystem/compat/tests/moz.build
new file mode 100644
index 0000000000..2f41008128
--- /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.toml"]
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>
diff --git a/dom/filesystem/moz.build b/dom/filesystem/moz.build
new file mode 100644
index 0000000000..8287f85777
--- /dev/null
+++ b/dom/filesystem/moz.build
@@ -0,0 +1,50 @@
+# -*- 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/.
+
+with Files("**"):
+ BUG_COMPONENT = ("Core", "DOM: File")
+
+DIRS += ["compat"]
+
+TEST_DIRS += ["tests"]
+
+EXPORTS.mozilla.dom += [
+ "Directory.h",
+ "FileSystemBase.h",
+ "FileSystemRequestParent.h",
+ "FileSystemSecurity.h",
+ "FileSystemTaskBase.h",
+ "FileSystemUtils.h",
+ "GetFilesHelper.h",
+ "OSFileSystem.h",
+]
+
+UNIFIED_SOURCES += [
+ "Directory.cpp",
+ "FileSystemBase.cpp",
+ "FileSystemRequestParent.cpp",
+ "FileSystemSecurity.cpp",
+ "FileSystemTaskBase.cpp",
+ "FileSystemUtils.cpp",
+ "GetDirectoryListingTask.cpp",
+ "GetFileOrDirectoryTask.cpp",
+ "GetFilesHelper.cpp",
+ "GetFilesTask.cpp",
+ "OSFileSystem.cpp",
+]
+
+FINAL_LIBRARY = "xul"
+
+IPDL_SOURCES += [
+ "PFileSystemParams.ipdlh",
+ "PFileSystemRequest.ipdl",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+LOCAL_INCLUDES += [
+ "/dom/base",
+]
diff --git a/dom/filesystem/tests/filesystem_commons.js b/dom/filesystem/tests/filesystem_commons.js
new file mode 100644
index 0000000000..af0ce36339
--- /dev/null
+++ b/dom/filesystem/tests/filesystem_commons.js
@@ -0,0 +1,180 @@
+function createPath(parentDir, dirOrFile) {
+ return parentDir.path + (parentDir.path == "/" ? "" : "/") + dirOrFile.name;
+}
+
+function createRelativePath(parentDir, dirOrFile) {
+ let path = createPath(parentDir, dirOrFile);
+ is(path[0], "/", "The full path should start with '/'");
+ return path.substring(1);
+}
+
+function setup_tests(aNext) {
+ SimpleTest.requestLongerTimeout(2);
+ SpecialPowers.pushPrefEnv(
+ {
+ set: [
+ ["dom.filesystem.pathcheck.disabled", true],
+ ["dom.webkitBlink.dirPicker.enabled", true],
+ ],
+ },
+ aNext
+ );
+}
+
+function test_basic(aDirectory, aNext) {
+ ok(aDirectory, "Directory exists.");
+ ok(aDirectory instanceof Directory, "We have a directory.");
+ is(aDirectory.path, "/" + aDirectory.name, "directory.path must be '/'+name");
+ aNext();
+}
+
+function test_getFilesAndDirectories(aDirectory, aRecursive, aNext) {
+ function checkSubDir(dir) {
+ return dir.getFilesAndDirectories().then(function (data) {
+ for (var i = 0; i < data.length; ++i) {
+ ok(
+ data[i] instanceof File || data[i] instanceof Directory,
+ "Just Files or Directories"
+ );
+ if (data[i] instanceof Directory) {
+ isnot(
+ data[i].name,
+ "/",
+ "Subdirectory should be called with the leafname"
+ );
+ isnot(
+ data[i].path,
+ "/",
+ "Subdirectory path should be called with the leafname"
+ );
+ isnot(
+ data[i].path,
+ dir.path,
+ "Subdirectory path should contain the parent path."
+ );
+ is(
+ data[i].path,
+ createPath(dir, data[i]),
+ "Subdirectory path should be called parentdir.path + '/' + leafname: " +
+ data[i].path
+ );
+ }
+
+ if (data[i] instanceof File) {
+ is(
+ data[i].webkitRelativePath,
+ createRelativePath(dir, data[i]),
+ "File.webkitRelativePath should be called: parentdir.path + '/' + file.name: " +
+ data[i].webkitRelativePath
+ );
+ ok(
+ !data[i].webkitRelativePath.endsWith("symlink.txt"),
+ "We should never see a path ending with symlink.txt, our symlink sentinel."
+ );
+ }
+ }
+ });
+ }
+
+ aDirectory
+ .getFilesAndDirectories()
+ .then(
+ function (data) {
+ ok(data.length, "We should have some data.");
+ var promises = [];
+ for (var i = 0; i < data.length; ++i) {
+ ok(
+ data[i] instanceof File || data[i] instanceof Directory,
+ "Just Files or Directories: " + data[i].name
+ );
+ if (data[i] instanceof Directory) {
+ isnot(
+ data[i].name,
+ "/",
+ "Subdirectory should be called with the leafname"
+ );
+ is(
+ data[i].path,
+ createPath(aDirectory, data[i]),
+ "Subdirectory path should be called parentdir.path + '/' + leafname: " +
+ data[i].path
+ );
+ if (aRecursive) {
+ promises.push(checkSubDir(data[i]));
+ }
+ }
+
+ if (data[i] instanceof File) {
+ is(
+ data[i].webkitRelativePath,
+ createRelativePath(aDirectory, data[i]),
+ "File.webkitRelativePath should be called file.name: " +
+ data[i].webkitRelativePath
+ );
+ }
+ }
+
+ return Promise.all(promises);
+ },
+ function () {
+ ok(false, "Something when wrong");
+ }
+ )
+ .then(aNext);
+}
+
+function test_getFiles(aDirectory, aRecursive, aNext) {
+ aDirectory
+ .getFiles(aRecursive)
+ .then(
+ function (data) {
+ for (var i = 0; i < data.length; ++i) {
+ ok(data[i] instanceof File, "File: " + data[i].name);
+ is(aDirectory.path[0], "/", "Directory path must start with '/'");
+ ok(
+ data[i].webkitRelativePath.indexOf(aDirectory.path.substring(1)) ==
+ 0 &&
+ data[i].webkitRelativePath.indexOf("/" + data[i].name) +
+ ("/" + data[i].name).length ==
+ data[i].webkitRelativePath.length,
+ "File.webkitRelativePath should be called dir.path + '/' + file.name: " +
+ data[i].webkitRelativePath
+ );
+ }
+ },
+ function () {
+ ok(false, "Something when wrong");
+ }
+ )
+ .then(aNext);
+}
+
+function test_getFiles_recursiveComparison(aDirectory, aNext) {
+ aDirectory
+ .getFiles(true)
+ .then(function (data) {
+ is(data.length, 2, "Only 2 files for this test.");
+ ok(
+ data[0].name == "foo.txt" || data[0].name == "bar.txt",
+ "First filename matches"
+ );
+ ok(
+ data[1].name == "foo.txt" || data[1].name == "bar.txt",
+ "Second filename matches"
+ );
+ })
+ .then(function () {
+ return aDirectory.getFiles(false);
+ })
+ .then(function (data) {
+ is(data.length, 1, "Only 1 file for this test.");
+ ok(
+ data[0].name == "foo.txt" || data[0].name == "bar.txt",
+ "First filename matches"
+ );
+ })
+ .catch(function () {
+ ok(false, "Something when wrong");
+ })
+ .then(aNext);
+}
diff --git a/dom/filesystem/tests/mochitest.toml b/dom/filesystem/tests/mochitest.toml
new file mode 100644
index 0000000000..869fe2d37f
--- /dev/null
+++ b/dom/filesystem/tests/mochitest.toml
@@ -0,0 +1,16 @@
+[DEFAULT]
+support-files = [
+ "filesystem_commons.js",
+ "script_fileList.js",
+ "worker_basic.js",
+]
+
+["test_basic.html"]
+
+["test_bug1319088.html"]
+
+["test_webkitdirectory.html"]
+skip-if = ["os == 'android'"] # Bug 1674428
+support-files = ["script_promptHandler.js"]
+
+["test_worker_basic.html"]
diff --git a/dom/filesystem/tests/moz.build b/dom/filesystem/tests/moz.build
new file mode 100644
index 0000000000..2f41008128
--- /dev/null
+++ b/dom/filesystem/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.toml"]
diff --git a/dom/filesystem/tests/script_fileList.js b/dom/filesystem/tests/script_fileList.js
new file mode 100644
index 0000000000..47438aa7b3
--- /dev/null
+++ b/dom/filesystem/tests/script_fileList.js
@@ -0,0 +1,176 @@
+/* eslint-env mozilla/chrome-script */
+// eslint-disable-next-line mozilla/reject-importGlobalProperties
+Cu.importGlobalProperties(["File"]);
+function createProfDFile() {
+ return Services.dirsvc
+ .QueryInterface(Ci.nsIProperties)
+ .get("ProfD", Ci.nsIFile);
+}
+
+const { AppConstants } = ChromeUtils.importESModule(
+ "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+// Creates a parametric arity directory hierarchy as a function of depth.
+// Each directory contains one leaf file, and subdirectories of depth [1, depth).
+// e.g. for depth 3:
+//
+// subdir3
+// - file.txt
+// - subdir2
+// - file.txt
+// - subdir1
+// - file.txt
+// - subdir1
+// - file.txt
+//
+// Returns the parent directory of the subtree.
+function createTreeFile(depth, parent) {
+ if (!parent) {
+ parent = Services.dirsvc
+ .QueryInterface(Ci.nsIProperties)
+ .get("TmpD", Ci.nsIFile);
+ parent.append("dir-tree-test");
+ parent.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+ }
+
+ var nextFile = parent.clone();
+ if (depth == 0) {
+ nextFile.append("file.txt");
+ nextFile.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+ // It's not possible to create symlinks on windows by default or on our
+ // Android platforms, so we can't create the symlink file there. Our
+ // callers that care are aware of this and also check AppConstants.
+ if (
+ AppConstants.platform !== "win" &&
+ AppConstants.platform !== "android"
+ ) {
+ var linkFile = parent.clone();
+ linkFile.append("symlink.txt");
+ createSymLink(nextFile.path, linkFile.path);
+ }
+ } else {
+ nextFile.append("subdir" + depth);
+ nextFile.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+ // Decrement the maximal depth by one for each level of nesting.
+ for (var i = 0; i < depth; i++) {
+ createTreeFile(i, nextFile);
+ }
+ }
+
+ return parent;
+}
+
+function createRootFile() {
+ var testFile = createProfDFile();
+
+ // Let's go back to the root of the FileSystem
+ while (true) {
+ var parent = testFile.parent;
+ if (!parent) {
+ break;
+ }
+
+ testFile = parent;
+ }
+
+ return testFile;
+}
+
+var process;
+function createSymLink(target, linkName) {
+ if (!process) {
+ var ln = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+ ln.initWithPath("/bin/ln");
+
+ process = Cc["@mozilla.org/process/util;1"].createInstance(Ci.nsIProcess);
+ process.init(ln);
+ }
+
+ const args = ["-s", target, linkName];
+ process.run(true, args, args.length);
+ Assert.equal(process.exitValue, 0);
+}
+
+function createTestFile() {
+ var tmpFile = Services.dirsvc
+ .QueryInterface(Ci.nsIProperties)
+ .get("TmpD", Ci.nsIFile);
+ tmpFile.append("dir-test");
+ tmpFile.createUnique(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+
+ var file1 = tmpFile.clone();
+ file1.append("foo.txt");
+ file1.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+ var dir = tmpFile.clone();
+ dir.append("subdir");
+ dir.create(Ci.nsIFile.DIRECTORY_TYPE, 0o700);
+
+ var file2 = dir.clone();
+ file2.append("bar.txt");
+ file2.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+ // It's not possible to create symlinks on windows by default or on our
+ // Android platforms, so we can't create the symlink file there. Our
+ // callers that care are aware of this and also check AppConstants.
+ if (AppConstants.platform !== "win" && AppConstants.platform !== "android") {
+ var linkFile = dir.clone();
+ linkFile.append("symlink.txt");
+ createSymLink(file1.path, linkFile.path);
+ }
+
+ return tmpFile;
+}
+
+addMessageListener("dir.open", function (e) {
+ var testFile;
+
+ switch (e.path) {
+ case "ProfD":
+ // Note that files in the profile directory are not guaranteed to persist-
+ // see bug 1284742.
+ testFile = createProfDFile();
+ break;
+
+ case "root":
+ testFile = createRootFile();
+ break;
+
+ case "test":
+ testFile = createTestFile();
+ break;
+
+ case "tree":
+ testFile = createTreeFile(3);
+ break;
+ }
+
+ sendAsyncMessage("dir.opened", {
+ dir: testFile.path,
+ name: testFile.leafName,
+ });
+});
+
+addMessageListener("file.open", function (e) {
+ var testFile = Services.dirsvc
+ .QueryInterface(Ci.nsIProperties)
+ .get("ProfD", Ci.nsIFile);
+ testFile.append("prefs.js");
+
+ File.createFromNsIFile(testFile).then(function (file) {
+ sendAsyncMessage("file.opened", { file });
+ });
+});
+
+addMessageListener("symlink.open", function (e) {
+ let testDir = createTestFile();
+ let testFile = testDir.clone();
+ testFile.append("subdir");
+ testFile.append("symlink.txt");
+
+ File.createFromNsIFile(testFile).then(function (file) {
+ sendAsyncMessage("symlink.opened", { dir: testDir.path, file });
+ });
+});
diff --git a/dom/filesystem/tests/script_promptHandler.js b/dom/filesystem/tests/script_promptHandler.js
new file mode 100644
index 0000000000..ed3bda7404
--- /dev/null
+++ b/dom/filesystem/tests/script_promptHandler.js
@@ -0,0 +1,18 @@
+/* eslint-env mozilla/chrome-script */
+
+let dialogObserverTopic = "common-dialog-loaded";
+
+function dialogObserver(subj, topic, data) {
+ subj.document.querySelector("dialog").acceptDialog();
+ sendAsyncMessage("promptAccepted");
+}
+
+addMessageListener("init", message => {
+ Services.obs.addObserver(dialogObserver, dialogObserverTopic);
+ sendAsyncMessage("initDone");
+});
+
+addMessageListener("cleanup", message => {
+ Services.obs.removeObserver(dialogObserver, dialogObserverTopic);
+ sendAsyncMessage("cleanupDone");
+});
diff --git a/dom/filesystem/tests/test_basic.html b/dom/filesystem/tests/test_basic.html
new file mode 100644
index 0000000000..b4daea79c9
--- /dev/null
+++ b/dom/filesystem/tests/test_basic.html
@@ -0,0 +1,118 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for Directory API</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <script type="text/javascript" src="filesystem_commons.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<script type="application/javascript">
+
+var directory;
+var fileList;
+
+function create_fileList(aPath) {
+ fileList = document.createElement("input");
+ fileList.setAttribute("type", "file");
+ document.body.appendChild(fileList);
+
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ function onOpened(message) {
+ SpecialPowers.wrap(fileList).mozSetDirectory(message.dir);
+ fileList.setAttribute("data-name", message.name);
+
+ SpecialPowers.wrap(fileList).getFilesAndDirectories().then(function(array) {
+ array = SpecialPowers.unwrap(array);
+ is(array.length, 1, "We want just 1 directory.");
+ ok(array[0] instanceof Directory, "We want just 1 directory.");
+
+ directory = array[0];
+ script.destroy();
+ next();
+ });
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: aPath });
+}
+
+function test_simpleFilePicker(aPath) {
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ function onOpened(message) {
+ SpecialPowers.wrap(fileList).mozSetFileArray([message.file]);
+
+ is(fileList.files.length, 1, "we want 1 element");
+ ok(fileList.files[0] instanceof File, "we want 1 file");
+ ok("webkitRelativePath" in fileList.files[0], "we have webkitRelativePath attribute");
+ is(fileList.files[0].webkitRelativePath, "", "No webkit relative path for normal filePicker");
+
+ script.destroy();
+ next();
+ }
+
+ script.addMessageListener("file.opened", onOpened);
+ script.sendAsyncMessage("file.open");
+}
+
+function test_duplicateGetFilesAndDirectories() {
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ function onOpened(message) {
+ SpecialPowers.wrap(fileList).mozSetDirectory(message.dir);
+
+ var p1 = SpecialPowers.wrap(fileList).getFilesAndDirectories();
+ var p2 = SpecialPowers.wrap(fileList).getFilesAndDirectories();
+
+ isnot(p1, p2, "We create 2 different promises");
+
+ script.destroy();
+ next();
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: "test" });
+}
+
+var tests = [
+ function() { setup_tests(next); },
+
+ function() { create_fileList("tree"); },
+ function() { test_basic(directory, next); },
+ function() { test_getFilesAndDirectories(directory, true, next); },
+ function() { test_getFiles(directory, false, next); },
+ function() { test_getFiles(directory, true, next); },
+
+ function() { create_fileList("test"); },
+ function() { test_getFiles_recursiveComparison(directory, next); },
+
+ function() { create_fileList("root"); },
+ function() { test_basic(directory, next); },
+ function() { test_getFilesAndDirectories(directory, false, next); },
+ function() { test_getFiles(directory, false, next); },
+
+ test_duplicateGetFilesAndDirectories,
+ test_simpleFilePicker,
+];
+
+function next() {
+ if (!tests.length) {
+ SimpleTest.finish();
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/tests/test_bug1319088.html b/dom/filesystem/tests/test_bug1319088.html
new file mode 100644
index 0000000000..98e0ad46f0
--- /dev/null
+++ b/dom/filesystem/tests/test_bug1319088.html
@@ -0,0 +1,65 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for bug 1319088</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<input id="input" type="file"></input>
+
+<script type="application/javascript">
+
+function testSetup() {
+ SpecialPowers.pushPrefEnv({"set": [["dom.webkitBlink.dirPicker.enabled", true]]}, next);
+}
+
+function populateInputFile() {
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ function onOpened(message) {
+ var input = document.getElementById("input");
+ SpecialPowers.wrap(input).mozSetFileArray([message.file]);
+
+ script.destroy();
+ next();
+ }
+
+ script.addMessageListener("file.opened", onOpened);
+ script.sendAsyncMessage("file.open");
+}
+
+function checkBug() {
+ var input = document.getElementById("input");
+ is(input.files[0].webkitRelativePath, "", "No relative path!");
+
+ let form = document.createElement("form");
+ form.appendChild(input);
+
+ is(input.files[0].webkitRelativePath, "", "No relative path!");
+ SimpleTest.finish();
+}
+
+var tests = [
+ testSetup,
+ populateInputFile,
+ checkBug,
+];
+
+function next() {
+ if (!tests.length) {
+ SimpleTest.finish();
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/tests/test_webkitdirectory.html b/dom/filesystem/tests/test_webkitdirectory.html
new file mode 100644
index 0000000000..50080ad7ba
--- /dev/null
+++ b/dom/filesystem/tests/test_webkitdirectory.html
@@ -0,0 +1,309 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for webkitdirectory and webkitRelativePath</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<input id="inputFileWebkitDirectory" type="file" webkitdirectory></input>
+<input id="inputFileWebkitFile" type="file"></input>
+<input id="inputFileDirectoryChange" type="file" webkitdirectory></input>
+
+<script type="application/javascript">
+
+const { AppConstants } = SpecialPowers.ChromeUtils.importESModule(
+ "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+let promptHandler;
+
+function waitForEvent(element, eventName) {
+ return new Promise(function(resolve) {
+ element.addEventListener(eventName, e => resolve(e.detail), { once: true });
+ });
+}
+
+function waitForPromptHandled() {
+ return new Promise(resolve => promptHandler.addMessageListener("promptAccepted", resolve));
+}
+
+// Populate the given input type=file `aInputFile`'s `files` attribute by:
+// - loading `script_fileList.js` in the parent process
+// - telling it to generate the "test" template directory pattern which will
+// create "foo.txt", "subdir/bar.txt", and if symlinks are available on the
+// platform, "symlink.txt" which will be a symlink to "foo.txt". (Note that
+// we explicitly expect the symlink to be filtered out if generated, and
+// during the enhancement of the test we verified the file was created on
+// linux by running the test before fixing the GetFilesHelper logic to filter
+// the symlink out and verifying the subsequent `test_fileList` check failed.)
+// - Triggering the mock file picker with the base directory of the "test"
+// template directory.
+//
+// It's expected that `test_fileList` will be used after this step completes in
+// order to validate the results.
+function populateInputFile(aInputFile) {
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ var MockFilePicker = SpecialPowers.MockFilePicker;
+ MockFilePicker.init(window, "A Mock File Picker", SpecialPowers.Ci.nsIFilePicker.modeGetFolder);
+
+ async function onOpened(message) {
+ MockFilePicker.useDirectory(message.dir);
+
+ let input = document.getElementById(aInputFile);
+ input.setAttribute("data-name", message.name);
+
+ let promptHandled = waitForPromptHandled();
+ let changeEvent = waitForEvent(input, "change");
+
+ input.click();
+
+ await promptHandled;
+ await changeEvent;
+
+ MockFilePicker.cleanup();
+ script.destroy();
+ next();
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: "test" });
+}
+
+function checkFile(file, fileList, dirName) {
+ for (var i = 0; i < fileList.length; ++i) {
+ ok(fileList[i] instanceof File, "We want just files.");
+ if (fileList[i].name == file.name) {
+ is(fileList[i].webkitRelativePath, dirName + file.path, "Path matches");
+ return;
+ }
+ }
+
+ ok(false, "File not found.");
+}
+
+// Validate the contents of the given input type=file `aInputFile`'s' `files`
+// property against the expected list of files `aWhat`.
+function test_fileList(aInputFile, aWhat) {
+ var input = document.getElementById(aInputFile);
+ var fileList = input.files;
+
+ if (aWhat == null) {
+ is(fileList, null, "We want a null fileList for " + aInputFile);
+ next();
+ return;
+ }
+
+ is(fileList.length, aWhat.length, "We want just " + aWhat.length + " elements for " + aInputFile);
+ for (var i = 0; i < aWhat.length; ++i) {
+ checkFile(aWhat[i], fileList, input.dataset.name);
+ }
+
+ next();
+}
+
+// Verify that we can explicitly select a symlink and it will not be filtered
+// out. This is really a verification that GetFileHelper's file-handling logic
+// https://searchfox.org/mozilla-central/rev/065102493dfc49234120c37fc6a334a5b1d86d9e/dom/filesystem/GetFilesHelper.cpp#81-86
+// does not proactively take an action to filter out a selected symlink.
+//
+// This is a glass box test that is not entirely realistic for our actual system
+// file pickers but does reflect what will happen in the drag-and-drop case
+// for `HTMLInputElement::MozSetDndFilesAndDirectories` and this helps ensure
+// that future implementation changes will behave as expected. Specifically,
+// the presence of webkitdirectory will result in the file picker using
+// `modeGetFolder` which will only allow selection of a directory and forbid
+// file selection.
+//
+// This test explicitly does not validate HTMLInputElement's non-webkitdirectory
+// file selection mechanism because it does not involve GetFileHelper.
+async function test_individualSymlink(aInputFile) {
+ const input = document.getElementById(aInputFile);
+
+ // -- Create the symlink and get a `File` instance pointing at it.
+ const url = SimpleTest.getTestFileURL("script_fileList.js");
+ const script = SpecialPowers.loadChromeScript(url);
+
+ let opened = new Promise(resolve => script.addMessageListener("symlink.opened", resolve));
+ script.sendAsyncMessage("symlink.open", {});
+ let { dir, file: symlinkFile } = await opened;
+ info(`symlink.open provided dir: ${dir}`)
+
+ // -- Have the picker pick it
+ var MockFilePicker = SpecialPowers.MockFilePicker;
+ MockFilePicker.init(window, "A Mock File Picker", SpecialPowers.Ci.nsIFilePicker.modeOpen);
+
+ MockFilePicker.displayDirectory = dir;
+ let pickerShown = new Promise(resolve => {
+ MockFilePicker.showCallback = function() {
+ // This is where we are diverging from a realistic scenario in order to get
+ // the expected coverage.
+ MockFilePicker.setFiles([symlinkFile]);
+ resolve();
+ }
+ });
+ MockFilePicker.returnValue = MockFilePicker.returnOK;
+
+ let changeEvent = waitForEvent(input, "change");
+
+ input.click();
+
+ await pickerShown;
+ await changeEvent;
+
+ MockFilePicker.cleanup();
+ script.destroy();
+
+ // -- Verify that we see the symlink.
+ let fileList = input.files;
+ is(fileList.length, 1, "There should be 1 file.");
+ is(fileList[0].name, "symlink.txt", "The file should be the symlink.");
+ next();
+}
+
+function test_webkitdirectory_attribute() {
+ var a = document.createElement("input");
+ a.setAttribute("type", "file");
+
+ ok("webkitdirectory" in a, "HTMLInputElement.webkitdirectory exists");
+
+ ok(!a.hasAttribute("webkitdirectory"), "No webkitdirectory DOM attribute by default");
+ ok(!a.webkitdirectory, "No webkitdirectory attribute by default");
+
+ a.webkitdirectory = true;
+
+ ok(a.hasAttribute("webkitdirectory"), "Webkitdirectory DOM attribute is set");
+ ok(a.webkitdirectory, "Webkitdirectory attribute is set");
+
+ next();
+}
+
+function test_changeDataWhileWorking() {
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ var MockFilePicker = SpecialPowers.MockFilePicker;
+ MockFilePicker.init(window, "A Mock File Picker", SpecialPowers.Ci.nsIFilePicker.modeGetFolder);
+ let promptHandled;
+
+ // Let's start retrieving the root nsIFile object
+ new Promise(function(resolve) {
+ function onOpened(message) {
+ script.removeMessageListener("dir.opened", onOpened);
+ resolve(message.dir);
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: "root" });
+ })
+
+ // input.click() pointing to the root dir
+ .then(async function(aDir) {
+ MockFilePicker.cleanup();
+ MockFilePicker.init(window, "A Mock File Picker", SpecialPowers.Ci.nsIFilePicker.modeGetFolder);
+ MockFilePicker.useDirectory(aDir);
+ var input = document.getElementById("inputFileDirectoryChange");
+
+ promptHandled = waitForPromptHandled();
+ input.click();
+ })
+
+ // Before onchange, let's take the 'test' directory
+ .then(function() {
+ return new Promise(function(resolve) {
+ function onOpened(message) {
+ script.removeMessageListener("dir.opened", onOpened);
+ script.destroy();
+ resolve(message.dir);
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: "test" });
+ });
+ })
+
+ // Now let's click again and wait for onchange.
+ .then(async function(aDir) {
+ MockFilePicker.cleanup();
+ MockFilePicker.init(window, "A Mock File Picker", SpecialPowers.Ci.nsIFilePicker.modeGetFolder);
+ MockFilePicker.useDirectory(aDir);
+
+ let input = document.getElementById("inputFileDirectoryChange");
+ let changeEvent = waitForEvent(input, "change");
+
+ input.click();
+
+ await promptHandled;
+ await changeEvent;
+
+ MockFilePicker.cleanup();
+ })
+ .then(function() {
+ test_fileList("inputFileWebkitDirectory", testDirData);
+ });
+}
+
+async function test_setup() {
+ let promptHandlerUrl = SimpleTest.getTestFileURL("script_promptHandler.js")
+ promptHandler = SpecialPowers.loadChromeScript(promptHandlerUrl);
+
+ let promptHandlerReady = new Promise(resolve => promptHandler.addMessageListener("initDone", resolve));
+ promptHandler.sendAsyncMessage("init");
+ await promptHandlerReady;
+
+ SpecialPowers.pushPrefEnv({"set": [["dom.filesystem.pathcheck.disabled", true],
+ ["dom.webkitBlink.dirPicker.enabled", true]]}, next);
+}
+
+async function test_cleanup() {
+ let promptHandlerDone = new Promise(resolve => promptHandler.addMessageListener("cleanupDone", resolve));
+ promptHandler.sendAsyncMessage("cleanup");
+ await promptHandlerDone;
+ promptHandler.destroy();
+}
+
+var testDirData = [ { name: "foo.txt", path: "/foo.txt" },
+ { name: "bar.txt", path: "/subdir/bar.txt" }];
+
+var tests = [
+ test_setup,
+
+ function() { populateInputFile("inputFileWebkitDirectory"); },
+
+ function() { test_fileList("inputFileWebkitDirectory", testDirData); },
+
+ function() {
+ // Symlinks are not available on Windows and so will not be created.
+ if (AppConstants.platform === "win" || AppConstants.platform === "android") {
+ info("Skipping individual symlink check on Windows and Android.");
+ next();
+ return;
+ }
+
+ test_individualSymlink("inputFileWebkitFile").catch(err => ok(false, `Problem in symlink case: ${err}`));
+ },
+
+ test_webkitdirectory_attribute,
+
+ test_changeDataWhileWorking,
+];
+
+async function next() {
+ if (!tests.length) {
+ await test_cleanup();
+ SimpleTest.finish();
+ return;
+ }
+
+ var test = tests.shift();
+ await test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/tests/test_worker_basic.html b/dom/filesystem/tests/test_worker_basic.html
new file mode 100644
index 0000000000..920f32719b
--- /dev/null
+++ b/dom/filesystem/tests/test_worker_basic.html
@@ -0,0 +1,73 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for Directory API in workers</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <script type="text/javascript" src="filesystem_commons.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body>
+<script type="application/javascript">
+
+var fileList;
+
+function create_fileList() {
+ fileList = document.createElement("input");
+ fileList.setAttribute("type", "file");
+ document.body.appendChild(fileList);
+
+ var url = SimpleTest.getTestFileURL("script_fileList.js");
+ var script = SpecialPowers.loadChromeScript(url);
+
+ function onOpened(message) {
+ SpecialPowers.wrap(fileList).mozSetDirectory(message.dir);
+ script.destroy();
+ next();
+ }
+
+ script.addMessageListener("dir.opened", onOpened);
+ script.sendAsyncMessage("dir.open", { path: "test" });
+}
+
+function test_worker() {
+ SpecialPowers.wrap(fileList).getFilesAndDirectories().then(function(array) {
+ array = SpecialPowers.unwrap(array);
+ var worker = new Worker("worker_basic.js");
+ worker.onmessage = function(e) {
+ if (e.data.type == "finish") {
+ next();
+ return;
+ }
+
+ if (e.data.type == "test") {
+ ok(e.data.test, e.data.message);
+ }
+ };
+
+ worker.postMessage(array[0]);
+ });
+}
+
+var tests = [
+ function() { setup_tests(next); },
+
+ create_fileList,
+ test_worker,
+];
+
+function next() {
+ if (!tests.length) {
+ SimpleTest.finish();
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+}
+
+SimpleTest.waitForExplicitFinish();
+next();
+</script>
+</body>
+</html>
diff --git a/dom/filesystem/tests/worker_basic.js b/dom/filesystem/tests/worker_basic.js
new file mode 100644
index 0000000000..2771c778fd
--- /dev/null
+++ b/dom/filesystem/tests/worker_basic.js
@@ -0,0 +1,50 @@
+/* eslint-env worker */
+importScripts("filesystem_commons.js");
+
+function finish() {
+ postMessage({ type: "finish" });
+}
+
+function ok(a, msg) {
+ postMessage({ type: "test", test: !!a, message: msg });
+}
+
+function is(a, b, msg) {
+ ok(a === b, msg);
+}
+
+function isnot(a, b, msg) {
+ ok(a != b, msg);
+}
+
+var tests = [
+ function () {
+ test_basic(directory, next);
+ },
+ function () {
+ test_getFilesAndDirectories(directory, true, next);
+ },
+ function () {
+ test_getFiles(directory, false, next);
+ },
+ function () {
+ test_getFiles(directory, true, next);
+ },
+];
+
+function next() {
+ if (!tests.length) {
+ finish();
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+}
+
+var directory;
+
+onmessage = function (e) {
+ directory = e.data;
+ next();
+};