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 532 matching lines @@
       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 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) {
+        int length = text_area.value().length();
+        text_area.setSelectionRange(length, length);
+        // 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 22 matching lines @@
     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());
     }
   } else if (IsTextAreaElement(*field)) {
     WebTextAreaElement textarea = field->to<WebTextAreaElement>();
     textarea.setSuggestedValue(data.value);
     field->setAutofilled(true);
+    if (is_initiating_node) {
+      // Select the part of the text that the user didn't type.
+      textarea.setSelectionRange(
+          textarea.value().length(),
+          textarea.suggestedValue().length());
+    }
   }
 }
 
 std::string RetrievalMethodToString(
     const WebElementDescriptor::RetrievalMethod& method) {
   switch (method) {
     case WebElementDescriptor::CSS_SELECTOR:
       return "CSS_SELECTOR";
     case WebElementDescriptor::ID:
       return "ID";
@@ skipping 173 matching lines @@
 
     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.
+    field->is_autofilled = element.isAutofilled();
+    field->is_focusable = element.isFocusable();
   } 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 36 matching lines @@
         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)
         control_element.setAutofilled(was_autofilled);
       else
         control_element.setAutofilled(false);
+      if (is_initiating_node) {
+        int length = text_area.value().length();
+        text_area.setSelectionRange(length, length);
+      }
     }
   }
 
   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