Add support for autofilling radio buttons and checkboxes.

chrome/renderer/autofill/form_autofill_util.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/renderer/autofill/form_autofill_util.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 24 matching lines @@
 using WebKit::WebNode;
 using WebKit::WebNodeList;
 using WebKit::WebOptionElement;
 using WebKit::WebSelectElement;
 using WebKit::WebString;
 using WebKit::WebVector;
 
 namespace {
 
 using autofill::ExtractAutofillableElements;
+using autofill::IsAutofillableInputElement;
+using autofill::IsCheckboxElement;
+using autofill::IsRadioButtonElement;
+using autofill::IsSelectElement;
 using autofill::IsTextInput;
-using autofill::IsSelectElement;
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
 
 bool IsOptionElement(const WebElement& element) {
   return element.hasTagName("option");
 }
 
 bool IsScriptElement(const WebElement& element) {
   return element.hasTagName("script");
 }
 
 bool IsNoScriptElement(const WebElement& element) {
   return element.hasTagName("noscript");
 }
 
 bool HasTagName(const WebNode& node, const WebKit::WebString& tag) {
   return node.isElementNode() && node.toConst<WebElement>().hasTagName(tag);
 }
 
 bool IsAutofillableElement(const WebFormControlElement& element) {
   const WebInputElement* input_element = toWebInputElement(&element);
-  return IsTextInput(input_element) || IsSelectElement(element);
+  return IsAutofillableInputElement(input_element) || IsSelectElement(element);
 }
 
 // Appends |suffix| to |prefix| so that any intermediary whitespace is collapsed
 // to a single space.  If |force_whitespace| is true, then the resulting string
 // is guaranteed to have a space between |prefix| and |suffix|.  Otherwise, the
 // result includes a space only if |prefix| has trailing whitespace or |suffix|
 // has leading whitespace.
 // A few examples:
 //  * CombineAndCollapseWhitespace("foo", "bar", false)       -> "foobar"
 //  * CombineAndCollapseWhitespace("foo", "bar", true)        -> "foo bar"
@@ skipping 371 matching lines @@
       // popup.  I (isherman) am not aware of any such websites, and so am
       // optimistically including a NOTREACHED().  If you ever trip this check,
       // please file a bug against me.
       NOTREACHED();
       continue;
     }
 
     bool is_initiating_element = (*element == initiating_element);
 
     const WebInputElement* input_element = toWebInputElement(element);
-    if (IsTextInput(input_element)) {
+    if (IsAutofillableInputElement(input_element)) {
       // Only autofill empty fields and the field that initiated the filling,
       // i.e. the field the user is currently editing and interacting with.
-      if (!is_initiating_element && !input_element->value().isEmpty())
+      if (!is_initiating_element && IsTextInput(input_element) &&
+          !input_element->value().isEmpty())
         continue;
     }
 
     if (!element->isEnabled() || element->isReadOnly() ||
         !element->isFocusable())
       continue;
 
     callback(element, &data.fields[i], is_initiating_element);
   }
 }
@@ skipping 13 matching lines @@
     // returns the default maxlength value.
     input_element->setValue(
         data->value.substr(0, input_element->maxLength()), true);
     input_element->setAutofilled(true);
     if (is_initiating_node) {
       int length = input_element->value().length();
       input_element->setSelectionRange(length, length);
       // Clear the current IME composition (the underline), if there is one.
       input_element->document().frame()->unmarkText();
     }
-  } else {
-    DCHECK(IsSelectElement(*field));
+  } else if (IsSelectElement(*field)) {
     WebSelectElement select_element = field->to<WebSelectElement>();
     if (select_element.value() != data->value) {
       select_element.setValue(data->value);
       select_element.dispatchFormControlChangeEvent();
     }
+  } else {
+    DCHECK(IsRadioButtonElement(input_element) ||
+           IsCheckboxElement(input_element));
+    input_element->setChecked(data->is_checked, true);
   }
 }
 
 // Sets the |field|'s "suggested" (non JS visible) value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void PreviewFormField(WebKit::WebFormControlElement* field,
                       const FormFieldData* data,
                       bool is_initiating_node) {
   // Nothing to preview.
   if (data->value.empty())
     return;
 
   // Only preview input fields.
   WebInputElement* input_element = toWebInputElement(field);
+  // Don't preview checkboxes and radio buttons, as there is no provision for
+  // setSuggestedCheckedValue in WebInputElement.
   if (!IsTextInput(input_element))
     return;
 
   // If the maxlength attribute contains a negative value, maxLength()
   // returns the default maxlength value.
   input_element->setSuggestedValue(
       data->value.substr(0, input_element->maxLength()));
   input_element->setAutofilled(true);
   if (is_initiating_node) {
     // Select the part of the text that the user didn't type.
@@ skipping 14 matching lines @@
   if (!element)
     return false;
 
   return element->isTextField() && !element->isPasswordField();
 }
 
 bool IsSelectElement(const WebFormControlElement& element) {
   return element.formControlType() == ASCIIToUTF16("select-one");
 }
 
+bool IsCheckboxElement(const WebInputElement* element) {
+  if (!element)
+    return false;
+
+  return element->formControlType() == ASCIIToUTF16("checkbox");
+}
+
+bool IsRadioButtonElement(const WebInputElement* element) {
+  if (!element)
+    return false;
+
+  return element->formControlType() == ASCIIToUTF16("radio");
+}
+
+bool IsAutofillableInputElement(const WebInputElement* element) {
+  return IsTextInput(element) || IsCheckboxElement(element) ||
+      IsRadioButtonElement(element);
+}
+
 const string16 GetFormIdentifier(const WebFormElement& form) {
   string16 identifier = form.name();
   if (identifier.empty())
     identifier = form.getAttribute(WebString("id"));
 
   return identifier;
 }
 
 // Fills |autofillable_elements| with all the auto-fillable form control
 // elements in |form_element|.
 void ExtractAutofillableElements(
     const WebFormElement& form_element,
     RequirementsMask requirements,
     std::vector<WebFormControlElement>* autofillable_elements) {
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   autofillable_elements->clear();
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement element = control_elements[i];
     if (!IsAutofillableElement(element))
       continue;
 
     if (requirements & REQUIRE_AUTOCOMPLETE) {
       // TODO(jhawkins): WebKit currently doesn't handle the autocomplete
       // attribute for select control elements, but it probably should.
       WebInputElement* input_element = toWebInputElement(&control_elements[i]);
-      if (IsTextInput(input_element) && !input_element->autoComplete())
+      if (IsAutofillableInputElement(input_element) &&
+          !input_element->autoComplete())
         continue;
     }
 
     autofillable_elements->push_back(element);
   }
 }
 
 void WebFormControlElementToFormField(const WebFormControlElement& element,
                                       ExtractMask extract_mask,
                                       FormFieldData* field) {
@@ skipping 11 matching lines @@
     // Discard overly long attribute values to avoid DOS-ing the browser
     // process.  However, send over a default string to indicate that the
     // attribute was present.
     field->autocomplete_attribute = "x-max-data-length-exceeded";
   }
 
   if (!IsAutofillableElement(element))
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
-  if (IsTextInput(input_element)) {
+  if (IsAutofillableInputElement(input_element)) {
     field->max_length = input_element->maxLength();
     field->is_autofilled = input_element->isAutofilled();
     field->is_focusable = input_element->isFocusable();
     field->should_autocomplete = input_element->autoComplete();
+    if (IsRadioButtonElement(input_element) ||
+        IsCheckboxElement(input_element)) {
+      field->is_checkable = true;
+    }
   } else if (extract_mask & EXTRACT_OPTIONS) {
     // Set option strings on the field if available.
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     GetOptionStringsFromElement(select_element,
                                 &field->option_values,
                                 &field->option_contents);
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
     return;
 
   string16 value;
-  if (IsTextInput(input_element)) {
+  if (IsAutofillableInputElement(input_element)) {
     value = input_element->value();
   } else {
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     value = select_element.value();
 
     // Convert the |select_element| value to text if requested.
     if (extract_mask & EXTRACT_OPTION_TEXT) {
       WebVector<WebElement> list_items = select_element.listItems();
       for (size_t i = 0; i < list_items.size(); ++i) {
@@ skipping 56 matching lines @@
   // requirements and thus will be in the resulting |form|.
   std::vector<bool> fields_extracted(control_elements.size(), false);
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     const WebFormControlElement& control_element = control_elements[i];
 
     if (!IsAutofillableElement(control_element))
       continue;
 
     const WebInputElement* input_element = toWebInputElement(&control_element);
-    if (requirements & REQUIRE_AUTOCOMPLETE && IsTextInput(input_element) &&
+    if (requirements & REQUIRE_AUTOCOMPLETE &&
+        IsAutofillableInputElement(input_element) &&
         !input_element->autoComplete())
       continue;
 
     // Create a new FormFieldData, fill it out and map it to the field's name.
     FormFieldData* form_field = new FormFieldData;
     WebFormControlElementToFormField(control_element, extract_mask, form_field);
     form_fields.push_back(form_field);
     // TODO(jhawkins): A label element is mapped to a form control element's id.
     // field->name() will contain the id only if the name does not exist.  Add
     // an id() method to WebFormControlElement and use that here.
@@ skipping 121 matching lines @@
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
                               &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     // Only text input elements can be previewed.
     WebInputElement* input_element = toWebInputElement(&control_elements[i]);
-    if (!IsTextInput(input_element))
+    if (!IsAutofillableInputElement(input_element))
       continue;
 
     // If the input element is not auto-filled, we did not preview it, so there
     // is nothing to reset.
     if (!input_element->isAutofilled())
       continue;
 
     // There might be unrelated elements in this form which have already been
     // auto-filled.  For example, the user might have already filled the address
     // part of a form and now be dealing with the credit card section.  We only
@@ skipping 25 matching lines @@
 bool FormWithElementIsAutofilled(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
                               &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebInputElement* input_element = toWebInputElement(&control_elements[i]);
-    if (!IsTextInput(input_element))
+    if (!IsAutofillableInputElement(input_element))
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 }  // namespace autofill