--- a/xpcom/string/nsReadableUtils.cpp
+++ b/xpcom/string/nsReadableUtils.cpp
@@ -880,16 +880,49 @@ ToLowerCase(const nsACString& aSource, n
   aDest.SetLength(aSource.Length());
 
   CopyToLowerCase converter(aDest.BeginWriting(toBegin), aDest.EndWriting(toEnd));
   copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd),
               converter);
 }
 
 bool
+ParseString(const nsAString& aSource, char16_t aDelimiter,
+            nsTArray<nsString>& aArray)
+{
+  nsAString::const_iterator start, end;
+  aSource.BeginReading(start);
+  aSource.EndReading(end);
+
+  uint32_t oldLength = aArray.Length();
+
+  for (;;) {
+    nsAString::const_iterator delimiter = start;
+    FindCharInReadable(aDelimiter, delimiter, end);
+
+    if (delimiter != start) {
+      if (!aArray.AppendElement(Substring(start, delimiter))) {
+        aArray.RemoveElementsAt(oldLength, aArray.Length() - oldLength);
+        return false;
+      }
+    }
+
+    if (delimiter == end) {
+      break;
+    }
+    start = ++delimiter;
+    if (start == end) {
+      break;
+    }
+  }
+
+  return true;
+}
+
+bool
 ParseString(const nsACString& aSource, char aDelimiter,
             nsTArray<nsCString>& aArray)
 {
   nsACString::const_iterator start, end;
   aSource.BeginReading(start);
   aSource.EndReading(end);
 
   uint32_t oldLength = aArray.Length();

--- a/xpcom/string/nsReadableUtils.h
+++ b/xpcom/string/nsReadableUtils.h
@@ -281,16 +281,18 @@ bool IsASCII(const nsACString& aString);
 
  *
  * @param aString an 8-bit wide string to scan
  * @param aRejectNonChar a boolean to control the rejection of utf-8
  *        non characters
  */
 bool IsUTF8(const nsACString& aString, bool aRejectNonChar = true);
 
+bool ParseString(const nsAString& aAstring, char16_t aDelimiter,
+                 nsTArray<nsString>& aArray);
 bool ParseString(const nsACString& aAstring, char aDelimiter,
                  nsTArray<nsCString>& aArray);
 
 /**
  * Converts case in place in the argument string.
  */
 void ToUpperCase(nsACString&);
 

--- a/xpcom/tests/gtest/TestStrings.cpp
+++ b/xpcom/tests/gtest/TestStrings.cpp
@@ -770,54 +770,61 @@ TEST(Strings, string_tointeger)
     EXPECT_EQ(rv, t->rv);
     EXPECT_EQ(result, t->result);
     result = nsAutoCString(t->str).ToInteger(&rv, t->radix);
     EXPECT_EQ(rv, t->rv);
     EXPECT_EQ(result, t->result);
   }
 }
 
-static void test_parse_string_helper(const char* str, char separator, int len,
-                                       const char* s1, const char* s2)
+static void test_parse_string_helper(int len, const char* str, char separator,
+                                     const char* s1, const char* s2)
 {
   nsCString data(str);
   nsTArray<nsCString> results;
   EXPECT_TRUE(ParseString(data, separator, results));
   EXPECT_EQ(int(results.Length()), len);
   const char* strings[] = { s1, s2 };
   for (int i = 0; i < len; ++i) {
     EXPECT_TRUE(results[i].Equals(strings[i]));
   }
 }
 
-static void test_parse_string_helper0(const char* str, char separator)
-{
-  test_parse_string_helper(str, separator, 0, nullptr, nullptr);
-}
-
-static void test_parse_string_helper1(const char* str, char separator, const char* s1)
+static void test_parse_wstring_helper(int len, const char16_t* str, char16_t separator,
+                                      const char16_t* s1, const char16_t* s2)
 {
-  test_parse_string_helper(str, separator, 1, s1, nullptr);
-}
-
-static void test_parse_string_helper2(const char* str, char separator, const char* s1, const char* s2)
-{
-  test_parse_string_helper(str, separator, 2, s1, s2);
+  nsString data(str);
+  nsTArray<nsString> results;
+  EXPECT_TRUE(ParseString(data, separator, results));
+  EXPECT_EQ(int(results.Length()), len);
+  const char16_t* strings[] = { s1, s2 };
+  for (int i = 0; i < len; ++i) {
+    EXPECT_TRUE(results[i].Equals(strings[i]));
+  }
 }
 
 TEST(String, parse_string)
 {
-  test_parse_string_helper1("foo, bar", '_', "foo, bar");
-  test_parse_string_helper2("foo, bar", ',', "foo", " bar");
-  test_parse_string_helper2("foo, bar ", ' ', "foo,", "bar");
-  test_parse_string_helper2("foo,bar", 'o', "f", ",bar");
-  test_parse_string_helper0("", '_');
-  test_parse_string_helper0("  ", ' ');
-  test_parse_string_helper1(" foo", ' ', "foo");
-  test_parse_string_helper1("  foo", ' ', "foo");
+  test_parse_string_helper(1, "foo, bar", '_', "foo, bar", nullptr);
+  test_parse_string_helper(2, "foo, bar", ',', "foo", " bar");
+  test_parse_string_helper(2, "foo, bar ", ' ', "foo,", "bar");
+  test_parse_string_helper(2, "foo,bar", 'o', "f", ",bar");
+  test_parse_string_helper(0, "", '_', nullptr, nullptr);
+  test_parse_string_helper(0, "  ", ' ', nullptr, nullptr);
+  test_parse_string_helper(1, " foo", ' ', "foo", nullptr);
+  test_parse_string_helper(1, "  foo", ' ', "foo", nullptr);
+
+  test_parse_wstring_helper(1, u"foo, bar", u'_', u"foo, bar", nullptr);
+  test_parse_wstring_helper(2, u"foo, bar", u',', u"foo", u" bar");
+  test_parse_wstring_helper(2, u"foo, bar ", u' ', u"foo,", u"bar");
+  test_parse_wstring_helper(2, u"foo,bar", u'o', u"f", u",bar");
+  test_parse_wstring_helper(0, u"", u'_', nullptr, nullptr);
+  test_parse_wstring_helper(0, u"  ", u' ', nullptr, nullptr);
+  test_parse_wstring_helper(1, u" foo", u' ', u"foo", nullptr);
+  test_parse_wstring_helper(1, u"  foo", u' ', u"foo", nullptr);
 }
 
 static void test_strip_chars_helper(const char16_t* str, const char16_t* strip, const nsAString& result, uint32_t offset=0)
 {
   nsAutoString data(str);
   data.StripChars(strip, offset);
   EXPECT_TRUE(data.Equals(result));
 }