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

This reverts commit 9594a943.

Reason for revert: https://crrev.com/c/1217506 is causing crashes in Canary (https://crbug.com/889422). Reverting this CL is necessary in order to be able to revert that CL.

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=dcheng@chromium.org,dmurph@chromium.org,mek@chromium.org

Change-Id: I8af7db79f5156bc354ade87b2ac5e31955b41cc3
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 878581
Reviewed-on: https://chromium-review.googlesource.com/1246862Reviewed-by: Adithya Srinivasan <adithyas@chromium.org>
Commit-Queue: Adithya Srinivasan <adithyas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#594446}

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,8 +5,6 @@
 #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"
@@ -21,37 +19,20 @@ 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, type, std::move(callback), std::move(callback_runner));
+  auto* listener = new FileSystemChooser(render_process_id, 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(
-      dialog_type, /*title=*/base::string16(),
+      ui::SelectFileDialog::SELECT_OPEN_FILE, /*title=*/base::string16(),
       /*default_path=*/base::FilePath(), /*file_types=*/nullptr,
       /*file_type_index=*/0,
       /*default_extension=*/base::FilePath::StringType(),
@@ -61,13 +42,11 @@ 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)),
-      type_(type) {}
+      callback_runner_(std::move(callback_runner)) {}
 
 FileSystemChooser::~FileSystemChooser() {
   if (dialog_)
@@ -94,72 +73,21 @@ void FileSystemChooser::MultiFilesSelected(
   for (const auto& path : files) {
     auto entry = blink::mojom::FileSystemEntry::New();
     entry->file_system_id = isolated_context->RegisterFileSystemForPath(
-        storage::kFileSystemTypeNativeLocal, std::string(), path,
+        storage::kFileSystemTypeNativeForPlatformApp, 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);
-    // 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);
-    }
+    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,12 +25,10 @@ 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);
 
@@ -48,7 +46,6 @@ 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,9 +592,7 @@ void FileSystemManagerImpl::CreateWriter(const GURL& file_path,
   std::move(callback).Run(base::File::FILE_OK, std::move(writer));
 }
 
-void FileSystemManagerImpl::ChooseEntry(
-    blink::mojom::ChooseFileSystemEntryType type,
-    ChooseEntryCallback callback) {
+void FileSystemManagerImpl::ChooseEntry(ChooseEntryCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!base::FeatureList::IsEnabled(blink::features::kWritableFilesAPI)) {
     bindings_.ReportBadMessage("FSMI_WRITABLE_FILES_DISABLED");
@@ -604,7 +602,7 @@ void FileSystemManagerImpl::ChooseEntry(
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::UI},
       base::BindOnce(
-          &FileSystemChooser::CreateAndShow, process_id_, frame_id_, type,
+          &FileSystemChooser::CreateAndShow, process_id_, frame_id_,
           std::move(callback),
           base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO})));
 }

content/browser/fileapi/file_system_manager_impl.h

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

content/test/BUILD.gn

@@ -757,7 +757,6 @@ 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,13 +72,6 @@ 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).
@@ -226,7 +219,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(ChooseFileSystemEntryType type) =>
+  ChooseEntry() =>
       (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,8 +135,7 @@ static_assert(
 
 ScriptPromise DOMWindowFileSystem::chooseFileSystemEntries(
     ScriptState* script_state,
-    LocalDOMWindow& window,
-    const ChooseFileSystemEntriesOptions& options) {
+    LocalDOMWindow& window) {
   if (!window.IsCurrentlyDisplayedInFrame()) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(DOMExceptionCode::kAbortError));
@@ -158,7 +157,7 @@ ScriptPromise DOMWindowFileSystem::chooseFileSystemEntries(
 
   auto* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise result = resolver->Promise();
-  LocalFileSystem::From(*document)->ChooseEntry(resolver, options);
+  LocalFileSystem::From(*document)->ChooseEntry(resolver);
   return result;
 }
 

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

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

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

@@ -436,20 +436,18 @@ void FileSystemDispatcher::CreateFileWriter(
 }
 
 void FileSystemDispatcher::ChooseEntry(
-    mojom::blink::ChooseFileSystemEntryType type,
     std::unique_ptr<ChooseEntryCallbacks> 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)));
+  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)));
 }
 
 mojom::blink::FileSystemManager& FileSystemDispatcher::GetFileSystemManager() {

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

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

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

@@ -43,7 +43,6 @@
 #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,13 +119,12 @@ class ChooseEntryCallbacks
     : public WebCallbacks<Vector<mojom::blink::FileSystemEntryPtr>,
                           base::File::Error> {
  public:
-  ChooseEntryCallbacks(ScriptPromiseResolver* resolver,
-                       const ChooseFileSystemEntriesOptions& options)
-      : resolver_(resolver), options_(options) {}
+  ChooseEntryCallbacks(ScriptPromiseResolver* resolver, bool return_multiple)
+      : resolver_(resolver), return_multiple_(return_multiple) {}
 
   void OnSuccess(Vector<mojom::blink::FileSystemEntryPtr> entries) override {
     ScriptState::Scope scope(resolver_->GetScriptState());
-    if (options_.multiple()) {
+    if (return_multiple_) {
       Vector<ScriptPromise> result;
       result.ReserveInitialCapacity(entries.size());
       for (const auto& entry : entries)
@@ -153,43 +151,19 @@ 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.
-    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));
-    }
+    fs->GetFile(fs->root(), entry->base_name, FileSystemFlags(),
+                new EntryCallbacks::OnDidGetEntryPromiseImpl(new_resolver),
+                new PromiseErrorCallback(new_resolver));
     return result;
   }
 
   Persistent<ScriptPromiseResolver> resolver_;
-  ChooseFileSystemEntriesOptions options_;
+  bool return_multiple_;
 };
 
-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,
-    const ChooseFileSystemEntriesOptions& options) {
+void LocalFileSystem::ChooseEntry(ScriptPromiseResolver* resolver) {
   if (!base::FeatureList::IsEnabled(blink::features::kWritableFilesAPI)) {
     resolver->Reject(
         FileError::CreateDOMException(base::File::FILE_ERROR_ABORT));
@@ -197,8 +171,7 @@ void LocalFileSystem::ChooseEntry(
   }
 
   FileSystemDispatcher::From(resolver->GetExecutionContext())
-      .ChooseEntry(ConvertChooserType(options.type(), options.multiple()),
-                   std::make_unique<ChooseEntryCallbacks>(resolver, options));
+      .ChooseEntry(std::make_unique<ChooseEntryCallbacks>(resolver, false));
 }
 
 void LocalFileSystem::RequestFileSystemAccessInternal(

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

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

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

@@ -41,6 +41,5 @@
     // 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(optional ChooseFileSystemEntriesOptions options);
+    Promise<(FileSystemBaseHandle or sequence<FileSystemBaseHandle>)> chooseFileSystemEntries();
 };

third_party/blink/renderer/modules/modules_idl_files.gni

@@ -524,7 +524,6 @@ modules_dictionary_idl_files =
           "encryptedmedia/media_key_system_configuration.idl",
           "encryptedmedia/media_key_system_media_capability.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",