Remove --respect-autocomplete-off-autofill flag.

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 105 matching lines @@
   for (size_t i = 0; i < strings->size(); ++i) {
     if ((*strings)[i].length() > kMaxDataLength)
       (*strings)[i].resize(kMaxDataLength);
   }
 }
 
 // Extract FormData from the form element and return whether the operation was
 // successful.
 bool ExtractFormDataOnSave(const WebFormElement& form_element, FormData* data) {
   return WebFormElementToFormData(
-      form_element, WebFormControlElement(), REQUIRE_NONE,
+      form_element, WebFormControlElement(),
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT), data,
       NULL);
 }
 
 }  // 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::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),
       password_generation_agent_(password_generation_agent),
       legacy_(render_frame->GetRenderView(), this),
       autofill_query_id_(0),
-      display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
       has_shown_autofill_popup_for_current_edit_(false),
       did_set_node_text_(false),
       ignore_text_changes_(false),
       is_popup_possibly_visible_(false),
       weak_ptr_factory_(this) {
   render_frame->GetWebFrame()->setAutofillClient(this);
 
   // This owns itself, and will delete itself when |render_frame| is destructed
   // (same as AutofillAgent).
@@ skipping 134 matching lines @@
       ::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,
                                        WebFormControlElement(),
-                                       REQUIRE_AUTOCOMPLETE,
                                        static_cast<ExtractMask>(
                                            EXTRACT_VALUE |
                                            EXTRACT_OPTION_TEXT |
                                            EXTRACT_OPTIONS),
                                        &form_data,
                                        NULL)) {
     error_message = "failed to parse form.";
   }
 
   if (!error_message.empty()) {
@@ skipping 25 matching lines @@
   // TODO(estade): Remove this check when PageClickTracker is per-frame.
   if (element.document().frame() != render_frame()->GetWebFrame())
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (!input_element && !IsTextAreaElement(element))
     return;
 
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
-  options.display_warning_if_disabled = true;
   options.show_full_suggestion_list = element.isAutofilled();
 
   // On Android, default to showing the dropdown on field focus.
   // On desktop, require an extra click after field focus.
   // See http://crbug.com/427660
 #if defined(OS_ANDROID)
   bool single_click_autofill =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableSingleClickAutofill);
 #else
@@ skipping 61 matching lines @@
       return;
     }
   }
 
   ShowSuggestionsOptions options;
   options.requires_caret_at_end = true;
   ShowSuggestions(element, options);
 
   FormData form;
   FormFieldData field;
-  if (FindFormAndFieldForFormControlElement(element,
-                                            &form,
-                                            &field,
-                                            REQUIRE_NONE)) {
+  if (FindFormAndFieldForFormControlElement(element, &form, &field)) {
     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) {
     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) {
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
   options.datalist_only = true;
   ShowSuggestions(element, options);
 }
@@ skipping 197 matching lines @@
        options.show_password_suggestions_only)) {
     is_popup_possibly_visible_ = true;
     return;
   }
 
   // Password field elements should only have suggestions shown by the password
   // autofill agent.
   if (input_element && input_element->isPasswordField())
     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.
-  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, options.datalist_only);
+  QueryAutofillSuggestions(element, 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));
 
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
-  display_warning_if_disabled_ = display_warning_if_disabled;
-
-  // If autocomplete is disabled at the form level, we want to see if there
-  // would have been any suggestions were it enabled, so that we can show a
-  // warning.  Otherwise, we want to ignore fields that disable autocomplete, so
-  // that the suggestions list does not include suggestions for these form
-  // fields -- see comment 1 on http://crbug.com/69914
-  RequirementsMask requirements =
-      element.autoComplete() ? REQUIRE_AUTOCOMPLETE : REQUIRE_NONE;
-
-  // If we're ignoring autocomplete="off", always extract everything.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kRespectAutocompleteOffForAutofill)) {
-    requirements = REQUIRE_NONE;
-  }
 
   FormData form;
   FormFieldData field;
-  if (!FindFormAndFieldForFormControlElement(element, &form, &field,
-                                             requirements)) {
+  if (!FindFormAndFieldForFormControlElement(element, &form, &field)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, EXTRACT_VALUE, &field);
   }
   if (datalist_only)
     field.should_autocomplete = false;
 
   gfx::RectF bounding_box_scaled = 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.
     GetDataListSuggestions(*input_element,
                            datalist_only,
                            &data_list_values,
                            &data_list_labels);
     TrimStringVectorForIPC(&data_list_values);
     TrimStringVectorForIPC(&data_list_labels);
   }
 
   is_popup_possibly_visible_ = true;
   Send(new AutofillHostMsg_SetDataList(routing_id(),
                                        data_list_values,
                                        data_list_labels));
 
-  Send(new AutofillHostMsg_QueryFormFieldAutofill(routing_id(),
-                                                  autofill_query_id_,
-                                                  form,
-                                                  field,
-                                                  bounding_box_scaled,
-                                                  display_warning_if_disabled));
+  Send(new AutofillHostMsg_QueryFormFieldAutofill(
+      routing_id(), autofill_query_id_, form, field, bounding_box_scaled));
 }
 
 void AutofillAgent::FillFieldWithValue(const base::string16& value,
                                        WebInputElement* node) {
   did_set_node_text_ = true;
   node->setEditingValue(value.substr(0, node->maxLength()));
 }
 
 void AutofillAgent::PreviewFieldWithValue(const base::string16& value,
                                           WebInputElement* node) {
@@ skipping 60 matching lines @@
 
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill