Remove calls to deprecated MessageLoop methods on Windows and Linux.

chrome/browser/profiles/profile_shortcut_manager_unittest_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
@@ skipping 58 matching lines @@
 
     // Delete all profiles and ensure their shortcuts got removed.
     const size_t num_profiles =
         profile_attributes_storage_->GetNumberOfProfiles();
     for (size_t i = 0; i < num_profiles; ++i) {
       ProfileAttributesEntry* entry =
           profile_attributes_storage_->GetAllProfilesAttributes().front();
       const base::FilePath profile_path = entry->GetPath();
       base::string16 profile_name = entry->GetName();
       profile_attributes_storage_->RemoveProfile(profile_path);
-      RunPendingTasks();
+      base::RunLoop().RunUntilIdle();
       ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name));
       // The icon file is not deleted until the profile directory is deleted.
       const base::FilePath icon_path =
           profiles::internal::GetProfileIconPath(profile_path);
       ASSERT_TRUE(base::PathExists(icon_path));
     }
     scoped_com_.reset();
   }
 
   base::FilePath CreateProfileDirectory(const base::string16& profile_name) {
     const base::FilePath profile_path =
         profile_manager_->profiles_dir().Append(profile_name);
     base::CreateDirectory(profile_path);
     return profile_path;
   }
 
-  void RunPendingTasks() {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
-    base::MessageLoop::current()->Run();
-  }
-
   void SetupDefaultProfileShortcut(const tracked_objects::Location& location) {
     ASSERT_EQ(0u, profile_attributes_storage_->GetNumberOfProfiles())
         << location.ToString();
     ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_))
         << location.ToString();
     profile_attributes_storage_->AddProfile(profile_1_path_, profile_1_name_,
                                             std::string(), base::string16(), 0,
                                             std::string());
     // Also create a non-badged shortcut for Chrome, which is conveniently done
     // by |CreateProfileShortcut()| since there is only one profile.
     profile_shortcut_manager_->CreateProfileShortcut(profile_1_path_);
-    RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
     // Verify that there's now a shortcut with no profile information.
     ValidateNonProfileShortcut(location);
   }
 
   void SetupAndCreateTwoShortcuts(const tracked_objects::Location& location) {
     SetupDefaultProfileShortcut(location);
     CreateProfileWithShortcut(location, profile_2_name_, profile_2_path_);
     ValidateProfileShortcut(location, profile_1_name_, profile_1_path_);
   }
 
@@ skipping 66 matching lines @@
 
   void CreateProfileWithShortcut(const tracked_objects::Location& location,
                                  const base::string16& profile_name,
                                  const base::FilePath& profile_path) {
     ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name))
         << location.ToString();
     profile_attributes_storage_->AddProfile(profile_path, profile_name,
                                             std::string(), base::string16(), 0,
                                             std::string());
     profile_shortcut_manager_->CreateProfileShortcut(profile_path);
-    RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
     ValidateProfileShortcut(location, profile_name, profile_path);
   }
 
   // Creates a regular (non-profile) desktop shortcut with the given name and
   // returns its path. Fails the test if an error occurs.
   base::FilePath CreateRegularShortcutWithName(
       const tracked_objects::Location& location,
       const base::string16& shortcut_name) {
     const base::FilePath shortcut_path =
         GetUserShortcutsDirectory().Append(shortcut_name + installer::kLnkExt);
@@ skipping 29 matching lines @@
   }
 
   void RenameProfile(const tracked_objects::Location& location,
                      const base::FilePath& profile_path,
                      const base::string16& new_profile_name) {
     ProfileAttributesEntry* entry;
     ASSERT_TRUE(profile_attributes_storage_->
                     GetProfileAttributesWithPath(profile_path, &entry));
     ASSERT_NE(entry->GetName(), new_profile_name);
     entry->SetName(new_profile_name);
-    RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
   }
 
   BrowserDistribution* GetDistribution() {
     return BrowserDistribution::GetDistribution();
   }
 
   base::FilePath GetExePath() {
     base::FilePath exe_path;
     EXPECT_TRUE(PathService::Get(base::FILE_EXE, &exe_path));
     return exe_path;
@@ skipping 100 matching lines @@
 
 TEST_F(ProfileShortcutManagerTest, CreateSecondProfileBadgesFirstShortcut) {
   SetupDefaultProfileShortcut(FROM_HERE);
   // Assert that a shortcut without a profile name exists.
   ASSERT_TRUE(ProfileShortcutExistsAtDefaultPath(base::string16()));
 
   // Create a second profile without a shortcut.
   profile_attributes_storage_->AddProfile(profile_2_path_, profile_2_name_,
                                           std::string(), base::string16(), 0,
                                           std::string());
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   // Ensure that the second profile doesn't have a shortcut and that the first
   // profile's shortcut got renamed and badged.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(base::string16()));
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsDeleteSecondToLast) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   // Delete one shortcut.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
 
   // Verify that the profile name has been removed from the remaining shortcut.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that an additional shortcut, with the default profile's name does
   // not exist.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteSecondToLastProfileWithoutShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   // Delete the profile that doesn't have a shortcut.
   profile_attributes_storage_->RemoveProfile(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that the remaining shortcut does not have a profile name.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that shortcuts with profile names do not exist.
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteSecondToLastProfileWithShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   // Delete the profile that has a shortcut.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that the remaining shortcut does not have a profile name.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that shortcuts with profile names do not exist.
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteOnlyProfileWithShortcuts) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
@@ skipping 14 matching lines @@
 
   // Only the shortcut to the third profile should exist.
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_2_shortcut_path));
   ASSERT_FALSE(base::PathExists(non_profile_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_3_shortcut_path));
 
   // Delete the third profile and check that its shortcut is gone and no
   // shortcuts have been re-created.
   profile_attributes_storage_->RemoveProfile(profile_3_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_2_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_3_shortcut_path));
   ASSERT_FALSE(base::PathExists(non_profile_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsCreateSecond) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   // Delete one shortcut.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that a default shortcut exists (no profile name/avatar).
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that an additional shortcut, with the first profile's name does
   // not exist.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
 
   // Create a second profile and shortcut.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
 
   // Verify that the original shortcut received the profile's name.
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
   // Verify that a default shortcut no longer exists.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(base::string16()));
 }
 
 TEST_F(ProfileShortcutManagerTest, RenamedDesktopShortcuts) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_2_shortcut_path_1 =
       GetDefaultShortcutPathForProfile(profile_2_name_);
   const base::FilePath profile_2_shortcut_path_2 =
       GetUserShortcutsDirectory().Append(L"MyChrome.lnk");
   ASSERT_TRUE(base::Move(profile_2_shortcut_path_1,
                               profile_2_shortcut_path_2));
 
   // Ensure that a new shortcut does not get made if the old one was renamed.
   profile_shortcut_manager_->CreateProfileShortcut(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_2,
                                 profile_2_path_);
 
   // Delete the renamed shortcut and try to create it again, which should work.
   ASSERT_TRUE(base::DeleteFile(profile_2_shortcut_path_2, false));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_2));
   profile_shortcut_manager_->CreateProfileShortcut(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   ValidateProfileShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, RenamedDesktopShortcutsGetDeleted) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_2_shortcut_path_1 =
       GetDefaultShortcutPathForProfile(profile_2_name_);
   const base::FilePath profile_2_shortcut_path_2 =
       GetUserShortcutsDirectory().Append(L"MyChrome.lnk");
   // Make a copy of the shortcut.
   ASSERT_TRUE(base::CopyFile(profile_2_shortcut_path_1,
                                   profile_2_shortcut_path_2));
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_1,
                                 profile_2_path_);
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_2,
                                 profile_2_path_);
 
   // Also, copy the shortcut for the first user and ensure it gets preserved.
   const base::FilePath preserved_profile_1_shortcut_path =
       GetUserShortcutsDirectory().Append(L"Preserved.lnk");
   ASSERT_TRUE(base::CopyFile(
       GetDefaultShortcutPathForProfile(profile_1_name_),
       preserved_profile_1_shortcut_path));
   EXPECT_TRUE(base::PathExists(preserved_profile_1_shortcut_path));
 
   // Delete the profile and ensure both shortcuts were also deleted.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_1));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_2));
   ValidateNonProfileShortcutAtPath(FROM_HERE,
                                    preserved_profile_1_shortcut_path);
 }
 
 TEST_F(ProfileShortcutManagerTest, RenamedDesktopShortcutsAfterProfileRename) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_2_shortcut_path_1 =
@@ skipping 77 matching lines @@
   ASSERT_TRUE(base::CopyFile(profile_2_shortcut_path_1,
                                   profile_2_shortcut_path_2));
   ValidateProfileShortcutAtPath(FROM_HERE, profile_1_shortcut_path_2,
                                 profile_1_path_);
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_2,
                                 profile_2_path_);
 
   // Delete shortcuts for profile 1 and ensure that they got deleted while the
   // shortcuts for profile 2 were kept.
   profile_shortcut_manager_->RemoveProfileShortcuts(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path_1));
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path_2));
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_1,
                                 profile_2_path_);
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_2,
                                 profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, HasProfileShortcuts) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   struct HasShortcutsResult {
     bool has_shortcuts;
     void set_has_shortcuts(bool value) { has_shortcuts = value; }
   } result = { false };
 
   const base::Callback<void(bool)> callback =
       base::Bind(&HasShortcutsResult::set_has_shortcuts,
                  base::Unretained(&result));
 
   // Profile 2 should have a shortcut initially.
   profile_shortcut_manager_->HasProfileShortcuts(profile_2_path_, callback);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(result.has_shortcuts);
 
   // Delete the shortcut and check that the function returns false.
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
   ASSERT_TRUE(base::DeleteFile(profile_2_shortcut_path, false));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
   profile_shortcut_manager_->HasProfileShortcuts(profile_2_path_, callback);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(result.has_shortcuts);
 }
 
 TEST_F(ProfileShortcutManagerTest, ProfileShortcutsWithSystemLevelShortcut) {
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Create the initial profile.
   profile_attributes_storage_->AddProfile(profile_1_path_, profile_1_name_,
                                           std::string(), base::string16(), 0,
                                           std::string());
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(1u, profile_attributes_storage_->GetNumberOfProfiles());
 
   // Ensure system-level continues to exist and user-level was not created.
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(base::string16())));
 
   // Create another profile with a shortcut and ensure both profiles receive
   // user-level profile shortcuts and the system-level one still exists.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
   ValidateProfileShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
 
   // Create a third profile without a shortcut and ensure it doesn't get one.
   profile_attributes_storage_->AddProfile(profile_3_path_, profile_3_name_,
                                           std::string(), base::string16(), 0,
                                           std::string());
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
 
   // Ensure that changing the avatar icon and the name does not result in a
   // shortcut being created.
   ProfileAttributesEntry* entry_3;
   ASSERT_TRUE(profile_attributes_storage_->
                   GetProfileAttributesWithPath(profile_3_path_, &entry_3));
   entry_3->SetAvatarIconIndex(3u);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
 
   const base::string16 new_profile_3_name = L"New Name 3";
   entry_3->SetName(new_profile_3_name);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(new_profile_3_name));
 
   // Rename the second profile and ensure its shortcut got renamed.
   const base::string16 new_profile_2_name = L"New Name 2";
   ProfileAttributesEntry* entry_2;
   ASSERT_TRUE(profile_attributes_storage_->
                   GetProfileAttributesWithPath(profile_2_path_, &entry_2));
   entry_2->SetName(new_profile_2_name);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   ValidateProfileShortcut(FROM_HERE, new_profile_2_name, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest,
        DeleteSecondToLastProfileWithSystemLevelShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Delete a profile and verify that only the system-level shortcut still
   // exists.
   profile_attributes_storage_->RemoveProfile(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(base::string16()));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
 }
 
 TEST_F(ProfileShortcutManagerTest,
        DeleteSecondToLastProfileWithShortcutWhenSystemLevelShortcutExists) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Delete the profile that has a shortcut, which will exercise the non-profile
   // shortcut creation path in |DeleteDesktopShortcuts()|, which is
   // not covered by the |DeleteSecondToLastProfileWithSystemLevelShortcut| test.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   // Verify that only the system-level shortcut still exists.
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(base::string16())));
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, CreateProfileIcon) {
   SetupDefaultProfileShortcut(FROM_HERE);
 
   const base::FilePath icon_path =
       profiles::internal::GetProfileIconPath(profile_1_path_);
 
   EXPECT_TRUE(base::PathExists(icon_path));
   EXPECT_TRUE(base::DeleteFile(icon_path, false));
   EXPECT_FALSE(base::PathExists(icon_path));
 
   profile_shortcut_manager_->CreateOrUpdateProfileIcon(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(base::PathExists(icon_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, UnbadgeProfileIconOnDeletion) {
   SetupDefaultProfileShortcut(FROM_HERE);
   const base::FilePath icon_path_1 =
       profiles::internal::GetProfileIconPath(profile_1_path_);
   const base::FilePath icon_path_2 =
       profiles::internal::GetProfileIconPath(profile_2_path_);
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &badged_icon_1));
   std::string badged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &badged_icon_2));
 
   EXPECT_NE(badged_icon_1, unbadged_icon_1);
   EXPECT_EQ(badged_icon_1, badged_icon_2);
 
   // Deleting the default profile will unbadge the new profile's icon and should
   // result in an icon that is identical to the unbadged default profile icon.
   profile_attributes_storage_->RemoveProfile(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   std::string unbadged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &unbadged_icon_2));
   EXPECT_EQ(unbadged_icon_1, unbadged_icon_2);
 }
 
 TEST_F(ProfileShortcutManagerTest, ProfileIconOnAvatarChange) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
   const base::FilePath icon_path_1 =
       profiles::internal::GetProfileIconPath(profile_1_path_);
   const base::FilePath icon_path_2 =
       profiles::internal::GetProfileIconPath(profile_2_path_);
 
   std::string badged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &badged_icon_1));
   std::string badged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &badged_icon_2));
 
   // Profile 1 and 2 are created with the same icon.
   EXPECT_EQ(badged_icon_1, badged_icon_2);
 
   // Change profile 1's icon.
   ProfileAttributesEntry* entry_1;
   ASSERT_TRUE(profile_attributes_storage_->
                   GetProfileAttributesWithPath(profile_1_path_, &entry_1));
   entry_1->SetAvatarIconIndex(1u);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   std::string new_badged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &new_badged_icon_1));
   EXPECT_NE(new_badged_icon_1, badged_icon_1);
 
   // Ensure the new icon is not the unbadged icon.
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   std::string unbadged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &unbadged_icon_1));
   EXPECT_NE(unbadged_icon_1, new_badged_icon_1);
 
   // Ensure the icon doesn't change on avatar change without 2 profiles.
   entry_1->SetAvatarIconIndex(1u);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
 
   std::string unbadged_icon_1_a;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &unbadged_icon_1_a));
   EXPECT_EQ(unbadged_icon_1, unbadged_icon_1_a);
 }
 
 TEST_F(ProfileShortcutManagerTest, ShortcutFilenameUniquified) {
   const auto suffix = l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME);
   std::set<base::FilePath> excludes;
 
@@ skipping 125 matching lines @@
   RenameProfile(FROM_HERE, profile_1_path_, new_profile_1_name);
   ValidateProfileShortcut(FROM_HERE, new_profile_1_name, profile_1_path_);
   // Check that nothing is changed for profile2 and profile3.
   ValidateProfileShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   ValidateProfileShortcutAtPath(FROM_HERE,
                                 profile_3_shortcut_path,
                                 profile_3_path_);
 
   // Delete profile1.
   profile_attributes_storage_->RemoveProfile(profile_1_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(new_profile_1_name));
   // Check that nothing is changed for profile2 and profile3.
   ValidateProfileShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   ValidateProfileShortcutAtPath(FROM_HERE,
                                 profile_3_shortcut_path,
                                 profile_3_path_);
 
   // Delete profile2.
   EXPECT_TRUE(base::PathExists(
       GetDefaultShortcutPathForProfile(profile_2_name_)));
   EXPECT_TRUE(base::PathExists(profile_3_shortcut_path));
   profile_attributes_storage_->RemoveProfile(profile_2_path_);
-  RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(base::PathExists(
       GetDefaultShortcutPathForProfile(profile_2_name_)));
   // Only profile3 exists. There should be non-profile shortcut only.
   EXPECT_FALSE(base::PathExists(profile_3_shortcut_path));
   ValidateNonProfileShortcut(FROM_HERE);
 }