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.

[Garrett Casto, 2014/02/24 23:45:09]

Just calling textFieldDidEndEditing() (or possibly focusing a different field?)
is an easier way to get the username to really fill and is closer to what the
test was originally trying to do.

[jww, 2014/03/05 02:11:49]

Calling textFieldDidEndEditing() is insufficient because of the need to wait for
the event loop and what-not, but you're right that this test can be simpler, so
I've pretty much reverted it back to its original state. (The extra complexity
was actually because I originally eliminated inline autocomplete, which is now
back.)

+  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. {

[Garrett Casto, 2014/02/24 23:45:09]

1) I think that this test is trying to verify that one click is sufficient to
get the popup, but that's not obvious from the comment.
2) Trailing "{"

[jww, 2014/03/05 02:11:49]

I've update the comment to be more specific, but do let me know if it's still
confusing.

+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);

[Garrett Casto, 2014/02/24 23:45:09]

Is this necessary to focus the element? As it's currently setup it looks like
you are simulating two clicks on the element (here and the additional
InputElementClicked() in SimulateSuggestionChoice()). If they are serving
different purposes, you probably want to document why they are called.

[jww, 2014/03/05 02:11:49]

Yeah, it's a bit odd because the SimulateElementClick doesn't actually call into
the AutofillAgent, so we have to manually call InputElementClicked. I'll make a
note of it.

+  SimulateSuggestionChoice(kAliceUsername, username_element_);
+
+  CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
+}
+
 }  // namespace autofill