Reland: Remove Finch support for PasswordBranding

chrome/browser/ui/passwords/manage_passwords_bubble_model_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/passwords/manage_passwords_bubble_model.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 17 matching lines @@
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/password_manager/core/common/password_manager_ui.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #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;
 using ::testing::_;
 
 namespace {
 
-const char kFakeGroup[] = "FakeGroup";
-const char kSignInPromoCountTilNoThanksMetric[] =
+constexpr char kFakeGroup[] = "FakeGroup";
+constexpr char kSignInPromoCountTilNoThanksMetric[] =
     "PasswordManager.SignInPromoCountTilNoThanks";
-const char kSignInPromoCountTilSignInMetric[] =
+constexpr char kSignInPromoCountTilSignInMetric[] =
     "PasswordManager.SignInPromoCountTilSignIn";
-const char kSignInPromoDismissalCountMetric[] =
+constexpr char kSignInPromoDismissalCountMetric[] =
     "PasswordManager.SignInPromoDismissalCount";
-const char kSignInPromoDismissalReasonMetric[] = "PasswordManager.SignInPromo";
-const char kSiteOrigin[] = "http://example.com/login";
-const char kUsername[] = "Admin";
-const char kUIDismissalReasonMetric[] = "PasswordManager.UIDismissalReason";
+constexpr char kSignInPromoDismissalReasonMetric[] =
+    "PasswordManager.SignInPromo";
+constexpr char kSiteOrigin[] = "http://example.com/login";
+constexpr char kUsername[] = "Admin";
+constexpr 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)),
-        smartlock_enabled_(false) {}
+        synced_types_(SyncedTypes::NONE) {}
   ~TestSyncService() override {}
 
   // FakeSyncService:
   bool IsFirstSetupComplete() const override { return true; }
   bool IsSyncAllowed() const override { return true; }
   bool IsSyncActive() const override { return true; }
   syncer::ModelTypeSet GetActiveDataTypes() const override {
-    return smartlock_enabled_ ? syncer::ModelTypeSet::All()
-                              : syncer::ModelTypeSet();
+    switch (synced_types_) {
+      case SyncedTypes::ALL:
+        return syncer::ModelTypeSet::All();
+      case SyncedTypes::NONE:
+        return syncer::ModelTypeSet();
+    }
+    NOTREACHED();
+    return syncer::ModelTypeSet();
   }
   bool CanSyncStart() const override { return true; }
   syncer::ModelTypeSet GetPreferredDataTypes() const override {
     return GetActiveDataTypes();
   }
   bool IsUsingSecondaryPassphrase() const override { return false; }
 
-  void set_smartlock_enabled(bool smartlock_enabled) {
-    smartlock_enabled_ = smartlock_enabled;
+  void set_synced_types(SyncedTypes synced_types) {
+    synced_types_ = synced_types;
   }
 
  private:
-  bool smartlock_enabled_;
+  SyncedTypes synced_types_;
 };
 
 std::unique_ptr<KeyedService> TestingSyncFactoryFunction(
     content::BrowserContext* context) {
   return base::MakeUnique<TestSyncService>(static_cast<Profile*>(context));
 }
 
 }  // namespace
 
 class ManagePasswordsBubbleModelTest : public ::testing::Test {
@@ skipping 214 matching lines @@
 
 TEST_F(ManagePasswordsBubbleModelTest, ClickUpdate) {
   PretendUpdatePasswordWaiting();
 
   autofill::PasswordForm form;
   EXPECT_CALL(*controller(), UpdatePassword(form));
   model()->OnUpdateClicked(form);
   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(_));
-  EXPECT_CALL(*controller(), OnNoInteraction());
-  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(_));
-  EXPECT_CALL(*controller(), OnNoInteraction());
-  DestroyModel();
-  PretendPasswordWaiting();
-
-  EXPECT_FALSE(model()->ShouldShowGoogleSmartLockWelcome());
-  EXPECT_FALSE(prefs()->GetBoolean(
-      password_manager::prefs::kWasSavePrompFirstRunExperienceShown));
-}
-
 TEST_F(ManagePasswordsBubbleModelTest, OnBrandLinkClicked) {
   PretendPasswordWaiting();
 
   EXPECT_CALL(*controller(), NavigateToSmartLockHelpPage());
   model()->OnBrandLinkClicked();
 }
 
 TEST_F(ManagePasswordsBubbleModelTest, SuppressSignInPromo) {
   base::HistogramTester histogram_tester;
   PretendPasswordWaiting();
@@ skipping 88 matching lines @@
       password_manager::metrics_util::CHROME_SIGNIN_DISMISSED, 1);
   histogram_tester.ExpectTotalCount(kSignInPromoCountTilSignInMetric, 0);
   histogram_tester.ExpectTotalCount(kSignInPromoCountTilNoThanksMetric, 0);
   histogram_tester.ExpectUniqueSample(kSignInPromoDismissalCountMetric, 1, 1);
   EXPECT_FALSE(prefs()->GetBoolean(
       password_manager::prefs::kWasSignInPasswordPromoClicked));
 }
 
 namespace {
 
-enum class SmartLockStatus { ENABLE, DISABLE };
-
 struct TitleTestCase {
-  const char* experiment_group;
-  SmartLockStatus smartlock_status;
+  TestSyncService::SyncedTypes synced_types;
   const char* expected_title;
 };
 
 }  // namespace
 
 class ManagePasswordsBubbleModelTitleTest
     : public ManagePasswordsBubbleModelTest,
       public ::testing::WithParamInterface<TitleTestCase> {};
 
 TEST_P(ManagePasswordsBubbleModelTitleTest, BrandedTitleOnSaving) {
   TitleTestCase test_case = GetParam();
   TestSyncService* sync_service = static_cast<TestSyncService*>(
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(), &TestingSyncFactoryFunction));
-  sync_service->set_smartlock_enabled(test_case.smartlock_status ==
-                                      SmartLockStatus::ENABLE);
-  if (test_case.experiment_group) {
-    base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
-                                           test_case.experiment_group);
-  }
+  sync_service->set_synced_types(test_case.synced_types);
 
   PretendPasswordWaiting();
   EXPECT_THAT(base::UTF16ToUTF8(model()->title()),
               testing::HasSubstr(test_case.expected_title));
 }
 
 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.
-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"},
+constexpr TitleTestCase kTitleTestCases[] = {
+    {TestSyncService::SyncedTypes::ALL, "Google Smart Lock"},
+    {TestSyncService::SyncedTypes::NONE, "Chrom"},
 };
 
 }  // namespace
 
 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<ManageLinkTestCase> {};
+      public ::testing::WithParamInterface<TestSyncService::SyncedTypes> {};
 
 TEST_P(ManagePasswordsBubbleModelManageLinkTest, OnManageLinkClicked) {
-  ManageLinkTestCase test_case = GetParam();
   TestSyncService* sync_service = static_cast<TestSyncService*>(
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(), &TestingSyncFactoryFunction));
-  sync_service->set_smartlock_enabled(test_case.smartlock_status ==
-                                      SmartLockStatus::ENABLE);
-  if (test_case.experiment_group) {
-    base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
-                                           test_case.experiment_group);
-  }
+  sync_service->set_synced_types(GetParam());
 
   PretendManagingPasswords();
 
-  switch (test_case.expected_target) {
-    case ManageLinkTarget::EXTERNAL_PASSWORD_MANAGER:
-      EXPECT_CALL(*controller(), NavigateToExternalPasswordManager());
-      break;
-    case ManageLinkTarget::SETTINGS_PAGE:
-      EXPECT_CALL(*controller(), NavigateToPasswordManagerSettingsPage());
-      break;
-  }
+  EXPECT_CALL(*controller(), NavigateToPasswordManagerSettingsPage());
 
   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::ValuesIn(kManageLinkTestCases));
+                        ::testing::Values(TestSyncService::SyncedTypes::ALL,
+                                          TestSyncService::SyncedTypes::NONE));