Fix more remaining FilePath -> base::FilePath.

cloud_print/virtual_driver/win/install/setup.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 <iomanip>
 #include <windows.h>
 #include <winspool.h>
 #include <setupapi.h>  // Must be included after windows.h
 
 #include "base/at_exit.h"
@@ skipping 69 matching lines @@
   if (key.Open(HKEY_LOCAL_MACHINE, cloud_print::kKeyLocation,
                DELETE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key to delete";
     return;
   }
   if (key.DeleteKey(L"") != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to delete key";
   }
 }
 
-FilePath GetSystemPath(const string16& binary) {
-  FilePath path;
+base::FilePath GetSystemPath(const string16& binary) {
+  base::FilePath path;
   if (!PathService::Get(base::DIR_SYSTEM, &path)) {
     LOG(ERROR) << "Unable to get system path.";
     return path;
   }
   return path.Append(binary);
 }
 
-FilePath GetNativeSystemPath(const string16& binary) {
+base::FilePath GetNativeSystemPath(const string16& binary) {
   if (!cloud_print::IsSystem64Bit())
     return GetSystemPath(binary);
-  FilePath path;
+  base::FilePath path;
   // Sysnative will bypass filesystem redirection and give us
   // the location of the 64bit system32 from a 32 bit process.
   if (!PathService::Get(base::DIR_WINDOWS, &path)) {
     LOG(ERROR) << "Unable to get windows path.";
     return path;
   }
   return path.Append(L"sysnative").Append(binary);
 }
 
 void SpoolerServiceCommand(const char* command) {
-  FilePath net_path = GetNativeSystemPath(L"net");
+  base::FilePath net_path = GetNativeSystemPath(L"net");
   if (net_path.empty())
     return;
   CommandLine command_line(net_path);
   command_line.AppendArg(command);
   command_line.AppendArg("spooler");
   command_line.AppendArg("/y");
 
   base::LaunchOptions options;
   options.wait = true;
   options.start_hidden = true;
   LOG(INFO) << command_line.GetCommandLineString();
   base::LaunchProcess(command_line, options, NULL);
 }
 
-HRESULT RegisterPortMonitor(bool install, const FilePath& install_path) {
+HRESULT RegisterPortMonitor(bool install, const base::FilePath& install_path) {
   DCHECK(install || install_path.empty());
-  FilePath target_path =
+  base::FilePath target_path =
       GetNativeSystemPath(cloud_print::GetPortMonitorDllName());
   if (target_path.empty()) {
     LOG(ERROR) << "Unable to get port monitor target path.";
     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
   }
   if (install) {
-    FilePath source_path =
+    base::FilePath source_path =
         install_path.Append(cloud_print::GetPortMonitorDllName());
     if (!file_util::CopyFile(source_path, target_path)) {
       LOG(ERROR) << "Unable copy port monitor dll from " <<
           source_path.value() << " to " << target_path.value();
       return cloud_print::GetLastHResult();
     }
   } else if (!file_util::PathExists(target_path)) {
     // Already removed.  Just "succeed" silently.
     return S_OK;
   }
 
-  FilePath regsvr32_path = GetNativeSystemPath(L"regsvr32.exe");
+  base::FilePath regsvr32_path = GetNativeSystemPath(L"regsvr32.exe");
   if (regsvr32_path.empty()) {
     LOG(ERROR) << "Can't find regsvr32.exe.";
     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
   }
 
   CommandLine command_line(regsvr32_path);
   command_line.AppendArg("/s");
   if (!install) {
     command_line.AppendArg("/u");
   }
@@ skipping 48 matching lines @@
     retval <<= 32;
     retval |= fixed_file_info->dwFileVersionLS;
   }
   return retval;
 }
 
 UINT CALLBACK CabinetCallback(PVOID data,
                               UINT notification,
                               UINT_PTR param1,
                               UINT_PTR param2 ) {
-  FilePath* temp_path = reinterpret_cast<FilePath*>(data);
+  base::FilePath* temp_path = reinterpret_cast<base::FilePath*>(data);
   if (notification == SPFILENOTIFY_FILEINCABINET) {
     FILE_IN_CABINET_INFO* info =
         reinterpret_cast<FILE_IN_CABINET_INFO*>(param1);
     for (int i = 0; i < arraysize(kDependencyList); i++) {
-      FilePath base_name(info->NameInCabinet);
+      base::FilePath base_name(info->NameInCabinet);
       base_name = base_name.BaseName();
-      if (FilePath::CompareEqualIgnoreCase(base_name.value().c_str(),
-                                           kDependencyList[i])) {
+      if (base::FilePath::CompareEqualIgnoreCase(base_name.value().c_str(),
+                                                 kDependencyList[i])) {
         StringCchCopy(info->FullTargetName, MAX_PATH,
                       temp_path->Append(kDependencyList[i]).value().c_str());
         return FILEOP_DOIT;
       }
     }
 
     return FILEOP_SKIP;
   }
   return NO_ERROR;
 }
 
-void ReadyPpdDependencies(const FilePath& install_path) {
+void ReadyPpdDependencies(const base::FilePath& install_path) {
   base::win::Version version = base::win::GetVersion();
   if (version >= base::win::VERSION_VISTA) {
     // GetCorePrinterDrivers and GetPrinterDriverPackagePath only exist on
     // Vista and later. Winspool.drv must be delayloaded so these calls don't
     // create problems on XP.
     DWORD size = MAX_PATH;
     wchar_t package_path[MAX_PATH] = {0};
     CORE_PRINTER_DRIVER driver;
     GetCorePrinterDrivers(NULL,
                           NULL,
                           L"{D20EA372-DD35-4950-9ED8-A6335AFE79F5}",
                           1,
                           &driver);
     GetPrinterDriverPackagePath(NULL,
                                 NULL,
                                 NULL,
                                 driver.szPackageID,
                                 package_path,
                                 MAX_PATH,
                                 &size);
     SetupIterateCabinet(package_path,
                         0,
                         CabinetCallback,
-                        const_cast<FilePath*>(&install_path));
+                        const_cast<base::FilePath*>(&install_path));
   } else {
     // PS driver files are in the sp3 cab.
-    FilePath package_path;
+    base::FilePath package_path;
     PathService::Get(base::DIR_WINDOWS, &package_path);
     package_path = package_path.Append(L"Driver Cache\\i386\\sp3.cab");
     SetupIterateCabinet(package_path.value().c_str(),
                         0,
                         CabinetCallback,
-                        const_cast<FilePath*>(&install_path));
+                        const_cast<base::FilePath*>(&install_path));
 
     // The XPS driver files are just sitting uncompressed in the driver cache.
-    FilePath xps_path;
+    base::FilePath xps_path;
     PathService::Get(base::DIR_WINDOWS, &xps_path);
     xps_path = xps_path.Append(L"Driver Cache\\i386");
     xps_path = xps_path.Append(kDriverName);
     file_util::CopyFile(xps_path, install_path.Append(kDriverName));
   }
 }
 
-HRESULT InstallPpd(const FilePath& install_path) {
+HRESULT InstallPpd(const base::FilePath& install_path) {
   DRIVER_INFO_6 driver_info = {0};
   HRESULT result = S_OK;
 
   // Set up paths for the files we depend on.
-  FilePath ppd_path = install_path.Append(kPpdName);
-  FilePath xps_path = install_path.Append(kDriverName);
-  FilePath ui_path = install_path.Append(kUiDriverName);
-  FilePath ui_help_path = install_path.Append(kHelpName);
+  base::FilePath ppd_path = install_path.Append(kPpdName);
+  base::FilePath xps_path = install_path.Append(kDriverName);
+  base::FilePath ui_path = install_path.Append(kUiDriverName);
+  base::FilePath ui_help_path = install_path.Append(kHelpName);
   ReadyPpdDependencies(install_path);
   // None of the print API structures likes constant strings even though they
   // don't modify the string.  const_casting is the cleanest option.
   driver_info.pDataFile = const_cast<LPWSTR>(ppd_path.value().c_str());
   driver_info.pHelpFile = const_cast<LPWSTR>(ui_help_path.value().c_str());
   driver_info.pDriverPath = const_cast<LPWSTR>(xps_path.value().c_str());
   driver_info.pConfigFile = const_cast<LPWSTR>(ui_path.value().c_str());
 
   // Set up user visible strings.
   string16 manufacturer = cloud_print::LoadLocalString(IDS_GOOGLE);
@@ skipping 82 matching lines @@
   if (!DeletePrinter(handle)) {
     HRESULT result = cloud_print::GetLastHResult();
     LOG(ERROR) << "Unable to delete printer";
     ClosePrinter(handle);
     return result;
   }
   ClosePrinter(handle);
   return S_OK;
 }
 
-void SetupUninstall(const FilePath& install_path) {
+void SetupUninstall(const base::FilePath& install_path) {
   // Now write the Windows Uninstall entries
   // Minimal error checking here since the install can contiunue
   // if this fails.
   base::win::RegKey key;
   if (key.Create(HKEY_LOCAL_MACHINE, kUninstallRegistry,
                  KEY_SET_VALUE) != ERROR_SUCCESS) {
     LOG(ERROR) << "Unable to open key";
     return;
   }
   CommandLine uninstall_command(install_path.Append(kInstallerName));
@@ skipping 27 matching lines @@
 }
 
 bool IsOSSupported() {
   // We don't support XP service pack 2 or older.
   base::win::Version version = base::win::GetVersion();
   return (version > base::win::VERSION_XP) ||
       ((version == base::win::VERSION_XP) &&
        (base::win::OSInfo::GetInstance()->service_pack().major >= 3));
 }
 
-HRESULT RegisterVirtualDriver(const FilePath& install_path) {
+HRESULT RegisterVirtualDriver(const base::FilePath& install_path) {
   HRESULT result = S_OK;
 
   DCHECK(file_util::DirectoryExists(install_path));
   if (!IsOSSupported()) {
     LOG(ERROR) << "Requires XP SP3 or later.";
     return HRESULT_FROM_WIN32(ERROR_OLD_WIN_VERSION);
   }
 
   result = RegisterPortMonitor(true, install_path);
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to register port monitor.";
     return result;
   }
 
   result = InstallPpd(install_path);
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to install Ppd.";
     return result;
   }
 
   result = InstallPrinter();
   if (FAILED(result) &&
       result != HRESULT_FROM_WIN32(ERROR_PRINTER_ALREADY_EXISTS)) {
     LOG(ERROR) << "Unable to install printer.";
     return result;
   }
   return S_OK;
 }
 
-void GetCurrentInstallPath(FilePath* install_path) {
+void GetCurrentInstallPath(base::FilePath* install_path) {
   base::win::RegKey key;
   if (key.Open(HKEY_LOCAL_MACHINE, kUninstallRegistry,
                KEY_QUERY_VALUE) != ERROR_SUCCESS) {
     // Not installed.
-    *install_path = FilePath();
+    *install_path = base::FilePath();
     return;
   }
   string16 install_path_value;
   key.ReadValue(L"InstallLocation", &install_path_value);
-  *install_path = FilePath(install_path_value);
+  *install_path = base::FilePath(install_path_value);
 }
 
 HRESULT TryUnregisterVirtualDriver() {
   HRESULT result = S_OK;
   result = UninstallPrinter();
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to delete printer.";
     return result;
   }
   result = UninstallPpd();
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to remove PPD.";
     return result;
   }
   // The second argument is ignored if the first is false.
-  result = RegisterPortMonitor(false, FilePath());
+  result = RegisterPortMonitor(false, base::FilePath());
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to remove port monitor.";
     return result;
   }
   return S_OK;
 }
 
 HRESULT UnregisterVirtualDriver() {
   HRESULT hr = S_FALSE;
   for (int i = 0; i < 2; ++i) {
     hr = TryUnregisterVirtualDriver();
     if (SUCCEEDED(hr)) {
       break;
     }
     // Restart spooler and try again.
     SpoolerServiceCommand("stop");
     SpoolerServiceCommand("start");
   }
   return hr;
 }
 
-HRESULT DeleteProgramDir(const FilePath& installer_source, bool wait) {
-  FilePath temp_path;
+HRESULT DeleteProgramDir(const base::FilePath& installer_source, bool wait) {
+  base::FilePath temp_path;
   if (file_util::CreateTemporaryFile(&temp_path)) {
     file_util::CopyFile(installer_source, temp_path);
     file_util::DeleteAfterReboot(temp_path);
     CommandLine command_line(temp_path);
     command_line.AppendSwitchPath(kDelete, installer_source.DirName());
     base::LaunchOptions options;
     options.wait = wait;
     base::ProcessHandle process_handle;
     if (!base::LaunchProcess(command_line, options, &process_handle)) {
       LOG(ERROR) << "Unable to launch child uninstall.";
@@ skipping 13 matching lines @@
   }
   return S_OK;
 }
 
 HRESULT DoUninstall() {
   DeleteGoogleUpdateKeys();
   HRESULT result = UnregisterVirtualDriver();
   if (FAILED(result))
     return result;
   CleanupUninstall();
-  FilePath installer_source;
+  base::FilePath installer_source;
   if (PathService::Get(base::FILE_EXE, &installer_source))
     return DeleteProgramDir(installer_source, false);
   return S_OK;
 }
 
 HRESULT DoUnregister() {
   return UnregisterVirtualDriver();
 }
 
-HRESULT DoRegister(const FilePath& install_path) {
+HRESULT DoRegister(const base::FilePath& install_path) {
   HRESULT result = UnregisterVirtualDriver();
   if (FAILED(result))
     return result;
   return RegisterVirtualDriver(install_path);
 }
 
-HRESULT DoDelete(const FilePath& install_path) {
+HRESULT DoDelete(const base::FilePath& install_path) {
   if (install_path.value().empty())
     return E_INVALIDARG;
   if (!file_util::DirectoryExists(install_path))
     return S_FALSE;
   Sleep(5000);  // Give parent some time to exit.
   return file_util::Delete(install_path, true) ? S_OK : E_FAIL;
 }
 
-HRESULT DoInstall(const FilePath& install_path) {
+HRESULT DoInstall(const base::FilePath& install_path) {
   HRESULT result = UnregisterVirtualDriver();
   if (FAILED(result)) {
     LOG(ERROR) << "Unable to unregister.";
     return result;
   }
-  FilePath old_install_path;
+  base::FilePath old_install_path;
   GetCurrentInstallPath(&old_install_path);
   if (!old_install_path.value().empty() &&
       install_path != old_install_path) {
     if (file_util::DirectoryExists(old_install_path))
       file_util::Delete(old_install_path, true);
   }
   SetupUninstall(install_path);
   result = RegisterVirtualDriver(install_path);
   if (FAILED(result))
     return result;
   SetGoogleUpdateKeys();
   return result;
 }
 
 HRESULT ExecuteCommands() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
-  FilePath exe_path;
+  base::FilePath exe_path;
   if (FAILED(PathService::Get(base::DIR_EXE, &exe_path)) ||
       !file_util::DirectoryExists(exe_path)) {
     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
   }
 
   if (command_line.HasSwitch(kDelete)) {
     return DoDelete(command_line.GetSwitchValuePath(kDelete));
   } else if (command_line.HasSwitch(kUninstallSwitch)) {
     return DoUninstall();
   } else if (command_line.HasSwitch(kInstallSwitch)) {
@@ skipping 19 matching lines @@
 
   LOG(INFO) << "HRESULT=0x" << std::setbase(16) << retval;
 
   // Installer is silent by default as required by Google Update.
   if (CommandLine::ForCurrentProcess()->HasSwitch("verbose")) {
     cloud_print::DisplayWindowsMessage(NULL, retval,
         cloud_print::LoadLocalString(IDS_DRIVER_NAME));
   }
   return retval;
 }