Add FilePath to base namespace.

chrome/test/ui/ui_test.h

 // 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.
 
 #ifndef CHROME_TEST_UI_UI_TEST_H_
 #define CHROME_TEST_UI_UI_TEST_H_
 
 // This file provides a common base for running UI unit tests, which operate
 // the entire browser application in a separate process for holistic
 // functional testing.
@@ skipping 12 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "base/time.h"
 #include "chrome/test/automation/proxy_launcher.h"
 #include "googleurl/src/gurl.h"
 #include "testing/platform_test.h"
 
 class AutomationProxy;
 class BrowserProxy;
-class FilePath;
 class GURL;
 class TabProxy;
 
 namespace base {
 class DictionaryValue;
+class FilePath;
 }
 
 // Base class for UI Tests. This implements the core of the functions.
 // This base class decouples all automation functionality from testing
 // infrastructure, for use without gtest.
 // If using gtest, you probably want to inherit from UITest (declared below)
 // rather than UITestBase.
 class UITestBase {
  public:
   // Profile theme type choices.
@@ skipping 90 matching lines @@
   void WaitUntilTabCount(int tab_count);
 
   // Closes the specified browser.  Returns true if the browser was closed.
   // This call is blocking.  |application_closed| is set to true if this was
   // the last browser window (and therefore as a result of it closing the
   // browser process terminated).  Note that in that case this method returns
   // after the browser process has terminated.
   bool CloseBrowser(BrowserProxy* browser, bool* application_closed) const;
 
   // Gets the executable file path of the Chrome browser process.
-  const FilePath::CharType* GetExecutablePath();
+  const base::FilePath::CharType* GetExecutablePath();
 
   // Returns the directory name where the "typical" user data is that we use
   // for testing.
-  static FilePath ComputeTypicalUserDataSource(ProfileType profile_type);
+  static base::FilePath ComputeTypicalUserDataSource(ProfileType profile_type);
 
   // Return the user data directory being used by the browser instance in
   // UITest::SetUp().
-  FilePath user_data_dir() const {
+  base::FilePath user_data_dir() const {
     return launcher_->user_data_dir();
   }
 
   // Called by some tests that wish to have a base profile to start from. This
   // "user data directory" (containing one or more profiles) will be recursively
   // copied into the user data directory for the test and the files will be
   // evicted from the OS cache. To start with a blank profile, supply an empty
   // string (the default).
-  const FilePath& template_user_data() const { return template_user_data_; }
-  void set_template_user_data(const FilePath& template_user_data) {
+  const base::FilePath& template_user_data() const { return template_user_data_; }
+  void set_template_user_data(const base::FilePath& template_user_data) {
     template_user_data_ = template_user_data;
   }
 
   // Get the handle of browser process connected to the automation. This
   // function only returns a reference to the handle so the caller does not
   // own the handle returned.
   base::ProcessHandle process() const { return launcher_->process(); }
 
   // Return the process id of the browser process (-1 on error).
   base::ProcessId browser_process_id() const { return launcher_->process_id(); }
@@ skipping 41 matching lines @@
 
   // Get the number of crash dumps we've logged since the test started.
   int GetCrashCount() const;
 
   // Returns empty string if there were no unexpected Chrome asserts or crashes,
   // a string describing the failures otherwise. As a side effect, it will fail
   // with EXPECT_EQ macros if this code runs within a gtest harness.
   std::string CheckErrorsAndCrashes() const;
 
   // Use Chromium binaries from the given directory.
-  void SetBrowserDirectory(const FilePath& dir);
+  void SetBrowserDirectory(const base::FilePath& dir);
 
   // Appends a command-line switch (no associated value) to be passed to the
   // browser when launched.
   void AppendBrowserLaunchSwitch(const char* name);
 
   // Appends a command-line switch with associated value to be passed to the
   // browser when launched.
   void AppendBrowserLaunchSwitch(const char* name, const char* value);
 
   // Pass-through to AutomationProxy::BeginTracing.
@@ skipping 36 matching lines @@
   // backward compatibility. The returned pointer MUST be deleted by the
   // caller if non-NULL.
   scoped_refptr<TabProxy> GetActiveTab();
 
   // Like above, but looks at the window at the given index.
   scoped_refptr<TabProxy> GetActiveTab(int window_index);
 
   // ********* Member variables *********
 
   // Path to the browser executable.
-  FilePath browser_directory_;
+  base::FilePath browser_directory_;
 
   // Path to the unit test data.
-  FilePath test_data_directory_;
+  base::FilePath test_data_directory_;
 
   // Command to launch the browser
   CommandLine launch_arguments_;
 
   // The number of errors expected during the run (generally 0).
   size_t expected_errors_;
 
   // The number of crashes expected during the run (generally 0).
   int expected_crashes_;
 
   // Homepage used for testing.
   std::string homepage_;
 
   // Name of currently running automated test passed to Chrome process.
   std::string test_name_;
 
   // Wait for initial loads to complete in SetUp() before running test body.
   bool wait_for_initial_loads_;
 
   // This can be set to true to have the test run the dom automation case.
   bool dom_automation_enabled_;
 
   // See set_template_user_data().
-  FilePath template_user_data_;
+  base::FilePath template_user_data_;
 
   // Determines if the window is shown or hidden. Defaults to hidden.
   bool show_window_;
 
   // If true the profile is cleared before launching. Default is true.
   bool clear_profile_;
 
   // Should we supply the testing channel id
   // on the command line? Default is true.
   bool include_testing_id_;
 
   // Enable file cookies, default is true.
   bool enable_file_cookies_;
 
   // Launches browser and AutomationProxy.
   scoped_ptr<ProxyLauncher> launcher_;
 
   // Are we using a profile with a complex theme?
   ProfileType profile_type_;
 
   // PID file for websocket server.
-  FilePath websocket_pid_file_;
+  base::FilePath websocket_pid_file_;
 
  private:
   // Time the test was started (so we can check for new crash dumps)
   base::Time test_start_time_;
 };
 
 class UITest : public UITestBase, public PlatformTest {
  protected:
   UITest() {}
   explicit UITest(MessageLoop::Type msg_loop_type)
@@ skipping 24 matching lines @@
                      const std::string &id, const GURL &url,
                      const std::string& test_complete_cookie,
                      const std::string& expected_cookie_value,
                      const base::TimeDelta wait_time);
 
   // Wrapper around EvictFileFromSystemCache to retry 10 times in case of
   // error.
   // Apparently needed for Windows buildbots (to workaround an error when
   // file is in use).
   // TODO(phajdan.jr): Move to test_file_util if we need it in more places.
-  bool EvictFileFromSystemCacheWrapper(const FilePath& path);
+  bool EvictFileFromSystemCacheWrapper(const base::FilePath& path);
 
   // Polls the tab for a JavaScript condition and returns once one of the
   // following conditions hold true:
   // - The JavaScript condition evaluates to true (return true).
   // - The browser process died (return false).
   // - The timeout value has been exceeded (return false).
   //
   // The JavaScript expression is executed in the context of the frame that
   // matches the provided xpath.
   bool WaitUntilJavaScriptCondition(TabProxy* tab,
@@ skipping 46 matching lines @@
 #ifdef UNIT_TEST
 std::ostream& operator<<(std::ostream& out, const std::wstring& wstr);
 
 template<typename T>
 std::ostream& operator<<(std::ostream& out, const ::scoped_ptr<T>& ptr) {
   return out << ptr.get();
 }
 #endif  // UNIT_TEST
 
 #endif  // CHROME_TEST_UI_UI_TEST_H_