Convert components/prefs away from base::Bind/base::Callback

base::Bind/base::Callback are deprecated in favor of either
base::BindOnce/base::OnceCallback or base::BindRepeating/
base::RepeatingCallback (depending on whether the callback
is invoked once or multiple time).

Convert last uses of base::Bind/base::Callback in
components/prefs to the recommended methods/types.

Bug: 1007719
Change-Id: I50ed50f2a419ef4b7afcc65756e8a4a0c08a8933
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1844784
Commit-Queue: Sylvain Defresne <sdefresne@chromium.org>
Auto-Submit: Sylvain Defresne <sdefresne@chromium.org>
Reviewed-by: Dominic Battré <battre@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705508}

components/prefs/json_pref_store_unittest.cc

@@ -732,8 +732,8 @@ class SuccessfulWriteReplyObserver {
 void SuccessfulWriteReplyObserver::ObserveNextWriteCallback(
     JsonPrefStore* json_pref_store) {
   json_pref_store->RegisterOnNextSuccessfulWriteReply(
-      base::Bind(&SuccessfulWriteReplyObserver::OnSuccessfulWrite,
-                 base::Unretained(this)));
+      base::BindOnce(&SuccessfulWriteReplyObserver::OnSuccessfulWrite,
+                     base::Unretained(this)));
 }
 
 enum WriteCallbackObservationState {
@@ -758,10 +758,10 @@ class WriteCallbacksObserver {
   WriteCallbackObservationState GetAndResetPostWriteObservationState();
 
   JsonPrefStore::OnWriteCallbackPair GetCallbackPair() {
-    return std::make_pair(
-        base::Bind(&WriteCallbacksObserver::OnPreWrite, base::Unretained(this)),
-        base::Bind(&WriteCallbacksObserver::OnPostWrite,
-                   base::Unretained(this)));
+    return std::make_pair(base::BindOnce(&WriteCallbacksObserver::OnPreWrite,
+                                         base::Unretained(this)),
+                          base::BindOnce(&WriteCallbacksObserver::OnPostWrite,
+                                         base::Unretained(this)));
   }
 
   void OnPreWrite() {
@@ -821,10 +821,10 @@ class JsonPrefStoreCallbackTest : public testing::Test {
 
   void TriggerFakeWriteForCallback(JsonPrefStore* pref_store, bool success) {
     JsonPrefStore::PostWriteCallback(
-        base::Bind(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback,
-                   pref_store->AsWeakPtr()),
-        base::Bind(&WriteCallbacksObserver::OnPostWrite,
-                   base::Unretained(&write_callback_observer_)),
+        base::BindOnce(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback,
+                       pref_store->AsWeakPtr()),
+        base::BindOnce(&WriteCallbacksObserver::OnPostWrite,
+                       base::Unretained(&write_callback_observer_)),
         base::SequencedTaskRunnerHandle::Get(), success);
   }
 

components/prefs/mock_pref_change_callback.cc

@@ -13,8 +13,8 @@ MockPrefChangeCallback::MockPrefChangeCallback(PrefService* prefs)
 MockPrefChangeCallback::~MockPrefChangeCallback() {}
 
 PrefChangeRegistrar::NamedChangeCallback MockPrefChangeCallback::GetCallback() {
-  return base::Bind(&MockPrefChangeCallback::OnPreferenceChanged,
-                    base::Unretained(this));
+  return base::BindRepeating(&MockPrefChangeCallback::OnPreferenceChanged,
+                             base::Unretained(this));
 }
 
 void MockPrefChangeCallback::Expect(const std::string& pref_name,

components/prefs/pref_change_registrar.cc

@@ -82,9 +82,10 @@ void PrefChangeRegistrar::OnPreferenceChanged(PrefService* service,
     observers_[pref].Run(pref);
 }
 
-void PrefChangeRegistrar::InvokeUnnamedCallback(base::OnceClosure callback,
-                                                const std::string& pref_name) {
-  std::move(callback).Run();
+void PrefChangeRegistrar::InvokeUnnamedCallback(
+    const base::RepeatingClosure& callback,
+    const std::string& pref_name) {
+  callback.Run();
 }
 
 PrefService* PrefChangeRegistrar::prefs() {

components/prefs/pref_change_registrar.h

@@ -67,7 +67,7 @@ class COMPONENTS_PREFS_EXPORT PrefChangeRegistrar final : public PrefObserver {
   void OnPreferenceChanged(PrefService* service,
                            const std::string& pref_name) override;
 
-  static void InvokeUnnamedCallback(base::OnceClosure callback,
+  static void InvokeUnnamedCallback(const base::RepeatingClosure& callback,
                                     const std::string& pref_name);
 
   using ObserverMap = std::map<std::string, NamedChangeCallback>;

components/prefs/pref_change_registrar_unittest.cc

@@ -34,6 +34,12 @@ class MockPrefService : public TestingPrefServiceSimple {
   MOCK_METHOD2(RemovePrefObserver, void(const std::string&, PrefObserver*));
 };
 
+// Due to overloads, base::DoNothing() cannot be passed directly to
+// PrefChangeRegistrar::Add() as it is convertible to all callbacks.
+base::RepeatingClosure DoNothingClosure() {
+  return base::DoNothing();
+}
+
 }  // namespace
 
 class PrefChangeRegistrarTest : public testing::Test {
@@ -44,8 +50,6 @@ class PrefChangeRegistrarTest : public testing::Test {
  protected:
   void SetUp() override;
 
-  base::Closure observer() const { return base::DoNothing(); }
-
   MockPrefService* service() const { return service_.get(); }
 
  private:
@@ -65,8 +69,8 @@ TEST_F(PrefChangeRegistrarTest, AddAndRemove) {
               AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
   EXPECT_CALL(*service(),
               AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
-  registrar.Add("test.pref.1", observer());
-  registrar.Add("test.pref.2", observer());
+  registrar.Add("test.pref.1", DoNothingClosure());
+  registrar.Add("test.pref.2", DoNothingClosure());
   EXPECT_FALSE(registrar.IsEmpty());
 
   // Test removing.
@@ -91,7 +95,7 @@ TEST_F(PrefChangeRegistrarTest, AutoRemove) {
   // Setup of auto-remove.
   EXPECT_CALL(*service(),
               AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
-  registrar.Add("test.pref.1", observer());
+  registrar.Add("test.pref.1", DoNothingClosure());
   Mock::VerifyAndClearExpectations(service());
   EXPECT_FALSE(registrar.IsEmpty());
 
@@ -108,8 +112,8 @@ TEST_F(PrefChangeRegistrarTest, RemoveAll) {
               AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
   EXPECT_CALL(*service(),
               AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
-  registrar.Add("test.pref.1", observer());
-  registrar.Add("test.pref.2", observer());
+  registrar.Add("test.pref.1", DoNothingClosure());
+  registrar.Add("test.pref.2", DoNothingClosure());
   Mock::VerifyAndClearExpectations(service());
 
   EXPECT_CALL(*service(),
@@ -136,10 +140,9 @@ class ObserveSetOfPreferencesTest : public testing::Test {
 
   PrefChangeRegistrar* CreatePrefChangeRegistrar() {
     PrefChangeRegistrar* pref_set = new PrefChangeRegistrar();
-    base::Closure callback = base::DoNothing();
     pref_set->Init(pref_service_.get());
-    pref_set->Add(kHomePage, callback);
-    pref_set->Add(kHomePageIsNewTabPage, callback);
+    pref_set->Add(kHomePage, DoNothingClosure());
+    pref_set->Add(kHomePageIsNewTabPage, DoNothingClosure());
     return pref_set;
   }
 
@@ -175,9 +178,9 @@ TEST_F(ObserveSetOfPreferencesTest, Observe) {
   using testing::Mock;
 
   PrefChangeRegistrar pref_set;
-  PrefChangeRegistrar::NamedChangeCallback callback = base::Bind(
-      &ObserveSetOfPreferencesTest::OnPreferenceChanged,
-      base::Unretained(this));
+  PrefChangeRegistrar::NamedChangeCallback callback =
+      base::BindRepeating(&ObserveSetOfPreferencesTest::OnPreferenceChanged,
+                          base::Unretained(this));
   pref_set.Init(pref_service_.get());
   pref_set.Add(kHomePage, callback);
   pref_set.Add(kHomePageIsNewTabPage, callback);

components/prefs/pref_member.cc

@@ -54,37 +54,37 @@ void PrefMemberBase::MoveToSequence(
   VerifyValuePrefName();
   // Load the value from preferences if it hasn't been loaded so far.
   if (!internal())
-    UpdateValueFromPref(base::Closure());
+    UpdateValueFromPref(base::OnceClosure());
   internal()->MoveToSequence(std::move(task_runner));
 }
 
 void PrefMemberBase::OnPreferenceChanged(PrefService* service,
                                          const std::string& pref_name) {
   VerifyValuePrefName();
-  UpdateValueFromPref((!setting_value_ && !observer_.is_null()) ?
-      base::Bind(observer_, pref_name) : base::Closure());
+  UpdateValueFromPref((!setting_value_ && !observer_.is_null())
+                          ? base::BindOnce(observer_, pref_name)
+                          : base::OnceClosure());
 }
 
-void PrefMemberBase::UpdateValueFromPref(const base::Closure& callback) const {
+void PrefMemberBase::UpdateValueFromPref(base::OnceClosure callback) const {
   VerifyValuePrefName();
   const PrefService::Preference* pref = prefs_->FindPreference(pref_name_);
   DCHECK(pref);
   if (!internal())
     CreateInternal();
-  internal()->UpdateValue(pref->GetValue()->DeepCopy(),
-                          pref->IsManaged(),
-                          pref->IsUserModifiable(),
-                          callback);
+  internal()->UpdateValue(pref->GetValue()->DeepCopy(), pref->IsManaged(),
+                          pref->IsUserModifiable(), std::move(callback));
 }
 
 void PrefMemberBase::VerifyPref() const {
   VerifyValuePrefName();
   if (!internal())
-    UpdateValueFromPref(base::Closure());
+    UpdateValueFromPref(base::OnceClosure());
 }
 
-void PrefMemberBase::InvokeUnnamedCallback(const base::Closure& callback,
-                                           const std::string& pref_name) {
+void PrefMemberBase::InvokeUnnamedCallback(
+    const base::RepeatingClosure& callback,
+    const std::string& pref_name) {
   callback.Run();
 }
 

components/prefs/pref_member.h

@@ -46,7 +46,7 @@ class COMPONENTS_PREFS_EXPORT PrefMemberBase : public PrefObserver {
  public:
   // Type of callback you can register if you need to know the name of
   // the pref that is changing.
-  typedef base::Callback<void(const std::string&)> NamedChangeCallback;
+  using NamedChangeCallback = base::RepeatingCallback<void(const std::string&)>;
 
   PrefService* prefs() { return prefs_; }
   const PrefService* prefs() const { return prefs_; }
@@ -123,7 +123,7 @@ class COMPONENTS_PREFS_EXPORT PrefMemberBase : public PrefObserver {
   // This method is used to do the actual sync with the preference.
   // Note: it is logically const, because it doesn't modify the state
   // seen by the outside world. It is just doing a lazy load behind the scenes.
-  void UpdateValueFromPref(const base::Closure& callback) const;
+  void UpdateValueFromPref(base::OnceClosure callback) const;
 
   // Verifies the preference name, and lazily loads the preference value if
   // it hasn't been loaded yet.
@@ -133,8 +133,8 @@ class COMPONENTS_PREFS_EXPORT PrefMemberBase : public PrefObserver {
 
   virtual Internal* internal() const = 0;
 
-  // Used to allow registering plain base::Closure callbacks.
-  static void InvokeUnnamedCallback(const base::Closure& callback,
+  // Used to allow registering plain base::RepeatingClosure callbacks.
+  static void InvokeUnnamedCallback(const base::RepeatingClosure& callback,
                                     const std::string& pref_name);
 
  private:
@@ -173,10 +173,10 @@ class PrefMember : public subtle::PrefMemberBase {
   }
   void Init(const std::string& pref_name,
             PrefService* prefs,
-            const base::Closure& observer) {
+            const base::RepeatingClosure& observer) {
     subtle::PrefMemberBase::Init(
         pref_name, prefs,
-        base::Bind(&PrefMemberBase::InvokeUnnamedCallback, observer));
+        base::BindRepeating(&PrefMemberBase::InvokeUnnamedCallback, observer));
   }
   void Init(const std::string& pref_name, PrefService* prefs) {
     subtle::PrefMemberBase::Init(pref_name, prefs);

components/prefs/pref_member_unittest.cc

@@ -80,8 +80,8 @@ class PrefMemberTestClass {
   explicit PrefMemberTestClass(PrefService* prefs)
       : observe_cnt_(0), prefs_(prefs) {
     str_.Init(kStringPref, prefs,
-              base::Bind(&PrefMemberTestClass::OnPreferenceChanged,
-                         base::Unretained(this)));
+              base::BindRepeating(&PrefMemberTestClass::OnPreferenceChanged,
+                                  base::Unretained(this)));
   }
 
   void OnPreferenceChanged(const std::string& pref_name) {

components/prefs/pref_value_store.h

@@ -33,7 +33,7 @@ class PrefStore;
 // be called on the UI thread.
 class COMPONENTS_PREFS_EXPORT PrefValueStore {
  public:
-  typedef base::Callback<void(const std::string&)> PrefChangedCallback;
+  using PrefChangedCallback = base::Callback<void(const std::string&)>;
 
   // Delegate used to observe certain events in the |PrefValueStore|'s lifetime.
   class Delegate {

components/prefs/pref_value_store_unittest.cc

@@ -122,8 +122,8 @@ class PrefValueStoreTest : public testing::Test {
                            &pref_notifier_));
 
     pref_value_store_->set_callback(
-        base::Bind(&MockPrefModelAssociator::ProcessPrefChange,
-                   base::Unretained(sync_associator_.get())));
+        base::BindRepeating(&MockPrefModelAssociator::ProcessPrefChange,
+                            base::Unretained(sync_associator_.get())));
   }
 
   void CreateManagedPrefs() {

components/prefs/testing_pref_service.cc

@@ -34,8 +34,9 @@ TestingPrefServiceBase<PrefService, PrefRegistry>::TestingPrefServiceBase(
                                            pref_notifier),
           user_prefs,
           pref_registry,
-          base::Bind(&TestingPrefServiceBase<PrefService,
-                                             PrefRegistry>::HandleReadError),
+          base::BindRepeating(
+              &TestingPrefServiceBase<PrefService,
+                                      PrefRegistry>::HandleReadError),
           false),
       managed_prefs_(managed_prefs),
       extension_prefs_(extension_prefs),