Rename FilePath -> base::FilePath in various toplevel directories

chrome_frame/test/chrome_frame_test_utils.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 "chrome_frame/test/chrome_frame_test_utils.h"
 
 #include <atlapp.h>
 #include <atlmisc.h>
 #include <iepmapi.h>
 #include <sddl.h>
@@ skipping 158 matching lines @@
     path = FormatCommandForApp(executable, argument);
     if (path.empty()) {
       LOG(ERROR) << "Failed to find executable: " << executable;
     } else {
       CommandLine cmdline = CommandLine::FromString(path);
       if (!base::LaunchProcess(cmdline, base::LaunchOptions(), &process)) {
         LOG(ERROR) << "LaunchProcess failed: " << ::GetLastError();
       }
     }
   } else {
-    CommandLine cmdline((FilePath(path)));
+    CommandLine cmdline((base::FilePath(path)));
     cmdline.AppendArgNative(argument);
     if (!base::LaunchProcess(cmdline, base::LaunchOptions(), &process)) {
       LOG(ERROR) << "LaunchProcess failed: " << ::GetLastError();
     }
   }
   return process;
 }
 
 base::ProcessHandle LaunchChrome(const std::wstring& url,
-                                 const FilePath& user_data_dir) {
-  FilePath path;
+                                 const base::FilePath& user_data_dir) {
+  base::FilePath path;
   PathService::Get(base::DIR_MODULE, &path);
   path = path.AppendASCII(kChromeImageName);
 
   CommandLine cmd(path);
   cmd.AppendSwitch(switches::kNoFirstRun);
   if (!user_data_dir.empty())
     cmd.AppendSwitchPath(switches::kUserDataDir, user_data_dir);
   cmd.AppendArgNative(url);
 
   base::ProcessHandle process = NULL;
@@ skipping 209 matching lines @@
 
   hr = ::CoCreateInstance(CLSID_InternetExplorer, NULL,
                           cocreate_flags, IID_IWebBrowser2,
                           reinterpret_cast<void**>(web_browser));
   // ~LowIntegrityToken() will switch integrity back to medium.
   return hr;
 }
 
 std::wstring GetExeVersion(const std::wstring& exe_path) {
   scoped_ptr<FileVersionInfo> ie_version_info(
-      FileVersionInfo::CreateFileVersionInfo(FilePath(exe_path)));
+      FileVersionInfo::CreateFileVersionInfo(base::FilePath(exe_path)));
   return ie_version_info->product_version();
 }
 
 IEVersion GetInstalledIEVersion() {
   std::wstring path(chrome_frame_test::GetExecutableAppPath(kIEImageName));
   std::wstring version(GetExeVersion(path));
   size_t first_dot = version.find(L'.');
   int major_version = 0;
   if (!base::StringToInt(base::StringPiece16(
           version.data(),
@@ skipping 13 matching lines @@
       return IE_9;
     case 10:
       return IE_10;
     default:
       break;
   }
 
   return IE_UNSUPPORTED;
 }
 
-FilePath GetProfilePathForIE() {
-  FilePath profile_path;
+base::FilePath GetProfilePathForIE() {
+  base::FilePath profile_path;
   // Browsers without IDeleteBrowsingHistory in non-priv mode
   // have their profiles moved into "Temporary Internet Files".
   // The code below basically retrieves the version of IE and computes
   // the profile directory accordingly.
   if (GetInstalledIEVersion() <= IE_7) {
     profile_path = GetIETemporaryFilesFolder();
     profile_path = profile_path.Append(L"Google Chrome Frame");
   } else {
     GetChromeFrameProfilePath(kIEProfileName, &profile_path);
   }
   return profile_path;
 }
 
-FilePath GetTestDataFolder() {
-  FilePath test_dir;
+base::FilePath GetTestDataFolder() {
+  base::FilePath test_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &test_dir);
   test_dir = test_dir.Append(FILE_PATH_LITERAL("chrome_frame"))
       .Append(FILE_PATH_LITERAL("test"))
       .Append(FILE_PATH_LITERAL("data"));
   return test_dir;
 }
 
-FilePath GetSeleniumTestFolder() {
-  FilePath test_dir;
+base::FilePath GetSeleniumTestFolder() {
+  base::FilePath test_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &test_dir);
   test_dir = test_dir.Append(FILE_PATH_LITERAL("data"))
       .Append(FILE_PATH_LITERAL("selenium_core"));
   return test_dir;
 }
 
 std::wstring GetPathFromUrl(const std::wstring& url) {
   string16 url16 = WideToUTF16(url);
   GURL gurl = GURL(url16);
   if (gurl.has_query()) {
@@ skipping 105 matching lines @@
   }
 }
 
 base::ProcessHandle StartCrashService() {
   if (DetectRunningCrashService(kCrashServiceStartupTimeoutMs)) {
     VLOG(1) << "crash_service.exe is already running. We will use the "
                "existing process and leave it running after tests complete.";
     return NULL;
   }
 
-  FilePath exe_dir;
+  base::FilePath exe_dir;
   if (!PathService::Get(base::DIR_EXE, &exe_dir)) {
     DCHECK(false);
     return NULL;
   }
 
   base::ProcessHandle crash_service = NULL;
 
   VLOG(1) << "Starting crash_service.exe so you know if a test crashes!";
 
-  FilePath crash_service_path = exe_dir.AppendASCII("crash_service.exe");
+  base::FilePath crash_service_path = exe_dir.AppendASCII("crash_service.exe");
   if (!base::LaunchProcess(crash_service_path.value(), base::LaunchOptions(),
                            &crash_service)) {
     LOG(ERROR) << "Couldn't start crash_service.exe";
     return NULL;
   }
 
   base::Time start = base::Time::Now();
 
   if (DetectRunningCrashService(kCrashServiceStartupTimeoutMs)) {
     VLOG(1) << "crash_service.exe is ready for clients in "
@@ skipping 37 matching lines @@
 
 ScopedChromeFrameRegistrar::RegistrationType GetTestBedType() {
   if (GetConfigBool(false, L"PerUserTestBed")) {
     return ScopedChromeFrameRegistrar::PER_USER;
   } else {
     return ScopedChromeFrameRegistrar::SYSTEM_LEVEL;
   }
 }
 
 void ClearIESessionHistory() {
-  FilePath session_history_path;
+  base::FilePath session_history_path;
   if (!PathService::Get(base::DIR_LOCAL_APP_DATA, &session_history_path))
     return;
 
   session_history_path = session_history_path.AppendASCII("Microsoft");
   session_history_path = session_history_path.AppendASCII("Internet Explorer");
   session_history_path = session_history_path.AppendASCII("Recovery");
   file_util::Delete(session_history_path, true);
 }
 
 std::string GetLocalIPv4Address() {
@@ skipping 24 matching lines @@
   if (address.empty()) {
     LOG(ERROR) << "Failed to find a non-loopback IP_V4 address. Tests will be "
                << "run over the loopback adapter, which may result in hangs.";
     address.assign("127.0.0.1");
   }
 
   return address;
 }
 
 }  // namespace chrome_frame_test