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..38c62adf6defb65609ebc861a5c07bb5ddea6ec3 100644
--- a/components/password_manager/core/browser/password_bubble_experiment_unittest.cc
+++ b/components/password_manager/core/browser/password_bubble_experiment_unittest.cc
@@ -12,6 +12,7 @@
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/testing_pref_service.h"
+#include "components/sync/base/model_type.h"
 #include "components/sync/driver/fake_sync_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -21,50 +22,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,39 +87,9 @@ 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:
+ protected:
   void SetupFakeSyncServiceForTestCase(syncer::ModelType type,
                                        CustomPassphraseState passphrase_state) {
     syncer::ModelTypeSet active_types;
@@ -171,164 +100,17 @@ class PasswordManagerPasswordBubbleExperimentTest : public testing::Test {
         passphrase_state == CustomPassphraseState::SET);
   }
 
+ private:
   TestSyncService fake_sync_service_;
   base::FieldTrialList field_trial_list_;
   TestingPrefServiceSimple pref_service_;
 };
 
 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));
-  const struct {
+  constexpr struct {
     bool was_already_clicked;
     bool is_sync_allowed;
     bool is_first_setup_complete;
@@ -362,4 +144,26 @@ TEST_F(PasswordManagerPasswordBubbleExperimentTest,
   }
 }
 
+TEST_F(PasswordManagerPasswordBubbleExperimentTest, IsSmartLockUser) {
+  constexpr struct {
+    syncer::ModelType type;
+    CustomPassphraseState passphrase_state;
+    bool expected_smart_lock_user;
+  } kTestData[] = {
+      {syncer::ModelType::BOOKMARKS, CustomPassphraseState::NONE, false},
+      {syncer::ModelType::BOOKMARKS, CustomPassphraseState::SET, false},
+      {syncer::ModelType::PASSWORDS, CustomPassphraseState::NONE, true},
+      {syncer::ModelType::PASSWORDS, CustomPassphraseState::SET, false},
+  };
+  for (const auto& test_case : kTestData) {
+    SCOPED_TRACE(testing::Message("#test_case = ") << (&test_case - kTestData));
+    SetupFakeSyncServiceForTestCase(test_case.type, test_case.passphrase_state);
+
+    if (test_case.expected_smart_lock_user)
+      EXPECT_TRUE(IsSmartLockUser(sync_service()));

[vasilii, 2016/12/19 13:31:02]

EXPECT_EQ(test_case.expected_smart_lock_user, IsSmartLockUser(sync_service()));
?

[vabr (Chromium), 2016/12/19 13:51:03]

Done.

+    else
+      EXPECT_FALSE(IsSmartLockUser(sync_service()));
+  }
+}
+
 }  // namespace password_bubble_experiment