chrome/browser/ash/android_sms/android_sms_app_setup_controller_impl_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2018 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/ash/android_sms/android_sms_app_setup_controller_impl.h"

 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>

 #include "base/containers/contains.h"
 #include "base/containers/flat_map.h"
 #include "base/files/file_path.h"
 #include "base/functional/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/test/bind.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/web_applications/external_install_options.h"
 #include "chrome/browser/web_applications/mojom/user_display_mode.mojom.h"
 #include "chrome/browser/web_applications/test/fake_externally_managed_app_manager.h"
 #include "chrome/browser/web_applications/test/fake_web_app_provider.h"
 #include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
 #include "chrome/browser/web_applications/web_app_helpers.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/webapps/browser/install_result_code.h"
 #include "content/public/test/browser_task_environment.h"
 #include "services/network/test/test_cookie_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/manifest/display_mode.mojom.h"

 namespace ash {
 namespace android_sms {

 namespace {

 const char kTestUrl1[] = "https://test-url-1.com/";
 const char kTestInstallUrl1[] = "https://test-url-1.com/install";
 const char kTestUrl2[] = "https://test-url-2.com/";

 web_app::ExternalInstallOptions GetInstallOptionsForUrl(const GURL& url) {
   web_app::ExternalInstallOptions options(
       url, web_app::mojom::UserDisplayMode::kStandalone,
       web_app::ExternalInstallSource::kInternalDefault);
   options.override_previous_user_uninstall = true;
   options.require_manifest = true;
   return options;
 }

 class FakeCookieManager : public network::TestCookieManager {
  public:
   FakeCookieManager() = default;
   ~FakeCookieManager() override {
     EXPECT_TRUE(set_canonical_cookie_calls_.empty());
     EXPECT_TRUE(delete_cookies_calls_.empty());
   }

   void InvokePendingSetCanonicalCookieCallback(
       const std::string& expected_cookie_name,
       const std::string& expected_cookie_value,
       const GURL& expected_source_url,
       bool expected_modify_http_only,
       net::CookieOptions::SameSiteCookieContext expect_same_site_context,
       bool success) {
     ASSERT_FALSE(set_canonical_cookie_calls_.empty());
     auto params = std::move(set_canonical_cookie_calls_.front());
     set_canonical_cookie_calls_.erase(set_canonical_cookie_calls_.begin());

     EXPECT_EQ(expected_cookie_name, std::get<0>(params).Name());
     EXPECT_EQ(expected_cookie_value, std::get<0>(params).Value());
     EXPECT_EQ(expected_source_url, std::get<1>(params));
     EXPECT_EQ(expected_modify_http_only,
               !std::get<2>(params).exclude_httponly());
     EXPECT_EQ(expect_same_site_context,
               std::get<2>(params).same_site_cookie_context());
     net::CookieAccessResult access_result;

     if (!success) {
       access_result.status.AddExclusionReason(
           net::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR);
     }

     std::move(std::get<3>(params)).Run(access_result);
   }

   void InvokePendingDeleteCookiesCallback(
       const GURL& expected_url,
       const std::string& expected_cookie_name,
       bool success) {
     ASSERT_FALSE(delete_cookies_calls_.empty());
     auto params = std::move(delete_cookies_calls_.front());
     delete_cookies_calls_.erase(delete_cookies_calls_.begin());

     EXPECT_EQ(expected_url, params.first->url);
     EXPECT_EQ(expected_cookie_name, params.first->cookie_name);

     std::move(params.second).Run(success);
   }

   // network::mojom::CookieManager
   void SetCanonicalCookie(const net::CanonicalCookie& cookie,
                           const GURL& source_url,
                           const net::CookieOptions& options,
                           SetCanonicalCookieCallback callback) override {
     set_canonical_cookie_calls_.emplace_back(cookie, source_url, options,
                                              std::move(callback));
   }

   void DeleteCookies(network::mojom::CookieDeletionFilterPtr filter,
                      DeleteCookiesCallback callback) override {
     delete_cookies_calls_.emplace_back(std::move(filter), std::move(callback));
   }

  private:
   std::vector<std::tuple<net::CanonicalCookie,
                          GURL,
                          net::CookieOptions,
                          SetCanonicalCookieCallback>>
       set_canonical_cookie_calls_;
   std::vector<
       std::pair<network::mojom::CookieDeletionFilterPtr, DeleteCookiesCallback>>
       delete_cookies_calls_;
 };

 }  // namespace

 class AndroidSmsAppSetupControllerImplTest : public testing::Test {
  public:
   AndroidSmsAppSetupControllerImplTest(
       const AndroidSmsAppSetupControllerImplTest&) = delete;
   AndroidSmsAppSetupControllerImplTest& operator=(
       const AndroidSmsAppSetupControllerImplTest&) = delete;

  protected:
   class TestPwaDelegate : public AndroidSmsAppSetupControllerImpl::PwaDelegate {
    public:
     explicit TestPwaDelegate(FakeCookieManager* fake_cookie_manager)
         : fake_cookie_manager_(fake_cookie_manager) {}
     ~TestPwaDelegate() override = default;

     void SetHasPwa(const GURL& url) {
       // If a PWA already exists for this URL, there is nothing to do.
       if (base::Contains(url_to_pwa_map_, url))
         return;

       url_to_pwa_map_[url] =
           web_app::GenerateAppId(/*manifest_id=*/std::nullopt, url);
     }

     // AndroidSmsAppSetupControllerImpl::PwaDelegate:
     std::optional<webapps::AppId> GetPwaForUrl(const GURL& install_url,
                                                Profile* profile) override {
       if (!base::Contains(url_to_pwa_map_, install_url))
         return std::nullopt;

       return url_to_pwa_map_[install_url];
     }

     network::mojom::CookieManager* GetCookieManager(Profile* profile) override {
       return fake_cookie_manager_;
     }

     void RemovePwa(
         const webapps::AppId& app_id,
         Profile* profile,
         AndroidSmsAppSetupController::SuccessCallback callback) override {
       for (const auto& url_pwa_pair : url_to_pwa_map_) {
         if (url_pwa_pair.second == app_id) {
           url_to_pwa_map_.erase(url_pwa_pair.first);
           std::move(callback).Run(true);
           return;
         }
       }

       std::move(callback).Run(false);
     }

    private:
     raw_ptr<FakeCookieManager> fake_cookie_manager_;
     base::flat_map<GURL, webapps::AppId> url_to_pwa_map_;
   };

   AndroidSmsAppSetupControllerImplTest()
       : task_environment_(
             content::BrowserTaskEnvironment::TimeSource::MOCK_TIME),
         host_content_settings_map_(
             HostContentSettingsMapFactory::GetForProfile(&profile_)) {}

   ~AndroidSmsAppSetupControllerImplTest() override = default;

   // testing::Test:
   void SetUp() override {
     host_content_settings_map_->ClearSettingsForOneType(
         ContentSettingsType::NOTIFICATIONS);
     fake_cookie_manager_ = std::make_unique<FakeCookieManager>();
     auto test_pwa_delegate =
         std::make_unique<TestPwaDelegate>(fake_cookie_manager_.get());
     test_pwa_delegate_ = test_pwa_delegate.get();

     provider_ = web_app::FakeWebAppProvider::Get(&profile_);
     web_app::test::AwaitStartWebAppProviderAndSubsystems(&profile_);

     fake_externally_managed_app_manager().SetHandleInstallRequestCallback(
         base::BindLambdaForTesting(
             [this](const web_app::ExternalInstallOptions& install_options) {
               return web_app::ExternallyManagedAppManager::InstallResult(
                   install_result_code_);
             }));

     setup_controller_ = base::WrapUnique(new AndroidSmsAppSetupControllerImpl(
         &profile_, &fake_externally_managed_app_manager(),
         host_content_settings_map_));

     std::unique_ptr<AndroidSmsAppSetupControllerImpl::PwaDelegate>
         base_delegate(test_pwa_delegate.release());

     static_cast<AndroidSmsAppSetupControllerImpl*>(setup_controller_.get())
         ->SetPwaDelegateForTesting(std::move(base_delegate));
   }

   void CallSetUpAppWithRetries(const GURL& app_url,
                                const GURL& install_url,
                                size_t num_failure_tries,
                                bool expected_setup_result) {
     const auto& install_requests =
         fake_externally_managed_app_manager().install_requests();
     size_t num_install_requests_before_call = install_requests.size();

     base::RunLoop run_loop;
     base::HistogramTester histogram_tester;

     SetInstallResultCode(
         webapps::InstallResultCode::kGetWebAppInstallInfoFailed);

     setup_controller_->SetUpApp(
         app_url, install_url,
         base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnSetUpAppResult,
                        base::Unretained(this), run_loop.QuitClosure()));

     fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
         "default_to_persist" /* expected_cookie_name */,
         "true" /* expected_cookie_value */,
         GURL("https://" + app_url.host()) /* expected_source_url */,
         false /* expected_modify_http_only */,
         net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
         true /* success */);

     fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
         app_url, "cros_migrated_to" /* expected_cookie_name */,
         true /* success */);

     base::RunLoop().RunUntilIdle();

     // Fast forward through remaining attempts.
     for (size_t retry_count = 0; retry_count < num_failure_tries - 1;
          retry_count++) {
       EXPECT_NE(ContentSetting::CONTENT_SETTING_ALLOW,
                 GetNotificationSetting(app_url));
       EXPECT_EQ(num_install_requests_before_call + retry_count + 1u,
                 install_requests.size());
       EXPECT_EQ(GetInstallOptionsForUrl(install_url), install_requests.back());

       task_environment_.FastForwardBy(
           AndroidSmsAppSetupControllerImpl::kInstallRetryDelay *
           (1 << retry_count));
     }

     // Send success code for last attempt.
     SetInstallResultCode(webapps::InstallResultCode::kSuccessNewInstall);
     task_environment_.FastForwardBy(
         AndroidSmsAppSetupControllerImpl::kInstallRetryDelay *
         (1 << (num_failure_tries - 1)));

     if (last_set_up_app_result_ && *last_set_up_app_result_) {
       histogram_tester.ExpectBucketCount(
           "AndroidSms.NumAttemptsForSuccessfulInstallation",
           num_failure_tries + 1, 1);
     }
     histogram_tester.ExpectBucketCount(
         "AndroidSms.EffectivePWAInstallationSuccess", expected_setup_result, 1);

     EXPECT_EQ(last_set_up_app_result_, expected_setup_result);
     last_set_up_app_result_.reset();
   }

   void CallSetUpApp(const GURL& app_url,
                     const GURL& install_url,
                     size_t num_expected_app_installs) {
     const auto& install_requests =
         fake_externally_managed_app_manager().install_requests();
     size_t num_install_requests_before_call = install_requests.size();

     base::RunLoop run_loop;
     base::HistogramTester histogram_tester;

     setup_controller_->SetUpApp(
         app_url, install_url,
         base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnSetUpAppResult,
                        base::Unretained(this), run_loop.QuitClosure()));

     fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
         "default_to_persist" /* expected_cookie_name */,
         "true" /* expected_cookie_value */,
         GURL("https://" + app_url.host()) /* expected_source_url */,
         false /* expected_modify_http_only */,
         net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
         true /* success */);

     fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
         app_url, "cros_migrated_to" /* expected_cookie_name */,
         true /* success */);
     base::RunLoop().RunUntilIdle();

     // If the PWA was not already installed at the URL, SetUpApp() should
     // install it.
     if (!test_pwa_delegate_->GetPwaForUrl(install_url, &profile_)) {
       EXPECT_EQ(num_install_requests_before_call + 1u, install_requests.size());
       EXPECT_EQ(GetInstallOptionsForUrl(install_url), install_requests.back());

       EXPECT_EQ(ContentSetting::CONTENT_SETTING_ALLOW,
                 GetNotificationSetting(app_url));
     }

     if (num_expected_app_installs) {
       histogram_tester.ExpectBucketCount(
           "AndroidSms.PWAInstallationResult",
           webapps::InstallResultCode::kSuccessNewInstall,
           num_expected_app_installs);
       histogram_tester.ExpectBucketCount(
           "AndroidSms.EffectivePWAInstallationSuccess", true, 1);
     }

     run_loop.Run();
     EXPECT_TRUE(*last_set_up_app_result_);
     last_set_up_app_result_.reset();
   }

   void CallDeleteRememberDeviceByDefaultCookie(const GURL& app_url) {
     base::RunLoop run_loop;

     setup_controller_->DeleteRememberDeviceByDefaultCookie(
         app_url,
         base::BindOnce(&AndroidSmsAppSetupControllerImplTest::
                            OnDeleteRememberDeviceByDefaultCookieResult,
                        base::Unretained(this), run_loop.QuitClosure()));

     fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
         app_url, "default_to_persist" /* expected_cookie_name */,
         true /* success */);

     run_loop.Run();
     EXPECT_TRUE(*last_delete_cookie_result_);
     last_delete_cookie_result_.reset();
   }

   void CallRemoveApp(const GURL& app_url,
                      const GURL& install_url,
                      const GURL& migrated_to_app_url,
                      size_t num_expected_app_uninstalls) {
     base::RunLoop run_loop;
     base::HistogramTester histogram_tester;

     bool was_installed =
         test_pwa_delegate_->GetPwaForUrl(install_url, &profile_).has_value();
     setup_controller_->RemoveApp(
         app_url, install_url, migrated_to_app_url,
         base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnRemoveAppResult,
                        base::Unretained(this), run_loop.QuitClosure()));
     base::RunLoop().RunUntilIdle();

     // If the PWA was already installed at the URL, RemoveApp() should uninstall
     // the it.
     if (was_installed) {
       EXPECT_FALSE(test_pwa_delegate()->GetPwaForUrl(install_url, &profile_));

       fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
           "cros_migrated_to" /* expected_cookie_name */,
           migrated_to_app_url.GetContent() /* expected_cookie_value */,
           GURL("https://" + app_url.host()) /* expected_source_url */,
           false /* expected_modify_http_only */,
           net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
           true /* success */);

       fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
           app_url, "default_to_persist" /* expected_cookie_name */,
           true /* success */);
       base::RunLoop().RunUntilIdle();
     }

     if (num_expected_app_uninstalls) {
       histogram_tester.ExpectBucketCount("AndroidSms.PWAUninstallationResult",
                                          true, num_expected_app_uninstalls);
     }

     run_loop.Run();
     EXPECT_TRUE(*last_remove_app_result_);
     last_remove_app_result_.reset();
   }

   TestPwaDelegate* test_pwa_delegate() { return test_pwa_delegate_; }

   void SetInstallResultCode(webapps::InstallResultCode result_code) {
     install_result_code_ = result_code;
   }

   web_app::FakeExternallyManagedAppManager&
   fake_externally_managed_app_manager() {
     return static_cast<web_app::FakeExternallyManagedAppManager&>(
         provider_->externally_managed_app_manager());
   }

  private:
   ContentSetting GetNotificationSetting(const GURL& url) {
     return host_content_settings_map_->GetContentSetting(
         url, GURL() /* top_level_url */, ContentSettingsType::NOTIFICATIONS);
   }

   void OnSetUpAppResult(base::OnceClosure quit_closure, bool success) {
     EXPECT_FALSE(last_set_up_app_result_);
     last_set_up_app_result_ = success;
     std::move(quit_closure).Run();
   }

   void OnDeleteRememberDeviceByDefaultCookieResult(
       base::OnceClosure quit_closure,
       bool success) {
     EXPECT_FALSE(last_delete_cookie_result_);
     last_delete_cookie_result_ = success;
     std::move(quit_closure).Run();
   }

   void OnRemoveAppResult(base::OnceClosure quit_closure, bool success) {
     EXPECT_FALSE(last_remove_app_result_);
     last_remove_app_result_ = success;
     std::move(quit_closure).Run();
   }

   webapps::InstallResultCode install_result_code_ =
       webapps::InstallResultCode::kSuccessNewInstall;

   content::BrowserTaskEnvironment task_environment_;

   std::optional<bool> last_set_up_app_result_;
   std::optional<bool> last_delete_cookie_result_;
   std::optional<bool> last_remove_app_result_;

   raw_ptr<web_app::FakeWebAppProvider, DanglingUntriaged> provider_;

   TestingProfile profile_;
   raw_ptr<HostContentSettingsMap> host_content_settings_map_;
   std::unique_ptr<FakeCookieManager> fake_cookie_manager_;
   raw_ptr<TestPwaDelegate, DanglingUntriaged> test_pwa_delegate_;
   std::unique_ptr<AndroidSmsAppSetupController> setup_controller_;
 };

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_NoPreviousApp) {
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                1u /* num_expected_app_installs */);
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_AppAlreadyInstalled) {
   // Start with a PWA already installed at the URL.
   test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                0u /* num_expected_app_installs */);
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_OtherPwaInstalled) {
   // Start with a PWA already installed at a different URL.
   test_pwa_delegate()->SetHasPwa(GURL(kTestUrl2));
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                1u /* num_expected_app_installs */);
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpAppThenDeleteCookie) {
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                1u /* num_expected_app_installs */);
   CallDeleteRememberDeviceByDefaultCookie(GURL(kTestUrl1));
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_Retry) {
   // Setup should fail when all attempts fail.
   CallSetUpAppWithRetries(
       GURL(kTestUrl1), GURL(kTestInstallUrl1),
       AndroidSmsAppSetupControllerImpl::kMaxInstallRetryCount +
           1 /* num_failure_tries*/,
       false /* expected_setup_result */);

   // Setup should succeed when the last attempt succeeds.
   CallSetUpAppWithRetries(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                           AndroidSmsAppSetupControllerImpl::
                               kMaxInstallRetryCount /* num_failure_tries*/,
                           true /* expected_setup_result */);

   // Setup should succeed when only fewer than max attempts fail.
   CallSetUpAppWithRetries(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                           1 /* num_failure_tries*/,
                           true /* expected_setup_result */);
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpAppThenRemove) {
   // Install and remove.
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                1u /* num_expected_app_installs */);
   test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
   CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                 GURL(kTestUrl2) /* migrated_to_app_url */,
                 1u /* num_expected_app_uninstalls */);

   // Repeat once more.
   CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                1u /* num_expected_app_installs */);
   test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
   CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                 GURL(kTestUrl2) /* migrated_to_app_url */,
                 1u /* num_expected_app_uninstalls */);
 }

 TEST_F(AndroidSmsAppSetupControllerImplTest, RemoveApp_NoInstalledApp) {
   // Do not have an installed app before attempting to remove it.
   CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
                 GURL(kTestUrl2) /* migrated_to_app_url */,
                 0u /* num_expected_app_uninstalls */);
 }

 }  // namespace android_sms
 }  // namespace ash
	// Copyright 2018 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/ash/android_sms/android_sms_app_setup_controller_impl.h"

	#include <memory>
	#include <string>
	#include <tuple>
	#include <utility>
	#include <vector>

	#include "base/containers/contains.h"
	#include "base/containers/flat_map.h"
	#include "base/files/file_path.h"
	#include "base/functional/bind.h"
	#include "base/memory/ptr_util.h"
	#include "base/memory/raw_ptr.h"
	#include "base/memory/ref_counted.h"
	#include "base/path_service.h"
	#include "base/run_loop.h"
	#include "base/test/bind.h"
	#include "base/test/metrics/histogram_tester.h"
	#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
	#include "chrome/browser/web_applications/external_install_options.h"
	#include "chrome/browser/web_applications/mojom/user_display_mode.mojom.h"
	#include "chrome/browser/web_applications/test/fake_externally_managed_app_manager.h"
	#include "chrome/browser/web_applications/test/fake_web_app_provider.h"
	#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
	#include "chrome/browser/web_applications/web_app_helpers.h"
	#include "chrome/test/base/testing_profile.h"
	#include "components/content_settings/core/browser/host_content_settings_map.h"
	#include "components/webapps/browser/install_result_code.h"
	#include "content/public/test/browser_task_environment.h"
	#include "services/network/test/test_cookie_manager.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/public/mojom/manifest/display_mode.mojom.h"

	namespace ash {
	namespace android_sms {

	namespace {

	const char kTestUrl1[] = "https://test-url-1.com/";
	const char kTestInstallUrl1[] = "https://test-url-1.com/install";
	const char kTestUrl2[] = "https://test-url-2.com/";

	web_app::ExternalInstallOptions GetInstallOptionsForUrl(const GURL& url) {
	web_app::ExternalInstallOptions options(
	url, web_app::mojom::UserDisplayMode::kStandalone,
	web_app::ExternalInstallSource::kInternalDefault);
	options.override_previous_user_uninstall = true;
	options.require_manifest = true;
	return options;
	}

	class FakeCookieManager : public network::TestCookieManager {
	public:
	FakeCookieManager() = default;
	~FakeCookieManager() override {
	EXPECT_TRUE(set_canonical_cookie_calls_.empty());
	EXPECT_TRUE(delete_cookies_calls_.empty());
	}

	void InvokePendingSetCanonicalCookieCallback(
	const std::string& expected_cookie_name,
	const std::string& expected_cookie_value,
	const GURL& expected_source_url,
	bool expected_modify_http_only,
	net::CookieOptions::SameSiteCookieContext expect_same_site_context,
	bool success) {
	ASSERT_FALSE(set_canonical_cookie_calls_.empty());
	auto params = std::move(set_canonical_cookie_calls_.front());
	set_canonical_cookie_calls_.erase(set_canonical_cookie_calls_.begin());

	EXPECT_EQ(expected_cookie_name, std::get<0>(params).Name());
	EXPECT_EQ(expected_cookie_value, std::get<0>(params).Value());
	EXPECT_EQ(expected_source_url, std::get<1>(params));
	EXPECT_EQ(expected_modify_http_only,
	!std::get<2>(params).exclude_httponly());
	EXPECT_EQ(expect_same_site_context,
	std::get<2>(params).same_site_cookie_context());
	net::CookieAccessResult access_result;

	if (!success) {
	access_result.status.AddExclusionReason(
	net::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR);
	}

	std::move(std::get<3>(params)).Run(access_result);
	}

	void InvokePendingDeleteCookiesCallback(
	const GURL& expected_url,
	const std::string& expected_cookie_name,
	bool success) {
	ASSERT_FALSE(delete_cookies_calls_.empty());
	auto params = std::move(delete_cookies_calls_.front());
	delete_cookies_calls_.erase(delete_cookies_calls_.begin());

	EXPECT_EQ(expected_url, params.first->url);
	EXPECT_EQ(expected_cookie_name, params.first->cookie_name);

	std::move(params.second).Run(success);
	}

	// network::mojom::CookieManager
	void SetCanonicalCookie(const net::CanonicalCookie& cookie,
	const GURL& source_url,
	const net::CookieOptions& options,
	SetCanonicalCookieCallback callback) override {
	set_canonical_cookie_calls_.emplace_back(cookie, source_url, options,
	std::move(callback));
	}

	void DeleteCookies(network::mojom::CookieDeletionFilterPtr filter,
	DeleteCookiesCallback callback) override {
	delete_cookies_calls_.emplace_back(std::move(filter), std::move(callback));
	}

	private:
	std::vector<std::tuple<net::CanonicalCookie,
	GURL,
	net::CookieOptions,
	SetCanonicalCookieCallback>>
	set_canonical_cookie_calls_;
	std::vector<
	std::pair<network::mojom::CookieDeletionFilterPtr, DeleteCookiesCallback>>
	delete_cookies_calls_;
	};

	} // namespace

	class AndroidSmsAppSetupControllerImplTest : public testing::Test {
	public:
	AndroidSmsAppSetupControllerImplTest(
	const AndroidSmsAppSetupControllerImplTest&) = delete;
	AndroidSmsAppSetupControllerImplTest& operator=(
	const AndroidSmsAppSetupControllerImplTest&) = delete;

	protected:
	class TestPwaDelegate : public AndroidSmsAppSetupControllerImpl::PwaDelegate {
	public:
	explicit TestPwaDelegate(FakeCookieManager* fake_cookie_manager)
	: fake_cookie_manager_(fake_cookie_manager) {}
	~TestPwaDelegate() override = default;

	void SetHasPwa(const GURL& url) {
	// If a PWA already exists for this URL, there is nothing to do.
	if (base::Contains(url_to_pwa_map_, url))
	return;

	url_to_pwa_map_[url] =
	web_app::GenerateAppId(/manifest_id=/std::nullopt, url);
	}

	// AndroidSmsAppSetupControllerImpl::PwaDelegate:
	std::optional<webapps::AppId> GetPwaForUrl(const GURL& install_url,
	Profile* profile) override {
	if (!base::Contains(url_to_pwa_map_, install_url))
	return std::nullopt;

	return url_to_pwa_map_[install_url];
	}

	network::mojom::CookieManager* GetCookieManager(Profile* profile) override {
	return fake_cookie_manager_;
	}

	void RemovePwa(
	const webapps::AppId& app_id,
	Profile* profile,
	AndroidSmsAppSetupController::SuccessCallback callback) override {
	for (const auto& url_pwa_pair : url_to_pwa_map_) {
	if (url_pwa_pair.second == app_id) {
	url_to_pwa_map_.erase(url_pwa_pair.first);
	std::move(callback).Run(true);
	return;
	}
	}

	std::move(callback).Run(false);
	}

	private:
	raw_ptr<FakeCookieManager> fake_cookie_manager_;
	base::flat_map<GURL, webapps::AppId> url_to_pwa_map_;
	};

	AndroidSmsAppSetupControllerImplTest()
	: task_environment_(
	content::BrowserTaskEnvironment::TimeSource::MOCK_TIME),
	host_content_settings_map_(
	HostContentSettingsMapFactory::GetForProfile(&profile_)) {}

	~AndroidSmsAppSetupControllerImplTest() override = default;

	// testing::Test:
	void SetUp() override {
	host_content_settings_map_->ClearSettingsForOneType(
	ContentSettingsType::NOTIFICATIONS);
	fake_cookie_manager_ = std::make_unique<FakeCookieManager>();
	auto test_pwa_delegate =
	std::make_unique<TestPwaDelegate>(fake_cookie_manager_.get());
	test_pwa_delegate_ = test_pwa_delegate.get();

	provider_ = web_app::FakeWebAppProvider::Get(&profile_);
	web_app::test::AwaitStartWebAppProviderAndSubsystems(&profile_);

	fake_externally_managed_app_manager().SetHandleInstallRequestCallback(
	base::BindLambdaForTesting(
	[this](const web_app::ExternalInstallOptions& install_options) {
	return web_app::ExternallyManagedAppManager::InstallResult(
	install_result_code_);
	}));

	setup_controller_ = base::WrapUnique(new AndroidSmsAppSetupControllerImpl(
	&profile_, &fake_externally_managed_app_manager(),
	host_content_settings_map_));

	std::unique_ptr<AndroidSmsAppSetupControllerImpl::PwaDelegate>
	base_delegate(test_pwa_delegate.release());

	static_cast<AndroidSmsAppSetupControllerImpl*>(setup_controller_.get())
	->SetPwaDelegateForTesting(std::move(base_delegate));
	}

	void CallSetUpAppWithRetries(const GURL& app_url,
	const GURL& install_url,
	size_t num_failure_tries,
	bool expected_setup_result) {
	const auto& install_requests =
	fake_externally_managed_app_manager().install_requests();
	size_t num_install_requests_before_call = install_requests.size();

	base::RunLoop run_loop;
	base::HistogramTester histogram_tester;

	SetInstallResultCode(
	webapps::InstallResultCode::kGetWebAppInstallInfoFailed);

	setup_controller_->SetUpApp(
	app_url, install_url,
	base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnSetUpAppResult,
	base::Unretained(this), run_loop.QuitClosure()));

	fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
	"default_to_persist" /* expected_cookie_name */,
	"true" /* expected_cookie_value */,
	GURL("https://" + app_url.host()) /* expected_source_url */,
	false /* expected_modify_http_only */,
	net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
	true /* success */);

	fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
	app_url, "cros_migrated_to" /* expected_cookie_name */,
	true /* success */);

	base::RunLoop().RunUntilIdle();

	// Fast forward through remaining attempts.
	for (size_t retry_count = 0; retry_count < num_failure_tries - 1;
	retry_count++) {
	EXPECT_NE(ContentSetting::CONTENT_SETTING_ALLOW,
	GetNotificationSetting(app_url));
	EXPECT_EQ(num_install_requests_before_call + retry_count + 1u,
	install_requests.size());
	EXPECT_EQ(GetInstallOptionsForUrl(install_url), install_requests.back());

	task_environment_.FastForwardBy(
	AndroidSmsAppSetupControllerImpl::kInstallRetryDelay *
	(1 << retry_count));
	}

	// Send success code for last attempt.
	SetInstallResultCode(webapps::InstallResultCode::kSuccessNewInstall);
	task_environment_.FastForwardBy(
	AndroidSmsAppSetupControllerImpl::kInstallRetryDelay *
	(1 << (num_failure_tries - 1)));

	if (last_set_up_app_result_ && *last_set_up_app_result_) {
	histogram_tester.ExpectBucketCount(
	"AndroidSms.NumAttemptsForSuccessfulInstallation",
	num_failure_tries + 1, 1);
	}
	histogram_tester.ExpectBucketCount(
	"AndroidSms.EffectivePWAInstallationSuccess", expected_setup_result, 1);

	EXPECT_EQ(last_set_up_app_result_, expected_setup_result);
	last_set_up_app_result_.reset();
	}

	void CallSetUpApp(const GURL& app_url,
	const GURL& install_url,
	size_t num_expected_app_installs) {
	const auto& install_requests =
	fake_externally_managed_app_manager().install_requests();
	size_t num_install_requests_before_call = install_requests.size();

	base::RunLoop run_loop;
	base::HistogramTester histogram_tester;

	setup_controller_->SetUpApp(
	app_url, install_url,
	base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnSetUpAppResult,
	base::Unretained(this), run_loop.QuitClosure()));

	fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
	"default_to_persist" /* expected_cookie_name */,
	"true" /* expected_cookie_value */,
	GURL("https://" + app_url.host()) /* expected_source_url */,
	false /* expected_modify_http_only */,
	net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
	true /* success */);

	fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
	app_url, "cros_migrated_to" /* expected_cookie_name */,
	true /* success */);
	base::RunLoop().RunUntilIdle();

	// If the PWA was not already installed at the URL, SetUpApp() should
	// install it.
	if (!test_pwa_delegate_->GetPwaForUrl(install_url, &profile_)) {
	EXPECT_EQ(num_install_requests_before_call + 1u, install_requests.size());
	EXPECT_EQ(GetInstallOptionsForUrl(install_url), install_requests.back());

	EXPECT_EQ(ContentSetting::CONTENT_SETTING_ALLOW,
	GetNotificationSetting(app_url));
	}

	if (num_expected_app_installs) {
	histogram_tester.ExpectBucketCount(
	"AndroidSms.PWAInstallationResult",
	webapps::InstallResultCode::kSuccessNewInstall,
	num_expected_app_installs);
	histogram_tester.ExpectBucketCount(
	"AndroidSms.EffectivePWAInstallationSuccess", true, 1);
	}

	run_loop.Run();
	EXPECT_TRUE(*last_set_up_app_result_);
	last_set_up_app_result_.reset();
	}

	void CallDeleteRememberDeviceByDefaultCookie(const GURL& app_url) {
	base::RunLoop run_loop;

	setup_controller_->DeleteRememberDeviceByDefaultCookie(
	app_url,
	base::BindOnce(&AndroidSmsAppSetupControllerImplTest::
	OnDeleteRememberDeviceByDefaultCookieResult,
	base::Unretained(this), run_loop.QuitClosure()));

	fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
	app_url, "default_to_persist" /* expected_cookie_name */,
	true /* success */);

	run_loop.Run();
	EXPECT_TRUE(*last_delete_cookie_result_);
	last_delete_cookie_result_.reset();
	}

	void CallRemoveApp(const GURL& app_url,
	const GURL& install_url,
	const GURL& migrated_to_app_url,
	size_t num_expected_app_uninstalls) {
	base::RunLoop run_loop;
	base::HistogramTester histogram_tester;

	bool was_installed =
	test_pwa_delegate_->GetPwaForUrl(install_url, &profile_).has_value();
	setup_controller_->RemoveApp(
	app_url, install_url, migrated_to_app_url,
	base::BindOnce(&AndroidSmsAppSetupControllerImplTest::OnRemoveAppResult,
	base::Unretained(this), run_loop.QuitClosure()));
	base::RunLoop().RunUntilIdle();

	// If the PWA was already installed at the URL, RemoveApp() should uninstall
	// the it.
	if (was_installed) {
	EXPECT_FALSE(test_pwa_delegate()->GetPwaForUrl(install_url, &profile_));

	fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
	"cros_migrated_to" /* expected_cookie_name */,
	migrated_to_app_url.GetContent() /* expected_cookie_value */,
	GURL("https://" + app_url.host()) /* expected_source_url */,
	false /* expected_modify_http_only */,
	net::CookieOptions::SameSiteCookieContext::MakeInclusive(),
	true /* success */);

	fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
	app_url, "default_to_persist" /* expected_cookie_name */,
	true /* success */);
	base::RunLoop().RunUntilIdle();
	}

	if (num_expected_app_uninstalls) {
	histogram_tester.ExpectBucketCount("AndroidSms.PWAUninstallationResult",
	true, num_expected_app_uninstalls);
	}

	run_loop.Run();
	EXPECT_TRUE(*last_remove_app_result_);
	last_remove_app_result_.reset();
	}

	TestPwaDelegate* test_pwa_delegate() { return test_pwa_delegate_; }

	void SetInstallResultCode(webapps::InstallResultCode result_code) {
	install_result_code_ = result_code;
	}

	web_app::FakeExternallyManagedAppManager&
	fake_externally_managed_app_manager() {
	return static_cast<web_app::FakeExternallyManagedAppManager&>(
	provider_->externally_managed_app_manager());
	}

	private:
	ContentSetting GetNotificationSetting(const GURL& url) {
	return host_content_settings_map_->GetContentSetting(
	url, GURL() /* top_level_url */, ContentSettingsType::NOTIFICATIONS);
	}

	void OnSetUpAppResult(base::OnceClosure quit_closure, bool success) {
	EXPECT_FALSE(last_set_up_app_result_);
	last_set_up_app_result_ = success;
	std::move(quit_closure).Run();
	}

	void OnDeleteRememberDeviceByDefaultCookieResult(
	base::OnceClosure quit_closure,
	bool success) {
	EXPECT_FALSE(last_delete_cookie_result_);
	last_delete_cookie_result_ = success;
	std::move(quit_closure).Run();
	}

	void OnRemoveAppResult(base::OnceClosure quit_closure, bool success) {
	EXPECT_FALSE(last_remove_app_result_);
	last_remove_app_result_ = success;
	std::move(quit_closure).Run();
	}

	webapps::InstallResultCode install_result_code_ =
	webapps::InstallResultCode::kSuccessNewInstall;

	content::BrowserTaskEnvironment task_environment_;

	std::optional<bool> last_set_up_app_result_;
	std::optional<bool> last_delete_cookie_result_;
	std::optional<bool> last_remove_app_result_;

	raw_ptr<web_app::FakeWebAppProvider, DanglingUntriaged> provider_;

	TestingProfile profile_;
	raw_ptr<HostContentSettingsMap> host_content_settings_map_;
	std::unique_ptr<FakeCookieManager> fake_cookie_manager_;
	raw_ptr<TestPwaDelegate, DanglingUntriaged> test_pwa_delegate_;
	std::unique_ptr<AndroidSmsAppSetupController> setup_controller_;
	};

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_NoPreviousApp) {
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1u /* num_expected_app_installs */);
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_AppAlreadyInstalled) {
	// Start with a PWA already installed at the URL.
	test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	0u /* num_expected_app_installs */);
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_OtherPwaInstalled) {
	// Start with a PWA already installed at a different URL.
	test_pwa_delegate()->SetHasPwa(GURL(kTestUrl2));
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1u /* num_expected_app_installs */);
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpAppThenDeleteCookie) {
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1u /* num_expected_app_installs */);
	CallDeleteRememberDeviceByDefaultCookie(GURL(kTestUrl1));
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpApp_Retry) {
	// Setup should fail when all attempts fail.
	CallSetUpAppWithRetries(
	GURL(kTestUrl1), GURL(kTestInstallUrl1),
	AndroidSmsAppSetupControllerImpl::kMaxInstallRetryCount +
	1 /* num_failure_tries*/,
	false /* expected_setup_result */);

	// Setup should succeed when the last attempt succeeds.
	CallSetUpAppWithRetries(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	AndroidSmsAppSetupControllerImpl::
	kMaxInstallRetryCount /* num_failure_tries*/,
	true /* expected_setup_result */);

	// Setup should succeed when only fewer than max attempts fail.
	CallSetUpAppWithRetries(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1 /* num_failure_tries*/,
	true /* expected_setup_result */);
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, SetUpAppThenRemove) {
	// Install and remove.
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1u /* num_expected_app_installs */);
	test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
	CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	GURL(kTestUrl2) /* migrated_to_app_url */,
	1u /* num_expected_app_uninstalls */);

	// Repeat once more.
	CallSetUpApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	1u /* num_expected_app_installs */);
	test_pwa_delegate()->SetHasPwa(GURL(kTestInstallUrl1));
	CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	GURL(kTestUrl2) /* migrated_to_app_url */,
	1u /* num_expected_app_uninstalls */);
	}

	TEST_F(AndroidSmsAppSetupControllerImplTest, RemoveApp_NoInstalledApp) {
	// Do not have an installed app before attempting to remove it.
	CallRemoveApp(GURL(kTestUrl1), GURL(kTestInstallUrl1),
	GURL(kTestUrl2) /* migrated_to_app_url */,
	0u /* num_expected_app_uninstalls */);
	}

	} // namespace android_sms
	} // namespace ash