Field's server type mapping (using Autofill server response) for forms with checkable elements/pass…

components/autofill/browser/form_structure.cc

 // Copyright (c) 2012 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/browser/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 287 matching lines @@
       server_experiment_id_("no server response"),
       has_author_specified_types_(false),
       autocheckout_url_prefix_(autocheckout_url_prefix),
       filled_by_autocheckout_(false) {
   // Copy the form fields.
   std::map<base::string16, size_t> unique_names;
   for (std::vector<FormFieldData>::const_iterator field =
            form.fields.begin();
        field != form.fields.end(); field++) {
 
-    // Skip checkable and password elements when Autocheckout is not enabled,
-    // else these fields will interfere with existing field signatures with
-    // Autofill servers.
-    if ((!field->is_checkable && field->form_control_type != "password") ||
-        IsAutocheckoutEnabled()) {
+    if (!ShouldSkipField(*field)) {
       // Add all supported form fields (including with empty names) to the
       // signature.  This is a requirement for Autofill servers.
       form_signature_field_names_.append("&");
       form_signature_field_names_.append(UTF16ToUTF8(field->name));
 
       ++active_field_count_;
     }
 
     // Generate a unique name for this field by appending a counter to the name.
     // Make sure to prepend the counter with a non-numeric digit so that we are
@@ skipping 229 matching lines @@
   // Copy the field types into the actual form.
   std::vector<AutofillServerFieldInfo>::iterator current_info =
       field_infos.begin();
   for (std::vector<FormStructure*>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     FormStructure* form = *iter;
     form->upload_required_ = upload_required;
     form->server_experiment_id_ = experiment_id;
 
     for (std::vector<AutofillField*>::iterator field = form->fields_.begin();
-         field != form->fields_.end(); ++field, ++current_info) {
+         field != form->fields_.end(); ++field) {
+      if (form->ShouldSkipField(**field))
+        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();
       if (heuristic_type != UNKNOWN_TYPE)
         heuristics_detected_fillable_field = true;
 
       (*field)->set_server_type(current_info->field_type);
       if (heuristic_type != (*field)->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();
     form->IdentifySections(false);
   }
 
   AutofillMetrics::ServerQueryMetric metric;
   if (query_response_overrode_heuristics) {
     if (heuristics_detected_fillable_field) {
       metric = AutofillMetrics::QUERY_RESPONSE_OVERRODE_LOCAL_HEURISTICS;
@@ skipping 58 matching lines @@
                             UTF16ToUTF8(form_name_) +
                             form_signature_field_names_;
 
   return Hash64Bit(form_string);
 }
 
 bool FormStructure::IsAutocheckoutEnabled() const {
   return !autocheckout_url_prefix_.empty();
 }
 
+bool FormStructure::ShouldSkipField(const FormFieldData field) const {
+  return (field.is_checkable || field.form_control_type == "password") &&
+      !IsAutocheckoutEnabled();
+}
+
 size_t FormStructure::RequiredFillableFields() const {
   return IsAutocheckoutEnabled() ? 0 : kRequiredAutofillFields;
 }
 
 bool FormStructure::IsAutofillable(bool require_method_post) const {
   if (autofill_count() < RequiredFillableFields())
     return false;
 
   return ShouldBeParsed(require_method_post);
 }
@@ skipping 349 matching lines @@
     return false;
 
   // Add the child nodes for the form fields.
   for (size_t index = 0; index < field_count(); ++index) {
     const AutofillField* field = fields_[index];
     switch (request_type) {
       case FormStructure::UPLOAD:
         EncodeFieldForUpload(*field, encompassing_xml_element);
         break;
       case FormStructure::QUERY:
-        // Skip putting checkable and password fields in the request if
-        // Autocheckout is not enabled.
-        if ((field->is_checkable || field->form_control_type == "password") &&
-            !IsAutocheckoutEnabled())
+        if (ShouldSkipField(*field))
           continue;
         EncodeFieldForQuery(*field, encompassing_xml_element);
         break;
       case FormStructure::FIELD_ASSIGNMENTS:
         EncodeFieldForFieldAssignments(*field, encompassing_xml_element);
         break;
     }
   }
   return true;
 }
@@ skipping 167 matching lines @@
     AutofillType::FieldTypeGroup field_type_group =
         AutofillType((*field)->type()).group();
     if (field_type_group == AutofillType::CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }
 
 }  // namespace autofill