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

base/file_path_unittest.cc

 // Copyright (c) 2010 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.
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
@@ skipping 19 matching lines @@
 struct BinaryBooleanTestData {
   const FilePath::CharType* inputs[2];
   bool expected;
 };
 
 struct BinaryIntTestData {
   const FilePath::CharType* inputs[2];
   int expected;
 };
 
+struct UTF8TestData {
+  const FilePath::CharType* native;
+  const char* utf8;
+};
+
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest
 class FilePathTest : public PlatformTest {
  protected:
   virtual void SetUp() {
     PlatformTest::SetUp();
   }
   virtual void TearDown() {
     PlatformTest::TearDown();
   }
@@ skipping 987 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     FilePath input(cases[i].input);
     bool observed = input.ReferencesParent();
     EXPECT_EQ(cases[i].expected, observed) <<
               "i: " << i << ", input: " << input.value();
   }
 }
 
+TEST_F(FilePathTest, FromUTF8Unsafe_And_AsUTF8Unsafe) {
+  const struct UTF8TestData cases[] = {
+    { FPL("foo.txt"), "foo.txt" },
+    // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them.
+    { FPL("\u00E0\u00E8\u00F2.txt"), "\xC3\xA0\xC3\xA8\xC3\xB2.txt" },
+    // Full-width "ABC".
+    { FPL("\uFF21\uFF22\uFF23.txt"),
+      "\xEF\xBC\xA1\xEF\xBC\xA2\xEF\xBC\xA3.txt" },
+  };
+
+  for (size_t i = 0; i < arraysize(cases); ++i) {
+    // Test FromUTF8Unsafe() works.
+    FilePath from_utf8 = FilePath::FromUTF8Unsafe(cases[i].utf8);
+    EXPECT_EQ(cases[i].native, from_utf8.value())
+        << "i: " << i << ", input: " << cases[i].native;
+    // Test AsUTF8Unsafe() works.
+    FilePath from_native = FilePath(cases[i].native);
+    EXPECT_EQ(cases[i].utf8, from_native.AsUTF8Unsafe())
+        << "i: " << i << ", input: " << cases[i].native;
+    // Test the two file paths are identical.
+    EXPECT_EQ(from_utf8.value(), from_native.value());
+  }
+}
+
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 TEST_F(FilePathTest, NormalizeWindowsPathSeparators) {
   const struct UnaryTestData cases[] = {
     { FPL("foo/bar"), FPL("foo\\bar") },
     { FPL("foo/bar\\betz"), FPL("foo\\bar\\betz") },
     { FPL("foo\\bar"), FPL("foo\\bar") },
     { FPL("foo\\bar/betz"), FPL("foo\\bar\\betz") },
     { FPL("foo"), FPL("foo") },
     // Trailing slashes don't automatically get stripped.  That's what
     // StripTrailingSeparators() is for.
@@ skipping 22 matching lines @@
     { FPL("foo/\\bar/\\"), FPL("foo\\\\bar\\\\") },
     { FPL("/\\foo\\/bar"), FPL("\\\\foo\\\\bar") },
   };
   for (size_t i = 0; i < arraysize(cases); ++i) {
     FilePath input(cases[i].input);
     FilePath observed = input.NormalizeWindowsPathSeparators();
     EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) <<
               "i: " << i << ", input: " << input.value();
   }
 }
+
 #endif