Don't ask the browser for Autofill suggestions for non-autofillable form fields.

chrome/browser/autofill/autofill_manager.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/browser/autofill/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 800 matching lines @@
   // forms are added to the back of the list, whereas original versions of these
   // forms might appear toward the beginning of the list.  The communication
   // protocol with the crowdsourcing server does not permit us to discard the
   // original versions of the forms.
   *form_structure = NULL;
   for (std::vector<FormStructure*>::const_reverse_iterator iter =
            form_structures_.rbegin();
        iter != form_structures_.rend(); ++iter) {
     if (**iter == form) {
       *form_structure = *iter;
-      break;
+
+      // The same form might be cached with multiple field counts: in some
+      // cases, non-autofillable fields are filtered out, whereas in other cases
+      // they are not.  To avoid thrashing the cache, keep scanning until we
+      // find a cached version with the same number of fields, if there is one.
+      if ((*iter)->field_count() == form.fields.size())
+        break;
     }
   }
 
   if (!(*form_structure))
     return false;
 
   return true;
 }
 
 bool AutofillManager::GetCachedFormAndField(const FormData& form,
                                             const FormField& field,
                                             FormStructure** form_structure,
                                             AutofillField** autofill_field) {
   // Find the FormStructure that corresponds to |form|.
   // If we do not have this form in our cache but it is parseable, we'll add it
   // in the call to |UpdateCachedForm()|.
   if (!FindCachedForm(form, form_structure) &&
-      (form_structures_.size() >= kMaxFormCacheSize ||
-       !FormStructure(form).ShouldBeParsed(false))) {
+      !FormStructure(form).ShouldBeParsed(false)) {
     return false;
   }
 
   // Update the cached form to reflect any dynamic changes to the form data, if
   // necessary.
-  UpdateCachedForm(form, *form_structure, form_structure);
+  if (!UpdateCachedForm(form, *form_structure, form_structure))
+    return false;
 
   // No data to return if there are no auto-fillable fields.
   if (!(*form_structure)->autofill_count())
     return false;
 
   // Find the AutofillField that corresponds to |field|.
   *autofill_field = NULL;
   for (std::vector<AutofillField*>::const_iterator iter =
            (*form_structure)->begin();
        iter != (*form_structure)->end(); ++iter) {
     if ((**iter) == field) {
       *autofill_field = *iter;
       break;
     }
   }
 
   // We always update the cache, so we should be guaranteed to find the field.
   DCHECK(*autofill_field);
   return true;
 }
 
-void AutofillManager::UpdateCachedForm(const FormData& live_form,
+bool AutofillManager::UpdateCachedForm(const FormData& live_form,
                                        const FormStructure* cached_form,
                                        FormStructure** updated_form) {
   bool needs_update =
       (!cached_form ||
        live_form.fields.size() != cached_form->field_count());
   for (size_t i = 0; !needs_update && i < cached_form->field_count(); ++i) {
     needs_update = *cached_form->field(i) != live_form.fields[i];
   }
 
   if (!needs_update)
-    return;
+    return true;
+
+  if (form_structures_.size() >= kMaxFormCacheSize)
+    return false;
 
   // Add the new or updated form to our cache.
-  DCHECK(form_structures_.size() < kMaxFormCacheSize);
   form_structures_.push_back(new FormStructure(live_form));
   *updated_form = *form_structures_.rbegin();
   (*updated_form)->DetermineHeuristicTypes();
 
   // If we have cached data, propagate it to the updated form.
   if (cached_form) {
     std::map<string16, const AutofillField*> cached_fields;
     for (size_t i = 0; i < cached_form->field_count(); ++i) {
       const AutofillField* field = cached_form->field(i);
       cached_fields[field->unique_name()] = field;
@@ skipping 10 matching lines @@
     }
 
     // Note: We _must not_ remove the original version of the cached form from
     // the list of |form_structures_|.  Otherwise, we break parsing of the
     // crowdsourcing server's response to our query.
   }
 
   // Annotate the updated form with its predicted types.
   std::vector<FormStructure*> forms(1, *updated_form);
   SendAutofillTypePredictions(forms);
+
+  return true;
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
     const FormField& field,
     AutofillFieldType type,
     std::vector<string16>* values,
     std::vector<string16>* labels,
     std::vector<string16>* icons,
     std::vector<int>* unique_ids) const {
@@ skipping 281 matching lines @@
   *profile_guid = IDToGUID(profile_id);
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }