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);
 }
 
+// A simple wrapper to get an element's value.
+WebString GetValue(const WebFormControlElement& element) {
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element))
+    return input_element->value();
+
+  if (IsTextAreaElement(element))
+    return element.toConst<WebTextAreaElement>().value();
+
+  DCHECK(IsSelectElement(element));
+  return element.toConst<WebSelectElement>().value();
+}
+
+// A simple wrapper to get an element's suggested value.
+WebString GetSuggestedValue(const WebFormControlElement& element) {
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element))
+    return input_element->suggestedValue();
+
+  DCHECK(IsTextAreaElement(element));
+  return element.toConst<WebTextAreaElement>().suggestedValue();
+}
+
+// A simple wrapper to get an element's character selection range.
+void SetSelectionRange(WebFormControlElement element, int start, int end) {
+  WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element)) {
+    input_element->setSelectionRange(start, end);
+  } else {
+    DCHECK(IsTextAreaElement(element));
+    element.to<WebTextAreaElement>().setSelectionRange(start, end);
+  }
+}
+
+// A helper function to set common attributes shared among elements.
+void SetCommonAttributes(const WebFormControlElement& element,
+                         FormFieldData* field) {
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (!IsAutofillableInputElement(input_element) &&
+      !IsTextAreaElement(element))
+    return;
+
+  field->is_autofilled = element.isAutofilled();
+  field->is_focusable = element.isFocusable();
+  if (IsAutofillableInputElement(input_element)) {
+    field->should_autocomplete = input_element->autoComplete();
+    field->text_direction = input_element->directionForFormData() ==
+          "rtl" ? base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
+  } else {
+    DCHECK(IsTextAreaElement(element));
+    const WebTextAreaElement textarea_element =
+        element.toConst<WebTextAreaElement>();
+    field->should_autocomplete = textarea_element.autoComplete();
+    field->text_direction = textarea_element.directionForFormData() ==
+        "rtl" ? base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
+  }
+}
+
 // 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 81 matching lines @@
     return;
 
   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);
-      // 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();
     }
   } 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);
   }
+
+  if (is_initiating_node &&
+      ((IsTextInput(input_element) || IsMonthInput(input_element)) ||
+       IsTextAreaElement(*field))) {
+    int length = GetValue(*field).length();
+    SetSelectionRange(*field, length, length);
+    // Clear the current IME composition (the underline), if there is one.
+    field->document().frame()->unmarkText();
+  }
 }
 
 // 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(const FormFieldData& data,
                       bool is_initiating_node,
                       blink::WebFormControlElement* field) {
   // Nothing to preview.
   if (data.value.empty())
     return;
 
   // 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) {
-      // 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 &&
+      (IsTextInput(input_element) || IsTextAreaElement(*field))) {
+    // Select the part of the text that the user didn't type.
+    int start = GetValue(*field).length();
+    int end = GetSuggestedValue(*field).length();
+    SetSelectionRange(*field, start, end);
+  }
 }
 
 std::string RetrievalMethodToString(
     const WebElementDescriptor::RetrievalMethod& method) {
   switch (method) {
     case WebElementDescriptor::CSS_SELECTOR:
       return "CSS_SELECTOR";
     case WebElementDescriptor::ID:
       return "ID";
     case WebElementDescriptor::NONE:
@@ skipping 158 matching lines @@
   if (field->autocomplete_attribute.size() > kMaxDataLength) {
     // Discard overly long attribute values to avoid DOS-ing the browser
     // process.  However, send over a default string to indicate that the
     // attribute was present.
     field->autocomplete_attribute = "x-max-data-length-exceeded";
   }
 
   if (!IsAutofillableElement(element))
     return;
 
+  SetCommonAttributes(element, field);
+
   const WebInputElement* input_element = toWebInputElement(&element);
   if (IsAutofillableInputElement(input_element)) {
     if (IsTextInput(input_element))
       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.
   } 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))
     return;
 
-  base::string16 value;
-  if (IsAutofillableInputElement(input_element)) {
-    value = input_element->value();
-  } else if (IsTextAreaElement(element)) {
-    value = element.toConst<WebTextAreaElement>().value();
-  } else {
-    DCHECK(IsSelectElement(element));
+  base::string16 value = GetValue(element);
+
+  if (IsSelectElement(element)) {
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
-    value = select_element.value();
-
     // Convert the |select_element| value to text if requested.
     if (extract_mask & EXTRACT_OPTION_TEXT) {
       WebVector<WebElement> list_items = select_element.listItems();
       for (size_t i = 0; i < list_items.size(); ++i) {
         if (IsOptionElement(list_items[i])) {
           const WebOptionElement option_element =
               list_items[i].toConst<WebOptionElement>();
           if (option_element.value() == value) {
             value = option_element.text();
             break;
@@ skipping 144 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 13 matching lines @@
       continue;
 
     if ((IsTextInput(input_element) &&
          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.
+    bool is_initiating_node;

[Ilya Sherman, 2014/03/01 02:50:53]

Please make sure to initialize this variable here, i.e. set it to false by
default.

[ziran.sun, 2014/03/03 19:23:32]

Done.

     if (IsTextInput(input_element)) {
       input_element->setSuggestedValue(WebString());
-      bool is_initiating_node = (element == *input_element);
+      is_initiating_node = (element == *input_element);
       if (is_initiating_node)
         input_element->setAutofilled(was_autofilled);
       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);
+      is_initiating_node = (element == text_area);
       if (is_initiating_node)
         control_element.setAutofilled(was_autofilled);
       else
         control_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 = GetValue(control_element).length();
+      SetSelectionRange(control_element, length, length);
+    }
   }
 
   return true;
 }
 
 bool FormWithElementIsAutofilled(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
@@ skipping 55 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