Add flag for single click autofill

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 101 matching lines @@
 
   // Limit the size of the strings in the vector.
   for (size_t i = 0; i < strings->size(); ++i) {
     if ((*strings)[i].length() > kMaxDataLength)
       (*strings)[i].resize(kMaxDataLength);
   }
 }
 
 }  // namespace
 
+AutofillAgent::ShowSuggestionsOptions::ShowSuggestionsOptions()
+    : autofill_on_empty_values(false),
+      requires_caret_at_end(false),
+      display_warning_if_disabled(false),
+      datalist_only(false),
+      show_full_suggestion_list(false),
+      show_password_suggestions_only(false) {
+}
+
 AutofillAgent::AutofillAgent(content::RenderView* render_view,
                              PasswordAutofillAgent* password_autofill_agent,
                              PasswordGenerationAgent* password_generation_agent)
     : content::RenderViewObserver(render_view),
       password_autofill_agent_(password_autofill_agent),
       password_generation_agent_(password_generation_agent),
       autofill_query_id_(0),
       web_view_(render_view->GetWebView()),
       display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
@@ skipping 125 matching lines @@
     const WebFormElement& form) {
   // Disallow the dialog over non-https or broken https, except when the
   // ignore SSL flag is passed. See http://crbug.com/272512.
   // TODO(palmer): this should be moved to the browser process after frames
   // get their own processes.
   GURL url(form.document().url());
   content::SSLStatus ssl_status =
       render_view()->GetSSLStatusOfFrame(form.document().frame());
   bool is_safe = url.SchemeIs(url::kHttpsScheme) &&
       !net::IsCertStatusError(ssl_status.cert_status);
-  bool allow_unsafe = CommandLine::ForCurrentProcess()->HasSwitch(
+  bool allow_unsafe = base::CommandLine::ForCurrentProcess()->HasSwitch(
       ::switches::kReduceSecurityForTesting);
 
   FormData form_data;
   std::string error_message;
   if (!in_flight_request_form_.isNull()) {
     error_message = "already active.";
   } else if (!is_safe && !allow_unsafe) {
     error_message =
         "must use a secure connection or --reduce-security-for-testing.";
   } else if (!WebFormElementToFormData(form,
@@ skipping 31 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;
 
-  bool show_full_suggestion_list = element.isAutofilled() || was_focused;
-  bool show_password_suggestions_only = !was_focused;
+  ShowSuggestionsOptions options;
+  options.autofill_on_empty_values = true;
+  options.display_warning_if_disabled = true;
+  options.show_full_suggestion_list = element.isAutofilled();
 
-  // TODO(gcasto): Remove after crbug.com/430318 has been fixed.
-  bool show_suggestions = true;
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableSingleClickAutofill)) {
+    // Show full suggestions when clicking on an already-focused form field. On
+    // the initial click (not focused yet), only show password suggestions.
 #if defined(OS_ANDROID)
-  show_suggestions = was_focused;
+    // TODO(gcasto): Remove after crbug.com/430318 has been fixed.
+    if (!was_focused)
+      return;
 #endif
 
-  if (show_suggestions) {
-    ShowSuggestions(element,
-                    true,
-                    false,
-                    true,
-                    false,
-                    show_full_suggestion_list,
-                    show_password_suggestions_only);
+    options.show_full_suggestion_list =
+        options.show_full_suggestion_list || was_focused;
+    options.show_password_suggestions_only = !was_focused;
   }
+  ShowSuggestions(element, options);
 }
 
 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()));
 }
 
 void AutofillAgent::textFieldDidChange(const WebFormControlElement& element) {
   if (ignore_text_changes_)
@@ skipping 31 matching lines @@
       is_popup_possibly_visible_ = true;
       return;
     }
 
     if (password_autofill_agent_->TextDidChangeInTextField(*input_element)) {
       element_ = element;
       return;
     }
   }
 
-  ShowSuggestions(element, false, true, false, false, false, false);
+  ShowSuggestionsOptions options;
+  options.requires_caret_at_end = true;
+  ShowSuggestions(element, options);
 
   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, false, false);
+      event.windowsKeyCode == ui::VKEY_UP) {
+    ShowSuggestionsOptions options;
+    options.autofill_on_empty_values = true;
+    options.requires_caret_at_end = true;
+    options.display_warning_if_disabled = true;
+    ShowSuggestions(element, options);
+  }
 }
 
 void AutofillAgent::openTextDataListChooser(const WebInputElement& element) {
-  ShowSuggestions(element, true, false, false, true, false, false);
+  ShowSuggestionsOptions options;
+  options.autofill_on_empty_values = true;
+  options.datalist_only = true;
+  ShowSuggestions(element, options);
 }
 
 void AutofillAgent::firstUserGestureObserved() {
   password_autofill_agent_->FirstUserGestureObserved();
 }
 
 void AutofillAgent::AcceptDataListSuggestion(
     const base::string16& suggested_value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   DCHECK(input_element);
@@ skipping 130 matching lines @@
     WebConsoleMessage console_message = WebConsoleMessage(
         WebConsoleMessage::LevelLog, WebString(prefix + message));
     in_flight_request_form_.document().frame()->addMessageToConsole(
         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 show_full_suggestion_list,
-                                    bool show_password_suggestions_only) {
+                                    const ShowSuggestionsOptions& options) {
   if (!element.isEnabled() || element.isReadOnly())
     return;
-  if (!datalist_only && !element.suggestedValue().isEmpty())
+  if (!options.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())
+    if (!options.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 &&
+  if (!options.datalist_only &&
       (value.length() > kMaxDataLength ||
-       (!autofill_on_empty_values && value.isEmpty()) ||
-       (requires_caret_at_end &&
+       (!options.autofill_on_empty_values && value.isEmpty()) ||
+       (options.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 (IsAutofillableInputElement(input_element) &&
-      (password_autofill_agent_->ShowSuggestions(*input_element,
-                                                 show_full_suggestion_list) ||
-       show_password_suggestions_only)) {
+      (password_autofill_agent_->ShowSuggestions(
+           *input_element, options.show_full_suggestion_list) ||
+       options.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 =
-      element.getAttribute("autocomplete");
-  if (LowerCaseEqualsASCII(autocomplete_attribute, "off"))
-    display_warning_if_disabled = false;
+  bool display_warning = options.display_warning_if_disabled;
+  if (display_warning) {
+    const base::string16 autocomplete_attribute =
+        element.getAttribute("autocomplete");
+    if (LowerCaseEqualsASCII(autocomplete_attribute, "off"))
+      display_warning = false;
+  }
 
-  QueryAutofillSuggestions(element,
-                           display_warning_if_disabled,
-                           datalist_only);
+  QueryAutofillSuggestions(element, display_warning, options.datalist_only);
 }
 
 void AutofillAgent::QueryAutofillSuggestions(
     const WebFormControlElement& element,
     bool display_warning_if_disabled,
     bool datalist_only) {
   if (!element.document().frame())
     return;
 
   DCHECK(toWebInputElement(&element) || IsTextAreaElement(element));
@@ skipping 111 matching lines @@
       ProcessForms(*frame);
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       if (password_generation_agent_)
         password_generation_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill