Processing USERNAME reply from Autofill server in Password Manager

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"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_autofill_agent.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "content/public/renderer/render_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
+#include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using autofill::PasswordForm;
 using base::ASCIIToUTF16;
 using base::UTF16ToUTF8;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebFrame;
 using blink::WebInputElement;
 using blink::WebString;
 using blink::WebView;
 
 namespace {
 
 const int kPasswordFillFormDataId = 1234;
 
 // The name of the username/password element in the form.
 const char kUsernameName[] = "username";
 const char kPasswordName[] = "password";
+const char kEmailName[] = "email";
 
 const char kAliceUsername[] = "alice";
 const char kAlicePassword[] = "password";
 const char kBobUsername[] = "bob";
 const char kBobPassword[] = "secret";
 const char kCarolUsername[] = "Carol";
 const char kCarolPassword[] = "test";
 const char kCarolAlternateUsername[] = "RealCarolUsername";
 
 const char kFormHTML[] =
@@ skipping 96 matching lines @@
     "  usernameOnchangeCalled = false;"
     "  passwordOnchangeCalled = false;"
     "  document.getElementById('username').onchange = function() {"
     "    usernameOnchangeCalled = true;"
     "  };"
     "  document.getElementById('password').onchange = function() {"
     "    passwordOnchangeCalled = true;"
     "  };"
     "</script>";
 
+const char kFormHTMLWithTwoTextFields[] =
+    "<FORM name='LoginTestForm' id='LoginTestForm' "
+    "action='http://www.bidule.com'>"
+    "  <INPUT type='text' id='username'/>"
+    "  <INPUT type='text' id='email'/>"
+    "  <INPUT type='password' id='password'/>"
+    "  <INPUT type='submit' value='Login'/>"
+    "</FORM>";
+
 // Sets the "readonly" attribute of |element| to the value given by |read_only|.
 void SetElementReadOnly(WebInputElement& element, bool read_only) {
   element.setAttribute(WebString::fromUTF8("readonly"),
                        read_only ? WebString::fromUTF8("true") : WebString());
 }
 
 }  // namespace
 
 namespace autofill {
 
@@ skipping 87 matching lines @@
     WebDocument document = GetMainFrame()->document();
     WebElement element =
         document.getElementById(WebString::fromUTF8(kUsernameName));
     ASSERT_FALSE(element.isNull());
     username_element_ = element.to<blink::WebInputElement>();
     element = document.getElementById(WebString::fromUTF8(kPasswordName));
     ASSERT_FALSE(element.isNull());
     password_element_ = element.to<blink::WebInputElement>();
   }
 
+  blink::WebInputElement GetInputElementByID(const std::string& id) {
+    WebDocument document = GetMainFrame()->document();
+    WebElement element =
+        document.getElementById(WebString::fromUTF8(id.c_str()));
+    return element.to<blink::WebInputElement>();
+  }
+
   void ClearUsernameAndPasswordFields() {
     username_element_.setValue("");
     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);
@@ skipping 1567 matching lines @@
       autofill::switches::kEnableFillOnAccountSelect);
 
   ClearUsernameAndPasswordFields();
 
   username_element_.setValue("foobar");
   SetElementReadOnly(username_element_, true);
 
   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);
+  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);
+
+  // Find FormData for visible password form.
+  blink::WebFormElement form_element = username_element_.form();
+  FormData form_data;
+  ASSERT_TRUE(WebFormElementToFormData(
+      form_element, blink::WebFormControlElement(), REQUIRE_NONE, 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);
+  static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
+      ->OnMessageReceived(msg);
+  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 first field as
+  // username.
+  ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
+}
+
 }  // namespace autofill