Add FilePath::FromUTF8Unsafe() and FilePath::AsUTF8Unsafe().

base/file_path.h

 // Copyright (c) 2011 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.
 
 // FilePath is a container for pathnames stored in a platform's native string
 // type, providing containers for manipulation in according with the
 // platform's conventions for pathnames.  It supports the following path
 // types:
 //
 //                   POSIX            Windows
 //                   ---------------  ----------------------------------
 // Fundamental type  char[]           wchar_t[]
 // Encoding          unspecified*     UTF-16

[Mark Mentovai, 2011/10/26 23:29:13]

*

 // Separator         /                \, tolerant of /
 // Drive letters     no               case-insensitive A-Z followed by :
 // Alternate root    // (surprise!)   \\, for UNC paths
 //
 // * The encoding need not be specified on POSIX systems, although some

[Mark Mentovai, 2011/10/26 23:29:13]

*

 //   POSIX-compliant systems do specify an encoding.  Mac OS X uses UTF-8.
 //   Linux does not specify an encoding, but in practice, the locale's
 //   character set may be used.
 //
 // For more arcane bits of path trivia, see below.
 //
 // FilePath objects are intended to be used anywhere paths are.  An
 // application may pass FilePath objects around internally, masking the
 // underlying differences between systems, only differing in implementation
 // where interfacing directly with the system.  For example, a single
 // OpenFile(const FilePath &) function may be made available, allowing all
 // callers to operate without regard to the underlying implementation.  On
 // POSIX-like platforms, OpenFile might wrap fopen, and on Windows, it might
 // wrap _wfopen_s, perhaps both by calling file_path.value().c_str().  This

[Mark Mentovai, 2011/10/26 23:29:13]

*

 // allows each platform to pass pathnames around without requiring conversions
 // between encodings, which has an impact on performance, but more imporantly,
 // has an impact on correctness on platforms that do not have well-defined
 // encodings for pathnames.
 //
 // Several methods are available to perform common operations on a FilePath
 // object, such as determining the parent directory (DirName), isolating the
 // final path component (BaseName), and appending a relative pathname string
 // to an existing FilePath object (Append).  These methods are highly
 // recommended over attempting to split and concatenate strings directly.
@@ skipping 213 matching lines @@
   // excessive separators if this object's path already ends with a separator.
   // If this object's path is kCurrentDirectory, a new FilePath corresponding
   // only to |component| is returned.  |component| must be a relative path;
   // it is an error to pass an absolute path.
   FilePath Append(const StringType& component) const WARN_UNUSED_RESULT;
   FilePath Append(const FilePath& component) const WARN_UNUSED_RESULT;
 
   // Although Windows StringType is std::wstring, since the encoding it uses for
   // paths is well defined, it can handle ASCII path components as well.
   // Mac uses UTF8, and since ASCII is a subset of that, it works there as well.
   // On Linux, although it can use any 8-bit encoding for paths, we assume that

[Mark Mentovai, 2011/10/26 23:29:13]

*

   // ASCII is a valid subset, regardless of the encoding, since many operating
   // system paths will always be ASCII.
   FilePath AppendASCII(const base::StringPiece& component)
       const WARN_UNUSED_RESULT;
 
   // Returns true if this FilePath contains an absolute path.  On Windows, an
   // absolute path begins with either a drive letter specification followed by
   // a separator character, or with two separator characters.  On POSIX
   // platforms, an absolute path begins with a separator character.
   bool IsAbsolute() const;
@@ skipping 10 matching lines @@
   // Warning: you can *not*, in general, go from a display name back to a real
   // path.  Only use this when displaying paths to users, not just when you
   // want to stuff a string16 into some other API.
   string16 LossyDisplayName() const;
 
   // Return the path as ASCII, or the empty string if the path is not ASCII.
   // This should only be used for cases where the FilePath is representing a
   // known-ASCII filename.
   std::string MaybeAsASCII() const;
 
+  // Return the path as UTF-8.
+  std::string AsUTF8() const;
+
   // Older Chromium code assumes that paths are always wstrings.
   // This function converts wstrings to FilePaths, and is
   // useful to smooth porting that old code to the FilePath API.
   // It has "Hack" its name so people feel bad about using it.
   // http://code.google.com/p/chromium/issues/detail?id=24672
   //
   // If you are trying to be a good citizen and remove these, ask yourself:
   // - Am I interacting with other Chrome code that deals with files?  Then
   //   try to convert the API into using FilePath.
   // - Am I interacting with OS-native calls?  Then use value() to get at an
   //   OS-native string format.
   // - Am I using well-known file names, like "config.ini"?  Then use the
   //   ASCII functions (we require paths to always be supersets of ASCII).
   // - Am I displaying a string to the user in some UI?  Then use the
   //   LossyDisplayName() function, but keep in mind that you can't
   //   ever use the result of that again as a path.
   static FilePath FromWStringHack(const std::wstring& wstring);
 
+  // Returns a FilePath object from a path name in UTF-8.
+  static FilePath FromUTF8(const std::string& utf8);
+
   void WriteToPickle(Pickle* pickle);
   bool ReadFromPickle(Pickle* pickle, void** iter);
 
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
   // Normalize all path separators to backslash.
   FilePath NormalizeWindowsPathSeparators() const;
 #endif
 
   // Compare two strings in the same way the file system does.
   // Note that these always ignore case, even on file systems that are case-
@@ skipping 69 matching lines @@
 
 inline size_t hash_value(const FilePath& f) {
   return hash_value(f.value());
 }
 
 #endif  // COMPILER
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // BASE_FILE_PATH_H_