Add username field discovery heuristic.

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 <stddef.h>
 
+#include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 250 matching lines @@
 
 bool DoUsernamesMatch(const base::string16& username1,
                       const base::string16& username2,
                       bool exact_match) {
   if (exact_match)
     return username1 == username2;
   return FieldIsSuggestionSubstringStartingOnTokenBoundary(username1, username2,
                                                            true);
 }
 
-// Returns |true| if the given element is editable. Otherwise, returns |false|.
+// Returns whether the given |element| is editable.
 bool IsElementAutocompletable(const blink::WebInputElement& element) {
   return IsElementEditable(element);
 }
 
 // Returns whether the |username_element| is allowed to be autofilled.
 //
 // Note that if the user interacts with the |password_field| and the
 // |username_element| is user-defined (i.e., non-empty and non-autofilled), then
 // this function returns false. This is a precaution, to not override the field
 // if it has been classified as username by accident.
@@ skipping 310 matching lines @@
     if (element.IsFormControlElement()) {
       const blink::WebFormControlElement& control =
           element.To<blink::WebFormControlElement>();
       if (control.FormControlType() == kPassword)
         return true;
     }
   }
   return false;
 }
 
+// Returns the closest visible autocompletable non-password text element
+// preceding the |password_element| either in a form, if it belongs to one, or
+// in the |frame|.
+blink::WebInputElement FindUsernameElementPrecedingPasswordElement(
+    blink::WebFrame* frame,
+    const blink::WebInputElement& password_element) {
+  DCHECK(!password_element.IsNull());
+
+  std::vector<blink::WebFormControlElement> elements;
+  if (password_element.Form().IsNull()) {
+    elements = form_util::GetUnownedAutofillableFormFieldElements(
+        frame->GetDocument().All(), nullptr);
+  } else {
+    blink::WebVector<blink::WebFormControlElement> web_control_elements;
+    password_element.Form().GetFormControlElements(web_control_elements);
+    elements.assign(web_control_elements.begin(), web_control_elements.end());
+  }
+
+  auto iter = std::find(elements.begin(), elements.end(), password_element);
+  if (iter == elements.end())
+    return blink::WebInputElement();
+
+  for (auto begin = elements.begin(); iter != begin;) {
+    --iter;
+    const blink::WebInputElement* input = blink::ToWebInputElement(&*iter);
+    if (input && input->IsTextField() && !input->IsPasswordField() &&
+        IsElementAutocompletable(*input) &&
+        form_util::IsWebElementVisible(*input)) {
+      return *input;
+    }
+  }
+
+  return blink::WebInputElement();
+}
+
 }  // namespace
 
 class PasswordAutofillAgent::FormElementObserverCallback
     : public blink::WebFormElementObserverCallback {
  public:
   explicit FormElementObserverCallback(PasswordAutofillAgent* agent)
       : agent_(agent) {}
   ~FormElementObserverCallback() override = default;
 
   void ElementWasHiddenOrRemoved() override {
@@ skipping 148 matching lines @@
     const blink::WebFormControlElement& control_element,
     const base::string16& username,
     const base::string16& password) {
   // The element in context of the suggestion popup.
   const blink::WebInputElement* element = ToWebInputElement(&control_element);
   if (!element)
     return false;
 
   blink::WebInputElement username_element;
   blink::WebInputElement password_element;
-  PasswordInfo* password_info;
+  PasswordInfo* password_info = nullptr;
 
   if (!FindPasswordInfoForElement(*element, &username_element,
                                   &password_element, &password_info) ||
       !IsElementAutocompletable(password_element)) {
     return false;
   }
 
   password_info->password_was_edited_last = false;
   if (element->IsPasswordField()) {
     password_info->password_field_suggestion_was_accepted = true;
@@ skipping 87 matching lines @@
   if (!element.IsPasswordField()) {
     *username_element = element;
   } else {
     // If there is a password field, but a request to the store hasn't been sent
     // yet, then do fetch saved credentials now.
     if (!sent_request_to_store_) {
       SendPasswordForms(false);
       return false;
     }
 
+    *password_element = element;
+
     WebInputToPasswordInfoMap::iterator iter =
         web_input_to_password_info_.find(element);
+    if (iter == web_input_to_password_info_.end()) {
+      PasswordToLoginMap::const_iterator password_iter =
+          password_to_username_.find(element);
+      if (password_iter == password_to_username_.end()) {
+        if (web_input_to_password_info_.empty())
+          return false;
+        // Now all PasswordInfo items refer to the same set of credentials for
+        // fill, so it is ok to take any of them.
+        iter = web_input_to_password_info_.begin();
+      } else {
+        *username_element = password_iter->second;
+      }
+    }
+
     if (iter != web_input_to_password_info_.end()) {
-      // It's a password field without corresponding username field.
-      *password_element = element;
+      // It's a password field without corresponding username field. Try to find
+      // the username field based on visibility.
+      *username_element = FindUsernameElementPrecedingPasswordElement(
+          render_frame()->GetWebFrame(), *password_element);
       *password_info = &iter->second;
       return true;
     }
-    PasswordToLoginMap::const_iterator password_iter =
-        password_to_username_.find(element);
-    if (password_iter == password_to_username_.end()) {
-      if (web_input_to_password_info_.empty())
-        return false;
-
-      *password_element = element;
-      // Now all PasswordInfo items refer to the same set of credentials for
-      // fill, so it is ok to take any of them.
-      *password_info = &web_input_to_password_info_.begin()->second;
-      return true;
-    }
-    *username_element = password_iter->second;
-    *password_element = element;
+    // Otherwise |username_element| has been set above.
   }
 
   WebInputToPasswordInfoMap::iterator iter =
       web_input_to_password_info_.find(*username_element);
-
   if (iter == web_input_to_password_info_.end())
     return false;
 
   *password_info = &iter->second;
   if (password_element->IsNull())
     *password_element = (*password_info)->password_field;
 
   return true;
 }
 
@@ skipping 809 matching lines @@
 PasswordAutofillAgent::GetPasswordManagerDriver() {
   if (!password_manager_driver_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&password_manager_driver_));
   }
 
   return password_manager_driver_;
 }
 
 }  // namespace autofill