Display a warning when autofill is disabled for a website.

chrome/browser/renderer_host/render_view_host.cc

 // Copyright (c) 2010 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/browser/renderer_host/render_view_host.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_reader.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/blocked_plugin_manager.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/child_process_security_policy.h"
@@ skipping 18 matching lines @@
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/translate_errors.h"
 #include "chrome/common/url_constants.h"
 #include "gfx/native_widget_types.h"
+#include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFindOptions.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/password_form_dom_manager.h"
 #include "webkit/glue/webaccessibility.h"
 #include "webkit/glue/webdropdata.h"
@@ skipping 1646 matching lines @@
 
   RenderViewHostDelegate::RendererManagement* management_delegate =
       delegate_->GetRendererManagementDelegate();
   if (management_delegate) {
     management_delegate->ShouldClosePage(
         unload_ack_is_for_cross_site_transition_, proceed);
   }
 }
 
 void RenderViewHost::OnQueryFormFieldAutoFill(
-    int query_id, bool form_autofilled, const webkit_glue::FormField& field) {
+    int query_id, bool field_autofilled, const webkit_glue::FormField& field,
+    bool autofill_disabled) {
+  ResetAutoFillState(query_id, autofill_disabled);
+
+  // We first query the autofill delegate for suggestions. We keep track of the
+  // results it gives us, which we will later combine with the autocomplete
+  // suggestions.
   RenderViewHostDelegate::AutoFill* autofill_delegate =
       delegate_->GetAutoFillDelegate();
-  // We first save the AutoFill delegate's suggestions. Then we fetch the
-  // Autocomplete delegate's suggestions and send the combined results back to
-  // the render view.
-  if (autofill_delegate &&
-      autofill_delegate->GetAutoFillSuggestions(query_id,
-                                                form_autofilled,
-                                                field)) {
-  } else {
-    // No suggestions provided, so supply an empty vector as the results.
-    AutoFillSuggestionsReturned(query_id,
-                                std::vector<string16>(),
-                                std::vector<string16>(),
-                                std::vector<string16>(),
-                                std::vector<int>());
+  if (autofill_delegate) {
+    autofill_delegate->GetAutoFillSuggestions(field_autofilled, field,
+                                              autofill_disabled);
   }
 
+  // If autofill is disabled but would have otherwise returned suggestions, we
+  // can route the corresponding warning to the renderer without looking at
+  // autocomplete suggestions.
+  if (autofill_disabled && !autofill_values_.empty()) {
+    DCHECK(autofill_unique_ids_.size() == 1);
+    DCHECK(autofill_unique_ids_[0] == -1);
+    Send(new ViewMsg_AutoFillSuggestionsReturned(routing_id(),
+                                                 autofill_query_id_,
+                                                 autofill_values_,
+                                                 autofill_labels_,
+                                                 autofill_icons_,
+                                                 autofill_unique_ids_));
+    return;
+  }
+
+  // Now query the Autocomplete delegate for suggestions. These will be combined
+  // with the saved autofill suggestions in |AutocompleteSuggestionsReturned()|.
   RenderViewHostDelegate::Autocomplete* autocomplete_delegate =
       delegate_->GetAutocompleteDelegate();
-  if (autocomplete_delegate &&
+  if (autocomplete_delegate) {
       autocomplete_delegate->GetAutocompleteSuggestions(
-          query_id, field.name(), field.value())) {
+          field.name(), field.value());
   } else {
-    // No suggestions provided, so send an empty vector as the results.
-    AutocompleteSuggestionsReturned(query_id, std::vector<string16>());
+    AutocompleteSuggestionsReturned(std::vector<string16>());
   }
 }
 
 void RenderViewHost::OnDidShowAutoFillSuggestions() {
   NotificationService::current()->Notify(
       NotificationType::AUTOFILL_DID_SHOW_SUGGESTIONS,
       Source<RenderViewHost>(this),
       NotificationService::NoDetails());
 }
 
@@ skipping 33 matching lines @@
   autofill_delegate->FillAutoFillFormData(query_id, form, unique_id);
 }
 
 void RenderViewHost::OnDidFillAutoFillFormData() {
   NotificationService::current()->Notify(
       NotificationType::AUTOFILL_DID_FILL_FORM_DATA,
       Source<RenderViewHost>(this),
       NotificationService::NoDetails());
 }
 
+void RenderViewHost::ResetAutoFillState(int query_id, bool autofill_disabled) {
+  autofill_query_id_ = query_id;
+  autofill_disabled_ = autofill_disabled;
+
+  autofill_values_.clear();
+  autofill_labels_.clear();
+  autofill_icons_.clear();
+  autofill_unique_ids_.clear();
+}
+
 void RenderViewHost::AutoFillSuggestionsReturned(
-    int query_id,
-    const std::vector<string16>& names,
+    const std::vector<string16>& values,
     const std::vector<string16>& labels,
     const std::vector<string16>& icons,
     const std::vector<int>& unique_ids) {
-  autofill_values_.assign(names.begin(), names.end());
+  autofill_values_.assign(values.begin(), values.end());
   autofill_labels_.assign(labels.begin(), labels.end());
   autofill_icons_.assign(icons.begin(), icons.end());
   autofill_unique_ids_.assign(unique_ids.begin(), unique_ids.end());
 }
 
 void RenderViewHost::AutocompleteSuggestionsReturned(
-    int query_id, const std::vector<string16>& suggestions) {
+    const std::vector<string16>& suggestions) {
+  if (autofill_disabled_ && suggestions.size() > 0) {

[dhollowa, 2010/11/12 23:44:20]

As we discussed, an alternate approach that might simplify things would be to
have the AutoFillHelper, the AutoFillManager, and the Autocomplete code add to
the list.  Then, once returned, have Autofill helper cull the list in one place.
 It will also add the "Clear" and "Options" menu items conditionally as well.

[Ilya Sherman, 2010/11/13 05:24:43]

This patch set mostly does this.  I've moved all the warning logic out of
RenderViewHost, so that part is nice and clean.  However, I didn't quite take
the approach of "dump everything in, then cull at the end".  In particular,
AutoFillManager doesn't add any autofill entries if it adds a warning; and it
adds at most one warning.  So, the autofill results consist of either a single
warning, or some number (possibly 0) of actual autofill results.  I think the
code comes out a little cleaner this way.

This also doesn't have unit tests for the AutoFillHelper logic, because both
RenderView and WebView were particularly painful to mock out.  In the spirit of
getting this landed and on the canaries, I think it's best to punt the
AutoFillHelper tests to a separate cl.

+    autofill_values_.assign(
+        1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_AUTOFILL_DISABLED));
+    autofill_labels_.assign(1, string16());
+    autofill_icons_.assign(1, string16());
+    autofill_unique_ids_.assign(1, -1);
+    Send(new ViewMsg_AutoFillSuggestionsReturned(routing_id(),
+                                                 autofill_query_id_,
+                                                 autofill_values_,
+                                                 autofill_labels_,
+                                                 autofill_icons_,
+                                                 autofill_unique_ids_));
+    return;
+  }
+
+  // If we could not provide autofill suggestions but can provide autocomplete
+  // suggestions, clear the autofill warning.
+  if (suggestions.size() > 0 &&
+      autofill_unique_ids_.size() > 0 && autofill_unique_ids_[0] < 0) {
+    ResetAutoFillState(autofill_query_id_, autofill_disabled_);
+  }
+
   // Combine AutoFill and Autocomplete values into values and labels.
   for (size_t i = 0; i < suggestions.size(); ++i) {
     bool unique = true;
     for (size_t j = 0; j < autofill_values_.size(); ++j) {
+      // TODO(isherman): Why just when the label is empty?
       // If the AutoFill label is empty, we need to make sure we don't add a
       // duplicate value.
       if (autofill_labels_[j].empty() &&
           autofill_values_[j] == suggestions[i]) {
         unique = false;
         break;
       }
     }
 
     if (unique) {
       autofill_values_.push_back(suggestions[i]);
       autofill_labels_.push_back(string16());
       autofill_icons_.push_back(string16());
       autofill_unique_ids_.push_back(0);  // 0 means no profile.
     }
   }
 
   Send(new ViewMsg_AutoFillSuggestionsReturned(routing_id(),
-                                               query_id,
+                                               autofill_query_id_,
                                                autofill_values_,
                                                autofill_labels_,
                                                autofill_icons_,
                                                autofill_unique_ids_));
 }
 
 void RenderViewHost::AutoFillFormDataFilled(int query_id,
                                             const FormData& form) {
   Send(new ViewMsg_AutoFillFormDataFilled(routing_id(), query_id, form));
 }
@@ skipping 404 matching lines @@
 }
 #else
 void RenderViewHost::OnPagesReadyForPreview(int fd_in_browser) {
   // TODO(kmadhusu): Function definition needs to be changed.
   // fd_in_browser should be the file descriptor of the metafile.
 
   // Send the printingDone msg for now.
   Send(new ViewMsg_PrintingDone(routing_id(), -1, true));
 }
 #endif