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

chrome_frame/test/perf/chrome_frame_perftest.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/perf/chrome_frame_perftest.h"
 
 #include <atlwin.h>
 #include <atlhost.h>
 #include <map>
 #include <vector>
 #include <string>
@@ skipping 285 matching lines @@
     chrome_frame_dll_ = dir_app_.Append(kChromeFrameDllName);
     icu_dll_ = dir_app_.Append(L"icudt.dll");
     ffmpegsumo_dll_ = dir_app_.Append(L"ffmpegsumo.dll");
   }
 
   // TODO(iyengar)
   // This function is similar to the RunStartupTest function used in chrome
   // startup tests. Refactor into a common implementation.
   void RunStartupTest(const char* graph, const char* trace,
                       const char* startup_url, bool test_cold,
-                      int total_binaries, const FilePath binaries_to_evict[],
+                      int total_binaries,
+                      const base::FilePath binaries_to_evict[],
                       bool important, bool ignore_cache_error) {
     const int kNumCycles = 20;
 
     startup_url_ = startup_url;
 
     TimeDelta timings[kNumCycles];
 
     for (int i = 0; i < kNumCycles; ++i) {
       if (test_cold) {
         for (int binary_index = 0; binary_index < total_binaries;
@@ skipping 24 matching lines @@
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
     }
 
     std::string times;
     for (int i = 0; i < kNumCycles; ++i)
       base::StringAppendF(&times, "%.2f,", timings[i].InMillisecondsF());
 
     perf_test::PrintResultList(graph, "", trace, times, "ms", important);
   }
 
-  FilePath dir_app_;
-  FilePath chrome_dll_;
-  FilePath chrome_exe_;
-  FilePath chrome_frame_dll_;
-  FilePath icu_dll_;
-  FilePath ffmpegsumo_dll_;
+  base::FilePath dir_app_;
+  base::FilePath chrome_dll_;
+  base::FilePath chrome_exe_;
+  base::FilePath chrome_frame_dll_;
+  base::FilePath icu_dll_;
+  base::FilePath ffmpegsumo_dll_;
 
  protected:
   // Individual startup tests should implement this function.
   virtual void RunStartupTestImpl(TimeTicks* start_time,
                                   TimeTicks* end_time) {}
 
   // The host is torn down by this function. It should not be used after
   // this function returns.
   static void ReleaseHostComReferences(CAxWindow& host) {
     CComPtr<IAxWinHostWindow> spWinHost;
@@ skipping 99 matching lines @@
  public:
   // override the browser directory to use the reference build instead.
   virtual void SetUp() {
     // Register the reference build Chrome Frame DLL.
     chrome_frame_registrar_.reset(new ScopedChromeFrameRegistrar(
         ScopedChromeFrameRegistrar::SYSTEM_LEVEL));
     chrome_frame_registrar_->RegisterReferenceChromeFrameBuild();
 
     ChromeFrameStartupTest::SetUp();
 
-    chrome_frame_dll_ = FilePath(
+    chrome_frame_dll_ = base::FilePath(
         chrome_frame_registrar_->GetReferenceChromeFrameDllPath());
     DVLOG(1) << __FUNCTION__ << ": " << chrome_frame_dll_.value();
   }
 
   virtual void TearDown() {
     // Reregister the Chrome Frame DLL in the build directory.
     chrome_frame_registrar_.reset(NULL);
   }
 };
 
@@ skipping 453 matching lines @@
   }
 };
 
 // TODO(rogerm): Flesh out the *PreReadImage* tests to validate an observed
 //     change in paging behaviour between raw loading and pre-reading.
 
 // TODO(rogerm): Add checks to the *PreReadImage* tests to validate the
 //     handling of invalid pe files and paths as input.
 
 TEST(ImagePreReader, PreReadImage) {
-  FilePath current_exe;
+  base::FilePath current_exe;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
 
   int64 file_size_64 = 0;
   ASSERT_TRUE(file_util::GetFileSize(current_exe, &file_size_64));
   ASSERT_TRUE(file_size_64 < std::numeric_limits<std::size_t>::max());
   size_t file_size = static_cast<size_t>(file_size_64);
 
   const wchar_t* module_path = current_exe.value().c_str();
   const size_t kStepSize = 2 * 1024 * 1024;
 
   ASSERT_TRUE(
       ImagePreReader::PreReadImage(module_path, 0, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PreReadImage(module_path, file_size / 4, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PreReadImage(module_path, file_size / 2, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PreReadImage(module_path, file_size, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PreReadImage(module_path, file_size * 2, kStepSize));
 }
 
 TEST(ImagePreReader, PartialPreReadImage) {
-  FilePath current_exe;
+  base::FilePath current_exe;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
 
   const wchar_t* module_path = current_exe.value().c_str();
   const size_t kStepSize = 2 * 1024 * 1024;
 
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImage(module_path, 0, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImage(module_path, 25, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImage(module_path, 50, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImage(module_path, 100, kStepSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImage(module_path, 150, kStepSize));
 }
 
 TEST(ImagePreReader, PartialPreReadImageOnDisk) {
-  FilePath current_exe;
+  base::FilePath current_exe;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
 
   const wchar_t* module_path = current_exe.value().c_str();
   const size_t kChunkSize = 2 * 1024 * 1024;
 
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageOnDisk(module_path, 0, kChunkSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageOnDisk(module_path, 25, kChunkSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageOnDisk(module_path, 50, kChunkSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageOnDisk(module_path, 100, kChunkSize));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageOnDisk(module_path, 150, kChunkSize));
 }
 
 TEST(ImagePreReader, PartialPreReadImageInMemory) {
-  FilePath current_exe;
+  base::FilePath current_exe;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
   const wchar_t* module_path = current_exe.value().c_str();
 
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageInMemory(module_path, 0));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageInMemory(module_path, 25));
   ASSERT_TRUE(
       ImagePreReader::PartialPreReadImageInMemory(module_path, 50));
   ASSERT_TRUE(
@@ skipping 27 matching lines @@
                  true /* important */, false);
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfWarm) {
   RunStartupTest("binary_load_warm", "t", "", false /* cold */, 0, NULL,
                  true /* important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveX, PerfCold) {
   SetConfigInt(L"PreRead", 0);
-  FilePath binaries_to_evict[] = {
+  base::FilePath binaries_to_evict[] = {
     ffmpegsumo_dll_, chrome_exe_, chrome_dll_, chrome_frame_dll_
   };
   RunStartupTest("cold", "t", "about:blank", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
   DeleteConfigValue(L"PreRead");
 }
 
 TEST_F(ChromeFrameStartupTestActiveX, PerfColdPreRead) {
   SetConfigInt(L"PreRead", 1);
-  FilePath binaries_to_evict[] = {
+  base::FilePath binaries_to_evict[] = {
     ffmpegsumo_dll_, chrome_exe_, chrome_dll_, chrome_frame_dll_
   };
   RunStartupTest("cold_preread", "t", "about:blank", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
   DeleteConfigValue(L"PreRead");
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfCold) {
-  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   RunStartupTest("binary_load_cold", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfColdPreRead) {
-  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   pre_read_type_ = kPreReadFull;
   RunStartupTest("binary_load_cold_preread", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead15) {
-  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   pre_read_type_ = kPreReadPartial;
   percentage_to_preread_ = 15;
   RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead25) {
-  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   pre_read_type_ = kPreReadPartial;
   percentage_to_preread_ = 25;
   RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead40) {
-  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   pre_read_type_ = kPreReadPartial;
   percentage_to_preread_ = 40;
   RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveXReference, PerfWarm) {
   RunStartupTest("warm", "t_ref", "about:blank", false /* cold */, 0, NULL,
                  true /* important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveX, PerfChromeFrameInitializationWarm) {
   RunStartupTest("ChromeFrame_init_warm", "t", "", false /* cold */, 0,
                  NULL, true /* important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveX, PerfChromeFrameInitializationCold) {
-  FilePath binaries_to_evict[] = {chrome_frame_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_frame_dll_};
   RunStartupTest("ChromeFrame_init_cold", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveXReference,
        PerfChromeFrameInitializationWarm) {
   RunStartupTest("ChromeFrame_init_warm", "t_ref", "", false /* cold */, 0,
                  NULL, true /* important */, false);
 }
@@ skipping 61 matching lines @@
   RunStartupTest("creation_warm", "t_flash", "", false /* cold */, 0, NULL,
                  true /* not important */, false);
 }
 
 TEST_F(SilverlightCreationTest, DISABLED_PerfWarm) {
   RunStartupTest("creation_warm", "t_silverlight", "", false /* cold */, 0,
                  NULL, false /* not important */, false);
 }
 
 TEST_F(ChromeFrameCreationTest, PerfCold) {
-  FilePath binaries_to_evict[] = {chrome_frame_dll_};
+  base::FilePath binaries_to_evict[] = {chrome_frame_dll_};
 
   RunStartupTest("creation_cold", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  true /* important */, false);
 }
 
 // Attempt to evict the Flash control can fail on the buildbot as the dll
 // is marked read only. The test run is aborted if we fail to evict the file
 // from the cache. This could also fail if the Flash control is in use.
 // On Vista this could fail because of UAC
 TEST_F(FlashCreationTest, PerfCold) {
   base::win::RegKey flash_key(HKEY_CLASSES_ROOT, kFlashControlKey, KEY_READ);
 
   std::wstring plugin_path;
   ASSERT_EQ(ERROR_SUCCESS, flash_key.ReadValue(L"", &plugin_path));
   ASSERT_FALSE(plugin_path.empty());
 
-  FilePath flash_path = FilePath(plugin_path);
-  FilePath binaries_to_evict[] = {flash_path};
+  base::FilePath flash_path = base::FilePath(plugin_path);
+  base::FilePath binaries_to_evict[] = {flash_path};
 
   RunStartupTest("creation_cold", "t_flash", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false/* important */, true);
 }
 
 // This test would fail on Vista due to UAC or if the Silverlight control is
 // in use. The test run is aborted if we fail to evict the file from the cache.
 // Disabling this test as the Silverlight dll does not seem to get unloaded
 // correctly causing the attempt to evict the dll from the system cache to
 // fail.
 TEST_F(SilverlightCreationTest, DISABLED_PerfCold) {
   base::win::RegKey silverlight_key(HKEY_CLASSES_ROOT, kSilverlightControlKey,
                                     KEY_READ);
 
   std::wstring plugin_path;
   ASSERT_EQ(ERROR_SUCCESS, silverlight_key.ReadValue(L"", &plugin_path));
   ASSERT_FALSE(plugin_path.empty());
 
-  FilePath silverlight_path = FilePath(plugin_path);
-  FilePath binaries_to_evict[] = {silverlight_path};
+  base::FilePath silverlight_path = base::FilePath(plugin_path);
+  base::FilePath binaries_to_evict[] = {silverlight_path};
 
   RunStartupTest("creation_cold", "t_silverlight", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* important */, true);
 }
 
 namespace {
 
 // Derive from this class in order to receive custom events traced
 // via TRACE_EVENT_XXXX macros from ChromeFrame/Chrome.
@@ skipping 79 matching lines @@
   }
 
   void AnalyzeOutput(TracedEvents* delegate) {
     EtwConsumer consumer;
     consumer.set_delegate(delegate);
     consumer.OpenFileSession(etl_log_file_.value().c_str());
     consumer.Consume();
     consumer.Close();
   }
 
-  FilePath etl_log_file_;
+  base::FilePath etl_log_file_;
   base::win::EtwTraceController controller_;
 };
 
 // Base class for the tracing event helper classes.
 class MonitorTraceBase {
  public:
   static bool IsMatchingEvent(EVENT_TRACE* event,
                               const base::StringPiece& event_to_compare) {
     return event->MofLength > event_to_compare.size() &&
       (memcmp(event_to_compare.data(), event->MofData,
@@ skipping 103 matching lines @@
                      const std::string& modifier,
                      const std::string& trace,
                      const std::string& values,
                      const std::string& units,
                      bool important) {
   PrintResultsImpl(measurement, modifier, trace, values,
       "[", "]", units, important);
 }
 
 bool RunSingleTestOutOfProc(const std::string& test_name) {
-  FilePath path;
+  base::FilePath path;
   if (!PathService::Get(base::DIR_EXE, &path))
     return false;
   path = path.Append(L"chrome_frame_tests.exe");
 
   CommandLine cmd_line(path);
   // Always enable disabled tests.  This method is not called with disabled
   // tests unless this flag was specified to the browser test executable.
   cmd_line.AppendSwitch("gtest_also_run_disabled_tests");
   cmd_line.AppendSwitchASCII("gtest_filter", test_name);
 
@@ skipping 103 matching lines @@
   PrintPerfTestResults(automation_provider_connect_monitor, kNumCycles,
                        "automationproviderconnect");
   PrintPerfTestResults(external_tab_navigate_monitor, kNumCycles,
                        "externaltabnavigate");
   PrintPerfTestResults(renderer_main_monitor, kNumCycles,
                        "beginrenderermain");
 #ifdef NDEBUG
   PrintPerfTestResults(pre_read_chrome_monitor, kNumCycles, "PreReadImage");
 #endif  // NDEBUG
 }