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 246 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)
+      autofill_agent_->password_autofill_agent_->gatekeeper_.OnUserGesture();
     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(WebInputElement& username_input) {
+    blink::WebString blink_username =
+        blink::WebString::fromUTF8(kAliceUsername);
+    blink::WebString blink_password =
+        blink::WebString::fromUTF8(kAlicePassword);
+
+    // This call is necessary to setup the autofill agent appropriate for the
+    // user selection; simulates the menu actually popping up.
+    render_thread_->sink().ClearMessages();
+    autofill_agent_->FormControlElementClicked(username_input, false);
+
+    autofill_agent_->OnFillPasswordSuggestion(blink_username, blink_password);
+  }
+
   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,
                                     username_autofilled,
                                     password_element_,
                                     password,
                                     password_autofilled,
                                     false);
   }
 
   void CheckUsernameSelection(int start, int end) {
     EXPECT_EQ(start, username_element_.selectionStart());
     EXPECT_EQ(end, username_element_.selectionEnd());
   }
 
+  void ExpectOneCredential(const base::string16& username) {
+    const IPC::Message* message =
+        render_thread_->sink().GetFirstMessageMatching(
+            AutofillHostMsg_ShowPasswordSuggestions::ID);
+    ASSERT_TRUE(message);
+    Tuple4<autofill::FormFieldData,
+           gfx::RectF,
+           std::vector<base::string16>,
+           std::vector<base::string16> > args;
+    AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args);
+    ASSERT_EQ(1u, args.c.size());
+    EXPECT_TRUE(args.c[0] == username);
+  }
+
+  void ExpectAllCredentials() {
+    std::set<base::string16> usernames;
+    usernames.insert(username1_);
+    usernames.insert(username2_);
+    usernames.insert(username3_);
+    usernames.insert(alternate_username3_);
+
+    const IPC::Message* message =
+        render_thread_->sink().GetFirstMessageMatching(
+            AutofillHostMsg_ShowPasswordSuggestions::ID);
+    ASSERT_TRUE(message);
+    Tuple4<autofill::FormFieldData,
+           gfx::RectF,
+           std::vector<base::string16>,
+           std::vector<base::string16> > args;
+    AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args);
+    ASSERT_EQ(4u, args.c.size());
+    std::set<base::string16>::iterator it;
+
+    for (int i = 0; i < 4; i++) {
+      it = usernames.find(args.c[i]);
+      EXPECT_TRUE(it != usernames.end());
+      if (it != usernames.end())
+        usernames.erase(it);
+    }
+
+    EXPECT_TRUE(usernames.empty());
+
+    render_thread_->sink().ClearMessages();
+  }
+
   base::string16 username1_;
   base::string16 username2_;
   base::string16 username3_;
   base::string16 password1_;
   base::string16 password2_;
   base::string16 password3_;
   base::string16 alternate_username3_;
   PasswordFormFillData fill_data_;
 
   WebInputElement username_element_;
@@ skipping 250 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
+  // Simulate the user typing in the username in the iframe which should cause
   // an autofill.
-  SimulateUsernameChangeForElement(kAliceUsername, true,
-                                   iframe, username_input);
+  SimulateUsernameChangeForElement(
+      kAliceUsername, true, iframe, username_input, true);
 
-  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(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);
-}
+  EXPECT_EQ(1, password_onchange_called); }
 
 // Tests that |FillSuggestion| properly fills the username and password.
 TEST_F(PasswordAutofillAgentTest, FillSuggestion) {
   // 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_);
 
   // Neither field should have been autocompleted.
   CheckTextFieldsDOMState(std::string(), false, std::string(), false);
@@ skipping 298 matching lines @@
 }
 
 // Test that the agent sends an IPC call to get the current activity state of
 // password saving logging soon after construction.
 TEST_F(PasswordAutofillAgentTest, SendsLoggingStateUpdatePingOnConstruction) {
   const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordAutofillAgentConstructed::ID);
   EXPECT_TRUE(message);
 }
 
+// Tests that one user click on a username field is sufficient to bring up a
+// credential suggestion popup, and the user can autocomplete the password by
+// selecting the credential from the popup.
+TEST_F(PasswordAutofillAgentTest, ClickAndSelect) {
+  // SimulateElementClick() is called so that a user gesture is actually made
+  // and the password can be filled. However, SimulateElementClick() does not
+  // actually lead to the AutofillAgent's InputElementClicked() method being
+  // called, so SimulateSuggestionChoice has to manually call
+  // InputElementClicked().
+  ClearUsernameAndPasswordFields();
+  SimulateOnFillPasswordForm(fill_data_);
+  SimulateElementClick(kUsernameName);
+  SimulateSuggestionChoice(username_element_);
+  ExpectAllCredentials();
+
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
+}
+
+// Tests the autosuggestions that are given when the element is clicked.
+// Specifiaclly, tests when the user clicks on the username element after page

[Garrett Casto, 2014/07/15 22:17:19]

Specifically

[jww, 2014/07/15 22:48:25]

Done.

+// load and the element is autofilled, when the user clicks on an element that
+// has a non-matching username, and when the user clicks on an element that's
+// already been autofilled and they've already modified.
+TEST_F(PasswordAutofillAgentTest, CredentialsOnClick) {
+  // Simulate the browser sending back the login info.
+  SimulateOnFillPasswordForm(fill_data_);
+
+  // Clear the text fields to start fresh.
+  ClearUsernameAndPasswordFields();
+
+  // Call SimulateElementClick() to produce a user gesture on the page so
+  // autofill will actually fill.
+  SimulateElementClick(kUsernameName);
+
+  // Simulate a user clicking on the username element. This should produce a
+  // message with all the usernames.
+  render_thread_->sink().ClearMessages();
+  autofill_agent_->FormControlElementClicked(username_element_, false);
+  ExpectAllCredentials();
+
+  // 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();
+  autofill_agent_->FormControlElementClicked(username_element_, true);
+  ExpectAllCredentials();
+
+  // 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);
+  render_thread_->sink().ClearMessages();
+  autofill_agent_->FormControlElementClicked(username_element_, true);
+  ExpectAllCredentials();
+}
+
 }  // namespace autofill