Remove Finch support for PasswordBranding

components/password_manager/core/browser/password_bubble_experiment_unittest.cc

Index: components/password_manager/core/browser/password_bubble_experiment_unittest.cc
diff --git a/components/password_manager/core/browser/password_bubble_experiment_unittest.cc b/components/password_manager/core/browser/password_bubble_experiment_unittest.cc
index 4f4baa8cd4fb8764050fc85ba26ae281ac59eabc..55906c30f9dd288d8e3d908ab11358d12d8bd1a0 100644
--- a/components/password_manager/core/browser/password_bubble_experiment_unittest.cc
+++ b/components/password_manager/core/browser/password_bubble_experiment_unittest.cc
@@ -21,50 +21,8 @@ namespace password_bubble_experiment {
 
 namespace {
 
-const char kSmartLockNoBrandingGroupName[] = "NoSmartLockBranding";
-
 enum class CustomPassphraseState { NONE, SET };
 
-enum class SavePromptFirstRunExperience { NONE, PRESENT };
-
-enum class UserType { SMARTLOCK, NOT_SMARTLOCK };
-
-struct IsSmartLockBrandingEnabledTestcase {
-  CustomPassphraseState passphrase_state;
-  syncer::ModelType type;
-  SmartLockBranding expected_branding;
-  UserType expected_user_type;
-};
-
-std::ostream& operator<<(std::ostream& os,
-                         const IsSmartLockBrandingEnabledTestcase& testcase) {
-  os << (testcase.passphrase_state == CustomPassphraseState::SET ? "{SET, "
-                                                                 : "{NONE, ");
-  os << (testcase.type == syncer::PASSWORDS ? "syncer::PASSWORDS, "
-                                            : "not syncer::PASSWORDS, ");
-  switch (testcase.expected_branding) {
-    case SmartLockBranding::NONE:
-      os << "NONE, ";
-      break;
-    case SmartLockBranding::FULL:
-      os << "FULL, ";
-      break;
-    case SmartLockBranding::SAVE_PROMPT_ONLY:
-      os << "SAVE_PROMPT_ONLY, ";
-      break;
-  }
-  os << (testcase.expected_user_type == UserType::SMARTLOCK ? "SMARTLOCK}"
-                                                            : "NOT_SMARTLOCK}");
-  return os;
-}
-
-struct ShouldShowSavePromptFirstRunExperienceTestcase {
-  CustomPassphraseState passphrase_state;
-  syncer::ModelType type;
-  bool pref_value;
-  SavePromptFirstRunExperience first_run_experience;
-};
-
 class TestSyncService : public syncer::FakeSyncService {
  public:
   // FakeSyncService overrides.
@@ -128,38 +86,8 @@ class PasswordManagerPasswordBubbleExperimentTest : public testing::Test {
 
   PrefService* prefs() { return &pref_service_; }
 
-  void EnforceExperimentGroup(const char* group_name) {
-    ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(kBrandingExperimentName,
-                                                       group_name));
-  }
-
   TestSyncService* sync_service() { return &fake_sync_service_; }
 
-  void TestIsSmartLockBrandingEnabledTestcase(
-      const IsSmartLockBrandingEnabledTestcase& test_case) {
-    SetupFakeSyncServiceForTestCase(test_case.type, test_case.passphrase_state);
-    EXPECT_EQ(test_case.expected_branding,
-              GetSmartLockBrandingState(sync_service()));
-    EXPECT_EQ(test_case.expected_user_type == UserType::SMARTLOCK,
-              IsSmartLockUser(sync_service()));
-  }
-
-  void TestShouldShowSavePromptFirstRunExperienceTestcase(
-      const ShouldShowSavePromptFirstRunExperienceTestcase& test_case) {
-    SetupFakeSyncServiceForTestCase(test_case.type, test_case.passphrase_state);
-    prefs()->SetBoolean(
-        password_manager::prefs::kWasSavePrompFirstRunExperienceShown,
-        test_case.pref_value);
-    bool should_show_first_run_experience =
-        ShouldShowSavePromptFirstRunExperience(sync_service(), prefs());
-    if (test_case.first_run_experience ==
-        SavePromptFirstRunExperience::PRESENT) {
-      EXPECT_FALSE(should_show_first_run_experience);
-    } else {
-      EXPECT_FALSE(should_show_first_run_experience);
-    }
-  }
-
  private:
   void SetupFakeSyncServiceForTestCase(syncer::ModelType type,

[vasilii, 2016/12/16 16:56:53]

I don't see where it's used.

[vabr (Chromium), 2016/12/16 18:56:27]

It's not, but it should be (we are not testing IsSmartLockUser at all. Will add
that test and put this to some good use.

                                        CustomPassphraseState passphrase_state) {
@@ -177,154 +105,6 @@ class PasswordManagerPasswordBubbleExperimentTest : public testing::Test {
 };
 
 TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       IsSmartLockBrandingEnabledTestNoBranding) {
-  const IsSmartLockBrandingEnabledTestcase kTestData[] = {
-      {CustomPassphraseState::SET, syncer::PASSWORDS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, SmartLockBranding::NONE,
-       UserType::SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-  };
-
-  EnforceExperimentGroup(kSmartLockNoBrandingGroupName);
-  for (const auto& test_case : kTestData) {
-    SCOPED_TRACE(testing::Message("test_case = ") << test_case);
-    TestIsSmartLockBrandingEnabledTestcase(test_case);
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       IsSmartLockBrandingEnabledTest_FULL) {
-  const IsSmartLockBrandingEnabledTestcase kTestData[] = {
-      {CustomPassphraseState::SET, syncer::PASSWORDS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, SmartLockBranding::FULL,
-       UserType::SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-  };
-
-  EnforceExperimentGroup(kSmartLockBrandingGroupName);
-  for (const auto& test_case : kTestData) {
-    SCOPED_TRACE(testing::Message("test_case = ") << test_case);
-    TestIsSmartLockBrandingEnabledTestcase(test_case);
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       IsSmartLockBrandingEnabledTest_SAVE_PROMPT_ONLY) {
-  const IsSmartLockBrandingEnabledTestcase kTestData[] = {
-      {CustomPassphraseState::SET, syncer::PASSWORDS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS,
-       SmartLockBranding::SAVE_PROMPT_ONLY, UserType::SMARTLOCK},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, SmartLockBranding::NONE,
-       UserType::NOT_SMARTLOCK},
-  };
-
-  EnforceExperimentGroup(kSmartLockBrandingSavePromptOnlyGroupName);
-  for (const auto& test_case : kTestData) {
-    SCOPED_TRACE(testing::Message("test_case = ") << test_case);
-    TestIsSmartLockBrandingEnabledTestcase(test_case);
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       ShoulShowSavePrompBrandingGroup) {
-  const struct ShouldShowSavePromptFirstRunExperienceTestcase kTestData[] = {
-      {CustomPassphraseState::SET, syncer::PASSWORDS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::PASSWORDS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, false,
-       SavePromptFirstRunExperience::NONE},
-  };
-
-  EnforceExperimentGroup(kSmartLockBrandingGroupName);
-  for (const auto& test_case : kTestData) {
-    TestShouldShowSavePromptFirstRunExperienceTestcase(test_case);
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       ShoulShowSavePrompNoBrandingGroup) {
-  const struct ShouldShowSavePromptFirstRunExperienceTestcase kTestData[] = {
-      {CustomPassphraseState::SET, syncer::PASSWORDS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::PASSWORDS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::SET, syncer::BOOKMARKS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::PASSWORDS, false,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, true,
-       SavePromptFirstRunExperience::NONE},
-      {CustomPassphraseState::NONE, syncer::BOOKMARKS, false,
-       SavePromptFirstRunExperience::NONE},
-  };
-
-  EnforceExperimentGroup(kSmartLockNoBrandingGroupName);
-  for (const auto& test_case : kTestData) {
-    TestShouldShowSavePromptFirstRunExperienceTestcase(test_case);
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
-       RecordFirstRunExperienceWasShownTest) {
-  const struct {
-    bool initial_pref_value;
-    bool result_pref_value;
-  } kTestData[] = {
-      {false, true}, {true, true},
-  };
-  for (const auto& test_case : kTestData) {
-    // Record Save prompt first run experience.
-    prefs()->SetBoolean(
-        password_manager::prefs::kWasSavePrompFirstRunExperienceShown,
-        test_case.initial_pref_value);
-    RecordSavePromptFirstRunExperienceWasShown(prefs());
-    EXPECT_EQ(
-        test_case.result_pref_value,
-        prefs()->GetBoolean(
-            password_manager::prefs::kWasSavePrompFirstRunExperienceShown));
-    // Record Auto sign-in first run experience.
-    prefs()->SetBoolean(
-        password_manager::prefs::kWasAutoSignInFirstRunExperienceShown,
-        test_case.initial_pref_value);
-    EXPECT_EQ(!test_case.initial_pref_value,
-              ShouldShowAutoSignInPromptFirstRunExperience(prefs()));
-        RecordAutoSignInPromptFirstRunExperienceWasShown(prefs());
-    EXPECT_EQ(
-        test_case.result_pref_value,
-        prefs()->GetBoolean(
-            password_manager::prefs::kWasAutoSignInFirstRunExperienceShown));
-    EXPECT_EQ(!test_case.result_pref_value,
-              ShouldShowAutoSignInPromptFirstRunExperience(prefs()));
-  }
-}
-
-TEST_F(PasswordManagerPasswordBubbleExperimentTest,
        ShouldShowChromeSignInPasswordPromo) {
   // By default the promo is off.
   EXPECT_FALSE(ShouldShowChromeSignInPasswordPromo(prefs(), nullptr));