AutoFill: Parse HTMLLabel elements for form control element labels.

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"
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebLabelElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebNodeList.h"
@@ skipping 33 matching lines @@
 
 FormManager::~FormManager() {
   Reset();
 }
 
 // static
 void FormManager::WebFormControlElementToFormField(
     const WebFormControlElement& element, FormField* field) {
   DCHECK(field);
 
-  // TODO(jhawkins): LabelForElement.  Returning an empty label temporarily to
-  // diagnose a perf issue.
-  field->set_label(string16());
+  // 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());
 
   // TODO(jhawkins): In WebKit, move value() and setValue() to
   // WebFormControlElement.
   string16 value;
   if (element.formControlType() == WebString::fromUTF8("text")) {
     const WebInputElement& input_element =
         element.toConstElement<WebInputElement>();
     value = input_element.value();
@@ skipping 23 matching lines @@
   form->name = element.name();
   form->method = element.method();
   form->origin = frame->url();
   form->action = frame->completeURL(element.action());
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(element.action());
 
+  // A map from a FormField's name to the FormField itself.
+  std::map<string16, FormField*> name_map;
+
+  // The extracted FormFields.  We use pointers so we can store them in
+  // |name_map|.
+  ScopedVector<FormField> form_fields;
+
   WebVector<WebFormControlElement> control_elements;
   element.getFormControlElements(control_elements);
   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")) {
       const WebInputElement& input_element =
           control_element.toConstElement<WebInputElement>();
       if (!input_element.autoComplete())
         continue;
     }
 
     if (requirements & REQUIRE_ELEMENTS_ENABLED && !control_element.isEnabled())
       continue;
 
-    FormField field;
-    WebFormControlElementToFormField(control_element, &field);
-    form->fields.push_back(field);
+    // Create a new FormField, fill it out and map it to the field's name.
+    FormField* field = new FormField;
+    WebFormControlElementToFormField(control_element, 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
+    // an id() method to WebFormControlElement and use that here.
+    name_map[field->name()] = field;
   }
 
-  return !form->fields.empty();
+  // Don't extract field labels if we have no fields.
+  if (form_fields.empty())
+    return false;
+
+  // Loop through the label elements inside the form element.  For each label
+  // element, get the corresponding form control element, use the form control
+  // element's name as a key into the <name, FormField> map to find the
+  // previously created FormField and set the FormField's label to the
+  // innerText() of the label element.
+  WebNodeList labels = element.getElementsByTagName("label");
+  for (unsigned i = 0; i < labels.length(); ++i) {
+    WebLabelElement label = labels.item(i).toElement<WebLabelElement>();
+    WebFormControlElement field_element =
+        label.correspondingControl().toElement<WebFormControlElement>();
+    if (field_element.isNull() || !field_element.isFormControlElement())
+      continue;
+
+    std::map<string16, FormField*>::iterator iter =
+        name_map.find(field_element.nameForAutofill());
+    if (iter != name_map.end())
+      iter->second->set_label(label.innerText());
+  }
+
+  // Copy the created FormFields into the resulting FormData object.
+  for (ScopedVector<FormField>::const_iterator iter = form_fields.begin();
+       iter != form_fields.end(); ++iter) {
+    form->fields.push_back(**iter);
+  }
+
+  return true;
 }
 
 void FormManager::ExtractForms(const WebFrame* frame) {
   DCHECK(frame);
 
   // Reset the vector of FormElements for this frame.
   ResetFrame(frame);
 
   WebVector<WebFormElement> web_forms;
   frame->forms(web_forms);
 
   for (size_t i = 0; i < web_forms.size(); ++i) {
     FormElement* form_elements = new FormElement;
     form_elements->form_element = web_forms[i];
 
     WebVector<WebFormControlElement> control_elements;
     form_elements->form_element.getFormControlElements(control_elements);
     for (size_t j = 0; j < control_elements.size(); ++j) {
       WebFormControlElement element = control_elements[j];
-      // TODO(jhawkins): Remove this check when we have labels.
-      if (!element.nameForAutofill().isEmpty())
-        form_elements->control_elements[element.nameForAutofill()] = element;
+      form_elements->control_elements.push_back(element);
     }
 
     form_elements_map_[frame].push_back(form_elements);
   }
 }
 
 void FormManager::GetForms(RequirementsMask requirements,
                            std::vector<FormData>* forms) {
   DCHECK(forms);
 
   for (WebFrameFormElementMap::iterator iter = form_elements_map_.begin();
        iter != form_elements_map_.end(); ++iter) {
-    const WebFrame* frame = iter->first;
-
     for (std::vector<FormElement*>::iterator form_iter = iter->second.begin();
          form_iter != iter->second.end(); ++form_iter) {
-      FormElement* form_element = *form_iter;
-
-      if (requirements & REQUIRE_AUTOCOMPLETE &&
-          !form_element->form_element.autoComplete())
-        continue;
-
       FormData form;
-      FormElementToFormData(frame, form_element, requirements, &form);
-      forms->push_back(form);
+      if (WebFormElementToFormData((*form_iter)->form_element,
+                                   requirements,
+                                   &form))
+        forms->push_back(form);
     }
   }
 }
 
 void FormManager::GetFormsInFrame(const WebFrame* frame,
                                   RequirementsMask requirements,
                                   std::vector<FormData>* forms) {
   DCHECK(frame);
   DCHECK(forms);
 
@@ skipping 61 matching lines @@
     return false;
 
   if (form_elements_map_.find(frame) == form_elements_map_.end())
     return false;
 
   const std::vector<FormElement*> forms = form_elements_map_[frame];
   for (std::vector<FormElement*>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     const FormElement* form_element = *iter;
 
-    if (form_element->control_elements.find(element.nameForAutofill()) !=
-        form_element->control_elements.end()) {
-      FormElementToFormData(frame, form_element, requirements, form);
-      return true;
+    for (std::vector<WebFormControlElement>::const_iterator iter =
+             form_element->control_elements.begin();
+         iter != form_element->control_elements.end(); ++iter) {
+      if (iter->nameForAutofill() == element.nameForAutofill()) {
+        WebFormElementToFormData(form_element->form_element, requirements, form);
+        return true;
+      }
     }
   }
 
   return false;
 }
 
 bool FormManager::FillForm(const FormData& form) {
   FormElement* form_element = NULL;
 
-  // Frame loop.
   for (WebFrameFormElementMap::iterator iter = form_elements_map_.begin();
        iter != form_elements_map_.end(); ++iter) {
-    // Form loop.
     for (std::vector<FormElement*>::iterator form_iter = iter->second.begin();
          form_iter != iter->second.end(); ++form_iter) {
       // TODO(dhollowa): matching on form name here which is not guaranteed to
       // be unique for the page, nor is it guaranteed to be non-empty.  Need to
       // find a way to uniquely identify the form cross-process.
       // http://crbug.com/37990 test file sample8.html.
       // Also note that WebString() == WebString(string16()) does not seem to
       // evaluate to |true| for some reason TBD, so forcing to string16.
       string16 element_name((*form_iter)->form_element.name());
       if (element_name == form.name &&
           (*form_iter)->control_elements.size() == form.fields.size()) {
         form_element = *form_iter;
         break;
       }
     }
   }
 
   if (!form_element)
     return false;
 
   DCHECK(form_element->control_elements.size() == form.fields.size());
 
-  size_t i = 0;
-  for (FormControlElementMap::iterator iter =
-           form_element->control_elements.begin();
-      iter != form_element->control_elements.end(); ++iter, ++i) {
-    DCHECK_EQ(form.fields[i].name(), iter->second.nameForAutofill());
+  for (size_t i = 0; i < form.fields.size(); ++i) {
+    WebFormControlElement* element = &form_element->control_elements[i];
+
+    // It's possible that nameForAutofill() is empty if the form control element
+    // has no name or ID.  In that case, iter->nameForAutofill() must also be
+    // empty.
+    if (form.fields[i].name().empty())
+      DCHECK(element->nameForAutofill().isEmpty());
+    else
+      DCHECK_EQ(form.fields[i].name(), element->nameForAutofill());
 
     if (!form.fields[i].value().empty() &&
-        iter->second.formControlType() != WebString::fromUTF8("submit")) {
-      if (iter->second.formControlType() == WebString::fromUTF8("text")) {
-        WebInputElement input_element =
-            iter->second.toElement<WebInputElement>();
+        element->formControlType() != WebString::fromUTF8("submit")) {
+      if (element->formControlType() == WebString::fromUTF8("text")) {
+        WebInputElement input_element = element->toElement<WebInputElement>();
         input_element.setValue(form.fields[i].value());
         input_element.setAutofilled(true);
-      } else if (iter->second.formControlType() ==
+      } else if (element->formControlType() ==
                  WebString::fromUTF8("select-one")) {
         WebSelectElement select_element =
-            iter->second.toElement<WebSelectElement>();
+            element->toElement<WebSelectElement>();
         select_element.setValue(form.fields[i].value());
       }
     }
   }
 
   return true;
 }
 
 void FormManager::Reset() {
   for (WebFrameFormElementMap::iterator iter = form_elements_map_.begin();
@@ skipping 16 matching lines @@
   form->method = form_element->form_element.method();
   form->origin = frame->url();
   form->action = frame->completeURL(form_element->form_element.action());
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(form_element->form_element.action());
 
   // Form elements loop.
-  for (FormControlElementMap::const_iterator element_iter =
+  for (std::vector<WebFormControlElement>::const_iterator element_iter =
            form_element->control_elements.begin();
        element_iter != form_element->control_elements.end(); ++element_iter) {
-    WebFormControlElement control_element = element_iter->second;
+    const WebFormControlElement& control_element = *element_iter;
 
     if (requirements & REQUIRE_AUTOCOMPLETE &&
         control_element.formControlType() == WebString::fromUTF8("text")) {
       const WebInputElement& input_element =
           control_element.toConstElement<WebInputElement>();
       if (!input_element.autoComplete())
         continue;
     }
 
     if (requirements & REQUIRE_ELEMENTS_ENABLED && !control_element.isEnabled())
@@ skipping 89 matching lines @@
             inferred_label = element.innerText();
             TrimWhitespace(inferred_label, TRIM_ALL, &inferred_label);
           }
         }
       }
     }
   }
 
   return inferred_label;
 }