[NativeFS] Refactor is_directory bool values to an enum

In order to improve code readability, all NativeFS code using a boolean
value to distinguish between files and directories has been updated
to use an enum located in content::NativeFileSystemPermissionContext.

Bug: 1046545
Change-Id: I251e43f0226934e3e7991c0f3b9d1e7eb8f96bcf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2255338Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Commit-Queue: Hazim Mohamed <hazimmohamed@google.com>
Cr-Commit-Position: refs/heads/master@{#785257}

chrome/browser/native_file_system/chrome_native_file_system_permission_context.cc

@@ -36,7 +36,7 @@ void ShowNativeFileSystemRestrictedDirectoryDialogOnUIThread(
     content::GlobalFrameRoutingId frame_id,
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     base::OnceCallback<
         void(ChromeNativeFileSystemPermissionContext::SensitiveDirectoryResult)>
         callback) {
@@ -59,7 +59,7 @@ void ShowNativeFileSystemRestrictedDirectoryDialogOnUIThread(
   }
 
   ShowNativeFileSystemRestrictedDirectoryDialog(
-      origin, path, is_directory, std::move(callback), web_contents);
+      origin, path, handle_type, std::move(callback), web_contents);
 }
 
 // Sentinel used to indicate that no PathService key is specified for a path in
@@ -303,7 +303,7 @@ bool ChromeNativeFileSystemPermissionContext::CanObtainWritePermission(
 void ChromeNativeFileSystemPermissionContext::ConfirmSensitiveDirectoryAccess(
     const url::Origin& origin,
     const std::vector<base::FilePath>& paths,
-    bool is_directory,
+    HandleType handle_type,
     content::GlobalFrameRoutingId frame_id,
 
     base::OnceCallback<void(SensitiveDirectoryResult)> callback) {
@@ -320,7 +320,7 @@ void ChromeNativeFileSystemPermissionContext::ConfirmSensitiveDirectoryAccess(
       base::BindOnce(&ShouldBlockAccessToPath, paths[0]),
       base::BindOnce(&ChromeNativeFileSystemPermissionContext::
                          DidConfirmSensitiveDirectoryAccess,
-                     GetWeakPtr(), origin, paths, is_directory, frame_id,
+                     GetWeakPtr(), origin, paths, handle_type, frame_id,
                      std::move(callback)));
 }
 
@@ -351,7 +351,7 @@ void ChromeNativeFileSystemPermissionContext::
     DidConfirmSensitiveDirectoryAccess(
         const url::Origin& origin,
         const std::vector<base::FilePath>& paths,
-        bool is_directory,
+        HandleType handle_type,
         content::GlobalFrameRoutingId frame_id,
         base::OnceCallback<void(SensitiveDirectoryResult)> callback,
         bool should_block) {
@@ -367,7 +367,7 @@ void ChromeNativeFileSystemPermissionContext::
   content::GetUIThreadTaskRunner({})->PostTask(
       FROM_HERE,
       base::BindOnce(&ShowNativeFileSystemRestrictedDirectoryDialogOnUIThread,
-                     frame_id, origin, paths[0], is_directory,
+                     frame_id, origin, paths[0], handle_type,
                      std::move(result_callback)));
 }
 

chrome/browser/native_file_system/chrome_native_file_system_permission_context.h

@@ -49,7 +49,7 @@ class ChromeNativeFileSystemPermissionContext
   void ConfirmSensitiveDirectoryAccess(
       const url::Origin& origin,
       const std::vector<base::FilePath>& paths,
-      bool is_directory,
+      HandleType handle_type,
       content::GlobalFrameRoutingId frame_id,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback) override;
   void PerformAfterWriteChecks(
@@ -96,7 +96,7 @@ class ChromeNativeFileSystemPermissionContext
   void DidConfirmSensitiveDirectoryAccess(
       const url::Origin& origin,
       const std::vector<base::FilePath>& paths,
-      bool is_directory,
+      HandleType handle_type,
       content::GlobalFrameRoutingId frame_id,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback,
       bool should_block);

chrome/browser/native_file_system/chrome_native_file_system_permission_context_unittest.cc

@@ -47,7 +47,7 @@ class TestNativeFileSystemPermissionContext
   scoped_refptr<content::NativeFileSystemPermissionGrant>
   GetReadPermissionGrant(const url::Origin& origin,
                          const base::FilePath& path,
-                         bool is_directory,
+                         HandleType handle_type,
                          UserAction user_action) override {
     NOTREACHED();
     return nullptr;
@@ -55,7 +55,7 @@ class TestNativeFileSystemPermissionContext
   scoped_refptr<content::NativeFileSystemPermissionGrant>
   GetWritePermissionGrant(const url::Origin& origin,
                           const base::FilePath& path,
-                          bool is_directory,
+                          HandleType handle_type,
                           UserAction user_action) override {
     NOTREACHED();
     return nullptr;
@@ -103,7 +103,8 @@ class ChromeNativeFileSystemPermissionContextTest : public testing::Test {
     base::RunLoop loop;
     SensitiveDirectoryResult out_result;
     permission_context_->ConfirmSensitiveDirectoryAccess(
-        kTestOrigin, paths, /*is_directory=*/false,
+        kTestOrigin, paths,
+        content::NativeFileSystemPermissionContext::HandleType::kFile,
         content::GlobalFrameRoutingId(),
         base::BindLambdaForTesting([&](SensitiveDirectoryResult result) {
           out_result = result;

chrome/browser/native_file_system/native_file_system_permission_request_manager.cc

@@ -17,14 +17,14 @@ bool RequestsAreIdentical(
     const NativeFileSystemPermissionRequestManager::RequestData& a,
     const NativeFileSystemPermissionRequestManager::RequestData& b) {
   return a.origin == b.origin && a.path == b.path &&
-         a.is_directory == b.is_directory && a.access == b.access;
+         a.handle_type == b.handle_type && a.access == b.access;
 }
 
 bool RequestsAreForSamePath(
     const NativeFileSystemPermissionRequestManager::RequestData& a,
     const NativeFileSystemPermissionRequestManager::RequestData& b) {
   return a.origin == b.origin && a.path == b.path &&
-         a.is_directory == b.is_directory;
+         a.handle_type == b.handle_type;
 }
 
 }  // namespace

chrome/browser/native_file_system/native_file_system_permission_request_manager.h

@@ -9,6 +9,7 @@
 #include "base/containers/circular_deque.h"
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
+#include "content/public/browser/native_file_system_permission_context.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "url/origin.h"
@@ -44,13 +45,14 @@ class NativeFileSystemPermissionRequestManager
   };
 
   struct RequestData {
-    RequestData(const url::Origin& origin,
-                const base::FilePath& path,
-                bool is_directory,
-                Access access)
+    RequestData(
+        const url::Origin& origin,
+        const base::FilePath& path,
+        content::NativeFileSystemPermissionContext::HandleType handle_type,
+        Access access)
         : origin(origin),
           path(path),
-          is_directory(is_directory),
+          handle_type(handle_type),
           access(access) {}
     RequestData(RequestData&&) = default;
     RequestData(const RequestData&) = default;
@@ -59,7 +61,7 @@ class NativeFileSystemPermissionRequestManager
 
     url::Origin origin;
     base::FilePath path;
-    bool is_directory;
+    content::NativeFileSystemPermissionContext::HandleType handle_type;
     Access access;
   };
 

chrome/browser/native_file_system/origin_scoped_native_file_system_permission_context.cc

@@ -33,17 +33,19 @@ constexpr base::TimeDelta kPermissionRevocationTimeout =
 
 class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     : public content::NativeFileSystemPermissionGrant {
+  using HandleType = NativeFileSystemPermissionContext::HandleType;
+
  public:
   PermissionGrantImpl(
       base::WeakPtr<OriginScopedNativeFileSystemPermissionContext> context,
       const url::Origin& origin,
       const base::FilePath& path,
-      bool is_directory,
+      HandleType handle_type,
       GrantType type)
       : context_(std::move(context)),
         origin_(origin),
         path_(path),
-        is_directory_(is_directory),
+        handle_type_(handle_type),
         type_(type) {}
 
   // NativeFileSystemPermissionGrant:
@@ -148,7 +150,7 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     // code does not have to have any way to request Access::kReadWrite.
 
     request_manager->AddRequest(
-        {origin_, path_, is_directory_, access},
+        {origin_, path_, handle_type_, access},
         base::BindOnce(&PermissionGrantImpl::OnPermissionRequestResult, this,
                        std::move(callback)),
         std::move(fullscreen_block));
@@ -159,9 +161,9 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     return origin_;
   }
 
-  bool is_directory() const {
+  HandleType handle_type() const {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-    return is_directory_;
+    return handle_type_;
   }
 
   const base::FilePath& path() const {
@@ -189,7 +191,7 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     for (const auto& entry : grants) {
       if (entry.second->GetStatus() != PermissionStatus::GRANTED)
         continue;
-      if (entry.second->is_directory()) {
+      if (entry.second->handle_type() == HandleType::kDirectory) {
         directory_grants->push_back(entry.second->path());
       } else {
         file_grants->push_back(entry.second->path());
@@ -238,7 +240,7 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     if (type_ == GrantType::kWrite) {
       base::UmaHistogramEnumeration(
           "NativeFileSystemAPI.WritePermissionRequestOutcome", outcome);
-      if (is_directory_) {
+      if (handle_type_ == HandleType::kDirectory) {
         base::UmaHistogramEnumeration(
             "NativeFileSystemAPI.WritePermissionRequestOutcome.Directory",
             outcome);
@@ -249,7 +251,7 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
     } else {
       base::UmaHistogramEnumeration(
           "NativeFileSystemAPI.ReadPermissionRequestOutcome", outcome);
-      if (is_directory_) {
+      if (handle_type_ == HandleType::kDirectory) {
         base::UmaHistogramEnumeration(
             "NativeFileSystemAPI.ReadPermissionRequestOutcome.Directory",
             outcome);
@@ -267,7 +269,7 @@ class OriginScopedNativeFileSystemPermissionContext::PermissionGrantImpl
   base::WeakPtr<OriginScopedNativeFileSystemPermissionContext> const context_;
   const url::Origin origin_;
   const base::FilePath path_;
-  const bool is_directory_;
+  const HandleType handle_type_;
   const GrantType type_;
 
   // This member should only be updated via SetStatus(), to make sure
@@ -302,7 +304,7 @@ scoped_refptr<content::NativeFileSystemPermissionGrant>
 OriginScopedNativeFileSystemPermissionContext::GetReadPermissionGrant(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     UserAction user_action) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // operator[] might insert a new OriginState in |origins_|, but that
@@ -313,7 +315,7 @@ OriginScopedNativeFileSystemPermissionContext::GetReadPermissionGrant(
   auto*& existing_grant = origin_state.read_grants[path];
   scoped_refptr<PermissionGrantImpl> new_grant;
 
-  if (existing_grant && existing_grant->is_directory() != is_directory) {
+  if (existing_grant && existing_grant->handle_type() != handle_type) {
     // |path| changed from being a directory to being a file or vice versa,
     // don't just re-use the existing grant but revoke the old grant before
     // creating a new grant.
@@ -323,7 +325,7 @@ OriginScopedNativeFileSystemPermissionContext::GetReadPermissionGrant(
 
   if (!existing_grant) {
     new_grant = base::MakeRefCounted<PermissionGrantImpl>(
-        weak_factory_.GetWeakPtr(), origin, path, is_directory,
+        weak_factory_.GetWeakPtr(), origin, path, handle_type,
         GrantType::kRead);
     existing_grant = new_grant.get();
   }
@@ -336,7 +338,8 @@ OriginScopedNativeFileSystemPermissionContext::GetReadPermissionGrant(
     case CONTENT_SETTING_ASK:
       // Files automatically get read access when picked by the user,
       // directories need to first be confirmed.
-      if (user_action != UserAction::kLoadFromStorage && !is_directory) {
+      if (user_action != UserAction::kLoadFromStorage &&
+          handle_type == HandleType::kFile) {
         existing_grant->SetStatus(PermissionStatus::GRANTED);
         ScheduleUsageIconUpdate();
       }
@@ -361,7 +364,7 @@ scoped_refptr<content::NativeFileSystemPermissionGrant>
 OriginScopedNativeFileSystemPermissionContext::GetWritePermissionGrant(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    HandleType handle_type,
     UserAction user_action) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // operator[] might insert a new OriginState in |origins_|, but that
@@ -372,7 +375,7 @@ OriginScopedNativeFileSystemPermissionContext::GetWritePermissionGrant(
   auto*& existing_grant = origin_state.write_grants[path];
   scoped_refptr<PermissionGrantImpl> new_grant;
 
-  if (existing_grant && existing_grant->is_directory() != is_directory) {
+  if (existing_grant && existing_grant->handle_type() != handle_type) {
     // |path| changed from being a directory to being a file or vice versa,
     // don't just re-use the existing grant but revoke the old grant before
     // creating a new grant.
@@ -382,7 +385,7 @@ OriginScopedNativeFileSystemPermissionContext::GetWritePermissionGrant(
 
   if (!existing_grant) {
     new_grant = base::MakeRefCounted<PermissionGrantImpl>(
-        weak_factory_.GetWeakPtr(), origin, path, is_directory,
+        weak_factory_.GetWeakPtr(), origin, path, handle_type,
         GrantType::kWrite);
     existing_grant = new_grant.get();
   }
@@ -422,7 +425,7 @@ void OriginScopedNativeFileSystemPermissionContext::ConfirmDirectoryReadAccess(
   // refactor the calling code of this method to just do what this
   // implementation does directly.
   scoped_refptr<content::NativeFileSystemPermissionGrant> grant =
-      GetReadPermissionGrant(origin, path, /*is_directory=*/true,
+      GetReadPermissionGrant(origin, path, HandleType::kDirectory,
                              UserAction::kOpen);
   static_cast<PermissionGrantImpl*>(grant.get())
       ->RequestPermissionImpl(

chrome/browser/native_file_system/origin_scoped_native_file_system_permission_context.h

@@ -28,12 +28,12 @@ class OriginScopedNativeFileSystemPermissionContext
   scoped_refptr<content::NativeFileSystemPermissionGrant>
   GetReadPermissionGrant(const url::Origin& origin,
                          const base::FilePath& path,
-                         bool is_directory,
+                         HandleType handle_type,
                          UserAction user_action) override;
   scoped_refptr<content::NativeFileSystemPermissionGrant>
   GetWritePermissionGrant(const url::Origin& origin,
                           const base::FilePath& path,
-                          bool is_directory,
+                          HandleType handle_type,
                           UserAction user_action) override;
   void ConfirmDirectoryReadAccess(
       const url::Origin& origin,

chrome/browser/ui/native_file_system_dialogs.cc

@@ -19,7 +19,7 @@ void ShowNativeFileSystemPermissionDialog(
 void ShowNativeFileSystemRestrictedDirectoryDialog(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     base::OnceCallback<void(
         content::NativeFileSystemPermissionContext::SensitiveDirectoryResult)>
         callback,

chrome/browser/ui/native_file_system_dialogs.h

@@ -44,7 +44,7 @@ void ShowNativeFileSystemPermissionDialog(
 void ShowNativeFileSystemRestrictedDirectoryDialog(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     base::OnceCallback<void(
         content::NativeFileSystemPermissionContext::SensitiveDirectoryResult)>
         callback,

chrome/browser/ui/views/native_file_system/native_file_system_permission_view.cc

@@ -13,6 +13,7 @@
 #include "components/constrained_window/constrained_window_views.h"
 #include "components/permissions/permission_util.h"
 #include "components/vector_icons/vector_icons.h"
+#include "content/public/browser/native_file_system_permission_context.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/strings/grit/ui_strings.h"
@@ -22,18 +23,19 @@
 
 namespace {
 using AccessType = NativeFileSystemPermissionRequestManager::Access;
+using HandleType = content::NativeFileSystemPermissionContext::HandleType;
 
 int GetMessageText(const NativeFileSystemPermissionView::Request& request) {
   switch (request.access) {
     case AccessType::kRead:
-      return request.is_directory
+      return request.handle_type == HandleType::kDirectory
                  ? IDS_NATIVE_FILE_SYSTEM_ORIGIN_SCOPED_READ_PERMISSION_DIRECTORY_TEXT
                  : IDS_NATIVE_FILE_SYSTEM_ORIGIN_SCOPED_READ_PERMISSION_FILE_TEXT;
     case AccessType::kWrite:
     case AccessType::kReadWrite:
       // Only difference between write and read-write access dialog is in button
       // label and dialog title.
-      return request.is_directory
+      return request.handle_type == HandleType::kDirectory
                  ? IDS_NATIVE_FILE_SYSTEM_ORIGIN_SCOPED_WRITE_PERMISSION_DIRECTORY_TEXT
                  : IDS_NATIVE_FILE_SYSTEM_ORIGIN_SCOPED_WRITE_PERMISSION_FILE_TEXT;
   }
@@ -43,13 +45,13 @@ int GetMessageText(const NativeFileSystemPermissionView::Request& request) {
 int GetButtonLabel(const NativeFileSystemPermissionView::Request& request) {
   switch (request.access) {
     case AccessType::kRead:
-      return request.is_directory
+      return request.handle_type == HandleType::kDirectory
                  ? IDS_NATIVE_FILE_SYSTEM_VIEW_DIRECTORY_PERMISSION_ALLOW_TEXT
                  : IDS_NATIVE_FILE_SYSTEM_VIEW_FILE_PERMISSION_ALLOW_TEXT;
     case AccessType::kWrite:
       return IDS_NATIVE_FILE_SYSTEM_WRITE_PERMISSION_ALLOW_TEXT;
     case AccessType::kReadWrite:
-      return request.is_directory
+      return request.handle_type == HandleType::kDirectory
                  ? IDS_NATIVE_FILE_SYSTEM_EDIT_DIRECTORY_PERMISSION_ALLOW_TEXT
                  : IDS_NATIVE_FILE_SYSTEM_EDIT_FILE_PERMISSION_ALLOW_TEXT;
   }
@@ -107,7 +109,7 @@ views::Widget* NativeFileSystemPermissionView::ShowDialog(
 base::string16 NativeFileSystemPermissionView::GetWindowTitle() const {
   switch (request_.access) {
     case AccessType::kRead:
-      if (request_.is_directory) {
+      if (request_.handle_type == HandleType::kDirectory) {
         return l10n_util::GetStringUTF16(
             IDS_NATIVE_FILE_SYSTEM_READ_DIRECTORY_PERMISSION_TITLE);
       } else {
@@ -120,7 +122,7 @@ base::string16 NativeFileSystemPermissionView::GetWindowTitle() const {
           IDS_NATIVE_FILE_SYSTEM_WRITE_PERMISSION_TITLE,
           request_.path.BaseName().LossyDisplayName());
     case AccessType::kReadWrite:
-      if (request_.is_directory) {
+      if (request_.handle_type == HandleType::kDirectory) {
         return l10n_util::GetStringUTF16(
             IDS_NATIVE_FILE_SYSTEM_EDIT_DIRECTORY_PERMISSION_TITLE);
       } else {

chrome/browser/ui/views/native_file_system/native_file_system_permission_view_browsertest.cc

@@ -13,20 +13,20 @@
 #include "ui/views/controls/button/label_button.h"
 
 using AccessType = NativeFileSystemPermissionRequestManager::Access;
+using HandleType = content::NativeFileSystemPermissionContext::HandleType;
 
 class NativeFileSystemPermissionViewTest : public DialogBrowserTest {
  public:
   // DialogBrowserTest:
   void ShowUi(const std::string& name) override {
     NativeFileSystemPermissionView::Request request(
-        kTestOrigin, base::FilePath(), /*is_directory=*/false,
-        AccessType::kWrite);
+        kTestOrigin, base::FilePath(), HandleType::kFile, AccessType::kWrite);
     if (name == "LongFileName") {
       request.path = base::FilePath(FILE_PATH_LITERAL(
           "/foo/bar/Some Really Really Really Really Long File Name.txt"));
     } else if (name == "Folder") {
       request.path = base::FilePath(FILE_PATH_LITERAL("/bar/MyProject"));
-      request.is_directory = true;
+      request.handle_type = HandleType::kDirectory;
     } else if (name == "LongOrigin") {
       request.path = base::FilePath(FILE_PATH_LITERAL("/foo/README.txt"));
       request.origin =
@@ -42,11 +42,11 @@ class NativeFileSystemPermissionViewTest : public DialogBrowserTest {
           "chrome-extension://ehoadneljpdggcbbknedodolkkjodefl/capture.html"));
     } else if (name == "FolderRead") {
       request.path = base::FilePath(FILE_PATH_LITERAL("/bar/MyProject"));
-      request.is_directory = true;
+      request.handle_type = HandleType::kDirectory;
       request.access = AccessType::kRead;
     } else if (name == "FolderReadWrite") {
       request.path = base::FilePath(FILE_PATH_LITERAL("/bar/MyProject"));
-      request.is_directory = true;
+      request.handle_type = HandleType::kDirectory;
       request.access = AccessType::kReadWrite;
     } else if (name == "FileRead") {
       request.path = base::FilePath(FILE_PATH_LITERAL("/foo/README.txt"));

chrome/browser/ui/views/native_file_system/native_file_system_restricted_directory_dialog_view.cc

@@ -16,6 +16,8 @@
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/fill_layout.h"
 
+using HandleType = content::NativeFileSystemPermissionContext::HandleType;
+
 NativeFileSystemRestrictedDirectoryDialogView::
     ~NativeFileSystemRestrictedDirectoryDialogView() {
   // Make sure the dialog ends up calling the callback no matter what.
@@ -27,12 +29,12 @@ NativeFileSystemRestrictedDirectoryDialogView::
 views::Widget* NativeFileSystemRestrictedDirectoryDialogView::ShowDialog(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     base::OnceCallback<void(SensitiveDirectoryResult)> callback,
     content::WebContents* web_contents) {
   auto delegate =
       base::WrapUnique(new NativeFileSystemRestrictedDirectoryDialogView(
-          origin, path, is_directory, std::move(callback)));
+          origin, path, handle_type, std::move(callback)));
   return constrained_window::ShowWebModalDialogViews(delegate.release(),
                                                      web_contents);
 }
@@ -40,8 +42,9 @@ views::Widget* NativeFileSystemRestrictedDirectoryDialogView::ShowDialog(
 base::string16 NativeFileSystemRestrictedDirectoryDialogView::GetWindowTitle()
     const {
   return l10n_util::GetStringUTF16(
-      is_directory_ ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_TITLE
-                    : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_TITLE);
+      handle_type_ == HandleType::kDirectory
+          ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_TITLE
+          : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_TITLE);
 }
 
 bool NativeFileSystemRestrictedDirectoryDialogView::ShouldShowCloseButton()
@@ -66,14 +69,14 @@ NativeFileSystemRestrictedDirectoryDialogView::
     NativeFileSystemRestrictedDirectoryDialogView(
         const url::Origin& origin,
         const base::FilePath& path,
-        bool is_directory,
+        content::NativeFileSystemPermissionContext::HandleType handle_type,
         base::OnceCallback<void(SensitiveDirectoryResult)> callback)
-    : is_directory_(is_directory), callback_(std::move(callback)) {
-  SetButtonLabel(
-      ui::DIALOG_BUTTON_OK,
-      l10n_util::GetStringUTF16(
-          is_directory_ ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_BUTTON
-                        : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_BUTTON));
+    : handle_type_(handle_type), callback_(std::move(callback)) {
+  SetButtonLabel(ui::DIALOG_BUTTON_OK,
+                 l10n_util::GetStringUTF16(
+                     handle_type_ == HandleType::kDirectory
+                         ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_BUTTON
+                         : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_BUTTON));
 
   auto run_callback = [](NativeFileSystemRestrictedDirectoryDialogView* dialog,
                          SensitiveDirectoryResult result) {
@@ -89,19 +92,20 @@ NativeFileSystemRestrictedDirectoryDialogView::
       views::TEXT, views::TEXT));
 
   AddChildView(native_file_system_ui_helper::CreateOriginLabel(
-      is_directory_ ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_TEXT
-                    : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_TEXT,
+      handle_type_ == HandleType::kDirectory
+          ? IDS_NATIVE_FILE_SYSTEM_RESTRICTED_DIRECTORY_TEXT
+          : IDS_NATIVE_FILE_SYSTEM_RESTRICTED_FILE_TEXT,
       origin, CONTEXT_BODY_TEXT_LARGE, /*show_emphasis=*/true));
 }
 
 void ShowNativeFileSystemRestrictedDirectoryDialog(
     const url::Origin& origin,
     const base::FilePath& path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     base::OnceCallback<void(
         content::NativeFileSystemPermissionContext::SensitiveDirectoryResult)>
         callback,
     content::WebContents* web_contents) {
   NativeFileSystemRestrictedDirectoryDialogView::ShowDialog(
-      origin, path, is_directory, std::move(callback), web_contents);
+      origin, path, handle_type, std::move(callback), web_contents);
 }

chrome/browser/ui/views/native_file_system/native_file_system_restricted_directory_dialog_view.h

@@ -41,7 +41,7 @@ class NativeFileSystemRestrictedDirectoryDialogView
   static views::Widget* ShowDialog(
       const url::Origin& origin,
       const base::FilePath& path,
-      bool is_directory,
+      content::NativeFileSystemPermissionContext::HandleType handle_type,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback,
       content::WebContents* web_contents);
 
@@ -55,10 +55,10 @@ class NativeFileSystemRestrictedDirectoryDialogView
   NativeFileSystemRestrictedDirectoryDialogView(
       const url::Origin& origin,
       const base::FilePath& path,
-      bool is_directory,
+      content::NativeFileSystemPermissionContext::HandleType handle_type,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback);
 
-  const bool is_directory_;
+  const content::NativeFileSystemPermissionContext::HandleType handle_type_;
   base::OnceCallback<void(SensitiveDirectoryResult)> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeFileSystemRestrictedDirectoryDialogView);

chrome/browser/ui/views/native_file_system/native_file_system_restricted_directory_dialog_view_browsertest.cc

@@ -22,7 +22,7 @@ class NativeFileSystemRestrictedDirectoryDialogViewTest
   void ShowUi(const std::string& name) override {
     widget_ = NativeFileSystemRestrictedDirectoryDialogView::ShowDialog(
         kTestOrigin, base::FilePath(FILE_PATH_LITERAL("/foo/bar")),
-        /*is_directory=*/true,
+        content::NativeFileSystemPermissionContext::HandleType::kDirectory,
         base::BindLambdaForTesting([&](SensitiveDirectoryResult result) {
           callback_called_ = true;
           callback_result_ = result;

content/browser/native_file_system/mock_native_file_system_permission_context.cc

@@ -22,10 +22,10 @@ void MockNativeFileSystemPermissionContext::ConfirmDirectoryReadAccess(
 void MockNativeFileSystemPermissionContext::ConfirmSensitiveDirectoryAccess(
     const url::Origin& origin,
     const std::vector<base::FilePath>& paths,
-    bool is_directory,
+    HandleType handle_type,
     GlobalFrameRoutingId frame_id,
     base::OnceCallback<void(SensitiveDirectoryResult)> callback) {
-  ConfirmSensitiveDirectoryAccess_(origin, paths, is_directory, frame_id,
+  ConfirmSensitiveDirectoryAccess_(origin, paths, handle_type, frame_id,
                                    callback);
 }
 

content/browser/native_file_system/mock_native_file_system_permission_context.h

@@ -20,7 +20,7 @@ class MockNativeFileSystemPermissionContext
                scoped_refptr<NativeFileSystemPermissionGrant>(
                    const url::Origin& origin,
                    const base::FilePath& path,
-                   bool is_directory,
+                   HandleType handle_type,
 
                    NativeFileSystemPermissionContext::UserAction user_action));
 
@@ -28,7 +28,7 @@ class MockNativeFileSystemPermissionContext
                scoped_refptr<NativeFileSystemPermissionGrant>(
                    const url::Origin& origin,
                    const base::FilePath& path,
-                   bool is_directory,
+                   HandleType handle_type,
 
                    NativeFileSystemPermissionContext::UserAction user_action));
 
@@ -46,14 +46,14 @@ class MockNativeFileSystemPermissionContext
   void ConfirmSensitiveDirectoryAccess(
       const url::Origin& origin,
       const std::vector<base::FilePath>& paths,
-      bool is_directory,
+      HandleType handle_type,
       GlobalFrameRoutingId frame_id,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback) override;
   MOCK_METHOD5(
       ConfirmSensitiveDirectoryAccess_,
       void(const url::Origin& origin,
            const std::vector<base::FilePath>& paths,
-           bool is_directory,
+           HandleType handle_type,
            GlobalFrameRoutingId frame_id,
            base::OnceCallback<void(SensitiveDirectoryResult)>& callback));
 

content/browser/native_file_system/native_file_system_directory_handle_impl.cc

@@ -28,6 +28,8 @@ using storage::FileSystemOperationRunner;
 
 namespace content {
 
+using HandleType = NativeFileSystemPermissionContext::HandleType;
+
 namespace {
 
 // Returns true when |name| contains a path separator like "/".
@@ -54,11 +56,7 @@ NativeFileSystemDirectoryHandleImpl::NativeFileSystemDirectoryHandleImpl(
     const BindingContext& context,
     const storage::FileSystemURL& url,
     const SharedHandleState& handle_state)
-    : NativeFileSystemHandleBase(manager,
-                                 context,
-                                 url,
-                                 handle_state,
-                                 /*is_directory=*/true) {}
+    : NativeFileSystemHandleBase(manager, context, url, handle_state) {}
 
 NativeFileSystemDirectoryHandleImpl::~NativeFileSystemDirectoryHandleImpl() =
     default;
@@ -255,8 +253,7 @@ void NativeFileSystemDirectoryHandleImpl::ResolveImpl(
   if (parent_path == child_path) {
     std::move(callback).Run(
         native_file_system_error::Ok(),
-        possible_child->type() ==
-                NativeFileSystemTransferTokenImpl::HandleType::kDirectory
+        possible_child->type() == HandleType::kDirectory
             ? base::make_optional(std::vector<std::string>())
             : base::nullopt);
     return;
@@ -393,7 +390,9 @@ void NativeFileSystemDirectoryHandleImpl::DidReadDirectory(
 
     entries.push_back(
         CreateEntry(basename, child_url,
-                    entry.type == filesystem::mojom::FsFileType::DIRECTORY));
+                    entry.type == filesystem::mojom::FsFileType::DIRECTORY
+                        ? HandleType::kDirectory
+                        : HandleType::kFile));
   }
   (*listener)->DidReadDirectory(native_file_system_error::Ok(),
                                 std::move(entries), has_more_entries);
@@ -455,8 +454,8 @@ NativeFileSystemDirectoryHandleImpl::GetChildURL(
 NativeFileSystemEntryPtr NativeFileSystemDirectoryHandleImpl::CreateEntry(
     const std::string& basename,
     const storage::FileSystemURL& url,
-    bool is_directory) {
-  if (is_directory) {
+    HandleType handle_type) {
+  if (handle_type == HandleType::kDirectory) {
     return NativeFileSystemEntry::New(
         NativeFileSystemHandle::NewDirectory(
             manager()->CreateDirectoryHandle(context(), url, handle_state())),

content/browser/native_file_system/native_file_system_directory_handle_impl.h

@@ -97,7 +97,7 @@ class CONTENT_EXPORT NativeFileSystemDirectoryHandleImpl
   blink::mojom::NativeFileSystemEntryPtr CreateEntry(
       const std::string& basename,
       const storage::FileSystemURL& url,
-      bool is_directory);
+      NativeFileSystemPermissionContext::HandleType handle_type);
 
   base::WeakPtr<NativeFileSystemHandleBase> AsWeakPtr() override;
 

content/browser/native_file_system/native_file_system_file_handle_impl.cc

@@ -36,11 +36,7 @@ NativeFileSystemFileHandleImpl::NativeFileSystemFileHandleImpl(
     const BindingContext& context,
     const storage::FileSystemURL& url,
     const SharedHandleState& handle_state)
-    : NativeFileSystemHandleBase(manager,
-                                 context,
-                                 url,
-                                 handle_state,
-                                 /*is_directory=*/false) {}
+    : NativeFileSystemHandleBase(manager, context, url, handle_state) {}
 
 NativeFileSystemFileHandleImpl::~NativeFileSystemFileHandleImpl() = default;
 
@@ -116,7 +112,7 @@ void NativeFileSystemFileHandleImpl::IsSameEntryImpl(
     return;
   }
 
-  if (other->type() != NativeFileSystemTransferTokenImpl::HandleType::kFile) {
+  if (other->type() != NativeFileSystemPermissionContext::HandleType::kFile) {
     std::move(callback).Run(native_file_system_error::Ok(), false);
     return;
   }

content/browser/native_file_system/native_file_system_file_writer_impl.cc

@@ -89,11 +89,7 @@ NativeFileSystemFileWriterImpl::NativeFileSystemFileWriterImpl(
     const storage::FileSystemURL& swap_url,
     const SharedHandleState& handle_state,
     bool has_transient_user_activation)
-    : NativeFileSystemHandleBase(manager,
-                                 context,
-                                 url,
-                                 handle_state,
-                                 /*is_directory=*/false),
+    : NativeFileSystemHandleBase(manager, context, url, handle_state),
       swap_url_(swap_url),
       has_transient_user_activation_(has_transient_user_activation) {
   DCHECK_EQ(swap_url.type(), url.type());

content/browser/native_file_system/native_file_system_handle_base.cc

@@ -17,8 +17,7 @@ NativeFileSystemHandleBase::NativeFileSystemHandleBase(
     NativeFileSystemManagerImpl* manager,
     const BindingContext& context,
     const storage::FileSystemURL& url,
-    const SharedHandleState& handle_state,
-    bool is_directory)
+    const SharedHandleState& handle_state)
     : manager_(manager),
       context_(context),
       url_(url),

content/browser/native_file_system/native_file_system_handle_base.h

@@ -44,8 +44,7 @@ class CONTENT_EXPORT NativeFileSystemHandleBase : public WebContentsObserver {
   NativeFileSystemHandleBase(NativeFileSystemManagerImpl* manager,
                              const BindingContext& context,
                              const storage::FileSystemURL& url,
-                             const SharedHandleState& handle_state,
-                             bool is_directory);
+                             const SharedHandleState& handle_state);
   ~NativeFileSystemHandleBase() override;
 
   const storage::FileSystemURL& url() const { return url_; }

content/browser/native_file_system/native_file_system_handle_base_unittest.cc

@@ -28,11 +28,7 @@ class TestNativeFileSystemHandle : public NativeFileSystemHandleBase {
                              const BindingContext& context,
                              const storage::FileSystemURL& url,
                              const SharedHandleState& handle_state)
-      : NativeFileSystemHandleBase(manager,
-                                   context,
-                                   url,
-                                   handle_state,
-                                   /*is_directory=*/false) {}
+      : NativeFileSystemHandleBase(manager, context, url, handle_state) {}
 
  private:
   base::WeakPtr<NativeFileSystemHandleBase> AsWeakPtr() override {

content/browser/native_file_system/native_file_system_manager_impl.cc

@@ -44,6 +44,7 @@ using PermissionStatus = NativeFileSystemPermissionGrant::PermissionStatus;
 using SensitiveDirectoryResult =
     NativeFileSystemPermissionContext::SensitiveDirectoryResult;
 using storage::FileSystemContext;
+using HandleType = NativeFileSystemPermissionContext::HandleType;
 
 namespace {
 
@@ -96,11 +97,10 @@ bool CreateOrTruncateFile(const base::FilePath& path) {
   return file.IsValid();
 }
 
-bool IsValidTransferToken(
-    NativeFileSystemTransferTokenImpl* token,
-    const url::Origin& expected_origin,
-    int process_id,
-    NativeFileSystemTransferTokenImpl::HandleType expected_handle_type) {
+bool IsValidTransferToken(NativeFileSystemTransferTokenImpl* token,
+                          const url::Origin& expected_origin,
+                          int process_id,
+                          HandleType expected_handle_type) {
   if (!token) {
     return false;
   }
@@ -322,11 +322,9 @@ void NativeFileSystemManagerImpl::DidResolveForSerializeHandle(
   const storage::FileSystemURL& url = *resolved_token->GetAsFileSystemURL();
 
   NativeFileSystemHandleData data;
-  data.set_handle_type(
-      resolved_token->type() ==
-              NativeFileSystemTransferTokenImpl::HandleType::kFile
-          ? NativeFileSystemHandleData::kFile
-          : NativeFileSystemHandleData::kDirectory);
+  data.set_handle_type(resolved_token->type() == HandleType::kFile
+                           ? NativeFileSystemHandleData::kFile
+                           : NativeFileSystemHandleData::kDirectory);
 
   switch (url.type()) {
     case storage::kFileSystemTypeNativeLocal: {
@@ -401,7 +399,9 @@ void NativeFileSystemManagerImpl::DeserializeHandle(
               PermissionStatus::GRANTED);
       CreateTransferTokenImpl(
           url, SharedHandleState(permission_grant, permission_grant, {}),
-          data.handle_type() == NativeFileSystemHandleData::kDirectory,
+          data.handle_type() == NativeFileSystemHandleData::kDirectory
+              ? HandleType::kDirectory
+              : HandleType::kFile,
           std::move(token));
       break;
     }
@@ -418,13 +418,20 @@ void NativeFileSystemManagerImpl::DeserializeHandle(
       const bool is_directory =
           data.handle_type() == NativeFileSystemHandleData::kDirectory;
 
+      // Permissions are scoped to |root_path|, rather than the individual
+      // handle. So if |relative_path| is not empty, this creates a
+      // SharedHandleState for a directory even if the handle represents a
+      // file.
       SharedHandleState handle_state = GetSharedHandleStateForPath(
           root_path, origin, std::move(root.file_system),
-          is_directory || !relative_path.empty(),
+          (is_directory || !relative_path.empty()) ? HandleType::kDirectory
+                                                   : HandleType::kFile,
           NativeFileSystemPermissionContext::UserAction::kLoadFromStorage);
 
-      CreateTransferTokenImpl(child, handle_state, is_directory,
-                              std::move(token));
+      CreateTransferTokenImpl(
+          child, handle_state,
+          is_directory ? HandleType::kDirectory : HandleType::kFile,
+          std::move(token));
       break;
     }
     case NativeFileSystemHandleData::DATA_NOT_SET:
@@ -450,7 +457,7 @@ NativeFileSystemManagerImpl::CreateDirectoryEntryFromPath(
 
   SharedHandleState shared_handle_state = GetSharedHandleStateForPath(
       file_path, binding_context.origin, std::move(url.file_system),
-      /*is_directory=*/true,
+      HandleType::kDirectory,
       NativeFileSystemPermissionContext::UserAction::kOpen);
 
   return blink::mojom::NativeFileSystemEntry::New(
@@ -526,12 +533,12 @@ NativeFileSystemManagerImpl::CreateFileWriter(
 
 void NativeFileSystemManagerImpl::CreateTransferTokenFromPath(
     const base::FilePath& file_path,
-    bool is_directory,
+    content::NativeFileSystemPermissionContext::HandleType handle_type,
     int renderer_id,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
   auto token_impl = NativeFileSystemTransferTokenImpl::CreateFromPath(
-      file_path, is_directory, this, std::move(receiver), renderer_id);
+      file_path, handle_type, this, std::move(receiver), renderer_id);
   auto token = token_impl->token();
   transfer_tokens_.emplace(token, std::move(token_impl));
 }
@@ -541,16 +548,16 @@ void NativeFileSystemManagerImpl::CreateTransferToken(
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
   return CreateTransferTokenImpl(file.url(), file.handle_state(),
-                                 /*is_directory=*/false, std::move(receiver));
+                                 HandleType::kFile, std::move(receiver));
 }
 
 void NativeFileSystemManagerImpl::CreateTransferTokenForTesting(
     const storage::FileSystemURL& url,
     const SharedHandleState& handle_state,
-    bool is_directory,
+    HandleType handle_type,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
-  return CreateTransferTokenImpl(url, handle_state, is_directory,
+  return CreateTransferTokenImpl(url, handle_state, handle_type,
                                  std::move(receiver));
 }
 
@@ -559,7 +566,7 @@ void NativeFileSystemManagerImpl::CreateTransferToken(
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
   return CreateTransferTokenImpl(directory.url(), directory.handle_state(),
-                                 /*is_directory=*/true, std::move(receiver));
+                                 HandleType::kDirectory, std::move(receiver));
 }
 
 void NativeFileSystemManagerImpl::ResolveTransferToken(
@@ -584,9 +591,8 @@ void NativeFileSystemManagerImpl::DidResolveTransferTokenForFileHandle(
     NativeFileSystemTransferTokenImpl* resolved_token) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  if (!IsValidTransferToken(
-          resolved_token, binding_context.origin, binding_context.process_id(),
-          NativeFileSystemTransferTokenImpl::HandleType::kFile)) {
+  if (!IsValidTransferToken(resolved_token, binding_context.origin,
+                            binding_context.process_id(), HandleType::kFile)) {
     // Fail silently. In practice, the NativeFileSystemManager should not
     // receive any invalid tokens. Before redeeming a token, the render process
     // performs an origin check to ensure the token is valid. Invalid tokens
@@ -610,9 +616,9 @@ void NativeFileSystemManagerImpl::DidResolveTransferTokenForDirectoryHandle(
     NativeFileSystemTransferTokenImpl* resolved_token) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  if (!IsValidTransferToken(
-          resolved_token, binding_context.origin, binding_context.process_id(),
-          NativeFileSystemTransferTokenImpl::HandleType::kDirectory)) {
+  if (!IsValidTransferToken(resolved_token, binding_context.origin,
+                            binding_context.process_id(),
+                            HandleType::kDirectory)) {
     // Fail silently. See comment above in
     // DidResolveTransferTokenForFileHandle() for details.
     return;
@@ -685,7 +691,8 @@ void NativeFileSystemManagerImpl::DidChooseEntries(
   const bool is_directory =
       options.type() == blink::mojom::ChooseFileSystemEntryType::kOpenDirectory;
   permission_context_->ConfirmSensitiveDirectoryAccess(
-      binding_context.origin, entries_copy, is_directory,
+      binding_context.origin, entries_copy,
+      is_directory ? HandleType::kDirectory : HandleType::kFile,
       binding_context.frame_id,
       base::BindOnce(
           &NativeFileSystemManagerImpl::DidVerifySensitiveDirectoryAccess,
@@ -801,13 +808,13 @@ void NativeFileSystemManagerImpl::DidChooseDirectory(
 void NativeFileSystemManagerImpl::CreateTransferTokenImpl(
     const storage::FileSystemURL& url,
     const SharedHandleState& handle_state,
-    bool is_directory,
+    HandleType handle_type,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto token_impl = NativeFileSystemTransferTokenImpl::Create(
-      url, handle_state, is_directory, this, std::move(receiver));
+      url, handle_state, handle_type, this, std::move(receiver));
   auto token = token_impl->token();
   transfer_tokens_.emplace(token, std::move(token_impl));
 }
@@ -883,7 +890,7 @@ NativeFileSystemManagerImpl::CreateFileEntryFromPathImpl(
 
   SharedHandleState shared_handle_state = GetSharedHandleStateForPath(
       file_path, binding_context.origin, std::move(url.file_system),
-      /*is_directory=*/false, user_action);
+      HandleType::kFile, user_action);
 
   return blink::mojom::NativeFileSystemEntry::New(
       blink::mojom::NativeFileSystemHandle::NewFile(
@@ -896,14 +903,14 @@ NativeFileSystemManagerImpl::GetSharedHandleStateForPath(
     const base::FilePath& path,
     const url::Origin& origin,
     storage::IsolatedContext::ScopedFSHandle file_system,
-    bool is_directory,
+    HandleType handle_type,
     NativeFileSystemPermissionContext::UserAction user_action) {
   scoped_refptr<NativeFileSystemPermissionGrant> read_grant, write_grant;
   if (permission_context_) {
     read_grant = permission_context_->GetReadPermissionGrant(
-        origin, path, is_directory, user_action);
+        origin, path, handle_type, user_action);
     write_grant = permission_context_->GetWritePermissionGrant(
-        origin, path, is_directory, user_action);
+        origin, path, handle_type, user_action);
   } else {
     // Auto-deny all write grants if no permisson context is available, unless
     // Experimental Web Platform features are enabled.

content/browser/native_file_system/native_file_system_manager_impl.h

@@ -15,6 +15,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_file_system_entry_factory.h"
 #include "content/public/browser/native_file_system_permission_context.h"
+#include "content/public/browser/native_file_system_permission_grant.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver_set.h"
@@ -171,7 +172,7 @@ class CONTENT_EXPORT NativeFileSystemManagerImpl
   // and drop operations.
   void CreateTransferTokenFromPath(
       const base::FilePath& file_path,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       int renderer_id,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver);
@@ -180,7 +181,7 @@ class CONTENT_EXPORT NativeFileSystemManagerImpl
   void CreateTransferTokenForTesting(
       const storage::FileSystemURL& url,
       const SharedHandleState& handle_state,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver);
 
@@ -220,7 +221,7 @@ class CONTENT_EXPORT NativeFileSystemManagerImpl
       const base::FilePath& path,
       const url::Origin& origin,
       storage::IsolatedContext::ScopedFSHandle file_system,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       NativeFileSystemPermissionContext::UserAction user_action);
 
   // Creates a FileSystemURL which corresponds to a FilePath and Origin.
@@ -267,7 +268,7 @@ class CONTENT_EXPORT NativeFileSystemManagerImpl
   void CreateTransferTokenImpl(
       const storage::FileSystemURL& url,
       const SharedHandleState& handle_state,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver);
   void DoResolveTransferToken(

content/browser/native_file_system/native_file_system_transfer_token_impl.cc

@@ -9,6 +9,7 @@
 #include "third_party/blink/public/mojom/native_file_system/native_file_system_directory_handle.mojom.h"
 
 namespace content {
+using HandleType = NativeFileSystemPermissionContext::HandleType;
 
 namespace {
 
@@ -24,11 +25,13 @@ class NativeFileSystemTransferTokenImplForHandles
   NativeFileSystemTransferTokenImplForHandles(
       const storage::FileSystemURL& url,
       const NativeFileSystemManagerImpl::SharedHandleState& handle_state,
-      HandleType type,
+      HandleType handle_type,
       NativeFileSystemManagerImpl* manager,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver)
-      : NativeFileSystemTransferTokenImpl(type, manager, std::move(receiver)),
+      : NativeFileSystemTransferTokenImpl(handle_type,
+                                          manager,
+                                          std::move(receiver)),
         url_(url),
         handle_state_(handle_state) {
     DCHECK_EQ(url_.mount_type() == storage::kFileSystemTypeIsolated,
@@ -57,7 +60,7 @@ class NativeFileSystemTransferTokenImplForHandles
   std::unique_ptr<NativeFileSystemFileHandleImpl> CreateFileHandle(
       const NativeFileSystemManagerImpl::BindingContext& binding_context)
       override {
-    DCHECK_EQ(type_, HandleType::kFile);
+    DCHECK_EQ(handle_type_, HandleType::kFile);
     return std::make_unique<NativeFileSystemFileHandleImpl>(
         manager_, binding_context, url_, handle_state_);
   }
@@ -65,7 +68,7 @@ class NativeFileSystemTransferTokenImplForHandles
   std::unique_ptr<NativeFileSystemDirectoryHandleImpl> CreateDirectoryHandle(
       const NativeFileSystemManagerImpl::BindingContext& binding_context)
       override {
-    DCHECK_EQ(type_, HandleType::kDirectory);
+    DCHECK_EQ(handle_type_, HandleType::kDirectory);
     return std::make_unique<NativeFileSystemDirectoryHandleImpl>(
         manager_, binding_context, url_, handle_state_);
   }
@@ -116,14 +119,14 @@ class NativeFileSystemTransferTokenFromPath
   std::unique_ptr<NativeFileSystemFileHandleImpl> CreateFileHandle(
       const NativeFileSystemManagerImpl::BindingContext& binding_context)
       override {
-    DCHECK_EQ(type_, HandleType::kFile);
+    DCHECK_EQ(handle_type_, HandleType::kFile);
     NativeFileSystemManagerImpl::FileSystemURLAndFSHandle url =
         manager_->CreateFileSystemURLFromPath(binding_context.origin,
                                               file_path_);
     NativeFileSystemManagerImpl::SharedHandleState shared_handle_state =
         manager_->GetSharedHandleStateForPath(
             file_path_, binding_context.origin, std::move(url.file_system),
-            /*is_directory=*/false,
+            HandleType::kFile,
             NativeFileSystemPermissionContext::UserAction::kOpen);
     return std::make_unique<NativeFileSystemFileHandleImpl>(
         manager_, binding_context, url.url, shared_handle_state);
@@ -132,14 +135,14 @@ class NativeFileSystemTransferTokenFromPath
   std::unique_ptr<NativeFileSystemDirectoryHandleImpl> CreateDirectoryHandle(
       const NativeFileSystemManagerImpl::BindingContext& binding_context)
       override {
-    DCHECK_EQ(type_, HandleType::kDirectory);
+    DCHECK_EQ(handle_type_, HandleType::kDirectory);
     NativeFileSystemManagerImpl::FileSystemURLAndFSHandle url =
         manager_->CreateFileSystemURLFromPath(binding_context.origin,
                                               file_path_);
     NativeFileSystemManagerImpl::SharedHandleState shared_handle_state =
         manager_->GetSharedHandleStateForPath(
             file_path_, binding_context.origin, url.file_system,
-            /*is_directory=*/true,
+            HandleType::kDirectory,
             NativeFileSystemPermissionContext::UserAction::kOpen);
     return std::make_unique<NativeFileSystemDirectoryHandleImpl>(
         manager_, binding_context, url.url, shared_handle_state);
@@ -156,34 +159,34 @@ std::unique_ptr<NativeFileSystemTransferTokenImpl>
 NativeFileSystemTransferTokenImpl::Create(
     const storage::FileSystemURL& url,
     const NativeFileSystemManagerImpl::SharedHandleState& handle_state,
-    bool is_directory,
+    HandleType handle_type,
     NativeFileSystemManagerImpl* manager,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
         receiver) {
   return std::make_unique<NativeFileSystemTransferTokenImplForHandles>(
-      url, handle_state,
-      is_directory ? HandleType::kDirectory : HandleType::kFile, manager,
-      std::move(receiver));
+      url, handle_state, handle_type, manager, std::move(receiver));
 }
 
 // static
 std::unique_ptr<NativeFileSystemTransferTokenImpl>
 NativeFileSystemTransferTokenImpl::CreateFromPath(
     const base::FilePath file_path,
-    bool is_directory,
+    HandleType handle_type,
     NativeFileSystemManagerImpl* manager,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken> receiver,
     int renderer_process_id) {
   return std::make_unique<NativeFileSystemTransferTokenFromPath>(
-      file_path, is_directory ? HandleType::kDirectory : HandleType::kFile,
-      manager, std::move(receiver), renderer_process_id);
+      file_path, handle_type, manager, std::move(receiver),
+      renderer_process_id);
 }
 
 NativeFileSystemTransferTokenImpl::NativeFileSystemTransferTokenImpl(
-    HandleType type,
+    HandleType handle_type,
     NativeFileSystemManagerImpl* manager,
     mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken> receiver)
-    : token_(base::UnguessableToken::Create()), type_(type), manager_(manager) {
+    : token_(base::UnguessableToken::Create()),
+      handle_type_(handle_type),
+      manager_(manager) {
   DCHECK(manager_);
 
   receivers_.set_disconnect_handler(

content/browser/native_file_system/native_file_system_transfer_token_impl.h

@@ -22,8 +22,6 @@ namespace content {
 class CONTENT_EXPORT NativeFileSystemTransferTokenImpl
     : public blink::mojom::NativeFileSystemTransferToken {
  public:
-  enum class HandleType { kFile, kDirectory };
-
   // Create a token that is tied to a particular origin (the origin of |url|,
   // and uses the permission grants in |handle_state| when creating new handles
   // out of the token. This is used for postMessage and IndexedDB serialization,
@@ -31,7 +29,7 @@ class CONTENT_EXPORT NativeFileSystemTransferTokenImpl
   static std::unique_ptr<NativeFileSystemTransferTokenImpl> Create(
       const storage::FileSystemURL& url,
       const NativeFileSystemManagerImpl::SharedHandleState& handle_state,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       NativeFileSystemManagerImpl* manager,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver);
@@ -39,21 +37,23 @@ class CONTENT_EXPORT NativeFileSystemTransferTokenImpl
   // Create a token that is not associated with any origin.
   static std::unique_ptr<NativeFileSystemTransferTokenImpl> CreateFromPath(
       const base::FilePath file_path,
-      bool is_directory,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       NativeFileSystemManagerImpl* manager,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver,
       int renderer_process_id);
 
   NativeFileSystemTransferTokenImpl(
-      HandleType type,
+      NativeFileSystemPermissionContext::HandleType handle_type,
       NativeFileSystemManagerImpl* manager,
       mojo::PendingReceiver<blink::mojom::NativeFileSystemTransferToken>
           receiver);
   ~NativeFileSystemTransferTokenImpl() override;
 
   const base::UnguessableToken& token() const { return token_; }
-  HandleType type() const { return type_; }
+  NativeFileSystemPermissionContext::HandleType type() const {
+    return handle_type_;
+  }
 
   // Returns true if |origin| is allowed to use this token. Where the transfer
   // token isn't associated with an origin, |process_id| is checked.
@@ -81,7 +81,7 @@ class CONTENT_EXPORT NativeFileSystemTransferTokenImpl
 
  protected:
   const base::UnguessableToken token_;
-  const HandleType type_;
+  const NativeFileSystemPermissionContext::HandleType handle_type_;
   // Raw pointer since NativeFileSystemManagerImpl owns |this|.
   NativeFileSystemManagerImpl* const manager_;
 

content/public/browser/native_file_system_permission_context.h

@@ -37,11 +37,15 @@ class NativeFileSystemPermissionContext {
     kLoadFromStorage,
   };
 
+  // This enum helps distinguish between file or directory Native File System
+  // handles.
+  enum class HandleType { kFile, kDirectory };
+
   // Returns the read permission grant to use for a particular path.
   virtual scoped_refptr<NativeFileSystemPermissionGrant> GetReadPermissionGrant(
       const url::Origin& origin,
       const base::FilePath& path,
-      bool is_directory,
+      HandleType handle_type,
       UserAction user_action) = 0;
 
   // Returns the permission grant to use for a particular path. This could be a
@@ -52,7 +56,7 @@ class NativeFileSystemPermissionContext {
   virtual scoped_refptr<NativeFileSystemPermissionGrant>
   GetWritePermissionGrant(const url::Origin& origin,
                           const base::FilePath& path,
-                          bool is_directory,
+                          HandleType handle_type,
                           UserAction user_action) = 0;
 
   // Displays a dialog to confirm that the user intended to give read access to
@@ -80,7 +84,7 @@ class NativeFileSystemPermissionContext {
   virtual void ConfirmSensitiveDirectoryAccess(
       const url::Origin& origin,
       const std::vector<base::FilePath>& paths,
-      bool is_directory,
+      HandleType handle_type,
       GlobalFrameRoutingId frame_id,
       base::OnceCallback<void(SensitiveDirectoryResult)> callback) = 0;