[Autofill] Distinguish between native field types and potentially HTML field types.

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/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 476 matching lines @@
     return autocheckout_url_prefix_;
   }
 
   const std::vector<std::pair<WebFormElement::AutocompleteResult, FormData> >&
       request_autocomplete_results() const {
     return request_autocomplete_results_;
   }
 
 
   void set_expected_submitted_field_types(
-      const std::vector<FieldTypeSet>& expected_types) {
+      const std::vector<ServerFieldTypeSet>& expected_types) {
     expected_submitted_field_types_ = expected_types;
   }
 
   virtual void UploadFormDataAsyncCallback(
       const FormStructure* submitted_form,
       const base::TimeTicks& load_time,
       const base::TimeTicks& interaction_time,
       const base::TimeTicks& submission_time) OVERRIDE {
     message_loop_runner_->Quit();
 
     // If we have expected field types set, make sure they match.
     if (!expected_submitted_field_types_.empty()) {
       ASSERT_EQ(expected_submitted_field_types_.size(),
                 submitted_form->field_count());
       for (size_t i = 0; i < expected_submitted_field_types_.size(); ++i) {
         SCOPED_TRACE(
             base::StringPrintf(
                 "Field %d with value %s", static_cast<int>(i),
                 UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
-        const FieldTypeSet& possible_types =
+        const ServerFieldTypeSet& possible_types =
             submitted_form->field(i)->possible_types();
         EXPECT_EQ(expected_submitted_field_types_[i].size(),
                   possible_types.size());
-        for (FieldTypeSet::const_iterator it =
+        for (ServerFieldTypeSet::const_iterator it =
                  expected_submitted_field_types_[i].begin();
              it != expected_submitted_field_types_[i].end(); ++it) {
           EXPECT_TRUE(possible_types.count(*it))
               << "Expected type: " << AutofillType::FieldTypeToString(*it);
         }
       }
     }
 
     AutofillManager::UploadFormDataAsyncCallback(submitted_form,
                                                  load_time,
@@ skipping 99 matching lines @@
   TestPersonalDataManager* personal_data_;
 
   bool autofill_enabled_;
   std::vector<std::pair<WebFormElement::AutocompleteResult, FormData> >
       request_autocomplete_results_;
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   std::string autocheckout_url_prefix_;
   std::string submitted_form_signature_;
-  std::vector<FieldTypeSet> expected_submitted_field_types_;
+  std::vector<ServerFieldTypeSet> expected_submitted_field_types_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 class TestAutofillExternalDelegate : public AutofillExternalDelegate {
  public:
   explicit TestAutofillExternalDelegate(content::WebContents* web_contents,
                                         AutofillManager* autofill_manager,
                                         AutofillDriver* autofill_driver)
       : AutofillExternalDelegate(web_contents, autofill_manager,
@@ skipping 205 matching lines @@
   // profile from which the off the record profile is derived.
   scoped_ptr<Profile> other_browser_context_;
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form)
       : FormStructure(form, std::string()) {}
   virtual ~TestFormStructure() {}
 
-  void SetFieldTypes(const std::vector<AutofillFieldType>& heuristic_types,
-                     const std::vector<AutofillFieldType>& server_types) {
+  void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types,
+                     const std::vector<ServerFieldType>& server_types) {
     ASSERT_EQ(field_count(), heuristic_types.size());
     ASSERT_EQ(field_count(), server_types.size());
 
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* form_field = field(i);
       ASSERT_TRUE(form_field);
       form_field->set_heuristic_type(heuristic_types[i]);
       form_field->set_server_type(server_types[i]);
     }
 
@@ skipping 1763 matching lines @@
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Clear the heuristic types, and instead set the appropriate server types.
-  std::vector<AutofillFieldType> heuristic_types, server_types;
+  std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
-    server_types.push_back(form_structure->field(i)->type());
+    server_types.push_back(form_structure->field(i)->Type().server_type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   // Fill the form.
   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[0],
@@ skipping 97 matching lines @@
 }
 
 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<FieldTypeSet> expected_types;
+  std::vector<ServerFieldTypeSet> expected_types;
 
   // These fields should all match.
   FormFieldData field;
-  FieldTypeSet types;
+  ServerFieldTypeSet types;
   test::CreateTestFormField("", "1", "Elvis", "text", &field);
   types.clear();
   types.insert(NAME_FIRST);
   form.fields.push_back(field);
   expected_types.push_back(types);
 
   test::CreateTestFormField("", "2", "Aaron", "text", &field);
   types.clear();
   types.insert(NAME_MIDDLE);
   form.fields.push_back(field);
@@ skipping 368 matching lines @@
   autofill_manager_->MarkAsFirstPageInAutocheckoutFlow();
 
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Build and add form structure with server data.
-  std::vector<AutofillFieldType> heuristic_types, server_types;
+  std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
-    server_types.push_back(form_structure->field(i)->type());
+    server_types.push_back(form_structure->field(i)->Type().server_type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   autofill_manager_->OnMaybeShowAutocheckoutBubble(form, gfx::RectF());
 
   EXPECT_TRUE(delegate.autocheckout_bubble_shown());
 }
 
 // Test that Autocheckout bubble is not offered when server doesn't have data
 // for the form.
 TEST_F(AutofillManagerTest, TestAutocheckoutBubbleNotShown) {
   MockAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(), &delegate, &personal_data_));
   autofill_manager_->set_autofill_enabled(true);
   autofill_manager_->MarkAsFirstPageInAutocheckoutFlow();
 
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Build form structure without server data.
-  std::vector<AutofillFieldType> heuristic_types, server_types;
+  std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
-    heuristic_types.push_back(form_structure->field(i)->type());
+    heuristic_types.push_back(form_structure->field(i)->Type().server_type());
     server_types.push_back(NO_SERVER_DATA);
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   autofill_manager_->OnMaybeShowAutocheckoutBubble(form, gfx::RectF());
 
   EXPECT_FALSE(delegate.autocheckout_bubble_shown());
 }
 
@@ skipping 21 matching lines @@
   FormData address;
   test::CreateTestAddressFormData(&address);
 
   autofill_manager_->set_autocheckout_url_prefix("test-prefix");
   // Push address only
   std::vector<FormData> forms;
   forms.push_back(address);
 
   // Build and add form structure with server data.
   scoped_ptr<TestFormStructure> form_structure(new TestFormStructure(address));
-  std::vector<AutofillFieldType> heuristic_types, server_types;
+  std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < address.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
-    server_types.push_back(form_structure->field(i)->type());
+    server_types.push_back(form_structure->field(i)->Type().server_type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure.release());
 
   // Make sure normal form is handled correctly.
   autofill_manager_->MarkAsFirstPageInAutocheckoutFlowIgnoringAjax();
   std::vector<FormStructure*> form_structures;
   form_structures = autofill_manager_->GetFormStructures();
   ASSERT_EQ(1U, form_structures.size());
   EXPECT_EQ("/form.html", form_structures[0]->source_url().path());
 
   scoped_ptr<FormStructure> filled_form(new TestFormStructure(address));
   delegate.SetUserSuppliedData(filled_form.Pass());
   autofill_manager_->OnMaybeShowAutocheckoutBubble(address, gfx::RectF());
 
   // Push other forms
   forms.push_back(shipping_options);
   forms.push_back(user_supplied);
 
   // FormStructure should contain the same forms as before.
   DynamicFormsSeen(forms);
   form_structures = autofill_manager_->GetFormStructures();
   ASSERT_EQ(1U, form_structures.size());
   EXPECT_EQ("/form.html", form_structures[0]->source_url().path());
 }
 
 }  // namespace autofill