Add autofill preview support for Textarea

chrome/renderer/autofill/form_autofill_browsertest.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 <vector>
 
 #include "base/format_macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ skipping 143 matching lines @@
     labels.push_back(ASCIIToUTF16("Email:"));
     names.push_back(ASCIIToUTF16("email"));
     values.push_back(ASCIIToUTF16("john@example.com"));
 
     ExpectLabels(html, labels, names, values);
   }
 
   typedef void (*FillFormFunction)(const FormData& form,
                                    const WebInputElement& element);
 
-  typedef WebString (WebInputElement::*GetValueFunction)(void) const;
+  typedef WebString (*GetValueFunction)(WebFormControlElement element);
 
   // Test FormFillxxx functions.
   void TestFormFillFunctions(const char* html,
                              const AutofillFieldCase* field_cases,
                              size_t number_of_field_cases,
                              FillFormFunction fill_form_function,
                              GetValueFunction get_value_function) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
@@ skipping 53 matching lines @@
   void ValidteFilledField(const AutofillFieldCase& field_case,
                           GetValueFunction get_value_function) {
     SCOPED_TRACE(base::StringPrintf("Verify autofilled value for field %s",
                                     field_case.name));
     WebString value;
     WebFormControlElement element = GetMainFrame()->document().getElementById(
         ASCIIToUTF16(field_case.name)).to<WebFormControlElement>();
     if (element.formControlType() == "select-one") {
       value = element.to<WebSelectElement>().value();
     } else if (element.formControlType() == "textarea") {
-      value = element.to<WebTextAreaElement>().value();
+      value = get_value_function(element);
     } else {
       ASSERT_TRUE(element.formControlType() == "text" ||
                   element.formControlType() == "month");
-      WebInputElement input_element = GetMainFrame()->document().getElementById(
-          ASCIIToUTF16(field_case.name)).to<WebInputElement>();
-      value = (input_element.*get_value_function)();
+      value = get_value_function(element);
     }
 
     const WebString expected_value = ASCIIToUTF16(field_case.expected_value);
     if (expected_value.isEmpty())
       EXPECT_TRUE(value.isEmpty());
     else
       EXPECT_EQ(expected_value, value);
 
     EXPECT_EQ(field_case.should_be_autofilled, element.isAutofilled());
   }
 
   static void FillFormForAllFieldsWrapper(const FormData& form,
                                        const WebInputElement& element) {
     FillFormForAllElements(form, element.form());
   }
 
   static void FillFormIncludingNonFocusableElementsWrapper(
       const FormData& form,
       const WebInputElement& element) {
     FillFormIncludingNonFocusableElements(form, element.form());
   }
 
+  static WebString GetValueWrapper(WebFormControlElement element) {
+    if (element.formControlType() == "textarea")
+      return element.to<WebTextAreaElement>().value();
+
+    return element.to<WebInputElement>().value();
+  }
+
+  static WebString GetSuggestedValueWrapper(WebFormControlElement element) {
+    if (element.formControlType() == "textarea")
+      return element.to<WebTextAreaElement>().suggestedValue();
+
+    return element.to<WebInputElement>().suggestedValue();
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(FormAutofillTest);
 };
 
 // We should be able to extract a normal text field.
 TEST_F(FormAutofillTest, WebFormControlElementToFormField) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
@@ skipping 831 matching lines @@
       // non-empty value.
       {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
       // Regular textarea elements should be autofilled.
       {"textarea", "textarea", "", "", true, "some multi-\nline value",
        "some multi-\nline value"},
       // Non-empty textarea elements should not be autofilled.
       {"textarea", "textarea-nonempty", "Go\naway!", "", false,
        "some multi-\nline value", "Go\naway!"},
   };
   TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
-                        FillForm, &WebInputElement::value);
+                        FillForm, &GetValueWrapper);
   // Verify preview selection.
   WebInputElement firstname = GetMainFrame()->document().
       getElementById("firstname").to<WebInputElement>();
   EXPECT_EQ(16, firstname.selectionStart());
   EXPECT_EQ(16, firstname.selectionEnd());
 }
 
 TEST_F(FormAutofillTest, FillFormIncludingNonFocusableElements) {
   static const AutofillFieldCase field_cases[] = {
       // fields: form_control_type, name, initial_value, autocomplete_attribute,
@@ skipping 29 matching lines @@
       {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
       // Regular textarea elements should be autofilled.
       {"textarea", "textarea", "", "", true, "some multi-\nline value",
        "some multi-\nline value"},
       // Nonempty textarea elements should be overridden.
       {"textarea", "textarea-nonempty", "Go\naway!", "", true,
        "some multi-\nline value", "some multi-\nline value"},
   };
   TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
                         &FillFormIncludingNonFocusableElementsWrapper,
-                        &WebInputElement::value);
+                        &GetValueWrapper);
 }
 
 TEST_F(FormAutofillTest, PreviewForm) {
-  static const char* html =
-      "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
-      "  <INPUT type=\"text\" id=\"firstname\"/>"
-      "  <INPUT type=\"text\" id=\"lastname\"/>"
-      "  <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
-      "  <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>"
-      "  <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>"
-      "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
-      "</FORM>";
-
   static const AutofillFieldCase field_cases[] = {
       // Normal empty fields should be previewed.
       {"text", "firstname", "", "", true, "suggested firstname",
        "suggested firstname"},
       {"text", "lastname", "", "", true, "suggested lastname",
        "suggested lastname"},
+      // Hidden fields should not be extracted to form_data.
       // Non empty fields should not be previewed.
-      {"text", "notempty", "Hi", "", false, "filled notempty", ""},
+      {"text", "notempty", "Hi", "", false, "suggested notempty", ""},
       // "noautocomplete" should not be extracted to form_data.
       // Disabled fields should not be previewed.
-      {"text", "notenabled", "", "", false, "filled notenabled", ""},
+      {"text", "notenabled", "", "", false, "suggested notenabled", ""},
+      // Readonly fields should not be previewed.
+      {"text", "readonly", "", "", false, "suggested readonly", ""},
+      // Fields with "visibility: hidden" should not be previewed.
+      {"text", "invisible", "", "", false, "suggested invisible",
+       ""},
+      // Fields with "display:none" should not previewed.
+      {"text", "displaynone", "", "", false, "suggested displaynone",
+       ""},
+      // Regular <input type="month"> should not be previewed.
+      {"month", "month", "", "", false, "2017-11", ""},
+      // Non-empty <input type="month"> should not be previewed.
+      {"month", "month-nonempty", "2011-12", "", false, "2017-11", ""},
+      // Regular select fields preview is not yet supported
+      {"select-one", "select", "", "", false, "TX", ""},
+      // Select fields preview is not yet supported
+      {"select-one", "select-nonempty", "CA", "", false, "TX", "CA"},
+      // Normal textarea elements should be previewed.
+      {"textarea", "textarea", "", "", true, "suggested multi-\nline value",
+       "suggested multi-\nline value"},
+      // Nonempty textarea elements should not be previewed.
+      {"textarea", "textarea-nonempty", "Go\naway!", "", false,
+       "suggested multi-\nline value", ""},
   };
-  TestFormFillFunctions(html, field_cases, arraysize(field_cases), &PreviewForm,
-                        &WebInputElement::suggestedValue);
+  TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
+                        &PreviewForm, &GetSuggestedValueWrapper);
 
   // Verify preview selection.
   WebInputElement firstname = GetMainFrame()->document().
       getElementById("firstname").to<WebInputElement>();
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(19, firstname.selectionEnd());
 }
 
 TEST_F(FormAutofillTest, Labels) {
   ExpectJohnSmithLabels(
@@ skipping 1983 matching lines @@
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("AL");
   expected.form_control_type = "select-one";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 }
 
 }  // namespace autofill