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

chrome/renderer/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/form_manager.h"
 
 #include "base/logging.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
@@ skipping 255 matching lines @@
     // For select-one elements copy option strings.
     WebVector<WebElement> list_items = select_element.listItems();
     option_strings->reserve(list_items.size());
     for (size_t i = 0; i < list_items.size(); ++i) {
       if (list_items[i].hasTagName("option"))
         option_strings->push_back(list_items[i].to<WebOptionElement>().value());
     }
   }
 }
 
+// In HTML5, email,month and tel are text input field to autocomplete.

[James Hawkins, 2011/01/03 19:50:00]

space after comma

+static bool IsTextInput(const WebFormControlElement& element) {
+  const static char* type_names[] = {"text", "email", "tel", "month"};
+  for (size_t i = 0; i < sizeof(type_names)/sizeof(const char*); ++i) {
+    if (element.formControlType() == WebString::fromUTF8(type_names[i]))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 struct FormManager::FormElement {
   WebKit::WebFormElement form_element;
   std::vector<WebKit::WebFormControlElement> control_elements;
   std::vector<string16> control_values;
 };
 
 FormManager::FormManager() {
 }
@@ skipping 15 matching lines @@
   field->set_name(element.nameForAutofill());
   field->set_form_control_type(element.formControlType());
 
   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 (element.formControlType() == WebString::fromUTF8("text")) {
+  if (IsTextInput(element)) {
     const WebInputElement& input_element = element.toConst<WebInputElement>();
     field->set_max_length(input_element.maxLength());
     field->set_autofilled(input_element.isAutofilled());
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
     return;
 
   // TODO(jhawkins): In WebKit, move value() and setValue() to
   // WebFormControlElement.
   string16 value;
-  if (element.formControlType() == WebString::fromUTF8("text") ||
+  if (IsTextInput(element) ||
       element.formControlType() == WebString::fromUTF8("hidden")) {
     const WebInputElement& input_element =
         element.toConst<WebInputElement>();
     value = input_element.value();
   } else if (element.formControlType() == WebString::fromUTF8("select-one")) {
     // TODO(jhawkins): This is ugly.  WebSelectElement::value() is a non-const
     // method.  Look into fixing this on the WebKit side.
     WebFormControlElement& e = const_cast<WebFormControlElement&>(element);
     WebSelectElement select_element = e.to<WebSelectElement>();
     value = select_element.value();
@@ skipping 76 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 &&
-        control_element.formControlType() == WebString::fromUTF8("text")) {
+    if (requirements & REQUIRE_AUTOCOMPLETE && IsTextInput(control_element)) {
       const WebInputElement& input_element =
           control_element.toConst<WebInputElement>();
       if (!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.
@@ skipping 192 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 (element.formControlType() == WebString::fromUTF8("text")) {
+    if (IsTextInput(element)) {
 
       WebInputElement input_element = element.to<WebInputElement>();
 
       // We don't modify the value of disabled fields.
       if (!input_element.isEnabled())
         continue;
 
       input_element.setValue(string16());
       input_element.setAutofilled(false);
 
@@ skipping 15 matching lines @@
 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];
 
     // Only input elements can be previewed.
-    if (element->formControlType() != WebString::fromUTF8("text"))
+    if (!IsTextInput(*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())
       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
@@ skipping 43 matching lines @@
   }
 }
 
 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 (element.formControlType() != WebString::fromUTF8("text"))
+    if (!IsTextInput(element))
       continue;
 
     const WebInputElement& input_element = element.to<WebInputElement>();
     if (input_element.isAutofilled())
       return true;
   }
 
   return false;
 }
 
@@ skipping 92 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 (element->formControlType() == WebString::fromUTF8("text")) {
+    if (IsTextInput(*element)) {
       const WebInputElement& input_element =
           element->toConst<WebInputElement>();
 
       // 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())
         continue;
 
       is_initiating_node = (input_element == node);
       // Don't require the node that initiated the auto-fill process to be
@@ skipping 17 matching lines @@
   delete callback;
 }
 
 void FormManager::FillFormField(WebFormControlElement* field,
                                 const FormField* data,
                                 bool is_initiating_node) {
   // Nothing to fill.
   if (data->value().empty())
     return;
 
-  if (field->formControlType() == WebString::fromUTF8("text")) {
+  if (IsTextInput(*field)) {
     WebInputElement input_element = field->to<WebInputElement>();
 
     // 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);
     if (is_initiating_node) {
       int length = input_element.value().length();
       input_element.setSelectionRange(length, length);
     }
   } else if (field->formControlType() == WebString::fromUTF8("select-one")) {
     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 (field->formControlType() != WebString::fromUTF8("text"))
+  if (!IsTextInput(*field))
     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);
   if (is_initiating_node)
     input_element.setSelectionRange(0, input_element.suggestedValue().length());
 }