AutoFill: Preview form field values when the user changes the AutoFill dropdown

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 298 matching lines @@
     const WebFormControlElement& control_element = control_elements[i];
 
     if (requirements & REQUIRE_AUTOCOMPLETE &&
         control_element.formControlType() == WebString::fromUTF8("text")) {
       const WebInputElement& input_element =
           control_element.toConst<WebInputElement>();
       if (!input_element.autoComplete())
         continue;
     }
 
-    if (requirements & REQUIRE_ELEMENTS_ENABLED && !control_element.isEnabled())
+    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, get_values, 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;
@@ skipping 182 matching lines @@
   }
 
   return false;
 }
 
 bool FormManager::FillForm(const FormData& form) {
   FormElement* form_element = NULL;
   if (!FindCachedFormElement(form, &form_element))
     return false;
 
-  ForEachMatchingFormField(
-      form_element, form, NewCallback(this, &FormManager::FillFormField));
+  RequirementsMask requirements = static_cast<RequirementsMask>(
+      REQUIRE_AUTOCOMPLETE | REQUIRE_ENABLED | REQUIRE_EMPTY);
+  ForEachMatchingFormField(form_element,
+                           requirements,
+                           form,
+                           NewCallback(this, &FormManager::FillFormField));
 
   return true;
 }
 
-void FormManager::FillForms(const std::vector<webkit_glue::FormData>& forms) {
-  for (std::vector<webkit_glue::FormData>::const_iterator iter = forms.begin();
+bool FormManager::PreviewForm(const FormData& form) {
+  FormElement* form_element = NULL;
+  if (!FindCachedFormElement(form, &form_element))
+    return false;
+
+  RequirementsMask requirements = static_cast<RequirementsMask>(
+      REQUIRE_AUTOCOMPLETE | REQUIRE_ENABLED | REQUIRE_EMPTY);
+  ForEachMatchingFormField(form_element,
+                           requirements,
+                           form,
+                           NewCallback(this, &FormManager::PreviewFormField));
+
+  return true;
+}
+
+void FormManager::ClearPreviewedForm(const FormData& form) {
+  FormElement* form_element = NULL;
+  if (!FindCachedFormElement(form, &form_element))
+    return;
+
+  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"))
+      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;
+
+    input_element.setPlaceholder(string16());
+    input_element.setAutofilled(false);
+  }
+}
+
+void FormManager::FillForms(const std::vector<FormData>& forms) {
+  for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     FillForm(*iter);
   }
 }
 
 void FormManager::Reset() {
   for (WebFrameFormElementMap::iterator iter = form_elements_map_.begin();
        iter != form_elements_map_.end(); ++iter) {
     STLDeleteElements(&iter->second);
   }
@@ skipping 35 matching lines @@
     const WebFormControlElement& control_element = *element_iter;
 
     if (requirements & REQUIRE_AUTOCOMPLETE &&
         control_element.formControlType() == WebString::fromUTF8("text")) {
       const WebInputElement& input_element =
           control_element.toConst<WebInputElement>();
       if (!input_element.autoComplete())
         continue;
     }
 
-    if (requirements & REQUIRE_ELEMENTS_ENABLED && !control_element.isEnabled())
+    if (requirements & REQUIRE_ENABLED && !control_element.isEnabled())
       continue;
 
     FormField field;
     WebFormControlElementToFormField(control_element, false, &field);
     form->fields.push_back(field);
   }
 
   return true;
 }
 
@@ skipping 36 matching lines @@
       if (element_name == form.name && action == form.action) {
         *form_element = *form_iter;
         return true;
       }
     }
   }
 
   return false;
 }
 
-void FormManager::ForEachMatchingFormField(
-    FormElement* form, const FormData& data, Callback* callback) {
+void FormManager::ForEachMatchingFormField(FormElement* form,
+                                           RequirementsMask requirements,
+                                           const FormData& data,
+                                           Callback* callback) {
   // It's possible that the site has injected fields into the form after the
   // page has loaded, so we can't assert that the size of the cached control
   // elements is equal to the size of the fields in |form|.  Fortunately, the
   // one case in the wild where this happens, paypal.com signup form, the fields
   // are appended to the end of the form and are not visible.
   for (size_t i = 0, j = 0;
        i < form->control_elements.size() && j < data.fields.size();
        ++i) {
     WebFormControlElement* element = &form->control_elements[i];
     WebString element_name = element->nameForAutofill();
 
     // Empty WebString != empty string16, so we have to explicitly
     // check for this case.
     if (element_name.isEmpty() && data.fields[j].name().empty())
       continue;
 
     // Search forward in the |form| for a corresponding field.
     size_t k = j;
     while (k < data.fields.size() && element_name != data.fields[k].name())
       k++;
 
     if (k >= data.fields.size())
       continue;
 
     DCHECK_EQ(data.fields[k].name(), element_name);
+
+    // 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")) {
+      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;
+
+      if (requirements & REQUIRE_EMPTY && !input_element.value().isEmpty())
+        continue;
+    }
+
+    if (requirements & REQUIRE_ENABLED && !element->isEnabled())
+      continue;
+
     callback->Run(element, &data.fields[k]);
 
     // We found a matching form field so move on to the next.
     ++j;
   }
 
   delete callback;
 }
 
 void FormManager::FillFormField(WebKit::WebFormControlElement* field,
                                 const FormField* data) {
   // Nothing to fill.
   if (data->value().empty())
     return;
 
   if (field->formControlType() == WebString::fromUTF8("text")) {
     WebInputElement input_element = field->to<WebInputElement>();
 
-    // Don't auto-fill a disabled field.
-    if (!input_element.isEnabledFormControl())
-      return;
-
-    // Don't auto-fill a field with autocomplete=off.
-    if (!input_element.autoComplete())
-      return;
-
-    // Don't overwrite a pre-existing value in the field.
-    if (!input_element.value().isEmpty())
-      return;
-
     // 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);
   } else if (field->formControlType() == WebString::fromUTF8("select-one")) {
     WebSelectElement select_element = field->to<WebSelectElement>();
     select_element.setValue(data->value());
   }
 }
+
+void FormManager::PreviewFormField(WebKit::WebFormControlElement* field,
+                                   const FormField* data) {
+  // Nothing to preview.
+  if (data->value().empty())
+    return;
+
+  // Only preview input fields.
+  if (field->formControlType() != WebString::fromUTF8("text"))
+    return;
+
+  WebInputElement input_element = field->to<WebInputElement>();
+
+  // If the maxlength attribute contains a negative value, maxLength()
+  // returns the default maxlength value.
+  input_element.setPlaceholder(
+      data->value().substr(0, input_element.maxLength()));
+  input_element.setAutofilled(true);
+}