[Autofill] Distinguish between native field types and potentially HTML field types.

components/autofill/core/browser/personal_data_manager.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/personal_data_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
@@ skipping 91 matching lines @@
     return false;
 
   if (country.requires_zip() && profile.GetRawInfo(ADDRESS_HOME_ZIP).empty())
     return false;
 
   return true;
 }
 
 // Return true if the |field_type| and |value| are valid within the context
 // of importing a form.
-bool IsValidFieldTypeAndValue(const std::set<AutofillFieldType>& types_seen,
-                              AutofillFieldType field_type,
+bool IsValidFieldTypeAndValue(const std::set<ServerFieldType>& types_seen,
+                              ServerFieldType field_type,
                               const base::string16& value) {
   // Abandon the import if two fields of the same type are encountered.
   // This indicates ambiguous data or miscategorization of types.
   // Make an exception for PHONE_HOME_NUMBER however as both prefix and
   // suffix are stored against this type, and for EMAIL_ADDRESS because it is
   // common to see second 'confirm email address' fields on forms.
-  if (types_seen.count(field_type) && field_type != PHONE_HOME_NUMBER &&
+  if (types_seen.count(field_type) &&
+      field_type != PHONE_HOME_NUMBER &&
       field_type != EMAIL_ADDRESS)
     return false;
 
   // Abandon the import if an email address value shows up in a field that is
   // not an email address.
-  if (field_type != EMAIL_ADDRESS && autofill::IsValidEmailAddress(value))
+  if (field_type != EMAIL_ADDRESS && IsValidEmailAddress(value))
     return false;
 
   return true;
 }
 
 }  // namespace
 
 PersonalDataManager::PersonalDataManager(const std::string& app_locale)
     : browser_context_(NULL),
       is_data_loaded_(false),
@@ skipping 96 matching lines @@
 
   const std::string origin = form.source_url().spec();
   imported_profile->set_origin(origin);
   local_imported_credit_card->set_origin(origin);
 
   // Parse the form and construct a profile based on the information that is
   // possible to import.
   int importable_credit_card_fields = 0;
 
   // Detect and discard forms with multiple fields of the same type.
-  std::set<AutofillFieldType> types_seen;
+  // TODO(isherman): Some types are overlapping but not equal, e.g. phone number
+  // parts, address parts.
+  std::set<ServerFieldType> types_seen;
 
   // We only set complete phone, so aggregate phone parts in these vars and set
   // complete at the end.
   PhoneNumber::PhoneCombineHelper home;
 
   for (size_t i = 0; i < form.field_count(); ++i) {
     const AutofillField* field = form.field(i);
     base::string16 value = CollapseWhitespace(field->value, false);
 
     // If we don't know the type of the field, or the user hasn't entered any
     // information into the field, then skip it.
     if (!field->IsFieldFillable() || value.empty())
       continue;
 
-    AutofillFieldType field_type = field->type();
-    FieldTypeGroup group(AutofillType(field_type).group());
+    AutofillType field_type = field->Type();
+    ServerFieldType server_field_type = field_type.server_type();
+    FieldTypeGroup group(field_type.group());
 
     // There can be multiple email fields (e.g. in the case of 'confirm email'
     // fields) but they must all contain the same value, else the profile is
     // invalid.
-    if (field_type == EMAIL_ADDRESS) {
-      if (types_seen.count(field_type) &&
-          imported_profile->GetRawInfo(field_type) != value) {
+    if (server_field_type == EMAIL_ADDRESS) {
+      if (types_seen.count(server_field_type) &&
+          imported_profile->GetRawInfo(EMAIL_ADDRESS) != value) {
         imported_profile.reset();
         break;
       }
     }
 
     // If the |field_type| and |value| don't pass basic validity checks then
     // abandon the import.
-    if (!IsValidFieldTypeAndValue(types_seen, field_type, value)) {
+    if (!IsValidFieldTypeAndValue(types_seen, server_field_type, value)) {
       imported_profile.reset();
       local_imported_credit_card.reset();
       break;
     }
 
-    types_seen.insert(field_type);
+    types_seen.insert(server_field_type);
 
     if (group == CREDIT_CARD) {
       if (LowerCaseEqualsASCII(field->form_control_type, "month")) {
-        DCHECK_EQ(CREDIT_CARD_EXP_MONTH, field_type);
+        DCHECK_EQ(CREDIT_CARD_EXP_MONTH, server_field_type);
         local_imported_credit_card->SetInfoForMonthInputType(value);
       } else {
         local_imported_credit_card->SetInfo(field_type, value, app_locale_);
       }
       ++importable_credit_card_fields;
     } else {
       // We need to store phone data in the variables, before building the whole
       // number at the end. The rest of the fields are set "as is".
       // If the fields are not the phone fields in question home.SetInfo() is
       // going to return false.
       if (!home.SetInfo(field_type, value))
         imported_profile->SetInfo(field_type, value, app_locale_);
 
       // Reject profiles with invalid country information.
-      if (field_type == ADDRESS_HOME_COUNTRY &&
+      if (server_field_type == ADDRESS_HOME_COUNTRY &&
           !value.empty() &&
           imported_profile->GetRawInfo(ADDRESS_HOME_COUNTRY).empty()) {
         imported_profile.reset();
         break;
       }
     }
   }
 
   // Construct the phone number. Reject the profile if the number is invalid.
   if (imported_profile.get() && !home.IsEmpty()) {
     base::string16 constructed_number;
     if (!home.ParseNumber(*imported_profile, app_locale_,
                           &constructed_number) ||
-        !imported_profile->SetInfo(PHONE_HOME_WHOLE_NUMBER, constructed_number,
+        !imported_profile->SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER),
+                                   constructed_number,
                                    app_locale_)) {
       imported_profile.reset();
     }
   }
 
   // Reject the profile if minimum address and validation requirements are not
   // met.
   if (imported_profile.get() &&
       !IsValidLearnableProfile(*imported_profile, app_locale_))
     imported_profile.reset();
@@ skipping 190 matching lines @@
   const std::vector<CreditCard*>& credit_cards = GetCreditCards();
   for (std::vector<CreditCard*>::const_iterator iter = credit_cards.begin();
        iter != credit_cards.end(); ++iter) {
     if ((*iter)->guid() == guid)
       return *iter;
   }
   return NULL;
 }
 
 void PersonalDataManager::GetNonEmptyTypes(
-    FieldTypeSet* non_empty_types) {
+    ServerFieldTypeSet* non_empty_types) {
   const std::vector<AutofillProfile*>& profiles = GetProfiles();
   for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     (*iter)->GetNonEmptyTypes(app_locale_, non_empty_types);
   }
 
   for (ScopedVector<CreditCard>::const_iterator iter = credit_cards_.begin();
        iter != credit_cards_.end(); ++iter) {
     (*iter)->GetNonEmptyTypes(app_locale_, non_empty_types);
   }
@@ skipping 27 matching lines @@
 const std::vector<CreditCard*>& PersonalDataManager::GetCreditCards() const {
   return credit_cards_.get();
 }
 
 void PersonalDataManager::Refresh() {
   LoadProfiles();
   LoadCreditCards();
 }
 
 void PersonalDataManager::GetProfileSuggestions(
-    AutofillFieldType type,
+    const AutofillType& type,
     const base::string16& field_contents,
     bool field_is_autofilled,
-    std::vector<AutofillFieldType> other_field_types,
+    std::vector<ServerFieldType> other_field_types,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<GUIDPair>* guid_pairs) {
   values->clear();
   labels->clear();
   icons->clear();
   guid_pairs->clear();
 
   const std::vector<AutofillProfile*>& profiles = GetProfiles();
@@ skipping 19 matching lines @@
         if (multi_values[i].empty())
           continue;
 
         base::string16 profile_value_lower_case(
             StringToLowerASCII(multi_values[i]));
         base::string16 field_value_lower_case(
             StringToLowerASCII(field_contents));
         // Phone numbers could be split in US forms, so field value could be
         // either prefix or suffix of the phone.
         bool matched_phones = false;
-        if (type == PHONE_HOME_NUMBER && !field_value_lower_case.empty() &&
-            (profile_value_lower_case.find(field_value_lower_case) !=
-             base::string16::npos)) {
+        if ((type.server_type() == PHONE_HOME_NUMBER ||
+             type.server_type() == PHONE_BILLING_NUMBER) &&
+            !field_value_lower_case.empty() &&
+            profile_value_lower_case.find(field_value_lower_case) !=
+                base::string16::npos) {
           matched_phones = true;
         }
 
         // Suggest variants of the profile that's already been filled in.
         if (matched_phones ||
             profile_value_lower_case == field_value_lower_case) {
           for (size_t j = 0; j < multi_values.size(); ++j) {
             if (!multi_values[j].empty()) {
               values->push_back(multi_values[j]);
               guid_pairs->push_back(GUIDPair(profile->guid(), j));
             }
           }
 
           // We've added all the values for this profile so move on to the
           // next.
           break;
         }
       }
     }
   }
 
   if (!field_is_autofilled) {
     AutofillProfile::CreateInferredLabels(
         &matched_profiles, &other_field_types,
-        type, 1, labels);
+        type.server_type(), 1, labels);
   } else {
     // No sub-labels for previously filled fields.
     labels->resize(values->size());
   }
 
   // No icons for profile suggestions.
   icons->resize(values->size());
 }
 
 void PersonalDataManager::GetCreditCardSuggestions(
-    AutofillFieldType type,
+    const AutofillType& type,
     const base::string16& field_contents,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<GUIDPair>* guid_pairs) {
   values->clear();
   labels->clear();
   icons->clear();
   guid_pairs->clear();
 
   const std::vector<CreditCard*>& credit_cards = GetCreditCards();
   for (std::vector<CreditCard*>::const_iterator iter = credit_cards.begin();
        iter != credit_cards.end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
     base::string16 creditcard_field_value =
         credit_card->GetInfo(type, app_locale_);
     if (!creditcard_field_value.empty() &&
         StartsWith(creditcard_field_value, field_contents, false)) {
-      if (type == CREDIT_CARD_NUMBER)
+      if (type.server_type() == CREDIT_CARD_NUMBER)
         creditcard_field_value = credit_card->ObfuscatedNumber();
 
       base::string16 label;
       if (credit_card->number().empty()) {
         // If there is no CC number, return name to show something.
-        label = credit_card->GetInfo(CREDIT_CARD_NAME, app_locale_);
+        label =
+            credit_card->GetInfo(AutofillType(CREDIT_CARD_NAME), app_locale_);
       } else {
         label = kCreditCardPrefix;
         label.append(credit_card->LastFourDigits());
       }
 
       values->push_back(creditcard_field_value);
       labels->push_back(label);
       icons->push_back(UTF8ToUTF16(credit_card->type()));
       guid_pairs->push_back(GUIDPair(credit_card->guid(), 0));
     }
   }
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
   return user_prefs::UserPrefs::Get(browser_context_)->GetBoolean(
       prefs::kAutofillEnabled);
 }
 
 // static
 bool PersonalDataManager::IsValidLearnableProfile(
     const AutofillProfile& profile,
     const std::string& app_locale) {
   if (!IsMinimumAddress(profile, app_locale))
     return false;
 
   base::string16 email = profile.GetRawInfo(EMAIL_ADDRESS);
-  if (!email.empty() && !autofill::IsValidEmailAddress(email))
+  if (!email.empty() && !IsValidEmailAddress(email))
     return false;
 
   // Reject profiles with invalid US state information.
   if (profile.IsPresentButInvalid(ADDRESS_HOME_STATE))
     return false;
 
   // Reject profiles with invalid US zip information.
   if (profile.IsPresentButInvalid(ADDRESS_HOME_ZIP))
     return false;
 
@@ skipping 299 matching lines @@
     const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 void PersonalDataManager::set_browser_context(
     content::BrowserContext* context) {
   browser_context_ = context;
 }
 
 }  // namespace autofill