Split CJK full names into name parts correctly.

components/autofill/core/browser/autofill_data_util.cc

 // Copyright 2016 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 "components/autofill/core/browser/autofill_data_util.h"
 
 #include <vector>
 
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/field_types.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
 
 namespace autofill {
 namespace data_util {
 
 namespace {
 const char* const name_prefixes[] = {
     "1lt",     "1st", "2lt", "2nd",    "3rd",  "admiral", "capt",
     "captain", "col", "cpt", "dr",     "gen",  "general", "lcdr",
     "lt",      "ltc", "ltg", "ltjg",   "maj",  "major",   "mg",
     "mr",      "mrs", "ms",  "pastor", "prof", "rep",     "reverend",
     "rev",     "sen", "st"};
 
 const char* const name_suffixes[] = {"b.a", "ba", "d.d.s", "dds",  "i",   "ii",
                                      "iii", "iv", "ix",    "jr",   "m.a", "m.d",
                                      "ma",  "md", "ms",    "ph.d", "phd", "sr",
                                      "v",   "vi", "vii",   "viii", "x"};
 
 const char* const family_name_prefixes[] = {"d'",  "de",  "del", "der", "di",
                                             "la",  "le",  "mc",  "san", "st",
                                             "ter", "van", "von"};
 
+// CJK surnames (last names) that have more than one character.
+const char* cjk_multi_char_surnames[] = {
+  // Korean, taken from the list of registered surnames:
+  // https://namu.wiki/w/%ED%95%9C%EA%B5%AD%EC%9D%98%20%EC%84%B1%EC%94%A8#s-6
+  "강전", "남궁", "독고", "동방", "망절", "사공", "서문", "선우",
+  "소봉", "어금", "장곡", "제갈", "황목", "황보",
+
+  // Chinese, taken from the top 10 Chinese surnames:
+  // https://zh.wikipedia.org/wiki/%E8%A4%87%E5%A7%93#.E5.B8.B8.E8.A6.8B.E7.9A.84.E8.A4.87.E5.A7.93
+  // Simplified Chinese (mostly mainland China)
+  "欧阳", "令狐", "皇甫", "上官", "司徒", "诸葛", "司马", "宇文", "呼延", "端木",
+  // Traditional Chinese (mostly Taiwan)
+  "張簡", "歐陽", "諸葛", "申屠", "尉遲", "司馬", "軒轅", "夏侯"
+};
+
 // Returns true if |set| contains |element|, modulo a final period.
 bool ContainsString(const char* const set[],
                     size_t set_size,
                     const base::string16& element) {
   if (!base::IsStringASCII(element))
     return false;
 
   base::string16 trimmed_element;
   base::TrimString(element, base::ASCIIToUTF16("."), &trimmed_element);
 
@@ skipping 23 matching lines @@
 void StripSuffixes(std::vector<base::string16>* name_tokens) {
   while (!name_tokens->empty()) {
     if (!ContainsString(name_suffixes, arraysize(name_suffixes),
                         name_tokens->back())) {
       break;
     }
     name_tokens->pop_back();
   }
 }
 
+// Returns true if |c| is a CJK (Chinese, Japanese, Korean) character, for any
+// of the CJK alphabets.
+bool IsCJK(base::char16 c) {
+  static const std::set<UScriptCode> kCjkScripts {
+    USCRIPT_HAN, // CJK logographs, used by all 3 (but rarely for Korean)
+    USCRIPT_HANGUL, // Korean alphabet
+    USCRIPT_KATAKANA, // A Japanese syllabary
+    USCRIPT_HIRAGANA, // A Japanese syllabary
+    USCRIPT_BOPOMOFO // Chinese semisyllabary, rarely used
+  };
+  UErrorCode error = U_ZERO_ERROR;
+  UScriptCode script = uscript_getScript(c, &error);
+  return kCjkScripts.find(script) != kCjkScripts.end();
+}
+
+// Returns true if |name| looks like a CJK name (or some kind of mish-mash of
+// the three, at least).
+//
+// Chinese and Japanese names are usually spelled out using the Han characters
+// (logographs), which constitute the "CJK Unified Ideographs" block in Unicode,
+// also referred to as Unihan. Korean names are usually spelled out in the
+// Korean alphabet (Hangul), although they do have a Han equivalent as well.
+bool IsCJKName(const base::string16& name) {
+  for (base::char16 c : name) {
+    if (!IsCJK(c) && !base::IsUnicodeWhitespace(c)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Returns true if |c| is a Korean Hangul character.
+bool IsHangul(base::char16 c) {
+  UErrorCode error = U_ZERO_ERROR;
+  return uscript_getScript(c, &error) == USCRIPT_HANGUL;
+}
+
+// Returns true if |name| looks like a Korean name, in Hangul characters.

[Mathieu, 2016/07/11 13:49:15]

"in Hangul characters" -> "made up entirely of Hangul characters or spaces"?

[nicolaso, 2016/07/11 15:28:54]

Done.

+bool IsHangulName(const base::string16& name) {
+  for (base::char16 c : name) {
+    if (!IsHangul(c) && !base::IsUnicodeWhitespace(c)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Tries to split a Chinese, Japanese, or Korean name into its given name &
+// surname parts, and puts the result in |parts|. If splitting did not work for
+// whatever reason, returns false.
+bool SplitCJKName(const std::vector<base::string16>& name_tokens,
+                  NameParts* parts) {
+  // The convention for CJK languages is to put the surname (last name) first,
+  // and the given name (first name) second. In a continuous text, there is
+  // normally no space between the two parts of the name. When entering their
+  // name into a field, though, some people add a space to disambiguate. CJK
+  // names (almost) never have a middle name.
+  if (name_tokens.size() == 1) {
+    // FIXME(89111): Japanese names with no space will be mis-split, since we

[Mathieu, 2016/07/11 13:49:15]

TODO(crbug.com/89111)

[nicolaso, 2016/07/11 15:28:54]

Done.

+    // don't have a list of Japanese last names. In the Han alphabet, it might
+    // also be difficult for us to differentiate between Chinese & Japanese
+    // names.
+    //
+    // There is no space between the surname and given name. Try to infer where
+    // to separate between the two. Most Chinese and Korean surnames have only
+    // one character, but there are a few that have 2. If the name does not
+    // start with a surname from a known list, default to 1 character.
+    const base::string16& name = name_tokens.front();
+    const bool is_korean = IsHangulName(name);
+    // Korean full names always have at least 3 characters. So, if there are
+    // less than three, it's only a given name.
+    if (is_korean && name.size() < 3) {
+      parts->given = name;
+    } else {
+      size_t surname_length = 1;
+      if (is_korean && name.size() == 4) {
+        // 4-character Korean full names default to a 2-character surname. It's
+        // definitely a 2/2 split.
+        surname_length = 2;
+      } else {
+        base::string16 surname;
+        // Try to find the surname in |cjk_multi_char_surnames|.
+        for (size_t i = 0; i < arraysize(cjk_multi_char_surnames); i++) {
+          surname.clear();
+          base::UTF8ToUTF16(cjk_multi_char_surnames[i],
+                            strlen(cjk_multi_char_surnames[i]),
+                            &surname);
+          if (base::StartsWith(name, surname, base::CompareCase::SENSITIVE)) {
+            surname_length = surname.size();
+            break;
+          }
+        }
+      }
+      parts->family = name.substr(0, surname_length);
+      parts->given = name.substr(surname_length);
+    }
+    return true;
+  } else if (name_tokens.size() == 2) {
+    // The user entered a space between the two name parts. This makes our job
+    // easier. Family name first, given name second.
+    parts->family = name_tokens[0];
+    parts->given = name_tokens[1];
+    return true;
+  }
+  // We don't know what to do if there are more than 2 tokens.
+  return false;
+}
+
 }  // namespace
 
 NameParts SplitName(const base::string16& name) {
   std::vector<base::string16> name_tokens =
       base::SplitString(name, base::ASCIIToUTF16(" ,"), base::KEEP_WHITESPACE,
                         base::SPLIT_WANT_NONEMPTY);
   StripPrefixes(&name_tokens);
 
+  NameParts parts;
+
+  // TODO(89111): Hungarian, Tamil, Telugu, and Vietnamese also have the

[Mathieu, 2016/07/11 13:49:15]

format is TODO(crbug.com/89111)

[nicolaso, 2016/07/11 15:28:54]

Done.

+  // given name before the surname, and should be treated as special cases too.
+
+  // Treat CJK names differently.
+  if (IsCJKName(name) && SplitCJKName(name_tokens, &parts)) {

[Mathieu, 2016/07/11 13:49:15]

Are there cases where a name is made up of CJK characters of different scripts?
If not, I'm thinking IsCJKName could instead return the script, which could be
used in SplitCJKName (would avoid going over the name twice). 

Let me know if such a thing could be possible, thanks

[nicolaso, 2016/07/11 15:28:54]

Off the top of my head, the only one I can think of, is someone whose name is
like "Bruce Takeshi". Japanese uses one script for Japanese names, and another
for foreign names. "Bruce" and "Takeshi" *could* be in different scripts.

As far as performance is concerned (since we re-traverse the name twice, with
`IsHangulName()'), I don't think we need to worry too much. Most CJK names are
made up of about 3 characters. A quick benchmark also says
`uscript_getScript(c)' is even faster than looking up `c' in an
`std::unordered_map', meaning that `IsCJK(c)' and `IsHangul(c)' are pretty fast
as well.

+    return parts;
+  }
+
   // Don't assume "Ma" is a suffix in John Ma.
   if (name_tokens.size() > 2)
     StripSuffixes(&name_tokens);
 
-  NameParts parts;
-
   if (name_tokens.empty()) {
     // Bad things have happened; just assume the whole thing is a given name.
     parts.given = name;
     return parts;
   }
 
   // Only one token, assume given name.
   if (name_tokens.size() == 1) {
     parts.given = name_tokens[0];
     return parts;
@@ skipping 62 matching lines @@
               profile.GetRawInfo(autofill::NAME_LAST);
   if (!full_name.compare(candidate)) {
     return true;
   }
 
   return false;
 }
 
 }  // namespace data_util
 }  // namespace autofill