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

chrome_frame/test/reliability/page_load_test.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.
 //
 // This file provides reliablity tests which run for ChromeFrame.
 //
 // Usage:
 // <reliability test exe> --list=file --startline=start --endline=end [...]
 // Upon invocation, it visits each of the URLs on line numbers between start
 // and end, inclusive, stored in the input file. The line number starts from 1.
@@ skipping 68 matching lines @@
 const char kNoClearProfileSwitch[] = "noclearprofile";
 const char kSaveDebugLogSwitch[] = "savedebuglog";
 
 // These are copied from v8 definitions as we cannot include them.
 const char kV8LogFileSwitch[] = "logfile";
 const char kV8LogFileDefaultName[] = "v8.log";
 
 // String name of local chrome dll for looking up file information.
 const wchar_t kChromeDll[] = L"chrome.dll";
 
-FilePath g_url_file_path;
+base::FilePath g_url_file_path;
 int32 g_start_index = 1;
 int32 g_end_index = kint32max;
 int32 g_iterations = 1;
 bool g_memory_usage = false;
 bool g_page_down = true;
 bool g_clear_profile = true;
 std::string g_end_url;
-FilePath g_log_file_path;
+base::FilePath g_log_file_path;
 bool g_save_debug_log = false;
-FilePath g_chrome_log_path;
-FilePath g_v8_log_path;
-FilePath g_test_log_path;
+base::FilePath g_chrome_log_path;
+base::FilePath g_v8_log_path;
+base::FilePath g_test_log_path;
 bool g_stand_alone = false;
 
 const int kUrlNavigationTimeoutSeconds = 20;
 int g_timeout_seconds = kUrlNavigationTimeoutSeconds;
 
 // Mocks document complete and load events.
 class MockLoadListener : public chrome_frame_test::IEEventListener {
  public:
   MOCK_METHOD1(OnDocumentComplete, void (const wchar_t* url));  // NOLINT
   MOCK_METHOD1(OnLoad, void (const wchar_t* url));  // NOLINT
@@ skipping 35 matching lines @@
   // Accept URL as std::string here because the url may also act as a test id
   // and needs to be logged in its original format even if invalid.
   void NavigateToURLLogResult(const std::string& url_string,
                               std::ofstream& log_file,
                               NavigationMetrics* metrics_output) {
     GURL url(url_string);
     NavigationMetrics metrics = {NAVIGATION_ERROR};
     std::ofstream test_log;
 
     // Create a test log.
-    g_test_log_path = FilePath(FILE_PATH_LITERAL("test_log.log"));
+    g_test_log_path = base::FilePath(FILE_PATH_LITERAL("test_log.log"));
     test_log.open(g_test_log_path.value().c_str());
 
     // Check file version info for chrome dll.
     scoped_ptr<FileVersionInfo> file_info;
 #if defined(OS_WIN)
     file_info.reset(
-        FileVersionInfo::CreateFileVersionInfo(FilePath(kChromeDll)));
+        FileVersionInfo::CreateFileVersionInfo(base::FilePath(kChromeDll)));
 #elif defined(OS_LINUX) || defined(OS_MACOSX)
     // TODO(fmeawad): the version retrieved here belongs to the test module and
     // not the chrome binary, need to be changed to chrome binary instead.
     file_info.reset(FileVersionInfo::CreateFileVersionInfoForCurrentModule());
 #endif  // !defined(OS_WIN)
     std::wstring last_change = file_info->last_change();
     test_log << "Last Change: ";
     test_log << last_change << std::endl;
 
 
@@ skipping 153 matching lines @@
     file.close();
   }
 
  protected:
   virtual void SetUp() {
     // Initialize crash_dumps_dir_path_.
     PathService::Get(chrome::DIR_CRASH_DUMPS, &crash_dumps_dir_path_);
     file_util::FileEnumerator enumerator(crash_dumps_dir_path_,
                                          false,  // not recursive
                                          file_util::FileEnumerator::FILES);
-    for (FilePath path = enumerator.Next(); !path.value().empty();
+    for (base::FilePath path = enumerator.Next(); !path.value().empty();
          path = enumerator.Next()) {
       if (path.MatchesExtension(FILE_PATH_LITERAL(".dmp")))
         crash_dumps_[path.BaseName()] = true;
     }
 
     if (g_clear_profile) {
-      FilePath user_data_dir;
+      base::FilePath user_data_dir;
       chrome::GetChromeFrameUserDataDirectory(&user_data_dir);
       ASSERT_TRUE(file_util::DieFileDie(user_data_dir, true));
     }
 
     SetConfigBool(kChromeFrameHeadlessMode, true);
     SetConfigBool(kAllowUnsafeURLs, true);
   }
 
   virtual void TearDown() {
     DeleteConfigValue(kChromeFrameHeadlessMode);
     DeleteConfigValue(kAllowUnsafeURLs);
   }
 
-  FilePath ConstructSavedDebugLogPath(const FilePath& debug_log_path,
-                                      int index) {
+  base::FilePath ConstructSavedDebugLogPath(const base::FilePath& debug_log_path,
+                                            int index) {
     std::string suffix("_");
     suffix.append(base::IntToString(index));
     return debug_log_path.InsertBeforeExtensionASCII(suffix);
   }
 
-  void SaveDebugLog(const FilePath& log_path, const std::wstring& log_id,
+  void SaveDebugLog(const base::FilePath& log_path, const std::wstring& log_id,
                     std::ofstream& log_file, int index) {
     if (!log_path.empty()) {
-      FilePath saved_log_file_path =
+      base::FilePath saved_log_file_path =
           ConstructSavedDebugLogPath(log_path, index);
       if (file_util::Move(log_path, saved_log_file_path)) {
         log_file << " " << log_id << "=" << saved_log_file_path.value();
       }
     }
   }
 
   // Rename the chrome and v8 debug log files if existing, and save the file
   // paths in the log_file provided.
   void SaveDebugLogs(std::ofstream& log_file) {
     static int url_count = 1;
     SaveDebugLog(g_chrome_log_path, L"chrome_log", log_file, url_count);
     SaveDebugLog(g_v8_log_path, L"v8_log", log_file, url_count);
     SaveDebugLog(g_test_log_path, L"test_log", log_file, url_count);
     url_count++;
   }
 
   // If a log_file is provided, log the crash dump with the given path;
   // otherwise, delete the crash dump file.
   void LogOrDeleteCrashDump(std::ofstream& log_file,
-                            FilePath crash_dump_file_name) {
-    FilePath crash_dump_file_path(crash_dumps_dir_path_);
+                            base::FilePath crash_dump_file_name) {
+    base::FilePath crash_dump_file_path(crash_dumps_dir_path_);
     crash_dump_file_path = crash_dump_file_path.Append(crash_dump_file_name);
-    FilePath crash_text_file_path =
+    base::FilePath crash_text_file_path =
         crash_dump_file_path.ReplaceExtension(FILE_PATH_LITERAL("txt"));
 
     if (log_file.is_open()) {
       crash_dumps_[crash_dump_file_name] = true;
       log_file << " crash_dump=" << crash_dump_file_path.value().c_str();
     } else {
       ASSERT_TRUE(file_util::DieFileDie(
           crash_dump_file_path, false));
       ASSERT_TRUE(file_util::DieFileDie(
           crash_text_file_path, false));
     }
   }
 
   // Check whether there are new .dmp files. Additionally, write
   //     " crash_dump=<full path name of the .dmp file>"
   // to log_file.
   void LogOrDeleteNewCrashDumps(std::ofstream& log_file,
                                 NavigationMetrics* metrics) {
     int num_dumps = 0;
 
     file_util::FileEnumerator enumerator(crash_dumps_dir_path_,
                                          false,  // not recursive
                                          file_util::FileEnumerator::FILES);
-    for (FilePath path = enumerator.Next(); !path.value().empty();
+    for (base::FilePath path = enumerator.Next(); !path.value().empty();
          path = enumerator.Next()) {
       if (path.MatchesExtension(FILE_PATH_LITERAL(".dmp")) &&
           !crash_dumps_[path.BaseName()]) {
         LogOrDeleteCrashDump(log_file, path.BaseName());
         num_dumps++;
       }
     }
     if (metrics)
       metrics->crash_dump_count = num_dumps;
   }
 
   // Get a PrefService whose contents correspond to the Local State file
   // that was saved by the app as it closed.  The caller takes ownership of the
   // returned PrefService object.
   PrefService* GetLocalState(PrefRegistry* registry) {
-    FilePath path;
+    base::FilePath path;
     chrome::GetChromeFrameUserDataDirectory(&path);
     PrefServiceMockBuilder builder;
     builder.WithUserFilePrefs(
         path,
         JsonPrefStore::GetTaskRunnerForFile(
             path, content::BrowserThread::GetBlockingPool()));
     return builder.Create(registry);
   }
 
   void GetStabilityMetrics(NavigationMetrics* metrics) {
@@ skipping 20 matching lines @@
         local_state->GetInteger(prefs::kStabilityCrashCount);
     metrics->renderer_crash_count =
         local_state->GetInteger(prefs::kStabilityRendererCrashCount);
     // TODO(huanr)
     metrics->plugin_crash_count = 0;
 
     if (!metrics->browser_clean_exit)
       metrics->browser_crash_count++;
   }
 
-  FilePath GetSampleDataDir() {
-    FilePath test_dir;
+  base::FilePath GetSampleDataDir() {
+    base::FilePath test_dir;
     PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
     test_dir = test_dir.AppendASCII("reliability");
     test_dir = test_dir.AppendASCII("sample_pages");
     return test_dir;
   }
 
   // The pathname of Chrome's crash dumps directory.
-  FilePath crash_dumps_dir_path_;
+  base::FilePath crash_dumps_dir_path_;
 
   // The set of all the crash dumps we have seen.  Each crash generates a
   // .dmp and a .txt file in the crash dumps directory.  We only store the
   // .dmp files in this set.
   //
   // The set is implemented as a std::map.  The key is the file name, and
   // the value is false (the file is not in the set) or true (the file is
   // in the set).  The initial value for any key in std::map is 0 (false),
   // which in this case means a new file is not in the set initially,
   // exactly the semantics we want.
-  std::map<FilePath, bool> crash_dumps_;
+  std::map<base::FilePath, bool> crash_dumps_;
 };
 
 TEST_F(PageLoadTest, IEFullTabMode_Reliability) {
   std::ofstream log_file;
 
   if (!g_log_file_path.empty()) {
     log_file.open(g_log_file_path.value().c_str());
   }
 
   EXPECT_FALSE(g_url_file_path.empty());
@@ skipping 77 matching lines @@
     if (parsed_command_line.HasSwitch(switches::kNoSandbox)) {
       PathService::Get(base::DIR_CURRENT, &g_v8_log_path);
       g_v8_log_path = g_v8_log_path.AppendASCII(kV8LogFileDefaultName);
       // The command line switch may override the default v8 log path.
       if (parsed_command_line.HasSwitch(switches::kJavaScriptFlags)) {
         CommandLine v8_command_line(
             parsed_command_line.GetSwitchValuePath(switches::kJavaScriptFlags));
         if (v8_command_line.HasSwitch(kV8LogFileSwitch)) {
           g_v8_log_path = v8_command_line.GetSwitchValuePath(kV8LogFileSwitch);
           if (!file_util::AbsolutePath(&g_v8_log_path))
-            g_v8_log_path = FilePath();
+            g_v8_log_path = base::FilePath();
         }
       }
     }
   }
 }