Reland "[FileSystem] Add support for selecting multiple files or directories."

This is a reland of 9594a943

Original change's description:
> [FileSystem] Add support for selecting multiple files or directories.
>
> Bug: 878581
> Change-Id: I65fc0029da2e3951495a6cd96704085e5c1b942c
> Reviewed-on: https://chromium-review.googlesource.com/1227366
> Reviewed-by: Daniel Cheng <dcheng@chromium.org>
> Reviewed-by: Daniel Murphy <dmurph@chromium.org>
> Commit-Queue: Marijn Kruisselbrink <mek@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#594132}

Tbr: dmurph@chromium.org, dcheng@chromium.org
Bug: 878581
Change-Id: Ic145a6b48279f29368fbbc802751eb3d43b4ef4c
Reviewed-on: https://chromium-review.googlesource.com/c/1265058Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Commit-Queue: Marijn Kruisselbrink <mek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#597233}

content/browser/fileapi/README.md

+# FileSystem API
+
+This directory contains part of the browser side implementation of various
+filesystem related APIs.
+
+## Related directories
+
+[`//storage/browser/fileapi/`](../../../storage/browser/fileapi) contains the
+rest of the browser side implementation, while
+[`blink/renderer/modules/filesystem`](../../../third_party/blink/renderer/modules/filesystem)
+contains the renderer side implementation and
+[`blink/public/mojom/filesystem`](../../../third_party/blink/public/mojom/filesystem)
+contains the mojom interfaces for these APIs.
+
+## In this directory
+
+[`FileSystemManagerImpl`](file_system_manager_impl.h) is the main entry point
+for calls from the renderer, it mostly redirects incoming mojom calls to a
+`storage::FileSystemContext` instance.
+
+[`FileSystemChooser`](file_system_chooser.h) uses ui::SelectFileDialog to show
+a file or directory picker, and is responsible for granting a process the right
+permissions for actually accessing the files that were selected.

content/browser/fileapi/file_system_chooser.cc

@@ -5,6 +5,8 @@
 #include "content/browser/fileapi/file_system_chooser.h"
 
 #include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/task/post_task.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/content_browser_client.h"
@@ -19,20 +21,37 @@ namespace content {
 void FileSystemChooser::CreateAndShow(
     int render_process_id,
     int frame_id,
+    blink::mojom::ChooseFileSystemEntryType type,
     ResultCallback callback,
     scoped_refptr<base::TaskRunner> callback_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHost* rfh = RenderFrameHost::FromID(render_process_id, frame_id);
   WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
-  auto* listener = new FileSystemChooser(render_process_id, std::move(callback),
-                                         std::move(callback_runner));
+  auto* listener = new FileSystemChooser(
+      render_process_id, type, std::move(callback), std::move(callback_runner));
   listener->dialog_ = ui::SelectFileDialog::Create(
       listener,
       GetContentClient()->browser()->CreateSelectFilePolicy(web_contents));
   // TODO(https://crbug.com/878581): Better/more specific options to pass to
   //     SelectFile.
+  ui::SelectFileDialog::Type dialog_type = ui::SelectFileDialog::SELECT_NONE;
+  switch (type) {
+    case blink::mojom::ChooseFileSystemEntryType::kOpenFile:
+      dialog_type = ui::SelectFileDialog::SELECT_OPEN_FILE;
+      break;
+    case blink::mojom::ChooseFileSystemEntryType::kOpenMultipleFiles:
+      dialog_type = ui::SelectFileDialog::SELECT_OPEN_MULTI_FILE;
+      break;
+    case blink::mojom::ChooseFileSystemEntryType::kSaveFile:
+      dialog_type = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
+      break;
+    case blink::mojom::ChooseFileSystemEntryType::kOpenDirectory:
+      dialog_type = ui::SelectFileDialog::SELECT_FOLDER;
+      break;
+  }
+  DCHECK_NE(dialog_type, ui::SelectFileDialog::SELECT_NONE);
   listener->dialog_->SelectFile(
-      ui::SelectFileDialog::SELECT_OPEN_FILE, /*title=*/base::string16(),
+      dialog_type, /*title=*/base::string16(),
       /*default_path=*/base::FilePath(), /*file_types=*/nullptr,
       /*file_type_index=*/0,
       /*default_extension=*/base::FilePath::StringType(),
@@ -42,11 +61,13 @@ void FileSystemChooser::CreateAndShow(
 
 FileSystemChooser::FileSystemChooser(
     int render_process_id,
+    blink::mojom::ChooseFileSystemEntryType type,
     ResultCallback callback,
     scoped_refptr<base::TaskRunner> callback_runner)
     : render_process_id_(render_process_id),
       callback_(std::move(callback)),
-      callback_runner_(std::move(callback_runner)) {}
+      callback_runner_(std::move(callback_runner)),
+      type_(type) {}
 
 FileSystemChooser::~FileSystemChooser() {
   if (dialog_)
@@ -73,21 +94,72 @@ void FileSystemChooser::MultiFilesSelected(
   for (const auto& path : files) {
     auto entry = blink::mojom::FileSystemEntry::New();
     entry->file_system_id = isolated_context->RegisterFileSystemForPath(
-        storage::kFileSystemTypeNativeForPlatformApp, std::string(), path,
+        storage::kFileSystemTypeNativeLocal, std::string(), path,
         &entry->base_name);
 
-    // TODO(https://crbug.com/878585): Determine if we always want to grant
-    //     write permission.
     security_policy->GrantReadFileSystem(render_process_id_,
                                          entry->file_system_id);
-    security_policy->GrantWriteFileSystem(render_process_id_,
-                                          entry->file_system_id);
-    security_policy->GrantDeleteFromFileSystem(render_process_id_,
-                                               entry->file_system_id);
+    // TODO(https://crbug.com/878585): Don't grant write/modify permissions
+    // unless a website already has the appropriate permissions.
+    if (type_ == blink::mojom::ChooseFileSystemEntryType::kOpenDirectory) {
+      // Only grant Create permissions if we're opening a directory. And
+      // just granting Create permissions on top of Write and Delete does not
+      // actually grant the same permissions as calling this method.
+      security_policy->GrantCreateReadWriteFileSystem(render_process_id_,
+                                                      entry->file_system_id);
+    } else {
+      security_policy->GrantWriteFileSystem(render_process_id_,
+                                            entry->file_system_id);
+      security_policy->GrantDeleteFromFileSystem(render_process_id_,
+                                                 entry->file_system_id);
+    }
 
     result.push_back(std::move(entry));
   }
 
+  if (type_ == blink::mojom::ChooseFileSystemEntryType::kSaveFile) {
+    // Create files if they don't yet exist.
+    // TODO(mek): If we change FileSystemFileHandle to be able to represent a
+    // file that doesn't exist on disk, we should be able to get rid of this
+    // step and make the whole API slightly more robust.
+    base::PostTaskWithTraits(
+        FROM_HERE, {base::TaskPriority::USER_BLOCKING, base::MayBlock()},
+        base::BindOnce(
+            [](const std::vector<base::FilePath>& files,
+               std::vector<blink::mojom::FileSystemEntryPtr> result,
+               scoped_refptr<base::TaskRunner> callback_runner,
+               ResultCallback callback) {
+              for (const auto& path : files) {
+                // Checking if a path exists, and then creating it if it doesn't
+                // is of course racy, but external applications could just as
+                // well be deleting the entire directory, or similar problematic
+                // cases, so no matter what we do there are always going to be
+                // race conditions and websites will just have to deal with any
+                // method being able to fail in unexpected ways.
+                if (base::PathExists(path))
+                  continue;
+                int creation_flags =
+                    base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ;
+                base::File file(path, creation_flags);
+
+                if (!file.IsValid()) {
+                  callback_runner->PostTask(
+                      FROM_HERE,
+                      base::BindOnce(
+                          std::move(callback), base::File::FILE_ERROR_FAILED,
+                          std::vector<blink::mojom::FileSystemEntryPtr>()));
+                  return;
+                }
+              }
+              callback_runner->PostTask(
+                  FROM_HERE,
+                  base::BindOnce(std::move(callback), base::File::FILE_OK,
+                                 std::move(result)));
+            },
+            files, std::move(result), callback_runner_, std::move(callback_)));
+    delete this;
+    return;
+  }
   callback_runner_->PostTask(
       FROM_HERE, base::BindOnce(std::move(callback_), base::File::FILE_OK,
                                 std::move(result)));

content/browser/fileapi/file_system_chooser.h

@@ -25,10 +25,12 @@ class FileSystemChooser : public ui::SelectFileDialog::Listener {
 
   static void CreateAndShow(int render_process_id,
                             int frame_id,
+                            blink::mojom::ChooseFileSystemEntryType type,
                             ResultCallback callback,
                             scoped_refptr<base::TaskRunner> callback_runner);
 
   FileSystemChooser(int render_process_id,
+                    blink::mojom::ChooseFileSystemEntryType type,
                     ResultCallback callback,
                     scoped_refptr<base::TaskRunner> callback_runner);
 
@@ -46,6 +48,7 @@ class FileSystemChooser : public ui::SelectFileDialog::Listener {
   int render_process_id_;
   ResultCallback callback_;
   scoped_refptr<base::TaskRunner> callback_runner_;
+  blink::mojom::ChooseFileSystemEntryType type_;
 
   scoped_refptr<ui::SelectFileDialog> dialog_;
 };

content/browser/fileapi/file_system_manager_impl.cc

@@ -592,7 +592,9 @@ void FileSystemManagerImpl::CreateWriter(const GURL& file_path,
   std::move(callback).Run(base::File::FILE_OK, std::move(writer));
 }
 
-void FileSystemManagerImpl::ChooseEntry(ChooseEntryCallback callback) {
+void FileSystemManagerImpl::ChooseEntry(
+    blink::mojom::ChooseFileSystemEntryType type,
+    ChooseEntryCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!base::FeatureList::IsEnabled(blink::features::kWritableFilesAPI)) {
     bindings_.ReportBadMessage("FSMI_WRITABLE_FILES_DISABLED");
@@ -602,7 +604,7 @@ void FileSystemManagerImpl::ChooseEntry(ChooseEntryCallback callback) {
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::UI},
       base::BindOnce(
-          &FileSystemChooser::CreateAndShow, process_id_, frame_id_,
+          &FileSystemChooser::CreateAndShow, process_id_, frame_id_, type,
           std::move(callback),
           base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO})));
 }

content/browser/fileapi/file_system_manager_impl.h

@@ -125,7 +125,8 @@ class CONTENT_EXPORT FileSystemManagerImpl
                        GetPlatformPathCallback callback) override;
   void CreateWriter(const GURL& file_path,
                     CreateWriterCallback callback) override;
-  void ChooseEntry(ChooseEntryCallback callback) override;
+  void ChooseEntry(blink::mojom::ChooseFileSystemEntryType type,
+                   ChooseEntryCallback callback) override;
 
  private:
   class FileSystemCancellableOperationImpl;

content/test/BUILD.gn

@@ -758,6 +758,7 @@ test("content_browsertests") {
     # These tests have incorrect threading (https://crbug.com/860547).
     #"../browser/fileapi/file_system_url_loader_factory_browsertest.cc",
 
+    "../browser/fileapi/file_system_chooser_browsertest.cc",
     "../browser/fileapi/fileapi_browsertest.cc",
     "../browser/find_request_manager_browsertest.cc",
     "../browser/font_unique_name_lookup/font_unique_name_browsertest.cc",

storage/browser/fileapi/README.md

+# FileSystem API
+
+This directory contains part of the browser side implementation of various
+filesystem related APIs, as well as interfaces to treat various types of native
+and non-native filesystems mostly the same without having to worry about the
+underlying implementation.
+
+## Related directories
+
+[`//content/browser/fileapi/`](../../../content/browser/fileapi) contains the
+rest of the browser side implementation, while
+[`blink/renderer/modules/filesystem`](../../../third_party/blink/renderer/modules/filesystem)
+contains the renderer side implementation and
+[`blink/public/mojom/filesystem`](../../../third_party/blink/public/mojom/filesystem)
+contains the mojom interfaces for these APIs.

third_party/blink/public/mojom/filesystem/file_system.mojom

@@ -72,6 +72,13 @@ interface ReceivedSnapshotListener {
   DidReceiveSnapshotFile();
 };
 
+enum ChooseFileSystemEntryType {
+  kOpenFile,
+  kOpenMultipleFiles,
+  kSaveFile,
+  kOpenDirectory
+};
+
 // Interface provided by the browser to the renderer to carry out filesystem
 // operations. All [Sync] methods should only be called synchronously on worker
 // threads (and asynchronously otherwise).
@@ -219,7 +226,7 @@ interface FileSystemManager {
   // success.
   // TODO(https://crbug.com/878581): Add more options to this method to support
   //     multiple files, directories, "open" vs "save" dialogs, etc.
-  ChooseEntry() =>
+  ChooseEntry(ChooseFileSystemEntryType type) =>
       (mojo_base.mojom.FileError error_code,
        array<FileSystemEntry> entries);
 };

third_party/blink/renderer/modules/filesystem/README.md

+# FileSystem API
+
+This directory contains the renderer side implementation of various filesystem
+related APIs.
+
+## Related directories
+
+[`//storage/browser/fileapi/`](../../../storage/browser/fileapi) contains part
+of the browser side implementation, while
+[`//content/browser/fileapi/`](../../../content/browser/fileapi) contains the
+rest of the browser side implementation and
+[`blink/public/mojom/filesystem`](../../../third_party/blink/public/mojom/filesystem)
+contains the mojom interfaces for these APIs.
+
+## APIs In this directory
+
+### File and Directory Entries API
+
+First of all this directory contains the implementation of the
+[Entries API](https://wicg.github.io/entries-api). This API consists of
+types to expose read-only access to file and directory entries to the web,
+primarily used by drag-and-drop and `<input type=file>`. Our implementation
+doesn't match the interface names of the spec, but otherwise should be pretty
+close to the spec.
+
+TODO(mek): More details
+
+### File API: Directories and FileSystem
+
+Secondly this directory contains the implementation of something similar to the
+deprecated [w3c file-system-api](https://www.w3.org/TR/2012/WD-file-system-api-20120417/).
+This API is very similar to the previous Entries API, but it also adds support
+for writing and modifying to files and directories, as well as a way to get
+access to a origin scoped sandboxed filesystem.
+
+TODO(mek): More details
+
+### Writable Files
+
+Finally this directory contains the implementation of the new and still under
+development [Writable Files API](https://github.com/WICG/writable-files/blob/master/EXPLAINER.md).
+This API is mostly implemented on top of the same backend as the previous two
+APIs, but hopes to eventually replace both of those, while also adding new
+functionality.
+
+It consists of the following parts:
+
+ * `FileSystemBaseHandle`, `FileSystemFileHandle` and `FileSystemDirectoryHandle`:
+   these interfaces mimic the old `Entry` interfaces (and inherit from `EntryBase`
+   to share as much of the implementation as possible), but expose a more modern
+   promisified API.
+
+ * `getSystemDirectory`: An entry point (exposed via `FileSystemDirectoryHandle`)
+   that today only gives access to the same sandboxed filesystem as what was
+   available through the old API. In the future this could get extended to add
+   support for other directories as well.
+
+ * `FileSystemWriter`: a more modern API with similar functionality to the
+   old `FileWriter` API. The implementation of this actually does make use of
+   a different mojom interface than the old API. But since the functionality is
+   mostly the same, hopefully we will be able to migrate the old implementation
+   to the new mojom API as well.
+
+ * `chooseFileSystemEntries`: An entry point, currently on `window`, that lets
+   a website pop-up a file picker, prompting the user to select one or more
+   files or directories, to which the website than gets access.
+
+Since the `Handle` interfaces are based on the implementation of the `Entry`
+interfaces, internally and across IPC these are still represented by
+`filesystem://` URLs. Hopefully in the future we will be able to change this and
+turn it into a more capabilities based API (where having a mojo handle gives you
+access to specific files or directories), as with the current implementation it
+is very hard to properly support transferring handles to other processes via
+postMessage (which is something we do want to support in the future).

third_party/blink/renderer/modules/filesystem/choose_file_system_entries_options.idl

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://github.com/WICG/writable-files/blob/master/EXPLAINER.md
+enum ChooseFileSystemEntriesType { "openFile", "saveFile", "openDirectory" };
+
+dictionary ChooseFileSystemEntriesOptions {
+    ChooseFileSystemEntriesType type = "openFile";
+    boolean multiple = false;
+};

third_party/blink/renderer/modules/filesystem/dom_window_file_system.cc

@@ -135,7 +135,8 @@ static_assert(
 
 ScriptPromise DOMWindowFileSystem::chooseFileSystemEntries(
     ScriptState* script_state,
-    LocalDOMWindow& window) {
+    LocalDOMWindow& window,
+    const ChooseFileSystemEntriesOptions& options) {
   if (!window.IsCurrentlyDisplayedInFrame()) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(DOMExceptionCode::kAbortError));
@@ -157,7 +158,7 @@ ScriptPromise DOMWindowFileSystem::chooseFileSystemEntries(
 
   auto* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise result = resolver->Promise();
-  LocalFileSystem::From(*document)->ChooseEntry(resolver);
+  LocalFileSystem::From(*document)->ChooseEntry(resolver, options);
   return result;
 }
 

third_party/blink/renderer/modules/filesystem/dom_window_file_system.h

@@ -32,6 +32,7 @@
 
 namespace blink {
 
+class ChooseFileSystemEntriesOptions;
 class LocalDOMWindow;
 class ScriptPromise;
 class ScriptState;
@@ -60,7 +61,10 @@ class DOMWindowFileSystem {
     kPersistent,
   };
 
-  static ScriptPromise chooseFileSystemEntries(ScriptState*, LocalDOMWindow&);
+  static ScriptPromise chooseFileSystemEntries(
+      ScriptState*,
+      LocalDOMWindow&,
+      const ChooseFileSystemEntriesOptions&);
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/filesystem/file_system_dispatcher.cc

@@ -436,18 +436,20 @@ void FileSystemDispatcher::CreateFileWriter(
 }
 
 void FileSystemDispatcher::ChooseEntry(
+    mojom::blink::ChooseFileSystemEntryType type,
     std::unique_ptr<ChooseEntryCallbacks> callbacks) {
-  GetFileSystemManager().ChooseEntry(WTF::Bind(
-      [](std::unique_ptr<ChooseEntryCallbacks> callbacks,
-         base::File::Error result,
-         Vector<mojom::blink::FileSystemEntryPtr> entries) {
-        if (result != base::File::FILE_OK) {
-          callbacks->OnError(result);
-        } else {
-          callbacks->OnSuccess(std::move(entries));
-        }
-      },
-      std::move(callbacks)));
+  GetFileSystemManager().ChooseEntry(
+      type, WTF::Bind(
+                [](std::unique_ptr<ChooseEntryCallbacks> callbacks,
+                   base::File::Error result,
+                   Vector<mojom::blink::FileSystemEntryPtr> entries) {
+                  if (result != base::File::FILE_OK) {
+                    callbacks->OnError(result);
+                  } else {
+                    callbacks->OnSuccess(std::move(entries));
+                  }
+                },
+                std::move(callbacks)));
 }
 
 mojom::blink::FileSystemManager& FileSystemDispatcher::GetFileSystemManager() {

third_party/blink/renderer/modules/filesystem/file_system_dispatcher.h

@@ -143,7 +143,8 @@ class FileSystemDispatcher
 
   using ChooseEntryCallbacks =
       WebCallbacks<Vector<mojom::blink::FileSystemEntryPtr>, base::File::Error>;
-  void ChooseEntry(std::unique_ptr<ChooseEntryCallbacks> callbacks);
+  void ChooseEntry(mojom::blink::ChooseFileSystemEntryType,
+                   std::unique_ptr<ChooseEntryCallbacks> callbacks);
 
  private:
   class WriteListener;

third_party/blink/renderer/modules/filesystem/local_file_system.cc

@@ -43,6 +43,7 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_client.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
+#include "third_party/blink/renderer/modules/filesystem/choose_file_system_entries_options.h"
 #include "third_party/blink/renderer/modules/filesystem/directory_entry.h"
 #include "third_party/blink/renderer/modules/filesystem/dom_file_system.h"
 #include "third_party/blink/renderer/modules/filesystem/file_system_client.h"
@@ -120,12 +121,13 @@ class ChooseEntryCallbacks
     : public WebCallbacks<Vector<mojom::blink::FileSystemEntryPtr>,
                           base::File::Error> {
  public:
-  ChooseEntryCallbacks(ScriptPromiseResolver* resolver, bool return_multiple)
-      : resolver_(resolver), return_multiple_(return_multiple) {}
+  ChooseEntryCallbacks(ScriptPromiseResolver* resolver,
+                       const ChooseFileSystemEntriesOptions& options)
+      : resolver_(resolver), options_(options) {}
 
   void OnSuccess(Vector<mojom::blink::FileSystemEntryPtr> entries) override {
     ScriptState::Scope scope(resolver_->GetScriptState());
-    if (return_multiple_) {
+    if (options_.multiple()) {
       Vector<ScriptPromise> result;
       result.ReserveInitialCapacity(SafeCast<wtf_size_t>(entries.size()));
       for (const auto& entry : entries)
@@ -152,19 +154,43 @@ class ChooseEntryCallbacks
         resolver_->GetExecutionContext(), entry->file_system_id);
     // TODO(mek): Try to create handle directly rather than having to do more
     // IPCs to get the actual entries.
-    fs->GetFile(fs->root(), entry->base_name, FileSystemFlags(),
-                new EntryCallbacks::OnDidGetEntryPromiseImpl(new_resolver),
-                new PromiseErrorCallback(new_resolver));
+    if (options_.type() == "openDirectory") {
+      fs->GetDirectory(
+          fs->root(), entry->base_name, FileSystemFlags(),
+          new EntryCallbacks::OnDidGetEntryPromiseImpl(new_resolver),
+          new PromiseErrorCallback(new_resolver));
+    } else {
+      fs->GetFile(fs->root(), entry->base_name, FileSystemFlags(),
+                  new EntryCallbacks::OnDidGetEntryPromiseImpl(new_resolver),
+                  new PromiseErrorCallback(new_resolver));
+    }
     return result;
   }
 
   Persistent<ScriptPromiseResolver> resolver_;
-  bool return_multiple_;
+  ChooseFileSystemEntriesOptions options_;
 };
 
+mojom::blink::ChooseFileSystemEntryType ConvertChooserType(const String& input,
+                                                           bool multiple) {
+  if (input == "openFile") {
+    return multiple
+               ? mojom::blink::ChooseFileSystemEntryType::kOpenMultipleFiles
+               : mojom::blink::ChooseFileSystemEntryType::kOpenFile;
+  }
+  if (input == "saveFile")
+    return mojom::blink::ChooseFileSystemEntryType::kSaveFile;
+  if (input == "openDirectory")
+    return mojom::blink::ChooseFileSystemEntryType::kOpenDirectory;
+  NOTREACHED();
+  return mojom::blink::ChooseFileSystemEntryType::kOpenFile;
+}
+
 }  // namespace
 
-void LocalFileSystem::ChooseEntry(ScriptPromiseResolver* resolver) {
+void LocalFileSystem::ChooseEntry(
+    ScriptPromiseResolver* resolver,
+    const ChooseFileSystemEntriesOptions& options) {
   if (!base::FeatureList::IsEnabled(blink::features::kWritableFilesAPI)) {
     resolver->Reject(
         FileError::CreateDOMException(base::File::FILE_ERROR_ABORT));
@@ -172,7 +198,8 @@ void LocalFileSystem::ChooseEntry(ScriptPromiseResolver* resolver) {
   }
 
   FileSystemDispatcher::From(resolver->GetExecutionContext())
-      .ChooseEntry(std::make_unique<ChooseEntryCallbacks>(resolver, false));
+      .ChooseEntry(ConvertChooserType(options.type(), options.multiple()),
+                   std::make_unique<ChooseEntryCallbacks>(resolver, options));
 }
 
 void LocalFileSystem::RequestFileSystemAccessInternal(

third_party/blink/renderer/modules/filesystem/local_file_system.h

@@ -45,6 +45,7 @@ namespace blink {
 
 class AsyncFileSystemCallbacks;
 class CallbackWrapper;
+class ChooseFileSystemEntriesOptions;
 class FileSystemClient;
 class ExecutionContext;
 class KURL;
@@ -76,7 +77,8 @@ class LocalFileSystem final : public GarbageCollectedFinalized<LocalFileSystem>,
                          std::unique_ptr<AsyncFileSystemCallbacks>,
                          SynchronousType sync_type);
 
-  void ChooseEntry(ScriptPromiseResolver*);
+  void ChooseEntry(ScriptPromiseResolver*,
+                   const ChooseFileSystemEntriesOptions& options);
 
   FileSystemClient& Client() const { return *client_; }
 

third_party/blink/renderer/modules/filesystem/window_file_system.idl

@@ -41,5 +41,6 @@
     // https://github.com/WICG/writable-files/blob/master/EXPLAINER.md
     // TODO(crbug.com/878581): This needs some kind of options dictionary.
     [RuntimeEnabled=WritableFiles, CallWith=ScriptState, SecureContext]
-    Promise<(FileSystemBaseHandle or sequence<FileSystemBaseHandle>)> chooseFileSystemEntries();
+    Promise<(FileSystemBaseHandle or sequence<FileSystemBaseHandle>)>
+        chooseFileSystemEntries(optional ChooseFileSystemEntriesOptions options);
 };

third_party/blink/renderer/modules/modules_idl_files.gni

@@ -528,6 +528,7 @@ modules_dictionary_idl_files =
           "encryptedmedia/media_key_system_media_capability.idl",
           "encryptedmedia/media_keys_policy.idl",
           "eventsource/event_source_init.idl",
+          "filesystem/choose_file_system_entries_options.idl",
           "filesystem/file_system_directory_iterator_entry.idl",
           "filesystem/file_system_flags.idl",
           "filesystem/file_system_get_directory_options.idl",