Sending a vote that a Password form looks like a SignUp form.

components/autofill/content/renderer/password_form_conversion_utils_browsertest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 31 matching lines @@
   // Creates a builder to start composing a new form. The form will have the
   // specified |action| URL.
   explicit PasswordFormBuilder(const char* action) {
     base::StringAppendF(
         &html_, "<FORM name=\"Test\" action=\"%s\" method=\"post\">", action);
   }
 
   // Appends a new text-type field at the end of the form, having the specified
   // |name_and_id|, |value|, and |autocomplete| attributes. The |autocomplete|
   // argument can take two special values, namely:
-  //  1.) NULL, causing no autocomplete attribute to be added,
+  //  1.) nullptr, causing no autocomplete attribute to be added,
   //  2.) "", causing an empty attribute (i.e. autocomplete="") to be added.
   void AddTextField(const char* name_and_id,
                     const char* value,
                     const char* autocomplete) {
     std::string autocomplete_attribute(autocomplete ?
         base::StringPrintf("autocomplete=\"%s\"", autocomplete) : "");
     base::StringAppendF(
         &html_,
         "<INPUT type=\"text\" name=\"%s\" id=\"%s\" value=\"%s\" %s/>",
         name_and_id, name_and_id, value, autocomplete_attribute.c_str());
@@ skipping 98 matching lines @@
 #endif  // defined(OS_ANDROID)
 
 class MAYBE_PasswordFormConversionUtilsTest : public content::RenderViewTest {
  public:
   MAYBE_PasswordFormConversionUtilsTest() : content::RenderViewTest() {}
   ~MAYBE_PasswordFormConversionUtilsTest() override {}
 
  protected:
   // Loads the given |html|, retrieves the sole WebFormElement from it, and then
   // calls CreatePasswordForm(), passing it the |predictions| to convert it into
-  // a |password_form|. Note that ASSERT() can only be used in void functions,
-  // this is why |password_form| is passed in as a pointer to a scoped_ptr.
+  // a |password_form|. If |with_user_input| == true it's considered that all
+  // values in the form elements came from the user input. Note that ASSERT()

[vabr (Chromium), 2016/04/06 22:42:12]

Actually, there seems to be no ASSERT in the method. Since you are already
changing the signature, you might want to change it to return the password form
instead of using the out-param (and drop the comment about ASSERT())?

[dvadym, 2016/04/07 11:52:18]

Thanks, it makes sense, the body of this function has changed, but ASSERT()
persists. I've made returning password_form and removed ASSERT()

+  // can only be used in void functions, this is why |password_form| is passed
+  // in as a pointer to a unique_ptr.
   void LoadHTMLAndConvertForm(const std::string& html,
                               std::unique_ptr<PasswordForm>* password_form,
-                              FormsPredictionsMap* predictions) {
+                              FormsPredictionsMap* predictions,
+                              bool with_user_input) {
     WebFormElement form;
     LoadWebFormFromHTML(html, &form);
 
     WebVector<WebFormControlElement> control_elements;
     form.getFormControlElements(control_elements);
+    ModifiedValues user_input;
     for (size_t i = 0; i < control_elements.size(); ++i) {
       WebInputElement* input_element = toWebInputElement(&control_elements[i]);
       if (input_element->hasAttribute("set-activated-submit"))
         input_element->setActivatedSubmit(true);
+      if (with_user_input)
+        user_input[*input_element] = input_element->value();
     }
 
-    *password_form = CreatePasswordFormFromWebForm(form, nullptr, predictions);
+    *password_form = CreatePasswordFormFromWebForm(
+        form, with_user_input ? &user_input : nullptr, predictions);
   }
 
   // Iterates on the form generated by the |html| and adds the fields and type
   // predictions corresponding to |predictions_positions| to |predictions|.
   void SetPredictions(const std::string& html,
                       FormsPredictionsMap* predictions,
                       const std::map<int, PasswordFormFieldPredictionType>&
                           predictions_positions) {
     WebFormElement form;
     LoadWebFormFromHTML(html, &form);
@@ skipping 32 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MAYBE_PasswordFormConversionUtilsTest);
 };
 
 }  // namespace
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, BasicFormAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
-  builder.AddTextField("username", "johnsmith", NULL);
+  builder.AddTextField("username", "johnsmith", nullptr);
   builder.AddSubmitButton("inactive_submit");
   builder.AddSubmitButton("active_submit");
   builder.AddSubmitButton("inactive_submit2");
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
 
   EXPECT_EQ("data:", password_form->signon_realm);
   EXPECT_EQ(GURL(kTestFormActionURL), password_form->action);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
   EXPECT_EQ(PasswordForm::SCHEME_HTML, password_form->scheme);
   EXPECT_FALSE(password_form->ssl_valid);
   EXPECT_FALSE(password_form->preferred);
   EXPECT_FALSE(password_form->blacklisted_by_user);
   EXPECT_EQ(PasswordForm::TYPE_MANUAL, password_form->type);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, DisabledFieldsAreIgnored) {
   PasswordFormBuilder builder(kTestFormActionURL);
-  builder.AddTextField("username", "johnsmith", NULL);
+  builder.AddTextField("username", "johnsmith", nullptr);
   builder.AddDisabledUsernameField();
   builder.AddDisabledPasswordField();
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IdentifyingUsernameFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below, plus the corresponding expectations.
   struct TestCase {
     const char* autocomplete[3];
     const char* expected_username_element;
     const char* expected_username_value;
     const char* expected_other_possible_usernames;
   } cases[] = {
       // When no elements are marked with autocomplete='username', the text-type
       // input field before the first password element should get selected as
       // the username, and the rest should be marked as alternatives.
-      {{NULL, NULL, NULL}, "username2", "William", "John+Smith"},
+      {{nullptr, nullptr, nullptr}, "username2", "William", "John+Smith"},
       // When a sole element is marked with autocomplete='username', it should
       // be treated as the username for sure, with no other_possible_usernames.
-      {{"username", NULL, NULL}, "username1", "John", ""},
-      {{NULL, "username", NULL}, "username2", "William", ""},
-      {{NULL, NULL, "username"}, "username3", "Smith", ""},
+      {{"username", nullptr, nullptr}, "username1", "John", ""},
+      {{nullptr, "username", nullptr}, "username2", "William", ""},
+      {{nullptr, nullptr, "username"}, "username3", "Smith", ""},
       // When >=2 elements have the attribute, the first should be selected as
       // the username, and the rest should go to other_possible_usernames.
-      {{"username", "username", NULL}, "username1", "John", "William"},
-      {{NULL, "username", "username"}, "username2", "William", "Smith"},
-      {{"username", NULL, "username"}, "username1", "John", "Smith"},
-      {{"username", "username", "username"}, "username1", "John",
+      {{"username", "username", nullptr}, "username1", "John", "William"},
+      {{nullptr, "username", "username"}, "username2", "William", "Smith"},
+      {{"username", nullptr, "username"}, "username1", "John", "Smith"},
+      {{"username", "username", "username"},
+       "username1",
+       "John",
        "William+Smith"},
       // When there is an empty autocomplete attribute (i.e. autocomplete=""),
       // it should have the same effect as having no attribute whatsoever.
       {{"", "", ""}, "username2", "William", "John+Smith"},
       {{"", "", "username"}, "username3", "Smith", ""},
       {{"username", "", "username"}, "username1", "John", "Smith"},
       // It should not matter if attribute values are upper or mixed case.
-      {{"USERNAME", NULL, "uSeRNaMe"}, "username1", "John", "Smith"},
-      {{"uSeRNaMe", NULL, "USERNAME"}, "username1", "John", "Smith"}};
+      {{"USERNAME", nullptr, "uSeRNaMe"}, "username1", "John", "Smith"},
+      {{"uSeRNaMe", nullptr, "USERNAME"}, "username1", "John", "Smith"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     for (size_t nonempty_username_fields = 0; nonempty_username_fields < 2;
          ++nonempty_username_fields) {
       SCOPED_TRACE(testing::Message()
                    << "Iteration " << i << " "
                    << (nonempty_username_fields ? "nonempty" : "empty"));
 
       // Repeat each test once with empty, and once with non-empty usernames.
       // In the former case, no empty other_possible_usernames should be saved.
       const char* names[3];
       if (nonempty_username_fields) {
         names[0] = "John";
         names[1] = "William";
         names[2] = "Smith";
       } else {
         names[0] = names[1] = names[2] = "";
       }
 
       PasswordFormBuilder builder(kTestFormActionURL);
       builder.AddTextField("username1", names[0], cases[i].autocomplete[0]);
       builder.AddTextField("username2", names[1], cases[i].autocomplete[1]);
-      builder.AddPasswordField("password", "secret", NULL);
+      builder.AddPasswordField("password", "secret", nullptr);
       builder.AddTextField("username3", names[2], cases[i].autocomplete[2]);
-      builder.AddPasswordField("password2", "othersecret", NULL);
+      builder.AddPasswordField("password2", "othersecret", nullptr);
       builder.AddSubmitButton("submit");
       std::string html = builder.ProduceHTML();
 
       std::unique_ptr<PasswordForm> password_form;
       ASSERT_NO_FATAL_FAILURE(
-          LoadHTMLAndConvertForm(html, &password_form, nullptr));
+          LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
       ASSERT_TRUE(password_form);
 
       EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_element),
                 password_form->username_element);
 
       if (nonempty_username_fields) {
         EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_value),
                   password_form->username_value);
         EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_other_possible_usernames),
                   base::JoinString(password_form->other_possible_usernames,
@@ skipping 30 matching lines @@
       // Two different values should be treated as a password change form, one
       // that also asks for the current password, but only once for the new.
       {{"alpha", ""}, "password1", "alpha", "password2", ""},
       {{"", "beta"}, "password1", "", "password2", "beta"},
       {{"alpha", "beta"}, "password1", "alpha", "password2", "beta"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
-    builder.AddTextField("username1", "William", NULL);
-    builder.AddPasswordField("password1", cases[i].password_values[0], NULL);
-    builder.AddTextField("username2", "Smith", NULL);
-    builder.AddPasswordField("password2", cases[i].password_values[1], NULL);
+    builder.AddTextField("username1", "William", nullptr);
+    builder.AddPasswordField("password1", cases[i].password_values[0], nullptr);
+    builder.AddTextField("username2", "Smith", nullptr);
+    builder.AddPasswordField("password2", cases[i].password_values[1], nullptr);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
     std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
-        LoadHTMLAndConvertForm(html, &password_form, nullptr));
+        LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
     ASSERT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_value),
               password_form->password_value);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_element),
               password_form->new_password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_value),
               password_form->new_password_value);
@@ skipping 31 matching lines @@
       // (current + new + new) once they are filled out, so we should classify
       // them the same for now to keep our abstract interpretation less flaky.
       {{"", "", ""}, "password1", "", "password2", ""}};
       // Note: In all other cases, we give up and consider the form invalid.
       // This is tested in InvalidFormDueToConfusingPasswordFields.
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
-    builder.AddTextField("username1", "William", NULL);
-    builder.AddPasswordField("password1", cases[i].password_values[0], NULL);
-    builder.AddPasswordField("password2", cases[i].password_values[1], NULL);
-    builder.AddTextField("username2", "Smith", NULL);
-    builder.AddPasswordField("password3", cases[i].password_values[2], NULL);
+    builder.AddTextField("username1", "William", nullptr);
+    builder.AddPasswordField("password1", cases[i].password_values[0], nullptr);
+    builder.AddPasswordField("password2", cases[i].password_values[1], nullptr);
+    builder.AddTextField("username2", "Smith", nullptr);
+    builder.AddPasswordField("password3", cases[i].password_values[2], nullptr);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
     std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
-        LoadHTMLAndConvertForm(html, &password_form, nullptr));
+        LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
     ASSERT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_value),
               password_form->password_value);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_element),
               password_form->new_password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_value),
               password_form->new_password_value);
@@ skipping 22 matching lines @@
   } cases[] = {
       // When there are elements marked with autocomplete='current-password',
       // but no elements with 'new-password', we should treat the first of the
       // former kind as the current password, and ignore all other password
       // fields, assuming they are not intentionally not marked. They might be
       // for other purposes, such as PINs, OTPs, and the like. Actual values in
       // the password fields should be ignored in all cases below.
       // Username is the element just before the first 'current-password' (even
       // if 'new-password' comes earlier). If no 'current-password', then the
       // element just before the first 'new-passwords'.
-      {{"current-password", NULL, NULL},
-       "password1", "alpha", "", "", false, "username1", "William"},
-      {{NULL, "current-password", NULL},
-       "password2", "beta", "", "", false, "username2", "Smith"},
-      {{NULL, NULL, "current-password"},
-       "password3", "gamma", "", "", false, "username2", "Smith"},
-      {{NULL, "current-password", "current-password"},
-       "password2", "beta", "", "", false, "username2", "Smith"},
-      {{"current-password", NULL, "current-password"},
-       "password1", "alpha", "", "", false, "username1", "William"},
-      {{"current-password", "current-password", NULL},
-       "password1", "alpha", "", "", false, "username1", "William"},
+      {{"current-password", nullptr, nullptr},
+       "password1",
+       "alpha",
+       "",
+       "",
+       false,
+       "username1",
+       "William"},
+      {{nullptr, "current-password", nullptr},
+       "password2",
+       "beta",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
+      {{nullptr, nullptr, "current-password"},
+       "password3",
+       "gamma",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
+      {{nullptr, "current-password", "current-password"},
+       "password2",
+       "beta",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
+      {{"current-password", nullptr, "current-password"},
+       "password1",
+       "alpha",
+       "",
+       "",
+       false,
+       "username1",
+       "William"},
+      {{"current-password", "current-password", nullptr},
+       "password1",
+       "alpha",
+       "",
+       "",
+       false,
+       "username1",
+       "William"},
       {{"current-password", "current-password", "current-password"},
-       "password1", "alpha", "", "", false, "username1", "William"},
+       "password1",
+       "alpha",
+       "",
+       "",
+       false,
+       "username1",
+       "William"},
       // The same goes vice versa for autocomplete='new-password'.
-      {{"new-password", NULL, NULL},
-       "", "", "password1", "alpha", true, "username1", "William"},
-      {{NULL, "new-password", NULL},
-       "", "", "password2", "beta", true, "username2", "Smith"},
-      {{NULL, NULL, "new-password"},
-       "", "", "password3", "gamma", true, "username2", "Smith"},
-      {{NULL, "new-password", "new-password"},
-       "", "", "password2", "beta", true, "username2", "Smith"},
-      {{"new-password", NULL, "new-password"},
-       "", "", "password1", "alpha", true, "username1", "William"},
-      {{"new-password", "new-password", NULL},
-       "", "", "password1", "alpha", true, "username1", "William"},
+      {{"new-password", nullptr, nullptr},
+       "",
+       "",
+       "password1",
+       "alpha",
+       true,
+       "username1",
+       "William"},
+      {{nullptr, "new-password", nullptr},
+       "",
+       "",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"},
+      {{nullptr, nullptr, "new-password"},
+       "",
+       "",
+       "password3",
+       "gamma",
+       true,
+       "username2",
+       "Smith"},
+      {{nullptr, "new-password", "new-password"},
+       "",
+       "",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"},
+      {{"new-password", nullptr, "new-password"},
+       "",
+       "",
+       "password1",
+       "alpha",
+       true,
+       "username1",
+       "William"},
+      {{"new-password", "new-password", nullptr},
+       "",
+       "",
+       "password1",
+       "alpha",
+       true,
+       "username1",
+       "William"},
       {{"new-password", "new-password", "new-password"},
-       "", "", "password1", "alpha", true, "username1", "William"},
+       "",
+       "",
+       "password1",
+       "alpha",
+       true,
+       "username1",
+       "William"},
       // When there is one element marked with autocomplete='current-password',
       // and one with 'new-password', just comply. Ignore the unmarked password
       // field(s) for the same reason as above.
-      {{"current-password", "new-password", NULL},
-       "password1", "alpha", "password2", "beta", true, "username1", "William"},
-      {{"current-password", NULL, "new-password"},
-       "password1", "alpha", "password3", "gamma", true, "username1","William"},
-      {{NULL, "current-password", "new-password"},
-       "password2", "beta", "password3", "gamma", true, "username2", "Smith"},
-      {{"new-password", "current-password", NULL},
-       "password2", "beta", "password1", "alpha", true, "username2", "Smith"},
-      {{"new-password", NULL, "current-password"},
-       "password3", "gamma", "password1", "alpha", true, "username2","Smith"},
-      {{NULL, "new-password", "current-password"},
-       "password3", "gamma", "password2", "beta", true, "username2", "Smith"},
+      {{"current-password", "new-password", nullptr},
+       "password1",
+       "alpha",
+       "password2",
+       "beta",
+       true,
+       "username1",
+       "William"},
+      {{"current-password", nullptr, "new-password"},
+       "password1",
+       "alpha",
+       "password3",
+       "gamma",
+       true,
+       "username1",
+       "William"},
+      {{nullptr, "current-password", "new-password"},
+       "password2",
+       "beta",
+       "password3",
+       "gamma",
+       true,
+       "username2",
+       "Smith"},
+      {{"new-password", "current-password", nullptr},
+       "password2",
+       "beta",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
+      {{"new-password", nullptr, "current-password"},
+       "password3",
+       "gamma",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
+      {{nullptr, "new-password", "current-password"},
+       "password3",
+       "gamma",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"},
       // In case of duplicated elements of either kind, go with the first one of
       // its kind.
       {{"current-password", "current-password", "new-password"},
-       "password1", "alpha", "password3", "gamma", true, "username1","William"},
+       "password1",
+       "alpha",
+       "password3",
+       "gamma",
+       true,
+       "username1",
+       "William"},
       {{"current-password", "new-password", "current-password"},
-       "password1", "alpha", "password2", "beta", true, "username1", "William"},
+       "password1",
+       "alpha",
+       "password2",
+       "beta",
+       true,
+       "username1",
+       "William"},
       {{"new-password", "current-password", "current-password"},
-       "password2", "beta", "password1", "alpha", true, "username2", "Smith"},
+       "password2",
+       "beta",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
       {{"current-password", "new-password", "new-password"},
-       "password1", "alpha", "password2", "beta", true, "username1", "William"},
+       "password1",
+       "alpha",
+       "password2",
+       "beta",
+       true,
+       "username1",
+       "William"},
       {{"new-password", "current-password", "new-password"},
-       "password2", "beta", "password1", "alpha", true, "username2", "Smith"},
+       "password2",
+       "beta",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
       {{"new-password", "new-password", "current-password"},
-       "password3", "gamma", "password1", "alpha", true, "username2", "Smith"},
+       "password3",
+       "gamma",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
       // When there is an empty autocomplete attribute (i.e. autocomplete=""),
       // it should have the same effect as having no attribute whatsoever.
       {{"current-password", "", ""},
-       "password1", "alpha", "", "", false, "username1", "William"},
+       "password1",
+       "alpha",
+       "",
+       "",
+       false,
+       "username1",
+       "William"},
       {{"", "", "new-password"},
-       "", "", "password3", "gamma", true, "username2", "Smith"},
+       "",
+       "",
+       "password3",
+       "gamma",
+       true,
+       "username2",
+       "Smith"},
       {{"", "new-password", ""},
-       "", "", "password2", "beta", true, "username2", "Smith"},
+       "",
+       "",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"},
       {{"", "current-password", "current-password"},
-       "password2", "beta", "", "", false, "username2", "Smith"},
+       "password2",
+       "beta",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
       {{"new-password", "", "new-password"},
-       "", "", "password1", "alpha", true, "username1", "William"},
+       "",
+       "",
+       "password1",
+       "alpha",
+       true,
+       "username1",
+       "William"},
       {{"new-password", "", "current-password"},
-       "password3", "gamma", "password1", "alpha", true, "username2","Smith"},
+       "password3",
+       "gamma",
+       "password1",
+       "alpha",
+       true,
+       "username2",
+       "Smith"},
       // It should not matter if attribute values are upper or mixed case.
-      {{NULL, "current-password", NULL},
-       "password2", "beta", "", "", false, "username2", "Smith"},
-      {{NULL, "CURRENT-PASSWORD", NULL},
-       "password2", "beta", "", "", false, "username2", "Smith"},
-      {{NULL, "new-password", NULL},
-       "", "", "password2", "beta", true, "username2", "Smith"},
-      {{NULL, "nEw-PaSsWoRd", NULL},
-       "", "", "password2", "beta", true, "username2", "Smith"}};
+      {{nullptr, "current-password", nullptr},
+       "password2",
+       "beta",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
+      {{nullptr, "CURRENT-PASSWORD", nullptr},
+       "password2",
+       "beta",
+       "",
+       "",
+       false,
+       "username2",
+       "Smith"},
+      {{nullptr, "new-password", nullptr},
+       "",
+       "",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"},
+      {{nullptr, "nEw-PaSsWoRd", nullptr},
+       "",
+       "",
+       "password2",
+       "beta",
+       true,
+       "username2",
+       "Smith"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
-    builder.AddPasswordField("pin1", "123456", NULL);
-    builder.AddPasswordField("pin2", "789101", NULL);
-    builder.AddTextField("username1", "William", NULL);
+    builder.AddPasswordField("pin1", "123456", nullptr);
+    builder.AddPasswordField("pin2", "789101", nullptr);
+    builder.AddTextField("username1", "William", nullptr);
     builder.AddPasswordField("password1", "alpha", cases[i].autocomplete[0]);
-    builder.AddTextField("username2", "Smith", NULL);
+    builder.AddTextField("username2", "Smith", nullptr);
     builder.AddPasswordField("password2", "beta", cases[i].autocomplete[1]);
     builder.AddPasswordField("password3", "gamma", cases[i].autocomplete[2]);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
     std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
-        LoadHTMLAndConvertForm(html, &password_form, nullptr));
+        LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
     ASSERT_TRUE(password_form);
 
     // In the absence of username autocomplete attributes, the username should
     // be the text input field just before 'current-password' or before
     // 'new-password', if there is no 'current-password'.
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_element),
               password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_value),
               password_form->username_value);
     if (strcmp(cases[i].expected_username_value, "William") == 0) {
@@ skipping 13 matching lines @@
               password_form->new_password_value);
     EXPECT_EQ(cases[i].expected_new_password_marked_by_site,
               password_form->new_password_marked_by_site);
   }
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IgnoreNonDisplayedTextFields) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("nondisplayed1", "nodispalyed_value1");
-  builder.AddTextField("username", "johnsmith", NULL);
+  builder.AddTextField("username", "johnsmith", nullptr);
   builder.AddNonDisplayedTextField("nondisplayed2", "nodispalyed_value2");
-  builder.AddPasswordField("password", "secret", NULL);
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
+  builder.AddPasswordField("password", "secret", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16(""), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->new_password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->new_password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IgnoreNonDisplayedLoginPairs) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("nondisplayed1", "nodispalyed_value1");
   builder.AddNonDisplayedPasswordField("nondisplayed2", "nodispalyed_value2");
-  builder.AddTextField("username", "johnsmith", NULL);
+  builder.AddTextField("username", "johnsmith", nullptr);
   builder.AddNonDisplayedTextField("nondisplayed3", "nodispalyed_value3");
   builder.AddNonDisplayedPasswordField("nondisplayed4", "nodispalyed_value4");
-  builder.AddPasswordField("password", "secret", NULL);
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
+  builder.AddPasswordField("password", "secret", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16(""), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->new_password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->new_password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, OnlyNonDisplayedLoginPair) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("username", "William");
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"),
             password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"),
             password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"),
             password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"),
             password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        VisiblePasswordAndInvisibleUsername) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("username", "William");
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvisiblePassword_LatestUsernameIsVisible) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("search", "query");
-  builder.AddTextField("username", "William", NULL);
+  builder.AddTextField("username", "William", nullptr);
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvisiblePassword_LatestUsernameIsInvisible) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
-  builder.AddTextField("search", "query", NULL);
+  builder.AddTextField("search", "query", nullptr);
   builder.AddNonDisplayedTextField("username", "William");
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, InvalidFormDueToBadActionURL) {
   PasswordFormBuilder builder("invalid_target");
-  builder.AddTextField("username", "JohnSmith", NULL);
+  builder.AddTextField("username", "JohnSmith", nullptr);
   builder.AddSubmitButton("submit");
-  builder.AddPasswordField("password", "secret", NULL);
+  builder.AddPasswordField("password", "secret", nullptr);
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormDueToNoPasswordFields) {
   PasswordFormBuilder builder(kTestFormActionURL);
-  builder.AddTextField("username1", "John", NULL);
-  builder.AddTextField("username2", "Smith", NULL);
+  builder.AddTextField("username1", "John", nullptr);
+  builder.AddTextField("username2", "Smith", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormsDueToConfusingPasswordFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below.
   const char* cases[][3] = {
       // No autocomplete attributes to guide us, and we see:
       //  * three password values that are all different,
       //  * three password values that are all the same;
       //  * three password values with the first and last matching.
       // In any case, we should just give up on this form.
       {"alpha", "beta", "gamma"},
       {"alpha", "alpha", "alpha"},
       {"alpha", "beta", "alpha"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
-    builder.AddTextField("username1", "John", NULL);
-    builder.AddPasswordField("password1", cases[i][0], NULL);
-    builder.AddPasswordField("password2", cases[i][1], NULL);
-    builder.AddPasswordField("password3", cases[i][2], NULL);
+    builder.AddTextField("username1", "John", nullptr);
+    builder.AddPasswordField("password1", cases[i][0], nullptr);
+    builder.AddPasswordField("password2", cases[i][1], nullptr);
+    builder.AddPasswordField("password3", cases[i][2], nullptr);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
     std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
-        LoadHTMLAndConvertForm(html, &password_form, nullptr));
+        LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
     EXPECT_FALSE(password_form);
   }
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormDueToTooManyPasswordFieldsWithoutAutocompleteAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
-  builder.AddTextField("username1", "John", NULL);
-  builder.AddPasswordField("password1", "alpha", NULL);
-  builder.AddPasswordField("password2", "alpha", NULL);
-  builder.AddPasswordField("password3", "alpha", NULL);
-  builder.AddPasswordField("password4", "alpha", NULL);
+  builder.AddTextField("username1", "John", nullptr);
+  builder.AddPasswordField("password1", "alpha", nullptr);
+  builder.AddPasswordField("password2", "alpha", nullptr);
+  builder.AddPasswordField("password3", "alpha", nullptr);
+  builder.AddPasswordField("password4", "alpha", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(html, &password_form, nullptr));
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationLogin) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddHiddenField();
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("password", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string login_html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> login_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(login_html, &login_form, nullptr));
+      LoadHTMLAndConvertForm(login_html, &login_form, nullptr, false));
   ASSERT_TRUE(login_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, login_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationSignup) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string signup_html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> signup_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(signup_html, &signup_form, nullptr));
+      LoadHTMLAndConvertForm(signup_html, &signup_form, nullptr, false));
   ASSERT_TRUE(signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationChange) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("old_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string change_html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> change_form;
   ASSERT_NO_FATAL_FAILURE(
-      LoadHTMLAndConvertForm(change_html, &change_form, nullptr));
+      LoadHTMLAndConvertForm(change_html, &change_form, nullptr, false));
   ASSERT_TRUE(change_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, change_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        LayoutClassificationLoginPlusSignup_A) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddTextField("username2", "", nullptr);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit");
   std::string login_plus_signup_html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(
-      login_plus_signup_html, &login_plus_signup_form, nullptr));
+      login_plus_signup_html, &login_plus_signup_form, nullptr, false));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        LayoutClassificationLoginPlusSignup_B) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddTextField("username2", "", nullptr);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddTextField("someotherfield2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit");
   std::string login_plus_signup_html = builder.ProduceHTML();
 
   std::unique_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(
-      login_plus_signup_html, &login_plus_signup_form, nullptr));
+      login_plus_signup_html, &login_plus_signup_form, nullptr, false));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardNumberWithTypePasswordForm) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddPasswordField("Credit card number", "0000 0000 0000 0000",
                            nullptr);
   builder.AddTextField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[1] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
   std::unique_ptr<PasswordForm> password_form;
-  LoadHTMLAndConvertForm(html, &password_form, &predictions);
+  LoadHTMLAndConvertForm(html, &password_form, &predictions, false);
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardVerificationNumberWithTypePasswordForm) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddTextField("Credit card number", "0000 0000 0000 0000", nullptr);
   builder.AddPasswordField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[2] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
   std::unique_ptr<PasswordForm> password_form;
-  LoadHTMLAndConvertForm(html, &password_form, &predictions);
+  LoadHTMLAndConvertForm(html, &password_form, &predictions, false);
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardNumberWithTypePasswordFormWithAutocomplete) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddPasswordField("Credit card number", "0000 0000 0000 0000",
                            "current-password");
   builder.AddTextField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[1] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
   std::unique_ptr<PasswordForm> password_form;
-  LoadHTMLAndConvertForm(html, &password_form, &predictions);
+  LoadHTMLAndConvertForm(html, &password_form, &predictions, false);
   EXPECT_TRUE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardVerificationNumberWithTypePasswordFormWithAutocomplete) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddTextField("Credit card number", "0000 0000 0000 0000", nullptr);
   builder.AddPasswordField("cvc", "000", "new-password");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[2] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
   std::unique_ptr<PasswordForm> password_form;
-  LoadHTMLAndConvertForm(html, &password_form, &predictions);
+  LoadHTMLAndConvertForm(html, &password_form, &predictions, false);
   EXPECT_TRUE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IsGaiaReauthFormIgnored) {
   struct TestCase {
     const char* origin;
     struct KeyValue {
       KeyValue() : name(nullptr), value(nullptr) {}
       KeyValue(const char* new_name, const char* new_value)
           : name(new_name), value(new_value) {}
@@ skipping 144 matching lines @@
 
     if (test_cases[i].new_password_fieldname == kEmpty) {
       builder.AddAnonymousInputField("password");
     } else {
       builder.AddPasswordField(test_cases[i].new_password_fieldname, "",
                                kEmpty);
     }
     std::string html = builder.ProduceHTML();
 
     std::unique_ptr<PasswordForm> password_form;
-    LoadHTMLAndConvertForm(html, &password_form, nullptr);
+    LoadHTMLAndConvertForm(html, &password_form, nullptr, false);
     EXPECT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_username_element),
               password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_new_password_element),
               password_form->new_password_element);
   }
 }
 
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       ProbablySignUpFormTwoTextOnePassword) {
+  PasswordFormBuilder builder(kTestFormActionURL);
+  builder.AddTextField("email", "johnsmith@gmail.com", nullptr);
+  builder.AddTextField("username", "johnsmith", nullptr);
+  builder.AddPasswordField("password", "secret", nullptr);
+  std::string html = builder.ProduceHTML();
+
+  std::unique_ptr<PasswordForm> password_form;
+  // No user input, not considered as SignUp.
+  ASSERT_NO_FATAL_FAILURE(
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
+  ASSERT_TRUE(password_form);
+  EXPECT_FALSE(password_form->does_look_like_signup_form);
+
+  // With user input, considered as SignUp.
+  ASSERT_NO_FATAL_FAILURE(
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, true));
+  ASSERT_TRUE(password_form);
+  EXPECT_TRUE(password_form->does_look_like_signup_form);
+}
+
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       ProbablySignUpFormOneTextNewAndConfirmPassword) {
+  PasswordFormBuilder builder(kTestFormActionURL);
+  builder.AddTextField("username", "johnsmith", nullptr);
+  builder.AddPasswordField("new_password", "secret", nullptr);
+  builder.AddPasswordField("confirm_password", "secret", nullptr);
+  std::string html = builder.ProduceHTML();
+
+  std::unique_ptr<PasswordForm> password_form;
+  // No user input, not considered as SignUp.
+  ASSERT_NO_FATAL_FAILURE(

[vabr (Chromium), 2016/04/06 22:42:12]

What would be the fatal failure which could happen in LoadHTMLAndConvertForm?

[dvadym, 2016/04/07 11:52:18]

Done.

+      LoadHTMLAndConvertForm(html, &password_form, nullptr, false));
+  ASSERT_TRUE(password_form);
+  EXPECT_FALSE(password_form->does_look_like_signup_form);
+
+  // With user input, considered as SignUp.
+  ASSERT_NO_FATAL_FAILURE(
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, true));
+  ASSERT_TRUE(password_form);
+  EXPECT_TRUE(password_form->does_look_like_signup_form);
+}
+
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       NotProbablySignUpFormOneTextCurrentAndNewPassword) {
+  PasswordFormBuilder builder(kTestFormActionURL);
+  builder.AddTextField("username", "johnsmith", nullptr);
+  builder.AddPasswordField("password", "secret", nullptr);
+  builder.AddPasswordField("new_password", "new_secret", nullptr);
+  std::string html = builder.ProduceHTML();
+
+  std::unique_ptr<PasswordForm> password_form;
+  ASSERT_NO_FATAL_FAILURE(
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, true));
+  ASSERT_TRUE(password_form);
+  EXPECT_FALSE(password_form->does_look_like_signup_form);
+}
+
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       NotProbablySignUpFormForSignInForm) {
+  PasswordFormBuilder builder(kTestFormActionURL);
+  builder.AddTextField("username", "johnsmith", nullptr);
+  builder.AddPasswordField("password", "secret", nullptr);
+  std::string html = builder.ProduceHTML();
+
+  std::unique_ptr<PasswordForm> password_form;
+  ASSERT_NO_FATAL_FAILURE(
+      LoadHTMLAndConvertForm(html, &password_form, nullptr, true));
+  ASSERT_TRUE(password_form);
+  EXPECT_FALSE(password_form->does_look_like_signup_form);
+}
+
 }  // namespace autofill