Move PathExists to base namespace.

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 <objbase.h>  // For CoInitialize().
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/message_loop.h"
@@ skipping 55 matching lines @@
     const int num_profiles = profile_info_cache_->GetNumberOfProfiles();
     for (int i = 0; i < num_profiles; ++i) {
       const base::FilePath profile_path =
           profile_info_cache_->GetPathOfProfileAtIndex(0);
       string16 profile_name = profile_info_cache_->GetNameOfProfileAtIndex(0);
       profile_info_cache_->DeleteProfileFromCache(profile_path);
       RunPendingTasks();
       ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name));
       const base::FilePath icon_path =
           profile_path.AppendASCII(profiles::internal::kProfileIconFileName);
-      ASSERT_FALSE(file_util::PathExists(icon_path));
+      ASSERT_FALSE(base::PathExists(icon_path));
     }
   }
 
   base::FilePath CreateProfileDirectory(const string16& profile_name) {
     const base::FilePath profile_path =
         profile_info_cache_->GetUserDataDir().Append(profile_name);
     file_util::CreateDirectoryW(profile_path);
     return profile_path;
   }
 
@@ skipping 27 matching lines @@
   // Returns the default shortcut path for this profile.
   base::FilePath GetDefaultShortcutPathForProfile(
       const string16& profile_name) {
     return GetUserShortcutsDirectory().Append(
         profiles::internal::GetShortcutFilenameForProfile(profile_name,
                                                           GetDistribution()));
   }
 
   // Returns true if the shortcut for this profile exists.
   bool ProfileShortcutExistsAtDefaultPath(const string16& profile_name) {
-    return file_util::PathExists(
+    return base::PathExists(
         GetDefaultShortcutPathForProfile(profile_name));
   }
 
   // Calls base::win::ValidateShortcut() with expected properties for the
   // shortcut at |shortcut_path| for the profile at |profile_path|.
   void ValidateProfileShortcutAtPath(const tracked_objects::Location& location,
                                      const base::FilePath& shortcut_path,
                                      const base::FilePath& profile_path) {
-    EXPECT_TRUE(file_util::PathExists(shortcut_path)) << location.ToString();
+    EXPECT_TRUE(base::PathExists(shortcut_path)) << location.ToString();
 
     // Ensure that the corresponding icon exists.
     const base::FilePath icon_path =
         profile_path.AppendASCII(profiles::internal::kProfileIconFileName);
-    EXPECT_TRUE(file_util::PathExists(icon_path)) << location.ToString();
+    EXPECT_TRUE(base::PathExists(icon_path)) << location.ToString();
 
     base::win::ShortcutProperties expected_properties;
     expected_properties.set_app_id(
         ShellIntegration::GetChromiumModelIdForProfile(profile_path));
     expected_properties.set_target(GetExePath());
     expected_properties.set_description(GetDistribution()->GetAppDescription());
     expected_properties.set_dual_mode(false);
     expected_properties.set_arguments(
         profiles::internal::CreateProfileShortcutFlags(profile_path));
     expected_properties.set_icon(icon_path, 0);
     base::win::ValidateShortcut(shortcut_path, expected_properties);
   }
 
   // Calls base::win::ValidateShortcut() with expected properties for
   // |profile_name|'s shortcut.
   void ValidateProfileShortcut(const tracked_objects::Location& location,
                                const string16& profile_name,
                                const base::FilePath& profile_path) {
     ValidateProfileShortcutAtPath(
         location, GetDefaultShortcutPathForProfile(profile_name), profile_path);
   }
 
   void ValidateNonProfileShortcutAtPath(
       const tracked_objects::Location& location,
       const base::FilePath& shortcut_path) {
-    EXPECT_TRUE(file_util::PathExists(shortcut_path)) << location.ToString();
+    EXPECT_TRUE(base::PathExists(shortcut_path)) << location.ToString();
 
     base::win::ShortcutProperties expected_properties;
     expected_properties.set_target(GetExePath());
     expected_properties.set_arguments(string16());
     expected_properties.set_icon(GetExePath(), 0);
     expected_properties.set_description(GetDistribution()->GetAppDescription());
     expected_properties.set_dual_mode(false);
     base::win::ValidateShortcut(shortcut_path, expected_properties);
   }
 
@@ skipping 15 matching lines @@
     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 string16& shortcut_name) {
     const base::FilePath shortcut_path =
         GetUserShortcutsDirectory().Append(shortcut_name + installer::kLnkExt);
-    EXPECT_FALSE(file_util::PathExists(shortcut_path)) << location.ToString();
+    EXPECT_FALSE(base::PathExists(shortcut_path)) << location.ToString();
 
     installer::Product product(GetDistribution());
     ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
     product.AddDefaultShortcutProperties(GetExePath(), &properties);
     properties.set_shortcut_name(shortcut_name);
     EXPECT_TRUE(ShellUtil::CreateOrUpdateShortcut(
         ShellUtil::SHORTCUT_LOCATION_DESKTOP, GetDistribution(), properties,
         ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS)) << location.ToString();
-    EXPECT_TRUE(file_util::PathExists(shortcut_path)) << location.ToString();
+    EXPECT_TRUE(base::PathExists(shortcut_path)) << location.ToString();
 
     return shortcut_path;
   }
 
   base::FilePath CreateRegularSystemLevelShortcut(
       const tracked_objects::Location& location) {
     BrowserDistribution* distribution = GetDistribution();
     installer::Product product(distribution);
     ShellUtil::ShortcutProperties properties(ShellUtil::SYSTEM_LEVEL);
     product.AddDefaultShortcutProperties(GetExePath(), &properties);
     EXPECT_TRUE(ShellUtil::CreateOrUpdateShortcut(
         ShellUtil::SHORTCUT_LOCATION_DESKTOP, distribution, properties,
         ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS)) << location.ToString();
     const base::FilePath system_level_shortcut_path =
         GetSystemShortcutsDirectory().Append(
             distribution->GetAppShortCutName() + installer::kLnkExt);
-    EXPECT_TRUE(file_util::PathExists(system_level_shortcut_path))
+    EXPECT_TRUE(base::PathExists(system_level_shortcut_path))
         << location.ToString();
     return system_level_shortcut_path;
   }
 
   void RenameProfile(const tracked_objects::Location& location,
                      const base::FilePath& profile_path,
                      const string16& new_profile_name) {
     const size_t profile_index =
         profile_info_cache_->GetIndexOfProfileWithPath(profile_2_path_);
     ASSERT_NE(std::string::npos, profile_index);
@@ skipping 148 matching lines @@
 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::Delete(profile_1_shortcut_path, false));
-  ASSERT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  ASSERT_TRUE(file_util::PathExists(profile_2_shortcut_path));
+  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_info_cache_->DeleteProfileFromCache(profile_1_path_);
   RunPendingTasks();
 
   // 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(file_util::PathExists(profile_1_shortcut_path));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path));
+  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::Delete(profile_1_shortcut_path, false));
-  ASSERT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  ASSERT_TRUE(file_util::PathExists(profile_2_shortcut_path));
+  ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
+  ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   // Delete the profile that has a shortcut.
   profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
   RunPendingTasks();
 
   // 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(file_util::PathExists(profile_1_shortcut_path));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path));
+  EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
+  EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteOnlyProfileWithShortcuts) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
   CreateProfileWithShortcut(FROM_HERE, profile_3_name_, profile_3_path_);
 
   const base::FilePath non_profile_shortcut_path =
       GetDefaultShortcutPathForProfile(string16());
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
   const base::FilePath profile_3_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_3_name_);
 
   // Delete shortcuts for the first two profiles.
   ASSERT_TRUE(base::Delete(profile_1_shortcut_path, false));
   ASSERT_TRUE(base::Delete(profile_2_shortcut_path, false));
 
   // Only the shortcut to the third profile should exist.
-  ASSERT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  ASSERT_FALSE(file_util::PathExists(profile_2_shortcut_path));
-  ASSERT_FALSE(file_util::PathExists(non_profile_shortcut_path));
-  ASSERT_TRUE(file_util::PathExists(profile_3_shortcut_path));
+  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_info_cache_->DeleteProfileFromCache(profile_3_path_);
   RunPendingTasks();
-  ASSERT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  ASSERT_FALSE(file_util::PathExists(profile_2_shortcut_path));
-  ASSERT_FALSE(file_util::PathExists(profile_3_shortcut_path));
-  ASSERT_FALSE(file_util::PathExists(non_profile_shortcut_path));
+  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_info_cache_->DeleteProfileFromCache(profile_2_path_);
   RunPendingTasks();
 
   // Verify that a default shortcut exists (no profile name/avatar).
@@ skipping 23 matching lines @@
 
   // Ensure that a new shortcut does not get made if the old one was renamed.
   profile_shortcut_manager_->CreateProfileShortcut(profile_2_path_);
   RunPendingTasks();
   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::Delete(profile_2_shortcut_path_2, false));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path_2));
+  EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_2));
   profile_shortcut_manager_->CreateProfileShortcut(profile_2_path_);
   RunPendingTasks();
   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(file_util::PathExists(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_info_cache_->DeleteProfileFromCache(profile_2_path_);
   RunPendingTasks();
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path_1));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path_2));
+  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 =
       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_);
 
   // Now, rename the profile.
   const string16 new_profile_2_name = L"New profile";
   RenameProfile(FROM_HERE, profile_2_path_, new_profile_2_name);
 
   // The original shortcut should be renamed but the copied shortcut should
   // keep its name.
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path_1));
+  EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_1));
   ValidateProfileShortcutAtPath(FROM_HERE, profile_2_shortcut_path_2,
                                 profile_2_path_);
   ValidateProfileShortcut(FROM_HERE, new_profile_2_name, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, UpdateShortcutWithNoFlags) {
   SetupDefaultProfileShortcut(FROM_HERE);
 
   // Delete the shortcut that got created for this profile and instead make
   // a new one without any command-line flags.
   ASSERT_TRUE(base::Delete(GetDefaultShortcutPathForProfile(string16()),
                                 false));
   const base::FilePath regular_shortcut_path =
       CreateRegularShortcutWithName(FROM_HERE,
                                     GetDistribution()->GetAppShortCutName());
 
   // Add another profile and check that the shortcut was replaced with
   // a badged shortcut with the right command line for the profile
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
-  EXPECT_FALSE(file_util::PathExists(regular_shortcut_path));
+  EXPECT_FALSE(base::PathExists(regular_shortcut_path));
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, UpdateTwoShortcutsWithNoFlags) {
   SetupDefaultProfileShortcut(FROM_HERE);
 
   // Delete the shortcut that got created for this profile and instead make
   // two new ones without any command-line flags.
   ASSERT_TRUE(base::Delete(GetDefaultShortcutPathForProfile(string16()),
                                 false));
   const base::FilePath regular_shortcut_path =
       CreateRegularShortcutWithName(FROM_HERE,
                                     GetDistribution()->GetAppShortCutName());
   const base::FilePath customized_regular_shortcut_path =
       CreateRegularShortcutWithName(FROM_HERE, L"MyChrome");
 
   // Add another profile and check that one shortcut was renamed and that the
   // other shortcut was updated but kept the same name.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
-  EXPECT_FALSE(file_util::PathExists(regular_shortcut_path));
+  EXPECT_FALSE(base::PathExists(regular_shortcut_path));
   ValidateProfileShortcutAtPath(FROM_HERE, customized_regular_shortcut_path,
                                 profile_1_path_);
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, RemoveProfileShortcuts) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
   CreateProfileWithShortcut(FROM_HERE, profile_3_name_, profile_3_path_);
 
   const base::FilePath profile_1_shortcut_path_1 =
@@ skipping 12 matching lines @@
                                   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();
-  EXPECT_FALSE(file_util::PathExists(profile_1_shortcut_path_1));
-  EXPECT_FALSE(file_util::PathExists(profile_1_shortcut_path_2));
+  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();
   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::Delete(profile_2_shortcut_path, false));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path));
+  EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
   profile_shortcut_manager_->HasProfileShortcuts(profile_2_path_, callback);
   RunPendingTasks();
   EXPECT_FALSE(result.has_shortcuts);
 }
 
 TEST_F(ProfileShortcutManagerTest, ProfileShortcutsWithSystemLevelShortcut) {
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Create the initial profile.
   profile_info_cache_->AddProfileToCache(profile_1_path_, profile_1_name_,
                                          string16(), 0, false);
   RunPendingTasks();
   ASSERT_EQ(1U, profile_info_cache_->GetNumberOfProfiles());
 
   // Ensure system-level continues to exist and user-level was not created.
-  EXPECT_TRUE(file_util::PathExists(system_level_shortcut_path));
-  EXPECT_FALSE(file_util::PathExists(
+  EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
+  EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(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(file_util::PathExists(system_level_shortcut_path));
+  EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
 
   // Create a third profile without a shortcut and ensure it doesn't get one.
   profile_info_cache_->AddProfileToCache(profile_3_path_, profile_3_name_,
                                          string16(), 0, false);
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
 
   // Ensure that changing the avatar icon and the name does not result in a
   // shortcut being created.
   profile_info_cache_->SetAvatarIconOfProfileAtIndex(
@@ skipping 24 matching lines @@
   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_info_cache_->DeleteProfileFromCache(profile_1_path_);
   RunPendingTasks();
 
-  EXPECT_TRUE(file_util::PathExists(system_level_shortcut_path));
+  EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(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::Delete(profile_1_shortcut_path, false));
-  ASSERT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  ASSERT_TRUE(file_util::PathExists(profile_2_shortcut_path));
+  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 |DeleteDesktopShortcutsAndIconFile()|, which is
   // not covered by the |DeleteSecondToLastProfileWithSystemLevelShortcut| test.
   profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
   RunPendingTasks();
 
   // Verify that only the system-level shortcut still exists.
-  EXPECT_TRUE(file_util::PathExists(system_level_shortcut_path));
-  EXPECT_FALSE(file_util::PathExists(
+  EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
+  EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(string16())));
-  EXPECT_FALSE(file_util::PathExists(profile_1_shortcut_path));
-  EXPECT_FALSE(file_util::PathExists(profile_2_shortcut_path));
+  EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
+  EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }