Add support for autofilling radio buttons and checkboxes.

chrome/browser/autofill/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 "chrome/browser/autofill/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 209 matching lines @@
   return UNKNOWN_TYPE;
 }
 
 }  // namespace
 
 FormStructure::FormStructure(const FormData& form)
     : form_name_(form.name),
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
+      checkable_field_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       server_experiment_id_("no server response"),
       has_author_specified_types_(false) {
   // Copy the form fields.
   std::map<string16, size_t> unique_names;
   for (std::vector<FormFieldData>::const_iterator field =
            form.fields.begin();
        field != form.fields.end(); 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));
+    // Skipping checkable elements when flag is not set, else these fields will
+    // interfere with existing field signatures with Autofill servers.
+    // TODO(ramankk): Add checkable elements only on whitelisted pages
+    if (!field->is_checkable ||
+        CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableExperimentalFormFilling)) {
+      // 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));
+    }
 
     // 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
     // guaranteed to avoid collisions.
     if (!unique_names.count(field->name))
       unique_names[field->name] = 1;
     else
       ++unique_names[field->name];
     string16 unique_name = field->name + ASCIIToUTF16("_") +
         base::IntToString16(unique_names[field->name]);
     fields_.push_back(new AutofillField(*field, unique_name));
+
+    if (field->is_checkable)
+      ++checkable_field_count_;
   }
 
   std::string method = UTF16ToUTF8(form.method);
   if (StringToLowerASCII(method) == kFormMethodPost) {
     method_ = POST;
   } else {
     // Either the method is 'get', or we don't know.  In this case we default
     // to GET.
     method_ = GET;
   }
@@ skipping 136 matching lines @@
   return true;
 }
 
 // static
 void FormStructure::ParseQueryResponse(const std::string& response_xml,
                                        const std::vector<FormStructure*>& forms,
                                        const AutofillMetrics& metric_logger) {
   metric_logger.LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_RECEIVED);
 
   // Parse the field types from the server response to the query.
-  std::vector<AutofillFieldType> field_types;
+  std::vector<AutofillServerFieldInfo> field_infos;
   UploadRequired upload_required;
   std::string experiment_id;
-  AutofillQueryXmlParser parse_handler(&field_types, &upload_required,
+  AutofillQueryXmlParser parse_handler(&field_infos, &upload_required,
                                        &experiment_id);
   buzz::XmlParser parser(&parse_handler);
   parser.Parse(response_xml.c_str(), response_xml.length(), true);
   if (!parse_handler.succeeded())
     return;
 
   metric_logger.LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_PARSED);
   metric_logger.LogServerExperimentIdForQuery(experiment_id);
 
   bool heuristics_detected_fillable_field = false;
   bool query_response_overrode_heuristics = false;
 
   // Copy the field types into the actual form.
-  std::vector<AutofillFieldType>::iterator current_type = field_types.begin();
+  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_type) {
+         field != form->fields_.end(); ++field, ++current_info) {
       // In some cases *successful* response does not return all the fields.
       // Quit the update of the types then.
-      if (current_type == field_types.end())
+      if (current_info == field_infos.end())
         break;
 
       // UNKNOWN_TYPE is reserved for use by the client.
-      DCHECK_NE(*current_type, UNKNOWN_TYPE);
+      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_type);
+      (*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);
     }
 
     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 84 matching lines @@
   }
 }
 
 bool FormStructure::ShouldBeParsed(bool require_method_post) const {
   // TODO(ramankk): Remove this check once we have better way of identifying the
   // cases to trigger experimental form filling.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalFormFilling))
     return true;
 
-  if (field_count() < kRequiredFillableFields)
+  // Ignore counting checkable elements towards minimum number of elements
+  // required to parse. This avoids trying to crowdsource forms with few text
+  // or select elements.
+  if ((field_count() - checkable_field_count()) < kRequiredFillableFields)
     return false;
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path() == "/search")
     return false;
 
   // Make sure there as at least one text field.
   bool has_text_field = false;
@@ skipping 241 matching lines @@
 
 AutofillField* FormStructure::field(size_t index) {
   return const_cast<AutofillField*>(
       static_cast<const FormStructure*>(this)->field(index));
 }
 
 size_t FormStructure::field_count() const {
   return fields_.size();
 }
 
+size_t FormStructure::checkable_field_count() const {
+  return checkable_field_count_;
+}
+
 std::string FormStructure::server_experiment_id() const {
   return server_experiment_id_;
 }
 
 FormData FormStructure::ToFormData() const {
   // |data.user_submitted| will always be false.
   FormData data;
   data.name = form_name_;
   data.origin = source_url_;
   data.action = target_url_;
@@ skipping 51 matching lines @@
   // Do not send requests for forms with more than this many fields, as they are
   // near certainly not valid/auto-fillable.
   const size_t kMaxFieldsOnTheForm = 48;
   if (field_count() > kMaxFieldsOnTheForm)
     return false;
 
   // Add the child nodes for the form fields.
   for (size_t index = 0; index < field_count(); ++index) {
     const AutofillField* field = fields_[index];
     if (request_type == FormStructure::UPLOAD) {
+      // Don't upload checkable fields.
+      if (field->is_checkable)
+        continue;
+
       FieldTypeSet types = field->possible_types();
       // |types| could be empty in unit-tests only.
       for (FieldTypeSet::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));
         encompassing_xml_element->AddElement(field_element);
       }
     } else {
+      // Skip putting checkable fields in the request if the flag is not set.
+      if (field->is_checkable &&
+          !CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kEnableExperimentalFormFilling))
+        continue;
+
       buzz::XmlElement *field_element = new buzz::XmlElement(
           buzz::QName(kXMLElementField));
       field_element->SetAttr(buzz::QName(kAttributeSignature),
                              field->FieldSignature());
       encompassing_xml_element->AddElement(field_element);
     }
   }
   return true;
 }
 
@@ skipping 160 matching lines @@
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
     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");
   }
 }