Add username field discovery heuristic.

chrome/renderer/autofill/password_autofill_agent_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 "components/autofill/content/renderer/password_autofill_agent.h"
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 355 matching lines @@
   void UpdateOriginForHTML(const std::string& html) {
     std::string origin = "data:text/html;charset=utf-8," + html;
     fill_data_.origin = GURL(origin);
   }
 
   void UpdateUsernameAndPasswordElements() {
     WebDocument document = GetMainFrame()->GetDocument();
     WebElement element =
         document.GetElementById(WebString::FromUTF8(kUsernameName));
     ASSERT_FALSE(element.IsNull());
-    username_element_ = element.To<blink::WebInputElement>();
+    username_element_ = element.To<WebInputElement>();
     element = document.GetElementById(WebString::FromUTF8(kPasswordName));
     ASSERT_FALSE(element.IsNull());
-    password_element_ = element.To<blink::WebInputElement>();
+    password_element_ = element.To<WebInputElement>();
   }
 
-  blink::WebInputElement GetInputElementByID(const std::string& id) {
+  void UpdateOnlyPasswordElement() {
+    WebDocument document = GetMainFrame()->GetDocument();
+    WebElement element =
+        document.GetElementById(WebString::FromUTF8(kPasswordName));
+    ASSERT_FALSE(element.IsNull());
+    password_element_ = element.To<WebInputElement>();
+    username_element_.Reset();
+  }
+
+  WebInputElement GetInputElementByID(const std::string& id) {
     WebDocument document = GetMainFrame()->GetDocument();
     WebElement element =
         document.GetElementById(WebString::FromUTF8(id.c_str()));
-    return element.To<blink::WebInputElement>();
+    return element.To<WebInputElement>();
   }
 
   void ClearUsernameAndPasswordFields() {
     username_element_.SetValue(WebString());
     username_element_.SetSuggestedValue(WebString());
     username_element_.SetAutofilled(false);
     password_element_.SetValue(WebString());
     password_element_.SetSuggestedValue(WebString());
     password_element_.SetAutofilled(false);
   }
@@ skipping 265 matching lines @@
 TEST_F(PasswordAutofillAgentTest, InitialAutocompleteForEmptyAction) {
   const char kEmptyActionFormHTML[] =
       "<FORM name='LoginTestForm'>"
       "  <INPUT type='text' id='username'/>"
       "  <INPUT type='password' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kEmptyActionFormHTML);
 
   // Retrieve the input elements so the test can access them.
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kUsernameName));
-  ASSERT_FALSE(element.IsNull());
-  username_element_ = element.To<blink::WebInputElement>();
-  element = document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateUsernameAndPasswordElements();
 
   // Set the expected form origin and action URLs.
   UpdateOriginForHTML(kEmptyActionFormHTML);
   fill_data_.action = GURL();
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should have been autocompleted.
@@ skipping 72 matching lines @@
 TEST_F(PasswordAutofillAgentTest, NoAutocompleteForTextFieldPasswords) {
   const char kTextFieldPasswordFormHTML[] =
       "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
       "  <INPUT type='text' id='username'/>"
       "  <INPUT type='text' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kTextFieldPasswordFormHTML);
 
   // Retrieve the input elements so the test can access them.
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kUsernameName));
-  ASSERT_FALSE(element.IsNull());
-  username_element_ = element.To<blink::WebInputElement>();
-  element = document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateUsernameAndPasswordElements();
 
   // Set the expected form origin URL.
   UpdateOriginForHTML(kTextFieldPasswordFormHTML);
 
   SimulateOnFillPasswordForm(fill_data_);
 
   // Fields should still be empty.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, NoAutocompleteForPasswordFieldUsernames) {
   const char kPasswordFieldUsernameFormHTML[] =
       "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
       "  <INPUT type='password' id='username'/>"
       "  <INPUT type='password' id='password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kPasswordFieldUsernameFormHTML);
 
   // Retrieve the input elements so the test can access them.
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kUsernameName));
-  ASSERT_FALSE(element.IsNull());
-  username_element_ = element.To<blink::WebInputElement>();
-  element = document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateUsernameAndPasswordElements();
 
   // Set the expected form origin URL.
   UpdateOriginForHTML(kPasswordFieldUsernameFormHTML);
 
   SimulateOnFillPasswordForm(fill_data_);
 
   // Fields should still be empty.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 }
 
@@ skipping 357 matching lines @@
         selected_element, ASCIIToUTF16(kBobUsername),
         ASCIIToUTF16(kCarolPassword)));
     CheckTextFieldsDOMState(kBobUsername, true, kCarolPassword, true);
     username_length = strlen(kBobUsername);
     CheckUsernameSelection(username_length, username_length);
 
     ClearUsernameAndPasswordFields();
   }
 }
 
+// Tests that |FillSuggestion| properly fills the username and password when the
+// username field is created dynamically in JavaScript.
+TEST_F(PasswordAutofillAgentTest, FillSuggestionWithDynamicUsernameField) {
+  LoadHTML(kVisibleFormWithNoUsernameHTML);
+  UpdateOnlyPasswordElement();
+
+  // Simulate the browser sending the login info, but set |wait_for_username|
+  // to prevent the form from being immediately filled.
+  fill_data_.wait_for_username = true;
+  SimulateOnFillPasswordForm(fill_data_);
+
+  constexpr const char* kAddUsernameToFormScript =
+      "var new_input = document.createElement('input');"
+      "new_input.setAttribute('type', 'text');"
+      "new_input.setAttribute('id', 'username');"
+      "password_field = document.getElementById('password');"
+      "password_field.parentNode.insertBefore(new_input, password_field);";
+  ExecuteJavaScriptForTests(kAddUsernameToFormScript);
+  UpdateUsernameAndPasswordElements();
+  CheckTextFieldsDOMState(std::string(), false, std::string(), false);
+
+  // After filling with the suggestion, both fields should be autocompleted.
+  EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
+      password_element_, ASCIIToUTF16(kAliceUsername),
+      ASCIIToUTF16(kAlicePassword)));
+
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
+}
+
 // Tests that |FillSuggestion| doesn't change non-empty non-autofilled username
 // when interacting with the password field.
 TEST_F(PasswordAutofillAgentTest,
        FillSuggestionFromPasswordFieldWithUsernameManuallyFilled) {
   username_element_.SetValue(WebString::FromUTF8("user1"));
 
   // Simulate the browser sending the login info, but set |wait_for_username| to
   // prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
@@ skipping 721 matching lines @@
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   CheckTextFieldsState(std::string("Carol"), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, FillOnAccountSelectOnlyNoUsername) {
   SetFillOnAccountSelect();
 
   // Load a form with no username and update test data.
   LoadHTML(kVisibleFormWithNoUsernameHTML);
-  username_element_.Reset();
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateOnlyPasswordElement();
   fill_data_.username_field = FormFieldData();
   UpdateOriginForHTML(kVisibleFormWithNoUsernameHTML);
   fill_data_.additional_logins.clear();
   fill_data_.other_possible_usernames.clear();
 
   password_element_.SetValue("");
   password_element_.SetAutofilled(false);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   EXPECT_TRUE(password_element_.SuggestedValue().IsEmpty());
   EXPECT_FALSE(password_element_.IsAutofilled());
   CheckSuggestions(std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, ShowPopupOnEmptyPasswordField) {
   // Load a form with no username and update test data.
   LoadHTML(kVisibleFormWithNoUsernameHTML);
-  username_element_.Reset();
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateOnlyPasswordElement();
   fill_data_.username_field = FormFieldData();
   UpdateOriginForHTML(kVisibleFormWithNoUsernameHTML);
   fill_data_.additional_logins.clear();
   fill_data_.other_possible_usernames.clear();
 
   password_element_.SetValue("");
   password_element_.SetAutofilled(false);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Show popup suggesstion when the password field is empty.
   password_element_.SetValue("");
   password_element_.SetAutofilled(false);
 
   SimulateSuggestionChoiceOfUsernameAndPassword(
       password_element_, base::string16(), ASCIIToUTF16(kAlicePassword));
   CheckSuggestions(std::string(), false);
   EXPECT_EQ(ASCIIToUTF16(kAlicePassword), password_element_.Value().Utf16());
   EXPECT_TRUE(password_element_.IsAutofilled());
 }
 
 TEST_F(PasswordAutofillAgentTest, ShowPopupOnAutofilledPasswordField) {
   // Load a form with no username and update test data.
   LoadHTML(kVisibleFormWithNoUsernameHTML);
-  username_element_.Reset();
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateOnlyPasswordElement();
   fill_data_.username_field = FormFieldData();
   UpdateOriginForHTML(kVisibleFormWithNoUsernameHTML);
   fill_data_.additional_logins.clear();
   fill_data_.other_possible_usernames.clear();
 
   password_element_.SetValue("");
   password_element_.SetAutofilled(false);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Show popup suggesstion when the password field is autofilled.
   password_element_.SetValue("123");
   password_element_.SetAutofilled(true);
 
   SimulateSuggestionChoiceOfUsernameAndPassword(
       password_element_, base::string16(), ASCIIToUTF16(kAlicePassword));
   CheckSuggestions(std::string(), false);
   EXPECT_EQ(ASCIIToUTF16(kAlicePassword), password_element_.Value().Utf16());
   EXPECT_TRUE(password_element_.IsAutofilled());
 }
 
 TEST_F(PasswordAutofillAgentTest, NotShowPopupPasswordField) {
   // Load a form with no username and update test data.
   LoadHTML(kVisibleFormWithNoUsernameHTML);
-  username_element_.Reset();
-  WebDocument document = GetMainFrame()->GetDocument();
-  WebElement element =
-      document.GetElementById(WebString::FromUTF8(kPasswordName));
-  ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  UpdateOnlyPasswordElement();
   fill_data_.username_field = FormFieldData();
   UpdateOriginForHTML(kVisibleFormWithNoUsernameHTML);
   fill_data_.additional_logins.clear();
   fill_data_.other_possible_usernames.clear();
 
   password_element_.SetValue("");
   password_element_.SetAutofilled(false);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnFillPasswordForm(fill_data_);
@@ skipping 21 matching lines @@
   SetElementReadOnly(username_element_, true);
 
   CheckTextFieldsState(std::string("foobar"), false, std::string(), false);
 }
 
 // Test that the last plain text field before a password field is chosen as a
 // username, in a form with 2 plain text fields without username predictions.
 TEST_F(PasswordAutofillAgentTest, FindingUsernameWithoutAutofillPredictions) {
   LoadHTML(kFormHTMLWithTwoTextFields);
   UpdateUsernameAndPasswordElements();
-  blink::WebInputElement email_element = GetInputElementByID(kEmailName);
+  WebInputElement email_element = GetInputElementByID(kEmailName);
   SimulateUsernameChange("temp");
   SimulateUserInputChangeForElement(&email_element, "temp@google.com");
   SimulatePasswordChange("random");
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSendSubmitEvent(username_element_.Form());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.Form());
 
   // Observe that the PasswordAutofillAgent identifies the second field (e-mail)
   // as username.
   ExpectFormSubmittedWithUsernameAndPasswords("temp@google.com", "random", "");
 }
 
 // Tests that field predictions are followed when identifying the username
 // and password in a password form with two plain text fields.
 TEST_F(PasswordAutofillAgentTest, FindingFieldsWithAutofillPredictions) {
   LoadHTML(kFormHTMLWithTwoTextFields);
   UpdateUsernameAndPasswordElements();
-  blink::WebInputElement email_element = GetInputElementByID(kEmailName);
+  WebInputElement email_element = GetInputElementByID(kEmailName);
   SimulateUsernameChange("temp");
   SimulateUserInputChangeForElement(&email_element, "temp@google.com");
   SimulatePasswordChange("random");
   // Find FormData for visible password form.
   WebFormElement form_element = username_element_.Form();
   FormData form_data;
   ASSERT_TRUE(WebFormElementToFormData(
       form_element, blink::WebFormControlElement(), nullptr,
       form_util::EXTRACT_NONE, &form_data, nullptr));
   // Simulate Autofill predictions: the first field is username, the third
@@ skipping 87 matching lines @@
 // If password generation is enabled for a field, password autofill should not
 // show UI.
 TEST_F(PasswordAutofillAgentTest, PasswordGenerationSupersedesAutofill) {
   LoadHTML(kSignupFormHTML);
 
   // Update password_element_;
   WebDocument document = GetMainFrame()->GetDocument();
   WebElement element =
       document.GetElementById(WebString::FromUTF8("new_password"));
   ASSERT_FALSE(element.IsNull());
-  password_element_ = element.To<blink::WebInputElement>();
+  password_element_ = element.To<WebInputElement>();
 
   // Update fill_data_ for the new form and simulate filling. Pretend as if
   // the password manager didn't detect a username field so it will try to
   // show UI when the password field is focused.
   fill_data_.wait_for_username = true;
   fill_data_.username_field = FormFieldData();
   fill_data_.password_field.name = base::ASCIIToUTF16("new_password");
   UpdateOriginForHTML(kSignupFormHTML);
   SimulateOnFillPasswordForm(fill_data_);
 
@@ skipping 71 matching lines @@
   // message.
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, true);
   CheckSuggestions("", false);
 }
 
 // Tests that NOT_PASSWORD field predictions are followed so that no password
 // form is submitted.
 TEST_F(PasswordAutofillAgentTest, IgnoreNotPasswordFields) {
   LoadHTML(kCreditCardFormHTML);
-  blink::WebInputElement credit_card_owner_element =
+  WebInputElement credit_card_owner_element =
       GetInputElementByID(kCreditCardOwnerName);
-  blink::WebInputElement credit_card_number_element =
+  WebInputElement credit_card_number_element =
       GetInputElementByID(kCreditCardNumberName);
-  blink::WebInputElement credit_card_verification_element =
+  WebInputElement credit_card_verification_element =
       GetInputElementByID(kCreditCardVerificationName);
   SimulateUserInputChangeForElement(&credit_card_owner_element, "JohnSmith");
   SimulateUserInputChangeForElement(&credit_card_number_element,
                                     "1234123412341234");
   SimulateUserInputChangeForElement(&credit_card_verification_element, "123");
   // Find FormData for visible form.
   WebFormElement form_element = credit_card_number_element.Form();
   FormData form_data;
   ASSERT_TRUE(WebFormElementToFormData(
       form_element, blink::WebFormControlElement(), nullptr,
@@ skipping 335 matching lines @@
     // Get the username and password form input elelments.
     blink::WebDocument document = GetMainFrame()->GetDocument();
     blink::WebVector<WebFormElement> forms;
     document.Forms(forms);
     WebFormElement form_element = forms[0];
     std::vector<blink::WebFormControlElement> control_elements =
         form_util::ExtractAutofillableElementsInForm(form_element);
     bool has_fillable_username =
         (kEmpty != test_case.fill_data_username_field_name);
     if (has_fillable_username) {
-      username_element_ = control_elements[0].To<blink::WebInputElement>();
-      password_element_ = control_elements[1].To<blink::WebInputElement>();
+      username_element_ = control_elements[0].To<WebInputElement>();
+      password_element_ = control_elements[1].To<WebInputElement>();
     } else {
-      password_element_ = control_elements[0].To<blink::WebInputElement>();
+      password_element_ = control_elements[0].To<WebInputElement>();
     }
 
     UpdateOriginForHTML(test_case.html_form);
     if (test_case.does_trigger_autocomplete_on_fill) {
       // Prepare |fill_data_| to trigger autocomplete.
       fill_data_.is_possible_change_password_form =
           test_case.is_possible_change_password_form;
       fill_data_.username_field.name =
           ASCIIToUTF16(test_case.fill_data_username_field_name);
       fill_data_.password_field.name =
@@ skipping 304 matching lines @@
 TEST_F(PasswordAutofillAgentTest, AutocompleteWhenPageUrlIsChanged) {
   // Simulate that JavaScript changes url.
   fill_data_.origin = GURL(fill_data_.origin.possibly_invalid_spec() + "/path");
 
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should have been autocompleted.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 }
 }  // namespace autofill