[Password Autofill] Make better use of prefilled usernames.

components/autofill/content/renderer/password_autofill_agent.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 "components/autofill/content/renderer/password_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 146 matching lines @@
       curr_elements->form_element = fe;
       results->push_back(curr_elements.release());
     }
   }
 }
 
 bool IsElementEditable(const WebKit::WebInputElement& element) {
   return element.isEnabled() && !element.isReadOnly();
 }
 
-void FillForm(FormElements* fe, const FormData& data) {
-  if (!fe->form_element.autoComplete())
-    return;
-
-  std::map<base::string16, base::string16> data_map;
-  for (size_t i = 0; i < data.fields.size(); i++)
-    data_map[data.fields[i].name] = data.fields[i].value;
-
-  for (FormInputElementMap::iterator it = fe->input_elements.begin();
-       it != fe->input_elements.end(); ++it) {
-    WebKit::WebInputElement element = it->second;
-    // Don't fill a form that has pre-filled values distinct from the ones we
-    // want to fill with.
-    if (!element.value().isEmpty() && element.value() != data_map[it->first])
-      return;
-
-    // Don't fill forms with uneditable fields or fields with autocomplete
-    // disabled.
-    if (!IsElementEditable(element) || !element.autoComplete())
-      return;
-  }
-
-  for (FormInputElementMap::iterator it = fe->input_elements.begin();
-       it != fe->input_elements.end(); ++it) {
-    WebKit::WebInputElement element = it->second;
-
-    // TODO(tkent): Check maxlength and pattern.
-    element.setValue(data_map[it->first]);
-    element.setAutofilled(true);
-    element.dispatchFormControlChangeEvent();
-  }
-}
-
 void SetElementAutofilled(WebKit::WebInputElement* element, bool autofilled) {
   if (element->isAutofilled() == autofilled)
     return;
   element->setAutofilled(autofilled);
   // Notify any changeEvent listeners.
   element->dispatchFormControlChangeEvent();
 }
 
 bool DoUsernamesMatch(const base::string16& username1,
                       const base::string16& username2,
@@ skipping 33 matching lines @@
     return false;
 
   WebKit::WebInputElement password = iter->second.password_field;
   if (!IsElementEditable(password))
     return false;
 
   WebKit::WebInputElement username = element;  // We need a non-const.
 
   // Do not set selection when ending an editing session, otherwise it can
   // mess with focus.
-  FillUserNameAndPassword(&username, &password, fill_data, true, false);
+  FillUserNameAndPassword(&username, &password, fill_data,
+                          true /* exact_username_match */,
+                          false /* set_selection */);
   return true;
 }
 
 bool PasswordAutofillAgent::TextDidChangeInTextField(
     const WebKit::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
@@ skipping 60 matching lines @@
     const WebKit::WebString& value) {
   WebKit::WebInputElement input;
   PasswordInfo password;
   if (!FindLoginInfo(node, &input, &password))
     return false;
 
   // Set the incoming |value| in the text field and |FillUserNameAndPassword|
   // will do the rest.
   input.setValue(value, true);
   return FillUserNameAndPassword(&input, &password.password_field,
-                                 password.fill_data, true, true);
+                                 password.fill_data,
+                                 true /* exact_username_match */,
+                                 true /* set_selection */);
 }
 
 bool PasswordAutofillAgent::DidClearAutofillSelection(
     const WebKit::WebNode& node) {
   WebKit::WebInputElement input;
   PasswordInfo password;
   return FindLoginInfo(node, &input, &password);
 }
 
 bool PasswordAutofillAgent::ShowSuggestions(
@@ skipping 164 matching lines @@
       usernames_usage_ = OTHER_POSSIBLE_USERNAMES_ABSENT;
   }
 
   FormElementsList forms;
   // We own the FormElements* in forms.
   FindFormElements(render_view()->GetWebView(), form_data.basic_data, &forms);
   FormElementsList::iterator iter;
   for (iter = forms.begin(); iter != forms.end(); ++iter) {
     scoped_ptr<FormElements> form_elements(*iter);
 
-    // If wait_for_username is true, we don't want to initially fill the form
-    // until the user types in a valid username.
-    if (!form_data.wait_for_username)
-      FillForm(form_elements.get(), form_data.basic_data);
-
     // Attach autocomplete listener to enable selecting alternate logins.
     // First, get pointers to username element.
     WebKit::WebInputElement username_element =
         form_elements->input_elements[form_data.basic_data.fields[0].name];
 
     // Get pointer to password element. (We currently only support single
     // password forms).
     WebKit::WebInputElement password_element =
         form_elements->input_elements[form_data.basic_data.fields[1].name];
 
+    // If wait_for_username is true, we don't want to initially fill the form
+    // until the user types in a valid username.
+    if (!form_data.wait_for_username)
+      FillFormOnPasswordRecieved(form_data, username_element, password_element);
+
     // We might have already filled this form if there are two <form> elements
     // with identical markup.
     if (login_to_password_info_.find(username_element) !=
         login_to_password_info_.end())
       continue;
 
     PasswordInfo password_info;
     password_info.fill_data = form_data;
     password_info.password_field = password_element;
     login_to_password_info_[username_element] = password_info;
@@ skipping 74 matching lines @@
                                  bounding_box.width() * scale,
                                  bounding_box.height() * scale);
   Send(new AutofillHostMsg_ShowPasswordSuggestions(routing_id(),
                                                    field,
                                                    bounding_box_scaled,
                                                    suggestions,
                                                    realms));
   return !suggestions.empty();
 }
 
+void PasswordAutofillAgent::FillFormOnPasswordRecieved(
+    const PasswordFormFillData& fill_data,
+    WebKit::WebInputElement username_element,
+    WebKit::WebInputElement password_element) {
+  if (!username_element.form().autoComplete())

[Ilya Sherman, 2013/11/05 02:21:42]

nit: Theoretically, it's possible for username_element.form().isNull() to be
true.  Unless you're sure this code is not reachable in such a case, please add
a null check.  The simple HTML to try to repro this with is

<body>
<input id="username">
<input id="password" type="password">
</body>

(with the <form> element intentionally omitted) on a domain for which you
already have passwords saved.

[Garrett Casto, 2013/11/05 05:56:11]

Added a test to verify this, but we only get forms by calling
WebDocument::forms(), so it doesn't look like this is possible.

+    return;
+
+  // If we can't modify the password, don't try to set the username
+  if (!IsElementEditable(password_element) || !password_element.autoComplete())
+    return;
+
+  // Try to set the username to the preferred name, but only if the field
+  // can be set and isn't prefilled.
+  if (IsElementEditable(username_element) &&
+      username_element.autoComplete() &&
+      username_element.value().isEmpty()) {
+    // TODO(tkent): Check maxlength and pattern.
+    username_element.setValue(fill_data.basic_data.fields[0].value);
+  }
+
+  // Fill if we have an exact match for the username. Note that this sets
+  // username to autofilled.
+  FillUserNameAndPassword(&username_element, &password_element, fill_data,
+                          true /* exact_username_match */,
+                          false /* set_selection */);
+}
+
 bool PasswordAutofillAgent::FillUserNameAndPassword(
     WebKit::WebInputElement* username_element,
     WebKit::WebInputElement* password_element,
     const PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection) {
   base::string16 current_username = username_element->value();
   // username and password will contain the match found if any.
   base::string16 username;
   base::string16 password;
@@ skipping 31 matching lines @@
           }
         }
         if (!username.empty() && !password.empty())
           break;
       }
     }
   }
   if (password.empty())
     return false;  // No match was found.
 
+  // TODO(tkent): Check maxlength and pattern for both username and password
+  // fields.
+
   // Input matches the username, fill in required values.
-  username_element->setValue(username);
+  if (IsElementEditable(*username_element)) {

[Ilya Sherman, 2013/11/05 02:21:42]

Please check username_element.autoComplete() as well.

[Garrett Casto, 2013/11/05 05:56:11]

Done.

+    username_element->setValue(username);
+    SetElementAutofilled(username_element, true);
 
-  if (set_selection) {
-    username_element->setSelectionRange(current_username.length(),
-                                        username.length());
+    if (set_selection) {
+      username_element->setSelectionRange(current_username.length(),
+                                          username.length());
+    }
+  } else if (current_username != username) {
+    // If the username can't be filled and it doesn't match a saved password
+    // as is, don't autofill a password.
+    return false;
   }
 
-  SetElementAutofilled(username_element, true);
-  if (IsElementEditable(*password_element))
+  if (IsElementEditable(*password_element)) {

[Ilya Sherman, 2013/11/05 02:21:42]

Please check password_element.autoComplete() as well.

[Garrett Casto, 2013/11/05 05:56:11]

Added, though I actually moved this check up before the username gets filled, so
that we won't autofill the username if we can't fill the password.

[Ilya Sherman, 2013/11/05 06:12:58]

Yeah, that's a good call.  Thanks :)

     password_element->setValue(password);
-  SetElementAutofilled(password_element, true);
-  return true;
+    SetElementAutofilled(password_element, true);
+    return true;
+  }
+  // Couldn't fill password
+  return false;
 }
 
 void PasswordAutofillAgent::PerformInlineAutocomplete(
     const WebKit::WebInputElement& username_input,
     const WebKit::WebInputElement& password_input,
     const PasswordFormFillData& fill_data) {
   DCHECK(!fill_data.wait_for_username);
 
   // We need non-const versions of the username and password inputs.
   WebKit::WebInputElement username = username_input;
   WebKit::WebInputElement password = password_input;
 
   // Don't inline autocomplete if the caret is not at the end.
   // TODO(jcivelli): is there a better way to test the caret location?
   if (username.selectionStart() != username.selectionEnd() ||
       username.selectionEnd() != static_cast<int>(username.value().length())) {
     return;
   }
 
   // Show the popup with the list of available usernames.
   ShowSuggestionPopup(fill_data, username);
 
 
 #if !defined(OS_ANDROID)
   // Fill the user and password field with the most relevant match. Android
   // only fills in the fields after the user clicks on the suggestion popup.
-  FillUserNameAndPassword(&username, &password, fill_data, false, true);
+  FillUserNameAndPassword(&username, &password, fill_data,
+                          false /* exact_username_match */,
+                          true /* set_selection */);
 #endif
 }
 
 void PasswordAutofillAgent::FrameClosing(const WebKit::WebFrame* frame) {
   for (LoginToPasswordInfoMap::iterator iter = login_to_password_info_.begin();
        iter != login_to_password_info_.end();) {
     if (iter->first.document().frame() == frame)
       login_to_password_info_.erase(iter++);
     else
       ++iter;
@@ skipping 14 matching lines @@
   LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(input);
   if (iter == login_to_password_info_.end())
     return false;
 
   *found_input = input;
   *found_password = iter->second;
   return true;
 }
 
 }  // namespace autofill