Add supports that allow Autofill to be initiated from textarea field

components/autofill/content/renderer/form_autofill_util.cc

 // Copyright 2013 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 "components/autofill/content/renderer/form_autofill_util.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 420 matching lines @@
 
   // If we didn't find a label, check for definition list case.
   inferred_label = InferLabelFromDefinitionList(element);
   if (!inferred_label.empty())
     return inferred_label;
 
   // If we didn't find a label, check for div table case.
   return InferLabelFromDivTable(element);
 }
 
+void HandleInitiatingNode(WebFormControlElement& element, bool preview) {

[Ilya Sherman, 2014/02/22 06:24:20]

nit: Pass-by-reference is almost entirely disallowed by the Chromium style
guide.  In this case, I'd recommend either pass-by-copy or pass-by-pointer.

+  WebInputElement* input_element = toWebInputElement(&element);
+  if (!IsTextInput(input_element) &&
+      !IsMonthInput(input_element) &&
+      !IsTextAreaElement(element))
+    return;
+
+  if (IsTextInput(input_element) || IsMonthInput(input_element)) {
+    if (preview) {
+      input_element->setSelectionRange(
+          input_element->value().length(),
+          input_element->suggestedValue().length());
+    } else {
+      input_element->setSelectionRange(input_element->value().length(),
+                                       input_element->value().length());
+    }
+  } else if (IsTextAreaElement(element)) {
+    WebTextAreaElement text_area = element.toConst<WebTextAreaElement>();
+    if (preview) {
+      text_area.setSelectionRange(text_area.value().length(),
+                                  text_area.suggestedValue().length());
+    } else {
+      text_area.setSelectionRange(text_area.value().length(),
+                                  text_area.value().length());
+    }
+  }
+}

[Ilya Sherman, 2014/02/22 06:24:20]

This method still makes it hard to tell that the code is doing the same thing
for both input elements and textarea elements.  Please decompose methods along
the lines of

WebString GetValue(const WebFormControlElement& element);
WebString GetSuggestedValue(const WebFormControlElement& element);
void SetSelectionRange(WebFormControlElement element, int start, int end);

+
 // Fills |option_strings| with the values of the <option> elements present in
 // |select_element|.
 void GetOptionStringsFromElement(const WebSelectElement& select_element,
                                  std::vector<base::string16>* option_values,
                                  std::vector<base::string16>* option_contents) {
   DCHECK(!select_element.isNull());
 
   option_values->clear();
   option_contents->clear();
   WebVector<WebElement> list_items = select_element.listItems();
@@ skipping 82 matching lines @@
 
   field->setAutofilled(true);
 
   WebInputElement* input_element = toWebInputElement(field);
   if (IsTextInput(input_element) || IsMonthInput(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);
     if (is_initiating_node) {
-      int length = input_element->value().length();
-      input_element->setSelectionRange(length, length);
+      HandleInitiatingNode(*input_element, false);
       // Clear the current IME composition (the underline), if there is one.
       input_element->document().frame()->unmarkText();
     }
   } else if (IsTextAreaElement(*field)) {
     WebTextAreaElement text_area = field->to<WebTextAreaElement>();
     if (text_area.value() != data.value) {
       text_area.setValue(data.value);
       text_area.dispatchFormControlChangeEvent();
+      if (is_initiating_node) {
+        HandleInitiatingNode(text_area, false);
+        // Clear the current IME composition (the underline), if there is one.
+        text_area.document().frame()->unmarkText();
+      }
     }
   } else if (IsSelectElement(*field)) {
     WebSelectElement select_element = field->to<WebSelectElement>();
     if (select_element.value() != data.value) {
       select_element.setValue(data.value);
       select_element.dispatchFormControlChangeEvent();
     }
   } else {
     DCHECK(IsCheckableElement(input_element));
     input_element->setChecked(data.is_checked, true);
@@ skipping 12 matching lines @@
   // Preview input and textarea fields. For input fields, excludes checkboxes
   // and radio buttons, as there is no provision for setSuggestedCheckedValue
   // in 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->setSuggestedValue(
       data.value.substr(0, input_element->maxLength()));
     input_element->setAutofilled(true);
-    if (is_initiating_node) {
+    if (is_initiating_node)

[Ilya Sherman, 2014/02/22 06:24:20]

nit: Curly braces are still needed, since the body of the loop spans two lines
of text.

       // Select the part of the text that the user didn't type.
-      input_element->setSelectionRange(
-          input_element->value().length(),
-          input_element->suggestedValue().length());
-    }
+      HandleInitiatingNode(*input_element, true);
+
   } else if (IsTextAreaElement(*field)) {
     WebTextAreaElement textarea = field->to<WebTextAreaElement>();
     textarea.setSuggestedValue(data.value);
     field->setAutofilled(true);
+    if (is_initiating_node)

[Ilya Sherman, 2014/02/22 06:24:20]

nit: Curly braces are still needed, since the body of the loop spans two lines
of text.

+      // Select the part of the text that the user didn't type.
+      HandleInitiatingNode(textarea, true);
   }
 }
 
 std::string RetrievalMethodToString(
     const WebElementDescriptor::RetrievalMethod& method) {
   switch (method) {
     case WebElementDescriptor::CSS_SELECTOR:
       return "CSS_SELECTOR";
     case WebElementDescriptor::ID:
       return "ID";
@@ skipping 172 matching lines @@
       field->max_length = input_element->maxLength();
 
     field->is_autofilled = input_element->isAutofilled();
     field->is_focusable = input_element->isFocusable();
     field->is_checkable = IsCheckableElement(input_element);
     field->is_checked = input_element->isChecked();
     field->should_autocomplete = input_element->autoComplete();
     field->text_direction = input_element->directionForFormData() == "rtl" ?
         base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
   } else if (IsTextAreaElement(element)) {
-    // Nothing more to do in this case.
+    const WebTextAreaElement textarea_element =
+        element.toConst<WebTextAreaElement>();
+    field->is_autofilled = element.isAutofilled();
+    field->is_focusable = element.isFocusable();
+    field->should_autocomplete = textarea_element.autoComplete();
+    field->text_direction = textarea_element.directionForFormData() == "rtl" ?
+        base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;

[Ilya Sherman, 2014/02/22 06:24:20]

Is it possible to refactor the code so that it is shared across the two branches
of the if/else, rather than duplicated?

   } else if (extract_mask & EXTRACT_OPTIONS) {
     // Set option strings on the field if available.
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     GetOptionStringsFromElement(select_element,
                                 &field->option_values,
                                 &field->option_contents);
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
@@ skipping 166 matching lines @@
 
   // Copy the created FormFields into the resulting FormData object.
   for (ScopedVector<FormFieldData>::const_iterator iter = form_fields.begin();
        iter != form_fields.end(); ++iter) {
     form->fields.push_back(**iter);
   }
 
   return true;
 }
 
-bool FindFormAndFieldForInputElement(const WebInputElement& element,
-                                     FormData* form,
-                                     FormFieldData* field,
-                                     RequirementsMask requirements) {
+bool FindFormAndFieldForFormControlElement(const WebFormControlElement& element,
+                                           FormData* form,
+                                           FormFieldData* field,
+                                           RequirementsMask requirements) {
   if (!IsAutofillableElement(element))
     return false;
 
   const WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
   return WebFormElementToFormData(form_element,
                                   element,
                                   requirements,
                                   extract_mask,
                                   form,
                                   field);
 }
 
-void FillForm(const FormData& form, const WebInputElement& element) {
+void FillForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
                            FILTER_ALL_NON_EDITIABLE_ELEMENTS,
                            false, /* dont force override */
                            &FillFormField);
@@ skipping 20 matching lines @@
     return;
 
   ForEachMatchingFormField(form_element,
                            WebInputElement(),
                            form_data,
                            FILTER_NONE,
                            true, /* force override */
                            &FillFormField);
 }
 
-void PreviewForm(const FormData& form, const WebInputElement& element) {
+void PreviewForm(const FormData& form, const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return;
 
   ForEachMatchingFormField(form_element,
                            element,
                            form,
                            FILTER_ALL_NON_EDITIABLE_ELEMENTS,
                            false, /* dont force override */
                            &PreviewFormField);
 }
 
-bool ClearPreviewedFormWithElement(const WebInputElement& element,
+bool ClearPreviewedFormWithElement(const WebFormControlElement& element,
                                    bool was_autofilled) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
                               &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     // There might be unrelated elements in this form which have already been
@@ skipping 16 matching lines @@
          input_element->suggestedValue().isEmpty()) ||
         (IsTextAreaElement(control_element) &&
          control_element.to<WebTextAreaElement>().suggestedValue().isEmpty()))
       continue;
 
     // Clear the suggested value. For the initiating node, also restore the
     // original value.
     if (IsTextInput(input_element)) {
       input_element->setSuggestedValue(WebString());
       bool is_initiating_node = (element == *input_element);
-      if (is_initiating_node)
+      if (is_initiating_node) {
         input_element->setAutofilled(was_autofilled);
-      else
+        // Clearing the suggested value in the focused node (above) can cause
+        // selection to be lost. We force selection range to restore the text
+        // cursor.
+        HandleInitiatingNode(*input_element, false);

[Ilya Sherman, 2014/02/22 06:24:20]

This change doesn't seem appropriate.  Is there some specific bug that this is
meant to be addressing?

+      }
+      else {

[Ilya Sherman, 2014/02/22 06:24:20]

nit: The else should be on the previous line, i.e. "} else {"

         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);
       }
     } else if (IsTextAreaElement(control_element)) {
       WebTextAreaElement text_area = control_element.to<WebTextAreaElement>();
       text_area.setSuggestedValue(WebString());
       bool is_initiating_node = (element == text_area);
-      if (is_initiating_node)
+      if (is_initiating_node) {
         control_element.setAutofilled(was_autofilled);
-      else
+        HandleInitiatingNode(text_area, false);
+      }
+      else {
         control_element.setAutofilled(false);
+      }
     }
   }
 
   return true;
 }
 
 bool FormWithElementIsAutofilled(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
@@ skipping 56 matching lines @@
         tag_is_allowed = true;
         break;
       }
     }
     if (!tag_is_allowed)
       return false;
   }
   return true;
 }
 
-gfx::RectF GetScaledBoundingBox(float scale, WebInputElement* element) {
+gfx::RectF GetScaledBoundingBox(float scale, WebFormControlElement* element) {
   gfx::Rect bounding_box(element->boundsInViewportSpace());
   return gfx::RectF(bounding_box.x() * scale,
                     bounding_box.y() * scale,
                     bounding_box.width() * scale,
                     bounding_box.height() * scale);
 }
 
 }  // namespace autofill