Autofill: don't require POST method.

components/autofill/core/browser/autofill_manager.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/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 310 matching lines @@
   if (!form.user_submitted)
     return false;
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return false;
 
   submitted_form->UpdateFromCache(*cached_submitted_form);
-  if (submitted_form->IsAutofillable(true))
+  if (submitted_form->IsAutofillable())
     ImportFormData(*submitted_form);
 
   // Only upload server statistics and UMA metrics if at least some local data
   // is available to use as a baseline.
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   const std::vector<CreditCard*>& credit_cards =
       personal_data_->GetCreditCards();
   if (!profiles.empty() || !credit_cards.empty()) {
     // Copy the profile and credit card data, so that it can be accessed on a
     // separate thread.
@@ skipping 104 matching lines @@
                               form,
                               field,
                               bounding_box,
                               display_warning);
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (RefreshDataModels() &&
       driver_->RendererIsAvailable() &&
       GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions for forms that aren't auto-fillable.
-      form_structure->IsAutofillable(false)) {
+      form_structure->IsAutofillable()) {
     AutofillType type = autofill_field->Type();
     bool is_filling_credit_card = (type.group() == CREDIT_CARD);
     if (is_filling_credit_card) {
       GetCreditCardSuggestions(
           field, type, &values, &labels, &icons, &unique_ids);
     } else {
       GetProfileSuggestions(
           form_structure, field, type, &values, &labels, &icons, &unique_ids);
     }
 
     DCHECK_EQ(values.size(), labels.size());
     DCHECK_EQ(values.size(), icons.size());
     DCHECK_EQ(values.size(), unique_ids.size());
 
     if (!values.empty()) {
       // Don't provide Autofill suggestions when Autofill is disabled, and don't
       // provide credit card suggestions for non-HTTPS pages. However, provide a
       // warning to the user in these cases.
       int warning = 0;
-      if (!form_structure->IsAutofillable(true))
+      if (!form_structure->IsAutofillable())
         warning = IDS_AUTOFILL_WARNING_FORM_DISABLED;
       else if (is_filling_credit_card && !FormIsHTTPS(*form_structure))
         warning = IDS_AUTOFILL_WARNING_INSECURE_CONNECTION;
       if (warning) {
         values.assign(1, l10n_util::GetStringUTF16(warning));
         labels.assign(1, base::string16());
         icons.assign(1, base::string16());
         unique_ids.assign(1, POPUP_ITEM_ID_WARNING_MESSAGE);
       } else {
         bool section_is_autofilled =
@@ skipping 484 matching lines @@
 }
 
 bool AutofillManager::GetCachedFormAndField(const FormData& form,
                                             const FormFieldData& 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) &&
-      !FormStructure(form).ShouldBeParsed(false)) {
+      !FormStructure(form).ShouldBeParsed()) {
     return false;
   }
 
   // Update the cached form to reflect any dynamic changes to the form data, if
   // necessary.
   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())
@@ skipping 106 matching lines @@
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   std::vector<FormStructure*> non_queryable_forms;
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
-    if (!form_structure->ShouldBeParsed(false))
+    if (!form_structure->ShouldBeParsed())
       continue;
 
     form_structure->DetermineHeuristicTypes(*metric_logger_);
 
     // Set aside forms with method GET or author-specified types, so that they
     // are not included in the query to the server.
     if (form_structure->ShouldBeCrowdsourced())
       form_structures_.push_back(form_structure.release());
     else
       non_queryable_forms.push_back(form_structure.release());
@@ skipping 85 matching lines @@
 }
 
 bool AutofillManager::ShouldUploadForm(const FormStructure& form) {
   if (!IsAutofillEnabled())
     return false;
 
   if (driver_->IsOffTheRecord())
     return false;
 
   // Disregard forms that we wouldn't ever autofill in the first place.
-  if (!form.ShouldBeParsed(true))
+  if (!form.ShouldBeParsed())
     return false;
 
   return true;
 }
 
 }  // namespace autofill