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
 // 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
 //   POSIX-compliant systems do specify an encoding.  Mac OS X uses UTF-8.
+//   Chrome OS also 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
@@ skipping 257 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.
+  //
+  // This function is *unsafe* as there is no way to tell what encoding is
+  // used in file names on POSIX systems other than Mac and Chrome OS,
+  // although UTF-8 is practically used everywhere these days. To mitigate
+  // the encoding issue, this function internally calls
+  // SysNativeMBToWide() on POSIX systems other than Mac and Chrome OS,
+  // per assumption that the current locale's encoding is used in file
+  // names, but this isn't a perfect solution.
+  //
+  // Once it becomes safe to to stop caring about non-UTF-8 file names,
+  // the SysNativeMBToWide() hack will be removed from the code, along
+  // with "Unsafe" in the function name.
+  std::string AsUTF8Unsafe() 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. This function
+  // should only be used for cases where you are sure that the input
+  // string is UTF-8.
+  //
+  // Like AsUTF8Unsafe(), this function is unsafe. This function
+  // internally calls SysWideToNativeMB() on POSIX systems other than Mac
+  // and Chrome OS, to mitigate the encoding issue. See the comment at
+  // AsUTF8Unsafe() for details.
+  static FilePath FromUTF8Unsafe(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_