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

chrome/browser/ui/autofill/autofill_dialog_controller_impl.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 "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 94 matching lines @@
 
 // Returns true if |card_type| is supported by Wallet.
 bool IsWalletSupportedCard(const std::string& card_type) {
   return card_type == autofill::kVisaCard ||
          card_type == autofill::kMasterCard ||
          card_type == autofill::kDiscoverCard;
 }
 
 // Returns true if |input| should be shown when |field_type| has been requested.
 bool InputTypeMatchesFieldType(const DetailInput& input,
-                               AutofillFieldType field_type) {
+                               const AutofillType& field_type) {
   // If any credit card expiration info is asked for, show both month and year
   // inputs.
-  if (field_type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
-      field_type == CREDIT_CARD_EXP_2_DIGIT_YEAR ||
-      field_type == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR ||
-      field_type == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR ||
-      field_type == CREDIT_CARD_EXP_MONTH) {
+  if (field_type.server_type() == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
+      field_type.server_type() == CREDIT_CARD_EXP_2_DIGIT_YEAR ||
+      field_type.server_type() == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR ||
+      field_type.server_type() == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR ||
+      field_type.server_type() == CREDIT_CARD_EXP_MONTH) {
     return input.type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
            input.type == CREDIT_CARD_EXP_MONTH;
   }
 
-  if (field_type == CREDIT_CARD_TYPE)
+  if (field_type.server_type() == CREDIT_CARD_TYPE)
     return input.type == CREDIT_CARD_NUMBER;
 
-  return input.type == field_type;
+  return input.type == field_type.server_type();
 }
 
 // Returns true if |input| in the given |section| should be used for a
 // site-requested |field|.
 bool DetailInputMatchesField(DialogSection section,
                              const DetailInput& input,
                              const AutofillField& field) {
+  AutofillType field_type = field.Type();
+
   // The credit card name is filled from the billing section's data.
-  if (field.type() == CREDIT_CARD_NAME &&
+  if (field_type.server_type() == CREDIT_CARD_NAME &&
       (section == SECTION_BILLING || section == SECTION_CC_BILLING)) {
     return input.type == NAME_BILLING_FULL;
   }
 
-  return InputTypeMatchesFieldType(input, field.type());
+  return InputTypeMatchesFieldType(input, field_type);
 }
 
-bool IsCreditCardType(AutofillFieldType type) {
+bool IsCreditCardType(ServerFieldType type) {
   return AutofillType(type).group() == CREDIT_CARD;
 }
 
 // Returns true if |input| should be used to fill a site-requested |field| which
 // is notated with a "shipping" tag, for use when the user has decided to use
 // the billing address as the shipping address.
 bool DetailInputMatchesShippingField(const DetailInput& input,
                                      const AutofillField& field) {
   // Equivalent billing field type is used to support UseBillingAsShipping
   // usecase.
-  AutofillFieldType field_type =
-      AutofillType::GetEquivalentBillingFieldType(field.type());
+  ServerFieldType field_type =
+      AutofillType::GetEquivalentBillingFieldType(field.Type().server_type());
 
-  return InputTypeMatchesFieldType(input, field_type);
+  return InputTypeMatchesFieldType(input, AutofillType(field_type));
 }
 
 // Constructs |inputs| from template data.
 void BuildInputs(const DetailInput* input_template,
                  size_t template_size,
                  DetailInputs* inputs) {
   for (size_t i = 0; i < template_size; ++i) {
     const DetailInput* input = &input_template[i];
     inputs->push_back(*input);
   }
 }
 
 // Initializes |form_group| from user-entered data.
 void FillFormGroupFromOutputs(const DetailOutputMap& detail_outputs,
                               FormGroup* form_group) {
   for (DetailOutputMap::const_iterator iter = detail_outputs.begin();
        iter != detail_outputs.end(); ++iter) {
+    ServerFieldType type = iter->first->type;
     if (!iter->second.empty()) {
-      AutofillFieldType type = iter->first->type;
       if (type == ADDRESS_HOME_COUNTRY || type == ADDRESS_BILLING_COUNTRY) {
-        form_group->SetInfo(type,
+        form_group->SetInfo(AutofillType(type),
                             iter->second,
                             g_browser_process->GetApplicationLocale());
       } else {
-        form_group->SetRawInfo(iter->first->type, iter->second);
+        form_group->SetRawInfo(type, iter->second);
       }
     }
   }
 }
 
 // Get billing info from |output| and put it into |card|, |cvc|, and |profile|.
 // These outparams are required because |card|/|profile| accept different types
 // of raw info, and CreditCard doesn't save CVCs.
 void GetBillingInfoFromOutputs(const DetailOutputMap& output,
                                CreditCard* card,
                                string16* cvc,
                                AutofillProfile* profile) {
   for (DetailOutputMap::const_iterator it = output.begin();
        it != output.end(); ++it) {
     string16 trimmed;
     TrimWhitespace(it->second, TRIM_ALL, &trimmed);
 
     // Special case CVC as CreditCard just swallows it.
     if (it->first->type == CREDIT_CARD_VERIFICATION_CODE) {
       if (cvc)
         cvc->assign(trimmed);
     } else if (it->first->type == ADDRESS_HOME_COUNTRY ||
                it->first->type == ADDRESS_BILLING_COUNTRY) {
       if (profile) {
-        profile->SetInfo(it->first->type,
+        profile->SetInfo(AutofillType(it->first->type),
                          trimmed,
                          g_browser_process->GetApplicationLocale());
       }
     } else {
       // Copy the credit card name to |profile| in addition to |card| as
       // wallet::Instrument requires a recipient name for its billing address.
       if (card && it->first->type == NAME_FULL)
         card->SetRawInfo(CREDIT_CARD_NAME, trimmed);
 
       if (IsCreditCardType(it->first->type)) {
@@ skipping 19 matching lines @@
       web_contents->GetView()->GetTopLevelNativeWindow();
   apps::ShellWindow* shell_window =
       extensions::ShellWindowRegistry::
           GetShellWindowForNativeWindowAnyProfile(native_window);
   return shell_window->GetBaseWindow();
 }
 
 // Extracts the string value of a field with |type| from |output|. This is
 // useful when you only need the value of 1 input from a section of view inputs.
 string16 GetValueForType(const DetailOutputMap& output,
-                         AutofillFieldType type) {
+                         ServerFieldType type) {
   for (DetailOutputMap::const_iterator it = output.begin();
        it != output.end(); ++it) {
     if (it->first->type == type)
       return it->second;
   }
   NOTREACHED();
   return string16();
 }
 
 // Returns a string descriptor for a DialogSection, for use with prefs (do not
@@ skipping 45 matching lines @@
 }
 
 // Returns whether |data_model| is complete, i.e. can fill out all the
 // |requested_fields|, and verified, i.e. not just automatically aggregated.
 // Incomplete or unverifed data will not be displayed in the dropdown menu.
 bool HasCompleteAndVerifiedData(const AutofillDataModel& data_model,
                                 const DetailInputs& requested_fields) {
   if (!data_model.IsVerified())
     return false;
 
-  const std::string app_locale = g_browser_process->GetApplicationLocale();
   for (size_t i = 0; i < requested_fields.size(); ++i) {
-    AutofillFieldType type = requested_fields[i].type;
+    ServerFieldType type = requested_fields[i].type;
     if (type != ADDRESS_HOME_LINE2 &&
         type != CREDIT_CARD_VERIFICATION_CODE &&
-        data_model.GetInfo(type, app_locale).empty()) {
+        data_model.GetRawInfo(type).empty()) {
       return false;
     }
   }
 
   return true;
 }
 
 // Returns true if |profile| has an invalid address, i.e. an invalid state, zip
 // code, or phone number. Otherwise returns false. Profiles with invalid
 // addresses are not suggested in the dropdown menu for billing and shipping
@@ skipping 509 matching lines @@
 
   state.strings.push_back(DialogOverlayString());
   DialogOverlayString& string = state.strings.back();
 #if !defined(OS_ANDROID)
   // gfx::Font isn't implemented on Android; DeriveFont() causes a null deref.
   string.font = rb.GetFont(ui::ResourceBundle::BaseFont).DeriveFont(4);
 #endif
 
   // First-run, post-submit, Wallet expository page.
   if (full_wallet_ && full_wallet_->required_actions().empty()) {
-    string16 cc_number = full_wallet_->GetInfo(CREDIT_CARD_NUMBER);
+    string16 cc_number =
+        full_wallet_->GetInfo(AutofillType(CREDIT_CARD_NUMBER));
     DCHECK_EQ(16U, cc_number.size());
     state.image = GetGeneratedCardImage(
         ASCIIToUTF16("xxxx xxxx xxxx ") +
         cc_number.substr(cc_number.size() - 4));
     string.text = l10n_util::GetStringUTF16(
         IDS_AUTOFILL_DIALOG_CARD_GENERATION_DONE);
     string.text_color = SK_ColorBLACK;
     string.alignment = gfx::ALIGN_CENTER;
 
     state.strings.push_back(DialogOverlayString());
@@ skipping 327 matching lines @@
       return requested_cc_billing_fields_;
     case SECTION_SHIPPING:
       return requested_shipping_fields_;
   }
 
   NOTREACHED();
   return requested_billing_fields_;
 }
 
 ui::ComboboxModel* AutofillDialogControllerImpl::ComboboxModelForAutofillType(
-    AutofillFieldType type) {
+    ServerFieldType type) {
   switch (AutofillType::GetEquivalentFieldType(type)) {
     case CREDIT_CARD_EXP_MONTH:
       return &cc_exp_month_combobox_model_;
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return &cc_exp_year_combobox_model_;
 
     case ADDRESS_HOME_COUNTRY:
       return &country_combobox_model_;
 
@@ skipping 286 matching lines @@
       GetDialogType(), DialogSectionToUiEditEvent(section));
 }
 
 void AutofillDialogControllerImpl::EditCancelledForSection(
     DialogSection section) {
   ResetSectionInput(section);
   UpdateSection(section);
 }
 
 gfx::Image AutofillDialogControllerImpl::IconForField(
-    AutofillFieldType type, const string16& user_input) const {
+    ServerFieldType type, const string16& user_input) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (type == CREDIT_CARD_VERIFICATION_CODE)
     return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT);
 
   // For the credit card, we show a few grayscale images, and possibly one
   // color image if |user_input| is a valid card number.
   if (type == CREDIT_CARD_NUMBER) {
     const int card_idrs[] = {
       IDR_AUTOFILL_CC_VISA,
       IDR_AUTOFILL_CC_MASTERCARD,
@@ skipping 31 matching lines @@
     return gfx::Image(skia);
   }
 
   return gfx::Image();
 }
 
 // TODO(estade): Replace all the error messages here with more helpful and
 // translateable ones. TODO(groby): Also add tests.
 string16 AutofillDialogControllerImpl::InputValidityMessage(
     DialogSection section,
-    AutofillFieldType type,
+    ServerFieldType type,
     const string16& value) {
   // If the field is edited, clear any Wallet errors.
   if (IsPayingWithWallet()) {
     WalletValidationErrors::iterator it = wallet_errors_.find(section);
     if (it != wallet_errors_.end()) {
       TypeErrorInputMap::const_iterator iter = it->second.find(type);
       if (iter != it->second.end()) {
         if (iter->second.second == value)
           return iter->second.first;
         it->second.erase(type);
@@ skipping 79 matching lines @@
       base::string16();
 }
 
 // TODO(estade): Replace all the error messages here with more helpful and
 // translateable ones. TODO(groby): Also add tests.
 ValidityData AutofillDialogControllerImpl::InputsAreValid(
     DialogSection section,
     const DetailOutputMap& inputs,
     ValidationType validation_type) {
   ValidityData invalid_messages;
-  std::map<AutofillFieldType, string16> field_values;
+  std::map<ServerFieldType, string16> field_values;
   for (DetailOutputMap::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     // Skip empty fields in edit mode.
     if (validation_type == VALIDATE_EDIT && iter->second.empty())
       continue;
 
-    const AutofillFieldType type = iter->first->type;
+    const ServerFieldType type = iter->first->type;
     string16 message = InputValidityMessage(section, type, iter->second);
     if (!message.empty())
       invalid_messages[type] = message;
     else
       field_values[type] = iter->second;
   }
 
   // Validate the date formed by month and year field. (Autofill dialog is
   // never supposed to have 2-digit years, so not checked).
   if (field_values.count(CREDIT_CARD_EXP_4_DIGIT_YEAR) &&
@@ skipping 65 matching lines @@
 
   // If the user clicks while the popup is already showing, be sure to hide
   // it.
   if (!was_edit && popup_controller_.get()) {
     HidePopup();
     return;
   }
 
   std::vector<string16> popup_values, popup_labels, popup_icons;
   if (IsCreditCardType(input->type)) {
-    GetManager()->GetCreditCardSuggestions(input->type,
+    GetManager()->GetCreditCardSuggestions(AutofillType(input->type),
                                            field_contents,
                                            &popup_values,
                                            &popup_labels,
                                            &popup_icons,
                                            &popup_guids_);
   } else {
-    std::vector<AutofillFieldType> field_types;
+    std::vector<ServerFieldType> field_types;
     field_types.push_back(EMAIL_ADDRESS);
     for (DetailInputs::const_iterator iter = requested_shipping_fields_.begin();
          iter != requested_shipping_fields_.end(); ++iter) {
       field_types.push_back(iter->type);
     }
-    GetManager()->GetProfileSuggestions(input->type,
+    GetManager()->GetProfileSuggestions(AutofillType(input->type),
                                         field_contents,
                                         false,
                                         field_types,
                                         &popup_values,
                                         &popup_labels,
                                         &popup_icons,
                                         &popup_guids_);
   }
 
   if (popup_values.empty()) {
@@ skipping 541 matching lines @@
   if (popup_controller_.get())
     return popup_controller_->HandleKeyPressEvent(event);
 
   return false;
 }
 
 bool AutofillDialogControllerImpl::RequestingCreditCardInfo() const {
   DCHECK_GT(form_structure_.field_count(), 0U);
 
   for (size_t i = 0; i < form_structure_.field_count(); ++i) {
-    if (IsCreditCardType(form_structure_.field(i)->type()))
+    if (IsCreditCardType(form_structure_.field(i)->Type().server_type()))
       return true;
   }
 
   return false;
 }
 
 bool AutofillDialogControllerImpl::TransmissionWillBeSecure() const {
   return source_url_.SchemeIs(chrome::kHttpsScheme);
 }
 
@@ skipping 257 matching lines @@
     const std::string app_locale = g_browser_process->GetApplicationLocale();
     for (size_t i = 0; i < profiles.size(); ++i) {
       if (!HasCompleteAndVerifiedData(*profiles[i],
                                       requested_shipping_fields_) ||
           HasInvalidAddress(*profiles[i])) {
         continue;
       }
 
       // Add all email addresses.
       std::vector<string16> values;
-      profiles[i]->GetMultiInfo(EMAIL_ADDRESS, app_locale, &values);
+      profiles[i]->GetMultiInfo(
+          AutofillType(EMAIL_ADDRESS), app_locale, &values);
       for (size_t j = 0; j < values.size(); ++j) {
         if (IsValidEmailAddress(values[j]))
           suggested_email_.AddKeyedItem(profiles[i]->guid(), values[j]);
       }
 
       // Don't add variants for addresses: the email variants are handled above,
       // name is part of credit card and we'll just ignore phone number
       // variants.
       suggested_billing_.AddKeyedItem(profiles[i]->guid(),
                                       profiles[i]->Label());
@@ skipping 160 matching lines @@
   // any of the fields.
   if (section == SECTION_SHIPPING)
     return cares_about_shipping_;
 
   return true;
 }
 
 void AutofillDialogControllerImpl::SetCvcResult(const string16& cvc) {
   for (size_t i = 0; i < form_structure_.field_count(); ++i) {
     AutofillField* field = form_structure_.field(i);
-    if (field->type() == CREDIT_CARD_VERIFICATION_CODE) {
+    if (field->Type().server_type() == CREDIT_CARD_VERIFICATION_CODE) {
       field->value = cvc;
       break;
     }
   }
 }
 
 string16 AutofillDialogControllerImpl::GetValueFromSection(
     DialogSection section,
-    AutofillFieldType type) {
+    ServerFieldType type) {
   DCHECK(SectionIsActive(section));
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper)
-    return wrapper->GetInfo(type);
+    return wrapper->GetInfo(AutofillType(type));
 
   DetailOutputMap output;
   view_->GetUserInput(section, &output);
   for (DetailOutputMap::iterator iter = output.begin(); iter != output.end();
        ++iter) {
     if (iter->first->type == type)
       return iter->second;
   }
 
   return string16();
@@ skipping 156 matching lines @@
     return false;
 
   if (IsPayingWithWallet() && IsEditingExistingData(SECTION_CC_BILLING)) {
     const wallet::WalletItems::MaskedInstrument* instrument =
         ActiveInstrument();
     const std::string& locale = g_browser_process->GetApplicationLocale();
     int month_int;
     if (base::StringToInt(month, &month_int) &&
         instrument->status() ==
             wallet::WalletItems::MaskedInstrument::EXPIRED &&
-        year == instrument->GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, locale) &&
+        year ==
+            instrument->GetInfo(
+                AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR), locale) &&
         month_int == instrument->expiration_month()) {
       // Otherwise, if the user is editing an instrument that's deemed expired
       // by the Online Wallet server, mark it invalid on selection.
       return false;
     }
   }
 
   return true;
 }
 
@@ skipping 480 matching lines @@
     view_->GetUserInput(SECTION_CC_BILLING, &output);
     CreditCard card;
     GetBillingInfoFromOutputs(output, &card, NULL, NULL);
     backing_last_four = card.TypeAndLastFourDigits();
   }
   AutofillCreditCardBubbleController::ShowGeneratedCardUI(
       web_contents(), backing_last_four, full_wallet_->TypeAndLastFourDigits());
 }
 
 }  // namespace autofill