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 284 matching lines @@
   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);
+    if (is_user_input)
+      SimulateUserInputChangeForElement(&input, input_frame, new_value);
+    else
+      input.setValue(WebString::fromUTF8(new_value), false);
 
-      // Also pass the message to the testing object.
-      if (input_frame == GetMainFrame())
-        password_autofill_agent_->FirstUserGestureObserved();
-    }
-    input_frame->toWebLocalFrame()->autofillClient()->textFieldDidChange(input);
+    ProcessEvents();
+  }
+
+  void ProcessEvents() {
     // 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)));
 
@@ skipping 29 matching lines @@
   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 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,
               static_cast<std::string>(username_element.value().utf8()));
     EXPECT_EQ(username_autofilled, username_element.isAutofilled());
@@ skipping 293 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", true, true);
 
   // 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", true, true);
   CheckTextFieldsState("a", false, std::string(), false);
-  SimulateUsernameChange("al", true);
+  SimulateUsernameChange("al", true, true);
   CheckTextFieldsState("al", false, std::string(), false);
-  SimulateUsernameChange(kAliceUsername, true);
+  SimulateUsernameChange(kAliceUsername, true, true);
   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", true, true);
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("a", false, std::string(), false);
-  username_element_.setValue("al");
+  SimulateUsernameChange("al", true, true);
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("al", false, std::string(), false);
-  username_element_.setValue("alices");
+  SimulateUsernameChange("alices", true, true);
   static_cast<blink::WebAutofillClient*>(autofill_agent_)
       ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("alices", false, std::string(), false);
-  username_element_.setValue(ASCIIToUTF16(kAliceUsername));
+  SimulateUsernameChange(kAliceUsername, true, true);
   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", true, true);
   // 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');
+  ProcessEvents();
   // 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.
+  SimulateUserTypingKeyCodeWithShift(ui::VKEY_BACK, false);
+  ProcessEvents();
+  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');
+  ProcessEvents();
   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", true, true);
   // 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", true, true);
   // 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", true, true);
   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", true, true);
+  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.
+  content::RenderFrame::FromWebFrame(iframe)
+      ->OnMessageReceived(AutofillMsg_FirstUserGestureObservedInTab(0));
   SimulateInputChangeForElement(
       kAliceUsername, true, iframe, username_input, true);
 
   CheckTextFieldsStateForElements(username_input,
                                   kAliceUsername,
                                   true,
                                   password_input,
                                   kAlicePassword,
                                   true,
                                   false);
@@ skipping 89 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", true, true);
   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", true, true);
   // 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 84 matching lines @@
   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);
   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", true, true);
   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 199 matching lines @@
   ClearUsernameAndPasswordFields();
 
   // The user enters a password
   SimulateInputChangeForElement("someOtherPassword",
                                 /*move_caret_to_end=*/true,
                                 GetMainFrame(),
                                 password_element_,
                                 /*is_user_input=*/true);
 
   // Simulate the user typing a stored username.
-  SimulateUsernameChange(kAliceUsername, true);
+  SimulateUsernameChange(kAliceUsername, true, true);
   // 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) {
@@ skipping 265 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