Add FilePath to base namespace.

net/base/net_util.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 NET_BASE_NET_UTIL_H_
 #define NET_BASE_NET_UTIL_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <ws2tcpip.h>
 #elif defined(OS_POSIX)
 #include <sys/types.h>
 #include <sys/socket.h>
 #endif
 
 #include <list>
 #include <string>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "net/base/escape.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 
-class FilePath;
 class GURL;
 
 namespace base {
+class FilePath;
 class Time;
 }
 
 namespace url_canon {
 struct CanonHostInfo;
 }
 
 namespace url_parse {
 struct Parsed;
 }
@@ skipping 29 matching lines @@
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitTrailingSlashOnBareHostname;
 
 // Convenience for omitting all unecessary types.
 NET_EXPORT extern const FormatUrlType kFormatUrlOmitAll;
 
 // Returns the number of explicitly allowed ports; for testing.
 NET_EXPORT_PRIVATE extern size_t GetCountOfExplicitlyAllowedPorts();
 
 // Given the full path to a file name, creates a file: URL. The returned URL
 // may not be valid if the input is malformed.
-NET_EXPORT GURL FilePathToFileURL(const FilePath& path);
+NET_EXPORT GURL FilePathToFileURL(const base::FilePath& path);
 
 // Converts a file: URL back to a filename that can be passed to the OS. The
 // file URL must be well-formed (GURL::is_valid() must return true); we don't
 // handle degenerate cases here. Returns true on success, false if it isn't a
 // valid file URL. On failure, *file_path will be empty.
-NET_EXPORT bool FileURLToFilePath(const GURL& url, FilePath* file_path);
+NET_EXPORT bool FileURLToFilePath(const GURL& url, base::FilePath* file_path);
 
 // Splits an input of the form <host>[":"<port>] into its consitituent parts.
 // Saves the result into |*host| and |*port|. If the input did not have
 // the optional port, sets |*port| to -1.
 // Returns true if the parsing was successful, false otherwise.
 // The returned host is NOT canonicalized, and may be invalid. If <host> is
 // an IPv6 literal address, the returned host includes the square brackets.
 NET_EXPORT bool ParseHostAndPort(
     std::string::const_iterator host_and_port_begin,
     std::string::const_iterator host_and_port_end,
@@ skipping 172 matching lines @@
 // Note: |mime_type| should only be specified if this function is called from a
 // thread that allows IO.
 NET_EXPORT string16 GetSuggestedFilename(const GURL& url,
                                          const std::string& content_disposition,
                                          const std::string& referrer_charset,
                                          const std::string& suggested_name,
                                          const std::string& mime_type,
                                          const std::string& default_name);
 
 // Similar to GetSuggestedFilename(), but returns a FilePath.
-NET_EXPORT FilePath GenerateFileName(const GURL& url,
-                                     const std::string& content_disposition,
-                                     const std::string& referrer_charset,
-                                     const std::string& suggested_name,
-                                     const std::string& mime_type,
-                                     const std::string& default_name);
+NET_EXPORT base::FilePath GenerateFileName(
+    const GURL& url,
+    const std::string& content_disposition,
+    const std::string& referrer_charset,
+    const std::string& suggested_name,
+    const std::string& mime_type,
+    const std::string& default_name);
 
 // Ensures that the filename and extension is safe to use in the filesystem.
 //
 // Assumes that |file_path| already contains a valid path or file name.  On
 // Windows if the extension causes the file to have an unsafe interaction with
 // the shell (see net_util::IsShellIntegratedExtension()), then it will be
 // replaced by the string 'download'.  If |file_path| doesn't contain an
 // extension or |ignore_extension| is true then the preferred extension, if one
 // exists, for |mime_type| will be used as the extension.
 //
 // On Windows, the filename will be checked against a set of reserved names, and
 // if so, an underscore will be prepended to the name.
 //
 // |file_name| can either be just the file name or it can be a full path to a
 // file.
 //
 // Note: |mime_type| should only be non-empty if this function is called from a
 // thread that allows IO.
 NET_EXPORT void GenerateSafeFileName(const std::string& mime_type,
                                      bool ignore_extension,
-                                     FilePath* file_path);
+                                     base::FilePath* file_path);
 
 // Checks |port| against a list of ports which are restricted by default.
 // Returns true if |port| is allowed, false if it is restricted.
 NET_EXPORT bool IsPortAllowedByDefault(int port);
 
 // Checks |port| against a list of ports which are restricted by the FTP
 // protocol.  Returns true if |port| is allowed, false if it is restricted.
 NET_EXPORT_PRIVATE bool IsPortAllowedByFtp(int port);
 
 // Check if banned |port| has been overriden by an entry in
@@ skipping 193 matching lines @@
 
 // Returns list of network interfaces except loopback interface. If an
 // interface has more than one address, a separate entry is added to
 // the list for each address.
 // Can be called only on a thread that allows IO.
 NET_EXPORT bool GetNetworkList(NetworkInterfaceList* networks);
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_UTIL_H_