autofill names - dont parse when calling SetRawInfo(FULL_NAME)

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>
 
@@ skipping 141 matching lines @@
   if (this == &info)
     return *this;
 
   given_ = info.given_;
   middle_ = info.middle_;
   family_ = info.family_;
   full_ = info.full_;
   return *this;
 }
 
-bool NameInfo::EqualsIgnoreCase(const NameInfo& info) {
+bool NameInfo::ParsedBitsAreEqual(const NameInfo& info) {
   return (StringToLowerASCII(given_) == StringToLowerASCII(info.given_) &&
           StringToLowerASCII(middle_) == StringToLowerASCII(info.middle_) &&
+          middle_.size() == info.middle_.size() &&

[Ilya Sherman, 2014/06/27 06:25:08]

Why is this check necessary?  How can the strings be equal without being the
same size?  If somehow that's possible, why is it only middle names that need
special treatment?

[Evan Stade, 2014/06/28 01:01:35]

this is totally not necessary. It was just me being paranoid  while I was
debugging a test failure, and then being forgetful when it came time to remove
it.

           StringToLowerASCII(family_) == StringToLowerASCII(info.family_));
 }
 
 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 given_;
 
     case NAME_MIDDLE:
       return middle_;
 
     case NAME_LAST:
       return family_;
 
     case NAME_MIDDLE_INITIAL:
       return MiddleInitial();
 
     case NAME_FULL:
-      return FullName();
+      return full_;
 
     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:
       given_ = value;
       break;
 
     case NAME_MIDDLE:
     case NAME_MIDDLE_INITIAL:
       middle_ = value;
       break;
 
     case NAME_LAST:
       family_ = value;
       break;
 
     case NAME_FULL:
-      // TODO(estade): this should just set |full_|; only SetInfo should attempt
-      // to be smart. http://crbug.com/384640
-      SetFullName(value);
+      full_ = value;
       break;
 
     default:
       NOTREACHED();
   }
 }
 
+base::string16 NameInfo::GetInfo(const AutofillType& type,
+                                 const std::string& app_locale) const {
+  if (type.GetStorableType() == NAME_FULL)
+    return FullName();
+
+  return GetRawInfo(type.GetStorableType());
+}
+
+bool NameInfo::SetInfo(const AutofillType& type,
+                       const base::string16& value,
+                       const std::string& app_locale) {
+  // Always clear out the full name if we're making a change.
+  if (value != GetInfo(type, app_locale))
+    full_.clear();
+
+  if (type.GetStorableType() == NAME_FULL) {
+    SetFullName(value);
+    return true;
+  }
+
+  return FormGroup::SetInfo(type, value, app_locale);
+}
+
 base::string16 NameInfo::FullName() const {
   if (!full_.empty())
     return full_;
 
   std::vector<base::string16> full_name;
   if (!given_.empty())
     full_name.push_back(given_);
 
   if (!middle_.empty())
     full_name.push_back(middle_);
 
   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 initial;
   initial.push_back(middle_name[0]);
   return initial;
 }
 
 void NameInfo::SetFullName(const base::string16& full) {
-  // 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. http://crbug.com/384640
-  if (FullName() == full)
-    return;
-
   full_ = full;
 
   // 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;
@@ skipping 59 matching lines @@
   return base::string16();
 }
 
 void CompanyInfo::SetRawInfo(ServerFieldType type,
                              const base::string16& value) {
   DCHECK_EQ(COMPANY_NAME, type);
   company_name_ = value;
 }
 
 }  // namespace autofill