Modified to allow to preserve two-word string in first-name and last-name in autofill profile.

components/autofill/core/browser/autofill_profile.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/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
@@ skipping 500 matching lines @@
       }
     } else if (StringToLowerASCII(GetRawInfo(*it)) !=
                    StringToLowerASCII(profile.GetRawInfo(*it))) {
       return false;
     }
   }
 
   return true;
 }
 
+void AutofillProfile::OverwriteOrAppendNames(
+    const std::vector<NameInfo>& names) {
+  std::vector<NameInfo> name_list(name_);

[Ilya Sherman, 2014/06/03 00:25:32]

nit: Let's call this "result" or something.  Otherwise, it's a little hard to
keep track of the distinction between "names" and "name_list".

Alternately, you could rename the variable currently named |names| to
|new_names| instead or |imported_names| instead.

[Pritam Nikam, 2014/06/03 15:37:34]

Done.
name_list -> result

+  for (std::vector<NameInfo>::const_iterator it = names.begin();
+       it != names.end();
+       ++it) {
+    NameInfo imported_profile_name = *it;

[Ilya Sherman, 2014/06/03 00:25:32]

nit: Let's drop "profile", and call this |imported_name| or |new_name".

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+    NameInfo profile_name_with_parsed_tokens;

[Ilya Sherman, 2014/06/03 00:25:32]

nit: Let's call this something more like |heuristically_parsed_name|.

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+    bool prefer_imported_profile_name = false;
+    bool identical_full_names = false;

[Ilya Sherman, 2014/06/03 00:25:32]

Let's simplify the logic a bit by replacing these two booleans with a single
"bool should_append_{imported,new}_name = true;".

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+
+    for (size_t index = 0; index < name_.size(); ++index) {
+      NameInfo current_name = name_[index];
+      base::string16 full_name = current_name.GetRawInfo(NAME_FULL);
+      if (full_name == imported_profile_name.GetRawInfo(NAME_FULL)) {
+        // Identical full names, we should always prefer to keep ones with more
+        // information, i.e. where parsing the full_name_ does not give the same
+        // results as are stored in first_, middle_, and last_.

[Ilya Sherman, 2014/06/03 00:25:32]

Here's a suggested rewording of this comment.  Of course, feel free to further
refine my wording :)

"The imported name has the same full name string as one of the existing names
for this profile.  Because full names are _heuristically_ parsed into {first,
middle, last} name components, it's possible that either the existing name or
the imported name was misparsed.  Prefer to keep the name whose {first, middle,
last} components do not match those computed by the heuristic parse, as this
more likely represents the correct, user-input parse of the name."

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+        identical_full_names = true;
+        profile_name_with_parsed_tokens.SetRawInfo(NAME_FULL, full_name);
+        prefer_imported_profile_name =
+            (current_name == profile_name_with_parsed_tokens) ||
+            (current_name == imported_profile_name);
+
+        if (prefer_imported_profile_name) {
+          name_list[index] = imported_profile_name;
+          break;
+        }

[Ilya Sherman, 2014/06/03 00:25:32]

With the changes above, the body of this loop would become something like

NameInfo current_name = name_[index];
if (current_name == imported_profile_name) {
  should_append_{imported,new}_name = false;
  break;
}

base::string16 full_name = current_name.GetRawInfo(NAME_FULL);
if (full_name == imported_profile_name.GetRawInfo(NAME_FULL)) {
  // Comment.
  NameInfo heuristically_parsed_name;
  heuristically_parsed_name.SetRawInfo(NAME_FULL, full_name);
  if (current_name == heuristically_parsed_name) {
    name_list[index] = imported_profile_name;
    should_append_{imported,new}_name = false;
    break;
  }
}

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+      }
+    }
+
+    // Append unique names to the list

[Ilya Sherman, 2014/06/03 00:25:32]

nit: Please end the sentence with a period.

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+    if (!identical_full_names ||
+        (!prefer_imported_profile_name &&
+         imported_profile_name != profile_name_with_parsed_tokens)) {

[Ilya Sherman, 2014/06/03 00:25:32]

With the changes above, this if-stmt's condition would become simply "if
(should_append_{imported,new}_name)".

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

+      name_list.push_back(imported_profile_name);
+    }
+  }

[Ilya Sherman, 2014/06/03 00:25:32]

Optional nit: I'd leave a blank line after this one.

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

In my opinion,below check is still required to avoid appending heuristically
parsed names.
 (imported_profile_name != profile_name_with_parsed_tokens)

Something like:
    if (should_append_imported_name &&
        (imported_name != heuristically_parsed_name))
      results.push_back(imported_name);

+  name_.swap(name_list);
+}
+
 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile,
                                            const std::string& app_locale) {
   // Verified profiles should never be overwritten with unverified data.
   DCHECK(!IsVerified() || profile.IsVerified());
   set_origin(profile.origin());
   set_language_code(profile.language_code());
 
   ServerFieldTypeSet field_types;
   profile.GetNonEmptyTypes(app_locale, &field_types);
 
@@ skipping 29 matching lines @@
           AddPhoneIfUnique(*value_iter, app_locale, &existing_values);
         } else {
           std::vector<base::string16>::const_iterator existing_iter =
               std::find_if(
                   existing_values.begin(), existing_values.end(),
                   std::bind1st(CaseInsensitiveStringEquals(), *value_iter));
           if (existing_iter == existing_values.end())
             existing_values.insert(existing_values.end(), *value_iter);
         }
       }
-      SetRawMultiInfo(*iter, existing_values);
+      if (group == NAME) {
+        OverwriteOrAppendNames(profile.name_);
+      } else {
+        SetRawMultiInfo(*iter, existing_values);
+      }

[Ilya Sherman, 2014/06/03 00:25:32]

nit: No need for curly braces.

[Pritam Nikam, 2014/06/03 15:37:34]

Done.

     } else {
       base::string16 new_value = profile.GetRawInfo(*iter);
       if (StringToLowerASCII(GetRawInfo(*iter)) !=
               StringToLowerASCII(new_value)) {
         SetRawInfo(*iter, new_value);
       }
     }
   }
 }
 
@@ skipping 286 matching lines @@
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << profile.language_code()
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill