Migrate more tests to ScopedFeatureList.

components/sync/engine_impl/sync_manager_impl_unittest.cc

 // Copyright 2012 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 "components/sync/engine_impl/sync_manager_impl.h"
 
 #include <cstddef>
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "components/sync/base/attachment_id_proto.h"
 #include "components/sync/base/cancelation_signal.h"
 #include "components/sync/base/extensions_activity.h"
 #include "components/sync/base/fake_encryptor.h"
 #include "components/sync/base/mock_unrecoverable_error_handler.h"
 #include "components/sync/base/model_type_test_util.h"
 #include "components/sync/base/sync_features.h"
 #include "components/sync/engine/engine_util.h"
@@ skipping 466 matching lines @@
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
     EXPECT_EQ(node.GetModelType(), BOOKMARKS);
   }
 }
 
 TEST_F(SyncApiTest, WriteAndReadPassword) {
   KeyParams params = {"localhost", "username", "passphrase"};
-  base::FeatureList::ClearInstanceForTesting();
   EXPECT_FALSE(base::FeatureList::IsEnabled(kFillPasswordMetadata));
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
     trans.GetCryptographer()->AddKey(params);
   }
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
@@ skipping 24 matching lines @@
   }
 }
 
 TEST_F(SyncApiTest, WritePasswordAndCheckMetadata) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, user_share());
     trans.GetCryptographer()->AddKey(params);
   }
 
-  base::FeatureList::ClearInstanceForTesting();
   base::FieldTrialList field_trial_list(nullptr);
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->InitializeFromCommandLine(kFillPasswordMetadata.name,
-                                          std::string());
-  base::FeatureList::SetInstance(std::move(feature_list));
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kFillPasswordMetadata);
 
   EXPECT_TRUE(base::FeatureList::IsEnabled(kFillPasswordMetadata));
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
     WriteNode::InitUniqueByCreationResult result =
         password_node.InitUniqueByCreation(PASSWORDS, root_node, kClientTag);
@@ skipping 1525 matching lines @@
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_TRUE(node_entry->GetIsUnsynced());
   }
 }
 
 // Passwords have their own handling for encryption. Verify setting a new
 // passphrase updates the data and clears the unencrypted metadta for passwords.
 TEST_F(SyncManagerTest, UpdatePasswordNewPassphrase) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
-  base::FeatureList::ClearInstanceForTesting();
   base::FieldTrialList field_trial_list(nullptr);
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->InitializeFromCommandLine(kFillPasswordMetadata.name,
-                                          std::string());
-  base::FeatureList::SetInstance(std::move(feature_list));
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kFillPasswordMetadata);
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value(kPasswordValue);
     entity_specifics.mutable_password()
         ->mutable_unencrypted_metadata()
         ->set_url(kUrl);
     cryptographer->Encrypt(
         data, entity_specifics.mutable_password()->mutable_encrypted());
@@ skipping 55 matching lines @@
     EXPECT_EQ(kPasswordValue, data.password_value());
     EXPECT_FALSE(password_node.GetEntitySpecifics()
                      .password()
                      .has_unencrypted_metadata());
   }
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via ReencryptEverything.
 TEST_F(SyncManagerTest, UpdatePasswordReencryptEverything) {
-  base::FeatureList::ClearInstanceForTesting();
   EXPECT_FALSE(base::FeatureList::IsEnabled(kFillPasswordMetadata));
 
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
@@ skipping 12 matching lines @@
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, kClientTag));
 }
 
 // Metadata filling can happen during ReencryptEverything, check that data is
 // written when it's applicable, namely that password specifics entity is marked
 // unsynced, when data was written to the unencrypted metadata field.
 TEST_F(SyncManagerTest, UpdatePasswordReencryptEverythingFillMetadata) {
-  base::FeatureList::ClearInstanceForTesting();
   base::FieldTrialList field_trial_list(nullptr);
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->InitializeFromCommandLine(kFillPasswordMetadata.name,
-                                          std::string());
-  base::FeatureList::SetInstance(std::move(feature_list));
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kFillPasswordMetadata);
   EXPECT_TRUE(base::FeatureList::IsEnabled(kFillPasswordMetadata));
 
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     data.set_signon_realm(kUrl);
@@ skipping 27 matching lines @@
                         .url());
   }
 
   EXPECT_TRUE(ResetUnsyncedEntry(PASSWORDS, kClientTag));
 }
 
 // Check that when the data in PasswordSpecifics hasn't changed during
 // ReEncryption, entity is not marked as unsynced.
 TEST_F(SyncManagerTest,
        UpdatePasswordReencryptEverythingDontMarkUnsyncWhenNotNeeded) {
-  base::FeatureList::ClearInstanceForTesting();
   base::FieldTrialList field_trial_list(nullptr);
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->InitializeFromCommandLine(kFillPasswordMetadata.name,
-                                          std::string());
-  base::FeatureList::SetInstance(std::move(feature_list));
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(kFillPasswordMetadata);
   EXPECT_TRUE(base::FeatureList::IsEnabled(kFillPasswordMetadata));
 
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     data.set_signon_realm(kUrl);
@@ skipping 1250 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer