Autofill: don't require POST method.

components/autofill/core/browser/form_structure.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/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_data_predictions.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/form_field_data_predictions.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 namespace autofill {
 namespace {
 
-const char kFormMethodPost[] = "post";
-
 // XML elements and attributes.
 const char kAttributeAutofillUsed[] = "autofillused";
 const char kAttributeAutofillType[] = "autofilltype";
 const char kAttributeClientVersion[] = "clientversion";
 const char kAttributeDataPresent[] = "datapresent";
 const char kAttributeFieldID[] = "fieldid";
 const char kAttributeFieldType[] = "fieldtype";
 const char kAttributeFormSignature[] = "formsignature";
 const char kAttributeName[] = "name";
 const char kAttributeSignature[] = "signature";
@@ skipping 325 matching lines @@
     // Make sure to prepend the counter with a non-numeric digit so that we are
     // guaranteed to avoid collisions.
     if (!unique_names.count(field->name))
       unique_names[field->name] = 1;
     else
       ++unique_names[field->name];
     base::string16 unique_name = field->name + base::ASCIIToUTF16("_") +
         base::IntToString16(unique_names[field->name]);
     fields_.push_back(new AutofillField(*field, unique_name));
   }
-
-  std::string method = base::UTF16ToUTF8(form.method);
-  if (StringToLowerASCII(method) == kFormMethodPost) {
-    method_ = POST;
-  } else {
-    // Either the method is 'get', or we don't know.  In this case we default
-    // to GET.
-    method_ = GET;
-  }
 }
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes(
     const AutofillMetrics& metric_logger) {
   // First, try to detect field types based on each field's |autocomplete|
   // attribute value.  If there is at least one form field that specifies an
   // autocomplete type hint, don't try to apply other heuristics to match fields
   // in this form.
   bool has_author_specified_sections;
   ParseFieldTypesFromAutocompleteAttributes(&has_author_specified_types_,
                                             &has_author_specified_sections);
 
   if (!has_author_specified_types_) {
     ServerFieldTypeMap field_type_map;
     FormField::ParseFormFields(fields_.get(), &field_type_map);
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* field = fields_[i];
       ServerFieldTypeMap::iterator iter =
           field_type_map.find(field->unique_name());
       if (iter != field_type_map.end())
         field->set_heuristic_type(iter->second);
     }
   }
 
   UpdateAutofillCount();
   IdentifySections(has_author_specified_sections);
 
-  if (IsAutofillable(true)) {
+  if (IsAutofillable()) {
     metric_logger.LogDeveloperEngagementMetric(
         AutofillMetrics::FILLABLE_FORM_PARSED);
     if (has_author_specified_types_) {
       metric_logger.LogDeveloperEngagementMetric(
           AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS);
     }
   }
 }
 
 bool FormStructure::EncodeUploadRequest(
@@ skipping 196 matching lines @@
 // static
 void FormStructure::GetFieldTypePredictions(
     const std::vector<FormStructure*>& form_structures,
     std::vector<FormDataPredictions>* forms) {
   forms->clear();
   forms->reserve(form_structures.size());
   for (size_t i = 0; i < form_structures.size(); ++i) {
     FormStructure* form_structure = form_structures[i];
     FormDataPredictions form;
     form.data.name = form_structure->form_name_;
-    form.data.method =
-        base::ASCIIToUTF16((form_structure->method_ == POST) ? "POST" : "GET");
     form.data.origin = form_structure->source_url_;
     form.data.action = form_structure->target_url_;
     form.signature = form_structure->FormSignature();
 
     for (std::vector<AutofillField*>::const_iterator field =
              form_structure->fields_.begin();
          field != form_structure->fields_.end(); ++field) {
       form.data.fields.push_back(FormFieldData(**field));
 
       FormFieldDataPredictions annotated_field;
@@ skipping 25 matching lines @@
                             base::UTF16ToUTF8(form_name_) +
                             form_signature_field_names_;
 
   return Hash64Bit(form_string);
 }
 
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
   return field.is_checkable;
 }
 
-bool FormStructure::IsAutofillable(bool require_method_post) const {
+bool FormStructure::IsAutofillable() const {
   if (autofill_count() < kRequiredAutofillFields)
     return false;
 
-  return ShouldBeParsed(require_method_post);
+  return ShouldBeParsed();
 }
 
 void FormStructure::UpdateAutofillCount() {
   autofill_count_ = 0;
   for (std::vector<AutofillField*>::const_iterator iter = begin();
        iter != end(); ++iter) {
     AutofillField* field = *iter;
     if (field && field->IsFieldFillable())
       ++autofill_count_;
   }
 }
 
-bool FormStructure::ShouldBeParsed(bool require_method_post) const {
+bool FormStructure::ShouldBeParsed() const {
   if (active_field_count() < kRequiredAutofillFields)
     return false;
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path() == "/search")
     return false;
 
   bool has_text_field = false;
   for (std::vector<AutofillField*>::const_iterator it = begin();
        it != end() && !has_text_field; ++it) {
     has_text_field |= (*it)->form_control_type != "select-one";
   }
-  if (!has_text_field)
-    return false;
 
-  return !require_method_post || (method_ == POST);
+  return has_text_field;
 }
 
 bool FormStructure::ShouldBeCrowdsourced() const {
-  return !has_author_specified_types_ && ShouldBeParsed(true);
+  return !has_author_specified_types_ && ShouldBeParsed();
 }
 
 void FormStructure::UpdateFromCache(const FormStructure& cached_form) {
   // Map from field signatures to cached fields.
   std::map<std::string, 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->FieldSignature()] = field;
   }
 
@@ skipping 189 matching lines @@
 size_t FormStructure::active_field_count() const {
   return active_field_count_;
 }
 
 FormData FormStructure::ToFormData() const {
   // |data.user_submitted| will always be false.
   FormData data;
   data.name = form_name_;
   data.origin = source_url_;
   data.action = target_url_;
-  data.method = base::ASCIIToUTF16(method_ == POST ? "POST" : "GET");
 
   for (size_t i = 0; i < fields_.size(); ++i) {
     data.fields.push_back(FormFieldData(*fields_[i]));
   }
 
   return data;
 }
 
 bool FormStructure::operator==(const FormData& form) const {
   // TODO(jhawkins): Is this enough to differentiate a form?
@@ skipping 297 matching lines @@
        field != fields_.end(); ++field) {
     FieldTypeGroup field_type_group = (*field)->Type().group();
     if (field_type_group == CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }
 
 }  // namespace autofill