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

components/autofill/core/browser/form_structure.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/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
 const char kXMLElementFields[] = "fields";
 const char kXMLElementForm[] = "form";
 const char kBillingSection[] = "billing";
 const char kShippingSection[] = "shipping";
 
 // Stip away >= 5 consecutive digits.
 const char kIgnorePatternInFieldName[] = "\\d{5,}+";
 
 // Helper for |EncodeUploadRequest()| that creates a bit field corresponding to
 // |available_field_types| and returns the hex representation as a string.
-std::string EncodeFieldTypes(const FieldTypeSet& available_field_types) {
+std::string EncodeFieldTypes(const ServerFieldTypeSet& available_field_types) {
   // There are |MAX_VALID_FIELD_TYPE| different field types and 8 bits per byte,
   // so we need ceil(MAX_VALID_FIELD_TYPE / 8) bytes to encode the bit field.
   const size_t kNumBytes = (MAX_VALID_FIELD_TYPE + 0x7) / 8;
 
   // Pack the types in |available_field_types| into |bit_field|.
   std::vector<uint8> bit_field(kNumBytes, 0);
-  for (FieldTypeSet::const_iterator field_type = available_field_types.begin();
+  for (ServerFieldTypeSet::const_iterator field_type =
+           available_field_types.begin();
        field_type != available_field_types.end();
        ++field_type) {
     // Set the appropriate bit in the field.  The bit we set is the one
     // |field_type| % 8 from the left of the byte.
     const size_t byte = *field_type / 8;
     const size_t bit = 0x80 >> (*field_type % 8);
     DCHECK(byte < bit_field.size());
     bit_field[byte] |= bit;
   }
 
@@ skipping 14 matching lines @@
 }
 
 // Helper for |EncodeFormRequest()| that creates XmlElements for the given field
 // in upload xml, and also add them to the parent XmlElement.
 void EncodeFieldForUpload(const AutofillField& field,
                           buzz::XmlElement* parent) {
   // Don't upload checkable fields.
   if (field.is_checkable)
     return;
 
-  FieldTypeSet types = field.possible_types();
+  ServerFieldTypeSet types = field.possible_types();
   // |types| could be empty in unit-tests only.
-  for (FieldTypeSet::iterator field_type = types.begin();
+  for (ServerFieldTypeSet::iterator field_type = types.begin();
        field_type != types.end(); ++field_type) {
     buzz::XmlElement *field_element = new buzz::XmlElement(
         buzz::QName(kXMLElementField));
 
     field_element->SetAttr(buzz::QName(kAttributeSignature),
                            field.FieldSignature());
     field_element->SetAttr(buzz::QName(kAttributeAutofillType),
                            base::IntToString(*field_type));
     parent->AddElement(field_element);
   }
 }
 
 // Helper for |EncodeFormRequest()| that creates XmlElement for the given field
 // in query xml, and also add it to the parent XmlElement.
 void EncodeFieldForQuery(const AutofillField& field,
                          buzz::XmlElement* parent) {
   buzz::XmlElement *field_element = new buzz::XmlElement(
       buzz::QName(kXMLElementField));
   field_element->SetAttr(buzz::QName(kAttributeSignature),
                          field.FieldSignature());
   parent->AddElement(field_element);
 }
 
 // Helper for |EncodeFormRequest()| that creates XmlElements for the given field
 // in field assignments xml, and also add them to the parent XmlElement.
 void EncodeFieldForFieldAssignments(const AutofillField& field,
                                     buzz::XmlElement* parent) {
-  FieldTypeSet types = field.possible_types();
-  for (FieldTypeSet::iterator field_type = types.begin();
+  ServerFieldTypeSet types = field.possible_types();
+  for (ServerFieldTypeSet::iterator field_type = types.begin();
        field_type != types.end(); ++field_type) {
     buzz::XmlElement *field_element = new buzz::XmlElement(
         buzz::QName(kXMLElementFields));
 
     field_element->SetAttr(buzz::QName(kAttributeFieldID),
                            field.FieldSignature());
     field_element->SetAttr(buzz::QName(kAttributeFieldType),
                            base::IntToString(*field_type));
     field_element->SetAttr(buzz::QName(kAttributeName),
                            UTF16ToUTF8(field.name));
     parent->AddElement(field_element);
   }
 }
 
 // Returns |true| iff the |token| is a type hint for a contact field, as
 // specified in the implementation section of http://is.gd/whatwg_autocomplete
 // Note that "fax" and "pager" are intentionally ignored, as Chrome does not
 // support filling either type of information.
 bool IsContactTypeHint(const std::string& token) {
   return token == "home" || token == "work" || token == "mobile";
 }
 
 // Returns |true| iff the |token| is a type hint appropriate for a field of the
 // given |field_type|, as specified in the implementation section of
 // http://is.gd/whatwg_autocomplete
+// TODO(isherman): This should use HTML field types, not native ones.
 bool ContactTypeHintMatchesFieldType(const std::string& token,
-                                     AutofillFieldType field_type) {
+                                     ServerFieldType field_type) {
   // The "home" and "work" type hints are only appropriate for email and phone
   // number field types.
   if (token == "home" || token == "work") {
     return field_type == EMAIL_ADDRESS ||
         (field_type >= PHONE_HOME_NUMBER &&
          field_type <= PHONE_HOME_WHOLE_NUMBER);
   }
 
   // The "mobile" type hint is only appropriate for phone number field types.
   // Note that "fax" and "pager" are intentionally ignored, as Chrome does not
   // support filling either type of information.
   if (token == "mobile") {
     return field_type >= PHONE_HOME_NUMBER &&
         field_type <= PHONE_HOME_WHOLE_NUMBER;
   }
 
   return false;
 }
 
 // Returns the Chrome Autofill-supported field type corresponding to the given
 // |autocomplete_type|, if there is one, in the context of the given |field|.
 // Chrome Autofill supports a subset of the field types listed at
 // http://is.gd/whatwg_autocomplete
-AutofillFieldType FieldTypeFromAutocompleteType(
+// TODO(isherman): This should use HTML field types, not native ones.
+ServerFieldType FieldTypeFromAutocompleteType(
     const std::string& autocomplete_type,
     const AutofillField& field) {
   if (autocomplete_type == "name")
     return NAME_FULL;
 
   if (autocomplete_type == "given-name")
     return NAME_FIRST;
 
   if (autocomplete_type == "additional-name") {
     if (field.max_length == 1)
@@ skipping 169 matching lines @@
   // First, try to detect field types based on each field's |autocomplete|
   // attribute value.  If there is at least one form field that specifies an
   // autocomplete type hint, don't try to apply other heuristics to match fields
   // in this form.
   bool has_author_specified_sections;
   ParseFieldTypesFromAutocompleteAttributes(PARSE_FOR_AUTOFILL,
                                             &has_author_specified_types_,
                                             &has_author_specified_sections);
 
   if (!has_author_specified_types_) {
-    FieldTypeMap field_type_map;
+    ServerFieldTypeMap field_type_map;
     FormField::ParseFormFields(fields_.get(), &field_type_map);
-    for (size_t index = 0; index < field_count(); index++) {
-      AutofillField* field = fields_[index];
-      FieldTypeMap::iterator iter = field_type_map.find(field->unique_name());
+    for (size_t i = 0; i < field_count(); ++i) {
+      AutofillField* field = fields_[i];
+      ServerFieldTypeMap::iterator iter =
+          field_type_map.find(field->unique_name());
       if (iter != field_type_map.end())
         field->set_heuristic_type(iter->second);
     }
   }
 
   UpdateAutofillCount();
   IdentifySections(has_author_specified_sections);
 
   if (IsAutofillable(true)) {
     metric_logger.LogDeveloperEngagementMetric(
         AutofillMetrics::FILLABLE_FORM_PARSED);
     if (has_author_specified_types_) {
       metric_logger.LogDeveloperEngagementMetric(
           AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS);
     }
   }
 }
 
 bool FormStructure::EncodeUploadRequest(
-    const FieldTypeSet& available_field_types,
+    const ServerFieldTypeSet& available_field_types,
     bool form_was_autofilled,
     std::string* encoded_xml) const {
   DCHECK(ShouldBeCrowdsourced());
 
   // Verify that |available_field_types| agrees with the possible field types we
   // are uploading.
   for (std::vector<AutofillField*>::const_iterator field = begin();
        field != end();
        ++field) {
-    for (FieldTypeSet::const_iterator type = (*field)->possible_types().begin();
+    for (ServerFieldTypeSet::const_iterator type =
+             (*field)->possible_types().begin();
          type != (*field)->possible_types().end();
          ++type) {
       DCHECK(*type == UNKNOWN_TYPE ||
              *type == EMPTY_TYPE ||
              available_field_types.count(*type));
     }
   }
 
   // Set up the <autofillupload> element and its attributes.
   buzz::XmlElement autofill_request_xml(
@@ skipping 14 matching lines @@
   *encoded_xml = kXMLDeclaration;
   *encoded_xml += autofill_request_xml.Str().c_str();
 
   // To enable this logging, run with the flag --vmodule="form_structure=2".
   VLOG(2) << "\n" << *encoded_xml;
 
   return true;
 }
 
 bool FormStructure::EncodeFieldAssignments(
-    const FieldTypeSet& available_field_types,
+    const ServerFieldTypeSet& available_field_types,
     std::string* encoded_xml) const {
   DCHECK(ShouldBeCrowdsourced());
 
   // Set up the <fieldassignments> element and its attributes.
   buzz::XmlElement autofill_request_xml(
       (buzz::QName(kXMLElementFieldAssignments)));
   autofill_request_xml.SetAttr(buzz::QName(kAttributeFormSignature),
                                FormSignature());
 
   if (!EncodeFormRequest(FormStructure::FIELD_ASSIGNMENTS,
@@ skipping 128 matching lines @@
         continue;
 
       // In some cases *successful* response does not return all the fields.
       // Quit the update of the types then.
       if (current_info == field_infos.end())
         break;
 
       // UNKNOWN_TYPE is reserved for use by the client.
       DCHECK_NE(current_info->field_type, UNKNOWN_TYPE);
 
-      AutofillFieldType heuristic_type = (*field)->type();
+      ServerFieldType heuristic_type = (*field)->heuristic_type();
       if (heuristic_type != UNKNOWN_TYPE)
         heuristics_detected_fillable_field = true;
 
       (*field)->set_server_type(current_info->field_type);
-      if (heuristic_type != (*field)->type())
+      if (heuristic_type != (*field)->Type().server_type())
         query_response_overrode_heuristics = true;
 
       // Copy default value into the field if available.
       if (!current_info->default_value.empty())
         (*field)->set_default_value(current_info->default_value);
 
       ++current_info;
     }
 
     form->UpdateAutofillCount();
@@ skipping 35 matching lines @@
          field != form_structure->fields_.end(); ++field) {
       form.data.fields.push_back(FormFieldData(**field));
 
       FormFieldDataPredictions annotated_field;
       annotated_field.signature = (*field)->FieldSignature();
       annotated_field.heuristic_type =
           AutofillType::FieldTypeToString((*field)->heuristic_type());
       annotated_field.server_type =
           AutofillType::FieldTypeToString((*field)->server_type());
       annotated_field.overall_type =
-          AutofillType::FieldTypeToString((*field)->type());
+          AutofillType::FieldTypeToString((*field)->Type().server_type());
       form.fields.push_back(annotated_field);
     }
 
     forms->push_back(form);
   }
 }
 
 std::string FormStructure::FormSignature() const {
   std::string scheme(target_url_.scheme());
   std::string host(target_url_.host());
@@ skipping 127 matching lines @@
   size_t num_detected_field_types = 0;
   bool did_autofill_all_possible_fields = true;
   bool did_autofill_some_possible_fields = false;
   for (size_t i = 0; i < field_count(); ++i) {
     const AutofillField* field = this->field(i);
     metric_logger.LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED,
                                    experiment_id);
 
     // No further logging for empty fields nor for fields where the entered data
     // does not appear to already exist in the user's stored Autofill data.
-    const FieldTypeSet& field_types = field->possible_types();
+    const ServerFieldTypeSet& field_types = field->possible_types();
     DCHECK(!field_types.empty());
     if (field_types.count(EMPTY_TYPE) || field_types.count(UNKNOWN_TYPE))
       continue;
 
     ++num_detected_field_types;
     if (field->is_autofilled)
       did_autofill_some_possible_fields = true;
     else
       did_autofill_all_possible_fields = false;
 
     // Collapse field types that Chrome treats as identical, e.g. home and
     // billing address fields.
-    FieldTypeSet collapsed_field_types;
-    for (FieldTypeSet::const_iterator it = field_types.begin();
+    ServerFieldTypeSet collapsed_field_types;
+    for (ServerFieldTypeSet::const_iterator it = field_types.begin();
          it != field_types.end();
          ++it) {
       // Since we currently only support US phone numbers, the (city code + main
       // digits) number is almost always identical to the whole phone number.
       // TODO(isherman): Improve this logic once we add support for
       // international numbers.
       if (*it == PHONE_HOME_CITY_AND_NUMBER)
         collapsed_field_types.insert(PHONE_HOME_WHOLE_NUMBER);
       else
         collapsed_field_types.insert(AutofillType::GetEquivalentFieldType(*it));
     }
 
     // Capture the field's type, if it is unambiguous.
-    AutofillFieldType field_type = UNKNOWN_TYPE;
+    ServerFieldType field_type = UNKNOWN_TYPE;
     if (collapsed_field_types.size() == 1)
       field_type = *collapsed_field_types.begin();
 
-    AutofillFieldType heuristic_type = field->heuristic_type();
-    AutofillFieldType server_type = field->server_type();
-    AutofillFieldType predicted_type = field->type();
+    ServerFieldType heuristic_type = field->heuristic_type();
+    ServerFieldType server_type = field->server_type();
+    ServerFieldType predicted_type = field->Type().server_type();
 
     // Log heuristic, server, and overall type quality metrics, independently of
     // whether the field was autofilled.
     if (heuristic_type == UNKNOWN_TYPE) {
       metric_logger.LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
                                                field_type, experiment_id);
     } else if (field_types.count(heuristic_type)) {
       metric_logger.LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
                                                field_type, experiment_id);
     } else {
@@ skipping 266 matching lines @@
     // Tokenize the attribute value.  Per the spec, the tokens are parsed in
     // reverse order.
     std::vector<std::string> tokens;
     Tokenize(autocomplete_attribute, " ", &tokens);
 
     // The final token must be the field type.
     // If it is not one of the known types, abort.
     DCHECK(!tokens.empty());
     std::string field_type_token = tokens.back();
     tokens.pop_back();
-    AutofillFieldType field_type =
+    ServerFieldType field_type =
         FieldTypeFromAutocompleteType(field_type_token, *field);
     if (field_type == UNKNOWN_TYPE)
       continue;
 
     // The preceding token, if any, may be a type hint.
     if (!tokens.empty() && IsContactTypeHint(tokens.back())) {
       // If it is, it must match the field type; otherwise, abort.
       // Note that an invalid token invalidates the entire attribute value, even
       // if the other tokens are valid.
       if (!ContactTypeHintMatchesFieldType(tokens.back(), field_type))
@@ skipping 57 matching lines @@
 
 void FormStructure::IdentifySections(bool has_author_specified_sections) {
   if (fields_.empty())
     return;
 
   if (!has_author_specified_sections) {
     // Name sections after the first field in the section.
     base::string16 current_section = fields_.front()->unique_name();
 
     // Keep track of the types we've seen in this section.
-    std::set<AutofillFieldType> seen_types;
-    AutofillFieldType previous_type = UNKNOWN_TYPE;
+    std::set<ServerFieldType> seen_types;
+    ServerFieldType previous_type = UNKNOWN_TYPE;
 
     for (std::vector<AutofillField*>::iterator field = fields_.begin();
          field != fields_.end(); ++field) {
-      const AutofillFieldType current_type =
-          AutofillType::GetEquivalentFieldType((*field)->type());
+      const ServerFieldType current_type =
+          AutofillType::GetEquivalentFieldType((*field)->Type().server_type());
 
       bool already_saw_current_type = seen_types.count(current_type) > 0;
 
       // Forms often ask for multiple phone numbers -- e.g. both a daytime and
       // evening phone number.  Our phone number detection is also generally a
       // little off.  Hence, ignore this field type as a signal here.
       if (AutofillType(current_type).group() == PHONE_HOME)
         already_saw_current_type = false;
 
       // Some forms have adjacent fields of the same type.  Two common examples:
@@ skipping 18 matching lines @@
 
       seen_types.insert(current_type);
       (*field)->set_section(UTF16ToUTF8(current_section));
     }
   }
 
   // Ensure that credit card and address fields are in separate sections.
   // This simplifies the section-aware logic in autofill_manager.cc.
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
-    FieldTypeGroup field_type_group = AutofillType((*field)->type()).group();
+    FieldTypeGroup field_type_group = (*field)->Type().group();
     if (field_type_group == CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }
 
 }  // namespace autofill