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

chrome_frame/test/test_with_web_server.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/test_with_web_server.h"
 
 #include "base/base_paths.h"
 #include "base/file_version_info.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
@@ skipping 35 matching lines @@
      << "Content-Type: " << content_type << "\r\n";
   if (invocation.type() == CFInvocation::HTTP_HEADER)
     ss << "X-UA-Compatible: chrome=1\r\n";
   if (add_no_cache_header) {
     ss << "Cache-Control: no-cache\r\n";
     ss << "Expires: Tue, 15 Nov 1994 08:12:31 GMT\r\n";
   }
   return ss.str();
 }
 
-std::string GetMockHttpHeaders(const FilePath& mock_http_headers_path) {
+std::string GetMockHttpHeaders(const base::FilePath& mock_http_headers_path) {
   std::string headers;
   file_util::ReadFileToString(mock_http_headers_path, &headers);
   return headers;
 }
 
 class ChromeFrameTestEnvironment: public testing::Environment {
  public:
   virtual ~ChromeFrameTestEnvironment() {}
   virtual void SetUp() OVERRIDE {
     ScopedChromeFrameRegistrar::RegisterDefaults();
   }
 };
 
 ::testing::Environment* const chrome_frame_env =
     ::testing::AddGlobalTestEnvironment(new ChromeFrameTestEnvironment);
 
 }  // namespace
 
-FilePath ChromeFrameTestWithWebServer::test_file_path_;
-FilePath ChromeFrameTestWithWebServer::results_dir_;
-FilePath ChromeFrameTestWithWebServer::CFInstall_path_;
-FilePath ChromeFrameTestWithWebServer::CFInstance_path_;
+base::FilePath ChromeFrameTestWithWebServer::test_file_path_;
+base::FilePath ChromeFrameTestWithWebServer::results_dir_;
+base::FilePath ChromeFrameTestWithWebServer::CFInstall_path_;
+base::FilePath ChromeFrameTestWithWebServer::CFInstance_path_;
 base::ScopedTempDir ChromeFrameTestWithWebServer::temp_dir_;
-FilePath ChromeFrameTestWithWebServer::chrome_user_data_dir_;
+base::FilePath ChromeFrameTestWithWebServer::chrome_user_data_dir_;
 chrome_frame_test::TimedMsgLoop* ChromeFrameTestWithWebServer::loop_;
 std::string ChromeFrameTestWithWebServer::local_address_;
 testing::StrictMock<MockWebServerListener>*
     ChromeFrameTestWithWebServer::listener_mock_;
 testing::StrictMock<MockWebServer>* ChromeFrameTestWithWebServer::server_mock_;
 
 ChromeFrameTestWithWebServer::ChromeFrameTestWithWebServer() {
 }
 
 // static
 void ChromeFrameTestWithWebServer::SetUpTestCase() {
-  FilePath chrome_frame_source_path;
+  base::FilePath chrome_frame_source_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &chrome_frame_source_path);
   chrome_frame_source_path = chrome_frame_source_path.Append(
       FILE_PATH_LITERAL("chrome_frame"));
 
   test_file_path_ = chrome_frame_source_path
       .Append(FILE_PATH_LITERAL("test"))
       .Append(FILE_PATH_LITERAL("data"));
 
   results_dir_ = chrome_frame_test::GetTestDataFolder().AppendASCII("dump");
 
   // Copy the CFInstance.js and CFInstall.js files from src\chrome_frame to
   // src\chrome_frame\test\data.
-  FilePath CFInstance_src_path;
-  FilePath CFInstall_src_path;
+  base::FilePath CFInstance_src_path;
+  base::FilePath CFInstall_src_path;
 
   CFInstance_src_path = chrome_frame_source_path.AppendASCII("CFInstance.js");
   CFInstance_path_ = test_file_path_.AppendASCII("CFInstance.js");
 
   ASSERT_TRUE(file_util::CopyFile(CFInstance_src_path, CFInstance_path_));
 
   CFInstall_src_path = chrome_frame_source_path.AppendASCII("CFInstall.js");
   CFInstall_path_ = test_file_path_.AppendASCII("CFInstall.js");
 
   ASSERT_TRUE(file_util::CopyFile(CFInstall_src_path, CFInstall_path_));
@@ skipping 17 matching lines @@
   local_address_.clear();
   delete loop_;
   loop_ = NULL;
   file_util::Delete(CFInstall_path_, false);
   file_util::Delete(CFInstance_path_, false);
   if (temp_dir_.IsValid())
     EXPECT_TRUE(temp_dir_.Delete());
 }
 
 // static
-const FilePath& ChromeFrameTestWithWebServer::GetChromeUserDataDirectory() {
+const base::FilePath&
+ChromeFrameTestWithWebServer::GetChromeUserDataDirectory() {
   if (!temp_dir_.IsValid()) {
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
     chrome_user_data_dir_ = temp_dir_.path().AppendASCII("User Data");
   }
   return chrome_user_data_dir_;
 }
 
 void ChromeFrameTestWithWebServer::SetUp() {
   // Make sure that we are not accidentally enabling gcf protocol.
   SetConfigBool(kAllowUnsafeURLs, false);
@@ skipping 17 matching lines @@
   // We should resolve the URL only if it is a relative url.
   GURL parsed_url(WideToUTF8(page));
   if (!parsed_url.has_scheme()) {
     url = server_mock().Resolve(page);
   }
 
   browser_ = browser;
   if (browser == IE) {
     browser_handle_.Set(chrome_frame_test::LaunchIE(url));
   } else if (browser == CHROME) {
-    const FilePath& user_data_dir = GetChromeUserDataDirectory();
+    const base::FilePath& user_data_dir = GetChromeUserDataDirectory();
     chrome_frame_test::OverrideDataDirectoryForThisTest(user_data_dir.value());
     browser_handle_.Set(chrome_frame_test::LaunchChrome(url, user_data_dir));
   } else {
     NOTREACHED();
   }
 
   return browser_handle_.IsValid();
 }
 
 void ChromeFrameTestWithWebServer::CloseBrowser() {
@@ skipping 87 matching lines @@
 void ChromeFrameTestWithWebServer::ExpectAndHandlePostedResult() {
   EXPECT_CALL(listener_mock(), OnExpectedResponse())
       .WillRepeatedly(QUIT_LOOP_SOON(loop(),
                                      base::TimeDelta::FromMilliseconds(100)));
   server_mock().ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
                                             kPostedResultSubstring);
 }
 
 void ChromeFrameTestWithWebServer::VersionTest(BrowserKind browser,
     const wchar_t* page) {
-  FilePath plugin_path;
+  base::FilePath plugin_path;
   PathService::Get(base::DIR_MODULE, &plugin_path);
   plugin_path = plugin_path.Append(kChromeFrameDllName);
 
   static FileVersionInfo* version_info =
       FileVersionInfo::CreateFileVersionInfo(plugin_path);
 
   std::wstring version;
   if (version_info)
     version = version_info->product_version();
 
   // If we can't find the Chrome Frame DLL in the src tree, we turn to
   // the directory where chrome is installed.
   if (!version_info) {
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     Version ver_system;
     InstallUtil::GetChromeVersion(dist, true, &ver_system);
     Version ver_user;
     InstallUtil::GetChromeVersion(dist, false, &ver_system);
     ASSERT_TRUE(ver_system.IsValid() || ver_user.IsValid());
 
     bool system_install = ver_system.IsValid();
-    FilePath cf_dll_path(installer::GetChromeInstallPath(system_install, dist));
+    base::FilePath cf_dll_path(installer::GetChromeInstallPath(system_install, dist));
     cf_dll_path = cf_dll_path.Append(UTF8ToWide(
         ver_system.IsValid() ? ver_system.GetString() : ver_user.GetString()));
     cf_dll_path = cf_dll_path.Append(kChromeFrameDllName);
     version_info = FileVersionInfo::CreateFileVersionInfo(cf_dll_path);
     if (version_info)
       version = version_info->product_version();
   }
 
   server_mock().set_expected_result(WideToUTF8(version));
 
@@ skipping 60 matching lines @@
         WideToUTF8(header), request.headers());
     connection->Send(header_value, "");
     return;
   }
   // Convert |request_uri| to a path.
   std::wstring path = request_uri;
   size_t query_index = request_uri.find(L"?");
   if (query_index != std::string::npos) {
     path = path.erase(query_index);
   }
-  FilePath file_path = root_dir_;
+  base::FilePath file_path = root_dir_;
   if (path.size())
     file_path = file_path.Append(path.substr(1));  // remove first '/'
 
   std::string headers, body;
   std::string content_type;
   if (file_util::PathExists(file_path) &&
       !file_util::DirectoryExists(file_path)) {
-    FilePath mock_http_headers(file_path.value() + L".mock-http-headers");
+    base::FilePath mock_http_headers(file_path.value() + L".mock-http-headers");
     if (file_util::PathExists(mock_http_headers)) {
       headers = GetMockHttpHeaders(mock_http_headers);
       content_type = http_utils::GetHttpHeaderFromHeaderList("Content-type",
                                                              headers);
     } else {
       EXPECT_TRUE(net::GetMimeTypeFromFile(file_path, &content_type));
       VLOG(1) << "Going to send file (" << WideToUTF8(file_path.value())
               << ") with content type (" << content_type << ")";
       headers = CreateHttpHeaders(invocation, add_no_cache_header,
                                   content_type);
@@ skipping 456 matching lines @@
 }
 
 // Specialized implementation of test_server::FileResponse that supports
 // adding the request's User-Agent header to the returned document.
 // The class also supports $request_id$ which will be replaced with an
 // id that's incremented each time the response is sent over a socket.
 class UaTemplateFileResponse : public test_server::FileResponse {
  public:
   typedef test_server::FileResponse SuperClass;
 
-  UaTemplateFileResponse(const char* request_path, const FilePath& file_path)
+  UaTemplateFileResponse(const char* request_path,
+                         const base::FilePath& file_path)
       : test_server::FileResponse(request_path, file_path), request_id_(0) {
   }
 
   virtual bool Matches(const test_server::Request& r) const {
     bool ret = SuperClass::Matches(r);
     if (ret)
       ua_ = GetHeaderValue(r.headers(), "User-Agent");
     return ret;
   }
 
@@ skipping 186 matching lines @@
   server.web_server()->AddResponse(response);
 
   std::wstring url(server.FormatHttpPath(L"form.html"));
 
   ASSERT_TRUE(LaunchBrowser(IE, url.c_str()));
   loop().RunFor(kChromeFrameLongNavigationTimeout);
 
   EXPECT_EQ(1, response->get_request_count());
   EXPECT_EQ(1, response->post_request_count());
 }