Fill in more name fields with requestAutocomplete

components/autofill/core/browser/contact_info.cc

 // Copyright 2013 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/contact_info.h"
 
 #include <stddef.h>
 #include <ostream>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_type.h"
 
 namespace autofill {
 
+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" };
+
+// 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);
+
+  for (size_t i = 0; i < set_size; ++i) {
+    if (LowerCaseEqualsASCII(trimmed_element, set[i]))
+      return true;
+  }
+
+  return false;
+}
+
+// Removes common name prefixes from |name_tokens|.
+void StripPrefixes(std::vector<base::string16>* name_tokens) {
+  std::vector<base::string16>::iterator iter = name_tokens->begin();
+  while(iter != name_tokens->end()) {
+    if (!ContainsString(name_prefixes, arraysize(name_prefixes), *iter))
+      break;
+    ++iter;
+  }
+
+  name_tokens->assign(iter, name_tokens->end());
+}
+
+// Removes common name suffixes from |name_tokens|.
+void StripSuffixes(std::vector<base::string16>* name_tokens) {
+  std::vector<base::string16>::iterator iter = name_tokens->end();
+  while(iter != name_tokens->begin()) {
+    if (!ContainsString(name_suffixes, arraysize(name_suffixes), *--iter))
+      break;
+  }
+
+  name_tokens->assign(name_tokens->begin(), ++iter);
+}
+
+struct NameParts {
+  base::string16 given;
+  base::string16 middle;
+  base::string16 family;
+};
+
+// TODO(estade): This does Western name splitting. It should do different
+// splitting based on the app locale.
+NameParts SplitName(const base::string16& name) {
+  std::vector<base::string16> name_tokens;
+  Tokenize(name, base::ASCIIToUTF16(" ,"), &name_tokens);
+
+  StripPrefixes(&name_tokens);
+
+  // 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;
+  }
+
+  // 2 or more tokens. Grab the family, which is the last word plus any
+  // recognizable family prefixes.
+  std::vector<base::string16> reverse_family_tokens;
+  reverse_family_tokens.push_back(name_tokens.back());
+  name_tokens.pop_back();
+  while (name_tokens.size() >= 1 &&
+         ContainsString(family_name_prefixes,
+                        arraysize(family_name_prefixes),
+                        name_tokens.back())) {
+    reverse_family_tokens.push_back(name_tokens.back());
+    name_tokens.pop_back();
+  }
+
+  std::vector<base::string16> family_tokens(reverse_family_tokens.rbegin(),
+                                            reverse_family_tokens.rend());
+  parts.family = JoinString(family_tokens, base::char16(' '));
+
+  // Take the last remaining token as the middle name (if there are at least 2
+  // tokens).
+  if (name_tokens.size() >= 2) {
+    parts.middle = name_tokens.back();
+    name_tokens.pop_back();
+  }
+
+  // Remainder is given name.
+  parts.given = JoinString(name_tokens, base::char16(' '));
+
+  return parts;
+}
+
+}  // namespace
+
 NameInfo::NameInfo() {}
 
 NameInfo::NameInfo(const NameInfo& info) : FormGroup() {
   *this = info;
 }
 
 NameInfo::~NameInfo() {}
 
 NameInfo& NameInfo::operator=(const NameInfo& info) {
   if (this == &info)
     return *this;
 
-  first_ = info.first_;
+  given_ = info.given_;
   middle_ = info.middle_;
-  last_ = info.last_;
+  family_ = info.family_;
+  full_ = info.full_;
   return *this;
 }
 
 void NameInfo::GetSupportedTypes(ServerFieldTypeSet* supported_types) const {
   supported_types->insert(NAME_FIRST);
   supported_types->insert(NAME_MIDDLE);
   supported_types->insert(NAME_LAST);
   supported_types->insert(NAME_MIDDLE_INITIAL);
   supported_types->insert(NAME_FULL);
 }
 
 base::string16 NameInfo::GetRawInfo(ServerFieldType type) const {
   DCHECK_EQ(NAME, AutofillType(type).group());
   switch (type) {
     case NAME_FIRST:
-      return first();
+      return given_;
 
     case NAME_MIDDLE:
-      return middle();
+      return middle_;
 
     case NAME_LAST:
-      return last();
+      return family_;
 
     case NAME_MIDDLE_INITIAL:
       return MiddleInitial();
 
     case NAME_FULL:
       return FullName();
 
     default:
       return base::string16();
   }
 }
 
 void NameInfo::SetRawInfo(ServerFieldType type, const base::string16& value) {
   DCHECK_EQ(NAME, AutofillType(type).group());
+
+  // Always clear out the full name if we're making a change.
+  if (value != GetRawInfo(type))
+    full_.clear();
+
   switch (type) {
     case NAME_FIRST:
-      first_ = value;
+      given_ = value;
       break;
 
     case NAME_MIDDLE:
     case NAME_MIDDLE_INITIAL:
       middle_ = value;
       break;
 
     case NAME_LAST:
-      last_ = value;
+      family_ = value;
       break;
 
     case NAME_FULL:
+      // TODO(estade): this should just set |full_|; only SetInfo should attempt
+      // to be smart.
       SetFullName(value);
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 base::string16 NameInfo::FullName() const {
+  if (!full_.empty())
+    return full_;
+
   std::vector<base::string16> full_name;
-  if (!first_.empty())
-    full_name.push_back(first_);
+  if (!given_.empty())
+    full_name.push_back(given_);
 
   if (!middle_.empty())
     full_name.push_back(middle_);
 
-  if (!last_.empty())
-    full_name.push_back(last_);
+  if (!family_.empty())
+    full_name.push_back(family_);
 
   return JoinString(full_name, ' ');
 }
 
 base::string16 NameInfo::MiddleInitial() const {
   if (middle_.empty())
     return base::string16();
 
-  base::string16 middle_name(middle());
+  base::string16 middle_name(middle_);
   base::string16 initial;
   initial.push_back(middle_name[0]);
   return initial;
 }
 
 void NameInfo::SetFullName(const base::string16& full) {
-  // Clear the names.
-  first_ = base::string16();
-  middle_ = base::string16();
-  last_ = base::string16();
+  // Hack: don't do anything if this wouldn't change the full, concatenated
+  // name. Otherwise when unpickling data from the database, "First|Middle|"
+  // will get parsed as "First||Middle".
+  // TODO(estade): we should be able to remove this when fixing the TODO in
+  // SetRawInfo.
+  if (FullName() == full)

[Evan Stade, 2014/06/06 23:10:44]

NB

+    return;
 
-  std::vector<base::string16> full_name_tokens;
-  Tokenize(full, base::ASCIIToUTF16(" "), &full_name_tokens);
+  full_ = full;
 
-  // There are four possibilities: empty; first name; first and last names;
-  // first, middle (possibly multiple strings) and then the last name.
-  if (full_name_tokens.size() > 0) {
-    first_ = full_name_tokens[0];
-    if (full_name_tokens.size() > 1) {
-      last_ = full_name_tokens.back();
-      if (full_name_tokens.size() > 2) {
-        full_name_tokens.erase(full_name_tokens.begin());
-        full_name_tokens.pop_back();
-        middle_ = JoinString(full_name_tokens, ' ');
-      }
-    }
-  }
+  // If |full| is empty, leave the other name parts alone. This might occur
+  // due to a migrated database with an empty |full_name| value.
+  if (full.empty())
+    return;
+
+  NameParts parts = SplitName(full);
+  given_ = parts.given;
+  middle_ = parts.middle;
+  family_ = parts.family;
 }
 
 EmailInfo::EmailInfo() {}
 
 EmailInfo::EmailInfo(const EmailInfo& info) : FormGroup() {
   *this = info;
 }
 
 EmailInfo::~EmailInfo() {}
 
@@ skipping 48 matching lines @@
   return base::string16();
 }
 
 void CompanyInfo::SetRawInfo(ServerFieldType type,
                              const base::string16& value) {
   DCHECK_EQ(COMPANY_NAME, type);
   company_name_ = value;
 }
 
 }  // namespace autofill