[Autofill] Clicking datalist chooser arrow now shows Autofill/Autocomplete

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/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 112 matching lines @@
     if ((*strings)[i].length() > kMaxDataLength)
       (*strings)[i].resize(kMaxDataLength);
   }
 }
 
 }  // namespace
 
 AutofillAgent::ShowSuggestionsOptions::ShowSuggestionsOptions()
     : autofill_on_empty_values(false),
       requires_caret_at_end(false),
-      datalist_only(false),
       show_full_suggestion_list(false),
       show_password_suggestions_only(false) {
 }
 
 AutofillAgent::AutofillAgent(content::RenderFrame* render_frame,
                              PasswordAutofillAgent* password_autofill_agent,
                              PasswordGenerationAgent* password_generation_agent)
     : content::RenderFrameObserver(render_frame),
       form_cache_(*render_frame->GetWebFrame()),
       password_autofill_agent_(password_autofill_agent),
@@ skipping 314 matching lines @@
     ShowSuggestionsOptions options;
     options.autofill_on_empty_values = true;
     options.requires_caret_at_end = true;
     ShowSuggestions(element, options);
   }
 }
 
 void AutofillAgent::openTextDataListChooser(const WebInputElement& element) {
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
-  options.datalist_only = true;
   ShowSuggestions(element, options);
 }
 
 void AutofillAgent::dataListOptionsChanged(const WebInputElement& element) {
   if (!is_popup_possibly_visible_ || !element.focused())
     return;
 
   TextFieldDidChangeImpl(element);
 }
 
@@ skipping 166 matching lines @@
         console_message);
   }
 
   in_flight_request_form_.reset();
 }
 
 void AutofillAgent::ShowSuggestions(const WebFormControlElement& element,
                                     const ShowSuggestionsOptions& options) {
   if (!element.isEnabled() || element.isReadOnly())
     return;
-  if (!options.datalist_only && !element.suggestedValue().isEmpty())
+  if (!element.suggestedValue().isEmpty())
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     if (!input_element->isTextField())
       return;
-    if (!options.datalist_only && !input_element->suggestedValue().isEmpty())
+    if (!input_element->suggestedValue().isEmpty())
       return;
   } else {
     DCHECK(form_util::IsTextAreaElement(element));
     if (!element.toConst<WebFormControlElement>().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 (!options.datalist_only &&
-      (value.length() > kMaxDataLength ||
-       (!options.autofill_on_empty_values && value.isEmpty()) ||
-       (options.requires_caret_at_end &&
-        (element.selectionStart() != element.selectionEnd() ||
-         element.selectionEnd() != static_cast<int>(value.length()))))) {
+  if (value.length() > kMaxDataLength ||
+      (!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 (form_util::IsAutofillableInputElement(input_element) &&
       password_autofill_agent_->ShowSuggestions(
           *input_element, options.show_full_suggestion_list,
           is_generation_popup_possibly_visible_)) {
     is_popup_possibly_visible_ = true;
     return;
   }
 
   if (is_generation_popup_possibly_visible_)
     return;
 
   if (options.show_password_suggestions_only)
     return;
 
   // Password field elements should only have suggestions shown by the password
   // autofill agent.
   if (input_element && input_element->isPasswordField())
     return;
 
-  QueryAutofillSuggestions(element, options.datalist_only);
+  QueryAutofillSuggestions(element);
 }
 
 void AutofillAgent::QueryAutofillSuggestions(
-    const WebFormControlElement& element,
-    bool datalist_only) {
+    const WebFormControlElement& element) {
   if (!element.document().frame())
     return;
 
   DCHECK(toWebInputElement(&element) || form_util::IsTextAreaElement(element));
 
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
 
   FormData form;
   FormFieldData field;
   if (!form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                         &field)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, form_util::EXTRACT_VALUE, &field);
   }
-  if (datalist_only)
-    field.should_autocomplete = false;
 
   gfx::RectF bounding_box_scaled = form_util::GetScaledBoundingBox(
       render_frame()->GetRenderView()->GetWebView()->pageScaleFactor(),
       &element_);
 
   std::vector<base::string16> data_list_values;
   std::vector<base::string16> data_list_labels;
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     // Find the datalist values and send them to the browser process.
@@ skipping 89 matching lines @@
 
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill