Support autocompletion for HTMl5 tags:"email", "month" and "tel".

chrome/renderer/autofill/form_manager.cc

 // Copyright (c) 2010 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_manager.h"
 
 #include "base/logging.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
@@ skipping 34 matching lines @@
 
 // The number of fields required by AutoFill.  Ideally we could send the forms
 // to AutoFill no matter how many fields are in the forms; however, finding the
 // label for each field is a costly operation and we can't spare the cycles if
 // it's not necessary.
 const size_t kRequiredAutoFillFields = 3;
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
 
-// TODO(isherman): Replace calls to this with IsTextInput() once
-// http://codereview.chromium.org/6033010/ lands.
-bool IsTextElement(const WebFormControlElement& element) {
-  return element.formControlType() == WebString::fromUTF8("text");
+// In HTML5, all text fields except password are text input fields to
+// autocomplete.
+bool IsTextInput(const WebInputElement* element) {
+  if (!element)
+    return false;
+
+  return element->isTextField() && !element->isPasswordField();
 }
 
 bool IsSelectElement(const WebFormControlElement& element) {
   return element.formControlType() == ASCIIToUTF16("select-one");
 }
 
 bool IsOptionElement(const WebElement& element) {
   return element.hasTagName("option");
 }
 
@@ skipping 259 matching lines @@
     ExtractMask extract_mask,
     FormField* field) {
   DCHECK(field);
 
   // The label is not officially part of a WebFormControlElement; however, the
   // labels for all form control elements are scraped from the DOM and set in
   // WebFormElementToFormData.
   field->set_name(element.nameForAutofill());
   field->set_form_control_type(element.formControlType());
 
-  if (IsTextElement(element)) {
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsTextInput(input_element)) {
     const WebInputElement& input_element = element.toConst<WebInputElement>();
     field->set_max_length(input_element.maxLength());
     field->set_autofilled(input_element.isAutofilled());
   } else if (extract_mask & EXTRACT_OPTIONS) {
     // Set option strings on the field if available.
     std::vector<string16> option_strings;
     GetOptionStringsFromElement(element, &option_strings);
     field->set_option_strings(option_strings);
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
     return;
 
   string16 value;
-  if (IsTextElement(element) ||
+  if (IsTextInput(input_element) ||
       element.formControlType() == WebString::fromUTF8("hidden")) {
-    const WebInputElement& input_element = element.toConst<WebInputElement>();
-    value = input_element.value();
+    value = input_element->value();
   } else if (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) {
         if (IsOptionElement(list_items[i])) {
           const WebOptionElement option_element =
@@ skipping 70 matching lines @@
   WebVector<WebFormControlElement> control_elements;
   element.getFormControlElements(control_elements);
 
   // A vector of bools that indicate whether each field in the form meets the
   // 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 (requirements & REQUIRE_AUTOCOMPLETE && IsTextElement(control_element)) {
-      const WebInputElement& input_element =
-          control_element.toConst<WebInputElement>();
-      if (!input_element.autoComplete())
-        continue;
-    }
+    const WebInputElement* input_element = toWebInputElement(&control_element);
+    if (requirements & REQUIRE_AUTOCOMPLETE && IsTextInput(input_element) &&
+        !input_element->autoComplete())
+      continue;
 
     if (requirements & REQUIRE_ENABLED && !control_element.isEnabled())
       continue;
 
     // Create a new FormField, fill it out and map it to the field's name.
     FormField* field = new FormField;
     WebFormControlElementToFormField(control_element, extract_mask, field);
     form_fields.push_back(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
@@ skipping 184 matching lines @@
   return true;
 }
 
 bool FormManager::ClearFormWithNode(const WebNode& node) {
   FormElement* form_element = NULL;
   if (!FindCachedFormElementWithNode(node, &form_element))
     return false;
 
   for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
     WebFormControlElement element = form_element->control_elements[i];
-    if (IsTextElement(element)) {
-      WebInputElement input_element = element.to<WebInputElement>();
+    WebInputElement* input_element = toWebInputElement(&element);
+    if (IsTextInput(input_element)) {
 
       // We don't modify the value of disabled fields.
-      if (!input_element.isEnabled())
+      if (!input_element->isEnabled())
         continue;
 
-      input_element.setValue(string16());
-      input_element.setAutofilled(false);
+      input_element->setValue(string16());
+      input_element->setAutofilled(false);
 
       // Clearing the value in the focused node (above) can cause selection
       // to be lost. We force selection range to restore the text cursor.
-      if (node == input_element) {
-        int length = input_element.value().length();
-        input_element.setSelectionRange(length, length);
+      if (node == *input_element) {
+        int length = input_element->value().length();
+        input_element->setSelectionRange(length, length);
       }
     } else if (IsSelectElement(element)) {
       WebSelectElement select_element = element.to<WebSelectElement>();
       select_element.setValue(form_element->control_values[i]);
     }
   }
 
   return true;
 }
 
 bool FormManager::ClearPreviewedFormWithNode(const WebNode& node,
                                              bool was_autofilled) {
   FormElement* form_element = NULL;
   if (!FindCachedFormElementWithNode(node, &form_element))
     return false;
 
   for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
-    WebFormControlElement* element = &form_element->control_elements[i];
-
+    WebInputElement* input_element =
+        toWebInputElement(&form_element->control_elements[i]);
     // Only text input elements can be previewed.
-    if (!IsTextElement(*element))
+    if (!IsTextInput(input_element))
       continue;
 
     // If the input element has not been auto-filled, FormManager has not
     // previewed this field, so we have nothing to reset.
-    WebInputElement input_element = element->to<WebInputElement>();
-    if (!input_element.isAutofilled())
+    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
     // want to reset the auto-filled status for fields that were previewed.
-    if (input_element.suggestedValue().isEmpty())
+    if (input_element->suggestedValue().isEmpty())
       continue;
 
     // Clear the suggested value. For the initiating node, also restore the
     // original value.
-    input_element.setSuggestedValue(WebString());
-    bool is_initiating_node = (node == input_element);
+    input_element->setSuggestedValue(WebString());
+    bool is_initiating_node = (node == *input_element);
     if (is_initiating_node) {
       // Call |setValue()| to force the renderer to update the field's displayed
       // value.
-      input_element.setValue(input_element.value());
-      input_element.setAutofilled(was_autofilled);
+      input_element->setValue(input_element->value());
+      input_element->setAutofilled(was_autofilled);
     } else {
-      input_element.setAutofilled(false);
+      input_element->setAutofilled(false);
     }
 
     // Clearing the suggested value in the focused node (above) can cause
     // selection to be lost. We force selection range to restore the text
     // cursor.
     if (is_initiating_node) {
-      int length = input_element.value().length();
-      input_element.setSelectionRange(length, length);
+      int length = input_element->value().length();
+      input_element->setSelectionRange(length, length);
     }
   }
 
   return true;
 }
 
 void FormManager::Reset() {
   form_elements_.reset();
 }
 
 void FormManager::ResetFrame(const WebFrame* frame) {
   FormElementList::iterator iter = form_elements_.begin();
   while (iter != form_elements_.end()) {
     if ((*iter)->form_element.document().frame() == frame)
       iter = form_elements_.erase(iter);
     else
       ++iter;
   }
 }
 
 bool FormManager::FormWithNodeIsAutoFilled(const WebNode& node) {
   FormElement* form_element = NULL;
   if (!FindCachedFormElementWithNode(node, &form_element))
     return false;
 
   for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
-    WebFormControlElement element = form_element->control_elements[i];
-    if (!IsTextElement(element))
+    WebInputElement* input_element =
+        toWebInputElement(&form_element->control_elements[i]);
+    if (!IsTextInput(input_element))
       continue;
 
-    const WebInputElement& input_element = element.to<WebInputElement>();
-    if (input_element.isAutofilled())
+    if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 bool FormManager::FindCachedFormElementWithNode(const WebNode& node,
                                                 FormElement** form_element) {
   for (FormElementList::const_iterator form_iter = form_elements_.begin();
        form_iter != form_elements_.end(); ++form_iter) {
@@ skipping 60 matching lines @@
     if (k >= data.fields.size())
       continue;
 
     DCHECK_EQ(data.fields[k].name(), element_name);
 
     bool is_initiating_node = false;
 
     // More than likely |requirements| will contain REQUIRE_AUTOCOMPLETE and/or
     // REQUIRE_EMPTY, which both require text form control elements, so special-
     // case this type of element.
-    if (IsTextElement(*element)) {
-      const WebInputElement& input_element =
-          element->toConst<WebInputElement>();
+    const WebInputElement* input_element = toWebInputElement(element);
+    if (IsTextInput(input_element)) {
 
       // TODO(jhawkins): WebKit currently doesn't handle the autocomplete
       // attribute for select control elements, but it probably should.
-      if (requirements & REQUIRE_AUTOCOMPLETE && !input_element.autoComplete())
+      if (requirements & REQUIRE_AUTOCOMPLETE && !input_element->autoComplete())
         continue;
 
-      is_initiating_node = (input_element == node);
+      is_initiating_node = (*input_element == node);
       // Don't require the node that initiated the auto-fill process to be
       // empty.  The user is typing in this field and we should complete the
       // value when the user selects a value to fill out.
       if (requirements & REQUIRE_EMPTY &&
           !is_initiating_node &&
-          !input_element.value().isEmpty())
+          !input_element->value().isEmpty())
         continue;
     }
 
     if (requirements & REQUIRE_ENABLED && !element->isEnabled())
       continue;
 
     callback->Run(element, &data.fields[k], is_initiating_node);
 
     // We found a matching form field so move on to the next.
     ++j;
   }
 
   delete callback;
 }
 
 void FormManager::FillFormField(WebFormControlElement* field,
                                 const FormField* data,
                                 bool is_initiating_node) {
   // Nothing to fill.
   if (data->value().empty())
     return;
 
-  if (IsTextElement(*field)) {
-    WebInputElement input_element = field->to<WebInputElement>();
+  WebInputElement* input_element = toWebInputElement(field);
+  if (IsTextInput(input_element)) {
 
     // If the maxlength attribute contains a negative value, maxLength()
     // returns the default maxlength value.
-    input_element.setValue(data->value().substr(0, input_element.maxLength()));
-    input_element.setAutofilled(true);
+    input_element->setValue(
+        data->value().substr(0, input_element->maxLength()));
+    input_element->setAutofilled(true);
     if (is_initiating_node) {
-      int length = input_element.value().length();
-      input_element.setSelectionRange(length, length);
+      int length = input_element->value().length();
+      input_element->setSelectionRange(length, length);
     }
   } else if (IsSelectElement(*field)) {
     WebSelectElement select_element = field->to<WebSelectElement>();
     select_element.setValue(data->value());
   }
 }
 
 void FormManager::PreviewFormField(WebFormControlElement* field,
                                    const FormField* data,
                                    bool is_initiating_node) {
   // Nothing to preview.
   if (data->value().empty())
     return;
 
   // Only preview input fields.
-  if (!IsTextElement(*field))
+  WebInputElement* input_element = toWebInputElement(field);
+  if (!IsTextInput(input_element))
     return;
 
-  WebInputElement input_element = field->to<WebInputElement>();
-
   // 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);
+  input_element->setSuggestedValue(
+      data->value().substr(0, input_element->maxLength()));
+  input_element->setAutofilled(true);
   if (is_initiating_node)
-    input_element.setSelectionRange(0, input_element.suggestedValue().length());
+    input_element->setSelectionRange(0,
+                                     input_element->suggestedValue().length());
 }
 
 }  // namespace autofill