Revert "Remove Finch support for PasswordBranding"

chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc

Index: chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc
diff --git a/chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc b/chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc
index 9432dc387b3f56cab20dfa49b55e9780a838c87d..a2b661fccf00fe08a0cbf477ee09d58d3b777ae9 100644
--- a/chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc
+++ b/chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc
@@ -35,8 +35,11 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using password_bubble_experiment::kBrandingExperimentName;
 using password_bubble_experiment::kChromeSignInPasswordPromoExperimentName;
 using password_bubble_experiment::kChromeSignInPasswordPromoThresholdParam;
+using password_bubble_experiment::kSmartLockBrandingGroupName;
+using password_bubble_experiment::kSmartLockBrandingSavePromptOnlyGroupName;
 using ::testing::AnyNumber;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ -44,27 +47,24 @@ using ::testing::_;
 
 namespace {
 
-constexpr char kFakeGroup[] = "FakeGroup";
-constexpr char kSignInPromoCountTilNoThanksMetric[] =
+const char kFakeGroup[] = "FakeGroup";
+const char kSignInPromoCountTilNoThanksMetric[] =
     "PasswordManager.SignInPromoCountTilNoThanks";
-constexpr char kSignInPromoCountTilSignInMetric[] =
+const char kSignInPromoCountTilSignInMetric[] =
     "PasswordManager.SignInPromoCountTilSignIn";
-constexpr char kSignInPromoDismissalCountMetric[] =
+const char kSignInPromoDismissalCountMetric[] =
     "PasswordManager.SignInPromoDismissalCount";
-constexpr char kSignInPromoDismissalReasonMetric[] =
-    "PasswordManager.SignInPromo";
-constexpr char kSiteOrigin[] = "http://example.com/login";
-constexpr char kUsername[] = "Admin";
-constexpr char kUIDismissalReasonMetric[] = "PasswordManager.UIDismissalReason";
+const char kSignInPromoDismissalReasonMetric[] = "PasswordManager.SignInPromo";
+const char kSiteOrigin[] = "http://example.com/login";
+const char kUsername[] = "Admin";
+const char kUIDismissalReasonMetric[] = "PasswordManager.UIDismissalReason";
 
 class TestSyncService : public browser_sync::ProfileSyncServiceMock {
  public:
-  enum class SyncedTypes { ALL, NONE };
-
   explicit TestSyncService(Profile* profile)
       : browser_sync::ProfileSyncServiceMock(
             CreateProfileSyncServiceParamsForTest(profile)),
-        synced_types_(SyncedTypes::NONE) {}
+        smartlock_enabled_(false) {}
   ~TestSyncService() override {}
 
   // FakeSyncService:
@@ -72,14 +72,8 @@ class TestSyncService : public browser_sync::ProfileSyncServiceMock {
   bool IsSyncAllowed() const override { return true; }
   bool IsSyncActive() const override { return true; }
   syncer::ModelTypeSet GetActiveDataTypes() const override {
-    switch (synced_types_) {
-      case SyncedTypes::ALL:
-        return syncer::ModelTypeSet::All();
-      case SyncedTypes::NONE:
-        return syncer::ModelTypeSet();
-    }
-    NOTREACHED();
-    return syncer::ModelTypeSet();
+    return smartlock_enabled_ ? syncer::ModelTypeSet::All()
+                              : syncer::ModelTypeSet();
   }
   bool CanSyncStart() const override { return true; }
   syncer::ModelTypeSet GetPreferredDataTypes() const override {
@@ -87,12 +81,12 @@ class TestSyncService : public browser_sync::ProfileSyncServiceMock {
   }
   bool IsUsingSecondaryPassphrase() const override { return false; }
 
-  void set_synced_types(SyncedTypes synced_types) {
-    synced_types_ = synced_types;
+  void set_smartlock_enabled(bool smartlock_enabled) {
+    smartlock_enabled_ = smartlock_enabled;
   }
 
  private:
-  SyncedTypes synced_types_;
+  bool smartlock_enabled_;
 };
 
 std::unique_ptr<KeyedService> TestingSyncFactoryFunction(
@@ -326,6 +320,46 @@ TEST_F(ManagePasswordsBubbleModelTest, ClickUpdate) {
   DestroyModel();
 }
 
+TEST_F(ManagePasswordsBubbleModelTest, ShowSmartLockWarmWelcome) {
+  TestSyncService* sync_service = static_cast<TestSyncService*>(
+      ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+          profile(), &TestingSyncFactoryFunction));
+  sync_service->set_smartlock_enabled(true);
+  base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
+                                         kSmartLockBrandingGroupName);
+
+  PretendPasswordWaiting();
+
+  EXPECT_TRUE(model()->ShouldShowGoogleSmartLockWelcome());
+  EXPECT_CALL(*GetStore(), AddSiteStatsImpl(_));
+  DestroyModel();
+  PretendPasswordWaiting();
+
+  EXPECT_FALSE(model()->ShouldShowGoogleSmartLockWelcome());
+  EXPECT_TRUE(prefs()->GetBoolean(
+      password_manager::prefs::kWasSavePrompFirstRunExperienceShown));
+}
+
+TEST_F(ManagePasswordsBubbleModelTest, OmitSmartLockWarmWelcome) {
+  TestSyncService* sync_service = static_cast<TestSyncService*>(
+      ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+          profile(), &TestingSyncFactoryFunction));
+  sync_service->set_smartlock_enabled(false);
+  base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
+                                         kSmartLockBrandingGroupName);
+
+  PretendPasswordWaiting();
+
+  EXPECT_FALSE(model()->ShouldShowGoogleSmartLockWelcome());
+  EXPECT_CALL(*GetStore(), AddSiteStatsImpl(_));
+  DestroyModel();
+  PretendPasswordWaiting();
+
+  EXPECT_FALSE(model()->ShouldShowGoogleSmartLockWelcome());
+  EXPECT_FALSE(prefs()->GetBoolean(
+      password_manager::prefs::kWasSavePrompFirstRunExperienceShown));
+}
+
 TEST_F(ManagePasswordsBubbleModelTest, OnBrandLinkClicked) {
   PretendPasswordWaiting();
 
@@ -434,8 +468,11 @@ TEST_F(ManagePasswordsBubbleModelTest, SignInPromoDismiss) {
 
 namespace {
 
+enum class SmartLockStatus { ENABLE, DISABLE };
+
 struct TitleTestCase {
-  TestSyncService::SyncedTypes synced_types;
+  const char* experiment_group;
+  SmartLockStatus smartlock_status;
   const char* expected_title;
 };
 
@@ -450,7 +487,12 @@ TEST_P(ManagePasswordsBubbleModelTitleTest, BrandedTitleOnSaving) {
   TestSyncService* sync_service = static_cast<TestSyncService*>(
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(), &TestingSyncFactoryFunction));
-  sync_service->set_synced_types(test_case.synced_types);
+  sync_service->set_smartlock_enabled(test_case.smartlock_status ==
+                                      SmartLockStatus::ENABLE);
+  if (test_case.experiment_group) {
+    base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
+                                           test_case.experiment_group);
+  }
 
   PretendPasswordWaiting();
   EXPECT_THAT(base::UTF16ToUTF8(model()->title()),
@@ -462,9 +504,17 @@ namespace {
 // Below, "Chrom" is the common prefix of Chromium and Google Chrome. Ideally,
 // we would use the localised strings, but ResourceBundle does not get
 // initialised for this unittest.
-constexpr TitleTestCase kTitleTestCases[] = {
-    {TestSyncService::SyncedTypes::ALL, "Google Smart Lock"},
-    {TestSyncService::SyncedTypes::NONE, "Chrom"},
+const TitleTestCase kTitleTestCases[] = {
+    {kSmartLockBrandingGroupName, SmartLockStatus::ENABLE, "Google Smart Lock"},
+    {kSmartLockBrandingSavePromptOnlyGroupName, SmartLockStatus::ENABLE,
+     "Google Smart Lock"},
+    {nullptr, SmartLockStatus::ENABLE, "Chrom"},
+    {"Default", SmartLockStatus::ENABLE, "Chrom"},
+    {kSmartLockBrandingGroupName, SmartLockStatus::DISABLE, "Chrom"},
+    {kSmartLockBrandingSavePromptOnlyGroupName, SmartLockStatus::DISABLE,
+     "Chrom"},
+    {"Default", SmartLockStatus::DISABLE, "Chrom"},
+    {nullptr, SmartLockStatus::DISABLE, "Chrom"},
 };
 
 }  // namespace
@@ -473,24 +523,67 @@ INSTANTIATE_TEST_CASE_P(Default,
                         ManagePasswordsBubbleModelTitleTest,
                         ::testing::ValuesIn(kTitleTestCases));
 
+namespace {
+
+enum class ManageLinkTarget { EXTERNAL_PASSWORD_MANAGER, SETTINGS_PAGE };
+
+struct ManageLinkTestCase {
+  const char* experiment_group;
+  SmartLockStatus smartlock_status;
+  ManageLinkTarget expected_target;
+};
+
+}  // namespace
+
 class ManagePasswordsBubbleModelManageLinkTest
     : public ManagePasswordsBubbleModelTest,
-      public ::testing::WithParamInterface<TestSyncService::SyncedTypes> {};
+      public ::testing::WithParamInterface<ManageLinkTestCase> {};
 
 TEST_P(ManagePasswordsBubbleModelManageLinkTest, OnManageLinkClicked) {
+  ManageLinkTestCase test_case = GetParam();
   TestSyncService* sync_service = static_cast<TestSyncService*>(
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(), &TestingSyncFactoryFunction));
-  sync_service->set_synced_types(GetParam());
+  sync_service->set_smartlock_enabled(test_case.smartlock_status ==
+                                      SmartLockStatus::ENABLE);
+  if (test_case.experiment_group) {
+    base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
+                                           test_case.experiment_group);
+  }
 
   PretendManagingPasswords();
 
-  EXPECT_CALL(*controller(), NavigateToPasswordManagerSettingsPage());
+  switch (test_case.expected_target) {
+    case ManageLinkTarget::EXTERNAL_PASSWORD_MANAGER:
+      EXPECT_CALL(*controller(), NavigateToExternalPasswordManager());
+      break;
+    case ManageLinkTarget::SETTINGS_PAGE:
+      EXPECT_CALL(*controller(), NavigateToPasswordManagerSettingsPage());
+      break;
+  }
 
   model()->OnManageLinkClicked();
 }
 
+namespace {
+
+const ManageLinkTestCase kManageLinkTestCases[] = {
+    {kSmartLockBrandingGroupName, SmartLockStatus::ENABLE,
+     ManageLinkTarget::EXTERNAL_PASSWORD_MANAGER},
+    {kSmartLockBrandingSavePromptOnlyGroupName, SmartLockStatus::ENABLE,
+     ManageLinkTarget::SETTINGS_PAGE},
+    {nullptr, SmartLockStatus::ENABLE, ManageLinkTarget::SETTINGS_PAGE},
+    {"Default", SmartLockStatus::ENABLE, ManageLinkTarget::SETTINGS_PAGE},
+    {kSmartLockBrandingGroupName, SmartLockStatus::DISABLE,
+     ManageLinkTarget::SETTINGS_PAGE},
+    {kSmartLockBrandingSavePromptOnlyGroupName, SmartLockStatus::DISABLE,
+     ManageLinkTarget::SETTINGS_PAGE},
+    {nullptr, SmartLockStatus::DISABLE, ManageLinkTarget::SETTINGS_PAGE},
+    {"Default", SmartLockStatus::DISABLE, ManageLinkTarget::SETTINGS_PAGE},
+};
+
+}  // namespace
+
 INSTANTIATE_TEST_CASE_P(Default,
                         ManagePasswordsBubbleModelManageLinkTest,
-                        ::testing::Values(TestSyncService::SyncedTypes::ALL,
-                                          TestSyncService::SyncedTypes::NONE));
+                        ::testing::ValuesIn(kManageLinkTestCases));