Show display warning if the form is autocomplete off.

chrome/renderer/autofill/autofill_agent.cc

 // Copyright (c) 2011 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 "chrome/renderer/autofill/autofill_agent.h"
 
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 216 matching lines @@
     web_view->hidePopups();
     return;
   }
 
   std::vector<string16> v(values);
   std::vector<string16> l(labels);
   std::vector<string16> i(icons);
   std::vector<int> ids(unique_ids);
   int separator_index = -1;
 
-  if (ids[0] < 0 && ids.size() > 1) {
+  if (!autofill_query_element_.isNull() &&
+      !autofill_query_element_.autoComplete()) {
+    // If autofill is disabled and we had suggestions, show a warning instead.
+    v.assign(1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED));
+    l.assign(1, string16());
+    i.assign(1, string16());
+    ids.assign(1, -1);
+  } else if (ids[0] < 0 && ids.size() > 1) {
     // If we received a warning instead of suggestions from autofill but regular
     // suggestions from autocomplete, don't show the autofill warning.
     v.erase(v.begin());
     l.erase(l.begin());
     i.erase(i.begin());
     ids.erase(ids.begin());
   }
 
   // If we were about to show a warning and we shouldn't, don't.
   if (ids[0] < 0 && !display_warning_if_disabled_)
     return;
 
   // Only include "Autofill Options" special menu item if we have Autofill
   // items, identified by |unique_ids| having at least one valid value.
   bool has_autofill_item = false;
   for (size_t i = 0; i < ids.size(); ++i) {
     if (ids[i] > 0) {
       has_autofill_item = true;
       break;
     }
   }
 
   // The form has been auto-filled, so give the user the chance to clear the
   // form.  Append the 'Clear form' menu item.
   if (has_autofill_item &&
-      form_manager_.FormWithNodeIsAutofilled(autofill_query_node_)) {
+      form_manager_.FormWithNodeIsAutofilled(autofill_query_element_)) {
     v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM));
     l.push_back(string16());
     i.push_back(string16());
     ids.push_back(0);
     suggestions_clear_index_ = v.size() - 1;
     separator_index = v.size() - 1;
   }
 
   if (has_autofill_item) {
     // Append the 'Chrome Autofill options' menu item;
     v.push_back(l10n_util::GetStringFUTF16(IDS_AUTOFILL_OPTIONS_POPUP,
         WideToUTF16(chrome::kBrowserAppName)));
     l.push_back(string16());
     i.push_back(string16());
     ids.push_back(0);
     suggestions_options_index_ = v.size() - 1;
     separator_index = values.size();
   }
 
   // Send to WebKit for display.
-  if (!v.empty() && !autofill_query_node_.isNull() &&
-      autofill_query_node_.isFocusable()) {
+  if (!v.empty() && !autofill_query_element_.isNull() &&
+      autofill_query_element_.isFocusable()) {
     web_view->applyAutofillSuggestions(
-        autofill_query_node_, v, l, i, ids, separator_index);
+        autofill_query_element_, v, l, i, ids, separator_index);
   }
 
   Send(new AutofillHostMsg_DidShowAutofillSuggestions(routing_id()));
 }
 
 void AutofillAgent::OnFormDataFilled(int query_id,
                                      const webkit_glue::FormData& form) {
   if (!render_view()->webview() || query_id != autofill_query_id_)
     return;
 
   switch (autofill_action_) {
     case AUTOFILL_FILL:
-      form_manager_.FillForm(form, autofill_query_node_);
+      form_manager_.FillForm(form, autofill_query_element_);
       break;
     case AUTOFILL_PREVIEW:
-      form_manager_.PreviewForm(form, autofill_query_node_);
+      form_manager_.PreviewForm(form, autofill_query_element_);
       break;
     default:
       NOTREACHED();
   }
   autofill_action_ = AUTOFILL_NONE;
   Send(new AutofillHostMsg_DidFillAutofillFormData(routing_id()));
 }
 
 void AutofillAgent::OnFieldTypePredictionsAvailable(
     const std::vector<FormDataPredictions>& forms) {
   for (size_t i = 0; i < forms.size(); ++i) {
     form_manager_.ShowPredictions(forms[i]);
   }
 }
 
 void AutofillAgent::ShowSuggestions(const WebInputElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled) {
-  if (!element.isEnabled() || element.isReadOnly() || !element.autoComplete() ||
+  // If autocomplete is disabled at the form level, then we might want to show
+  // a warning in place of suggestions. However, if autocomplete is disabled
+  // specifically for this field, we never want to show a warning. Otherwise,
+  // we might interfere with custom popups (e.g. search suggestions) used by
+  // the website.
+  const WebFormElement form = element.form();
+  if (!element.isEnabled() || element.isReadOnly() ||
+      (!element.autoComplete() && form.autoComplete()) ||
       !element.isTextField() || element.isPasswordField() ||
       !element.suggestedValue().isEmpty())
     return;
 
   // If the field has no name, then we won't have values.
   if (element.nameForAutofill().isEmpty())
     return;
 
   // Don't attempt to autofill with values that are too large.
   WebString value = element.value();
   if (value.length() > kMaximumTextSizeForAutofill)
     return;
 
   if (!autofill_on_empty_values && value.isEmpty())
     return;
 
   if (requires_caret_at_end &&
       (element.selectionStart() != element.selectionEnd() ||
        element.selectionEnd() != static_cast<int>(value.length())))
     return;
 
   QueryAutofillSuggestions(element, display_warning_if_disabled);
 }
 
-void AutofillAgent::QueryAutofillSuggestions(const WebNode& node,
+void AutofillAgent::QueryAutofillSuggestions(const WebInputElement& element,
                                              bool display_warning_if_disabled) {
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
-  autofill_query_node_ = node;
+  autofill_query_element_ = element;
   display_warning_if_disabled_ = display_warning_if_disabled;
 
   webkit_glue::FormData form;
   webkit_glue::FormField field;
-  if (!FindFormAndFieldForNode(node, &form, &field)) {
+  if (!FindFormAndFieldForNode(element, &form, &field)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
-    FormManager::WebFormControlElementToFormField(
-        node.toConst<WebFormControlElement>(), FormManager::EXTRACT_VALUE,
-        &field);
+    FormManager::WebFormControlElementToFormField(element,
+                                                  FormManager::EXTRACT_VALUE,
+                                                  &field);
   }
 
   Send(new AutofillHostMsg_QueryFormFieldAutofill(
       routing_id(), autofill_query_id_, form, field));
 }
 
 void AutofillAgent::FillAutofillFormData(const WebNode& node,
                                          int unique_id,
                                          AutofillAction action) {
   static int query_counter = 0;
@@ skipping 24 matching lines @@
   // WebFormControlElementToFormField does not scrape the DOM for the field
   // label, so find the label here.
   // TODO(isherman): Add form and field identities so we can use the cached form
   // data in FormManager.
   field->label = FormManager::LabelForElement(element);
 
   return true;
 }
 
 }  // namespace autofill