chrome_file_system_access_permission_context_unittest.cc

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/file_system_access/chrome_file_system_access_permission_context.h"

#include <memory>
#include <string>

#include "base/base_paths.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/json/values_util.h"
#include "base/strings/strcat.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_path_override.h"
#include "base/test/simple_test_clock.h"
#include "base/test/test_file_util.h"
#include "base/test/test_future.h"
#include "base/test/values_test_util.h"
#include "base/time/time.h"
#include "base/win/windows_version.h"
#include "build/build_config.h"
#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
#include "chrome/browser/download/chrome_download_manager_delegate.h"
#include "chrome/browser/download/download_core_service.h"
#include "chrome/browser/download/download_core_service_factory.h"
#include "chrome/browser/download/download_prefs.h"
#include "chrome/browser/file_system_access/file_system_access_permission_request_manager.h"
#include "chrome/browser/permissions/permission_decision_auto_blocker_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/test/base/testing_profile.h"
#include "components/content_settings/core/browser/host_content_settings_map.h"
#include "components/content_settings/core/common/pref_names.h"
#include "components/enterprise/buildflags/buildflags.h"
#include "components/permissions/features.h"
#include "components/permissions/permission_decision_auto_blocker.h"
#include "components/permissions/permission_uma_util.h"
#include "components/permissions/permission_util.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/browser_task_environment.h"
#include "content/public/test/test_renderer_host.h"
#include "content/public/test/web_contents_tester.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "ui/shell_dialogs/select_file_dialog.h"
#include "ui/webui/webui_allowlist.h"
#include "url/gurl.h"
#include "url/origin.h"

#if !BUILDFLAG(IS_ANDROID)
#include "chrome/browser/permissions/one_time_permissions_tracker_observer.h"
#include "chrome/browser/web_applications/test/fake_web_app_provider.h"
#include "chrome/browser/web_applications/test/os_integration_test_override_impl.h"
#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
#include "chrome/browser/web_applications/test/web_app_test_utils.h"
#include "chrome/browser/web_applications/web_app_install_info.h"
#endif

#if BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)
#include "chrome/browser/enterprise/connectors/analysis/content_analysis_delegate.h"
#include "chrome/browser/enterprise/connectors/test/deep_scanning_test_utils.h"
#include "chrome/browser/enterprise/connectors/test/fake_content_analysis_delegate.h"
#include "chrome/browser/policy/dm_token_utils.h"
#endif

BrowserContext;
WebContents;
WebContentsTester;
PermissionAction;
PersistedGrantStatus;
GrantType;
HandleType;
PathType;
PersistedGrantType;
UserAction;
PermissionRequestOutcome;
PermissionStatus;
RestorePermissionPromptOutcome;
SensitiveDirectoryResult;
UserActivationState;
PathInfo;

#if BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)
ContentAnalysisDelegate;
FakeContentAnalysisDelegate;
ContentAnalysisResponse;
#endif

#if BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)
namespace {

enum class CreateSymbolicLinkResult { … };

// Observes `grant`'s permission status and destroys itself when it changes.
class SelfDestructingPermissionGrantObserver
    : content::FileSystemAccessPermissionGrant::Observer { … };

constexpr char kDummyDmToken[] = …;

void EnableEnterpriseAnalysis(Profile* profile) { … }

bool CreateNonEmptyFile(const base::FilePath& path) { … }

#if BUILDFLAG(IS_WIN)
CreateSymbolicLinkResult CreateWinSymbolicLink(const base::FilePath& target,
                                               const base::FilePath& symlink,
                                               bool is_directory) {
  // Creating symbolic links on Windows requires Administrator privileges.
  // However, recent versions of Windows introduced the
  // SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE flag, which allows the
  // creation of symbolic links by processes with lower privileges, provided
  // that Developer Mode is enabled.
  //
  // On older versions of Windows where the
  // SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE flag does not exist, the OS
  // will return the error code ERROR_INVALID_PARAMETER when attempting to
  // create a symbolic link without sufficient privileges.
  if (base::win::GetVersion() < base::win::Version::WIN10_RS3) {
    return CreateSymbolicLinkResult::kUnsupported;
  }

  DWORD flags = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;

  if (!::CreateSymbolicLink(
          symlink.value().c_str(), target.value().c_str(),
          flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)) {
    // SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE works only if Developer Mode
    // is enabled.
    if (::GetLastError() == ERROR_PRIVILEGE_NOT_HELD) {
      return CreateSymbolicLinkResult::kUnsupported;
    }
    return CreateSymbolicLinkResult::kFailed;
  }

  return CreateSymbolicLinkResult::kSucceeded;
}
#endif  // BUILDFLAG(IS_WIN)

CreateSymbolicLinkResult CreateSymbolicLinkForTesting(
    const base::FilePath& target,
    const base::FilePath& symlink) { … }

}  // namespace
#endif  // BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)

class TestFileSystemAccessPermissionContext
    : public ChromeFileSystemAccessPermissionContext { … };

class ChromeFileSystemAccessPermissionContextTest : public testing::Test { … };

class ChromeFileSystemAccessPermissionContextNoPersistenceTest
    : public ChromeFileSystemAccessPermissionContextTest { … };

#if !BUILDFLAG(IS_ANDROID)

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_NoSpecialPath) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_DontBlockAllChildren) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_BlockAllChildren) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_BlockChildrenNested) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_RelativePathBlock) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_ExplicitPathBlock) { … }

#if BUILDFLAG(IS_MAC)
TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_DontBlockAllChildren_Overlapping) {
  base::FilePath home_dir = temp_dir_.GetPath().AppendASCII("home");
  base::ScopedPathOverride home_override(base::DIR_HOME, home_dir, true, true);

  // The Home directory itself should not be allowed.
  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal, home_dir,
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);
  // $HOME/Library should be blocked.
  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                home_dir.AppendASCII("Library"), HandleType::kDirectory,
                UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);
  // $HOME/Library/Mobile Documents should be blocked.
  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                home_dir.AppendASCII("Library/Mobile Documents"),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);
  // Paths within $HOME/Library/Mobile Documents should not be blocked.
  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                home_dir.AppendASCII("Library/Mobile Documents/foo"),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAllowed);
  // Except for $HOME/Library/Mobile Documents/com~apple~CloudDocs, which should
  // be blocked.
  EXPECT_EQ(

      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          home_dir.AppendASCII("Library/Mobile Documents/com~apple~CloudDocs"),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAbort);
  // Paths within $HOME/Library/Mobile Documents/com~apple~CloudDocs should not
  // be blocked.
  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                home_dir.AppendASCII(
                    "Library/Mobile Documents/com~apple~CloudDocs/foo"),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAllowed);
}
#endif  // BUILDFLAG(IS_MAC)

#if BUILDFLAG(IS_WIN)
TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_UNCPath) {
  if (!base::FeatureList::IsEnabled(
          features::kFileSystemAccessLocalUNCPathBlock)) {
    return;
  }

  EXPECT_EQ(
      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          base::FilePath(FILE_PATH_LITERAL("\\\\server\\share\\foo\\bar")),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAllowed);

  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                base::FilePath(FILE_PATH_LITERAL("c:\\\\foo\\bar")),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAllowed);

  EXPECT_EQ(
      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          base::FilePath(FILE_PATH_LITERAL("\\\\localhost\\c$\\foo\\bar")),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(
      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          base::FilePath(FILE_PATH_LITERAL("\\\\LOCALHOST\\c$\\foo\\bar")),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(
      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          base::FilePath(FILE_PATH_LITERAL("\\\\127.0.0.1\\c$\\foo\\bar")),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                base::FilePath(FILE_PATH_LITERAL("\\\\.\\c:\\foo\\bar")),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                base::FilePath(FILE_PATH_LITERAL("\\\\?\\c:\\foo\\bar")),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                base::FilePath(FILE_PATH_LITERAL(
                    "\\\\;LanmanRedirector\\localhost\\c$\\foo\\bar")),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(ConfirmSensitiveEntryAccessSync(
                permission_context(), PathType::kLocal,
                base::FilePath(
                    FILE_PATH_LITERAL("\\\\.\\UNC\\LOCALHOST\\c:\\foo\\bar")),
                HandleType::kDirectory, UserAction::kOpen),
            SensitiveDirectoryResult::kAbort);

  EXPECT_EQ(
      ConfirmSensitiveEntryAccessSync(
          permission_context(), PathType::kLocal,
          base::FilePath(FILE_PATH_LITERAL("\\\\myhostname\\c$\\foo\\bar")),
          HandleType::kDirectory, UserAction::kOpen),
      SensitiveDirectoryResult::kAbort);
}
#endif

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_ResolveSymbolicLink) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ConfirmSensitiveEntryAccess_DangerousFile) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CanObtainWritePermission_ContentSettingAsk) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CanObtainWritePermission_ContentSettingsBlock) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CanObtainWritePermission_ContentSettingAllow) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, PolicyReadGuardPermission) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       PolicyWriteGuardPermission) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, PolicyReadAskForUrls) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, PolicyReadBlockedForUrls) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, PolicyWriteAskForUrls) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, PolicyWriteBlockedForUrls) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, GetLastPickedDirectory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, SetLastPickedDirectory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       SetLastPickedDirectory_DefaultId) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, LimitNumberOfIds) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       SetLastPickedDirectory_NewPermissionContext) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWellKnownDirectoryPath_Base_OK) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWellKnownDirectoryPath_Chrome_OK) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWellKnownDirectoryPath_Pdf_Downloads) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_InitialState_LoadFromStorage) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_InitialState_Open_File) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_InitialState_Open_Directory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InitialState_LoadFromStorage) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InitialState_Open_File) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InitialState_Open_Directory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InitialState_WritableImplicitState) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_WriteGrantedChangesExistingGrant) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextNoPersistenceTest,
    GetWritePermissionGrant_GrantIsRevokedWhenNoLongerUsed_NoPersistentPermissions) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_GrantIsAutoGrantedViaPersistentPermissions) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       IsValidObject_GrantsWithDeprecatedTimestampKeyAreNotValidObjects) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    GetGrantedObjectsAndConvertObjectsToGrants_GrantsAreRetainedViaPersistedPermissions) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetExtendedPersistedObjects) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InitialState_OpenAction_GlobalGuardBlocked) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    GetWritePermissionGrant_InitialState_WritableImplicitState_GlobalGuardBlocked) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    GetWritePermissionGrant_WriteGrantedChangesExistingGrant_GlobalGuardBlocked) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    GetWritePermissionGrant_GrantIsRevokedWhenNoLongerUsed_GlobalGuardBlockedBeforeNewGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextNoPersistenceTest,
       GetGrantedObjects_NoPersistentPermissions) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetOriginsWithGrants_ForGrantedActiveGrantsOnly) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_Triggered_AfterTabBackgrounded) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_Triggered_HandleLoadedFromStorage) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_NotTriggered_HandleNotLoadedFromStorage) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_NotTriggered_WhenNoDormatGrants) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    RestorePermissionPrompt_NotTriggered_WhenRequestingWriteAccessToReadGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_NotTriggered_WhenRequestAccessToNewFile) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_AllowEveryTime) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_AllowOnce) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_Denied) { … }

class ChromeFileSystemAccessPermissionContextTestWithWebApp
    : public ChromeFileSystemAccessPermissionContextTest { … };

TEST_F(ChromeFileSystemAccessPermissionContextTestWithWebApp,
       OnWebAppInstalled) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTestWithWebApp,
       OnWebAppInstalled_WithCurrentGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTestWithWebApp,
       OnWebAppInstalled_ExtendedPermissionsEnabled) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTestWithWebApp,
       OnWebAppUninstalled_WithPeristentAndActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTestWithWebApp,
       OnWebAppUninstalled_NoGrantedActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ToggleExtendedPermissionByUser) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RestorePermissionPrompt_Ignored) { … }

// TODO(crbug.com/40101962): Expand upon this test case to cover checking that
// dormant grants are not revoked, when backgrounded dormant grants exist.
// Currently, there is no method to retrieve dormant grants, for testing
// purposes.
TEST_F(ChromeFileSystemAccessPermissionContextTest,
       OnLastPageFromOriginClosed) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       OnLastPageFromOriginClosed_PersistedGrantStatusUpdated) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       OnLastPageFromOriginClosed_HasExtendedPermissions) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextNoPersistenceTest,
    GetWritePermissionGrant_GrantIsRevokedWhenNoLongerUsed_GlobalGuardBlockedAfterNewGrant_NoPersistentPermissions) { … }

TEST_F(
    ChromeFileSystemAccessPermissionContextTest,
    GetWritePermissionGrant_GrantIsRevokedWhenNoLongerUsed_GlobalGuardBlockedAfterNewGrant_HasPersistentPermissions) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_InheritFromAncestor) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InheritFromAncestor) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       DoNotInheritFromAncestorOfOppositeType) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_InheritFromPersistedAncestor) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_InheritFromPersistedAncestor) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       DoNotInheritFromPersistedAncestorOfOppositeType) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       PersistedPermission_RevokeGrantByFilePath) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       PersistedPermission_NotAccessibleIfContentSettingBlock) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       PersistedPermission_ReadWriteGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_ClearOutdatedDormantGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_Dismissed) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, RequestPermission_Granted) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, RequestPermission_Denied) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_NoUserActivation) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_NoUserActivation_UserActivationNotRequired) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_AlreadyGranted) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_GlobalGuardBlockedBeforeOpenGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       RequestPermission_GlobalGuardBlockedAfterOpenGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_AllowlistedOrigin_InitialState) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_AllowlistedOrigin_ExistingGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetReadPermissionGrant_FileBecomesDirectory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GetWritePermissionGrant_FileBecomesDirectory) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest, NotifyEntryMoved_File) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       NotifyEntryMoved_ChildFileObtainedLater) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       NotifyEntryMoved_ChildFileObtainedFirst) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ReadGrantDestroyedOnRevokeActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       WriteGrantDestroyedOnRevokeActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ReadGrantDestroyedOnRevokeAllActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       WriteGrantDestroyedOnRevokeAllActiveGrants) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       GrantDestroyedOnRequestingPermission) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       WriteGrantDestroyedOnGrantingSecondWriteGrant) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       ReadGrantDestroyedOnGrantingSecondReadGrant) { … }

#if BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_Empty) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_BadFrameId) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_OneFile) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_OneDirectoryAllowed) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_OneDirectoryBlocked) { … }

TEST_F(ChromeFileSystemAccessPermissionContextTest,
       CheckPathsAgainstEnterprisePolicy_TwoFilesOneBlocked) { … }

#endif  // BUILDFLAG(ENTERPRISE_CLOUD_CONTENT_ANALYSIS)

#endif  // !BUILDFLAG(IS_ANDROID)
chromium/chrome/browser/file_system_access/chrome_file_system_access_permission_context_unittest.cc
