[Autofill] Remove direct use of base::Time::Now() in Autofill

components/autofill/core/browser/personal_data_manager_unittest.cc

 // Copyright 2013 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/autofill/core/browser/personal_data_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager_observer.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
+#include "components/autofill/core/common/autofill_clock.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/os_crypt/os_crypt_mocker.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "components/signin/core/common/signin_pref_names.h"
@@ skipping 12 matching lines @@
 
 enum UserMode { USER_MODE_NORMAL, USER_MODE_INCOGNITO };
 
 const std::string kUTF8MidlineEllipsis =
     "  "
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86";
 
+const base::Time kFirstArbitraryTestTime = base::Time::FromDoubleT(25);
+const base::Time kSecondArbitraryTestTime = base::Time::FromDoubleT(1000);

[Mathieu, 2017/01/25 22:32:14]

nit: tests would read even better with ArbitraryTime, SomeTimeLater, MuchLater
:)

[sebsg, 2017/01/30 20:27:26]

Done.

+const base::Time kThirdArbitraryTestTime = base::Time::FromDoubleT(5000);
+
 ACTION(QuitMainMessageLoop) {
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 class PersonalDataLoadedObserverMock : public PersonalDataManagerObserver {
  public:
   PersonalDataLoadedObserverMock() {}
   virtual ~PersonalDataLoadedObserverMock() {}
 
   MOCK_METHOD0(OnPersonalDataChanged, void());
@@ skipping 177 matching lines @@
   // to test the suggestions based on name as well as on credit card number.
   void SetupReferenceLocalCreditCards() {
     ASSERT_EQ(0U, personal_data_->GetCreditCards().size());
 
     CreditCard credit_card0("287151C8-6AB1-487C-9095-28E80BE5DA15",
                             "https://www.example.com");
     test::SetCreditCardInfo(&credit_card0, "Clyde Barrow",
                             "347666888555" /* American Express */, "04",
                             "2999");
     credit_card0.set_use_count(3);
-    credit_card0.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+    credit_card0.set_use_date(AutofillClock::Now() -
+                              base::TimeDelta::FromDays(1));
     personal_data_->AddCreditCard(credit_card0);
 
     CreditCard credit_card1("1141084B-72D7-4B73-90CF-3D6AC154673B",
                             "https://www.example.com");
     credit_card1.set_use_count(300);
-    credit_card1.set_use_date(base::Time::Now() -
+    credit_card1.set_use_date(AutofillClock::Now() -
                               base::TimeDelta::FromDays(10));
     test::SetCreditCardInfo(&credit_card1, "John Dillinger",
                             "423456789012" /* Visa */, "01", "2999");
     personal_data_->AddCreditCard(credit_card1);
 
     CreditCard credit_card2("002149C1-EE28-4213-A3B9-DA243FFF021B",
                             "https://www.example.com");
     credit_card2.set_use_count(1);
-    credit_card2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+    credit_card2.set_use_date(AutofillClock::Now() -
+                              base::TimeDelta::FromDays(1));
     test::SetCreditCardInfo(&credit_card2, "Bonnie Parker",
                             "518765432109" /* Mastercard */, "12", "2999");
     personal_data_->AddCreditCard(credit_card2);
 
     EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
         .WillOnce(QuitMainMessageLoop());
     base::RunLoop().Run();
 
     ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
   }
@@ skipping 51 matching lines @@
     base::RunLoop().Run();
 
     CreditCard expected(base::GenerateGUID(), "https://www.example.com");
     test::SetCreditCardInfo(&expected, exp_name, exp_cc_num, exp_cc_month,
                             exp_cc_year);
     const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
     ASSERT_EQ(1U, results.size());
     EXPECT_EQ(0, expected.Compare(*results[0]));
   }
 
+  void SetClockForTests(std::unique_ptr<base::Clock> unique_test_clock) {
+    AutofillClock::SetClockForTests(std::move(unique_test_clock));
+  }
+
   // The temporary directory should be deleted at the end to ensure that
   // files are not used anymore and deletion succeeds.
   base::ScopedTempDir temp_dir_;
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<PrefService> prefs_;
   std::unique_ptr<AccountTrackerService> account_tracker_;
   std::unique_ptr<FakeSigninManagerBase> signin_manager_;
   std::unique_ptr<TestSigninClient> signin_client_;
   scoped_refptr<AutofillWebDataService> autofill_database_service_;
   scoped_refptr<WebDatabaseService> web_database_;
@@ skipping 47 matching lines @@
 
   // Verify the addition.
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 }
 
 // Test that a new profile has its basic information set.
 TEST_F(PersonalDataManagerTest, AddProfile_BasicInformation) {
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kFirstArbitraryTestTime);
+
   // Add a profile to the database.
   AutofillProfile profile(test::GetFullProfile());
   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com"));
   personal_data_->AddProfile(profile);
 
   // Reload the database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Verify the addition.
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, profile.Compare(*results[0]));
 
   // Make sure the use count and use date were set.
   EXPECT_EQ(1U, results[0]->use_count());
-  EXPECT_NE(base::Time(), results[0]->use_date());
-  EXPECT_NE(base::Time(), results[0]->modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, results[0]->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, results[0]->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, DontDuplicateServerProfile) {
   EnableWalletCardImport();
 
+  // Create the test clock.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+
   std::vector<AutofillProfile> server_profiles;
   server_profiles.push_back(
       AutofillProfile(AutofillProfile::SERVER_PROFILE, "a123"));
   test::SetProfileInfo(&server_profiles.back(), "John", "", "Doe", "",
                        "ACME Corp", "500 Oak View", "Apt 8", "Houston", "TX",
                        "77401", "US", "");
   // Wallet only provides a full name, so the above first and last names
   // will be ignored when the profile is written to the DB.
   server_profiles.back().SetRawInfo(NAME_FULL, ASCIIToUTF16("John Doe"));
   autofill_table_->SetServerProfiles(server_profiles);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
   EXPECT_EQ(1U, personal_data_->GetProfiles().size());
 
   // Add profile with identical values.  Duplicates should not get saved.
   AutofillProfile scraped_profile(base::GenerateGUID(),
                                   "https://www.example.com");
   test::SetProfileInfo(&scraped_profile, "John", "", "Doe", "", "ACME Corp",
                        "500 Oak View", "Apt 8", "Houston", "TX", "77401", "US",
                        "");
   EXPECT_TRUE(scraped_profile.IsSubsetOf(server_profiles.back(), "en-US"));
+
+  // Set the time to a specific value.
+  test_clock->SetNow(kFirstArbitraryTestTime);
+
   std::string saved_guid = personal_data_->SaveImportedProfile(scraped_profile);
   EXPECT_NE(scraped_profile.guid(), saved_guid);
 
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Verify the non-addition.
   EXPECT_EQ(0U, personal_data_->web_profiles().size());
   ASSERT_EQ(1U, personal_data_->GetProfiles().size());
 
-  // Verify that the server profile's use date was updated.
+  // Verify that the server profile's use date was updated with the specified
+  // value.
   const AutofillProfile* server_profile = personal_data_->GetProfiles()[0];
-  EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
-            base::Time::Now() - server_profile->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, server_profile->use_date());
 }
 
 // Tests that SaveImportedProfile sets the modification date on new profiles.
 TEST_F(PersonalDataManagerTest, SaveImportedProfileSetModificationDate) {
   AutofillProfile profile(test::GetFullProfile());
   EXPECT_NE(base::Time(), profile.modification_date());
 
   personal_data_->SaveImportedProfile(profile);
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   ASSERT_EQ(1U, profiles.size());
   EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
-            base::Time::Now() - profiles[0]->modification_date());
+            AutofillClock::Now() - profiles[0]->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, AddUpdateRemoveProfiles) {
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile0,
       "Marion", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
 
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
@@ skipping 97 matching lines @@
 
   // Verify that we've loaded the credit cards from the web database.
   cards.clear();
   cards.push_back(&credit_card0);
   cards.push_back(&credit_card2);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 }
 
 // Test that a new credit card has its basic information set.
 TEST_F(PersonalDataManagerTest, AddCreditCard_BasicInformation) {
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kFirstArbitraryTestTime);
+
   // Add a credit to the database.
   CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card, "John Dillinger",
                           "423456789012" /* Visa */, "01", "2999");
   personal_data_->AddCreditCard(credit_card);
 
   // Reload the database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Verify the addition.
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, credit_card.Compare(*results[0]));
 
   // Make sure the use count and use date were set.
   EXPECT_EQ(1U, results[0]->use_count());
-  EXPECT_NE(base::Time(), results[0]->use_date());
-  EXPECT_NE(base::Time(), results[0]->modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, results[0]->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, results[0]->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, UpdateUnverifiedProfilesAndCreditCards) {
   // Start with unverified data.
   AutofillProfile profile(base::GenerateGUID(), "https://www.example.com/");
   test::SetProfileInfo(&profile,
       "Marion", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
   EXPECT_FALSE(profile.IsVerified());
@@ skipping 2771 matching lines @@
 // Tests that GetProfileSuggestions orders its suggestions based on the frecency
 // formula.
 TEST_F(PersonalDataManagerTest, GetProfileSuggestions_Ranking) {
   // Set up the profiles. They are named with number suffixes X so the X is the
   // order in which they should be ordered by frecency.
   AutofillProfile profile3(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile3, "Marion3", "Mitchell", "Morrison",
                        "johnwayne@me.xyz", "Fox",
                        "123 Zoo St.\nSecond Line\nThird line", "unit 5",
                        "Hollywood", "CA", "91601", "US", "12345678910");
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile3.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
   profile3.set_use_count(5);
   personal_data_->AddProfile(profile3);
 
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Marion1", "Mitchell", "Morrison",
                        "johnwayne@me.xyz", "Fox",
                        "123 Zoo St.\nSecond Line\nThird line", "unit 5",
                        "Hollywood", "CA", "91601", "US", "12345678910");
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile1.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
   profile1.set_use_count(10);
   personal_data_->AddProfile(profile1);
 
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Marion2", "Mitchell", "Morrison",
                        "johnwayne@me.xyz", "Fox",
                        "123 Zoo St.\nSecond Line\nThird line", "unit 5",
                        "Hollywood", "CA", "91601", "US", "12345678910");
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
+  profile2.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(15));
   profile2.set_use_count(300);
   personal_data_->AddProfile(profile2);
 
   ResetPersonalDataManager(USER_MODE_NORMAL);
   std::vector<Suggestion> suggestions = personal_data_->GetProfileSuggestions(
       AutofillType(NAME_FIRST), base::ASCIIToUTF16("Ma"), false,
       std::vector<ServerFieldType>());
   ASSERT_EQ(3U, suggestions.size());
   EXPECT_EQ(suggestions[0].value, base::ASCIIToUTF16("Marion1"));
   EXPECT_EQ(suggestions[1].value, base::ASCIIToUTF16("Marion2"));
@@ skipping 128 matching lines @@
        GetCreditCardSuggestions_LocalAndServerCardsRanking) {
   EnableWalletCardImport();
   SetupReferenceLocalCreditCards();
 
   // Add some server cards.
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "b459"));
   test::SetCreditCardInfo(&server_cards.back(), "Emmet Dalton", "2110", "12",
                           "2999");
   server_cards.back().set_use_count(2);
-  server_cards.back().set_use_date(base::Time::Now() -
+  server_cards.back().set_use_date(AutofillClock::Now() -
                                    base::TimeDelta::FromDays(1));
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "b460"));
   test::SetCreditCardInfo(&server_cards.back(), "Jesse James", "2109", "12",
                           "2999");
   server_cards.back().set_use_count(6);
-  server_cards.back().set_use_date(base::Time::Now() -
+  server_cards.back().set_use_date(AutofillClock::Now() -
                                    base::TimeDelta::FromDays(1));
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
@@ skipping 20 matching lines @@
   test::SetCreditCardInfo(&credit_card0, "Bonnie Parker",
                           "518765432109" /* Mastercard */, "04", "2999");
   personal_data_->AddCreditCard(credit_card0);
 
   // Add an expired card with a higher frecency score.
   CreditCard credit_card1("287151C8-6AB1-487C-9095-28E80BE5DA15",
                           "https://www.example.com");
   test::SetCreditCardInfo(&credit_card1, "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "1999");
   credit_card1.set_use_count(300);
-  credit_card1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(10));
+  credit_card1.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(10));
   personal_data_->AddCreditCard(credit_card1);
 
   // Add an expired card with a lower frecency score.
   CreditCard credit_card2("1141084B-72D7-4B73-90CF-3D6AC154673B",
                           "https://www.example.com");
   credit_card2.set_use_count(3);
-  credit_card2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  credit_card2.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(1));
   test::SetCreditCardInfo(&credit_card2, "John Dillinger",
                           "423456789012" /* Visa */, "01", "1998");
   personal_data_->AddCreditCard(credit_card2);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
@@ skipping 15 matching lines @@
 // when querying credit cards by their number.
 TEST_F(PersonalDataManagerTest, GetCreditCardSuggestions_NumberMissing) {
   // Create one normal credit card and one credit card with the number missing.
   ASSERT_EQ(0U, personal_data_->GetCreditCards().size());
 
   CreditCard credit_card0("287151C8-6AB1-487C-9095-28E80BE5DA15",
                           "https://www.example.com");
   test::SetCreditCardInfo(&credit_card0, "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "2999");
   credit_card0.set_use_count(3);
-  credit_card0.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  credit_card0.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(1));
   personal_data_->AddCreditCard(credit_card0);
 
   CreditCard credit_card1("1141084B-72D7-4B73-90CF-3D6AC154673B",
                           "https://www.example.com");
   credit_card1.set_use_count(300);
-  credit_card1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(10));
+  credit_card1.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(10));
   test::SetCreditCardInfo(&credit_card1, "John Dillinger", "", "01", "2999");
   personal_data_->AddCreditCard(credit_card1);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   ASSERT_EQ(2U, personal_data_->GetCreditCards().size());
 
   // Sublabel is expiration date when filling card number. The second card
@@ skipping 16 matching lines @@
   // Add some server cards. If there are local dupes, the locals should be
   // hidden.
   std::vector<CreditCard> server_cards;
   // This server card matches a local card, except the local card is missing the
   // number. This should count as a dupe and thus not be shown in the
   // suggestions since the locally saved card takes precedence.
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "9012" /* Visa */, "01", "2999");
   server_cards.back().set_use_count(2);
-  server_cards.back().set_use_date(base::Time::Now() -
+  server_cards.back().set_use_date(AutofillClock::Now() -
                                    base::TimeDelta::FromDays(15));
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   // This server card is identical to a local card, but has a different
   // card type. Not a dupe and therefore both should appear in the suggestions.
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "b456"));
   test::SetCreditCardInfo(&server_cards.back(), "Bonnie Parker", "2109", "12",
                           "2999");
   server_cards.back().set_use_count(3);
-  server_cards.back().set_use_date(base::Time::Now() -
+  server_cards.back().set_use_date(AutofillClock::Now() -
                                    base::TimeDelta::FromDays(15));
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   // This unmasked server card is an exact dupe of a local card. Therefore only
   // this card should appear in the suggestions as full server cards have
   // precedence over local cards.
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "2999");
   server_cards.back().set_use_count(1);
-  server_cards.back().set_use_date(base::Time::Now() -
+  server_cards.back().set_use_date(AutofillClock::Now() -
                                    base::TimeDelta::FromDays(15));
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
@@ skipping 66 matching lines @@
 TEST_F(PersonalDataManagerTest,
        DedupeCreditCardToSuggest_FullServerShadowsLocal) {
   std::list<CreditCard*> credit_cards;
 
   // Create 3 different local credit cards.
   CreditCard local_card("287151C8-6AB1-487C-9095-28E80BE5DA15",
                         "https://www.example.com");
   test::SetCreditCardInfo(&local_card, "Homer Simpson",
                           "423456789012" /* Visa */, "01", "2999");
   local_card.set_use_count(3);
-  local_card.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  local_card.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
   credit_cards.push_back(&local_card);
 
   // Create a full server card that is a duplicate of one of the local cards.
   CreditCard full_server_card(CreditCard::FULL_SERVER_CARD, "c789");
   test::SetCreditCardInfo(&full_server_card, "Homer Simpson",
                           "423456789012" /* Visa */, "01", "2999");
   full_server_card.set_use_count(1);
-  full_server_card.set_use_date(base::Time::Now() -
+  full_server_card.set_use_date(AutofillClock::Now() -
                                 base::TimeDelta::FromDays(15));
   credit_cards.push_back(&full_server_card);
 
   PersonalDataManager::DedupeCreditCardToSuggest(&credit_cards);
   ASSERT_EQ(1U, credit_cards.size());
 
   const CreditCard* deduped_card(credit_cards.front());
   EXPECT_TRUE(*deduped_card == full_server_card);
 }
 
 // Tests that only the local card is kept when deduping with a masked server
 // duplicate of it.
 TEST_F(PersonalDataManagerTest, DedupeCreditCardToSuggest_LocalShadowsMasked) {
   std::list<CreditCard*> credit_cards;
 
   CreditCard local_card("1141084B-72D7-4B73-90CF-3D6AC154673B",
                         "https://www.example.com");
   local_card.set_use_count(300);
-  local_card.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(10));
+  local_card.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(10));
   test::SetCreditCardInfo(&local_card, "Homer Simpson",
                           "423456789012" /* Visa */, "01", "2999");
   credit_cards.push_back(&local_card);
 
   // Create a masked server card that is a duplicate of a local card.
   CreditCard masked_card(CreditCard::MASKED_SERVER_CARD, "a123");
   test::SetCreditCardInfo(&masked_card, "Homer Simpson", "9012" /* Visa */,
                           "01", "2999");
   masked_card.set_use_count(2);
-  masked_card.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
+  masked_card.set_use_date(AutofillClock::Now() -
+                           base::TimeDelta::FromDays(15));
   masked_card.SetTypeForMaskedCard(kVisaCard);
   credit_cards.push_back(&masked_card);
 
   PersonalDataManager::DedupeCreditCardToSuggest(&credit_cards);
   ASSERT_EQ(1U, credit_cards.size());
 
   const CreditCard* deduped_card(credit_cards.front());
   EXPECT_TRUE(*deduped_card == local_card);
 }
 
 // Tests that identical full server and masked credit cards are not deduped.
 TEST_F(PersonalDataManagerTest, DedupeCreditCardToSuggest_FullServerAndMasked) {
   std::list<CreditCard*> credit_cards;
 
   // Create a full server card that is a duplicate of one of the local cards.
   CreditCard full_server_card(CreditCard::FULL_SERVER_CARD, "c789");
   test::SetCreditCardInfo(&full_server_card, "Homer Simpson",
                           "423456789012" /* Visa */, "01", "2999");
   full_server_card.set_use_count(1);
-  full_server_card.set_use_date(base::Time::Now() -
+  full_server_card.set_use_date(AutofillClock::Now() -
                                 base::TimeDelta::FromDays(15));
   credit_cards.push_back(&full_server_card);
 
   // Create a masked server card that is a duplicate of a local card.
   CreditCard masked_card(CreditCard::MASKED_SERVER_CARD, "a123");
   test::SetCreditCardInfo(&masked_card, "Homer Simpson", "9012" /* Visa */,
                           "01", "2999");
   masked_card.set_use_count(2);
-  masked_card.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
+  masked_card.set_use_date(AutofillClock::Now() -
+                           base::TimeDelta::FromDays(15));
   masked_card.SetTypeForMaskedCard(kVisaCard);
   credit_cards.push_back(&masked_card);
 
   PersonalDataManager::DedupeCreditCardToSuggest(&credit_cards);
   EXPECT_EQ(2U, credit_cards.size());
 }
 
 // Tests that slightly different local, full server, and masked credit cards are
 // not deduped.
 TEST_F(PersonalDataManagerTest, DedupeCreditCardToSuggest_DifferentCards) {
   std::list<CreditCard*> credit_cards;
 
   CreditCard credit_card2("002149C1-EE28-4213-A3B9-DA243FFF021B",
                           "https://www.example.com");
   credit_card2.set_use_count(1);
-  credit_card2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  credit_card2.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(1));
   test::SetCreditCardInfo(&credit_card2, "Homer Simpson",
                           "518765432109" /* Mastercard */, "", "");
   credit_cards.push_back(&credit_card2);
 
   // Create a masked server card that is slightly different of the local card.
   CreditCard credit_card4(CreditCard::MASKED_SERVER_CARD, "b456");
   test::SetCreditCardInfo(&credit_card4, "Homer Simpson", "2109", "12", "2999");
   credit_card4.set_use_count(3);
-  credit_card4.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
+  credit_card4.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(15));
   credit_card4.SetTypeForMaskedCard(kVisaCard);
   credit_cards.push_back(&credit_card4);
 
   // Create a full server card that is slightly different of the two other
   // cards.
   CreditCard credit_card5(CreditCard::FULL_SERVER_CARD, "c789");
   test::SetCreditCardInfo(&credit_card5, "Homer Simpson",
                           "347666888555" /* American Express */, "04", "2999");
   credit_card5.set_use_count(1);
-  credit_card5.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
+  credit_card5.set_use_date(AutofillClock::Now() -
+                            base::TimeDelta::FromDays(15));
   credit_cards.push_back(&credit_card5);
 
   PersonalDataManager::DedupeCreditCardToSuggest(&credit_cards);
   EXPECT_EQ(3U, credit_cards.size());
 }
 
 TEST_F(PersonalDataManagerTest, RecordUseOf) {
-  base::Time creation_time = base::Time::FromTimeT(12345);
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kFirstArbitraryTestTime);
 
   AutofillProfile profile(test::GetFullProfile());
-  profile.set_use_date(creation_time);
-  profile.set_modification_date(creation_time);
   EXPECT_EQ(1U, profile.use_count());
-  EXPECT_EQ(creation_time, profile.use_date());
-  EXPECT_EQ(creation_time, profile.modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, profile.use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, profile.modification_date());
   personal_data_->AddProfile(profile);
 
   CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card, "John Dillinger",
                           "423456789012" /* Visa */, "01", "2999");
-  credit_card.set_use_date(creation_time);
-  credit_card.set_modification_date(creation_time);
   EXPECT_EQ(1U, credit_card.use_count());
-  EXPECT_EQ(creation_time, credit_card.use_date());
-  EXPECT_EQ(creation_time, credit_card.modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, credit_card.use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, credit_card.modification_date());
   personal_data_->AddCreditCard(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
+  // Set the current time to another value.
+  test_clock->SetNow(kSecondArbitraryTestTime);
+
   // Notify the PDM that the profile and credit card were used.
   AutofillProfile* added_profile =
       personal_data_->GetProfileByGUID(profile.guid());
   ASSERT_TRUE(added_profile);
   EXPECT_EQ(*added_profile, profile);
   EXPECT_EQ(1U, added_profile->use_count());
-  EXPECT_EQ(creation_time, added_profile->use_date());
-  EXPECT_NE(creation_time, added_profile->modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_profile->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_profile->modification_date());
   personal_data_->RecordUseOf(profile);
 
   CreditCard* added_card =
       personal_data_->GetCreditCardByGUID(credit_card.guid());
   ASSERT_TRUE(added_card);
   EXPECT_EQ(*added_card, credit_card);
   EXPECT_EQ(1U, added_card->use_count());
-  EXPECT_EQ(creation_time, added_card->use_date());
-  EXPECT_NE(creation_time, added_card->modification_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_card->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_card->modification_date());
   personal_data_->RecordUseOf(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Verify usage stats are updated.
   added_profile = personal_data_->GetProfileByGUID(profile.guid());
   ASSERT_TRUE(added_profile);
   EXPECT_EQ(2U, added_profile->use_count());
-  EXPECT_NE(creation_time, added_profile->use_date());
-  EXPECT_NE(creation_time, added_profile->modification_date());
+  EXPECT_EQ(kSecondArbitraryTestTime, added_profile->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_profile->modification_date());
 
   added_card = personal_data_->GetCreditCardByGUID(credit_card.guid());
   ASSERT_TRUE(added_card);
   EXPECT_EQ(2U, added_card->use_count());
-  EXPECT_NE(creation_time, added_card->use_date());
-  EXPECT_NE(creation_time, added_card->modification_date());
+  EXPECT_EQ(kSecondArbitraryTestTime, added_card->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, added_card->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, UpdateServerCreditCardUsageStats) {
   EnableWalletCardImport();
 
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "9012" /* Visa */, "01", "2999");
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "b456"));
   test::SetCreditCardInfo(&server_cards.back(), "Bonnie Parker",
                           "4444" /* Mastercard */, "12", "2999");
   server_cards.back().SetTypeForMaskedCard(kMasterCard);
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "2999");
 
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kFirstArbitraryTestTime);
+
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   if (!OfferStoreUnmaskedCards()) {
@@ skipping 18 matching lines @@
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 
   // For an unmasked card, usage data starts out as 2 because of the unmasking
-  // which is considered a use.
+  // which is considered a use. The use date should now be the specified Now()
+  // time kFirstArbitraryTestTime.
   EXPECT_EQ(2U, personal_data_->GetCreditCards()[0]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[0]->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime,
+            personal_data_->GetCreditCards()[0]->use_date());
 
   EXPECT_EQ(1U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_NE(kFirstArbitraryTestTime,
+            personal_data_->GetCreditCards()[1]->use_date());
 
-  // Having unmasked this card, usage stats should be 2 and Now().
+  // Having unmasked this card, usage stats should be 2 and
+  // kFirstArbitraryTestTime.
   EXPECT_EQ(2U, personal_data_->GetCreditCards()[2]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[2]->use_date());
-  base::Time initial_use_date = personal_data_->GetCreditCards()[2]->use_date();
+  EXPECT_EQ(kFirstArbitraryTestTime,
+            personal_data_->GetCreditCards()[2]->use_date());
+
+  // Change the Now() value for a second time.
+  test_clock->SetNow(kSecondArbitraryTestTime);
 
   server_cards.back().set_guid(personal_data_->GetCreditCards()[2]->guid());
   personal_data_->RecordUseOf(server_cards.back());
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   EXPECT_EQ(2U, personal_data_->GetCreditCards()[0]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[0]->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime,
+            personal_data_->GetCreditCards()[0]->use_date());
 
   EXPECT_EQ(1U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_NE(kFirstArbitraryTestTime,
+            personal_data_->GetCreditCards()[1]->use_date());
 
+  // The RecordUseOf call should have incremented the use_count to 3 and set the
+  // use_date to kSecondArbitraryTestTime.
   EXPECT_EQ(3U, personal_data_->GetCreditCards()[2]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[2]->use_date());
-  // Time may or may not have elapsed between unmasking and RecordUseOf.
-  EXPECT_LE(initial_use_date, personal_data_->GetCreditCards()[2]->use_date());
+  EXPECT_EQ(kSecondArbitraryTestTime,
+            personal_data_->GetCreditCards()[2]->use_date());
 
   // Can record usage stats on masked cards.
   server_cards[1].set_guid(personal_data_->GetCreditCards()[1]->guid());
   personal_data_->RecordUseOf(server_cards[1]);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
   EXPECT_EQ(2U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_EQ(kSecondArbitraryTestTime,
+            personal_data_->GetCreditCards()[1]->use_date());
+
+  // Change Now()'s return value for a third time.
+  test_clock->SetNow(kThirdArbitraryTestTime);
 
   // Upgrading to unmasked retains the usage stats (and increments them).
   CreditCard* unmasked_card2 = &server_cards[1];
   unmasked_card2->set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked_card2->SetNumber(ASCIIToUTF16("5555555555554444"));
   personal_data_->UpdateServerCreditCard(*unmasked_card2);
 
   server_cards[1].set_guid(personal_data_->GetCreditCards()[1]->guid());
   personal_data_->RecordUseOf(server_cards[1]);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
   EXPECT_EQ(3U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_EQ(kThirdArbitraryTestTime,
+            personal_data_->GetCreditCards()[1]->use_date());
 }
 
 TEST_F(PersonalDataManagerTest, ClearAllServerData) {
   // Add a server card.
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "9012" /* Visa */, "01", "2999");
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
   test::SetServerCreditCards(autofill_table_, server_cards);
@@ skipping 390 matching lines @@
 
       // Make sure the new information was merged correctly.
       for (ProfileField changed_field : test_case.changed_field_values) {
         EXPECT_EQ(base::UTF8ToUTF16(changed_field.field_value),
                   saved_profiles.front()->GetRawInfo(changed_field.field_type));
       }
       // Verify that the merged profile's use count, use date and modification
       // date were properly updated.
       EXPECT_EQ(1U, saved_profiles.front()->use_count());
       EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
-                base::Time::Now() - saved_profiles.front()->use_date());
+                AutofillClock::Now() - saved_profiles.front()->use_date());
       EXPECT_GT(
           base::TimeDelta::FromMilliseconds(500),
-          base::Time::Now() - saved_profiles.front()->modification_date());
+          AutofillClock::Now() - saved_profiles.front()->modification_date());
     }
 
     // Erase the profiles for the next test.
     ResetProfiles();
   }
 }
 
 // Tests that MergeProfile tries to merge the imported profile into the
 // existing profile in decreasing order of frecency.
 TEST_F(PersonalDataManagerTest, MergeProfile_Frecency) {
@@ skipping 29 matching lines @@
   std::string guid = personal_data_->MergeProfile(
       imported_profile, &existing_profiles, "US-EN", &profiles);
 
   // The new profile should be merged into the "fox" profile.
   EXPECT_EQ(profile2->guid(), guid);
 }
 
 // Tests that MergeProfile produces a merged profile with the expected usage
 // statistics.
 TEST_F(PersonalDataManagerTest, MergeProfile_UsageStats) {
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kFirstArbitraryTestTime);
+
   // Create an initial profile with a use count of 10, an old use date and an
   // old modification date of 4 days ago.
   AutofillProfile* profile =
       new AutofillProfile(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(profile, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "SNP", "742 Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "12345678910");
   profile->set_use_count(4U);
-  profile->set_use_date(base::Time::Now() - base::TimeDelta::FromDays(4));
-  profile->set_modification_date(base::Time::Now() -
-                                 base::TimeDelta::FromDays(4));
+  EXPECT_EQ(kFirstArbitraryTestTime, profile->use_date());
+  EXPECT_EQ(kFirstArbitraryTestTime, profile->modification_date());
 
   // Create the |existing_profiles| vector.
   std::vector<std::unique_ptr<AutofillProfile>> existing_profiles;
   existing_profiles.push_back(base::WrapUnique(profile));
 
+  // Change the current date.
+  test_clock->SetNow(kSecondArbitraryTestTime);
+
   // Create a new imported profile that will get merged with the existing one.
   AutofillProfile imported_profile(base::GenerateGUID(),
                                    "https://www.example.com");
   test::SetProfileInfo(&imported_profile, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "US", "12345678910");
 
+  // Change the current date.
+  test_clock->SetNow(kThirdArbitraryTestTime);
+
   // Merge the imported profile into the existing profiles.
   std::vector<AutofillProfile> profiles;
   std::string guid = personal_data_->MergeProfile(
       imported_profile, &existing_profiles, "US-EN", &profiles);
 
   // The new profile should be merged into the existing profile.
   EXPECT_EQ(profile->guid(), guid);
   // The use count should have be max(4, 1) => 4.
   EXPECT_EQ(4U, profile->use_count());
-  // The use date and modification dates should have been set to less than 500
-  // milliseconds ago.
-  EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
-            base::Time::Now() - profile->use_date());
-  EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
-            base::Time::Now() - profile->modification_date());
+  // The use date should be the one of the most recent profile, which is
+  // kSecondArbitraryTime.
+  EXPECT_EQ(kSecondArbitraryTestTime, profile->use_date());
+  // Since the merge is considered a modification, the modification_date should
+  // be set to kThirdArbitraryTestTime.
+  EXPECT_EQ(kThirdArbitraryTestTime, profile->modification_date());
 }
 
 // Tests that DedupeProfiles sets the correct profile guids to
 // delete after merging similar profiles.
 TEST_F(PersonalDataManagerTest, DedupeProfiles_ProfilesToDelete) {
   // Create the profile for which to find duplicates. It has the highest
   // frecency.
   AutofillProfile* profile1 =
       new AutofillProfile(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(profile1, "Homer", "Jay", "Simpson",
@@ skipping 211 matching lines @@
   // 5 has a higher score than 6. This will ensure a deterministic order when
   // verifying results.
 
   // Create a set of 3 profiles to be merged together.
   // Create a profile with a higher frecency score.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile1.set_use_count(12);
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile1.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
 
   // Create a profile with a medium frecency score.
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   profile2.set_use_count(5);
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile2.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a profile with a lower frecency score.
   AutofillProfile profile3(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile3, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile3.set_use_count(3);
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  profile3.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(5));
 
   // Create a set of two profiles to be merged together.
   // Create a profile with a higher frecency score.
   AutofillProfile profile4(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile4, "Marge", "B", "Simpson",
                        "marge.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile4.set_use_count(11);
-  profile4.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile4.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
 
   // Create a profile with a lower frecency score.
   AutofillProfile profile5(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile5, "Marge", "B", "Simpson",
                        "marge.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile5.set_use_count(5);
-  profile5.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile5.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a unique profile.
   AutofillProfile profile6(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile6, "Bart", "J", "Simpson",
                        "bart.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile6.set_use_count(10);
-  profile6.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile6.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
 
   // Add three credit cards. Give them a frecency score so that they are
   // suggested in order (1, 2, 3). This will ensure a deterministic order for
   // verifying results.
   CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card1, "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "2999");
   credit_card1.set_use_count(10);
 
   CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com");
@@ skipping 70 matching lines @@
 // Tests that ApplyDedupingRoutine merges the profile values correctly, i.e.
 // never lose information and keep the syntax of the profile with the higher
 // frecency score.
 TEST_F(PersonalDataManagerTest, ApplyDedupingRoutine_MergedProfileValues) {
   // Create a profile with a higher frecency score.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile1.set_use_count(10);
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile1.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
 
   // Create a profile with a medium frecency score.
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   profile2.set_use_count(5);
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile2.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a profile with a lower frecency score.
   AutofillProfile profile3(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile3, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile3.set_use_count(3);
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  profile3.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(5));
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved;
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
@@ skipping 55 matching lines @@
 // Tests that ApplyDedupingRoutine only keeps the verified profile with its
 // original data when deduping with similar profiles, even if it has a higher
 // frecency score.
 TEST_F(PersonalDataManagerTest, ApplyDedupingRoutine_VerifiedProfileFirst) {
   // Create a verified profile with a higher frecency score.
   AutofillProfile profile1(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&profile1, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   profile1.set_use_count(7);
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  profile1.set_use_date(kThirdArbitraryTestTime);
 
   // Create a similar non verified profile with a medium frecency score.
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile2.set_use_count(5);
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile2.set_use_date(kSecondArbitraryTestTime);
 
   // Create a similar non verified profile with a lower frecency score.
   AutofillProfile profile3(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile3, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile3.set_use_count(3);
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  profile3.set_use_date(kFirstArbitraryTestTime);
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
@@ skipping 19 matching lines @@
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesConsideredForDedupe", 3, 1);
   // 2 profile were removed (profiles 2 and 3).
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesRemovedDuringDedupe", 2, 1);
 
   // Only the verified |profile1| with its original data should have been kept.
   EXPECT_EQ(profile1.guid(), profiles[0]->guid());
   EXPECT_TRUE(profile1 == *profiles[0]);
   EXPECT_EQ(profile1.use_count(), profiles[0]->use_count());
-  EXPECT_LT(profile1.use_date() - TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
-  EXPECT_GT(profile1.use_date() + TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
+  EXPECT_EQ(profile1.use_date(), profiles[0]->use_date());
 }
 
 // Tests that ApplyDedupingRoutine only keeps the verified profile with its
 // original data when deduping with similar profiles, even if it has a lower
 // frecency score.
 TEST_F(PersonalDataManagerTest, ApplyDedupingRoutine_VerifiedProfileLast) {
   // Create a profile to dedupe with a higher frecency score.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile1.set_use_count(5);
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile1.set_use_date(kThirdArbitraryTestTime);
 
   // Create a similar non verified profile with a medium frecency score.
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile2.set_use_count(5);
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile2.set_use_date(kSecondArbitraryTestTime);
 
   // Create a similar verified profile with a lower frecency score.
   AutofillProfile profile3(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&profile3, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   profile3.set_use_count(3);
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  profile3.set_use_date(kFirstArbitraryTestTime);
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
@@ skipping 15 matching lines @@
   // should then have been discarded because it is similar to the verified
   // |profile3|.
   ASSERT_EQ(1U, profiles.size());
   // 3 profiles were considered for dedupe.
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesConsideredForDedupe", 3, 1);
   // 2 profile were removed (profiles 1 and 2).
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesRemovedDuringDedupe", 2, 1);
 
-  // Only the verified |profile2| with it's original data should have been kept.
+  // Only the verified |profile3| with it's original data should have been kept.
   EXPECT_EQ(profile3.guid(), profiles[0]->guid());
   EXPECT_TRUE(profile3 == *profiles[0]);
   EXPECT_EQ(profile3.use_count(), profiles[0]->use_count());
-  EXPECT_LT(profile3.use_date() - TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
-  EXPECT_GT(profile3.use_date() + TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
+  EXPECT_EQ(profile3.use_date(), profiles[0]->use_date());
 }
 
 // Tests that ApplyDedupingRoutine does not merge unverified data into
 // a verified profile. Also tests that two verified profiles don't get merged.
 TEST_F(PersonalDataManagerTest, ApplyDedupingRoutine_MultipleVerifiedProfiles) {
   // Create a profile to dedupe with a higher frecency score.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   profile1.set_use_count(5);
-  profile1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile1.set_use_date(kThirdArbitraryTestTime);
 
   // Create a similar verified profile with a medium frecency score.
   AutofillProfile profile2(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&profile2, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   profile2.set_use_count(5);
-  profile2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  profile2.set_use_date(kSecondArbitraryTestTime);
 
   // Create a similar verified profile with a lower frecency score.
   AutofillProfile profile3(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&profile3, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   profile3.set_use_count(3);
-  profile3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  profile3.set_use_date(kFirstArbitraryTestTime);
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
@@ skipping 26 matching lines @@
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesRemovedDuringDedupe", 1, 1);
 
   EXPECT_EQ(profile2.guid(), profiles[0]->guid());
   EXPECT_EQ(profile3.guid(), profiles[1]->guid());
   // The profiles should have kept their original data.
   EXPECT_TRUE(profile2 == *profiles[0]);
   EXPECT_TRUE(profile3 == *profiles[1]);
   EXPECT_EQ(profile2.use_count(), profiles[0]->use_count());
   EXPECT_EQ(profile3.use_count(), profiles[1]->use_count());
-  EXPECT_LT(profile2.use_date() - TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
-  EXPECT_GT(profile2.use_date() + TimeDelta::FromSeconds(2),
-            profiles[0]->use_date());
-  EXPECT_LT(profile3.use_date() - TimeDelta::FromSeconds(2),
-            profiles[1]->use_date());
-  EXPECT_GT(profile3.use_date() + TimeDelta::FromSeconds(2),
-            profiles[1]->use_date());
+  EXPECT_EQ(profile2.use_date(), profiles[0]->use_date());
+  EXPECT_EQ(profile3.use_date(), profiles[1]->use_date());
 }
 
 // Tests that ApplyProfileUseDatesFix sets the use date of profiles from an
 // incorrect value of 0 to [two weeks from now]. Also tests that SetProfiles
 // does not modify any other profiles.
 TEST_F(PersonalDataManagerTest, ApplyProfileUseDatesFix) {
   // Set the kAutofillProfileUseDatesFixed pref to true so that the fix is not
   // applied just yet.
   personal_data_->pref_service_->SetBoolean(
       prefs::kAutofillProfileUseDatesFixed, true);
 
   // Create a profile. The use date will be set to now automatically.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "SNP", "742 Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "12345678910");
+  profile1.set_use_date(kFirstArbitraryTestTime);
 
   // Create another profile and set its use date to the default value.
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Marge", "", "Simpson",
                        "homer.simpson@abc.com", "SNP", "742 Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "12345678910");
   profile2.set_use_date(base::Time());
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Get a sorted list of profiles. |profile1| will be first and |profile2| will
   // be second.
   std::vector<AutofillProfile*> saved_profiles =
       personal_data_->GetProfilesToSuggest();
 
   ASSERT_EQ(2U, saved_profiles.size());
 
   // The use dates should not have been modified.
-  EXPECT_LE(base::Time::Now() - base::TimeDelta::FromDays(1),
-            saved_profiles[0]->use_date());
-  EXPECT_EQ(base::Time(), saved_profiles[1]->use_date());
+  EXPECT_EQ(profile1.use_date(), saved_profiles[0]->use_date());
+  EXPECT_EQ(profile2.use_date(), saved_profiles[1]->use_date());
 
   // Set the pref to false to indicate the fix has never been run.
   personal_data_->pref_service_->SetBoolean(
       prefs::kAutofillProfileUseDatesFixed, false);
 
+  // Create the test clock and set the time to a specific value.
+  std::unique_ptr<base::SimpleTestClock> unique_test_clock(
+      new base::SimpleTestClock());
+  base::SimpleTestClock* test_clock = unique_test_clock.get();
+  SetClockForTests(std::move(unique_test_clock));
+  test_clock->SetNow(kSecondArbitraryTestTime);
+
   personal_data_->ApplyProfileUseDatesFix();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Get a sorted list of profiles.
   saved_profiles = personal_data_->GetProfilesToSuggest();
 
   ASSERT_EQ(2U, saved_profiles.size());
 
   // |profile1|'s use date should not have been modified.
-  EXPECT_LE(base::Time::Now() - base::TimeDelta::FromDays(1),
-            saved_profiles[0]->use_date());
+  EXPECT_LE(profile1.use_date(), saved_profiles[0]->use_date());
   // |profile2|'s use date should have been set to two weeks before now.
-  EXPECT_LE(base::Time::Now() - base::TimeDelta::FromDays(15),
-            saved_profiles[1]->use_date());
-  EXPECT_GE(base::Time::Now() - base::TimeDelta::FromDays(13),
+  EXPECT_EQ(kSecondArbitraryTestTime - base::TimeDelta::FromDays(14),
             saved_profiles[1]->use_date());
 }
 
 // Tests that ApplyProfileUseDatesFix does apply the fix if it's already been
 // applied.
 TEST_F(PersonalDataManagerTest, ApplyProfileUseDatesFix_NotAppliedTwice) {
   // Set the kAutofillProfileUseDatesFixed pref which means the fix has already
   // been applied.
   personal_data_->pref_service_->SetBoolean(
       prefs::kAutofillProfileUseDatesFixed, true);
 
   // Create two profiles.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "SNP", "742 Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "12345678910");
+  profile1.set_use_date(kFirstArbitraryTestTime);
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2, "Marge", "", "Simpson",
                        "homer.simpson@abc.com", "SNP", "742 Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "12345678910");
   profile2.set_use_date(base::Time());
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Get a sorted list of profiles. |profile1| will be first and |profile2| will
   // be second.
   std::vector<AutofillProfile*> saved_profiles =
       personal_data_->GetProfilesToSuggest();
 
   ASSERT_EQ(2U, saved_profiles.size());
   // The use dates should not have been modified.
-  EXPECT_LE(base::Time::Now() - base::TimeDelta::FromDays(1),
-            saved_profiles[0]->use_date());
+  EXPECT_EQ(profile1.use_date(), saved_profiles[0]->use_date());
   EXPECT_EQ(base::Time(), saved_profiles[1]->use_date());
 }
 
 // Tests that ApplyDedupingRoutine works as expected in a realistic scenario.
 // Tests that it merges the diffent set of similar profiles independently and
 // that the resulting profiles have the right values, has no effect on the other
 // profiles and that the data of verified profiles is not modified.
 TEST_F(PersonalDataManagerTest, ApplyDedupingRoutine_MultipleDedupes) {
   // Create a Homer home profile with a higher frecency score than other Homer
   // profiles.
   AutofillProfile Homer1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Homer1, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "", "742. Evergreen Terrace",
                        "", "Springfield", "IL", "91601", "US", "");
   Homer1.set_use_count(10);
-  Homer1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(1));
+  Homer1.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(1));
 
   // Create a Homer home profile with a medium frecency score compared to other
   // Homer profiles.
   AutofillProfile Homer2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Homer2, "Homer", "Jay", "Simpson",
                        "homer.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   Homer2.set_use_count(5);
-  Homer2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  Homer2.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a Homer home profile with a lower frecency score than other Homer
   // profiles.
   AutofillProfile Homer3(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Homer3, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "742 Evergreen Terrace.",
                        "", "Springfield", "IL", "91601", "", "");
   Homer3.set_use_count(3);
-  Homer3.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  Homer3.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(5));
 
   // Create a Homer work profile (different address).
   AutofillProfile Homer4(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Homer4, "Homer", "J", "Simpson",
                        "homer.simpson@abc.com", "Fox", "12 Nuclear Plant.", "",
                        "Springfield", "IL", "91601", "US", "9876543");
   Homer4.set_use_count(3);
-  Homer4.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
+  Homer4.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(5));
 
   // Create a Marge profile with a lower frecency score that other Marge
   // profiles.
   AutofillProfile Marge1(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&Marge1, "Marjorie", "J", "Simpson",
                        "marge.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   Marge1.set_use_count(4);
-  Marge1.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  Marge1.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a verified Marge home profile with a lower frecency score that the
   // other Marge profile.
   AutofillProfile Marge2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Marge2, "Marjorie", "Jacqueline", "Simpson",
                        "marge.simpson@abc.com", "", "742 Evergreen Terrace", "",
                        "Springfield", "IL", "91601", "", "12345678910");
   Marge2.set_use_count(2);
-  Marge2.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(3));
+  Marge2.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(3));
 
   // Create a Barney profile (guest user).
   AutofillProfile Barney(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&Barney, "Barney", "", "Gumble", "barney.gumble@abc.com",
                        "ABC", "123 Other Street", "", "Springfield", "IL",
                        "91601", "", "");
   Barney.set_use_count(1);
-  Barney.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(180));
+  Barney.set_use_date(AutofillClock::Now() - base::TimeDelta::FromDays(180));
 
   personal_data_->AddProfile(Homer1);
   personal_data_->AddProfile(Homer2);
   personal_data_->AddProfile(Homer3);
   personal_data_->AddProfile(Homer4);
   personal_data_->AddProfile(Marge1);
   personal_data_->AddProfile(Marge2);
   personal_data_->AddProfile(Barney);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
@@ skipping 181 matching lines @@
   EnableAutofillProfileCleanup();
 
   // The deduping routine should not be run.
   EXPECT_FALSE(personal_data_->ApplyDedupingRoutine());
 
   // The two duplicate profiles should still be present.
   EXPECT_EQ(2U, personal_data_->GetProfiles().size());
 }
 
 }  // namespace autofill