Disable "using base::FilePath" on Linux since it now compiles.

chrome/test/pyautolib/pyautolib.i

 // Copyright 2013 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.
 //
 // Swig Interface for PyAuto.
 // PyAuto makes the Automation Proxy interface available in Python
 //
 // Running swig as:
 //   swig -python -c++ chrome/test/pyautolib/pyautolib.i
 // would generate pyautolib.py, pyautolib_wrap.cxx
@@ skipping 63 matching lines @@
 %feature("docstring", "Represent a URL. Call spec() to get the string.") GURL;
 class GURL {
  public:
   GURL();
   explicit GURL(const std::string& url_string);
   %feature("docstring", "Get the string representation.") spec;
   const std::string& spec() const;
 };
 
 // FilePath
+namespace base {
 %feature("docstring",
          "Represent a file path. Call value() to get the string.") FilePath;
 class FilePath {
  public:
   %feature("docstring", "Get the string representation.") value;
 #ifdef SWIGWIN
   typedef std::wstring StringType;
 #else
   typedef std::string StringType;
 #endif  // SWIGWIN
   const StringType& value() const;
   %feature("docstring", "Construct an empty FilePath from a string.")
       FilePath;
   FilePath();
   explicit FilePath(const StringType& path);
 };
+}  // namespace base
 
 class PyUITestSuiteBase {
  public:
   %feature("docstring", "Create the suite.") PyUITestSuiteBase;
   PyUITestSuiteBase(int argc, char** argv);
   virtual ~PyUITestSuiteBase();
 
   %feature("docstring", "Initialize from the path to browser dir.")
       InitializeWithPath;
-  void InitializeWithPath(const FilePath& browser_dir);
+  void InitializeWithPath(const base::FilePath& browser_dir);
   %feature("docstring", "Set chrome source root path, used in some tests")
       SetCrSourceRoot;
-  void SetCrSourceRoot(const FilePath& path);
+  void SetCrSourceRoot(const base::FilePath& path);
 };
 
 class PyUITestBase {
  public:
   PyUITestBase(bool clear_profile, std::wstring homepage);
 
   %feature("docstring", "Initialize the entire setup. Should be called "
            "before launching the browser. For internal use.") Initialize;
-  void Initialize(const FilePath& browser_dir);
+  void Initialize(const base::FilePath& browser_dir);
 
   %feature("docstring", "Appends a command-line switch (with associated value "
            "if given) to the list of switches to be passed to the browser "
            "upon launch. Should be called before launching the browser. "
            "For internal use only.")
       AppendBrowserLaunchSwitch;
   void AppendBrowserLaunchSwitch(const char* name);
   void AppendBrowserLaunchSwitch(const char* name, const char* value);
 
   %feature("docstring", "Begins tracing with the given category string.")
@@ skipping 23 matching lines @@
   %feature("docstring", "Determine if the profile is set to be cleared on "
                         "next startup.") get_clear_profile;
   bool get_clear_profile() const;
   %feature("docstring", "If False, sets the flag so that the profile is "
            "not cleared on next startup. Useful for persisting profile "
            "across restarts. By default the state is True, to clear profile.")
       set_clear_profile;
   void set_clear_profile(bool clear_profile);
 
   %feature("docstring", "Get the path to profile directory.") user_data_dir;
-  FilePath user_data_dir() const;
+  base::FilePath user_data_dir() const;
 
   // Meta-method
   %feature("docstring", "Send a sync JSON request to Chrome.  "
                         "Returns a JSON dict as a response.  "
                         "Given timeout in milliseconds."
                         "Internal method.")
       _SendJSONRequest;
   std::string _SendJSONRequest(int window_index,
                                const std::string& request,
                                int timeout);
@@ skipping 13 matching lines @@
     TestServer;
 class TestServer {
  public:
   enum Type {
     TYPE_FTP,
     TYPE_HTTP,
     TYPE_HTTPS,
   };
 
   // Initialize a TestServer listening on the specified host (IP or hostname).
-  TestServer(Type type, const std::string& host, const FilePath& document_root);
+  TestServer(Type type, const std::string& host,
+             const base::FilePath& document_root);
   // Initialize a TestServer with a specific set of SSLOptions.
   TestServer(Type type,
              const SSLOptions& ssl_options,
-             const FilePath& document_root);
+             const base::FilePath& document_root);
 
   %feature("docstring", "Start TestServer over an ephemeral port") Start;
   bool Start();
 
   %feature("docstring", "Stop TestServer") Stop;
   bool Stop();
 
   %feature("docstring", "Get FilePath to the document root") document_root;
-  const FilePath& document_root() const;
+  const base::FilePath& document_root() const;
 
   std::string GetScheme() const;
 
   %feature("docstring", "Get URL for a file path") GetURL;
   GURL GetURL(const std::string& path) const;
 };
 
 %extend TestServer {
   %feature("docstring", "Get port number.") GetPort;
   int GetPort() const {
@@ skipping 18 matching lines @@
   // Initialize a new SSLOptions that will use the specified certificate.
   explicit SSLOptions(ServerCertificate cert);
 };
 
 %{
 typedef net::TestServer::SSLOptions SSLOptions;
 %}
 
 %pointer_class(int, int_ptr);
 %pointer_class(uint32, uint32_ptr);