Remove calls to deprecated MessageLoop methods in components.

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/feature_list.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.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/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"
@@ skipping 140 matching lines @@
         scoped_refptr<AutofillWebDataService>(autofill_database_service_),
         prefs_.get(),
         account_tracker_.get(),
         signin_manager_.get(),
         is_incognito);
     personal_data_->AddObserver(&personal_data_observer_);
 
     // Verify that the web database has been updated and the notification sent.
     EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
         .WillOnce(QuitMainMessageLoop());
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
   }
 
   void ResetProfiles() {
     std::vector<AutofillProfile> empty_profiles;
     personal_data_->SetProfiles(&empty_profiles);
   }
 
   void EnableWalletCardImport() {
     signin_manager_->SetAuthenticatedAccountInfo("12345",
                                                  "syncuser@example.com");
@@ skipping 13 matching lines @@
     ASSERT_EQ(0U, personal_data_->GetProfiles().size());
 
     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");
     personal_data_->AddProfile(profile);
 
     EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
         .WillOnce(QuitMainMessageLoop());
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
 
     ASSERT_EQ(1U, personal_data_->GetProfiles().size());
   }
 
   // Helper method that will add credit card fields in |form|, according to the
   // specified values. If a value is nullptr, the corresponding field won't get
   // added (empty string will add a field with an empty string as the value).
   void AddFullCreditCardForm(FormData* form,
                              const char* name,
                              const char* number,
@@ skipping 49 matching lines @@
     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));
     test::SetCreditCardInfo(&credit_card2, "Bonnie Parker",
                             "518765432109" /* Mastercard */, "12", "3999");
     personal_data_->AddCreditCard(credit_card2);
 
     EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
         .WillOnce(QuitMainMessageLoop());
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
 
     ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
   }
 
   // Helper methods that simply forward the call to the private member (to avoid
   // having to friend every test that needs to access the private
   // PersonalDataManager::ImportAddressProfile or ImportCreditCard).
   bool ImportAddressProfiles(const FormStructure& form) {
     return personal_data_->ImportAddressProfiles(form);
   }
@@ skipping 120 matching lines @@
   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::MessageLoop::current()->Run();
+  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"));
   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::MessageLoop::current()->Run();
+  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.
   const AutofillProfile* server_profile = personal_data_->GetProfiles()[0];
   EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
             base::Time::Now() - server_profile->use_date());
 }
@@ skipping 29 matching lines @@
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   // Add two test profiles to the database.
   personal_data_->AddProfile(profile0);
   personal_data_->AddProfile(profile1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 
   // Update, remove, and add.
   profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
   personal_data_->UpdateProfile(profile0);
   personal_data_->RemoveByGUID(profile1.guid());
   personal_data_->AddProfile(profile2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   profiles.clear();
   profiles.push_back(&profile0);
   profiles.push_back(&profile2);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the profiles from the web
   // database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
@@ skipping 15 matching lines @@
   test::SetCreditCardInfo(&credit_card2,
       "Clyde Barrow", "347666888555" /* American Express */, "04", "3999");
 
   // Add two test credit cards to the database.
   personal_data_->AddCreditCard(credit_card0);
   personal_data_->AddCreditCard(credit_card1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<CreditCard*> cards;
   cards.push_back(&credit_card0);
   cards.push_back(&credit_card1);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 
   // Update, remove, and add.
   credit_card0.SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("Joe"));
   personal_data_->UpdateCreditCard(credit_card0);
   personal_data_->RemoveByGUID(credit_card1.guid());
   personal_data_->AddCreditCard(credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   cards.clear();
   cards.push_back(&credit_card0);
   cards.push_back(&credit_card2);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the credit cards from the web
   // database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
@@ skipping 41 matching lines @@
       "John Dillinger", "423456789012" /* Visa */, "01", "2999");
   EXPECT_FALSE(credit_card.IsVerified());
 
   // Add the data to the database.
   personal_data_->AddProfile(profile);
   personal_data_->AddCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& profiles1 =
       personal_data_->GetProfiles();
   const std::vector<CreditCard*>& cards1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, profiles1.size());
   ASSERT_EQ(1U, cards1.size());
   EXPECT_EQ(0, profile.Compare(*profiles1[0]));
   EXPECT_EQ(0, credit_card.Compare(*cards1[0]));
 
   // Try to update with just the origin changed.
@@ skipping 23 matching lines @@
   // Try to update with data changed as well.
   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
   credit_card.SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("Joe"));
 
   personal_data_->UpdateProfile(profile);
   personal_data_->UpdateCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& profiles3 =
       personal_data_->GetProfiles();
   const std::vector<CreditCard*>& cards3 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, profiles3.size());
   ASSERT_EQ(1U, cards3.size());
   EXPECT_EQ(0, profile.Compare(*profiles3[0]));
   EXPECT_EQ(0, credit_card.Compare(*cards3[0]));
   EXPECT_EQ(profile.origin(), profiles3[0]->origin());
   EXPECT_EQ(credit_card.origin(), cards3[0]->origin());
@@ skipping 13 matching lines @@
 
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(1U, personal_data_->GetCreditCards().size());
   EXPECT_EQ(CreditCard::MASKED_SERVER_CARD,
             personal_data_->GetCreditCards()[0]->record_type());
 }
 
 TEST_F(PersonalDataManagerTest, OfferStoreUnmaskedCards) {
 #if defined(OS_CHROMEOS) || defined(OS_WIN) || defined(OS_MACOSX) || \
     defined(OS_IOS) || defined(OS_ANDROID)
   bool should_offer = true;
@@ skipping 20 matching lines @@
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   if (!OfferStoreUnmaskedCards()) {
     for (CreditCard* card : personal_data_->GetCreditCards()) {
       EXPECT_EQ(CreditCard::MASKED_SERVER_CARD, card->record_type());
     }
     // The rest of this test doesn't work if we're force-masking all unmasked
     // cards.
     return;
   }
 
   // The GUIDs will be different, so just compare the data.
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 
   CreditCard* unmasked_card = &server_cards.front();
   unmasked_card->set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked_card->SetNumber(ASCIIToUTF16("423456789012"));
   EXPECT_NE(0, server_cards.front().Compare(
                    *personal_data_->GetCreditCards().front()));
   personal_data_->UpdateServerCreditCard(*unmasked_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 
   CreditCard* remasked_card = &server_cards.back();
   remasked_card->set_record_type(CreditCard::MASKED_SERVER_CARD);
   remasked_card->SetNumber(ASCIIToUTF16("8555"));
   EXPECT_NE(
       0, server_cards.back().Compare(*personal_data_->GetCreditCards().back()));
   personal_data_->UpdateServerCreditCard(*remasked_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 }
 
 TEST_F(PersonalDataManagerTest, AddProfilesAndCreditCards) {
   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",
@@ skipping 13 matching lines @@
   test::SetCreditCardInfo(&credit_card1,
       "Bonnie Parker", "518765432109" /* Mastercard */, "12", "3999");
 
   // Add two test profiles to the database.
   personal_data_->AddProfile(profile0);
   personal_data_->AddProfile(profile1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 
   // Add two test credit cards to the database.
   personal_data_->AddCreditCard(credit_card0);
   personal_data_->AddCreditCard(credit_card1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<CreditCard*> cards;
   cards.push_back(&credit_card0);
   cards.push_back(&credit_card1);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 
   // Determine uniqueness by inserting all of the GUIDs into a set and verifying
   // the size of the set matches the number of GUIDs.
   std::set<std::string> guids;
   guids.insert(profile0.guid());
   guids.insert(profile1.guid());
   guids.insert(credit_card0.guid());
   guids.insert(credit_card1.guid());
   EXPECT_EQ(4U, guids.size());
 }
 
 // Test for http://crbug.com/50047. Makes sure that guids are populated
 // correctly on load.
 TEST_F(PersonalDataManagerTest, PopulateUniqueIDsOnLoad) {
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile0,
       "y", "", "", "", "", "", "", "", "", "", "", "");
 
   // Add the profile0 to the db.
   personal_data_->AddProfile(profile0);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Verify that we've loaded the profiles from the web database.
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, profile0.Compare(*results2[0]));
 
   // Add a new profile.
   AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile1,
       "z", "", "", "", "", "", "", "", "", "", "", "");
   personal_data_->AddProfile(profile1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Make sure the two profiles have different GUIDs, both valid.
   const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
   ASSERT_EQ(2U, results3.size());
   EXPECT_NE(results3[0]->guid(), results3[1]->guid());
   EXPECT_TRUE(base::IsValidGUID(results3[0]->guid()));
   EXPECT_TRUE(base::IsValidGUID(results3[1]->guid()));
 }
 
 TEST_F(PersonalDataManagerTest, SetUniqueCreditCardLabels) {
@@ skipping 85 matching lines @@
       "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801",
       "US", "19482937549");
 
   // Add the test profiles to the database.
   personal_data_->AddProfile(profile0);
   personal_data_->AddProfile(profile1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2,
       "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   autofill_database_service_->AddAutofillProfile(profile2);
 
   personal_data_->Refresh();
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   profiles.clear();
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   profiles.push_back(&profile2);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 
   autofill_database_service_->RemoveAutofillProfile(profile1.guid());
   autofill_database_service_->RemoveAutofillProfile(profile2.guid());
 
   // Before telling the PDM to refresh, simulate an edit to one of the deleted
   // profiles via a SetProfile update (this would happen if the Autofill window
   // was open with a previous snapshot of the profiles, and something
   // [e.g. sync] removed a profile from the browser.  In this edge case, we will
   // end up in a consistent state by dropping the write).
   profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Mar"));
   profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jo"));
   personal_data_->UpdateProfile(profile0);
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(profile0, *results[0]);
 }
 
 // ImportAddressProfiles tests.
 
 TEST_F(PersonalDataManagerTest, ImportAddressProfiles) {
   FormData form;
@@ skipping 16 matching lines @@
   form.fields.push_back(field);
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form.fields.push_back(field);
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
       "San Francisco", "California", "94102", NULL, NULL);
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
@@ skipping 207 matching lines @@
   form.fields.push_back(field);
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form.fields.push_back(field);
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", NULL, NULL, "21 Laussat St", NULL,
       "San Francisco", "California", "94102", NULL, "(650) 555-0000");
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
@@ skipping 23 matching lines @@
   form.fields.push_back(field);
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form.fields.push_back(field);
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", "theprez@gmail.com", NULL, "21 Laussat St", "Apt. #42",
       "San Francisco", "California", "94102", NULL, NULL);
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
@@ skipping 20 matching lines @@
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form1.fields.push_back(field);
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure1));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL,
       "San Francisco", "California", "94102", NULL, NULL);
   const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, expected.Compare(*results1[0]));
 
   // Now create a completely different profile.
@@ skipping 17 matching lines @@
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure2));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected2, "John", NULL,
       "Adams", "second@gmail.com", NULL, "22 Laussat St", NULL,
       "San Francisco", "California", "94102", NULL, NULL);
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&expected);
   profiles.push_back(&expected2);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 }
@@ skipping 40 matching lines @@
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form.fields.push_back(field);
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL, "Washington",
                        "theprez@gmail.com", NULL, "21 Laussat St", NULL,
                        "San Francisco", "California", "94102", NULL, NULL);
   AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected2, "John", NULL, "Adams", "second@gmail.com",
                        NULL, "22 Laussat St", NULL, "San Francisco",
                        "California", "94102", NULL, NULL);
 
@@ skipping 57 matching lines @@
   form.fields.push_back(field);
 
   // Still able to do the import.
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL, "Washington",
                        "theprez@gmail.com", NULL, "21 Laussat St", NULL,
                        "San Francisco", "California", "94102", NULL, NULL);
 
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
 
   std::vector<AutofillProfile*> profiles;
@@ skipping 63 matching lines @@
                             &field);
   form.fields.push_back(field);
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Only two are saved.
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL, "Washington",
                        "theprez@gmail.com", NULL, "21 Laussat St", NULL,
                        "San Francisco", "California", "94102", NULL, NULL);
   AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected2, "John", NULL, "Adams", "second@gmail.com",
                        NULL, "22 Laussat St", NULL, "San Francisco",
                        "California", "94102", NULL, NULL);
@@ skipping 34 matching lines @@
   test::CreateTestFormField("Phone:", "phone", "6505556666", "text", &field);
   form1.fields.push_back(field);
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure1));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", nullptr, "Washington",
                        "theprez@gmail.com", nullptr, "1600 Pennsylvania Avenue",
                        "Suite A", "San Francisco", "California", "94102",
                        nullptr, "(650) 555-6666");
   const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, expected.Compare(*results1[0]));
 
@@ skipping 27 matching lines @@
   test::CreateTestFormField("Phone:", "phone", "650-555-6666", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure2));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
 
   // Phone formatting is updated.  Also, country gets added.
   expected.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("650-555-6666"));
   expected.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected.Compare(*results2[0]));
 }
 
@@ skipping 16 matching lines @@
   test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
   form1.fields.push_back(field);
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure1));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", NULL, NULL, "190 High Street", NULL,
       "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
   const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, expected.Compare(*results1[0]));
 
   // Submit a form with new data for the first profile.
@@ skipping 17 matching lines @@
   test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure2));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
 
   AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected2, "George", NULL,
       "Washington", "theprez@gmail.com", NULL, "190 High Street", NULL,
       "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
@@ skipping 23 matching lines @@
   test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
   form1.fields.push_back(field);
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure1));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile expected(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&expected, "George", NULL,
       "Washington", "theprez@gmail.com", "Government", "190 High Street", NULL,
       "Philadelphia", "Pennsylvania", "19106", NULL, NULL);
   const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, expected.Compare(*results1[0]));
 
   // Submit a form with new data for the first profile.
@@ skipping 18 matching lines @@
   test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure2));
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
 
   // Expect no change.
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportAddressProfiles_InsufficientAddress) {
   FormData form1;
@@ skipping 42 matching lines @@
                        "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5",
                        "Hollywood", "CA", "91601", "US", "12345678910");
   EXPECT_TRUE(profile.IsVerified());
 
   // Add the profile to the database.
   personal_data_->AddProfile(profile);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Simulate a form submission with conflicting info.
   FormData form;
   FormFieldData field;
   test::CreateTestFormField("First name:", "first_name", "Marion Mitchell",
                             "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Last name:", "last_name", "Morrison", "text",
                             &field);
   form.fields.push_back(field);
@@ skipping 10 matching lines @@
   test::CreateTestFormField("Zip:", "zip", "91601", "text", &field);
   form.fields.push_back(field);
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure));
 
   // Wait for the refresh, which in this case is a no-op.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that no new profile is saved.
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, profile.Compare(*results[0]));
 
   // Try the same thing, but without "Mitchell". The profiles should still match
   // because the non empty name pieces (first and last) match that stored in the
   // profile.
   test::CreateTestFormField("First name:", "first_name", "Marion", "text",
                             &field);
   form.fields[0] = field;
 
   FormStructure form_structure2(form);
   form_structure2.DetermineHeuristicTypes();
   EXPECT_TRUE(ImportAddressProfiles(form_structure2));
 
   // Wait for the refresh, which in this case is a no-op.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that no new profile is saved.
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, profile.Compare(*results2[0]));
 }
 
 // ImportCreditCard tests.
 
 // Tests that a valid credit card is extracted.
 TEST_F(PersonalDataManagerTest, ImportCreditCard_Valid) {
   // Add a single valid credit card form.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
 // Tests that an invalid credit card is not extracted.
@@ skipping 39 matching lines @@
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // See that the invalid option text was converted to the right value.
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "02",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_TwoValidCards) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card.
   FormData form2;
   AddFullCreditCardForm(&form2, "", "5500 0000 0000 0004", "02", "3999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card2;
   EXPECT_TRUE(ImportCreditCard(form_structure2, false, &imported_credit_card2));
   ASSERT_TRUE(imported_credit_card2);
   personal_data_->SaveImportedCreditCard(*imported_credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "", "5500000000000004", "02", "3999");
   std::vector<CreditCard*> cards;
   cards.push_back(&expected);
   cards.push_back(&expected2);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 }
 
 // Tests that a credit card is extracted because it only matches a masked server
@@ skipping 18 matching lines @@
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 }
 
 // Tests that a credit card is not extracted because it matches a full server
 // card.
 TEST_F(PersonalDataManagerTest,
        ImportCreditCard_DuplicateServerCards_FullCard) {
   // Add a full server card.
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
@@ skipping 22 matching lines @@
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form2;
   AddFullCreditCardForm(&form2, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "3999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card2;
   EXPECT_TRUE(ImportCreditCard(form_structure2, false, &imported_credit_card2));
   EXPECT_FALSE(imported_credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // updated to "3999".
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01",
                           "3999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_ShouldReturnLocalCard) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form2;
   AddFullCreditCardForm(&form2, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "3999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card2;
   EXPECT_TRUE(ImportCreditCard(form_structure2,
                                /* should_return_local_card= */ true,
                                &imported_credit_card2));
   // The local card is returned after an update.
   EXPECT_TRUE(imported_credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // updated to "3999".
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "3999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_EmptyCardWithConflict) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second credit card with no number.
   FormData form2;
@@ skipping 29 matching lines @@
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the name is missing but
   // the credit card number matches.
@@ skipping 49 matching lines @@
   // Start with a single valid credit card stored via the preferences.
   // Note the empty name.
   CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&saved_credit_card,
       "", "4111111111111111" /* Visa */, "01", "2999");
   personal_data_->AddCreditCard(saved_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(saved_credit_card, *results1[0]);
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         /* different year */ "3999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // added to the existing credit card.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "3999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 // We allow the user to store a credit card number with separators via the UI.
 // We should not try to re-aggregate the same card with the separators stripped.
 TEST_F(PersonalDataManagerTest, ImportCreditCard_SameCardWithSeparators) {
   // Start with a single valid credit card stored via the preferences.
   // Note the separators in the credit card number.
   CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&saved_credit_card,
       "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2999");
   personal_data_->AddCreditCard(saved_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, saved_credit_card.Compare(*results1[0]));
 
   // Import the same card info, but with different separators in the number.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
@@ skipping 22 matching lines @@
   test::SetCreditCardInfo(&credit_card, "Biggie Smalls",
                           "4111 1111 1111 1111" /* Visa */, "01", "2999");
   EXPECT_TRUE(credit_card.IsVerified());
 
   // Add the credit card to the database.
   personal_data_->AddCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Simulate a form submission with conflicting expiration year.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "3999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
@@ skipping 44 matching lines @@
   form_structure.DetermineHeuristicTypes();
   std::unique_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(personal_data_->ImportFormData(form_structure, false,
                                              &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Test that the address has been saved.
   AutofillProfile expected_address(base::GenerateGUID(),
                                    "https://www.example.com");
   test::SetProfileInfo(&expected_address, "George", NULL, "Washington",
                        "theprez@gmail.com", NULL, "21 Laussat St", NULL,
                        "San Francisco", "California", "94102", NULL, NULL);
   const std::vector<AutofillProfile*>& results_addr =
       personal_data_->GetProfiles();
   ASSERT_EQ(1U, results_addr.size());
@@ skipping 58 matching lines @@
   std::unique_ptr<CreditCard> imported_credit_card;
   // Still returns true because the credit card import was successful.
   EXPECT_TRUE(personal_data_->ImportFormData(form_structure, false,
                                              &imported_credit_card));
   ASSERT_TRUE(imported_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Test that both addresses have been saved.
   EXPECT_EQ(2U, personal_data_->GetProfiles().size());
 
   // Test that the credit card has been saved.
   CreditCard expected_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected_card, "Biggie Smalls", "4111111111111111",
                           "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
@@ skipping 10 matching lines @@
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
   EXPECT_FALSE(profile.IsVerified());
 
   // Add the profile to the database.
   personal_data_->AddProfile(profile);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   AutofillProfile new_verified_profile = profile;
   new_verified_profile.set_guid(base::GenerateGUID());
   new_verified_profile.set_origin(kSettingsOrigin);
   new_verified_profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                                   ASCIIToUTF16("1 234 567-8910"));
   EXPECT_TRUE(new_verified_profile.IsVerified());
 
   personal_data_->SaveImportedProfile(new_verified_profile);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // The new profile should be merged into the existing one.
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, new_verified_profile.Compare(*results[0]));
 }
 
 // Ensure that verified credit cards can be saved via SaveImportedCreditCard.
 TEST_F(PersonalDataManagerTest, SaveImportedCreditCardWithVerifiedData) {
   // Start with a verified credit card.
   CreditCard credit_card(base::GenerateGUID(), kSettingsOrigin);
   test::SetCreditCardInfo(&credit_card,
       "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2999");
   EXPECT_TRUE(credit_card.IsVerified());
 
   // Add the credit card to the database.
   personal_data_->AddCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CreditCard new_verified_card = credit_card;
   new_verified_card.set_guid(base::GenerateGUID());
   new_verified_card.SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("B. Small"));
   EXPECT_TRUE(new_verified_card.IsVerified());
 
   personal_data_->SaveImportedCreditCard(new_verified_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Expect that the saved credit card is updated.
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(ASCIIToUTF16("B. Small"),
             results[0]->GetRawInfo(CREDIT_CARD_NAME_FULL));
 }
 
 TEST_F(PersonalDataManagerTest, GetNonEmptyTypes) {
   // Check that there are no available types with no profiles stored.
   ServerFieldTypeSet non_empty_types;
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   EXPECT_EQ(0U, non_empty_types.size());
 
   // Test with one profile stored.
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile0,
       "Marion", NULL, "Morrison",
       "johnwayne@me.xyz", NULL, "123 Zoo St.", NULL, "Hollywood", "CA",
       "91601", "US", "14155678910");
 
   personal_data_->AddProfile(profile0);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   EXPECT_EQ(15U, non_empty_types.size());
   EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
   EXPECT_TRUE(non_empty_types.count(NAME_LAST));
   EXPECT_TRUE(non_empty_types.count(NAME_FULL));
   EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
   EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
   EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STREET_ADDRESS));
   EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
@@ skipping 18 matching lines @@
       "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "16502937549");
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   EXPECT_EQ(19U, non_empty_types.size());
   EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
   EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
   EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
   EXPECT_TRUE(non_empty_types.count(NAME_LAST));
   EXPECT_TRUE(non_empty_types.count(NAME_FULL));
   EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
   EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
@@ skipping 13 matching lines @@
   // Test with credit card information also stored.
   CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card,
                           "John Dillinger", "423456789012" /* Visa */,
                           "01", "2999");
   personal_data_->AddCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   EXPECT_EQ(29U, non_empty_types.size());
   EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
   EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
   EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
   EXPECT_TRUE(non_empty_types.count(NAME_LAST));
   EXPECT_TRUE(non_empty_types.count(NAME_FULL));
   EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
   EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
@@ skipping 100 matching lines @@
       personal_data_->GetDefaultCountryCodeForNewAddress();
   EXPECT_EQ(2U, default_country.size());
 
   AutofillProfile moose(base::GenerateGUID(), kSettingsOrigin);
   test::SetProfileInfo(&moose, "Moose", "P", "McMahon", "mpm@example.com",
       "", "1 Taiga TKTR", "", "Calgary", "AB", "T2B 2K2",
       "CA", "(800) 555-9000");
   personal_data_->AddProfile(moose);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   // The value is cached and doesn't change even after adding an address.
   EXPECT_EQ(default_country,
             personal_data_->GetDefaultCountryCodeForNewAddress());
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(2);
 
   // Disabling Autofill blows away this cache and shouldn't account for Autofill
   // profiles.
   prefs_->SetBoolean(prefs::kAutofillEnabled, false);
   EXPECT_EQ(default_country,
@@ skipping 63 matching lines @@
 TEST_F(PersonalDataManagerTest, UpdateLanguageCodeInProfile) {
   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");
   personal_data_->AddProfile(profile);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   profile.set_language_code("en");
   personal_data_->UpdateProfile(profile);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, profile.Compare(*results[0]));
   EXPECT_EQ("en", results[0]->language_code());
 }
 
 TEST_F(PersonalDataManagerTest, GetProfileSuggestions) {
   AutofillProfile profile(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile,
@@ skipping 194 matching lines @@
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "b459"));
   test::SetCreditCardInfo(&server_cards.back(), "Emmet Dalton", "2110", "12",
                           "3999");
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(AutofillType(CREDIT_CARD_NUMBER),
                                                ASCIIToUTF16("12345678"));
 
   // There should be no suggestions.
   ASSERT_EQ(0U, suggestions.size());
 }
 
 // Test that local credit cards are ordered as expected.
@@ skipping 40 matching lines @@
   test::SetCreditCardInfo(&server_cards.back(), "Jesse James", "2109", "12",
                           "3999");
   server_cards.back().set_use_count(6);
   server_cards.back().set_use_date(base::Time::Now() -
                                    base::TimeDelta::FromDays(1));
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
           AutofillType(CREDIT_CARD_NAME_FULL),
           /* field_contents= */ base::string16());
   ASSERT_EQ(5U, suggestions.size());
 
   // All cards should be ordered as expected.
   EXPECT_EQ(ASCIIToUTF16("Jesse James"), suggestions[0].value);
   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), suggestions[1].value);
@@ skipping 27 matching lines @@
   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));
   test::SetCreditCardInfo(&credit_card2, "John Dillinger",
                           "423456789012" /* Visa */, "01", "1998");
   personal_data_->AddCreditCard(credit_card2);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
           AutofillType(CREDIT_CARD_NAME_FULL),
           /* field_contents= */ base::string16());
   ASSERT_EQ(3U, suggestions.size());
 
   // The never used non expired card should be suggested first.
@@ skipping 20 matching lines @@
 
   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));
   test::SetCreditCardInfo(&credit_card1, "John Dillinger", "", "01", "2999");
   personal_data_->AddCreditCard(credit_card1);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(2U, personal_data_->GetCreditCards().size());
 
   // Sublabel is expiration date when filling card number. The second card
   // doesn't have a number so it should not be included in the suggestions.
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
           AutofillType(CREDIT_CARD_NUMBER),
           /* field_contents= */ base::string16());
   ASSERT_EQ(1U, suggestions.size());
@@ skipping 39 matching lines @@
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
   server_cards.back().set_use_count(1);
   server_cards.back().set_use_date(base::Time::Now() -
                                    base::TimeDelta::FromDays(15));
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
           AutofillType(CREDIT_CARD_NAME_FULL),
           /* field_contents= */ base::string16());
   ASSERT_EQ(4U, suggestions.size());
   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), suggestions[0].value);
   EXPECT_EQ(ASCIIToUTF16("Clyde Barrow"), suggestions[1].value);
   EXPECT_EQ(ASCIIToUTF16("Bonnie Parker"), suggestions[2].value);
   EXPECT_EQ(ASCIIToUTF16("Bonnie Parker"), suggestions[3].value);
@@ skipping 26 matching lines @@
   // This unmasked server card is an exact dupe of a local card. Therefore only
   // the local card should appear in the suggestions.
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<Suggestion> suggestions =
       personal_data_->GetCreditCardSuggestions(
           AutofillType(CREDIT_CARD_NAME_FULL),
           /* field_contents= */ base::string16());
   ASSERT_EQ(3U, suggestions.size());
 
   // Add a second dupe local card to make sure a full server card can be a dupe
   // of more than one local card.
   CreditCard credit_card3("4141084B-72D7-4B73-90CF-3D6AC154673B",
                           "https://www.example.com");
   test::SetCreditCardInfo(&credit_card3, "Clyde Barrow", "", "04", "");
   personal_data_->AddCreditCard(credit_card3);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   suggestions = personal_data_->GetCreditCardSuggestions(
       AutofillType(CREDIT_CARD_NAME_FULL),
       /* field_contents= */ base::string16());
   ASSERT_EQ(3U, suggestions.size());
 }
 
 // Tests that only the full server card is kept when deduping with a local
 // duplicate of it.
 TEST_F(PersonalDataManagerTest,
@@ skipping 130 matching lines @@
                           "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());
   personal_data_->AddCreditCard(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // 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());
   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());
   personal_data_->RecordUseOf(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  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());
 
   added_card = personal_data_->GetCreditCardByGUID(credit_card.guid());
   ASSERT_TRUE(added_card);
@@ skipping 18 matching lines @@
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   if (!OfferStoreUnmaskedCards()) {
     for (CreditCard* card : personal_data_->GetCreditCards()) {
       EXPECT_EQ(CreditCard::MASKED_SERVER_CARD, card->record_type());
     }
     // The rest of this test doesn't work if we're force-masking all unmasked
     // cards.
     return;
   }
 
   // The GUIDs will be different, so just compare the data.
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 
   CreditCard* unmasked_card = &server_cards.front();
   unmasked_card->set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked_card->SetNumber(ASCIIToUTF16("423456789012"));
   EXPECT_NE(0, unmasked_card->Compare(
       *personal_data_->GetCreditCards().front()));
   personal_data_->UpdateServerCreditCard(*unmasked_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  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.
   EXPECT_EQ(2U, personal_data_->GetCreditCards()[0]->use_count());
   EXPECT_NE(base::Time(), 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());
 
   // Having unmasked this card, usage stats should be 2 and Now().
   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();
 
   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::MessageLoop::current()->Run();
+  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(1U, personal_data_->GetCreditCards()[1]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
 
   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());
 
   // 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::MessageLoop::current()->Run();
+  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());
 
   // 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::MessageLoop::current()->Run();
+  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());
 }
 
 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",
@@ skipping 37 matching lines @@
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "3999");
 
   test::SetServerCreditCards(autofill_table_, server_cards);
   personal_data_->Refresh();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // A valid credit card form. A user re-enters one of their masked cards.
   // We shouldn't offer to save. It's possible this is actually a different card
   // but it's very unlikely. And these circumstances will also arise if the user
   // has the same card available locally and synced from payments.
   FormData form1;
   FormFieldData field;
   test::CreateTestFormField("Name on card:", "name_on_card", "John Dillinger",
                             "text", &field);
   form1.fields.push_back(field);
@@ skipping 535 matching lines @@
                        "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));
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved;
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
 
   // Enable the profile cleanup now. Otherwise it would be triggered by the
   // calls to AddProfile.
   EnableAutofillProfileCleanup();
 
   base::HistogramTester histogram_tester;
 
   personal_data_->ApplyDedupingRoutine();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles = personal_data_->GetProfiles();
 
   // |profile1| should have been merged into |profile2| which should then have
   // been merged into |profile3|. Therefore there should only be 1 saved
   // profile.
   ASSERT_EQ(1U, profiles.size());
   // 3 profiles were considered for dedupe.
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesConsideredForDedupe", 3, 1);
@@ skipping 58 matching lines @@
                        "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));
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
 
   // Enable the profile cleanup now. Otherwise it would be triggered by the
   // calls to AddProfile.
   EnableAutofillProfileCleanup();
 
   base::HistogramTester histogram_tester;
 
   personal_data_->ApplyDedupingRoutine();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles = personal_data_->GetProfiles();
 
   // |profile2| should have merged with |profile3|. |profile3|
   // should then have been discarded because it is similar to the verified
   // |profile1|.
   ASSERT_EQ(1U, profiles.size());
   // 3 profiles were considered for dedupe.
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfProfilesConsideredForDedupe", 3, 1);
@@ skipping 37 matching lines @@
                        "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));
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
 
   // Enable the profile cleanup now. Otherwise it would be triggered by the
   // calls to AddProfile.
   EnableAutofillProfileCleanup();
 
   base::HistogramTester histogram_tester;
 
   personal_data_->ApplyDedupingRoutine();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   std::vector<AutofillProfile*> profiles = personal_data_->GetProfiles();
 
   // |profile1| should have merged with |profile2|. |profile2|
   // 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);
@@ skipping 36 matching lines @@
                        "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));
 
   personal_data_->AddProfile(profile1);
   personal_data_->AddProfile(profile2);
   personal_data_->AddProfile(profile3);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Make sure the 3 profiles were saved.
   EXPECT_EQ(3U, personal_data_->GetProfiles().size());
 
   // Enable the profile cleanup now. Otherwise it would be triggered by the
   // calls to AddProfile.
   EnableAutofillProfileCleanup();
 
   base::HistogramTester histogram_tester;
 
   personal_data_->ApplyDedupingRoutine();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Get the profiles, sorted by frecency to have a deterministic order.
   std::vector<AutofillProfile*> profiles =
       personal_data_->GetProfilesToSuggest();
 
   // |profile1| should have been discarded because the saved profile with the
   // highest frecency score is verified (|profile2|). Therefore, |profile1|'s
   // data should not have been merged with |profile2|'s data. Then |profile2|
   // should have been compared to |profile3| but they should not have merged
   // because both profiles are verified.
@@ skipping 41 matching lines @@
   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::MessageLoop::current()->Run();
+  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());
 
   // Set the pref to false to indicate the fix has never been run.
   personal_data_->pref_service_->SetBoolean(
       prefs::kAutofillProfileUseDatesFixed, false);
 
   personal_data_->ApplyProfileUseDatesFix();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
-  base::MessageLoop::current()->Run();
+  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());
   // |profile2|'s use date should have been set to two weeks before now.
@@ skipping 20 matching lines @@
   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::MessageLoop::current()->Run();
+  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());
@@ skipping 238 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