Allow only a user gesture to trigger autofill popup

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 "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
@@ skipping 279 matching lines @@
     username_element_.setAutofilled(false);
     password_element_.setValue("");
     password_element_.setAutofilled(false);
   }
 
   void SimulateDidEndEditing(WebFrame* input_frame, WebInputElement& input) {
     static_cast<blink::WebAutofillClient*>(autofill_agent_)
         ->textFieldDidEndEditing(input);
   }
 
-  void SimulateInputChangeForElement(const std::string& new_value,
-                                     bool move_caret_to_end,
-                                     WebFrame* input_frame,
-                                     WebInputElement& input,
-                                     bool is_user_input) {
-    input.setValue(WebString::fromUTF8(new_value), is_user_input);
-    // The field must have focus or AutofillAgent will think the
-    // change should be ignored.
-    while (!input.focused())
-      input_frame->document().frame()->view()->advanceFocus(false);
-    if (move_caret_to_end)
-      input.setSelectionRange(new_value.length(), new_value.length());
-    if (is_user_input) {
-      AutofillMsg_FirstUserGestureObservedInTab msg(0);
-      content::RenderFrame::FromWebFrame(input_frame)->OnMessageReceived(msg);
-
-      // Also pass the message to the testing object.
-      if (input_frame == GetMainFrame())
-        password_autofill_agent_->FirstUserGestureObserved();
-    }
-    input_frame->toWebLocalFrame()->autofillClient()->textFieldDidChange(input);
-    // Processing is delayed because of a Blink bug:
-    // https://bugs.webkit.org/show_bug.cgi?id=16976
-    // See PasswordAutofillAgent::TextDidChangeInTextField() for details.
-
-    // Autocomplete will trigger a style recalculation when we put up the next
-    // frame, but we don't want to wait that long. Instead, trigger a style
-    // recalcuation manually after TextFieldDidChangeImpl runs.
-    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &PasswordAutofillAgentTest::LayoutMainFrame, base::Unretained(this)));
-
-    base::MessageLoop::current()->RunUntilIdle();
-  }
-
   void SimulateSuggestionChoice(WebInputElement& username_input) {
     base::string16 username(base::ASCIIToUTF16(kAliceUsername));
     base::string16 password(base::ASCIIToUTF16(kAlicePassword));
     SimulateSuggestionChoiceOfUsernameAndPassword(username_input, username,
                                                   password);
   }
 
   void SimulateSuggestionChoiceOfUsernameAndPassword(
       WebInputElement& input,
       const base::string16& username,
       const base::string16& password) {
     // This call is necessary to setup the autofill agent appropriate for the
     // user selection; simulates the menu actually popping up.
     render_thread_->sink().ClearMessages();
     static_cast<autofill::PageClickListener*>(autofill_agent_)
         ->FormControlElementClicked(input, false);
 
     AutofillMsg_FillPasswordSuggestion msg(0, username, password);
     static_cast<content::RenderFrameObserver*>(autofill_agent_)
         ->OnMessageReceived(msg);
   }
 
-  void LayoutMainFrame() {
-    GetMainFrame()->view()->layout();
+  void SimulateUsernameChange(const std::string& username) {
+    SimulateUserInputChangeForElement(&username_element_, username);
   }
 
-  void SimulateUsernameChange(const std::string& username,
-                              bool move_caret_to_end,
-                              bool is_user_input = false) {
-    SimulateInputChangeForElement(username,
-                                  move_caret_to_end,
-                                  GetMainFrame(),
-                                  username_element_,
-                                  is_user_input);
-  }
-
-  void SimulateKeyDownEvent(const WebInputElement& element,
-                            ui::KeyboardCode key_code) {
-    blink::WebKeyboardEvent key_event;
-    key_event.windowsKeyCode = key_code;
-    static_cast<blink::WebAutofillClient*>(autofill_agent_)
-        ->textFieldDidReceiveKeyDown(element, key_event);
+  void SimulatePasswordChange(const std::string& password) {
+    SimulateUserInputChangeForElement(&password_element_, password);
   }
 
   void CheckTextFieldsStateForElements(const WebInputElement& username_element,
                                        const std::string& username,
                                        bool username_autofilled,
                                        const WebInputElement& password_element,
                                        const std::string& password,
                                        bool password_autofilled,
                                        bool checkSuggestedValue) {
     EXPECT_EQ(username,
@@ skipping 295 matching lines @@
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Tests that editing the password clears the autocompleted password field.
 TEST_F(PasswordAutofillAgentTest, PasswordClearOnEdit) {
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Simulate the user changing the username to some unknown username.
-  SimulateUsernameChange("alicia", true);
+  SimulateUsernameChange("alicia");
 
   // The password should have been cleared.
   CheckTextFieldsState("alicia", false, std::string(), false);
 }
 
 // Tests that we only autocomplete on focus lost and with a full username match
 // when |wait_for_username| is true.
 TEST_F(PasswordAutofillAgentTest, WaitUsername) {
   // Simulate the browser sending back the login info.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   // No auto-fill should have taken place.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 
   // No autocomplete should happen when text is entered in the username.
-  SimulateUsernameChange("a", true);
+  SimulateUsernameChange("a");
   CheckTextFieldsState("a", false, std::string(), false);
-  SimulateUsernameChange("al", true);
+  SimulateUsernameChange("al");
   CheckTextFieldsState("al", false, std::string(), false);
-  SimulateUsernameChange(kAliceUsername, true);
+  SimulateUsernameChange(kAliceUsername);
   CheckTextFieldsState(kAliceUsername, false, std::string(), false);
 
   // Autocomplete should happen only when the username textfield is blurred with
   // a full match.
-  username_element_.setValue("a");
+  SimulateUsernameChange("a");
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("a", false, std::string(), false);
-  username_element_.setValue("al");
+  SimulateUsernameChange("al");
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("al", false, std::string(), false);
-  username_element_.setValue("alices");
+  SimulateUsernameChange("alices");
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("alices", false, std::string(), false);
-  username_element_.setValue(ASCIIToUTF16(kAliceUsername));
+  SimulateUsernameChange(kAliceUsername);
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
-  CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Tests that inline autocompletion works properly.
 TEST_F(PasswordAutofillAgentTest, InlineAutocomplete) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   ClearUsernameAndPasswordFields();
 
   // Simulate the user typing in the first letter of 'alice', a stored
   // username.
-  SimulateUsernameChange("a", true);
+  SimulateUsernameChange("a");
   // Both the username and password text fields should reflect selection of the
   // stored login.
-  CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
   // And the selection should have been set to 'lice', the last 4 letters.
   CheckUsernameSelection(1, 5);
 
   // Now the user types the next letter of the same username, 'l'.
-  SimulateUsernameChange("al", true);
+  SimulateUserTypingASCIICharacter('l', true);
   // Now the fields should have the same value, but the selection should have a
   // different start value.
-  CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
   CheckUsernameSelection(2, 5);
 
-  // Test that deleting does not trigger autocomplete.
-  SimulateKeyDownEvent(username_element_, ui::VKEY_BACK);
-  SimulateUsernameChange("alic", true);
-  CheckTextFieldsState("alic", false, std::string(), false);
-  CheckUsernameSelection(4, 4);  // No selection.
-  // Reset the last pressed key to something other than backspace.
-  SimulateKeyDownEvent(username_element_, ui::VKEY_A);
+  // Test that backspace will erase the selection and will stop autocompletion.
+  SimulateUserTypingASCIICharacter(ui::VKEY_BACK, true);
+  CheckTextFieldsState("al", false, std::string(), false);
+  CheckUsernameSelection(2, 2);  // No selection.
 
   // Now lets say the user goes astray from the stored username and types the
   // letter 'f', spelling 'alf'.  We don't know alf (that's just sad), so in
   // practice the username should no longer be 'alice' and the selected range
   // should be empty.
-  SimulateUsernameChange("alf", true);
+  SimulateUserTypingASCIICharacter('f', true);
   CheckTextFieldsState("alf", false, std::string(), false);
   CheckUsernameSelection(3, 3);  // No selection.
 
   // Ok, so now the user removes all the text and enters the letter 'b'.
-  SimulateUsernameChange("b", true);
+  SimulateUsernameChange("b");
   // The username and password fields should match the 'bob' entry.
-  CheckTextFieldsState(kBobUsername, true, kBobPassword, true);
+  CheckTextFieldsDOMState(kBobUsername, true, kBobPassword, true);
   CheckUsernameSelection(1, 3);
 
   // Then, the user again removes all the text and types an uppercase 'C'.
-  SimulateUsernameChange("C", true);
+  SimulateUsernameChange("C");
   // The username and password fields should match the 'Carol' entry.
-  CheckTextFieldsState(kCarolUsername, true, kCarolPassword, true);
+  CheckTextFieldsDOMState(kCarolUsername, true, kCarolPassword, true);
   CheckUsernameSelection(1, 5);
+
   // The user removes all the text and types a lowercase 'c'.  We only
   // want case-sensitive autocompletion, so the username and the selected range
   // should be empty.
-  SimulateUsernameChange("c", true);
+  SimulateUsernameChange("c");
   CheckTextFieldsState("c", false, std::string(), false);
   CheckUsernameSelection(1, 1);
 
   // Check that we complete other_possible_usernames as well.
-  SimulateUsernameChange("R", true);
-  CheckTextFieldsState(kCarolAlternateUsername, true, kCarolPassword, true);
+  SimulateUsernameChange("R");
+  CheckTextFieldsDOMState(kCarolAlternateUsername, true, kCarolPassword, true);
   CheckUsernameSelection(1, 17);
 }
 
 TEST_F(PasswordAutofillAgentTest, IsWebNodeVisibleTest) {
   blink::WebVector<blink::WebFormElement> forms1, forms2, forms3;
   blink::WebFrame* frame;
 
   LoadHTML(kVisibleFormWithNoUsernameHTML);
   frame = GetMainFrame();
   frame->document().forms(forms1);
@@ skipping 108 matching lines @@
 
   WebInputElement username_input = username_element.to<WebInputElement>();
   WebInputElement password_input = password_element.to<WebInputElement>();
   ASSERT_FALSE(username_element.isNull());
 
   CheckTextFieldsStateForElements(
       username_input, "", false, password_input, "", false, false);
 
   // Simulate the user typing in the username in the iframe which should cause
   // an autofill.
-  SimulateInputChangeForElement(
-      kAliceUsername, true, iframe, username_input, true);
+  content::RenderFrame::FromWebFrame(iframe)
+      ->OnMessageReceived(AutofillMsg_FirstUserGestureObservedInTab(0));
+  SimulateUserInputChangeForElement(&username_input, kAliceUsername);
 
   CheckTextFieldsStateForElements(username_input,
                                   kAliceUsername,
                                   true,
                                   password_input,
                                   kAlicePassword,
                                   true,
                                   false);
 }
 
@@ skipping 87 matching lines @@
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should not yet have been autocompleted.
   CheckTextFieldsState(std::string(), false, std::string(), false);
 
   // Simulate a click just to force a user gesture, since the username value is
   // set directly.
   SimulateElementClick(kUsernameName);
 
-  // Simulate the user entering her username and selecting the matching autofill
-  // from the dropdown.
-  SimulateUsernameChange(kAliceUsername, true, true);
+  // Simulate the user entering the first letter of her username and selecting
+  // the matching autofill from the dropdown.
+  SimulateUsernameChange("a");
   SimulateSuggestionChoice(username_element_);
 
   // The username and password should now have been autocompleted.
   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 
   // JavaScript onChange events should have been triggered both for the username
   // and for the password.
   int username_onchange_called = -1;
   int password_onchange_called = -1;
   ASSERT_TRUE(
@@ skipping 237 matching lines @@
 // Tests that |ClearPreview| properly restores the original selection range of
 // username field that has initially been filled by inline autocomplete.
 TEST_F(PasswordAutofillAgentTest, ClearPreviewWithInlineAutocompletedUsername) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Simulate the user typing in the first letter of 'alice', a stored username.
-  SimulateUsernameChange("a", true);
+  SimulateUsernameChange("a");
   // Both the username and password text fields should reflect selection of the
   // stored login.
-  CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
   // The selection should have been set to 'lice', the last 4 letters.
   CheckUsernameSelection(1, 5);
 
   EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, "alicia", "secret"));
   EXPECT_EQ(
       "alicia",
       static_cast<std::string>(username_element_.suggestedValue().utf8()));
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(
       "secret",
       static_cast<std::string>(password_element_.suggestedValue().utf8()));
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(1, 6);
 
   EXPECT_TRUE(
       password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_EQ(kAliceUsername, username_element_.value().utf8());
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(username_element_.isAutofilled());
-  EXPECT_TRUE(password_element_.value().isEmpty());
+  EXPECT_EQ(kAlicePassword, password_element_.value().utf8());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(1, 5);
 }
 
 // Tests that logging is off by default.
 TEST_F(PasswordAutofillAgentTest, OnChangeLoggingState_NoMessage) {
   render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
   const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
@@ skipping 79 matching lines @@
   // Simulate a user clicking on the username element. This should produce a
   // message with all the usernames.
   render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, false);
   CheckSuggestions(std::string(), false);
 
   // Now simulate a user typing in an unrecognized username and then
   // clicking on the username element. This should also produce a message with
   // all the usernames.
-  SimulateUsernameChange("baz", true);
+  SimulateUsernameChange("baz");
   render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, true);
   CheckSuggestions("baz", true);
+  ClearUsernameAndPasswordFields();
 
   // Now simulate a user typing in the first letter of the username and then
   // clicking on the username element. While the typing of the first letter will
   // inline autocomplete, clicking on the element should still produce a full
   // suggestion list.
-  SimulateUsernameChange("a", true);
+  SimulateUsernameChange("a");
   render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, true);
   CheckSuggestions(kAliceUsername, true);
 }
 
 // Tests that there are no autosuggestions from the password manager when the
 // user clicks on the password field and the username field is editable when
 // FillOnAccountSelect is enabled.
 TEST_F(PasswordAutofillAgentTest,
@@ skipping 75 matching lines @@
   EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordSuggestions::ID));
 }
 
 // The user types in a username and a password, but then just before sending
 // the form off, a script clears them. This test checks that
 // PasswordAutofillAgent can still remember the username and the password
 // typed by the user.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_ScriptCleared) {
-  SimulateInputChangeForElement(
-      "temp", true, GetMainFrame(), username_element_, true);
-  SimulateInputChangeForElement(
-      "random", true, GetMainFrame(), password_element_, true);
+  SimulateUsernameChange("temp");
+  SimulatePasswordChange("random");
 
   // Simulate that the username and the password value was cleared by the
   // site's JavaScript before submit.
   username_element_.setValue(WebString());
   password_element_.setValue(WebString());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // username and password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but this time
 // it's the user who clears the username and the password. This test checks
 // that in that case, the last non-empty username and password are not
 // remembered.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_UserCleared) {
-  SimulateInputChangeForElement(
-      "temp", true, GetMainFrame(), username_element_, true);
-  SimulateInputChangeForElement(
-      "random", true, GetMainFrame(), password_element_, true);
+  SimulateUsernameChange("temp");
+  SimulatePasswordChange("random");
 
   // Simulate that the user actually cleared the username and password again.
-  SimulateInputChangeForElement("", true, GetMainFrame(), username_element_,
-                                true);
-  SimulateInputChangeForElement(
-      "", true, GetMainFrame(), password_element_, true);
+  SimulateUsernameChange("");
+  SimulatePasswordChange("");
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   // Observe that the PasswordAutofillAgent respects the user having cleared the
   // password.
   ExpectFormSubmittedWithUsernameAndPasswords("", "", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but uses the
 // new password instead of the current password.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_New) {
   const char kNewPasswordFormHTML[] =
       "<FORM name='LoginTestForm'>"
       "  <INPUT type='text' id='username' autocomplete='username'/>"
       "  <INPUT type='password' id='password' autocomplete='new-password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kNewPasswordFormHTML);
   UpdateUsernameAndPasswordElements();
 
-  SimulateInputChangeForElement(
-      "temp", true, GetMainFrame(), username_element_, true);
-  SimulateInputChangeForElement(
-      "random", true, GetMainFrame(), password_element_, true);
+  SimulateUsernameChange("temp");
+  SimulatePasswordChange("random");
 
   // Simulate that the username and the password value was cleared by
   // the site's JavaScript before submit.
   username_element_.setValue(WebString());
   password_element_.setValue(WebString());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "", "random");
 }
 
 // The user first accepts a suggestion, but then overwrites the password. This
 // test checks that the overwritten password is not reverted back if the user
 // triggers autofill through focusing (but not changing) the username again.
 TEST_F(PasswordAutofillAgentTest,
        NoopEditingDoesNotOverwriteManuallyEditedPassword) {
   // Simulate having credentials which needed to wait until the user starts
   // typing the username to be filled (e.g., PSL-matched credentials). Those are
   // the ones which can be filled as a result of TextFieldDidEndEditing.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
   // Simulate that the user typed her name to make the autofill work.
-  SimulateInputChangeForElement(kAliceUsername,
-                                /*move_caret_to_end=*/true,
-                                GetMainFrame(),
-                                username_element_,
-                                /*is_user_input=*/true);
+  SimulateUsernameChange(kAliceUsername);
   SimulateDidEndEditing(GetMainFrame(), username_element_);
   const std::string old_username(username_element_.value().utf8());
   const std::string old_password(password_element_.value().utf8());
   const std::string new_password(old_password + "modify");
 
   // The user changes the password.
-  SimulateInputChangeForElement(new_password,
-                                /*move_caret_to_end=*/true,
-                                GetMainFrame(),
-                                password_element_,
-                                /*is_user_input=*/true);
+  SimulatePasswordChange(new_password);
 
   // The user switches back into the username field, but leaves that without
   // changes.
   SimulateDidEndEditing(GetMainFrame(), username_element_);
 
   // The password should have stayed as the user changed it.
   CheckTextFieldsDOMState(old_username, true, new_password, false);
   // The password should not have a suggested value.
   CheckTextFieldsState(old_username, true, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest,
        InlineAutocompleteOverwritesManuallyEditedPassword) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   ClearUsernameAndPasswordFields();
 
   // The user enters a password
-  SimulateInputChangeForElement("someOtherPassword",
-                                /*move_caret_to_end=*/true,
-                                GetMainFrame(),
-                                password_element_,
-                                /*is_user_input=*/true);
+  SimulatePasswordChange("someOtherPassword");
 
   // Simulate the user typing a stored username.
-  SimulateUsernameChange(kAliceUsername, true);
+  SimulateUsernameChange(kAliceUsername);
   // The autofileld password should replace the typed one.
   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // The user types in a username and a password, but then just before sending
 // the form off, a script changes them. This test checks that
 // PasswordAutofillAgent can still remember the username and the password
 // typed by the user.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastTypedUsernameAndPasswordOnSubmit_ScriptChanged) {
-  SimulateInputChangeForElement("temp", true, GetMainFrame(), username_element_,
-                                true);
-  SimulateInputChangeForElement("random", true, GetMainFrame(),
-                                password_element_, true);
+  SimulateUsernameChange("temp");
+  SimulatePasswordChange("random");
 
   // Simulate that the username and the password value was changed by the
   // site's JavaScript before submit.
   username_element_.setValue(WebString("new username"));
   password_element_.setValue(WebString("new password"));
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSendSubmitEvent(username_element_.form());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
@@ skipping 26 matching lines @@
 
 // The username/password is autofilled by password manager then user types in a
 // username and a password. Then just before sending the form off, a script
 // changes them. This test checks that PasswordAutofillAgent can still remember
 // the username and the password typed by the user.
 TEST_F(
     PasswordAutofillAgentTest,
     RememberLastTypedAfterAutofilledUsernameAndPasswordOnSubmit_ScriptChanged) {
   SimulateOnFillPasswordForm(fill_data_);
 
-  SimulateInputChangeForElement("temp", true, GetMainFrame(), username_element_,
-                                true);
-  SimulateInputChangeForElement("random", true, GetMainFrame(),
-                                password_element_, true);
+  SimulateUsernameChange("temp");
+  SimulatePasswordChange("random");
 
   // Simulate that the username and the password value was changed by the
   // site's JavaScript before submit.
   username_element_.setValue(WebString("new username"));
   password_element_.setValue(WebString("new password"));
   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 still remembered the last typed
   // username and password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
 }
 
 // The user starts typing username then it is autofilled.
 // PasswordAutofillAgent should remember the username that was autofilled,
 // not last typed.
 TEST_F(PasswordAutofillAgentTest, RememberAutofilledUsername) {
-  SimulateInputChangeForElement("Te", true, GetMainFrame(), username_element_,
-                                true);
+  SimulateUsernameChange("Te");
   // Simulate that the username was changed by autofilling.
   username_element_.setValue(WebString("temp"));
-  SimulateInputChangeForElement("random", true, GetMainFrame(),
-                                password_element_, true);
+  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 still remembered the last typed
   // username and password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
 }
@@ skipping 124 matching lines @@
 
   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);
-  SimulateInputChangeForElement("temp", true, GetMainFrame(), username_element_,
-                                true);
-  SimulateInputChangeForElement("temp@google.com", true, GetMainFrame(),
-                                email_element, true);
-  SimulateInputChangeForElement("random", true, GetMainFrame(),
-                                password_element_, true);
+  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 username predictions are followed when identifying the username
 // in a password form with two plain text fields.
 TEST_F(PasswordAutofillAgentTest, FindingUsernameWithAutofillPredictions) {
   LoadHTML(kFormHTMLWithTwoTextFields);
   UpdateUsernameAndPasswordElements();
   blink::WebInputElement email_element = GetInputElementByID(kEmailName);
-  SimulateInputChangeForElement("temp", true, GetMainFrame(), username_element_,
-                                true);
-  SimulateInputChangeForElement("temp@google.com", true, GetMainFrame(),
-                                email_element, true);
-  SimulateInputChangeForElement("random", true, GetMainFrame(),
-                                password_element_, true);
-
+  SimulateUsernameChange("temp");
+  SimulateUserInputChangeForElement(&email_element, "temp@google.com");
+  SimulatePasswordChange("random");
   // Find FormData for visible password form.
   blink::WebFormElement form_element = username_element_.form();
   FormData form_data;
   ASSERT_TRUE(WebFormElementToFormData(form_element,
                                        blink::WebFormControlElement(),
                                        EXTRACT_NONE, &form_data, nullptr));
   // Simulate Autofill predictions: the first field is username.
   std::map<autofill::FormData, autofill::FormFieldData> predictions;
   predictions[form_data] = form_data.fields[0];
   AutofillMsg_AutofillUsernameDataReceived msg(0, predictions);
@@ skipping 14 matching lines @@
       ->WillSendSubmitEvent(username_element_.form());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   // Observe that the PasswordAutofillAgent identifies the first field as
   // username.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
 }
 
 }  // namespace autofill