chrome/browser/ui/web_applications/web_app_file_handling_browsertest.cc - chromium/src - Git at Google

 // 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 "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/functional/bind.h"
 #include "base/memory/raw_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/strcat.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/bind.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
 #include "chrome/browser/apps/app_service/app_launch_params.h"
 #include "chrome/browser/apps/app_service/app_service_proxy.h"
 #include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
 #include "chrome/browser/apps/app_service/browser_app_launcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/ui_features.h"
 #include "chrome/browser/ui/web_applications/test/test_server_redirect_handle.h"
 #include "chrome/browser/ui/web_applications/test/web_app_browsertest_util.h"
 #include "chrome/browser/ui/web_applications/web_app_controller_browsertest.h"
 #include "chrome/browser/web_applications/os_integration/os_integration_manager.h"
 #include "chrome/browser/web_applications/os_integration/web_app_file_handler_manager.h"
 #include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/browser/web_applications/web_app_constants.h"
 #include "chrome/browser/web_applications/web_app_install_info.h"
 #include "chrome/browser/web_applications/web_app_prefs_utils.h"
 #include "chrome/browser/web_applications/web_app_provider.h"
 #include "chrome/browser/web_applications/web_app_registrar.h"
 #include "chrome/browser/web_applications/web_app_registry_update.h"
 #include "chrome/browser/web_applications/web_app_sync_bridge.h"
 #include "chrome/browser/web_applications/web_app_utils.h"
 #include "chrome/common/chrome_features.h"
 #include "components/embedder_support/switches.h"
 #include "components/permissions/test/permission_request_observer.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/policy_constants.h"
 #include "components/services/app_service/public/cpp/app_launch_util.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_launcher.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/url_loader_interceptor.h"
 #include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "third_party/blink/public/common/features.h"

 #if BUILDFLAG(IS_CHROMEOS_ASH)
 #include "chrome/browser/ash/file_manager/file_manager_test_util.h"
 #endif

 namespace web_app {

 class WebAppFileHandlingTestBase : public WebAppControllerBrowserTest {
  public:
   WebAppProvider* provider() { return WebAppProvider::GetForTest(profile()); }

   WebAppFileHandlerManager& file_handler_manager() {
     return provider()->os_integration_manager().file_handler_manager();
   }

   WebAppRegistrar& registrar() { return provider()->registrar_unsafe(); }

   GURL GetSecureAppURL() {
     return https_server()->GetURL("app.com", "/ssl/google.html");
   }

   GURL GetTextFileHandlerActionURL() {
     return https_server()->GetURL("app.com", "/ssl/blank_page.html");
   }

   GURL GetCSVFileHandlerActionURL() {
     return https_server()->GetURL("app.com", "/ssl/page_with_refs.html");
   }

   GURL GetHTMLFileHandlerActionURL() {
     return https_server()->GetURL("app.com", "/ssl/page_with_frame.html");
   }

   void InstallFileHandlingPWA() {
     GURL url = GetSecureAppURL();

     auto web_app_info = std::make_unique<WebAppInstallInfo>();
     web_app_info->start_url = url;
     web_app_info->scope = url.GetWithoutFilename();
     web_app_info->title = u"A Hosted App";

     // Basic plain text format.
     apps::FileHandler entry1;
     entry1.action = GetTextFileHandlerActionURL();
     entry1.accept.emplace_back();
     entry1.accept[0].mime_type = "text/*";
     entry1.accept[0].file_extensions.insert(".txt");
     web_app_info->file_handlers.push_back(std::move(entry1));

     // A format that the browser is also a handler for, to confirm that the
     // browser doesn't override PWAs using File Handling for types that the
     // browser also handles.
     apps::FileHandler entry2;
     entry2.action = GetHTMLFileHandlerActionURL();
     entry2.accept.emplace_back();
     entry2.accept[0].mime_type = "text/html";
     entry2.accept[0].file_extensions.insert(".html");
     web_app_info->file_handlers.push_back(std::move(entry2));

     // application/* format.
     apps::FileHandler entry3;
     entry3.action = GetCSVFileHandlerActionURL();
     entry3.accept.emplace_back();
     entry3.accept[0].mime_type = "application/csv";
     entry3.accept[0].file_extensions.insert(".csv");
     web_app_info->file_handlers.push_back(std::move(entry3));

     app_id_ =
         WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
   }

   AppId InstallAnotherFileHandlingPwa(const GURL& start_url) {
     auto web_app_info = std::make_unique<WebAppInstallInfo>();
     web_app_info->start_url = start_url;
     web_app_info->scope = start_url.GetWithoutFilename();
     web_app_info->title = u"A second app";

     // This one handles jpegs.
     apps::FileHandler entry1;
     entry1.action = GetTextFileHandlerActionURL();
     entry1.accept.emplace_back();
     entry1.accept[0].mime_type = "image/jpeg";
     entry1.accept[0].file_extensions.insert(".jpeg");
     web_app_info->file_handlers.push_back(std::move(entry1));

     return WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
   }

  protected:
   const AppId& app_id() { return app_id_; }

  private:
   AppId app_id_;
 };

 namespace {

 // Attach the launchParams to the window so we can inspect them easily.
 void AttachTestConsumer(content::WebContents* web_contents) {
   auto result = content::EvalJs(web_contents,
                                 "launchQueue.setConsumer(launchParams => {"
                                 "  window.launchParams = launchParams;"
                                 "});");
 }

 }  // namespace

 class WebAppFileHandlingBrowserTest : public WebAppFileHandlingTestBase {
  public:
   WebAppFileHandlingBrowserTest() : redirect_handle_(*https_server()) {}

   void LaunchWithFiles(const std::string& app_id,
                        const GURL& expected_launch_url,
                        const std::vector<base::FilePath>& files,
                        const apps::LaunchContainer launch_container =
                            apps::LaunchContainer::kLaunchContainerWindow) {
     web_contents_ = LaunchApplication(
         profile(), app_id, expected_launch_url, launch_container,
         apps::LaunchSource::kFromFileManager, files);
     destroyed_watcher_ =
         std::make_unique<content::WebContentsDestroyedWatcher>(web_contents_);
   }

   void VerifyPwaDidReceiveFileLaunchParams(
       bool expect_got_launch_params,
       const base::FilePath& expected_file_path = {}) {
     bool got_launch_params =
         content::EvalJs(web_contents_.get(), "!!window.launchParams")
             .ExtractBool();
     ASSERT_EQ(expect_got_launch_params, got_launch_params);
     if (got_launch_params) {
       EXPECT_EQ(1, content::EvalJs(web_contents_.get(),
                                    "window.launchParams.files.length"));
       EXPECT_EQ(expected_file_path.BaseName().AsUTF8Unsafe(),
                 content::EvalJs(web_contents_.get(),
                                 "window.launchParams.files[0].name"));
       std::string check_permissions_js(
           // clang-format off
         "(async () => {"
         "  return await window.launchParams.files[0].queryPermission("
         "             {mode: 'readwrite'}) === 'granted';"
         "})()");
       // clang-format on
       EXPECT_TRUE(content::EvalJs(web_contents_.get(), check_permissions_js)
                       .ExtractBool());
     }
   }

   AppId InstallFileHandlingWebApp(const std::u16string& title,
                                   const GURL& handler_url) {
     auto web_app_info = std::make_unique<WebAppInstallInfo>();
     web_app_info->start_url =
         https_server()->GetURL("app.com", "/web_app_file_handling/index.html");
     web_app_info->scope = web_app_info->start_url.GetWithoutFilename();
     web_app_info->title = title;
     apps::FileHandler entry;
     entry.action = handler_url;
     entry.accept.emplace_back();
     entry.accept[0].mime_type = "text/*";
     entry.accept[0].file_extensions.insert(".txt");
     web_app_info->file_handlers.push_back(std::move(entry));
     return WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
   }

  protected:
   // Launches the |app_id| web app with |files| handles, awaits for
   // |expected_launch_url| to load and stashes any launch params on
   // "window.launchParams" for further inspection.
   content::WebContents* LaunchApplication(
       Profile* profile,
       const std::string& app_id,
       const GURL& expected_launch_url,
       const apps::LaunchContainer launch_container =
           apps::LaunchContainer::kLaunchContainerWindow,
       const apps::LaunchSource launch_source = apps::LaunchSource::kFromTest,
       const std::vector<base::FilePath>& files =
           std::vector<base::FilePath>()) {
     apps::AppLaunchParams params(app_id, launch_container,
                                  WindowOpenDisposition::NEW_WINDOW,
                                  launch_source);

     if (files.size()) {
       auto launch_infos =
           file_handler_manager().GetMatchingFileHandlerUrls(app_id, files);
       EXPECT_EQ(1u, launch_infos.size());

       const auto& [url, launch_files] = launch_infos[0];
       params.launch_files = launch_files;
       params.override_url = url;
     }

     content::TestNavigationObserver navigation_observer(expected_launch_url);
     navigation_observer.StartWatchingNewWebContents();
     content::WebContents* web_contents =
         apps::AppServiceProxyFactory::GetForProfile(profile)
             ->BrowserAppLauncher()
             ->LaunchAppWithParamsForTesting(std::move(params));

     navigation_observer.Wait();
     AttachTestConsumer(web_contents);
     return web_contents;
   }

   TestServerRedirectHandle redirect_handle_;
   raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_;
   std::unique_ptr<content::WebContentsDestroyedWatcher> destroyed_watcher_;
 };

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        PWAsCanReceiveFileLaunchParams) {
   InstallFileHandlingPWA();
   base::FilePath test_file_path = CreateTestFileWithExtension("txt");
   LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path});

   VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        FileExtensionCaseInsensitive) {
   InstallFileHandlingPWA();
   base::FilePath test_file_path = CreateTestFileWithExtension("TXT");
   LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path});

   VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        PWAsCanReceiveFileLaunchParamsInTab) {
   InstallFileHandlingPWA();
   base::FilePath test_file_path = CreateTestFileWithExtension("txt");
   LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path},
                   apps::LaunchContainer::kLaunchContainerTab);

   VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        PWAsDispatchOnCorrectFileHandlingURL) {
   InstallFileHandlingPWA();

   // Test that file handler dispatches correct URL based on file extension.
   LaunchWithFiles(app_id(), GetSecureAppURL(), {});
   LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(),
                   {CreateTestFileWithExtension("txt")});
   LaunchWithFiles(app_id(), GetHTMLFileHandlerActionURL(),
                   {CreateTestFileWithExtension("html")});
   LaunchWithFiles(app_id(), GetCSVFileHandlerActionURL(),
                   {CreateTestFileWithExtension("csv")});

   // Test as above in a tab.
   LaunchWithFiles(app_id(), GetSecureAppURL(), {},
                   apps::LaunchContainer::kLaunchContainerTab);
   LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(),
                   {CreateTestFileWithExtension("txt")},
                   apps::LaunchContainer::kLaunchContainerTab);
   LaunchWithFiles(app_id(), GetHTMLFileHandlerActionURL(),
                   {CreateTestFileWithExtension("html")},
                   apps::LaunchContainer::kLaunchContainerTab);
   LaunchWithFiles(app_id(), GetCSVFileHandlerActionURL(),
                   {CreateTestFileWithExtension("csv")},
                   apps::LaunchContainer::kLaunchContainerTab);
 }

 // Regression test for crbug.com/1126091
 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        LaunchQueueSetOnRedirect) {
   GURL handler_url = https_server()->GetURL(
       "app.com", "/web_app_file_handling/handle_files_with_redirect.html");
   AppId app_id =
       InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

   base::FilePath file = CreateTestFileWithExtension("txt");

   {
     auto redirect_scope = redirect_handle_.Redirect({
         .redirect_url = handler_url,
         .target_url = https_server()->GetURL(
             "app.com", "/web_app_file_handling/handle_files.html"),
         .origin = "app.com",
     });

     LaunchWithFiles(app_id, redirect_handle_.params().target_url, {file});
   }

   // The redirected-to page should get the launch queue.
   VerifyPwaDidReceiveFileLaunchParams(true, file);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest, LaunchQueueSetOnReload) {
   GURL handler_url = https_server()->GetURL(
       "app.com", "/web_app_file_handling/handle_files.html");
   AppId app_id =
       InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

   base::FilePath file = CreateTestFileWithExtension("txt");
   LaunchWithFiles(app_id, handler_url, {file});
   VerifyPwaDidReceiveFileLaunchParams(true, file);

   // Reload the page.
   {
     content::TestNavigationObserver navigation_observer(web_contents_);
     chrome::Reload(chrome::FindBrowserWithWebContents(web_contents_),
                    WindowOpenDisposition::CURRENT_TAB);
     navigation_observer.Wait();
     AttachTestConsumer(web_contents_);
   }
   VerifyPwaDidReceiveFileLaunchParams(true, file);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        LaunchQueueSetOnReloadAfterPushState) {
   GURL handler_url = https_server()->GetURL(
       "app.com", "/web_app_file_handling/handle_files.html");
   AppId app_id =
       InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

   base::FilePath file = CreateTestFileWithExtension("txt");
   LaunchWithFiles(app_id, handler_url, {file});
   VerifyPwaDidReceiveFileLaunchParams(true, file);

   // page initiates pushstate
   {
     content::TestNavigationObserver navigation_observer(web_contents_);
     auto result = content::EvalJs(web_contents_.get(),
                                   "window.history.replaceState(null, '', "
                                   "window.location.href + '#foo');");
     EXPECT_TRUE(result.error.empty());
     navigation_observer.Wait();
   }

   // Reload the page.
   {
     content::TestNavigationObserver navigation_observer(web_contents_);
     chrome::Reload(chrome::FindBrowserWithWebContents(web_contents_),
                    WindowOpenDisposition::CURRENT_TAB);
     navigation_observer.Wait();
     AttachTestConsumer(web_contents_);
   }
   VerifyPwaDidReceiveFileLaunchParams(true, file);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        LaunchQueueNotSetOnCrossOriginRedirect) {
   // Install an app where the file handling action page redirects to a page on a
   // different origin.
   GURL handler_url = https_server()->GetURL(
       "app.com",
       "/web_app_file_handling/handle_files_with_redirect_to_other_origin.html");
   AppId app_id =
       InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);
   base::FilePath file = CreateTestFileWithExtension("txt");

   {
     auto redirect_scope = redirect_handle_.Redirect({
         .redirect_url = handler_url,
         .target_url = https_server()->GetURL(
             "example.com", "/web_app_file_handling/handle_files.html"),
         .origin = "app.com",
     });

     LaunchWithFiles(app_id, redirect_handle_.params().target_url, {file});
   }

   // The redirected-to page should NOT get the launch queue.
   VerifyPwaDidReceiveFileLaunchParams(false);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        LaunchQueueNotSetOnNavigate) {
   GURL handler_url = https_server()->GetURL(
       "app.com", "/web_app_file_handling/handle_files.html");
   GURL start_url =
       https_server()->GetURL("app.com", "/web_app_file_handling/index.html");
   AppId app_id =
       InstallFileHandlingWebApp(u"An app that will be navigated", handler_url);

   base::FilePath file = CreateTestFileWithExtension("txt");
   LaunchWithFiles(app_id, handler_url, {file});
   VerifyPwaDidReceiveFileLaunchParams(true, file);

   // Navigating the page should not enqueue the LaunchParams again.
   ASSERT_TRUE(NavigateToURL(web_contents_, start_url));
   AttachTestConsumer(web_contents_);
   VerifyPwaDidReceiveFileLaunchParams(false);

   // Nor should navigating back to the handler page re-enqueue.
   ASSERT_TRUE(NavigateToURL(web_contents_, handler_url));
   AttachTestConsumer(web_contents_);
   VerifyPwaDidReceiveFileLaunchParams(false);
 }

 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        SometimesResetPermission) {
   // Install the first app and simulate the user granting it the file handling
   // permission.
   InstallFileHandlingPWA();
   const GURL origin = GetSecureAppURL().DeprecatedGetOriginAsURL();

   EXPECT_EQ(ApiApprovalState::kRequiresPrompt,
             registrar().GetAppFileHandlerApprovalState(app_id()));
   provider()->sync_bridge_unsafe().SetAppFileHandlerApprovalState(
       app_id(), ApiApprovalState::kAllowed);

   auto [file_associations, association_count] =
       GetFileTypeAssociationsHandledByWebAppForDisplay(profile(), app_id());
   EXPECT_EQ(3u, association_count);

   // Installing a different app should have no impact.
   GURL second_app_url = https_server()->GetURL("app.com", "/pwa/app2.html");
   InstallAnotherFileHandlingPwa(second_app_url);
   EXPECT_EQ(ApiApprovalState::kAllowed,
             registrar().GetAppById(app_id())->file_handler_approval_state());
 }

 #if BUILDFLAG(IS_CHROMEOS_ASH)
 // End-to-end test to ensure the file handler is registered on ChromeOS when the
 // extension system is initialized. Gives more coverage than the unit tests.
 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest, IsFileHandlerOnChromeOS) {
   InstallFileHandlingPWA();

   base::FilePath test_file_path = CreateTestFileWithExtension("txt");
   std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks =
       file_manager::test::GetTasksForFile(profile(), test_file_path);
   // Note that there are normally multiple tasks due to default-installed
   // handlers (e.g. add to zip file). But those handlers are not installed by
   // default in browser tests.
   ASSERT_EQ(1u, tasks.size());
   EXPECT_EQ(tasks[0].task_descriptor.app_id, app_id());
 }

 // Ensures correct behavior for files on "special volumes", such as file systems
 // provided by extensions. These do not have local files (i.e. backed by
 // inodes).
 IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
                        NotHandlerForNonNativeFiles) {
   InstallFileHandlingPWA();
   base::WeakPtr<file_manager::Volume> fsp_volume =
       file_manager::test::InstallFileSystemProviderChromeApp(profile());

   // File in chrome/test/data/extensions/api_test/file_browser/image_provider/.
   base::FilePath test_file_path =
       fsp_volume->mount_path().AppendASCII("readonly.txt");
   std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks =
       file_manager::test::GetTasksForFile(profile(), test_file_path);

   // Current expectation is for the task not to be found while the native
   // filesystem API is still being built up. See https://crbug.com/1079065.
   // When the "special file" check in file_manager::file_tasks::FindWebTasks()
   // is removed, this test should work the same as IsFileHandlerOnChromeOS.
   EXPECT_EQ(0u, tasks.size());
 }
 #endif

 class WebAppFileHandlingIconBrowserTest
     : public WebAppControllerBrowserTest,
       public testing::WithParamInterface<bool> {
  public:
   WebAppFileHandlingIconBrowserTest() {
     feature_list_.InitWithFeatures({blink::features::kFileHandlingIcons}, {});
     WebAppFileHandlerManager::SetIconsSupportedByOsForTesting(GetParam());
   }
   ~WebAppFileHandlingIconBrowserTest() override = default;

  private:
   base::test::ScopedFeatureList feature_list_;
 };

 IN_PROC_BROWSER_TEST_P(WebAppFileHandlingIconBrowserTest, Basic) {
   ASSERT_TRUE(embedded_test_server()->Start());
   const GURL app_url(
       embedded_test_server()->GetURL("/web_app_file_handling/icons_app.html"));
   const AppId app_id = InstallWebAppFromManifest(browser(), app_url);
   auto* provider = WebAppProvider::GetForTest(browser()->profile());
   const WebApp* web_app = provider->registrar_unsafe().GetAppById(app_id);
   ASSERT_TRUE(web_app);

   ASSERT_EQ(1U, web_app->file_handlers().size());
   if (WebAppFileHandlerManager::IconsEnabled()) {
     ASSERT_EQ(1U, web_app->file_handlers()[0].downloaded_icons.size());
     EXPECT_EQ(20,
               web_app->file_handlers()[0].downloaded_icons[0].square_size_px);
   } else {
     EXPECT_TRUE(web_app->file_handlers()[0].downloaded_icons.empty());
   }
 }

 // TODO(crbug.com/1218210): add more tests.

 INSTANTIATE_TEST_SUITE_P(, WebAppFileHandlingIconBrowserTest, testing::Bool());

 }  // namespace web_app
	// 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 "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/functional/bind.h"
	#include "base/memory/raw_ptr.h"
	#include "base/run_loop.h"
	#include "base/strings/strcat.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/test/bind.h"
	#include "base/test/scoped_feature_list.h"
	#include "base/threading/thread_restrictions.h"
	#include "base/values.h"
	#include "build/build_config.h"
	#include "build/chromeos_buildflags.h"
	#include "chrome/browser/apps/app_service/app_launch_params.h"
	#include "chrome/browser/apps/app_service/app_service_proxy.h"
	#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
	#include "chrome/browser/apps/app_service/browser_app_launcher.h"
	#include "chrome/browser/profiles/profile.h"
	#include "chrome/browser/ui/browser.h"
	#include "chrome/browser/ui/browser_commands.h"
	#include "chrome/browser/ui/browser_finder.h"
	#include "chrome/browser/ui/tabs/tab_strip_model.h"
	#include "chrome/browser/ui/ui_features.h"
	#include "chrome/browser/ui/web_applications/test/test_server_redirect_handle.h"
	#include "chrome/browser/ui/web_applications/test/web_app_browsertest_util.h"
	#include "chrome/browser/ui/web_applications/web_app_controller_browsertest.h"
	#include "chrome/browser/web_applications/os_integration/os_integration_manager.h"
	#include "chrome/browser/web_applications/os_integration/web_app_file_handler_manager.h"
	#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
	#include "chrome/browser/web_applications/web_app.h"
	#include "chrome/browser/web_applications/web_app_constants.h"
	#include "chrome/browser/web_applications/web_app_install_info.h"
	#include "chrome/browser/web_applications/web_app_prefs_utils.h"
	#include "chrome/browser/web_applications/web_app_provider.h"
	#include "chrome/browser/web_applications/web_app_registrar.h"
	#include "chrome/browser/web_applications/web_app_registry_update.h"
	#include "chrome/browser/web_applications/web_app_sync_bridge.h"
	#include "chrome/browser/web_applications/web_app_utils.h"
	#include "chrome/common/chrome_features.h"
	#include "components/embedder_support/switches.h"
	#include "components/permissions/test/permission_request_observer.h"
	#include "components/policy/core/browser/browser_policy_connector.h"
	#include "components/policy/core/common/mock_configuration_policy_provider.h"
	#include "components/policy/core/common/policy_map.h"
	#include "components/policy/policy_constants.h"
	#include "components/services/app_service/public/cpp/app_launch_util.h"
	#include "content/public/test/browser_test.h"
	#include "content/public/test/browser_test_utils.h"
	#include "content/public/test/test_launcher.h"
	#include "content/public/test/test_navigation_observer.h"
	#include "content/public/test/url_loader_interceptor.h"
	#include "mojo/public/cpp/bindings/associated_receiver.h"
	#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
	#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
	#include "third_party/blink/public/common/features.h"

	#if BUILDFLAG(IS_CHROMEOS_ASH)
	#include "chrome/browser/ash/file_manager/file_manager_test_util.h"
	#endif

	namespace web_app {

	class WebAppFileHandlingTestBase : public WebAppControllerBrowserTest {
	public:
	WebAppProvider* provider() { return WebAppProvider::GetForTest(profile()); }

	WebAppFileHandlerManager& file_handler_manager() {
	return provider()->os_integration_manager().file_handler_manager();
	}

	WebAppRegistrar& registrar() { return provider()->registrar_unsafe(); }

	GURL GetSecureAppURL() {
	return https_server()->GetURL("app.com", "/ssl/google.html");
	}

	GURL GetTextFileHandlerActionURL() {
	return https_server()->GetURL("app.com", "/ssl/blank_page.html");
	}

	GURL GetCSVFileHandlerActionURL() {
	return https_server()->GetURL("app.com", "/ssl/page_with_refs.html");
	}

	GURL GetHTMLFileHandlerActionURL() {
	return https_server()->GetURL("app.com", "/ssl/page_with_frame.html");
	}

	void InstallFileHandlingPWA() {
	GURL url = GetSecureAppURL();

	auto web_app_info = std::make_unique<WebAppInstallInfo>();
	web_app_info->start_url = url;
	web_app_info->scope = url.GetWithoutFilename();
	web_app_info->title = u"A Hosted App";

	// Basic plain text format.
	apps::FileHandler entry1;
	entry1.action = GetTextFileHandlerActionURL();
	entry1.accept.emplace_back();
	entry1.accept[0].mime_type = "text/*";
	entry1.accept[0].file_extensions.insert(".txt");
	web_app_info->file_handlers.push_back(std::move(entry1));

	// A format that the browser is also a handler for, to confirm that the
	// browser doesn't override PWAs using File Handling for types that the
	// browser also handles.
	apps::FileHandler entry2;
	entry2.action = GetHTMLFileHandlerActionURL();
	entry2.accept.emplace_back();
	entry2.accept[0].mime_type = "text/html";
	entry2.accept[0].file_extensions.insert(".html");
	web_app_info->file_handlers.push_back(std::move(entry2));

	// application/* format.
	apps::FileHandler entry3;
	entry3.action = GetCSVFileHandlerActionURL();
	entry3.accept.emplace_back();
	entry3.accept[0].mime_type = "application/csv";
	entry3.accept[0].file_extensions.insert(".csv");
	web_app_info->file_handlers.push_back(std::move(entry3));

	app_id_ =
	WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
	}

	AppId InstallAnotherFileHandlingPwa(const GURL& start_url) {
	auto web_app_info = std::make_unique<WebAppInstallInfo>();
	web_app_info->start_url = start_url;
	web_app_info->scope = start_url.GetWithoutFilename();
	web_app_info->title = u"A second app";

	// This one handles jpegs.
	apps::FileHandler entry1;
	entry1.action = GetTextFileHandlerActionURL();
	entry1.accept.emplace_back();
	entry1.accept[0].mime_type = "image/jpeg";
	entry1.accept[0].file_extensions.insert(".jpeg");
	web_app_info->file_handlers.push_back(std::move(entry1));

	return WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
	}

	protected:
	const AppId& app_id() { return app_id_; }

	private:
	AppId app_id_;
	};

	namespace {

	// Attach the launchParams to the window so we can inspect them easily.
	void AttachTestConsumer(content::WebContents* web_contents) {
	auto result = content::EvalJs(web_contents,
	"launchQueue.setConsumer(launchParams => {"
	" window.launchParams = launchParams;"
	"});");
	}

	} // namespace

	class WebAppFileHandlingBrowserTest : public WebAppFileHandlingTestBase {
	public:
	WebAppFileHandlingBrowserTest() : redirect_handle_(*https_server()) {}

	void LaunchWithFiles(const std::string& app_id,
	const GURL& expected_launch_url,
	const std::vector<base::FilePath>& files,
	const apps::LaunchContainer launch_container =
	apps::LaunchContainer::kLaunchContainerWindow) {
	web_contents_ = LaunchApplication(
	profile(), app_id, expected_launch_url, launch_container,
	apps::LaunchSource::kFromFileManager, files);
	destroyed_watcher_ =
	std::make_unique<content::WebContentsDestroyedWatcher>(web_contents_);
	}

	void VerifyPwaDidReceiveFileLaunchParams(
	bool expect_got_launch_params,
	const base::FilePath& expected_file_path = {}) {
	bool got_launch_params =
	content::EvalJs(web_contents_.get(), "!!window.launchParams")
	.ExtractBool();
	ASSERT_EQ(expect_got_launch_params, got_launch_params);
	if (got_launch_params) {
	EXPECT_EQ(1, content::EvalJs(web_contents_.get(),
	"window.launchParams.files.length"));
	EXPECT_EQ(expected_file_path.BaseName().AsUTF8Unsafe(),
	content::EvalJs(web_contents_.get(),
	"window.launchParams.files[0].name"));
	std::string check_permissions_js(
	// clang-format off
	"(async () => {"
	" return await window.launchParams.files[0].queryPermission("
	" {mode: 'readwrite'}) === 'granted';"
	"})()");
	// clang-format on
	EXPECT_TRUE(content::EvalJs(web_contents_.get(), check_permissions_js)
	.ExtractBool());
	}
	}

	AppId InstallFileHandlingWebApp(const std::u16string& title,
	const GURL& handler_url) {
	auto web_app_info = std::make_unique<WebAppInstallInfo>();
	web_app_info->start_url =
	https_server()->GetURL("app.com", "/web_app_file_handling/index.html");
	web_app_info->scope = web_app_info->start_url.GetWithoutFilename();
	web_app_info->title = title;
	apps::FileHandler entry;
	entry.action = handler_url;
	entry.accept.emplace_back();
	entry.accept[0].mime_type = "text/*";
	entry.accept[0].file_extensions.insert(".txt");
	web_app_info->file_handlers.push_back(std::move(entry));
	return WebAppControllerBrowserTest::InstallWebApp(std::move(web_app_info));
	}

	protected:
	// Launches the \|app_id\| web app with \|files\| handles, awaits for
	// \|expected_launch_url\| to load and stashes any launch params on
	// "window.launchParams" for further inspection.
	content::WebContents* LaunchApplication(
	Profile* profile,
	const std::string& app_id,
	const GURL& expected_launch_url,
	const apps::LaunchContainer launch_container =
	apps::LaunchContainer::kLaunchContainerWindow,
	const apps::LaunchSource launch_source = apps::LaunchSource::kFromTest,
	const std::vector<base::FilePath>& files =
	std::vector<base::FilePath>()) {
	apps::AppLaunchParams params(app_id, launch_container,
	WindowOpenDisposition::NEW_WINDOW,
	launch_source);

	if (files.size()) {
	auto launch_infos =
	file_handler_manager().GetMatchingFileHandlerUrls(app_id, files);
	EXPECT_EQ(1u, launch_infos.size());

	const auto& [url, launch_files] = launch_infos[0];
	params.launch_files = launch_files;
	params.override_url = url;
	}

	content::TestNavigationObserver navigation_observer(expected_launch_url);
	navigation_observer.StartWatchingNewWebContents();
	content::WebContents* web_contents =
	apps::AppServiceProxyFactory::GetForProfile(profile)
	->BrowserAppLauncher()
	->LaunchAppWithParamsForTesting(std::move(params));

	navigation_observer.Wait();
	AttachTestConsumer(web_contents);
	return web_contents;
	}

	TestServerRedirectHandle redirect_handle_;
	raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_;
	std::unique_ptr<content::WebContentsDestroyedWatcher> destroyed_watcher_;
	};

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	PWAsCanReceiveFileLaunchParams) {
	InstallFileHandlingPWA();
	base::FilePath test_file_path = CreateTestFileWithExtension("txt");
	LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path});

	VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	FileExtensionCaseInsensitive) {
	InstallFileHandlingPWA();
	base::FilePath test_file_path = CreateTestFileWithExtension("TXT");
	LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path});

	VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	PWAsCanReceiveFileLaunchParamsInTab) {
	InstallFileHandlingPWA();
	base::FilePath test_file_path = CreateTestFileWithExtension("txt");
	LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(), {test_file_path},
	apps::LaunchContainer::kLaunchContainerTab);

	VerifyPwaDidReceiveFileLaunchParams(true, test_file_path);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	PWAsDispatchOnCorrectFileHandlingURL) {
	InstallFileHandlingPWA();

	// Test that file handler dispatches correct URL based on file extension.
	LaunchWithFiles(app_id(), GetSecureAppURL(), {});
	LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(),
	{CreateTestFileWithExtension("txt")});
	LaunchWithFiles(app_id(), GetHTMLFileHandlerActionURL(),
	{CreateTestFileWithExtension("html")});
	LaunchWithFiles(app_id(), GetCSVFileHandlerActionURL(),
	{CreateTestFileWithExtension("csv")});

	// Test as above in a tab.
	LaunchWithFiles(app_id(), GetSecureAppURL(), {},
	apps::LaunchContainer::kLaunchContainerTab);
	LaunchWithFiles(app_id(), GetTextFileHandlerActionURL(),
	{CreateTestFileWithExtension("txt")},
	apps::LaunchContainer::kLaunchContainerTab);
	LaunchWithFiles(app_id(), GetHTMLFileHandlerActionURL(),
	{CreateTestFileWithExtension("html")},
	apps::LaunchContainer::kLaunchContainerTab);
	LaunchWithFiles(app_id(), GetCSVFileHandlerActionURL(),
	{CreateTestFileWithExtension("csv")},
	apps::LaunchContainer::kLaunchContainerTab);
	}

	// Regression test for crbug.com/1126091
	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	LaunchQueueSetOnRedirect) {
	GURL handler_url = https_server()->GetURL(
	"app.com", "/web_app_file_handling/handle_files_with_redirect.html");
	AppId app_id =
	InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

	base::FilePath file = CreateTestFileWithExtension("txt");

	{
	auto redirect_scope = redirect_handle_.Redirect({
	.redirect_url = handler_url,
	.target_url = https_server()->GetURL(
	"app.com", "/web_app_file_handling/handle_files.html"),
	.origin = "app.com",
	});

	LaunchWithFiles(app_id, redirect_handle_.params().target_url, {file});
	}

	// The redirected-to page should get the launch queue.
	VerifyPwaDidReceiveFileLaunchParams(true, file);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest, LaunchQueueSetOnReload) {
	GURL handler_url = https_server()->GetURL(
	"app.com", "/web_app_file_handling/handle_files.html");
	AppId app_id =
	InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

	base::FilePath file = CreateTestFileWithExtension("txt");
	LaunchWithFiles(app_id, handler_url, {file});
	VerifyPwaDidReceiveFileLaunchParams(true, file);

	// Reload the page.
	{
	content::TestNavigationObserver navigation_observer(web_contents_);
	chrome::Reload(chrome::FindBrowserWithWebContents(web_contents_),
	WindowOpenDisposition::CURRENT_TAB);
	navigation_observer.Wait();
	AttachTestConsumer(web_contents_);
	}
	VerifyPwaDidReceiveFileLaunchParams(true, file);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	LaunchQueueSetOnReloadAfterPushState) {
	GURL handler_url = https_server()->GetURL(
	"app.com", "/web_app_file_handling/handle_files.html");
	AppId app_id =
	InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);

	base::FilePath file = CreateTestFileWithExtension("txt");
	LaunchWithFiles(app_id, handler_url, {file});
	VerifyPwaDidReceiveFileLaunchParams(true, file);

	// page initiates pushstate
	{
	content::TestNavigationObserver navigation_observer(web_contents_);
	auto result = content::EvalJs(web_contents_.get(),
	"window.history.replaceState(null, '', "
	"window.location.href + '#foo');");
	EXPECT_TRUE(result.error.empty());
	navigation_observer.Wait();
	}

	// Reload the page.
	{
	content::TestNavigationObserver navigation_observer(web_contents_);
	chrome::Reload(chrome::FindBrowserWithWebContents(web_contents_),
	WindowOpenDisposition::CURRENT_TAB);
	navigation_observer.Wait();
	AttachTestConsumer(web_contents_);
	}
	VerifyPwaDidReceiveFileLaunchParams(true, file);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	LaunchQueueNotSetOnCrossOriginRedirect) {
	// Install an app where the file handling action page redirects to a page on a
	// different origin.
	GURL handler_url = https_server()->GetURL(
	"app.com",
	"/web_app_file_handling/handle_files_with_redirect_to_other_origin.html");
	AppId app_id =
	InstallFileHandlingWebApp(u"An app that will be reloaded", handler_url);
	base::FilePath file = CreateTestFileWithExtension("txt");

	{
	auto redirect_scope = redirect_handle_.Redirect({
	.redirect_url = handler_url,
	.target_url = https_server()->GetURL(
	"example.com", "/web_app_file_handling/handle_files.html"),
	.origin = "app.com",
	});

	LaunchWithFiles(app_id, redirect_handle_.params().target_url, {file});
	}

	// The redirected-to page should NOT get the launch queue.
	VerifyPwaDidReceiveFileLaunchParams(false);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	LaunchQueueNotSetOnNavigate) {
	GURL handler_url = https_server()->GetURL(
	"app.com", "/web_app_file_handling/handle_files.html");
	GURL start_url =
	https_server()->GetURL("app.com", "/web_app_file_handling/index.html");
	AppId app_id =
	InstallFileHandlingWebApp(u"An app that will be navigated", handler_url);

	base::FilePath file = CreateTestFileWithExtension("txt");
	LaunchWithFiles(app_id, handler_url, {file});
	VerifyPwaDidReceiveFileLaunchParams(true, file);

	// Navigating the page should not enqueue the LaunchParams again.
	ASSERT_TRUE(NavigateToURL(web_contents_, start_url));
	AttachTestConsumer(web_contents_);
	VerifyPwaDidReceiveFileLaunchParams(false);

	// Nor should navigating back to the handler page re-enqueue.
	ASSERT_TRUE(NavigateToURL(web_contents_, handler_url));
	AttachTestConsumer(web_contents_);
	VerifyPwaDidReceiveFileLaunchParams(false);
	}

	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	SometimesResetPermission) {
	// Install the first app and simulate the user granting it the file handling
	// permission.
	InstallFileHandlingPWA();
	const GURL origin = GetSecureAppURL().DeprecatedGetOriginAsURL();

	EXPECT_EQ(ApiApprovalState::kRequiresPrompt,
	registrar().GetAppFileHandlerApprovalState(app_id()));
	provider()->sync_bridge_unsafe().SetAppFileHandlerApprovalState(
	app_id(), ApiApprovalState::kAllowed);

	auto [file_associations, association_count] =
	GetFileTypeAssociationsHandledByWebAppForDisplay(profile(), app_id());
	EXPECT_EQ(3u, association_count);

	// Installing a different app should have no impact.
	GURL second_app_url = https_server()->GetURL("app.com", "/pwa/app2.html");
	InstallAnotherFileHandlingPwa(second_app_url);
	EXPECT_EQ(ApiApprovalState::kAllowed,
	registrar().GetAppById(app_id())->file_handler_approval_state());
	}

	#if BUILDFLAG(IS_CHROMEOS_ASH)
	// End-to-end test to ensure the file handler is registered on ChromeOS when the
	// extension system is initialized. Gives more coverage than the unit tests.
	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest, IsFileHandlerOnChromeOS) {
	InstallFileHandlingPWA();

	base::FilePath test_file_path = CreateTestFileWithExtension("txt");
	std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks =
	file_manager::test::GetTasksForFile(profile(), test_file_path);
	// Note that there are normally multiple tasks due to default-installed
	// handlers (e.g. add to zip file). But those handlers are not installed by
	// default in browser tests.
	ASSERT_EQ(1u, tasks.size());
	EXPECT_EQ(tasks[0].task_descriptor.app_id, app_id());
	}

	// Ensures correct behavior for files on "special volumes", such as file systems
	// provided by extensions. These do not have local files (i.e. backed by
	// inodes).
	IN_PROC_BROWSER_TEST_F(WebAppFileHandlingBrowserTest,
	NotHandlerForNonNativeFiles) {
	InstallFileHandlingPWA();
	base::WeakPtr<file_manager::Volume> fsp_volume =
	file_manager::test::InstallFileSystemProviderChromeApp(profile());

	// File in chrome/test/data/extensions/api_test/file_browser/image_provider/.
	base::FilePath test_file_path =
	fsp_volume->mount_path().AppendASCII("readonly.txt");
	std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks =
	file_manager::test::GetTasksForFile(profile(), test_file_path);

	// Current expectation is for the task not to be found while the native
	// filesystem API is still being built up. See https://crbug.com/1079065.
	// When the "special file" check in file_manager::file_tasks::FindWebTasks()
	// is removed, this test should work the same as IsFileHandlerOnChromeOS.
	EXPECT_EQ(0u, tasks.size());
	}
	#endif

	class WebAppFileHandlingIconBrowserTest
	: public WebAppControllerBrowserTest,
	public testing::WithParamInterface<bool> {
	public:
	WebAppFileHandlingIconBrowserTest() {
	feature_list_.InitWithFeatures({blink::features::kFileHandlingIcons}, {});
	WebAppFileHandlerManager::SetIconsSupportedByOsForTesting(GetParam());
	}
	~WebAppFileHandlingIconBrowserTest() override = default;

	private:
	base::test::ScopedFeatureList feature_list_;
	};

	IN_PROC_BROWSER_TEST_P(WebAppFileHandlingIconBrowserTest, Basic) {
	ASSERT_TRUE(embedded_test_server()->Start());
	const GURL app_url(
	embedded_test_server()->GetURL("/web_app_file_handling/icons_app.html"));
	const AppId app_id = InstallWebAppFromManifest(browser(), app_url);
	auto* provider = WebAppProvider::GetForTest(browser()->profile());
	const WebApp* web_app = provider->registrar_unsafe().GetAppById(app_id);
	ASSERT_TRUE(web_app);

	ASSERT_EQ(1U, web_app->file_handlers().size());
	if (WebAppFileHandlerManager::IconsEnabled()) {
	ASSERT_EQ(1U, web_app->file_handlers()[0].downloaded_icons.size());
	EXPECT_EQ(20,
	web_app->file_handlers()[0].downloaded_icons[0].square_size_px);
	} else {
	EXPECT_TRUE(web_app->file_handlers()[0].downloaded_icons.empty());
	}
	}

	// TODO(crbug.com/1218210): add more tests.

	INSTANTIATE_TEST_SUITE_P(, WebAppFileHandlingIconBrowserTest, testing::Bool());

	} // namespace web_app