[floc] bugfix: use profile-level prefs instead of browser-level

Bug: 1154556
Change-Id: Ib4d6bbb1f94fac80823b729b963f36becd1f3792
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2568939
Commit-Queue: Yao Xiao <yaoxia@chromium.org>
Reviewed-by: Josh Karlin <jkarlin@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#833091}

chrome/browser/federated_learning/floc_id_provider_browsertest.cc

@@ -82,6 +82,10 @@ class FlocIdProviderBrowserTest : public InProcessBrowserTest {
     return FlocIdProviderFactory::GetForProfile(browser()->profile());
   }
 
+  PrefService* floc_prefs() {
+    return static_cast<FlocIdProviderImpl*>(floc_id_provider())->prefs_;
+  }
+
   FlocId GetFlocId() {
     return static_cast<FlocIdProviderImpl*>(floc_id_provider())->floc_id_;
   }
@@ -111,6 +115,11 @@ IN_PROC_BROWSER_TEST_F(FlocIdProviderBrowserTest, NoProviderInIncognitoMode) {
   ASSERT_FALSE(incognito_floc_id_provider);
 }
 
+IN_PROC_BROWSER_TEST_F(FlocIdProviderBrowserTest, PrefsMember) {
+  EXPECT_EQ(floc_prefs(), browser()->profile()->GetPrefs());
+  EXPECT_NE(floc_prefs(), g_browser_process->local_state());
+}
+
 class MockFlocRemotePermissionService : public FlocRemotePermissionService {
  public:
   using FlocRemotePermissionService::FlocRemotePermissionService;

chrome/browser/federated_learning/floc_id_provider_factory.cc

@@ -75,9 +75,9 @@ KeyedService* FlocIdProviderFactory::BuildServiceInstanceFor(
   if (!user_event_service)
     return nullptr;
 
-  return new FlocIdProviderImpl(sync_service, std::move(cookie_settings),
-                                floc_remote_permission_service, history_service,
-                                user_event_service);
+  return new FlocIdProviderImpl(
+      profile->GetPrefs(), sync_service, std::move(cookie_settings),
+      floc_remote_permission_service, history_service, user_event_service);
 }
 
 }  // namespace federated_learning

chrome/browser/federated_learning/floc_id_provider_impl.cc

@@ -39,12 +39,14 @@ base::TimeDelta GetFlocIdScheduledUpdateInterval() {
 }  // namespace
 
 FlocIdProviderImpl::FlocIdProviderImpl(
+    PrefService* prefs,
     syncer::SyncService* sync_service,
     scoped_refptr<content_settings::CookieSettings> cookie_settings,
     FlocRemotePermissionService* floc_remote_permission_service,
     history::HistoryService* history_service,
     syncer::UserEventService* user_event_service)
-    : sync_service_(sync_service),
+    : prefs_(prefs),
+      sync_service_(sync_service),
       cookie_settings_(std::move(cookie_settings)),
       floc_remote_permission_service_(floc_remote_permission_service),
       history_service_(history_service),
@@ -53,8 +55,7 @@ FlocIdProviderImpl::FlocIdProviderImpl(
   sync_service_->AddObserver(this);
   g_browser_process->floc_sorting_lsh_clusters_service()->AddObserver(this);
 
-  PrefService* local_state = g_browser_process->local_state();
-  base::Time last_compute_time = FlocId::ReadComputeTimeFromPrefs(local_state);
+  base::Time last_compute_time = FlocId::ReadComputeTimeFromPrefs(prefs_);
 
   if (!last_compute_time.is_null()) {
     first_floc_computed_ = true;
@@ -64,7 +65,7 @@ FlocIdProviderImpl::FlocIdProviderImpl(
     if (time_since_last_compute < GetFlocIdScheduledUpdateInterval()) {
       // Keep using the last floc. Schedule a recompute event when it's
       // |GetFlocIdScheduledUpdateInterval()| from the last compute time.
-      floc_id_ = FlocId::ReadFromPrefs(local_state);
+      floc_id_ = FlocId::ReadFromPrefs(prefs_);
       ScheduleFlocComputation(GetFlocIdScheduledUpdateInterval() -
                               time_since_last_compute);
     }
@@ -118,9 +119,8 @@ void FlocIdProviderImpl::OnComputeFlocCompleted(ComputeFlocTrigger trigger,
   LogFlocComputedEvent(trigger, result);
   floc_id_ = result.floc_id;
 
-  PrefService* local_state = g_browser_process->local_state();
-  floc_id_.SaveToPrefs(local_state);
-  FlocId::SaveComputeTimeToPrefs(base::Time::Now(), local_state);
+  floc_id_.SaveToPrefs(prefs_);
+  FlocId::SaveComputeTimeToPrefs(base::Time::Now(), prefs_);
 
   ScheduleFlocComputation(GetFlocIdScheduledUpdateInterval());
 }
@@ -210,7 +210,7 @@ void FlocIdProviderImpl::OnURLsDeleted(
   // history-delete.
   LogFlocComputedEvent(ComputeFlocTrigger::kHistoryDelete, ComputeFlocResult());
   floc_id_ = FlocId();
-  floc_id_.SaveToPrefs(g_browser_process->local_state());
+  floc_id_.SaveToPrefs(prefs_);
 }
 
 void FlocIdProviderImpl::OnSortingLshClustersFileReady() {

chrome/browser/federated_learning/floc_id_provider_impl.h

@@ -101,6 +101,7 @@ class FlocIdProviderImpl : public FlocIdProvider,
       history::HistoryService::QueryHistoryCallback;
 
   FlocIdProviderImpl(
+      PrefService* prefs,
       syncer::SyncService* sync_service,
       scoped_refptr<content_settings::CookieSettings> cookie_settings,
       FlocRemotePermissionService* floc_remote_permission_service,
@@ -203,6 +204,14 @@ class FlocIdProviderImpl : public FlocIdProvider,
   bool first_sorting_lsh_file_ready_seen_ = false;
   bool first_sync_history_enabled_seen_ = false;
 
+  // The following raw pointer references are guaranteed to outlive this object.
+  // |prefs_| is owned by Profile, and it won't be destroyed until the
+  // destructor of Profile is called, where all the profile-keyed services
+  // including this object will be destroyed. Other services are all created by
+  // profile-keyed service factories, and the dependency declared in
+  // FlocIdProviderFactory::FlocIdProviderFactory() guarantees that this object
+  // will be destroyed first among those services.
+  PrefService* prefs_;
   syncer::SyncService* sync_service_;
   scoped_refptr<content_settings::CookieSettings> cookie_settings_;
   FlocRemotePermissionService* floc_remote_permission_service_;

chrome/browser/federated_learning/floc_id_provider_unittest.cc

@@ -204,9 +204,8 @@ class FlocIdProviderUnitTest : public testing::Test {
   ~FlocIdProviderUnitTest() override = default;
 
   void SetUp() override {
-    FlocId::RegisterPrefs(pref_service_.registry());
+    FlocId::RegisterPrefs(prefs_.registry());
     InitializeFlocPrefs();
-    TestingBrowserProcess::GetGlobal()->SetLocalState(&pref_service_);
 
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
 
@@ -241,7 +240,7 @@ class FlocIdProviderUnitTest : public testing::Test {
         settings_map_.get(), &prefs_, false, "chrome-extension");
 
     floc_id_provider_ = std::make_unique<MockFlocIdProvider>(
-        test_sync_service_.get(), fake_cookie_settings_,
+        &prefs_, test_sync_service_.get(), fake_cookie_settings_,
         fake_floc_remote_permission_service_.get(), history_service_.get(),
         fake_user_event_service_.get());
 
@@ -340,7 +339,6 @@ class FlocIdProviderUnitTest : public testing::Test {
   content::BrowserTaskEnvironment task_environment_;
 
   sync_preferences::TestingPrefServiceSyncable prefs_;
-  TestingPrefServiceSimple pref_service_;
   scoped_refptr<HostContentSettingsMap> settings_map_;
 
   std::unique_ptr<history::HistoryService> history_service_;
@@ -1335,8 +1333,8 @@ class FlocIdProviderUnitTestLastFlocUnexpired
     base::Time last_compute_time =
         base::Time::Now() - base::TimeDelta::FromHours(12);
 
-    floc_id.SaveToPrefs(&pref_service_);
-    FlocId::SaveComputeTimeToPrefs(last_compute_time, &pref_service_);
+    floc_id.SaveToPrefs(&prefs_);
+    FlocId::SaveComputeTimeToPrefs(last_compute_time, &prefs_);
   }
 
   void InitializeHistory() override {
@@ -1389,7 +1387,7 @@ TEST_F(FlocIdProviderUnitTestLastFlocUnexpired, NextScheduledUpdate) {
   task_environment_.RunUntilIdle();
 
   // Expect that the floc prefs hasn't changed at this stage.
-  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&pref_service_));
+  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&prefs_));
 
   // Fast forward by 12 hours. This should trigger a scheduled update.
   task_environment_.FastForwardBy(base::TimeDelta::FromHours(12));
@@ -1411,9 +1409,8 @@ TEST_F(FlocIdProviderUnitTestLastFlocUnexpired, NextScheduledUpdate) {
   EXPECT_EQ(FlocId::SimHashHistory({"foo.com", "domain1.com", "domain2.com"}),
             event.floc_id());
 
-  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&pref_service_));
-  EXPECT_EQ(base::Time::Now(),
-            FlocId::ReadComputeTimeFromPrefs(&pref_service_));
+  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&prefs_));
+  EXPECT_EQ(base::Time::Now(), FlocId::ReadComputeTimeFromPrefs(&prefs_));
 }
 
 TEST_F(FlocIdProviderUnitTestLastFlocUnexpired, HistoryDelete) {
@@ -1439,9 +1436,9 @@ TEST_F(FlocIdProviderUnitTestLastFlocUnexpired, HistoryDelete) {
   // changed.
   EXPECT_EQ(0u, floc_id_provider_->compute_floc_completed_count());
   EXPECT_FALSE(floc_id().IsValid());
-  EXPECT_FALSE(FlocId::ReadFromPrefs(&pref_service_).IsValid());
+  EXPECT_FALSE(FlocId::ReadFromPrefs(&prefs_).IsValid());
   EXPECT_EQ(base::Time::Now() - base::TimeDelta::FromHours(12),
-            FlocId::ReadComputeTimeFromPrefs(&pref_service_));
+            FlocId::ReadComputeTimeFromPrefs(&prefs_));
 }
 
 class FlocIdProviderUnitTestLastFlocExpired
@@ -1458,8 +1455,8 @@ class FlocIdProviderUnitTestLastFlocExpired
     base::Time last_compute_time =
         base::Time::Now() - base::TimeDelta::FromHours(25);
 
-    floc_id.SaveToPrefs(&pref_service_);
-    FlocId::SaveComputeTimeToPrefs(last_compute_time, &pref_service_);
+    floc_id.SaveToPrefs(&prefs_);
+    FlocId::SaveComputeTimeToPrefs(last_compute_time, &prefs_);
   }
 
   void InitializeHistory() override {
@@ -1526,9 +1523,8 @@ TEST_F(FlocIdProviderUnitTestLastFlocExpired, ComputeOnInitialSetupReady) {
             event.event_trigger());
   EXPECT_EQ(FlocId::SimHashHistory({"foo.com"}), event.floc_id());
 
-  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&pref_service_));
-  EXPECT_EQ(base::Time::Now(),
-            FlocId::ReadComputeTimeFromPrefs(&pref_service_));
+  EXPECT_EQ(floc_id(), FlocId::ReadFromPrefs(&prefs_));
+  EXPECT_EQ(base::Time::Now(), FlocId::ReadComputeTimeFromPrefs(&prefs_));
 }
 
 }  // namespace federated_learning

chrome/browser/prefs/browser_prefs.cc

@@ -593,7 +593,6 @@ void RegisterLocalState(PrefRegistrySimple* registry) {
   ChromeTracingDelegate::RegisterPrefs(registry);
   component_updater::RegisterPrefs(registry);
   ExternalProtocolHandler::RegisterPrefs(registry);
-  federated_learning::FlocId::RegisterPrefs(registry);
   flags_ui::PrefServiceFlagsStorage::RegisterPrefs(registry);
   GpuModeManager::RegisterPrefs(registry);
   signin::IdentityManager::RegisterLocalStatePrefs(registry);
@@ -805,6 +804,7 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry,
   dom_distiller::DistilledPagePrefs::RegisterProfilePrefs(registry);
   dom_distiller::RegisterProfilePrefs(registry);
   DownloadPrefs::RegisterProfilePrefs(registry);
+  federated_learning::FlocId::RegisterPrefs(registry);
   HostContentSettingsMap::RegisterProfilePrefs(registry);
   HttpsImageCompressionInfoBarDecider::RegisterProfilePrefs(registry);
   image_fetcher::ImageCache::RegisterProfilePrefs(registry);

components/federated_learning/floc_id.cc

@@ -76,38 +76,38 @@ void FlocId::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterTimePref(kFlocIdComputeTimePrefKey, base::Time());
 }
 
-void FlocId::SaveToPrefs(PrefService* local_state) {
+void FlocId::SaveToPrefs(PrefService* prefs) {
   if (!id_.has_value()) {
-    local_state->ClearPref(kFlocIdValuePrefKey);
+    prefs->ClearPref(kFlocIdValuePrefKey);
     return;
   }
 
-  local_state->SetUint64(kFlocIdValuePrefKey, id_.value());
-  local_state->SetTime(kFlocIdHistoryBeginTimePrefKey, history_begin_time_);
-  local_state->SetTime(kFlocIdHistoryEndTimePrefKey, history_end_time_);
-  local_state->SetUint64(kFlocIdSortingLshVersionPrefKey, sorting_lsh_version_);
+  prefs->SetUint64(kFlocIdValuePrefKey, id_.value());
+  prefs->SetTime(kFlocIdHistoryBeginTimePrefKey, history_begin_time_);
+  prefs->SetTime(kFlocIdHistoryEndTimePrefKey, history_end_time_);
+  prefs->SetUint64(kFlocIdSortingLshVersionPrefKey, sorting_lsh_version_);
 }
 
 // static
-FlocId FlocId::ReadFromPrefs(PrefService* local_state) {
-  if (!local_state->HasPrefPath(kFlocIdValuePrefKey))
+FlocId FlocId::ReadFromPrefs(PrefService* prefs) {
+  if (!prefs->HasPrefPath(kFlocIdValuePrefKey))
     return FlocId();
 
-  return FlocId(local_state->GetUint64(kFlocIdValuePrefKey),
-                local_state->GetTime(kFlocIdHistoryBeginTimePrefKey),
-                local_state->GetTime(kFlocIdHistoryEndTimePrefKey),
-                local_state->GetUint64(kFlocIdSortingLshVersionPrefKey));
+  return FlocId(prefs->GetUint64(kFlocIdValuePrefKey),
+                prefs->GetTime(kFlocIdHistoryBeginTimePrefKey),
+                prefs->GetTime(kFlocIdHistoryEndTimePrefKey),
+                prefs->GetUint64(kFlocIdSortingLshVersionPrefKey));
 }
 
 // static
 void FlocId::SaveComputeTimeToPrefs(base::Time compute_time,
-                                    PrefService* local_state) {
-  local_state->SetTime(kFlocIdComputeTimePrefKey, compute_time);
+                                    PrefService* prefs) {
+  prefs->SetTime(kFlocIdComputeTimePrefKey, compute_time);
 }
 
 // static
-base::Time FlocId::ReadComputeTimeFromPrefs(PrefService* local_state) {
-  return local_state->GetTime(kFlocIdComputeTimePrefKey);
+base::Time FlocId::ReadComputeTimeFromPrefs(PrefService* prefs) {
+  return prefs->GetTime(kFlocIdComputeTimePrefKey);
 }
 
 }  // namespace federated_learning

components/federated_learning/floc_id.h

@@ -56,12 +56,12 @@ class FlocId {
 
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
-  void SaveToPrefs(PrefService* local_state);
-  static FlocId ReadFromPrefs(PrefService* local_state);
+  void SaveToPrefs(PrefService* prefs);
+  static FlocId ReadFromPrefs(PrefService* prefs);
 
   static void SaveComputeTimeToPrefs(base::Time compute_time,
-                                     PrefService* local_state);
-  static base::Time ReadComputeTimeFromPrefs(PrefService* local_state);
+                                     PrefService* prefs);
+  static base::Time ReadComputeTimeFromPrefs(PrefService* prefs);
 
  private:
   base::Optional<uint64_t> id_;

components/federated_learning/floc_id_unittest.cc

@@ -40,95 +40,94 @@ TEST(FlocIdTest, ToStringForJsApi) {
 }
 
 TEST(FlocIdTest, ReadFromPrefs_DefaultInvalid) {
-  TestingPrefServiceSimple local_state;
-  FlocId::RegisterPrefs(local_state.registry());
+  TestingPrefServiceSimple prefs;
+  FlocId::RegisterPrefs(prefs.registry());
 
-  FlocId floc_id = FlocId::ReadFromPrefs(&local_state);
+  FlocId floc_id = FlocId::ReadFromPrefs(&prefs);
   EXPECT_FALSE(floc_id.IsValid());
 
-  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&local_state);
+  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&prefs);
   EXPECT_TRUE(compute_time.is_null());
 }
 
 TEST(FlocIdTest, ReadFromPrefs_SavedInvalid) {
-  TestingPrefServiceSimple local_state;
-  FlocId::RegisterPrefs(local_state.registry());
+  TestingPrefServiceSimple prefs;
+  FlocId::RegisterPrefs(prefs.registry());
 
-  local_state.ClearPref(kFlocIdValuePrefKey);
-  local_state.SetTime(kFlocIdHistoryBeginTimePrefKey, base::Time::FromTimeT(1));
-  local_state.SetTime(kFlocIdHistoryEndTimePrefKey, base::Time::FromTimeT(2));
-  local_state.SetUint64(kFlocIdSortingLshVersionPrefKey, 2);
+  prefs.ClearPref(kFlocIdValuePrefKey);
+  prefs.SetTime(kFlocIdHistoryBeginTimePrefKey, base::Time::FromTimeT(1));
+  prefs.SetTime(kFlocIdHistoryEndTimePrefKey, base::Time::FromTimeT(2));
+  prefs.SetUint64(kFlocIdSortingLshVersionPrefKey, 2);
 
-  FlocId floc_id = FlocId::ReadFromPrefs(&local_state);
+  FlocId floc_id = FlocId::ReadFromPrefs(&prefs);
   EXPECT_FALSE(floc_id.IsValid());
 
-  local_state.SetTime(kFlocIdComputeTimePrefKey, base::Time());
-  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&local_state);
+  prefs.SetTime(kFlocIdComputeTimePrefKey, base::Time());
+  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&prefs);
   EXPECT_TRUE(compute_time.is_null());
 }
 
 TEST(FlocIdTest, ReadFromPrefs_SavedValid) {
-  TestingPrefServiceSimple local_state;
-  FlocId::RegisterPrefs(local_state.registry());
+  TestingPrefServiceSimple prefs;
+  FlocId::RegisterPrefs(prefs.registry());
 
-  local_state.SetUint64(kFlocIdValuePrefKey, 123);
-  local_state.SetTime(kFlocIdHistoryBeginTimePrefKey, base::Time::FromTimeT(1));
-  local_state.SetTime(kFlocIdHistoryEndTimePrefKey, base::Time::FromTimeT(2));
-  local_state.SetUint64(kFlocIdSortingLshVersionPrefKey, 2);
+  prefs.SetUint64(kFlocIdValuePrefKey, 123);
+  prefs.SetTime(kFlocIdHistoryBeginTimePrefKey, base::Time::FromTimeT(1));
+  prefs.SetTime(kFlocIdHistoryEndTimePrefKey, base::Time::FromTimeT(2));
+  prefs.SetUint64(kFlocIdSortingLshVersionPrefKey, 2);
 
-  FlocId floc_id = FlocId::ReadFromPrefs(&local_state);
+  FlocId floc_id = FlocId::ReadFromPrefs(&prefs);
   EXPECT_EQ(floc_id,
             FlocId(123, base::Time::FromTimeT(1), base::Time::FromTimeT(2), 2));
 
-  local_state.SetTime(kFlocIdComputeTimePrefKey, base::Time::FromTimeT(3));
-  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&local_state);
+  prefs.SetTime(kFlocIdComputeTimePrefKey, base::Time::FromTimeT(3));
+  base::Time compute_time = FlocId::ReadComputeTimeFromPrefs(&prefs);
   EXPECT_EQ(compute_time, base::Time::FromTimeT(3));
 }
 
 TEST(FlocIdTest, SaveToPrefs_InvalidFloc) {
-  TestingPrefServiceSimple local_state;
-  FlocId::RegisterPrefs(local_state.registry());
+  TestingPrefServiceSimple prefs;
+  FlocId::RegisterPrefs(prefs.registry());
 
   FlocId floc_id;
-  floc_id.SaveToPrefs(&local_state);
+  floc_id.SaveToPrefs(&prefs);
 
-  EXPECT_FALSE(local_state.HasPrefPath(kFlocIdValuePrefKey));
-  EXPECT_FALSE(local_state.HasPrefPath(kFlocIdHistoryBeginTimePrefKey));
-  EXPECT_FALSE(local_state.HasPrefPath(kFlocIdHistoryEndTimePrefKey));
-  EXPECT_FALSE(local_state.HasPrefPath(kFlocIdSortingLshVersionPrefKey));
+  EXPECT_FALSE(prefs.HasPrefPath(kFlocIdValuePrefKey));
+  EXPECT_FALSE(prefs.HasPrefPath(kFlocIdHistoryBeginTimePrefKey));
+  EXPECT_FALSE(prefs.HasPrefPath(kFlocIdHistoryEndTimePrefKey));
+  EXPECT_FALSE(prefs.HasPrefPath(kFlocIdSortingLshVersionPrefKey));
 
-  EXPECT_EQ(0u, local_state.GetUint64(kFlocIdValuePrefKey));
-  EXPECT_TRUE(local_state.GetTime(kFlocIdHistoryBeginTimePrefKey).is_null());
-  EXPECT_TRUE(local_state.GetTime(kFlocIdHistoryEndTimePrefKey).is_null());
-  EXPECT_EQ(0u, local_state.GetUint64(kFlocIdSortingLshVersionPrefKey));
+  EXPECT_EQ(0u, prefs.GetUint64(kFlocIdValuePrefKey));
+  EXPECT_TRUE(prefs.GetTime(kFlocIdHistoryBeginTimePrefKey).is_null());
+  EXPECT_TRUE(prefs.GetTime(kFlocIdHistoryEndTimePrefKey).is_null());
+  EXPECT_EQ(0u, prefs.GetUint64(kFlocIdSortingLshVersionPrefKey));
 
-  FlocId::SaveComputeTimeToPrefs(base::Time(), &local_state);
-  EXPECT_TRUE(local_state.GetTime(kFlocIdComputeTimePrefKey).is_null());
+  FlocId::SaveComputeTimeToPrefs(base::Time(), &prefs);
+  EXPECT_TRUE(prefs.GetTime(kFlocIdComputeTimePrefKey).is_null());
 }
 
 TEST(FlocIdTest, SaveToPrefs_ValidFloc) {
-  TestingPrefServiceSimple local_state;
-  FlocId::RegisterPrefs(local_state.registry());
+  TestingPrefServiceSimple prefs;
+  FlocId::RegisterPrefs(prefs.registry());
 
   FlocId floc_id =
       FlocId(123, base::Time::FromTimeT(1), base::Time::FromTimeT(2), 2);
-  floc_id.SaveToPrefs(&local_state);
+  floc_id.SaveToPrefs(&prefs);
 
-  EXPECT_TRUE(local_state.HasPrefPath(kFlocIdValuePrefKey));
-  EXPECT_TRUE(local_state.HasPrefPath(kFlocIdHistoryBeginTimePrefKey));
-  EXPECT_TRUE(local_state.HasPrefPath(kFlocIdHistoryEndTimePrefKey));
-  EXPECT_TRUE(local_state.HasPrefPath(kFlocIdSortingLshVersionPrefKey));
+  EXPECT_TRUE(prefs.HasPrefPath(kFlocIdValuePrefKey));
+  EXPECT_TRUE(prefs.HasPrefPath(kFlocIdHistoryBeginTimePrefKey));
+  EXPECT_TRUE(prefs.HasPrefPath(kFlocIdHistoryEndTimePrefKey));
+  EXPECT_TRUE(prefs.HasPrefPath(kFlocIdSortingLshVersionPrefKey));
 
-  EXPECT_EQ(123u, local_state.GetUint64(kFlocIdValuePrefKey));
+  EXPECT_EQ(123u, prefs.GetUint64(kFlocIdValuePrefKey));
   EXPECT_EQ(base::Time::FromTimeT(1),
-            local_state.GetTime(kFlocIdHistoryBeginTimePrefKey));
+            prefs.GetTime(kFlocIdHistoryBeginTimePrefKey));
   EXPECT_EQ(base::Time::FromTimeT(2),
-            local_state.GetTime(kFlocIdHistoryEndTimePrefKey));
-  EXPECT_EQ(2u, local_state.GetUint64(kFlocIdSortingLshVersionPrefKey));
+            prefs.GetTime(kFlocIdHistoryEndTimePrefKey));
+  EXPECT_EQ(2u, prefs.GetUint64(kFlocIdSortingLshVersionPrefKey));
 
-  FlocId::SaveComputeTimeToPrefs(base::Time::FromTimeT(3), &local_state);
-  EXPECT_EQ(base::Time::FromTimeT(3),
-            local_state.GetTime(kFlocIdComputeTimePrefKey));
+  FlocId::SaveComputeTimeToPrefs(base::Time::FromTimeT(3), &prefs);
+  EXPECT_EQ(base::Time::FromTimeT(3), prefs.GetTime(kFlocIdComputeTimePrefKey));
 }
 
 }  // namespace federated_learning