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> results(name_);
+  for (std::vector<NameInfo>::const_iterator it = names.begin();
+       it != names.end();
+       ++it) {
+    NameInfo imported_name = *it;
+    NameInfo heuristically_parsed_name;
+    bool should_append_imported_name = true;
+
+    for (size_t index = 0; index < name_.size(); ++index) {
+      NameInfo current_name = name_[index];
+      if (current_name == imported_name) {
+        should_append_imported_name = false;
+        break;
+      }
+
+      base::string16 full_name = current_name.GetRawInfo(NAME_FULL);
+      if (full_name == imported_name.GetRawInfo(NAME_FULL)) {
+        // 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.
+        heuristically_parsed_name.SetRawInfo(NAME_FULL, full_name);
+        if (current_name == heuristically_parsed_name) {
+          results[index] = imported_name;
+          should_append_imported_name = false;
+          break;
+        }
+      }
+    }
+
+    // Append unique names to the list.
+    if (should_append_imported_name &&
+        (imported_name != heuristically_parsed_name))

[Ilya Sherman, 2014/06/03 22:09:52]

What is the test case that would fail if this line were missing?  (Moreover, if
you decide that it is not needed, please consider whether there is a test case
that you could add that would *fail* if this line were present.)

[Pritam Nikam, 2014/06/04 06:54:44]

If this (imported_name != heuristically_parsed_name) check is missing then few
of our test-cases will going to fail.

e.g. 
 
// considering same test-case structure
  struct TestCase {
    std::string starting_names[3];
    std::string additional_names[3];
    std::string expected_result[3];
  };

Below test cases will fail, as avoid this check will try to append additional
names (from imported profile) to the |name_| list even if full names are
_heuristically_ parsed into {first, middle, last} name components, and matching
to full name for one of the exiting names.

1.    {{"Marion Mitchell", "", "Morrison"},
       {"Marion", "Mitchell", "Morrison"},
       {"Marion Mitchell", "", "Morrison"}},

2.   {{"Marion", "", "Mitchell Morrison"},
       {"Marion", "Mitchell", "Morrison"},
       {"Marion", "", "Mitchell Morrison"}},

3.    {{"Arthur Ignatius", "", "Conan Doyle"},
       {"Arthur", "Ignatius Conan", "Doyle"},
       {"Arthur Ignatius", "", "Conan Doyle"}},
etc...

hope I'm not confusing you.

[Ilya Sherman, 2014/06/04 22:38:27]

Sorry, you are of course correct that this check is needed in some cases -- I
was thinking that heuristically_parsed_name would always be computed, even when
the full names did not match, which would cause problems.  I'd recommend moving
this condition into the the code that handles identical full names.  So,
specifically, I'd move line 528 to be immediately above line 548, and then
immediately below that include

if (imported_name == heuristically_parsed_name) {
  should_append_imported_name = false;
  break;
}

The advantage of this structure is that it groups all of the code that deals
with the case where the full names match.

[Pritam Nikam, 2014/06/07 06:25:12]

Done.

+      results.push_back(imported_name);
+  }
+
+  name_.swap(results);
+}
+
 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);
     } 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