[autofill] Fill in values on a successful run of interactive autocomplete.

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 26 matching lines @@
 using WebKit::WebOptionElement;
 using WebKit::WebSelectElement;
 using WebKit::WebString;
 using WebKit::WebVector;
 
 namespace {
 
 using autofill::ExtractAutofillableElements;
 using autofill::IsTextInput;
 using autofill::IsSelectElement;
+using autofill::REQUIRE_AUTOCOMPLETE;
+using autofill::REQUIRE_FOCUSABLE;
+using autofill::RequirementsMask;

[Ilya Sherman, 2012/11/30 04:04:54]

Do these lines actually compile?  I didn't think this was legal syntax...

[Dan Beam, 2012/11/30 04:13:33]

Yes, at least with g++.

 
 // 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");
@@ skipping 349 matching lines @@
   for (size_t i = 0; i < list_items.size(); ++i) {
     if (IsOptionElement(list_items[i])) {
       const WebOptionElement option = list_items[i].toConst<WebOptionElement>();
       option_values->push_back(option.value());
       option_contents->push_back(option.text());
     }
   }
 }
 
 // The callback type used by |ForEachMatchingFormField()|.
-typedef void (*Callback)(WebKit::WebFormControlElement*,
-                         const FormFieldData*,
-                         bool);
+typedef void (*Callback)(const FormFieldData&,
+                         bool, /* is_initiating_element */
+                         WebKit::WebFormControlElement*);
 
 // For each autofillable field in |data| that matches a field in the |form|,
 // the |callback| is invoked with the corresponding |form| field data.
 void ForEachMatchingFormField(const WebFormElement& form_element,
                               const WebElement& initiating_element,
                               const FormData& data,
+                              RequirementsMask requirements,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, autofill::REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(form_element, requirements, &control_elements);
 
   if (control_elements.size() != data.fields.size()) {
     // This case should be reachable only for pathological websites, which add
     // or remove form fields while the user is interacting with the Autofill
     // 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();
     return;
   }
@@ skipping 20 matching lines @@
 
     const WebInputElement* input_element = toWebInputElement(element);
     if (IsTextInput(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())
         continue;
     }
 
     if (!element->isEnabled() || element->isReadOnly() ||
-        !element->isFocusable())
+        (requirements & REQUIRE_FOCUSABLE && !element->isFocusable()))
       continue;
 
-    callback(element, &data.fields[i], is_initiating_element);
+    callback(data.fields[i], is_initiating_element, element);
   }
 }
 
 // Sets the |field|'s value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
-void FillFormField(WebKit::WebFormControlElement* field,
-                   const FormFieldData* data,
-                   bool is_initiating_node) {
+void FillFormField(const FormFieldData& data,
+                   bool is_initiating_node,
+                   WebKit::WebFormControlElement* field) {
   // Nothing to fill.
-  if (data->value.empty())
+  if (data.value.empty())
     return;
 
   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()), true);
+        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));
     WebSelectElement select_element = field->to<WebSelectElement>();
-    if (select_element.value() != data->value) {
-      select_element.setValue(data->value);
+    if (select_element.value() != data.value) {
+      select_element.setValue(data.value);
       select_element.dispatchFormControlChangeEvent();
     }
   }
 }
 
 // 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) {
+void PreviewFormField(const FormFieldData& data,
+                      bool is_initiating_node,
+                      WebKit::WebFormControlElement* field) {
   // Nothing to preview.
-  if (data->value.empty())
+  if (data.value.empty())
     return;
 
   // Only preview input fields.
   WebInputElement* input_element = toWebInputElement(field);
   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()));
+      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.
     input_element->setSelectionRange(input_element->value().length(),
                                      input_element->suggestedValue().length());
   }
 }
 
 }  // namespace
 
@@ skipping 274 matching lines @@
                                   extract_mask,
                                   form,
                                   field);
 }
 
 void FillForm(const FormData& form, const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
+  RequirementsMask requirements =
+      static_cast<RequirementsMask>(REQUIRE_AUTOCOMPLETE | REQUIRE_FOCUSABLE);
+  ForEachMatchingFormField(form_element,
+                           element,
+                           form,
+                           requirements,
+                           &FillFormField);
+}
+
+void FillFormAndNonFocusableElements(const FormData& form_data,
+                                     const WebFormElement& form_element) {
+  if (form_element.isNull())
+    return;
+
   ForEachMatchingFormField(form_element,
-                           element,
-                           form,
+                           WebInputElement(),
+                           form_data,
+                           REQUIRE_AUTOCOMPLETE,
                            &FillFormField);
 }
 
 void PreviewForm(const FormData& form, const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
+  RequirementsMask requirements =
+      static_cast<RequirementsMask>(REQUIRE_AUTOCOMPLETE | REQUIRE_FOCUSABLE);
   ForEachMatchingFormField(form_element,
                            element,
                            form,
+                           requirements,
                            &PreviewFormField);
 }
 
 bool ClearPreviewedFormWithElement(const WebInputElement& element,
                                    bool was_autofilled) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
@@ skipping 52 matching lines @@
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 }  // namespace autofill