Enable manual password autofilling if the username field is read-only.

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 <tuple>
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 380 matching lines @@
     SimulateUserInputChangeForElement(&password_element_, password);
   }
 
   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) {
-    EXPECT_EQ(username,
-              static_cast<std::string>(username_element.value().utf8()));
+    EXPECT_EQ(username, 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, checkSuggestedValue
+                            ? password_element.suggestedValue().utf8()
+                            : password_element.value().utf8())
         << "checkSuggestedValue == " << checkSuggestedValue;
     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) {
@@ skipping 572 matching lines @@
   // Try Filling with a suggestion with password different from the one that was
   // initially sent to the renderer.
   EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
       username_element_, ASCIIToUTF16(kBobUsername),
       ASCIIToUTF16(kCarolPassword)));
   CheckTextFieldsDOMState(kBobUsername, true, kCarolPassword, true);
   username_length = strlen(kBobUsername);
   CheckUsernameSelection(username_length, username_length);
 }
 
+// Tests that |FillSuggestion| properly fills the password if username is
+// read-only.
+TEST_F(PasswordAutofillAgentTest, FillSuggestionIfUsernameReadOnly) {
+  // Simulate the browser sending the login info.
+  SetElementReadOnly(username_element_, true);
+  SimulateOnFillPasswordForm(fill_data_);
+
+  // Neither field should have been autocompleted.
+  CheckTextFieldsDOMState(std::string(), false, std::string(), false);
+
+  // Username field is not autocompletable, it should not be affected.
+  EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
+      password_element_, ASCIIToUTF16(kAliceUsername),
+      ASCIIToUTF16(kAlicePassword)));
+  CheckTextFieldsDOMState(std::string(), false, kAlicePassword, true);
+
+  // Try Filling with a suggestion with password different from the one that was
+  // initially sent to the renderer.
+  EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
+      password_element_, ASCIIToUTF16(kBobUsername),
+      ASCIIToUTF16(kCarolPassword)));
+  CheckTextFieldsDOMState(std::string(), false, kCarolPassword, true);
+}
+
 // Tests that |PreviewSuggestion| properly previews the username and password.
 TEST_F(PasswordAutofillAgentTest, PreviewSuggestion) {
   // 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);
 
   // If the password field is not autocompletable, it should not be affected.
   SetElementReadOnly(password_element_, true);
   EXPECT_FALSE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   EXPECT_EQ(std::string(), username_element_.suggestedValue().utf8());
   EXPECT_FALSE(username_element_.isAutofilled());
   EXPECT_EQ(std::string(), password_element_.suggestedValue().utf8());
   EXPECT_FALSE(password_element_.isAutofilled());
   SetElementReadOnly(password_element_, false);
 
   // After selecting the suggestion, both fields should be previewed
   // with suggested values.
   EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
-  EXPECT_EQ(
-      kAliceUsername,
-      static_cast<std::string>(username_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kAliceUsername, username_element_.suggestedValue().utf8());
   EXPECT_TRUE(username_element_.isAutofilled());
-  EXPECT_EQ(
-      kAlicePassword,
-      static_cast<std::string>(password_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kAlicePassword, password_element_.suggestedValue().utf8());
   EXPECT_TRUE(password_element_.isAutofilled());
   int username_length = strlen(kAliceUsername);
   CheckUsernameSelection(0, username_length);
 
   // Try previewing with a password different from the one that was initially
   // sent to the renderer.
   EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kBobUsername, kCarolPassword));
-  EXPECT_EQ(
-      kBobUsername,
-      static_cast<std::string>(username_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kBobUsername, username_element_.suggestedValue().utf8());
   EXPECT_TRUE(username_element_.isAutofilled());
-  EXPECT_EQ(
-      kCarolPassword,
-      static_cast<std::string>(password_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kCarolPassword, password_element_.suggestedValue().utf8());
   EXPECT_TRUE(password_element_.isAutofilled());
   username_length = strlen(kBobUsername);
   CheckUsernameSelection(0, username_length);
 }
 
+// Tests that |PreviewSuggestion| properly previews the password if username is
+// read-only.
+TEST_F(PasswordAutofillAgentTest, PreviewSuggestionIfUsernameReadOnly) {
+  // Simulate the browser sending the login info.
+  SetElementReadOnly(username_element_, true);
+  SimulateOnFillPasswordForm(fill_data_);
+
+  // Neither field should have been autocompleted.
+  CheckTextFieldsDOMState(std::string(), false, std::string(), false);
+
+  // Username field is not autocompletable, it should not be affected.
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
+      password_element_, kAliceUsername, kAlicePassword));
+  EXPECT_EQ(std::string(), username_element_.suggestedValue().utf8());
+  EXPECT_FALSE(username_element_.isAutofilled());
+
+  // Password field must be autofilled.
+  EXPECT_EQ(kAlicePassword, password_element_.suggestedValue().utf8());
+  EXPECT_TRUE(password_element_.isAutofilled());
+
+  // Try previewing with a password different from the one that was initially
+  // sent to the renderer.
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
+      password_element_, kBobUsername, kCarolPassword));
+  EXPECT_EQ(std::string(), username_element_.suggestedValue().utf8());
+  EXPECT_FALSE(username_element_.isAutofilled());
+  EXPECT_EQ(kCarolPassword, password_element_.suggestedValue().utf8());
+  EXPECT_TRUE(password_element_.isAutofilled());
+}
+
 // Tests that |PreviewSuggestion| properly sets the username selection range.
 TEST_F(PasswordAutofillAgentTest, PreviewSuggestionSelectionRange) {
   username_element_.setValue(WebString::fromUTF8("ali"));
   username_element_.setSelectionRange(3, 3);
   username_element_.setAutofilled(true);
 
   CheckTextFieldsDOMState("ali", true, std::string(), false);
 
   // 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_);
 
   EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
-  EXPECT_EQ(
-      kAliceUsername,
-      static_cast<std::string>(username_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kAliceUsername, username_element_.suggestedValue().utf8());
   EXPECT_TRUE(username_element_.isAutofilled());
-  EXPECT_EQ(
-      kAlicePassword,
-      static_cast<std::string>(password_element_.suggestedValue().utf8()));
+  EXPECT_EQ(kAlicePassword, password_element_.suggestedValue().utf8());
   EXPECT_TRUE(password_element_.isAutofilled());
   int username_length = strlen(kAliceUsername);
   CheckUsernameSelection(3, username_length);
 }
 
 // Tests that |ClearPreview| properly clears previewed username and password
 // with password being previously autofilled.
 TEST_F(PasswordAutofillAgentTest, ClearPreviewWithPasswordAutofilled) {
   password_element_.setValue(WebString::fromUTF8("sec"));
   password_element_.setAutofilled(true);
@@ skipping 1334 matching lines @@
   EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordSuggestions::ID));
 
   // But when the user clicks on the autofilled password field again it should
   // still produce a suggestion dropdown.
   SimulateElementClick("password");
   CheckSuggestions("", false);
 }
 
 }  // namespace autofill