Add password manager autocomplete suggestion when a username element in clicked.

components/autofill/content/renderer/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/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 274 matching lines @@
   Send(new AutofillHostMsg_RequestAutocomplete(routing_id(), form_data, url));
 }
 
 void AutofillAgent::setIgnoreTextChanges(bool ignore) {
   ignore_text_changes_ = ignore;
 }
 
 void AutofillAgent::InputElementClicked(const WebInputElement& element,
                                         bool was_focused,
                                         bool is_focused) {
-  if (was_focused)
-    ShowSuggestions(element, true, false, true, false);
+  bool show_full_suggestion_list = (element.isAutofilled() && !was_focused) ||
+                                   (!element.isAutofilled() && was_focused);

[Garrett Casto, 2014/03/12 06:50:45]

This seems overly complicated to me. If the element is autofilled and you double
click on the field instead of single click, do you really want to dismiss all
the suggestions on the second click? For the same reason I don't see how the
!element.isAutofilled() is relevant on the next line. 

So I think that you just want element.isAutofilled() || was_focused. Perhaps you
are thinking about this differently, but it seems like there are two cases you
are trying to catch.

1) If the user clicks on an already autofilled entry, we immediately show all
suggestions since it's likely that they are trying to change the already
autofilled entry.
2) If the user is typing something and for some reason still wants to override
inline autocomplete (because the mistyped for instance) they can click on the
input field again.

I've been arguing against 2) so far because I thought that it was not a great
user experience to change the autofill dropdown in mid edit. I hadn't thought
specifically of the mistyping case, but I thought that people would just choose
the username that they wanted on click now if they didn't intend to use inline
autocomplete.

I'm skeptical that this is really better as a user experience, but I'm willing
to let it go. I do think that we should probably add some UMA stats for this to
see how often people make use of either of these cases in practice. Doesn't need
to be in this CL. Part of the reason that I'm okay with this is that I'm
guessing usage is low enough for the click during inline autocomplete that it
doesn't matter much.

[jww, 2014/03/19 01:08:02]

This is for the case you argue for later, not creating a full list when you've
already got an inline autocomplete. That is, we only create a full list when
it's already autofilled it it was already focused.
This analysis makes sense to me. I'll make the change, and I'll start a spearate
CL with UMA stats.

[Garrett Casto, 2014/03/19 20:54:41]

Ahh, my fault. For some reason I thought that we weren't marking the field as
autofilled during inline autocomplete. This makes more sense now. I'm cool with
keeping it this way as well then, though I would add comments to clarify the two
cases so that other aren't confused as well.

[jww, 2014/06/20 18:43:46]

So I've actually had a bit of a change of heart on this behavior, as you'll see
in the latest patch. I was playing around with it a bunch, and it's just a weird
and inconsistent set of behaviors. For example, if we're inline autocompleting
and we prevent retrieval of the full list via another click, then it's very
unintuitive that the answer is to erase the entire username (when it only
required a click earlier).

Additionally, if I click somewhere in the field, that probably means I mistyped
something, so it's nice to get a full list immediately where I can select the
right answer (until I start typing again, at which point the reduced, inline
autocomplete selection jumps in).

Let me know if that reasoning makes sense to you.

+  bool show_password_suggestions_only = !was_focused;
+  ShowSuggestions(element,
+                  true,
+                  false,
+                  true,
+                  false,
+                  show_full_suggestion_list,
+                  show_password_suggestions_only);
 }
 
 void AutofillAgent::InputElementLostFocus() {
   HidePopup();
 }
 
 void AutofillAgent::textFieldDidEndEditing(const WebInputElement& element) {
   password_autofill_agent_->TextFieldDidEndEditing(element);
   has_shown_autofill_popup_for_current_edit_ = false;
   Send(new AutofillHostMsg_DidEndTextFieldEditing(routing_id()));
@@ skipping 28 matching lines @@
   if (password_generation_agent_ &&
       password_generation_agent_->TextDidChangeInTextField(element)) {
     return;
   }
 
   if (password_autofill_agent_->TextDidChangeInTextField(element)) {
     element_ = element;
     return;
   }
 
-  ShowSuggestions(element, false, true, false, false);
+  ShowSuggestions(element, false, true, false, false, false, false);
 
   FormData form;
   FormFieldData field;
   if (FindFormAndFieldForInputElement(element, &form, &field, REQUIRE_NONE)) {
     Send(new AutofillHostMsg_TextFieldDidChange(routing_id(), form, field,
                                                 base::TimeTicks::Now()));
   }
 }
 
 void AutofillAgent::textFieldDidReceiveKeyDown(const WebInputElement& element,
                                                const WebKeyboardEvent& event) {
   if (password_autofill_agent_->TextFieldHandlingKeyDown(element, event)) {
     element_ = element;
     return;
   }
 
   if (event.windowsKeyCode == ui::VKEY_DOWN ||
       event.windowsKeyCode == ui::VKEY_UP)
-    ShowSuggestions(element, true, true, true, false);
+    ShowSuggestions(element, true, true, true, false, false, false);
 }
 
 void AutofillAgent::openTextDataListChooser(const WebInputElement& element) {
-    ShowSuggestions(element, true, false, false, true);
+  ShowSuggestions(element, true, false, false, true, false, false);
 }
 
 void AutofillAgent::AcceptDataListSuggestion(
     const base::string16& suggested_value) {
   base::string16 new_value = suggested_value;
   // If this element takes multiple values then replace the last part with
   // the suggestion.
   if (element_.isMultiple() &&
       element_.formControlType() == WebString::fromUTF8("email")) {
     std::vector<base::string16> parts;
@@ skipping 110 matching lines @@
   in_flight_request_form_.reset();
 }
 
 void AutofillAgent::OnPageShown() {
 }
 
 void AutofillAgent::ShowSuggestions(const WebInputElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled,
-                                    bool datalist_only) {
+                                    bool datalist_only,
+                                    bool show_full_suggestion_list,
+                                    bool show_password_suggestions_only) {
   if (!element.isEnabled() || element.isReadOnly() || !element.isTextField() ||
       element.isPasswordField())
     return;
   if (!datalist_only && !element.suggestedValue().isEmpty())
     return;
 
   // Don't attempt to autofill with values that are too large or if filling
   // criteria are not met.
   WebString value = element.editingValue();
   if (!datalist_only &&
       (value.length() > kMaxDataLength ||
        (!autofill_on_empty_values && value.isEmpty()) ||
        (requires_caret_at_end &&
         (element.selectionStart() != element.selectionEnd() ||
          element.selectionEnd() != static_cast<int>(value.length()))))) {
     // Any popup currently showing is obsolete.
     HidePopup();
     return;
   }
 
   element_ = element;
-  if (password_autofill_agent_->ShowSuggestions(element)) {
+  if (password_autofill_agent_->ShowSuggestions(element,
+                                                show_full_suggestion_list) ||
+      show_password_suggestions_only) {
     is_popup_possibly_visible_ = true;
     return;
   }
 
   // If autocomplete is disabled at the field level, ensure that the native
   // UI won't try to show a warning, since that may conflict with a custom
   // popup. Note that we cannot use the WebKit method element.autoComplete()
   // as it does not allow us to distinguish the case where autocomplete is
   // disabled for *both* the element and for the form.
   const base::string16 autocomplete_attribute =
@@ skipping 105 matching lines @@
     // Only monitors dynamic forms created in the top frame. Dynamic forms
     // inserted in iframes are not captured yet.
     if (!frame->parent()) {
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill