Move a bunch of non-shared methods out of the FormGroup class.

chrome/browser/autofill/autofill_profile.cc

 // Copyright (c) 2011 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 "chrome/browser/autofill/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
@@ skipping 176 matching lines @@
 
   bool operator()(const string16* phone) {
     return autofill_i18n::PhoneNumbersMatch(*phone, phone_, country_code_);
   }
 
  private:
   string16 phone_;
   std::string country_code_;
 };
 
+// Functor used to check for case-insensitive equality of two strings.
+struct CaseInsensitiveStringEquals
+    : public std::binary_function<string16, string16, bool>
+{
+  bool operator()(const string16& x, const string16& y) const {
+    return
+        x.size() == y.size() && StringToLowerASCII(x) == StringToLowerASCII(y);
+  }
+};
+
 }  // namespace
 
 AutofillProfile::AutofillProfile(const std::string& guid)
     : guid_(guid),
       name_(1),
       email_(1),
       home_number_(1, PhoneNumber(this)) {
 }
 
 AutofillProfile::AutofillProfile()
@@ skipping 299 matching lines @@
 
 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
   return !operator==(profile);
 }
 
 const string16 AutofillProfile::PrimaryValue() const {
   return GetInfo(ADDRESS_HOME_LINE1) +
          GetInfo(ADDRESS_HOME_CITY);
 }
 
-// Functor used to check for case-insensitive equality of two strings.
-struct CaseInsensitiveStringEquals
-    : public std::binary_function<string16, string16, bool>
-{
-  bool operator()(const string16& x, const string16& y) const {
-    if (x.size() != y.size()) return false;
-    return StringToLowerASCII(x) == StringToLowerASCII(y);
+bool AutofillProfile::IsSubsetOf(const AutofillProfile& profile) const {
+  FieldTypeSet types;
+  GetNonEmptyTypes(&types);
+
+  for (FieldTypeSet::const_iterator iter = types.begin(); iter != types.end();
+       ++iter) {
+    if (StringToLowerASCII(GetInfo(*iter)) !=
+            StringToLowerASCII(profile.GetInfo(*iter)))
+      return false;
   }
-};
+
+  return true;
+}
 
 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile) {
   FieldTypeSet field_types;
   profile.GetNonEmptyTypes(&field_types);
 
   // Only transfer "full" types (e.g. full name) and not fragments (e.g.
   // first name, last name).
   CollapseCompoundFieldTypes(&field_types);
 
   for (FieldTypeSet::const_iterator iter = field_types.begin();
        iter != field_types.end(); ++iter) {
     if (AutofillProfile::SupportsMultiValue(*iter)) {
       std::vector<string16> new_values;
       profile.GetMultiInfo(*iter, &new_values);
       std::vector<string16> existing_values;
       GetMultiInfo(*iter, &existing_values);
+
+      // GetMultiInfo always returns at least one element, even if the profile
+      // has no data stored for this field type.
+      if (existing_values.size() == 1 && existing_values.front().empty())
+        existing_values.clear();
+
       FieldTypeGroup group = AutofillType(*iter).group();
       for (std::vector<string16>::iterator value_iter = new_values.begin();
            value_iter != new_values.end(); ++value_iter) {
         // Don't add duplicates.
         if (group == AutofillType::PHONE_HOME) {
           AddPhoneIfUnique(*value_iter, &existing_values);
         } else {
           std::vector<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);
         }
       }
       SetMultiInfo(*iter, existing_values);
     } else {
-      SetInfo(*iter, profile.GetInfo(*iter));
+      string16 new_value = profile.GetInfo(*iter);
+      if (StringToLowerASCII(GetInfo(*iter)) != StringToLowerASCII(new_value))
+        SetInfo(*iter, new_value);
     }
   }
 }
 
 void AutofillProfile::AddPhoneIfUnique(const string16& phone,
                                        std::vector<string16>* existing_phones) {
   DCHECK(existing_phones);
   // Phones allow "fuzzy" matching, so "1-800-FLOWERS", "18003569377",
   // "(800)356-9377" and "356-9377" are considered the same.
   std::vector<string16>::const_iterator phone_iter;
@@ skipping 169 matching lines @@
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_CITY))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_STATE))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_ZIP))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }