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 300 matching lines @@
   ignore_text_changes_ = ignore;
 }
 
 void AutofillAgent::FormControlElementClicked(
     const WebFormControlElement& element,
     bool was_focused) {
   const WebInputElement* input_element = toWebInputElement(&element);
   if (!input_element && !IsTextAreaElement(element))
     return;
 
-  if (was_focused)
-    ShowSuggestions(element, true, false, true, false);
+  bool show_full_suggestion_list = element.isAutofilled() || was_focused;
+  bool show_password_suggestions_only = !was_focused;
+  ShowSuggestions(element,
+                  true,
+                  false,
+                  true,
+                  false,
+                  show_full_suggestion_list,
+                  show_password_suggestions_only);
 }
 
 void AutofillAgent::FormControlElementLostFocus() {
   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 (!element.focused())
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     if (password_generation_agent_ &&
         password_generation_agent_->TextDidChangeInTextField(*input_element)) {
       is_popup_possibly_visible_ = true;
       return;
     }
-
-    if (password_autofill_agent_->TextDidChangeInTextField(*input_element)) {
-      element_ = element;
-      return;
-    }
   }
 
-  ShowSuggestions(element, false, true, false, false);
+  if (password_autofill_agent_->TextDidChangeInTextField(*input_element)) {

[Garrett Casto, 2014/07/15 22:17:19]

Was this change intentional? Seems like it would crash if input_element is NULL.

[jww, 2014/07/15 22:48:25]

No, I think this was a rebase mistake. Good catch!

+    element_ = element;
+    return;
+  }
+
+  ShowSuggestions(element, false, true, false, false, false, false);
 
   FormData form;
   FormFieldData field;
   if (FindFormAndFieldForFormControlElement(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::firstUserGestureObserved() {
   password_autofill_agent_->FirstUserGestureObserved();
 }
 
 void AutofillAgent::AcceptDataListSuggestion(
     const base::string16& suggested_value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   DCHECK(input_element);
@@ skipping 131 matching lines @@
         console_message);
   }
 
   in_flight_request_form_.reset();
 }
 
 void AutofillAgent::ShowSuggestions(const WebFormControlElement& 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())
     return;
+  if (!datalist_only && !element.suggestedValue().isEmpty())
+    return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     if (!input_element->isTextField() || input_element->isPasswordField())
       return;
     if (!datalist_only && !input_element->suggestedValue().isEmpty())
       return;
   } else {
     DCHECK(IsTextAreaElement(element));
     if (!element.toConst<WebTextAreaElement>().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 (input_element &&
-      password_autofill_agent_->ShowSuggestions(*input_element)) {
+  if (IsAutofillableInputElement(input_element) &&
+      (password_autofill_agent_->ShowSuggestions(*input_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 122 matching lines @@
     // parsed form.
     if (frame && !frame->parent() && !frame->isLoading()) {
       ProcessForms(*frame);
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill