Suggest to fill password change forms

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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 840 matching lines @@
   if (!IsElementAutocompletable(element) ||
       !IsElementAutocompletable(password_info->password_field))
     return true;
 
   bool username_is_available =
       !username_element->isNull() && IsElementEditable(*username_element);
   // If the element is a password field, a popup should only be shown if there
   // is no username or the corresponding username element is not editable since
   // it is only in that case that the username element does not have a
   // suggestions popup.
-  if (element.isPasswordField() && username_is_available)
+  if (element.isPasswordField() && username_is_available &&
+      (!password_info->fill_data.is_change_password_form ||

[Garrett Casto, 2015/06/12 00:09:09]

Instead of keeping an additional structure, how about adding a bit to
PasswordInfo that keeps track of if the username was changed and then updating
that in UpdateStateForTextChange(). I think it's a little simpler since we
wouldn't need to add another function and another data structure. It would mean
that we possibly show on both if the user focuses the username field, doesn't
enter any info, and then focuses the password field, but I don't think that
matters much.

Also, can you add a test for this behavior.

[dvadym, 2015/06/12 17:22:37]

I agree, that it's better to be simpler, so I've removed OnFocusChange handler
and implemented your proposition with user typing. Here the question, should we
stop showing suggestions for password field after filling username/password? In
current implementation we will still show, since filling doesn't raise onChange
event. But it seems to be not big deal, since if the user used autofill,
probably he will not click on password field.

I've realized that I hadn't tested ShowSuggestions, only FillSuggestions. So
I've added 3 more tests for testing ShowSuggestion (for username field, for
password field and for password field after typing in username field).

+       (password_info->fill_data.is_change_password_form &&
+        had_focus_username_fields_.find(*username_element) !=
+            had_focus_username_fields_.end())))
     return true;
 
   // Chrome should never show more than one account for a password element since
   // this implies that the username element cannot be modified. Thus even if
   // |show_all| is true, check if the element in question is a password element
   // for the call to ShowSuggestionPopup.
   return ShowSuggestionPopup(
       password_info->fill_data,
       username_element->isNull() ? element : *username_element,
       show_all && !element.isPasswordField(), element.isPasswordField());
@@ skipping 517 matching lines @@
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : login_to_password_info_) {
     login_to_password_info_key_.erase(iter.first);
     password_to_username_.erase(iter.second.password_field);
   }
   login_to_password_info_.clear();
   provisionally_saved_form_.reset();
   nonscript_modified_values_.clear();
+  had_focus_username_fields_.clear();
 }
 
 bool PasswordAutofillAgent::FindLoginInfo(const blink::WebNode& node,
                                           blink::WebInputElement* found_input,
                                           PasswordInfo** found_password) {
   if (!node.isElementNode())
     return false;
 
   blink::WebElement element = node.toConst<blink::WebElement>();
   if (!element.hasHTMLTagName("input"))
@@ skipping 33 matching lines @@
   provisionally_saved_form_ = password_form.Pass();
 }
 
 bool PasswordAutofillAgent::ProvisionallySavedPasswordIsValid() {
    return provisionally_saved_form_ &&
        !provisionally_saved_form_->username_value.empty() &&
        !(provisionally_saved_form_->password_value.empty() &&
          provisionally_saved_form_->new_password_value.empty());
 }
 
+void PasswordAutofillAgent::FocusedNodeChanged(const blink::WebNode& node) {
+  if (node.isNull() || !node.isElementNode())
+    return;
+
+  blink::WebElement web_element = node.toConst<blink::WebElement>();
+  const blink::WebInputElement* element = toWebInputElement(&web_element);
+
+  // If |element| is a username element then add it to username elements that
+  // had focus.
+  if (element && element->isTextField() &&
+      login_to_password_info_.find(*element) != login_to_password_info_.end()) {
+    had_focus_username_fields_.insert(*element);
+  }
+}
+
 // LegacyPasswordAutofillAgent -------------------------------------------------
 
 PasswordAutofillAgent::LegacyPasswordAutofillAgent::LegacyPasswordAutofillAgent(
     content::RenderView* render_view,
     PasswordAutofillAgent* agent)
     : content::RenderViewObserver(render_view), agent_(agent) {
 }
 
 PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     ~LegacyPasswordAutofillAgent() {
@@ skipping 10 matching lines @@
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::DidStopLoading() {
   agent_->DidStopLoading();
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 }  // namespace autofill