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

components/autofill/core/browser/autofill_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/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 132 matching lines @@
     const std::string& app_locale,
     FormStructure* submitted_form) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   // For each field in the |submitted_form|, extract the value.  Then for each
   // profile or credit card, identify any stored types that match the value.
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     AutofillField* field = submitted_form->field(i);
     base::string16 value = CollapseWhitespace(field->value, false);
 
-    FieldTypeSet matching_types;
+    ServerFieldTypeSet matching_types;
     for (std::vector<AutofillProfile>::const_iterator it = profiles.begin();
          it != profiles.end(); ++it) {
       it->GetMatchingTypes(value, app_locale, &matching_types);
     }
     for (std::vector<CreditCard>::const_iterator it = credit_cards.begin();
           it != credit_cards.end(); ++it) {
       it->GetMatchingTypes(value, app_locale, &matching_types);
     }
 
     if (matching_types.empty())
@@ skipping 253 matching lines @@
                               bounding_box,
                               display_warning);
 
   RenderViewHost* host = NULL;
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (GetHost(&host) &&
       GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions for forms that aren't auto-fillable.
       form_structure->IsAutofillable(false)) {
-    AutofillFieldType type = autofill_field->type();
-    bool is_filling_credit_card =
-        (AutofillType(type).group() == CREDIT_CARD);
+    AutofillType type = autofill_field->Type();
+    bool is_filling_credit_card = (type.group() == CREDIT_CARD);
     if (is_filling_credit_card) {
       GetCreditCardSuggestions(
           field, type, &values, &labels, &icons, &unique_ids);
     } else {
       GetProfileSuggestions(
           form_structure, field, type, &values, &labels, &icons, &unique_ids);
     }
 
     DCHECK_EQ(values.size(), labels.size());
     DCHECK_EQ(values.size(), icons.size());
@@ skipping 87 matching lines @@
         autofill_field->is_autofilled = true;
         break;
       }
     }
 
     driver_->SendFormDataToRenderer(query_id, result);
     return;
   }
 
   // Cache the field type for the field from which the user initiated autofill.
-  FieldTypeGroup initiating_group_type =
-      AutofillType(autofill_field->type()).group();
+  FieldTypeGroup initiating_group_type = autofill_field->Type().group();
   DCHECK_EQ(form_structure->field_count(), form.fields.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i) {
     if (form_structure->field(i)->section() != autofill_field->section())
       continue;
 
     DCHECK_EQ(*form_structure->field(i), result.fields[i]);
 
     const AutofillField* cached_field = form_structure->field(i);
-    FieldTypeGroup field_group_type =
-        AutofillType(cached_field->type()).group();
+    FieldTypeGroup field_group_type = cached_field->Type().group();
     if (field_group_type != NO_GROUP) {
       // If the field being filled is either
       //   (a) the field that the user initiated the fill from, or
       //   (b) part of the same logical unit, e.g. name or phone number,
       // then take the multi-profile "variant" into account.
       // Otherwise fill with the default (zeroth) variant.
       size_t use_variant = 0;
       if (result.fields[i] == field ||
           field_group_type == initiating_group_type) {
         use_variant = variant;
@@ skipping 291 matching lines @@
   bool was_autofilled = false;
   std::string form_signature = submitted_form.FormSignature();
   for (std::list<std::string>::const_iterator it =
            autofilled_form_signatures_.begin();
        it != autofilled_form_signatures_.end() && !was_autofilled;
        ++it) {
     if (*it == form_signature)
       was_autofilled = true;
   }
 
-  FieldTypeSet non_empty_types;
+  ServerFieldTypeSet non_empty_types;
   personal_data_->GetNonEmptyTypes(&non_empty_types);
 
   download_manager_->StartUploadRequest(submitted_form, was_autofilled,
                                        non_empty_types);
 }
 
 void AutofillManager::Reset() {
   form_structures_.clear();
   has_logged_autofill_enabled_ = false;
   has_logged_address_suggestions_count_ = false;
@@ skipping 193 matching lines @@
   // Annotate the updated form with its predicted types.
   std::vector<FormStructure*> forms(1, *updated_form);
   driver_->SendAutofillTypePredictionsToRenderer(forms);
 
   return true;
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
     const FormFieldData& field,
-    AutofillFieldType type,
+    const AutofillType& type,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
-  std::vector<AutofillFieldType> field_types(form->field_count());
+  std::vector<ServerFieldType> field_types(form->field_count());
   for (size_t i = 0; i < form->field_count(); ++i) {
-    field_types[i] = form->field(i)->type();
+    field_types.push_back(form->field(i)->Type().server_type());
   }
   std::vector<GUIDPair> guid_pairs;
 
   personal_data_->GetProfileSuggestions(
       type, field.value, field.is_autofilled, field_types,
       values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
                                     guid_pairs[i]));
   }
 }
 
 void AutofillManager::GetCreditCardSuggestions(
     const FormFieldData& field,
-    AutofillFieldType type,
+    const AutofillType& type,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
   std::vector<GUIDPair> guid_pairs;
   personal_data_->GetCreditCardSuggestions(
       type, field.value, values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
@@ skipping 105 matching lines @@
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
 }  // namespace autofill