Autofill: don't require POST method.

components/autofill/core/browser/autofill_manager_unittest.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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 170 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
 };
 
 // Populates |form| with data corresponding to a simple credit card form.
 // Note that this actually appends fields to the form data, which can be useful
 // for building up more complex test forms.
 void CreateTestCreditCardFormData(FormData* form,
                                   bool is_https,
                                   bool use_month_type) {
   form->name = ASCIIToUTF16("MyForm");
-  form->method = ASCIIToUTF16("POST");
   if (is_https) {
     form->origin = GURL("https://myform.com/form.html");
     form->action = GURL("https://myform.com/submit.html");
   } else {
     form->origin = GURL("http://myform.com/form.html");
     form->action = GURL("http://myform.com/submit.html");
   }
   form->user_submitted = true;
 
   FormFieldData field;
@@ skipping 49 matching lines @@
                       const char* expiration_year,
                       bool has_address_fields,
                       bool has_credit_card_fields,
                       bool use_month_type) {
   // The number of fields in the address and credit card forms created above.
   const size_t kAddressFormSize = 11;
   const size_t kCreditCardFormSize = use_month_type ? 3 : 4;
 
   EXPECT_EQ(expected_page_id, page_id);
   EXPECT_EQ(ASCIIToUTF16("MyForm"), filled_form.name);
-  EXPECT_EQ(ASCIIToUTF16("POST"), filled_form.method);
   if (has_credit_card_fields) {
     EXPECT_EQ(GURL("https://myform.com/form.html"), filled_form.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), filled_form.action);
   } else {
     EXPECT_EQ(GURL("http://myform.com/form.html"), filled_form.origin);
     EXPECT_EQ(GURL("http://myform.com/submit.html"), filled_form.action);
   }
   EXPECT_TRUE(filled_form.user_submitted);
 
   size_t form_size = 0;
@@ skipping 492 matching lines @@
   external_delegate_->CheckSuggestions(
       kDefaultPageID, arraysize(expected_values), expected_values,
       expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return no suggestions when the form has no relevant fields.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsUnknownFields) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
-  form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
 
   FormFieldData field;
   test::CreateTestFormField("Username", "username", "", "text",&field);
   form.fields.push_back(field);
   test::CreateTestFormField("Password", "password", "", "password",&field);
   form.fields.push_back(field);
   test::CreateTestFormField("Quest", "quest", "", "quest", &field);
@@ skipping 55 matching lines @@
   FormsSeen(forms);
 
   // Disable Autofill.
   autofill_manager_->set_autofill_enabled(false);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
 }
 
-// Test that we return a warning explaining that autofill suggestions are
-// unavailable when the form method is GET rather than POST.
-TEST_F(AutofillManagerTest, GetProfileSuggestionsMethodGet) {
-  // Set up our form data.
-  FormData form;
-  test::CreateTestAddressFormData(&form);
-  form.method = ASCIIToUTF16("GET");
-  std::vector<FormData> forms(1, form);
-  FormsSeen(forms);
-
-  const FormFieldData& field = form.fields[0];
-  GetAutofillSuggestions(form, field);
-
-  // No suggestions provided, so send an empty vector as the results.
-  // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<base::string16>());
-
-  // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED)
-  };
-  base::string16 expected_labels[] = {base::string16()};
-  base::string16 expected_icons[] = {base::string16()};
-  int expected_unique_ids[] = {POPUP_ITEM_ID_WARNING_MESSAGE};
-  external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
-
-  // Now add some Autocomplete suggestions. We should return the autocomplete
-  // suggestions and the warning; these will be culled by the renderer.
-  const int kPageID2 = 2;
-  GetAutofillSuggestions(kPageID2, form, field);
-
-  std::vector<base::string16> suggestions;
-  suggestions.push_back(ASCIIToUTF16("Jay"));
-  suggestions.push_back(ASCIIToUTF16("Jason"));
-  AutocompleteSuggestionsReturned(suggestions);
-
-  base::string16 expected_values2[] = {
-    l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED),
-    ASCIIToUTF16("Jay"),
-    ASCIIToUTF16("Jason")
-  };
-  base::string16 expected_labels2[] = { base::string16(), base::string16(),
-                                        base::string16()};
-  base::string16 expected_icons2[] = { base::string16(), base::string16(),
-                                       base::string16()};
-  int expected_unique_ids2[] = {-1, 0, 0};
-  external_delegate_->CheckSuggestions(
-      kPageID2, arraysize(expected_values2), expected_values2,
-      expected_labels2, expected_icons2, expected_unique_ids2);
-
-  // Now clear the test profiles and try again -- we shouldn't return a warning.
-  personal_data_.ClearAutofillProfiles();
-  GetAutofillSuggestions(form, field);
-  EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
-}
-
 // Test that we return all credit card profile suggestions when all form fields
 // are empty.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsEmptyValue) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
@@ skipping 878 matching lines @@
   }
 }
 
 // Test that we correctly fill a form that has author-specified sections, which
 // might not match our expected section breakdown.
 TEST_F(AutofillManagerTest, FillFormWithAuthorSpecifiedSections) {
   // Create a form with a billing section and an unnamed section, interleaved.
   // The billing section includes both address and credit card fields.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
-  form.method = ASCIIToUTF16("POST");
   form.origin = GURL("https://myform.com/form.html");
   form.action = GURL("https://myform.com/submit.html");
   form.user_submitted = true;
 
   FormFieldData field;
 
   test::CreateTestFormField("", "country", "", "text", &field);
   field.autocomplete_attribute = "section-billing country";
   form.fields.push_back(field);
 
@@ skipping 44 matching lines @@
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[1],
       PackGUIDs(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Unnamed section");
     EXPECT_EQ(kDefaultPageID, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
     EXPECT_TRUE(response_data.user_submitted);
     ASSERT_EQ(11U, response_data.fields.size());
 
     ExpectFilledField("", "country", "", "text", response_data.fields[0]);
     ExpectFilledField("", "firstname", "Elvis", "text",
                       response_data.fields[1]);
     ExpectFilledField("", "lastname", "Presley", "text",
                       response_data.fields[2]);
@@ skipping 11 matching lines @@
   // Fill the address portion of the billing section.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
       PackGUIDs(empty, guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Billing address");
     EXPECT_EQ(kPageID2, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
     EXPECT_TRUE(response_data.user_submitted);
     ASSERT_EQ(11U, response_data.fields.size());
 
     ExpectFilledField("", "country", "US", "text",
                       response_data.fields[0]);
     ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
     ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
     ExpectFilledField("", "address", "3734 Elvis Presley Blvd.", "text",
@@ skipping 12 matching lines @@
   const int kPageID3 = 3;
   GUIDPair guid3("00000000-0000-0000-0000-000000000004", 0);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(
       kPageID3, form, form.fields[form.fields.size() - 2],
       PackGUIDs(guid3, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card");
     EXPECT_EQ(kPageID3, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
     EXPECT_TRUE(response_data.user_submitted);
     ASSERT_EQ(11U, response_data.fields.size());
 
     ExpectFilledField("", "country", "", "text", response_data.fields[0]);
     ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
     ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
     ExpectFilledField("", "address", "", "text", response_data.fields[3]);
     ExpectFilledField("", "city", "", "text", response_data.fields[4]);
@@ skipping 152 matching lines @@
                      "theking@gmail.com", "", "", "", "", true, false, false);
   }
 }
 
 // Test that we correctly fill a phone number split across multiple fields.
 TEST_F(AutofillManagerTest, FillPhoneNumber) {
   // In one form, rely on the maxlength attribute to imply phone number parts.
   // In the other form, rely on the autocompletetype attribute.
   FormData form_with_maxlength;
   form_with_maxlength.name = ASCIIToUTF16("MyMaxlengthPhoneForm");
-  form_with_maxlength.method = ASCIIToUTF16("POST");
   form_with_maxlength.origin = GURL("http://myform.com/phone_form.html");
   form_with_maxlength.action = GURL("http://myform.com/phone_submit.html");
   form_with_maxlength.user_submitted = true;
   FormData form_with_autocompletetype = form_with_maxlength;
   form_with_autocompletetype.name = ASCIIToUTF16("MyAutocompletetypePhoneForm");
 
   struct {
     const char* label;
     const char* name;
     size_t max_length;
@@ skipping 214 matching lines @@
   autofill_manager_->set_autofill_enabled(false);
   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   autocomplete_history_manager.reset(
       new MockAutocompleteHistoryManager(autofill_driver_.get(), &client));
   autofill_manager_->autocomplete_history_manager_ =
       autocomplete_history_manager.Pass();
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
-  form.method = ASCIIToUTF16("GET");
   MockAutocompleteHistoryManager* m = static_cast<
       MockAutocompleteHistoryManager*>(
           autofill_manager_->autocomplete_history_manager_.get());
   EXPECT_CALL(*m,
               OnFormSubmitted(_)).Times(1);
   FormSubmitted(form);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
 // Autocomplete suggestions are still received.
 TEST_F(AutofillManagerTest, AutocompleteSuggestionsWhenAutofillDisabled) {
   TestAutofillClient client;
   autofill_manager_.reset(
       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
   autofill_manager_->SetExternalDelegate(external_delegate_.get());
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
-  form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions. We should return the autocomplete
   // suggestions, these will be culled by the renderer.
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
@@ skipping 134 matching lines @@
   prefs->SetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
   prefs->ClearPref(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled);
   ASSERT_FALSE(
       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
 #endif  // defined(OS_MACOSX) || defined(OS_ANDROID)
 }
 
 TEST_F(AutofillManagerTest, DeterminePossibleFieldTypesForUpload) {
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
-  form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
 
   std::vector<ServerFieldTypeSet> expected_types;
 
   // These fields should all match.
   FormFieldData field;
   ServerFieldTypeSet types;
   test::CreateTestFormField("", "1", "Elvis", "text", &field);
@@ skipping 355 matching lines @@
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   EXPECT_TRUE(external_delegate_->on_query_seen());
 }
 
 }  // namespace autofill