Move PathExists to base namespace.

chrome/installer/setup/setup_main.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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
@@ skipping 103 matching lines @@
     return ret;
 
   base::FilePath uncompressed_archive(
       temp_path.Append(installer::kChromeArchive));
   scoped_ptr<Version> archive_version(
       installer::GetMaxVersionFromArchiveDir(installer_state.target_path()));
 
   // Check if this is differential update and if it is, patch it to the
   // installer archive that should already be on the machine. We assume
   // it is a differential installer if chrome.7z is not found.
-  if (!file_util::PathExists(uncompressed_archive)) {
+  if (!base::PathExists(uncompressed_archive)) {
     *archive_type = installer::INCREMENTAL_ARCHIVE_TYPE;
     VLOG(1) << "Differential patch found. Applying to existing archive.";
     if (!archive_version.get()) {
       LOG(ERROR) << "Can not use differential update when Chrome is not "
                  << "installed on the system.";
       return installer::CHROME_NOT_INSTALLED;
     }
 
     base::FilePath existing_archive(installer_state.target_path().AppendASCII(
         archive_version->GetString()));
@@ skipping 541 matching lines @@
     installer_state.WriteInstallerResult(installer::TEMP_DIR_FAILED,
         IDS_INSTALL_TEMP_DIR_FAILED_BASE, NULL);
     return installer::TEMP_DIR_FAILED;
   }
 
   bool unpacked = false;
 
   // We want to keep uncompressed archive (chrome.7z) that we get after
   // uncompressing and binary patching. Get the location for this file.
   base::FilePath archive_to_copy;
-  if (file_util::PathExists(archive)) {
+  if (base::PathExists(archive)) {
     VLOG(1) << "Archive found to install Chrome " << archive.value();
     if (UnPackArchive(archive, installer_state, temp_path.path(), unpack_path,
                       archive_type)) {
       install_status = (*archive_type) == installer::INCREMENTAL_ARCHIVE_TYPE ?
           installer::APPLY_DIFF_PATCH_FAILED : installer::UNCOMPRESSION_FAILED;
       installer_state.WriteInstallerResult(
           install_status,
           IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
           NULL);
     } else {
       unpacked = true;
       archive_to_copy = temp_path.path().Append(installer::kChromeArchive);
     }
   } else {
     base::FilePath uncompressed_archive(cmd_line.GetProgram().DirName().Append(
         installer::kChromeArchive));
 
-    if (file_util::PathExists(uncompressed_archive)) {
+    if (base::PathExists(uncompressed_archive)) {
       VLOG(1) << "Uncompressed archive found to install Chrome "
               << uncompressed_archive.value();
       *archive_type = installer::FULL_ARCHIVE_TYPE;
       string16 unpacked_file;
       if (LzmaUtil::UnPackArchive(uncompressed_archive.value(),
                                   unpack_path.value(), &unpacked_file)) {
         installer_state.WriteInstallerResult(
             installer::UNCOMPRESSION_FAILED,
             IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
             NULL);
@@ skipping 335 matching lines @@
         !installer_state.system_install()) {
       BrowserDistribution* dist = chrome->distribution();
       const base::FilePath system_exe_path(
           installer::GetChromeInstallPath(true, dist)
               .Append(installer::kChromeExe));
       system_level_cmd.SetProgram(system_exe_path);
 
       base::FilePath first_run_sentinel;
       InstallUtil::GetSentinelFilePath(
           chrome::kFirstRunSentinel, dist, &first_run_sentinel);
-      if (file_util::PathExists(first_run_sentinel)) {
+      if (base::PathExists(first_run_sentinel)) {
         // If the Chrome being self-destructed has already undergone First Run,
         // trigger Active Setup and make sure the system-level Chrome doesn't go
         // through first run.
         trigger_active_setup = true;
         system_level_cmd.AppendSwitch(::switches::kNoFirstRun);
       }
     }
   }
   if (installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES)) {
     // Chrome Binaries should be last; if something else is cancelled, they
@@ skipping 126 matching lines @@
   }
 
   base::FilePath chrome_exe(
       cmd_line.GetSwitchValuePath(installer::switches::kRegisterDevChrome));
   if (chrome_exe.empty())
     chrome_exe = cmd_line.GetProgram().DirName().Append(installer::kChromeExe);
   if (!chrome_exe.IsAbsolute())
     chrome_exe = base::MakeAbsoluteFilePath(chrome_exe);
 
   installer::InstallStatus status = installer::FIRST_INSTALL_SUCCESS;
-  if (file_util::PathExists(chrome_exe)) {
+  if (base::PathExists(chrome_exe)) {
     Product chrome(chrome_dist);
 
     // Create the Start menu shortcut and pin it to the taskbar.
     ShellUtil::ShortcutProperties shortcut_properties(ShellUtil::CURRENT_USER);
     chrome.AddDefaultShortcutProperties(chrome_exe, &shortcut_properties);
     shortcut_properties.set_dual_mode(true);
     shortcut_properties.set_pin_to_taskbar(true);
     ShellUtil::CreateOrUpdateShortcut(
         ShellUtil::SHORTCUT_LOCATION_START_MENU, chrome_dist,
         shortcut_properties, ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS);
@@ skipping 534 matching lines @@
   if (!(installer_state.is_msi() && is_uninstall))
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }