Add password manager autocomplete suggestion when a username element in clicked.

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 236 matching lines @@
   void ClearUsernameAndPasswordFields() {
     username_element_.setValue("");
     username_element_.setAutofilled(false);
     password_element_.setValue("");
     password_element_.setAutofilled(false);
   }
 
   void SimulateUsernameChangeForElement(const std::string& username,
                                         bool move_caret_to_end,
                                         WebFrame* input_frame,
-                                        WebInputElement& username_input) {
-    username_input.setValue(WebString::fromUTF8(username));
+                                        WebInputElement& username_input,
+                                        bool is_user_input) {
+    username_input.setValue(WebString::fromUTF8(username), is_user_input);
     // The field must have focus or AutofillAgent will think the
     // change should be ignored.
     while (!username_input.focused())
       input_frame->document().frame()->view()->advanceFocus(false);
     if (move_caret_to_end)
       username_input.setSelectionRange(username.length(), username.length());
+    if (is_user_input)
+      password_autofill_->set_user_gesture_occurred(true);
     autofill_agent_->textFieldDidChange(username_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(const std::string& username,
+                                WebInputElement& username_input) {
+    blink::WebString blink_username = blink::WebString::fromUTF8(username);
+
+    // This call is necessary to setup the autofill agent appropriate for the
+    // user selection; simulates the menu actually popping up.
+    autofill_agent_->InputElementClicked(username_input, false, true);
+
+    autofill_agent_->OnAcceptPasswordAutofillSuggestion(blink_username);
+  }
+
   void LayoutMainFrame() {
     GetMainFrame()->view()->layout();
   }
 
   void SimulateUsernameChange(const std::string& username,
-                              bool move_caret_to_end) {
-    SimulateUsernameChangeForElement(username, move_caret_to_end,
-                                     GetMainFrame(), username_element_);
+                              bool move_caret_to_end,
+                              bool is_user_input = false) {
+    SimulateUsernameChangeForElement(username,
+                                     move_caret_to_end,
+                                     GetMainFrame(),
+                                     username_element_,
+                                     is_user_input);
   }
 
   // Tests that no suggestion popup is generated when the username_element_ is
   // edited.
   void ExpectNoSuggestionsPopup() {
     // The first test below ensures that the suggestions have been handled by
     // the password_autofill_agent, even though autocomplete='off' is set. The
     // second check ensures that, although handled, no "show suggestions" IPC to
     // the browser was generated.
     //
     // This is interesting in the specific case of an autocomplete='off' form
     // that also has a remembered username and password
     // (http://crbug.com/326679). To fix the DCHECK that this case used to hit,
     // |true| is returned from ShowSuggestions for all forms with valid
     // usersnames that are autocomplete='off', prentending that a selection box
     // has been shown to the user. Of course, it hasn't, so a message is never
     // sent to the browser on acceptance, and the DCHECK isn't hit (and nothing
     // is filled).
     //
     // These tests only make sense in the context of not ignoring
     // autocomplete='off', so only test them if the disable autocomplete='off'
     // flag is not enabled.
     // TODO(jww): Remove this function and callers once autocomplete='off' is
     // permanently ignored.
     if (!ShouldIgnoreAutocompleteOffForPasswordFields()) {
       EXPECT_TRUE(autofill_agent_->password_autofill_agent_->ShowSuggestions(
-          username_element_));
+          username_element_, false));
 
       EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
           AutofillHostMsg_ShowPasswordSuggestions::ID));
     }
   }
 
   void SimulateKeyDownEvent(const WebInputElement& element,
                             ui::KeyboardCode key_code) {
     blink::WebKeyboardEvent key_event;
     key_event.windowsKeyCode = key_code;
     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 = true) {
+                                       bool checkSuggestedValue) {
     EXPECT_EQ(username,
               static_cast<std::string>(username_element.value().utf8()));
     EXPECT_EQ(username_autofilled, username_element.isAutofilled());
     EXPECT_EQ(password,
               static_cast<std::string>(
                   checkSuggestedValue ? password_element.suggestedValue().utf8()
                                       : password_element.value().utf8()));
     EXPECT_EQ(password_autofilled, password_element.isAutofilled());
   }
 
   // Checks the DOM-accessible value of the username element and the
   // *suggested* value of the password element.
   void CheckTextFieldsState(const std::string& username,
                             bool username_autofilled,
                             const std::string& password,
                             bool password_autofilled) {
-    CheckTextFieldsStateForElements(username_element_, username,
-                                    username_autofilled, password_element_,
-                                    password, password_autofilled);
+    CheckTextFieldsStateForElements(username_element_,
+                                    username,
+                                    username_autofilled,
+                                    password_element_,
+                                    password,
+                                    password_autofilled,
+                                    true);
   }
 
   // Checks the DOM-accessible value of the username element and the
   // DOM-accessible value of the password element.
   void CheckTextFieldsDOMState(const std::string& username,
                                bool username_autofilled,
                                const std::string& password,
                                bool password_autofilled) {
     CheckTextFieldsStateForElements(username_element_,
                                     username,
@@ skipping 275 matching lines @@
   username_element_.setValue(ASCIIToUTF16(kAliceUsername));
   autofill_agent_->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState(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_);
 
-  // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
-  // Simulate the user typing in the first letter of 'alice', a stored username.
+  // Simulate the user typing in the first letter of 'alice', a stored
+  // username.
   SimulateUsernameChange("a", true);
   // Both the username and password text fields should reflect selection of the
   // stored login.
   CheckTextFieldsState(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);
   // Now the fields should have the same value, but the selection should have a
@@ skipping 153 matching lines @@
 
   WebElement username_element = document.getElementById(kUsernameName);
   WebElement password_element = document.getElementById(kPasswordName);
   ASSERT_FALSE(username_element.isNull());
   ASSERT_FALSE(password_element.isNull());
 
   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);
+  CheckTextFieldsStateForElements(
+      username_input, "", false, password_input, "", false, false);
 
-  // Simulate the user typing in the username in the iframe, which should cause
-  // an autofill.
-  SimulateUsernameChangeForElement(kAliceUsername, true,
-                                   iframe, username_input);
+  // Simulate the user typing in the username in the iframe and then selecting
+  // the autofill choice from the dropdown, thus causing an autofill.
+  SimulateUsernameChangeForElement(
+      kAliceUsername, true, iframe, username_input, false);
+  SimulateElementClick(kUsernameName);
+  SimulateSuggestionChoice(kAliceUsername, username_input);
 
-  CheckTextFieldsStateForElements(username_input, kAliceUsername, true,
-                                  password_input, kAlicePassword, true);
+  CheckTextFieldsStateForElements(username_input,
+                                  kAliceUsername,
+                                  true,
+                                  password_input,
+                                  kAlicePassword,
+                                  true,
+                                  false);
 }
 
 // Tests that a password will only be filled as a suggested and will not be
 // accessible by the DOM until a user gesture has occurred.
 TEST_F(PasswordAutofillAgentTest, GestureRequiredTest) {
   // Trigger the initial autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should have been autocompleted.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
@@ skipping 141 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.
-  username_element_.setValue(ASCIIToUTF16(kAliceUsername), true);
-  autofill_agent_->textFieldDidEndEditing(username_element_);
+  // Simulate the user entering her username and selecting the matching autofill
+  // from the dropdown.
+  SimulateUsernameChange(kAliceUsername, true, true);
+  SimulateSuggestionChoice(kAliceUsername, 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(
       ExecuteJavaScriptAndReturnIntValue(
           ASCIIToUTF16("usernameOnchangeCalled ? 1 : 0"),
           &username_onchange_called));
   EXPECT_EQ(1, username_onchange_called);
   ASSERT_TRUE(
       ExecuteJavaScriptAndReturnIntValue(
           ASCIIToUTF16("passwordOnchangeCalled ? 1 : 0"),
           &password_onchange_called));
   EXPECT_EQ(1, password_onchange_called);
 }
 
+// Tests that autocomplete works when the user clicks on an element and chooses
+// a suggestion from the autofill suggestion list. {
+TEST_F(PasswordAutofillAgentTest, ClickAndSelect) {
+  // Simulate the browser sending back the login info.
+  SimulateOnFillPasswordForm(fill_data_);
+
+  // Clear the text fields to start fresh.
+  ClearUsernameAndPasswordFields();
+
+  SimulateElementClick(kUsernameName);
+  SimulateSuggestionChoice(kAliceUsername, username_element_);
+
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
+}
+
 }  // namespace autofill