[Multidevice] Add default-to-persist cookie logic in PWA installation

This CL adds logic to set a default-to-persist cookie that will force
the messages PWA to default to persisting the pairing. Also fixes issue
with PWA installing unexpectedly when disabling features.

Bug: 896057,900799
Change-Id: I77354ecbbccf69e1b9a97e1bcff82bccaeeb44b1
Reviewed-on: https://chromium-review.googlesource.com/c/1312305Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Jeremy Klein <jlklein@chromium.org>
Commit-Queue: Azeem Arshad <azeemarshad@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606319}

chrome/browser/chromeos/multidevice_setup/android_sms_app_helper_delegate_impl.cc

@@ -21,9 +21,23 @@
 #include "chromeos/components/proximity_auth/logging/logging.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
+#include "content/public/browser/storage_partition.h"
 #include "extensions/common/constants.h"
 #include "ui/base/window_open_disposition.h"
 
+namespace {
+const char kDefaultToPersistCookieName[] = "default_to_persist";
+const char kDefaultToPersistCookieValue[] = "true";
+
+network::mojom::CookieManager* GetCookieManager(Profile* profile) {
+  content::StoragePartition* partition =
+      content::BrowserContext::GetStoragePartitionForSite(
+          profile, chromeos::android_sms::GetAndroidMessagesURL());
+  return partition->GetCookieManagerForBrowserProcess();
+}
+
+}  // namespace
+
 namespace chromeos {
 
 namespace multidevice_setup {
@@ -35,19 +49,45 @@ AndroidSmsAppHelperDelegateImpl::AndroidSmsAppHelperDelegateImpl(
       profile_(profile),
       host_content_settings_map_(
           HostContentSettingsMapFactory::GetForProfile(profile)),
+      cookie_manager_(GetCookieManager(profile)),
       weak_ptr_factory_(this) {}
 
 AndroidSmsAppHelperDelegateImpl::AndroidSmsAppHelperDelegateImpl(
     web_app::PendingAppManager* pending_app_manager,
-    HostContentSettingsMap* host_content_settings_map)
+    HostContentSettingsMap* host_content_settings_map,
+    network::mojom::CookieManager* cookie_manager)
     : pending_app_manager_(pending_app_manager),
       host_content_settings_map_(host_content_settings_map),
+      cookie_manager_(cookie_manager),
       weak_ptr_factory_(this) {}
 
 AndroidSmsAppHelperDelegateImpl::~AndroidSmsAppHelperDelegateImpl() = default;
 
-void AndroidSmsAppHelperDelegateImpl::InstallAndroidSmsApp(
+void AndroidSmsAppHelperDelegateImpl::SetUpAndroidSmsApp(
     bool launch_on_install) {
+  PA_LOG(INFO) << "Setting DefaultToPersist Cookie";
+  cookie_manager_->SetCanonicalCookie(
+      *net::CanonicalCookie::CreateSanitizedCookie(
+          chromeos::android_sms::GetAndroidMessagesURL(),
+          kDefaultToPersistCookieName, kDefaultToPersistCookieValue,
+          std::string() /* domain */, std::string() /* path */,
+          base::Time::Now() /* creation_time */,
+          base::Time() /* expiration_time */,
+          base::Time::Now() /* last_access_time */, true /* secure */,
+          false /* http_only */, net::CookieSameSite::STRICT_MODE,
+          net::COOKIE_PRIORITY_DEFAULT),
+      true /* secure_source */, false /* modify_http_only */,
+      base::BindOnce(&AndroidSmsAppHelperDelegateImpl::
+                         OnSetDefaultToPersistCookieForInstall,
+                     weak_ptr_factory_.GetWeakPtr(), launch_on_install));
+}
+
+void AndroidSmsAppHelperDelegateImpl::OnSetDefaultToPersistCookieForInstall(
+    bool launch_on_install,
+    bool set_cookie_success) {
+  if (!set_cookie_success)
+    PA_LOG(WARNING) << "Failed to set default to persist cookie";
+
   // TODO(crbug.com/874605): Consider retries and error handling here. This call
   // can easily fail.
   pending_app_manager_->Install(
@@ -63,17 +103,17 @@ void AndroidSmsAppHelperDelegateImpl::InstallAndroidSmsApp(
                      weak_ptr_factory_.GetWeakPtr(), launch_on_install));
 }
 
-void AndroidSmsAppHelperDelegateImpl::InstallAndroidSmsApp() {
-  InstallAndroidSmsApp(false /* launch_on_install */);
+void AndroidSmsAppHelperDelegateImpl::SetUpAndroidSmsApp() {
+  SetUpAndroidSmsApp(false /* launch_on_install */);
 }
 
-void AndroidSmsAppHelperDelegateImpl::InstallAndLaunchAndroidSmsApp() {
+void AndroidSmsAppHelperDelegateImpl::SetUpAndLaunchAndroidSmsApp() {
   const extensions::Extension* android_sms_pwa =
       extensions::util::GetInstalledPwaForUrl(
           profile_, chromeos::android_sms::GetAndroidMessagesURL());
   if (!android_sms_pwa) {
     PA_LOG(VERBOSE) << "No Messages app found. Installing it.";
-    InstallAndroidSmsApp(true /* launch_on_install */);
+    SetUpAndroidSmsApp(true /* launch_on_install */);
     return;
   }
 
@@ -118,6 +158,15 @@ void AndroidSmsAppHelperDelegateImpl::OnAppInstalled(
   }
 }
 
+void AndroidSmsAppHelperDelegateImpl::TearDownAndroidSmsApp() {
+  PA_LOG(INFO) << "Clearing DefaultToPersist Cookie";
+  network::mojom::CookieDeletionFilterPtr filter(
+      network::mojom::CookieDeletionFilter::New());
+  filter->url = chromeos::android_sms::GetAndroidMessagesURL();
+  filter->cookie_name = kDefaultToPersistCookieName;
+  cookie_manager_->DeleteCookies(std::move(filter), base::DoNothing());
+}
+
 }  // namespace multidevice_setup
 
 }  // namespace chromeos

chrome/browser/chromeos/multidevice_setup/android_sms_app_helper_delegate_impl.h

@@ -11,6 +11,7 @@
 #include "base/memory/weak_ptr.h"
 #include "chromeos/services/multidevice_setup/public/cpp/android_sms_app_helper_delegate.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "services/network/public/mojom/cookie_manager.mojom.h"
 #include "url/gurl.h"
 
 class Profile;
@@ -37,21 +38,26 @@ class AndroidSmsAppHelperDelegateImpl : public AndroidSmsAppHelperDelegate {
   // function are added. See https://crbug.com/876972.
   AndroidSmsAppHelperDelegateImpl(
       web_app::PendingAppManager* pending_app_manager,
-      HostContentSettingsMap* host_content_settings_map);
+      HostContentSettingsMap* host_content_settings_map,
+      network::mojom::CookieManager* cookie_manager);
   void OnAppInstalled(bool launch_on_install,
                       const GURL& app_url,
                       web_app::InstallResultCode code);
-  void InstallAndroidSmsApp(bool launch_on_install);
+  void SetUpAndroidSmsApp(bool launch_on_install);
   void LaunchAndroidSmsApp();
+  void OnSetDefaultToPersistCookieForInstall(bool launch_on_install,
+                                             bool set_cookie_success);
 
   // AndroidSmsAppHelperDelegate:
-  void InstallAndroidSmsApp() override;
-  void InstallAndLaunchAndroidSmsApp() override;
+  void SetUpAndroidSmsApp() override;
+  void SetUpAndLaunchAndroidSmsApp() override;
+  void TearDownAndroidSmsApp() override;
 
   static const char kMessagesWebAppUrl[];
   web_app::PendingAppManager* pending_app_manager_;
   Profile* profile_;
   HostContentSettingsMap* host_content_settings_map_;
+  network::mojom::CookieManager* cookie_manager_;
   base::WeakPtrFactory<AndroidSmsAppHelperDelegateImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AndroidSmsAppHelperDelegateImpl);

chrome/browser/chromeos/multidevice_setup/android_sms_app_helper_delegate_impl_unittest.cc

@@ -20,6 +20,62 @@
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+class FakeCookieManager : public network::mojom::CookieManager {
+ public:
+  const std::vector<std::tuple<net::CanonicalCookie, bool, bool>>&
+  set_canonical_cookie_calls() {
+    return set_canonical_cookie_calls_;
+  }
+
+  const std::vector<network::mojom::CookieDeletionFilterPtr>&
+  delete_cookies_calls() {
+    return delete_cookies_calls_;
+  }
+
+  // network::mojom::CookieManager
+  void SetCanonicalCookie(const net::CanonicalCookie& cookie,
+                          bool secure_source,
+                          bool modify_http_only,
+                          SetCanonicalCookieCallback callback) override {
+    set_canonical_cookie_calls_.push_back(
+        std::make_tuple(cookie, secure_source, modify_http_only));
+    std::move(callback).Run(true);
+  }
+
+  void DeleteCookies(network::mojom::CookieDeletionFilterPtr filter,
+                     DeleteCookiesCallback callback) override {
+    delete_cookies_calls_.push_back(std::move(filter));
+    std::move(callback).Run(1);
+  }
+
+  void GetAllCookies(GetAllCookiesCallback callback) override {}
+  void GetCookieList(const GURL& url,
+                     const net::CookieOptions& cookie_options,
+                     GetCookieListCallback callback) override {}
+  void DeleteCanonicalCookie(const net::CanonicalCookie& cookie,
+                             DeleteCanonicalCookieCallback callback) override {}
+  void AddCookieChangeListener(
+      const GURL& url,
+      const std::string& name,
+      network::mojom::CookieChangeListenerPtr listener) override {}
+  void AddGlobalChangeListener(
+      network::mojom::CookieChangeListenerPtr notification_pointer) override {}
+  void CloneInterface(
+      network::mojom::CookieManagerRequest new_interface) override {}
+  void FlushCookieStore(FlushCookieStoreCallback callback) override {}
+  void SetContentSettings(
+      const std::vector<::ContentSettingPatternSource>& settings) override {}
+  void SetForceKeepSessionState() override {}
+  void BlockThirdPartyCookies(bool block) override {}
+
+ private:
+  std::vector<std::tuple<net::CanonicalCookie, bool, bool>>
+      set_canonical_cookie_calls_;
+  std::vector<network::mojom::CookieDeletionFilterPtr> delete_cookies_calls_;
+};
+}  // namespace
+
 namespace chromeos {
 
 namespace multidevice_setup {
@@ -38,21 +94,29 @@ class AndroidSmsAppHelperDelegateImplTest : public testing::Test {
         ContentSettingsType::CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
     test_pending_app_manager_ =
         std::make_unique<web_app::TestPendingAppManager>();
+    fake_cookie_manager_ = std::make_unique<FakeCookieManager>();
     android_sms_app_helper_delegate_ =
         base::WrapUnique(new AndroidSmsAppHelperDelegateImpl(
-            test_pending_app_manager_.get(), host_content_settings_map_));
+            test_pending_app_manager_.get(), host_content_settings_map_,
+            fake_cookie_manager_.get()));
   }
 
   web_app::TestPendingAppManager* test_pending_app_manager() {
     return test_pending_app_manager_.get();
   }
 
-  void InstallApp() {
-    android_sms_app_helper_delegate_->InstallAndroidSmsApp();
+  FakeCookieManager* fake_cookie_manager() {
+    return fake_cookie_manager_.get();
   }
 
-  void InstallAndLaunchApp() {
-    android_sms_app_helper_delegate_->InstallAndLaunchAndroidSmsApp();
+  void SetUpApp() { android_sms_app_helper_delegate_->SetUpAndroidSmsApp(); }
+
+  void SetUpAndLaunchApp() {
+    android_sms_app_helper_delegate_->SetUpAndLaunchAndroidSmsApp();
+  }
+
+  void TearDownApp() {
+    android_sms_app_helper_delegate_->TearDownAndroidSmsApp();
   }
 
   ContentSetting GetNotificationSetting() {
@@ -69,6 +133,7 @@ class AndroidSmsAppHelperDelegateImplTest : public testing::Test {
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   HostContentSettingsMap* host_content_settings_map_;
+  std::unique_ptr<FakeCookieManager> fake_cookie_manager_;
   std::unique_ptr<web_app::TestPendingAppManager> test_pending_app_manager_;
   std::unique_ptr<AndroidSmsAppHelperDelegate> android_sms_app_helper_delegate_;
 
@@ -78,7 +143,7 @@ class AndroidSmsAppHelperDelegateImplTest : public testing::Test {
 TEST_F(AndroidSmsAppHelperDelegateImplTest, TestInstallMessagesApp) {
   base::HistogramTester histogram_tester;
   EXPECT_NE(ContentSetting::CONTENT_SETTING_ALLOW, GetNotificationSetting());
-  InstallApp();
+  SetUpApp();
 
   std::vector<web_app::PendingAppManager::AppInfo> expected_apps_to_install;
   expected_apps_to_install.emplace_back(
@@ -92,6 +157,24 @@ TEST_F(AndroidSmsAppHelperDelegateImplTest, TestInstallMessagesApp) {
   EXPECT_EQ(ContentSetting::CONTENT_SETTING_ALLOW, GetNotificationSetting());
   histogram_tester.ExpectBucketCount("AndroidSms.PWAInstallationResult",
                                      web_app::InstallResultCode::kSuccess, 1);
+
+  // Check if the default_to_persist cookie is set.
+  ASSERT_EQ(1u, fake_cookie_manager()->set_canonical_cookie_calls().size());
+  std::tuple<net::CanonicalCookie, bool, bool> set_cookie_call =
+      fake_cookie_manager()->set_canonical_cookie_calls()[0];
+  EXPECT_EQ("default_to_persist", std::get<0>(set_cookie_call).Name());
+  EXPECT_EQ("true", std::get<0>(set_cookie_call).Value());
+  EXPECT_TRUE(std::get<1>(set_cookie_call));
+  EXPECT_FALSE(std::get<2>(set_cookie_call));
+}
+
+TEST_F(AndroidSmsAppHelperDelegateImplTest, TestTearDownMessagesApp) {
+  TearDownApp();
+  ASSERT_EQ(1u, fake_cookie_manager()->delete_cookies_calls().size());
+  const network::mojom::CookieDeletionFilterPtr& delete_filter =
+      fake_cookie_manager()->delete_cookies_calls()[0];
+  EXPECT_EQ(android_sms::GetAndroidMessagesURL(), delete_filter->url);
+  EXPECT_EQ("default_to_persist", delete_filter->cookie_name);
 }
 
 TEST_F(AndroidSmsAppHelperDelegateImplTest, TestInstallAndLaunchMessagesApp) {

chrome/browser/ui/webui/settings/chromeos/multidevice_handler.cc

@@ -214,7 +214,7 @@ void MultideviceHandler::HandleRetryPendingHostSetup(
 
 void MultideviceHandler::HandleSetUpAndroidSms(const base::ListValue* args) {
   DCHECK(args->empty());
-  android_sms_app_helper_->InstallAndLaunchAndroidSmsApp();
+  android_sms_app_helper_->SetUpAndLaunchAndroidSmsApp();
 }
 
 void MultideviceHandler::HandleGetSmartLockSignInEnabled(

chromeos/services/multidevice_setup/android_sms_app_installing_status_observer.cc

@@ -6,6 +6,7 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/no_destructor.h"
+#include "chromeos/components/proximity_auth/logging/logging.h"
 #include "chromeos/services/multidevice_setup/host_status_provider.h"
 #include "chromeos/services/multidevice_setup/public/cpp/android_sms_app_helper_delegate.h"
 #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
@@ -67,13 +68,12 @@ AndroidSmsAppInstallingStatusObserver::AndroidSmsAppInstallingStatusObserver(
   InstallPwaIfNeeded();
 }
 
-void AndroidSmsAppInstallingStatusObserver::InstallPwaIfNeeded() {
+bool AndroidSmsAppInstallingStatusObserver::IsPwaNeeded() {
   mojom::FeatureState feature_state =
       feature_state_manager_->GetFeatureStates()[mojom::Feature::kMessages];
-  if (feature_state == mojom::FeatureState::kProhibitedByPolicy ||
-      feature_state == mojom::FeatureState::kNotSupportedByChromebook ||
-      feature_state == mojom::FeatureState::kNotSupportedByPhone) {
-    return;
+  if (feature_state != mojom::FeatureState::kEnabledByUser &&
+      feature_state != mojom::FeatureState::kFurtherSetupRequired) {
+    return false;
   }
 
   mojom::HostStatus status(
@@ -81,12 +81,22 @@ void AndroidSmsAppInstallingStatusObserver::InstallPwaIfNeeded() {
   if (status !=
           mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation &&
       status != mojom::HostStatus::kHostVerified) {
+    return false;
+  }
+
+  return true;
+}
+
+void AndroidSmsAppInstallingStatusObserver::InstallPwaIfNeeded() {
+  // If PWA is not needed, clear default to persist cookie that was set
+  // during the last installation.
+  if (!IsPwaNeeded()) {
+    android_sms_app_helper_delegate_->TearDownAndroidSmsApp();
     return;
   }
 
-  // This call is re-entrant. If the app is already installed, it will just
-  // fail silently, which is fine.
-  android_sms_app_helper_delegate_->InstallAndroidSmsApp();
+  // Otherwise, set the default to persist cookie and install the PWA.
+  android_sms_app_helper_delegate_->SetUpAndroidSmsApp();
 }
 
 void AndroidSmsAppInstallingStatusObserver::OnHostStatusChange(

chromeos/services/multidevice_setup/android_sms_app_installing_status_observer.h

@@ -50,10 +50,11 @@ class AndroidSmsAppInstallingStatusObserver
   void OnHostStatusChange(const HostStatusProvider::HostStatusWithDevice&
                               host_status_with_device) override;
 
-  // FeatureStateManager:;Observer:
+  // FeatureStateManager::Observer:
   void OnFeatureStatesChange(
       const FeatureStateManager::FeatureStatesMap& feature_states_map) override;
 
+  bool IsPwaNeeded();
   void InstallPwaIfNeeded();
 
   HostStatusProvider* host_status_provider_;

chromeos/services/multidevice_setup/android_sms_app_installing_status_observer_unittest.cc

@@ -86,8 +86,6 @@ class MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest
 
 TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,
        InstallsAfterHostPending) {
-  SetMessagesFeatureState(mojom::FeatureState::kUnavailableNoVerifiedHost);
-  fake_app_helper_delegate()->Reset();
   EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
 
   SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
@@ -161,10 +159,30 @@ TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,
 }
 
 TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,
-       InstallsEvenIfFeatureIsDisabledByUser) {
+       CleansUpPwaInstallationWhenDisabled) {
+  SetMessagesFeatureState(mojom::FeatureState::kNotSupportedByChromebook);
   EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
+  SetMessagesFeatureState(mojom::FeatureState::kEnabledByUser);
+  EXPECT_TRUE(fake_app_helper_delegate()->HasInstalledApp());
+  EXPECT_TRUE(fake_app_helper_delegate()->IsDefaultToPersistCookieSet());
+
   SetMessagesFeatureState(mojom::FeatureState::kDisabledByUser);
   EXPECT_TRUE(fake_app_helper_delegate()->HasInstalledApp());
+  EXPECT_FALSE(fake_app_helper_delegate()->IsDefaultToPersistCookieSet());
+}
+
+TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,
+       DoesNotInstallWhenFeatureIsDisabledByUser) {
+  EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
+  SetMessagesFeatureState(mojom::FeatureState::kDisabledByUser);
+  EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
+}
+
+TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,
+       DoesNotInstallWhenSuiteIsDisabledByUser) {
+  EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
+  SetMessagesFeatureState(mojom::FeatureState::kUnavailableSuiteDisabled);
+  EXPECT_FALSE(fake_app_helper_delegate()->HasInstalledApp());
 }
 
 TEST_F(MultiDeviceSetupAndroidSmsAppInstallingStatusObserverTest,

chromeos/services/multidevice_setup/feature_state_manager_impl.cc

@@ -85,8 +85,10 @@ void ProcessSuiteEdgeCases(
     return;
 
   for (auto& map_entry : *feature_states_map) {
-    if (map_entry.second == mojom::FeatureState::kEnabledByUser)
+    if (map_entry.second == mojom::FeatureState::kEnabledByUser ||
+        map_entry.second == mojom::FeatureState::kFurtherSetupRequired) {
       map_entry.second = mojom::FeatureState::kUnavailableSuiteDisabled;
+    }
   }
 }
 

chromeos/services/multidevice_setup/feature_state_manager_impl_unittest.cc

@@ -327,22 +327,27 @@ TEST_F(MultiDeviceSetupFeatureStateManagerImplTest, Messages) {
   VerifyFeatureStateChange(4u /* expected_index */, mojom::Feature::kMessages,
                            mojom::FeatureState::kEnabledByUser);
 
+  SetAndroidSmsPairingState(false /* is_paired */);
   MakeBetterTogetherSuiteDisabledByUser();
   EXPECT_EQ(mojom::FeatureState::kUnavailableSuiteDisabled,
             manager()->GetFeatureStates()[mojom::Feature::kMessages]);
-  VerifyFeatureStateChange(6u /* expected_index */, mojom::Feature::kMessages,
+  VerifyFeatureStateChange(7u /* expected_index */, mojom::Feature::kMessages,
                            mojom::FeatureState::kUnavailableSuiteDisabled);
 
+  SetAndroidSmsPairingState(true /* is_paired */);
+  EXPECT_EQ(mojom::FeatureState::kUnavailableSuiteDisabled,
+            manager()->GetFeatureStates()[mojom::Feature::kMessages]);
+
   test_pref_service()->SetBoolean(kMessagesEnabledPrefName, false);
   EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
             manager()->GetFeatureStates()[mojom::Feature::kMessages]);
-  VerifyFeatureStateChange(7u /* expected_index */, mojom::Feature::kMessages,
+  VerifyFeatureStateChange(8u /* expected_index */, mojom::Feature::kMessages,
                            mojom::FeatureState::kDisabledByUser);
 
   test_pref_service()->SetBoolean(kMessagesAllowedPrefName, false);
   EXPECT_EQ(mojom::FeatureState::kProhibitedByPolicy,
             manager()->GetFeatureStates()[mojom::Feature::kMessages]);
-  VerifyFeatureStateChange(8u /* expected_index */, mojom::Feature::kMessages,
+  VerifyFeatureStateChange(9u /* expected_index */, mojom::Feature::kMessages,
                            mojom::FeatureState::kProhibitedByPolicy);
 }
 

chromeos/services/multidevice_setup/public/cpp/android_sms_app_helper_delegate.h

@@ -5,6 +5,7 @@
 #ifndef CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_ANDROID_SMS_APP_HELPER_DELEGATE_H_
 #define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_PUBLIC_CPP_ANDROID_SMS_APP_HELPER_DELEGATE_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
 
 namespace chromeos {
@@ -15,12 +16,15 @@ class AndroidSmsAppHelperDelegate {
  public:
   virtual ~AndroidSmsAppHelperDelegate() = default;
 
-  // Installs the Messages for Web PWA. Handles retries and errors internally.
-  virtual void InstallAndroidSmsApp() = 0;
-  // Tries to install the Messages for Web PWA (if needed) and then launches it
+  // Sets up the Messages for Web PWA. Handles retries and errors internally.
+  virtual void SetUpAndroidSmsApp() = 0;
+  // Attempts to setup the Messages for Web PWA (if needed) and then launches it
   // if the installation succeeds. If installation fails, retries will continue,
   // but the app will not be launched if the first installation attempt failed.
-  virtual void InstallAndLaunchAndroidSmsApp() = 0;
+  virtual void SetUpAndLaunchAndroidSmsApp() = 0;
+  // Cleans up previously setup Messages for Web PWA. This does not uninstall
+  // the PWA but only clears state that was setup for the PWA.
+  virtual void TearDownAndroidSmsApp() = 0;
 
  protected:
   AndroidSmsAppHelperDelegate() = default;

chromeos/services/multidevice_setup/public/cpp/fake_android_sms_app_helper_delegate.cc

@@ -14,13 +14,14 @@ FakeAndroidSmsAppHelperDelegate::FakeAndroidSmsAppHelperDelegate() {}
 
 FakeAndroidSmsAppHelperDelegate::~FakeAndroidSmsAppHelperDelegate() = default;
 
-void FakeAndroidSmsAppHelperDelegate::InstallAndroidSmsApp() {
+void FakeAndroidSmsAppHelperDelegate::SetUpAndroidSmsApp() {
   // TODO(jlklein): Add error simulation when error codes are added to the API.
   has_installed_ = true;
+  is_default_to_persist_cookie_set_ = true;
 }
 
-void FakeAndroidSmsAppHelperDelegate::InstallAndLaunchAndroidSmsApp() {
-  InstallAndroidSmsApp();
+void FakeAndroidSmsAppHelperDelegate::SetUpAndLaunchAndroidSmsApp() {
+  SetUpAndroidSmsApp();
   has_launched_ = true;
 }
 
@@ -32,9 +33,18 @@ bool FakeAndroidSmsAppHelperDelegate::HasLaunchedApp() {
   return has_launched_;
 }
 
+bool FakeAndroidSmsAppHelperDelegate::IsDefaultToPersistCookieSet() {
+  return is_default_to_persist_cookie_set_;
+}
+
 void FakeAndroidSmsAppHelperDelegate::Reset() {
   has_installed_ = false;
   has_launched_ = false;
+  is_default_to_persist_cookie_set_ = false;
+}
+
+void FakeAndroidSmsAppHelperDelegate::TearDownAndroidSmsApp() {
+  is_default_to_persist_cookie_set_ = false;
 }
 
 }  // namespace multidevice_setup

chromeos/services/multidevice_setup/public/cpp/fake_android_sms_app_helper_delegate.h

@@ -17,15 +17,18 @@ class FakeAndroidSmsAppHelperDelegate : public AndroidSmsAppHelperDelegate {
   ~FakeAndroidSmsAppHelperDelegate() override;
   bool HasInstalledApp();
   bool HasLaunchedApp();
+  bool IsDefaultToPersistCookieSet();
   void Reset();
 
   // AndroidSmsAppHelperDelegate:
-  void InstallAndroidSmsApp() override;
-  void InstallAndLaunchAndroidSmsApp() override;
+  void SetUpAndroidSmsApp() override;
+  void SetUpAndLaunchAndroidSmsApp() override;
+  void TearDownAndroidSmsApp() override;
 
  private:
   bool has_installed_ = false;
   bool has_launched_ = false;
+  bool is_default_to_persist_cookie_set_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAndroidSmsAppHelperDelegate);
 };