Fix more remaining FilePath -> base::FilePath.

cloud_print/service/win/cloud_print_service.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 "cloud_print/service/win/cloud_print_service.h"
 
 #define SECURITY_WIN32
 #include <security.h>
 
 #include <iomanip>
@@ skipping 50 matching lines @@
 
 HRESULT HResultFromLastError() {
   HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
   // Something already failed if function called.
   if (SUCCEEDED(hr))
     hr = E_FAIL;
   return hr;
 }
 
 void InvalidUsage() {
-  FilePath service_path;
+  base::FilePath service_path;
   CHECK(PathService::Get(base::FILE_EXE, &service_path));
 
   std::cout << "Usage: ";
   std::cout << service_path.BaseName().value();
   std::cout << " [";
     std::cout << "[";
       std::cout << "[";
         std::cout << " -" << kInstallSwitch;
         std::cout << " -" << kUserDataDirSwitch << "=DIRECTORY";
       std::cout << "]";
@@ skipping 104 matching lines @@
     // TODO(vitalybuka): consider "lite" version if we don't want unregister
     // printers here.
     HRESULT hr = UninstallService();
     if (FAILED(hr))
       return hr;
 
     hr = UpdateRegistryAppId(true);
     if (FAILED(hr))
       return hr;
 
-    FilePath service_path;
+    base::FilePath service_path;
     CHECK(PathService::Get(base::FILE_EXE, &service_path));
     CommandLine command_line(service_path);
     command_line.AppendSwitch(run_switch);
     command_line.AppendSwitchPath(kUserDataDirSwitch, user_data_dir_);
 
     LocalSecurityPolicy local_security_policy;
     if (local_security_policy.Open()) {
       if (!local_security_policy.IsPrivilegeSet(user, kSeServiceLogonRight)) {
         LOG(WARNING) << "Setting " << kSeServiceLogonRight << " for " << user;
         if (!local_security_policy.SetPrivilege(user, kSeServiceLogonRight)) {
@@ skipping 132 matching lines @@
 
   void SelectWindowsAccount(string16* run_as_user,
                             string16* run_as_password) {
     *run_as_user = GetCurrentUserName();
     for (;;) {
       std::cout << "\nPlease provide Windows account to run service.\n";
       *run_as_user = ASCIIToWide(GetOption("Account as DOMAIN\\USERNAME",
                                            WideToASCII(*run_as_user), false));
       *run_as_password = ASCIIToWide(GetOption("Password", "", true));
 
-      FilePath requirements_filename(user_data_dir_);
+      base::FilePath requirements_filename(user_data_dir_);
       requirements_filename =
           requirements_filename.Append(kRequirementsFileName);
 
       file_util::Delete(requirements_filename, false);
       if (file_util::PathExists(requirements_filename)) {
         LOG(ERROR) << "Unable to delete " <<
             requirements_filename.value() << ".";
         continue;
       }
       if (FAILED(InstallService(run_as_user->c_str(),
@@ skipping 22 matching lines @@
       std::cout << "\nService requirements check result: \n";
       std::cout << printers << "\n";
       file_util::Delete(requirements_filename, false);
 
       if (AskUser("Do you want to use " + WideToASCII(*run_as_user) + "?"))
         return;
     }
   }
 
   HRESULT SetupServiceState() {
-    FilePath file = user_data_dir_.Append(kServiceStateFileName);
+    base::FilePath file = user_data_dir_.Append(kServiceStateFileName);
 
     for (;;) {
       std::string contents;
       ServiceState service_state;
 
       bool is_valid = file_util::ReadFileToString(file, &contents) &&
                       service_state.FromString(contents);
 
       std::cout << "\nFile '" << file.value() << "' content:\n";
       std::cout << contents << "\n";
@@ skipping 82 matching lines @@
     if (!::ControlService(service, SERVICE_CONTROL_STOP, &status))
       return HResultFromLastError();
     while (::QueryServiceStatus(service, &status) &&
            status.dwCurrentState > SERVICE_STOPPED) {
       Sleep(500);
     }
     return S_OK;
   }
 
   HRESULT CheckRequirements() {
-    FilePath requirements_filename(user_data_dir_);
+    base::FilePath requirements_filename(user_data_dir_);
     requirements_filename = requirements_filename.Append(kRequirementsFileName);
     std::string output;
     output.append("Printers available for " +
                   WideToASCII(GetCurrentUserName()) + ":\n");
     scoped_refptr<printing::PrintBackend> backend(
         printing::PrintBackend::CreateInstance(NULL));
     printing::PrinterList printer_list;
     backend->EnumeratePrinters(&printer_list);
     for (size_t i = 0; i < printer_list.size(); ++i) {
       output += " ";
       output += printer_list[i].printer_name;
       output += "\n";
     }
-    FilePath chrome = chrome_launcher_support::GetAnyChromePath();
+    base::FilePath chrome = chrome_launcher_support::GetAnyChromePath();
     output.append(chrome.empty() ? kChromeIsNotAvalible : kChromeIsAvalible);
     file_util::WriteFile(requirements_filename, output.c_str(), output.size());
     return S_OK;
   }
 
   HRESULT StartConnector() {
     chrome_.reset(new ChromeLauncher(user_data_dir_));
     return chrome_->Start() ? S_OK : E_FAIL;
   }
 
   void StopConnector() {
     if (chrome_.get()) {
       chrome_->Stop();
       chrome_.reset();
     }
   }
 
   static BOOL WINAPI ConsoleCtrlHandler(DWORD type);
 
   bool check_requirements_;
-  FilePath user_data_dir_;
+  base::FilePath user_data_dir_;
   scoped_ptr<ChromeLauncher> chrome_;
 };
 
 CloudPrintServiceModule _AtlModule;
 
 BOOL CloudPrintServiceModule::ConsoleCtrlHandler(DWORD type) {
   PostThreadMessage(_AtlModule.m_dwThreadID, WM_QUIT, 0, 0);
   return TRUE;
 }
 
 int main() {
   base::AtExitManager at_exit;
   return _AtlModule.WinMain(0);
 }