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

components/autofill/core/browser/credit_card.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/credit_card.h"
 
 #include <stddef.h>
 
 #include <ostream>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_regexes.h"
 #include "components/autofill/core/browser/autofill_type.h"
-#include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/component_strings.h"
 #include "grit/webkit_resources.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "third_party/icu/source/i18n/unicode/dtfmtsym.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace autofill {
 
@@ skipping 234 matching lines @@
 
   if (first_four_digits >= 3528 && first_four_digits <= 3589)
     return kJCBCard;
 
   if (first_four_digits == 6011)
     return kDiscoverCard;
 
   return kGenericCard;
 }
 
-base::string16 CreditCard::GetRawInfo(AutofillFieldType type) const {
+base::string16 CreditCard::GetRawInfo(ServerFieldType type) const {
   switch (type) {
     case CREDIT_CARD_NAME:
       return name_on_card_;
 
     case CREDIT_CARD_EXP_MONTH:
       return ExpirationMonthAsString();
 
     case CREDIT_CARD_EXP_2_DIGIT_YEAR:
       return Expiration2DigitYearAsString();
 
@@ skipping 25 matching lines @@
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store credit card verification codes.
       return base::string16();
 
     default:
       // ComputeDataPresentForArray will hit this repeatedly.
       return base::string16();
   }
 }
 
-void CreditCard::SetRawInfo(AutofillFieldType type,
+void CreditCard::SetRawInfo(ServerFieldType type,
                             const base::string16& value) {
   switch (type) {
     case CREDIT_CARD_NAME:
       name_on_card_ = value;
       break;
 
     case CREDIT_CARD_EXP_MONTH:
       SetExpirationMonthFromString(value, std::string());
       break;
 
@@ skipping 27 matching lines @@
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store the credit card verification code.
       break;
 
     default:
       NOTREACHED() << "Attempting to set unknown info-type " << type;
       break;
   }
 }
 
-base::string16 CreditCard::GetInfo(AutofillFieldType type,
+base::string16 CreditCard::GetInfo(const AutofillType& type,
                                    const std::string& app_locale) const {
-  if (type == CREDIT_CARD_NUMBER)
+  if (type.server_type() == CREDIT_CARD_NUMBER)
     return StripSeparators(number_);
 
-  return GetRawInfo(type);
+  return GetRawInfo(type.server_type());
 }
 
-bool CreditCard::SetInfo(AutofillFieldType type,
+bool CreditCard::SetInfo(const AutofillType& type,
                          const base::string16& value,
                          const std::string& app_locale) {
-  if (type == CREDIT_CARD_NUMBER)
-    SetRawInfo(type, StripSeparators(value));
-  else if (type == CREDIT_CARD_EXP_MONTH)
+  ServerFieldType server_type = type.server_type();
+  if (server_type == CREDIT_CARD_NUMBER)
+    SetRawInfo(server_type, StripSeparators(value));
+  else if (server_type == CREDIT_CARD_EXP_MONTH)
     SetExpirationMonthFromString(value, app_locale);
   else
-    SetRawInfo(type, value);
+    SetRawInfo(server_type, value);
 
   return true;
 }
 
 void CreditCard::GetMatchingTypes(const base::string16& text,
                                   const std::string& app_locale,
-                                  FieldTypeSet* matching_types) const {
+                                  ServerFieldTypeSet* matching_types) const {
   FormGroup::GetMatchingTypes(text, app_locale, matching_types);
 
-  base::string16 card_number = GetInfo(CREDIT_CARD_NUMBER, app_locale);
+  base::string16 card_number =
+      GetInfo(AutofillType(CREDIT_CARD_NUMBER), app_locale);
   if (!card_number.empty() && StripSeparators(text) == card_number)
     matching_types->insert(CREDIT_CARD_NUMBER);
 
   int month;
   if (ConvertMonth(text, app_locale, &month) && month != 0 &&
       month == expiration_month_) {
     matching_types->insert(CREDIT_CARD_EXP_MONTH);
   }
 }
 
@@ skipping 84 matching lines @@
   type_ = credit_card.type_;
   expiration_month_ = credit_card.expiration_month_;
   expiration_year_ = credit_card.expiration_year_;
 
   set_guid(credit_card.guid());
   set_origin(credit_card.origin());
 }
 
 bool CreditCard::UpdateFromImportedCard(const CreditCard& imported_card,
                                         const std::string& app_locale) {
-  if (this->GetInfo(CREDIT_CARD_NUMBER, app_locale) !=
-          imported_card.GetInfo(CREDIT_CARD_NUMBER, app_locale)) {
+  if (this->GetInfo(AutofillType(CREDIT_CARD_NUMBER), app_locale) !=
+          imported_card.GetInfo(AutofillType(CREDIT_CARD_NUMBER), app_locale)) {
     return false;
   }
 
   // Heuristically aggregated data should never overwrite verified data.
   // Instead, discard any heuristically aggregated credit cards that disagree
   // with explicitly entered data, so that the UI is not cluttered with
   // duplicate cards.
   if (this->IsVerified() && !imported_card.IsVerified())
     return true;
 
@@ skipping 10 matching lines @@
   expiration_month_ = imported_card.expiration_month_;
   expiration_year_ = imported_card.expiration_year_;
 
   return true;
 }
 
 void CreditCard::FillFormField(const AutofillField& field,
                                size_t /*variant*/,
                                const std::string& app_locale,
                                FormFieldData* field_data) const {
-  DCHECK_EQ(CREDIT_CARD, AutofillType(field.type()).group());
+  DCHECK_EQ(CREDIT_CARD, field.Type().group());
   DCHECK(field_data);
 
   if (field_data->form_control_type == "select-one") {
-    FillSelectControl(field.type(), app_locale, field_data);
+    FillSelectControl(field.Type(), app_locale, field_data);
   } else if (field_data->form_control_type == "month") {
     // HTML5 input="month" consists of year-month.
-    base::string16 year = GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, app_locale);
-    base::string16 month = GetInfo(CREDIT_CARD_EXP_MONTH, app_locale);
+    base::string16 year =
+        GetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR), app_locale);
+    base::string16 month =
+        GetInfo(AutofillType(CREDIT_CARD_EXP_MONTH), app_locale);
     if (!year.empty() && !month.empty()) {
       // Fill the value only if |this| includes both year and month
       // information.
       field_data->value = year + ASCIIToUTF16("-") + month;
     }
   } else {
-    field_data->value = GetInfo(field.type(), app_locale);
+    field_data->value = GetInfo(field.Type(), app_locale);
   }
 }
 
 int CreditCard::Compare(const CreditCard& credit_card) const {
   // The following CreditCard field types are the only types we store in the
   // WebDB so far, so we're only concerned with matching these types in the
   // credit card.
-  const AutofillFieldType types[] = { CREDIT_CARD_NAME,
-                                      CREDIT_CARD_NUMBER,
-                                      CREDIT_CARD_EXP_MONTH,
-                                      CREDIT_CARD_EXP_4_DIGIT_YEAR };
-  for (size_t index = 0; index < arraysize(types); ++index) {
-    int comparison = GetRawInfo(types[index]).compare(
-        credit_card.GetRawInfo(types[index]));
+  const ServerFieldType types[] = { CREDIT_CARD_NAME,
+                                    CREDIT_CARD_NUMBER,
+                                    CREDIT_CARD_EXP_MONTH,
+                                    CREDIT_CARD_EXP_4_DIGIT_YEAR };
+  for (size_t i = 0; i < arraysize(types); ++i) {
+    int comparison =
+        GetRawInfo(types[i]).compare(credit_card.GetRawInfo(types[i]));
     if (comparison != 0)
       return comparison;
   }
 
   return 0;
 }
 
 bool CreditCard::operator==(const CreditCard& credit_card) const {
   return guid() == credit_card.guid() &&
          origin() == credit_card.origin() &&
          Compare(credit_card) == 0;
 }
 
 bool CreditCard::operator!=(const CreditCard& credit_card) const {
   return !operator==(credit_card);
 }
 
 bool CreditCard::IsEmpty(const std::string& app_locale) const {
-  FieldTypeSet types;
+  ServerFieldTypeSet types;
   GetNonEmptyTypes(app_locale, &types);
   return types.empty();
 }
 
 bool CreditCard::IsComplete() const {
   return
       autofill::IsValidCreditCardNumber(number_) &&
       expiration_month_ != 0 &&
       expiration_year_ != 0;
 }
 
 bool CreditCard::IsValid() const {
   return autofill::IsValidCreditCardNumber(number_) &&
          autofill::IsValidCreditCardExpirationDate(
              expiration_year_, expiration_month_, base::Time::Now());
 }
 
-void CreditCard::GetSupportedTypes(FieldTypeSet* supported_types) const {
+void CreditCard::GetSupportedTypes(ServerFieldTypeSet* supported_types) const {
   supported_types->insert(CREDIT_CARD_NAME);
   supported_types->insert(CREDIT_CARD_NUMBER);
   supported_types->insert(CREDIT_CARD_TYPE);
   supported_types->insert(CREDIT_CARD_EXP_MONTH);
   supported_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
 }
 
@@ skipping 88 matching lines @@
 const char* const kAmericanExpressCard = "americanExpressCC";
 const char* const kDinersCard = "dinersCC";
 const char* const kDiscoverCard = "discoverCC";
 const char* const kGenericCard = "genericCC";
 const char* const kJCBCard = "jcbCC";
 const char* const kMasterCard = "masterCardCC";
 const char* const kUnionPay = "unionPayCC";
 const char* const kVisaCard = "visaCC";
 
 }  // namespace autofill