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 142 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) {
+    WebString value;
+    if (element.formControlType() == "textarea")
+      value = element.to<WebTextAreaElement>().value();
+    else
+      value = element.to<WebInputElement>().value();
+    return value;

[Ilya Sherman, 2014/01/07 01:09:38]

nit: No need for the local variable value, i.e. you can express this more
concisely as:

static WebString GetValueWrapper(WebFormControlElement element) {
  if (element.formControlType() == "textarea")
    return element.to<WebTextAreaElement>().value();
  
  return element.to<WebInputElement>().value();
}

[ziran.sun, 2014/01/07 16:40:41]

Done.

+  }
+
+  static WebString GetSuggestedValueWrapper(WebFormControlElement element) {
+    WebString suggested_value;
+    if (element.formControlType() == "textarea")
+      suggested_value = element.to<WebTextAreaElement>().suggestedValue();
+    else
+      suggested_value = element.to<WebInputElement>().suggestedValue();
+    return suggested_value;
+  }

[Ilya Sherman, 2014/01/07 01:09:38]

Likewise for this method.

[ziran.sun, 2014/01/07 16:40:41]

Done.

+
  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\"/>"
+      "  <TEXTAREA id=\"textarea\"></TEXTAREA>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>";

[Ilya Sherman, 2014/01/07 01:09:38]

Please update this test to use kFormHtml rather than a custom form (unless I'm
missing a reason why that's quite a pain to do currently).

[ziran.sun, 2014/01/07 16:40:41]

I think selection preview is not supported from this discussion thread: 
http://code.google.com/p/chromium/issues/detail?id=58719

Again, do let me know if I missed any points here.

[Ilya Sherman, 2014/01/08 04:13:47]

That's true, but I think we could still have test coverage for <select> fields
-- the test would simply verify that previewing is a no-op for these fields.  I
admit that's a little silly, but IMO the advantages of sharing the test cases
implicit in the kFormHtml markup outweigh this minor wrinkle.

Note that you'll probably need to special-case <select> fields in
GetSuggestedValueWrapper(), possibly just always returning an empty string for
now.  (Yes, that means the test isn't really testing anything "real".  IMO
that's ok, because there are only two <select> fields that we're hacking around,
but an order of magnitude more test cases that we gain by sharing the input test
cases.)

[ziran.sun, 2014/01/08 17:02:39]

I've made a note on <select> fields saying that preview is not yet supported.
Adding a case in "GetSuggestedValueWrapper()" probably is not required yet. I
guess that we can add <select> case for this function once we have Selection
preview supported :).

[ziran.sun, 2014/01/08 17:02:39]

Done.

 
   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"},
       // Non empty fields should not be previewed.
       {"text", "notempty", "Hi", "", false, "filled notempty", ""},
       // "noautocomplete" should not be extracted to form_data.
       // Disabled fields should not be previewed.
       {"text", "notenabled", "", "", false, "filled notenabled", ""},
+      // Normal textarea elements should be previewed.
+      {"textarea", "textarea", "", "", true, "suggested multi-\nline value",
+       "suggested multi-\nline value"},
   };
   TestFormFillFunctions(html, field_cases, arraysize(field_cases), &PreviewForm,
-                        &WebInputElement::suggestedValue);
+                        &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