[Native File System] Start implementing read/write permissions.

No prompting for permissions is implemented yet, so all permissions are always
denied unless chrome was launched with --enable-experimental-web-platform-features.
This implements the plumbing/ground work on top of which
prompting and a more complicated permission model will be added.

Also operations don't actually check if permissions have been granted, that too
will be added in a follow-up CL.

Tbr: jbroman
Bug: 878585
Change-Id: I2325fdcebbc3ccf1f688b101f01fd5b20437d3b1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1636471
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: Chris Palmer <palmer@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#666549}

content/browser/native_file_system/file_system_chooser_browsertest.cc

@@ -8,6 +8,7 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/native_file_system/file_system_chooser_test_helpers.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
@@ -34,6 +35,12 @@ class FileSystemChooserBrowserTest : public ContentBrowserTest {
     ContentBrowserTest::SetUp();
   }
 
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    // Enable experimental web platform features to enable write access.
+    command_line->AppendSwitch(
+        switches::kEnableExperimentalWebPlatformFeatures);
+  }
+
   void TearDown() override {
     ContentBrowserTest::TearDown();
     ASSERT_TRUE(temp_dir_.Delete());

content/browser/native_file_system/native_file_system_directory_handle_impl.cc

@@ -65,6 +65,18 @@ NativeFileSystemDirectoryHandleImpl::NativeFileSystemDirectoryHandleImpl(
 NativeFileSystemDirectoryHandleImpl::~NativeFileSystemDirectoryHandleImpl() =
     default;
 
+void NativeFileSystemDirectoryHandleImpl::GetPermissionStatus(
+    bool writable,
+    GetPermissionStatusCallback callback) {
+  DoGetPermissionStatus(writable, std::move(callback));
+}
+
+void NativeFileSystemDirectoryHandleImpl::RequestPermission(
+    bool writable,
+    RequestPermissionCallback callback) {
+  DoRequestPermission(writable, std::move(callback));
+}
+
 void NativeFileSystemDirectoryHandleImpl::GetFile(const std::string& name,
                                                   bool create,
                                                   GetFileCallback callback) {

content/browser/native_file_system/native_file_system_directory_handle_impl.h

@@ -33,6 +33,10 @@ class NativeFileSystemDirectoryHandleImpl
   ~NativeFileSystemDirectoryHandleImpl() override;
 
   // blink::mojom::NativeFileSystemDirectoryHandle:
+  void GetPermissionStatus(bool writable,
+                           GetPermissionStatusCallback callback) override;
+  void RequestPermission(bool writable,
+                         RequestPermissionCallback callback) override;
   void GetFile(const std::string& name,
                bool create,
                GetFileCallback callback) override;

content/browser/native_file_system/native_file_system_file_handle_impl.cc

@@ -38,6 +38,18 @@ NativeFileSystemFileHandleImpl::NativeFileSystemFileHandleImpl(
 
 NativeFileSystemFileHandleImpl::~NativeFileSystemFileHandleImpl() = default;
 
+void NativeFileSystemFileHandleImpl::GetPermissionStatus(
+    bool writable,
+    GetPermissionStatusCallback callback) {
+  DoGetPermissionStatus(writable, std::move(callback));
+}
+
+void NativeFileSystemFileHandleImpl::RequestPermission(
+    bool writable,
+    RequestPermissionCallback callback) {
+  DoRequestPermission(writable, std::move(callback));
+}
+
 void NativeFileSystemFileHandleImpl::AsBlob(AsBlobCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mek): Check backend::SupportsStreaming and create snapshot file if

content/browser/native_file_system/native_file_system_file_handle_impl.h

@@ -43,6 +43,10 @@ class CONTENT_EXPORT NativeFileSystemFileHandleImpl
   ~NativeFileSystemFileHandleImpl() override;
 
   // blink::mojom::NativeFileSystemFileHandle:
+  void GetPermissionStatus(bool writable,
+                           GetPermissionStatusCallback callback) override;
+  void RequestPermission(bool writable,
+                         RequestPermissionCallback callback) override;
   void AsBlob(AsBlobCallback callback) override;
   void Remove(RemoveCallback callback) override;
   void Write(uint64_t offset,

content/browser/native_file_system/native_file_system_handle_base.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/native_file_system/native_file_system_handle_base.h"
 
+#include "content/public/common/content_switches.h"
+
 namespace content {
 
 NativeFileSystemHandleBase::NativeFileSystemHandleBase(
@@ -19,8 +21,67 @@ NativeFileSystemHandleBase::NativeFileSystemHandleBase(
   DCHECK_EQ(url_.mount_type() == storage::kFileSystemTypeIsolated,
             file_system_.is_valid())
       << url_.mount_type();
+  // For now only support sandboxed file system and native file system.
+  DCHECK(url_.type() == storage::kFileSystemTypeNativeLocal ||
+         url_.type() == storage::kFileSystemTypePersistent ||
+         url_.type() == storage::kFileSystemTypeTemporary ||
+         url_.type() == storage::kFileSystemTypeTest)
+      << url_.type();
+  // Sandboxed and test file systems should always be writable.
+  if (url_.type() == storage::kFileSystemTypePersistent ||
+      url_.type() == storage::kFileSystemTypeTemporary ||
+      url_.type() == storage::kFileSystemTypeTest) {
+    write_permission_status_ = PermissionStatus::GRANTED;
+  }
 }
 
 NativeFileSystemHandleBase::~NativeFileSystemHandleBase() = default;
 
-}  // namespace content
+NativeFileSystemHandleBase::PermissionStatus
\ No newline at end of file
+NativeFileSystemHandleBase::GetWritePermissionStatus() const {
+  // It is not currently possible to have write only handles, so first check the
+  // read permission status. See also:
+  // http://wicg.github.io/native-file-system/#api-filesystemhandle-querypermission
+  if (read_permission_status_ != PermissionStatus::GRANTED)
+    return read_permission_status_;
+  return write_permission_status_;
+}
+
+void NativeFileSystemHandleBase::DoGetPermissionStatus(
+    bool writable,
+    base::OnceCallback<void(PermissionStatus)> callback) {
+  std::move(callback).Run(writable ? GetWritePermissionStatus()
+                                   : GetReadPermissionStatus());
+}
+
+void NativeFileSystemHandleBase::DoRequestPermission(
+    bool writable,
+    base::OnceCallback<void(PermissionStatus)> callback) {
+  PermissionStatus current_status =
+      writable ? GetWritePermissionStatus() : GetReadPermissionStatus();
+  if (current_status != PermissionStatus::ASK) {
+    std::move(callback).Run(current_status);
+    return;
+  }
+  if (!writable) {
+    // TODO(https://crbug.com/971401): Implement prompt. Currently unreachable,
+    // since read permission isn't revokable yet.
+    std::move(callback).Run(read_permission_status_);
+    return;
+  }
+  // TODO(https://crbug.com/971401): Today read permission isn't revokable, so
+  // current status should always be GRANTED.
+  DCHECK_EQ(GetReadPermissionStatus(), PermissionStatus::GRANTED);
+  // TODO(https://crbug.com/878585): Actually prompt for write permission. For
+  // now we're just always denying requests, unless Experimental Web Platform
+  // features are enabled.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalWebPlatformFeatures)) {
+    write_permission_status_ = PermissionStatus::GRANTED;
+  } else {
+    write_permission_status_ = PermissionStatus::DENIED;
+  }
+  std::move(callback).Run(write_permission_status_);
+}
+
+}  // namespace content

content/browser/native_file_system/native_file_system_handle_base.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "content/browser/native_file_system/native_file_system_manager_impl.h"
+#include "content/common/content_export.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "third_party/blink/public/mojom/permissions/permission_status.mojom.h"
@@ -29,9 +30,10 @@ namespace content {
 // thread. This is because code interacts directly with the file system backends
 // (via storage::FileSystemContext and store::FileSystemOperationRunner, which
 // both expect some of their methods to only be called on the IO thread).
-class NativeFileSystemHandleBase {
+class CONTENT_EXPORT NativeFileSystemHandleBase {
  public:
   using BindingContext = NativeFileSystemManagerImpl::BindingContext;
+  using PermissionStatus = blink::mojom::PermissionStatus;
 
   NativeFileSystemHandleBase(
       NativeFileSystemManagerImpl* manager,
@@ -45,6 +47,21 @@ class NativeFileSystemHandleBase {
     return file_system_;
   }
 
+  PermissionStatus GetReadPermissionStatus() const {
+    return read_permission_status_;
+  }
+  PermissionStatus GetWritePermissionStatus() const;
+
+  // Implementation for the GetPermissionStatus method in the
+  // blink::mojom::NativeFileSystemFileHandle and DirectoryHandle interfaces.
+  void DoGetPermissionStatus(
+      bool writable,
+      base::OnceCallback<void(PermissionStatus)> callback);
+  // Implementation for the RequestPermission method in the
+  // blink::mojom::NativeFileSystemFileHandle and DirectoryHandle interfaces.
+  void DoRequestPermission(bool writable,
+                           base::OnceCallback<void(PermissionStatus)> callback);
+
  protected:
   NativeFileSystemManagerImpl* manager() { return manager_; }
   const BindingContext& context() { return context_; }
@@ -65,6 +82,11 @@ class NativeFileSystemHandleBase {
   const storage::FileSystemURL url_;
   const storage::IsolatedContext::ScopedFSHandle file_system_;
 
+  // TODO(mek): We'll likely end up with something more complicated than simple
+  // fields like this, but this will do for now.
+  PermissionStatus read_permission_status_ = PermissionStatus::GRANTED;
+  PermissionStatus write_permission_status_ = PermissionStatus::ASK;
+
   DISALLOW_COPY_AND_ASSIGN(NativeFileSystemHandleBase);
 };
 

content/browser/native_file_system/native_file_system_handle_base_unittest.cc

+// Copyright 2019 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.
+
+#include "content/browser/native_file_system/native_file_system_handle_base.h"
+
+#include "base/files/scoped_temp_dir.h"
+#include "base/test/bind_test_util.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/scoped_task_environment.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/test/test_file_system_context.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/common/features.h"
+
+namespace content {
+
+using blink::mojom::PermissionStatus;
+using storage::FileSystemURL;
+
+class NativeFileSystemHandleBaseTest : public testing::Test {
+ public:
+  NativeFileSystemHandleBaseTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::IO) {
+    scoped_feature_list_.InitAndEnableFeature(
+        blink::features::kNativeFileSystemAPI);
+  }
+
+  void SetUp() override {
+    ASSERT_TRUE(dir_.CreateUniqueTempDir());
+    file_system_context_ = CreateFileSystemContextForTesting(
+        /*quota_manager_proxy=*/nullptr, dir_.GetPath());
+
+    chrome_blob_context_ = base::MakeRefCounted<ChromeBlobStorageContext>();
+    chrome_blob_context_->InitializeOnIOThread(base::FilePath(), nullptr);
+
+    manager_ = base::MakeRefCounted<NativeFileSystemManagerImpl>(
+        file_system_context_, chrome_blob_context_);
+  }
+
+ protected:
+  const url::Origin kTestOrigin =
+      url::Origin::Create(GURL("https://example.com"));
+  base::test::ScopedFeatureList scoped_feature_list_;
+  TestBrowserThreadBundle scoped_task_environment_;
+
+  base::ScopedTempDir dir_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
+  scoped_refptr<ChromeBlobStorageContext> chrome_blob_context_;
+  scoped_refptr<NativeFileSystemManagerImpl> manager_;
+};
+
+TEST_F(NativeFileSystemHandleBaseTest, InitialPermissionStatus_TestURL) {
+  auto url =
+      FileSystemURL::CreateForTest(kTestOrigin, storage::kFileSystemTypeTest,
+                                   base::FilePath::FromUTF8Unsafe("test"));
+  NativeFileSystemHandleBase handle(manager_.get(),
+                                    NativeFileSystemManagerImpl::BindingContext(
+                                        kTestOrigin, /*process_id=*/1,
+                                        /*frame_id=*/MSG_ROUTING_NONE),
+                                    url,
+                                    storage::IsolatedContext::ScopedFSHandle());
+  EXPECT_EQ(PermissionStatus::GRANTED, handle.GetReadPermissionStatus());
+  EXPECT_EQ(PermissionStatus::GRANTED, handle.GetWritePermissionStatus());
+}
+
+TEST_F(NativeFileSystemHandleBaseTest, InitialPermissionStatus_SandboxedURL) {
+  auto url = FileSystemURL::CreateForTest(
+      kTestOrigin, storage::kFileSystemTypeTemporary,
+      base::FilePath::FromUTF8Unsafe("test"));
+
+  NativeFileSystemHandleBase handle(manager_.get(),
+                                    NativeFileSystemManagerImpl::BindingContext(
+                                        kTestOrigin, /*process_id=*/1,
+                                        /*frame_id=*/MSG_ROUTING_NONE),
+                                    url,
+                                    storage::IsolatedContext::ScopedFSHandle());
+  EXPECT_EQ(PermissionStatus::GRANTED, handle.GetReadPermissionStatus());
+  EXPECT_EQ(PermissionStatus::GRANTED, handle.GetWritePermissionStatus());
+}
+
+TEST_F(NativeFileSystemHandleBaseTest, InitialPermissionStatus_NativeFSURL) {
+  auto url = FileSystemURL::CreateForTest(
+      kTestOrigin, storage::kFileSystemTypeNativeLocal,
+      base::FilePath::FromUTF8Unsafe("test"));
+
+  NativeFileSystemHandleBase handle(manager_.get(),
+                                    NativeFileSystemManagerImpl::BindingContext(
+                                        kTestOrigin, /*process_id=*/1,
+                                        /*frame_id=*/MSG_ROUTING_NONE),
+                                    url,
+                                    storage::IsolatedContext::ScopedFSHandle());
+  EXPECT_EQ(PermissionStatus::GRANTED, handle.GetReadPermissionStatus());
+  EXPECT_EQ(PermissionStatus::ASK, handle.GetWritePermissionStatus());
+}
+
+TEST_F(NativeFileSystemHandleBaseTest, RequestWritePermission_NativeFSURL) {
+  auto url = FileSystemURL::CreateForTest(
+      kTestOrigin, storage::kFileSystemTypeNativeLocal,
+      base::FilePath::FromUTF8Unsafe("test"));
+
+  NativeFileSystemHandleBase handle(manager_.get(),
+                                    NativeFileSystemManagerImpl::BindingContext(
+                                        kTestOrigin, /*process_id=*/1,
+                                        /*frame_id=*/MSG_ROUTING_NONE),
+                                    url,
+                                    storage::IsolatedContext::ScopedFSHandle());
+
+  base::RunLoop loop;
+  handle.DoRequestPermission(
+      /*writable=*/true,
+      base::BindLambdaForTesting([&](PermissionStatus result) {
+        EXPECT_EQ(PermissionStatus::DENIED, result);
+        loop.Quit();
+      }));
+  loop.Run();
+  EXPECT_EQ(PermissionStatus::DENIED, handle.GetWritePermissionStatus());
+}
+
+}  // namespace content

content/test/BUILD.gn

@@ -1609,6 +1609,7 @@ test("content_unittests") {
     "../browser/memory/test_memory_monitor.h",
     "../browser/native_file_system/file_system_chooser_unittest.cc",
     "../browser/native_file_system/native_file_system_file_handle_impl_unittest.cc",
+    "../browser/native_file_system/native_file_system_handle_base_unittest.cc",
     "../browser/net/network_quality_observer_impl_unittest.cc",
     "../browser/net/quota_policy_cookie_store_unittest.cc",
     "../browser/network_service_client_unittest.cc",

third_party/blink/public/mojom/native_file_system/native_file_system_directory_handle.mojom

@@ -7,6 +7,7 @@ module blink.mojom;
 import "third_party/blink/public/mojom/native_file_system/native_file_system_file_handle.mojom";
 import "third_party/blink/public/mojom/native_file_system/native_file_system_error.mojom";
 import "third_party/blink/public/mojom/native_file_system/native_file_system_transfer_token.mojom";
+import "third_party/blink/public/mojom/permissions/permission_status.mojom";
 
 // Union representing either a file or a directory handle. Used in APIs that
 // can return arbitrary handles.
@@ -30,6 +31,13 @@ struct NativeFileSystemEntry {
 // fact that our paths really aren't base::FilePath, but instead are virtual
 // paths).
 interface NativeFileSystemDirectoryHandle {
+  // Queries the current permission status for this handle.
+  GetPermissionStatus(bool writable) => (PermissionStatus status);
+
+  // Requests read and/or write permission for this handle. Returns the new
+  // permission status for this handle.
+  RequestPermission(bool writable) => (PermissionStatus status);
+
   // Returns a file with the given |name| that is a child of this directory. If
   // no such file exists, and |create| is true, the file is first created.
   // Returns an error if the operation fails, or a handle to the newly created

third_party/blink/public/mojom/native_file_system/native_file_system_file_handle.mojom

@@ -8,10 +8,18 @@ import "third_party/blink/public/mojom/blob/blob.mojom";
 import "third_party/blink/public/mojom/blob/serialized_blob.mojom";
 import "third_party/blink/public/mojom/native_file_system/native_file_system_error.mojom";
 import "third_party/blink/public/mojom/native_file_system/native_file_system_transfer_token.mojom";
+import "third_party/blink/public/mojom/permissions/permission_status.mojom";
 
 // This interface represents a handle to a directory in the Native File System
 // API.
 interface NativeFileSystemFileHandle {
+  // Queries the current permission status for this handle.
+  GetPermissionStatus(bool writable) => (PermissionStatus status);
+
+  // Requests read and/or write permission for this handle. Returns the new
+  // permission status for this handle.
+  RequestPermission(bool writable) => (PermissionStatus status);
+
   // Returns a blob representing the current state of this file.
   AsBlob() => (NativeFileSystemError result, SerializedBlob? blob);
 

third_party/blink/renderer/modules/modules_idl_files.gni

@@ -655,6 +655,7 @@ modules_dictionary_idl_files =
           "native_file_system/choose_file_system_entries_options_accepts.idl",
           "native_file_system/file_system_get_directory_options.idl",
           "native_file_system/file_system_get_file_options.idl",
+          "native_file_system/file_system_handle_permission_descriptor.idl",
           "native_file_system/get_system_directory_options.idl",
           "native_file_system/native_file_system_directory_iterator_entry.idl",
           "nfc/ndef_message.idl",

third_party/blink/renderer/modules/native_file_system/file_system_handle.idl

@@ -16,4 +16,9 @@
     readonly attribute USVString name;
 
     [CallWith=ScriptState] Promise<void> remove();
+
+    [CallWith = ScriptState] Promise<PermissionState> queryPermission(
+        optional FileSystemHandlePermissionDescriptor descriptor);
+    [CallWith = ScriptState] Promise<PermissionState> requestPermission(
+        optional FileSystemHandlePermissionDescriptor descriptor);
 };

third_party/blink/renderer/modules/native_file_system/file_system_handle_permission_descriptor.idl

+// Copyright 2019 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.
+
+// http://wicg.github.io/native-file-system/#dictdef-filesystemhandlepermissiondescriptor
+dictionary FileSystemHandlePermissionDescriptor {
+  boolean writable = false;
+};

third_party/blink/renderer/modules/native_file_system/native_file_system_directory_handle.cc

@@ -182,4 +182,16 @@ void NativeFileSystemDirectoryHandle::RemoveImpl(
   mojo_ptr_->Remove(/*recursive=*/false, std::move(callback));
 }
 
+void NativeFileSystemDirectoryHandle::QueryPermissionImpl(
+    bool writable,
+    base::OnceCallback<void(mojom::blink::PermissionStatus)> callback) {
+  mojo_ptr_->GetPermissionStatus(writable, std::move(callback));
+}
+
+void NativeFileSystemDirectoryHandle::RequestPermissionImpl(
+    bool writable,
+    base::OnceCallback<void(mojom::blink::PermissionStatus)> callback) {
+  mojo_ptr_->RequestPermission(writable, std::move(callback));
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/native_file_system/native_file_system_directory_handle.h

@@ -45,6 +45,12 @@ class NativeFileSystemDirectoryHandle final : public NativeFileSystemHandle {
   void RemoveImpl(
       base::OnceCallback<void(mojom::blink::NativeFileSystemErrorPtr)>)
       override;
+  void QueryPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) override;
+  void RequestPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) override;
 
   mojom::blink::NativeFileSystemDirectoryHandlePtr mojo_ptr_;
 };

third_party/blink/renderer/modules/native_file_system/native_file_system_file_handle.cc

@@ -69,9 +69,22 @@ NativeFileSystemFileHandle::Transfer() {
   mojo_ptr_->Transfer(mojo::MakeRequest(&result));
   return result;
 }
+
 void NativeFileSystemFileHandle::RemoveImpl(
     base::OnceCallback<void(mojom::blink::NativeFileSystemErrorPtr)> callback) {
   mojo_ptr_->Remove(std::move(callback));
 }
 
+void NativeFileSystemFileHandle::QueryPermissionImpl(
+    bool writable,
+    base::OnceCallback<void(mojom::blink::PermissionStatus)> callback) {
+  mojo_ptr_->GetPermissionStatus(writable, std::move(callback));
+}
+
+void NativeFileSystemFileHandle::RequestPermissionImpl(
+    bool writable,
+    base::OnceCallback<void(mojom::blink::PermissionStatus)> callback) {
+  mojo_ptr_->RequestPermission(writable, std::move(callback));
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/native_file_system/native_file_system_file_handle.h

@@ -33,6 +33,12 @@ class NativeFileSystemFileHandle final : public NativeFileSystemHandle {
   void RemoveImpl(
       base::OnceCallback<void(mojom::blink::NativeFileSystemErrorPtr)>)
       override;
+  void QueryPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) override;
+  void RequestPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) override;
 
   mojom::blink::NativeFileSystemFileHandlePtr mojo_ptr_;
 };

third_party/blink/renderer/modules/native_file_system/native_file_system_handle.cc

@@ -8,6 +8,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/fileapi/file_error.h"
+#include "third_party/blink/renderer/modules/native_file_system/file_system_handle_permission_descriptor.h"
 #include "third_party/blink/renderer/modules/native_file_system/native_file_system_directory_handle.h"
 #include "third_party/blink/renderer/modules/native_file_system/native_file_system_file_handle.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
@@ -49,4 +50,55 @@ ScriptPromise NativeFileSystemHandle::remove(ScriptState* script_state) {
   return result;
 }
 
+namespace {
+String MojoPermissionStatusToString(mojom::blink::PermissionStatus status) {
+  switch (status) {
+    case mojom::blink::PermissionStatus::GRANTED:
+      return "granted";
+    case mojom::blink::PermissionStatus::DENIED:
+      return "denied";
+    case mojom::blink::PermissionStatus::ASK:
+      return "prompt";
+  }
+  NOTREACHED();
+  return "denied";
+}
+}  // namespace
+
+ScriptPromise NativeFileSystemHandle::queryPermission(
+    ScriptState* script_state,
+    const FileSystemHandlePermissionDescriptor* descriptor) {
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise result = resolver->Promise();
+
+  QueryPermissionImpl(
+      descriptor->writable(),
+      WTF::Bind(
+          [](ScriptPromiseResolver* resolver,
+             mojom::blink::PermissionStatus result) {
+            resolver->Resolve(MojoPermissionStatusToString(result));
+          },
+          WrapPersistent(resolver)));
+
+  return result;
+}
+
+ScriptPromise NativeFileSystemHandle::requestPermission(
+    ScriptState* script_state,
+    const FileSystemHandlePermissionDescriptor* descriptor) {
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise result = resolver->Promise();
+
+  RequestPermissionImpl(
+      descriptor->writable(),
+      WTF::Bind(
+          [](ScriptPromiseResolver* resolver,
+             mojom::blink::PermissionStatus result) {
+            resolver->Resolve(MojoPermissionStatusToString(result));
+          },
+          WrapPersistent(resolver)));
+
+  return result;
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/native_file_system/native_file_system_handle.h

@@ -8,6 +8,7 @@
 #include "third_party/blink/public/mojom/native_file_system/native_file_system_directory_handle.mojom-blink-forward.h"
 #include "third_party/blink/public/mojom/native_file_system/native_file_system_error.mojom-blink-forward.h"
 #include "third_party/blink/public/mojom/native_file_system/native_file_system_transfer_token.mojom-blink-forward.h"
+#include "third_party/blink/public/mojom/permissions/permission_status.mojom-blink-forward.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
@@ -16,6 +17,7 @@
 
 namespace blink {
 class NativeFileSystemDirectoryHandle;
+class FileSystemHandlePermissionDescriptor;
 
 class NativeFileSystemHandle : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
@@ -37,11 +39,22 @@ class NativeFileSystemHandle : public ScriptWrappable {
                        const String& new_name = String());
   ScriptPromise remove(ScriptState*);
 
+  ScriptPromise queryPermission(ScriptState*,
+                                const FileSystemHandlePermissionDescriptor*);
+  ScriptPromise requestPermission(ScriptState*,
+                                  const FileSystemHandlePermissionDescriptor*);
+
   virtual mojom::blink::NativeFileSystemTransferTokenPtr Transfer() = 0;
 
  private:
   virtual void RemoveImpl(
       base::OnceCallback<void(mojom::blink::NativeFileSystemErrorPtr)>) = 0;
+  virtual void QueryPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) = 0;
+  virtual void RequestPermissionImpl(
+      bool writable,
+      base::OnceCallback<void(mojom::blink::PermissionStatus)>) = 0;
 
   String name_;
 };