[Autofill] Control using Variations the sending of Autofill field metadata

components/autofill/core/browser/form_structure_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 "components/autofill/core/browser/form_structure.h"
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/rappor/test_rappor_service.h"
+#include "components/variations/entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using rappor::TestRapporService;
 
 namespace autofill {
 
 namespace content {
 
@@ skipping 10 matching lines @@
        iter != form.fields.end(); ++iter) {
     os << *iter
        << " ";
   }
 
   return os;
 }
 
 }  // namespace content
 
-class FormStructureTest {
+class FormStructureTest : public testing::Test {
  public:
   static std::string Hash64Bit(const std::string& str) {
     return FormStructure::Hash64Bit(str);
   }
+
+  void SetUp() override {
+    // By default this trial is enabled on tests.
+    EnableAutofillMetadataFieldTrial();
+  }
+
+ protected:
+  void DisableAutofillMetadataFieldTrial() {
+    field_trial_list_.reset(NULL);
+  }
+
+ private:
+  void EnableAutofillMetadataFieldTrial() {
+    // Clear the existing |field_trial_list_| to avoid firing a DCHECK.
+    field_trial_list_.reset(NULL);
+    field_trial_list_.reset(
+        new base::FieldTrialList(new metrics::SHA1EntropyProvider("foo")));
+    field_trial_ = base::FieldTrialList::CreateFieldTrial(
+        "AutofillFieldMetadata", "Enabled");
+    field_trial_->group();
+  }
+
+  scoped_ptr<base::FieldTrialList> field_trial_list_;
+  scoped_refptr<base::FieldTrial> field_trial_;
 };
 
-TEST(FormStructureTest, FieldCount) {
+TEST_F(FormStructureTest, FieldCount) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
@@ skipping 11 matching lines @@
   field.form_control_type = "text";
   field.should_autocomplete = false;
   form.fields.push_back(field);
 
   // The render process sends all fields to browser including fields with
   // autocomplete=off
   form_structure.reset(new FormStructure(form));
   EXPECT_EQ(4U, form_structure->field_count());
 }
 
-TEST(FormStructureTest, AutofillCount) {
+TEST_F(FormStructureTest, AutofillCount) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
@@ skipping 32 matching lines @@
   field.name = ASCIIToUTF16("address1");
   field.form_control_type = "text";
   field.should_autocomplete = false;
   form.fields.push_back(field);
 
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
   EXPECT_EQ(4U, form_structure->autofill_count());
 }
 
-TEST(FormStructureTest, SourceURL) {
+TEST_F(FormStructureTest, SourceURL) {
   FormData form;
   form.origin = GURL("http://www.foo.com/");
   FormStructure form_structure(form);
 
   EXPECT_EQ(form.origin, form_structure.source_url());
 }
 
-TEST(FormStructureTest, IsAutofillable) {
+TEST_F(FormStructureTest, IsAutofillable) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   // We need at least three text fields to be auto-fillable.
   FormFieldData field;
 
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
@@ skipping 43 matching lines @@
   form_structure->DetermineHeuristicTypes();
   EXPECT_FALSE(form_structure->IsAutofillable());
 
   // But search can be in the URL.
   form.action = GURL("http://search.com/?q=hello");
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
   EXPECT_TRUE(form_structure->IsAutofillable());
 }
 
-TEST(FormStructureTest, ShouldBeParsed) {
+TEST_F(FormStructureTest, ShouldBeParsed) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   // We need at least three text fields to be parseable.
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
@@ skipping 60 matching lines @@
 
   form_structure.reset(new FormStructure(form));
   EXPECT_TRUE(form_structure->ShouldBeParsed());
 
   form.fields[0].form_control_type = "select-one";
   // Now, no text fields.
   form_structure.reset(new FormStructure(form));
   EXPECT_FALSE(form_structure->ShouldBeParsed());
 }
 
-TEST(FormStructureTest, HeuristicsContactInfo) {
+TEST_F(FormStructureTest, HeuristicsContactInfo) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
 
@@ skipping 47 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(4)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(5)->heuristic_type());
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(7)->heuristic_type());
 }
 
 // Verify that we can correctly process the |autocomplete| attribute.
-TEST(FormStructureTest, HeuristicsAutocompleteAttribute) {
+TEST_F(FormStructureTest, HeuristicsAutocompleteAttribute) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("field1");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
@@ skipping 19 matching lines @@
   EXPECT_EQ(HTML_TYPE_GIVEN_NAME, form_structure->field(0)->html_type());
   EXPECT_EQ(HTML_TYPE_FAMILY_NAME, form_structure->field(1)->html_type());
   EXPECT_EQ(HTML_TYPE_EMAIL, form_structure->field(2)->html_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type());
 }
 
 // Verify that we can correctly process the 'autocomplete' attribute for phone
 // number types (especially phone prefixes and suffixes).
-TEST(FormStructureTest, HeuristicsAutocompleteAttributePhoneTypes) {
+TEST_F(FormStructureTest, HeuristicsAutocompleteAttributePhoneTypes) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("field1");
   field.autocomplete_attribute = "tel-local";
   form.fields.push_back(field);
@@ skipping 21 matching lines @@
   EXPECT_EQ(HTML_TYPE_TEL_LOCAL_PREFIX, form_structure->field(1)->html_type());
   EXPECT_EQ(AutofillField::PHONE_PREFIX,
             form_structure->field(1)->phone_part());
   EXPECT_EQ(HTML_TYPE_TEL_LOCAL_SUFFIX, form_structure->field(2)->html_type());
   EXPECT_EQ(AutofillField::PHONE_SUFFIX,
             form_structure->field(2)->phone_part());
 }
 
 // If at least one field includes type hints in the 'autocomplete' attribute, we
 // should not try to apply any other heuristics.
-TEST(FormStructureTest, AutocompleteAttributeOverridesOtherHeuristics) {
+TEST_F(FormStructureTest, AutocompleteAttributeOverridesOtherHeuristics) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   // Start with a regular contact form.
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
@@ skipping 30 matching lines @@
 
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type());
 }
 
 // Even with an 'autocomplete' attribute set, ShouldBeCrowdsourced() should
 // return true if the structure contains a password field, since there are
 // no local heuristics to depend upon in this case. Fields will still not be
 // considered autofillable though.
-TEST(FormStructureTest, PasswordFormShouldBeCrowdsourced) {
+TEST_F(FormStructureTest, PasswordFormShouldBeCrowdsourced) {
   FormData form;
 
   // Start with a regular contact form.
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
 
@@ skipping 11 matching lines @@
   field.form_control_type = "password";
   form.fields.push_back(field);
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
   EXPECT_TRUE(form_structure.ShouldBeCrowdsourced());
 }
 
 // Verify that we can correctly process sections listed in the |autocomplete|
 // attribute.
-TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSections) {
+TEST_F(FormStructureTest, HeuristicsAutocompleteAttributeWithSections) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Some fields will have no section specified.  These fall into the default
   // section.
   field.autocomplete_attribute = "email";
   form.fields.push_back(field);
 
@@ skipping 42 matching lines @@
   // sections.
   std::set<std::string> section_names;
   for (size_t i = 0; i < 9; ++i) {
     section_names.insert(form_structure.field(i)->section());
   }
   EXPECT_EQ(9U, section_names.size());
 }
 
 // Verify that we can correctly process a degenerate section listed in the
 // |autocomplete| attribute.
-TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSectionsDegenerate) {
+TEST_F(FormStructureTest,
+       HeuristicsAutocompleteAttributeWithSectionsDegenerate) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Some fields will have no section specified.  These fall into the default
   // section.
   field.autocomplete_attribute = "email";
   form.fields.push_back(field);
 
@@ skipping 22 matching lines @@
   // section.
   std::set<std::string> section_names;
   for (size_t i = 0; i < 6; ++i) {
     section_names.insert(form_structure.field(i)->section());
   }
   EXPECT_EQ(1U, section_names.size());
 }
 
 // Verify that we can correctly process repeated sections listed in the
 // |autocomplete| attribute.
-TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSectionsRepeated) {
+TEST_F(FormStructureTest, HeuristicsAutocompleteAttributeWithSectionsRepeated) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.autocomplete_attribute = "section-foo email";
   form.fields.push_back(field);
   field.autocomplete_attribute = "section-foo address-line1";
   form.fields.push_back(field);
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes();
 
   // Expect the correct number of fields.
   ASSERT_EQ(2U, form_structure.field_count());
   EXPECT_EQ(2U, form_structure.autofill_count());
 
   // All of the fields in this form should be parsed as belonging to the same
   // section.
   std::set<std::string> section_names;
   for (size_t i = 0; i < 2; ++i) {
     section_names.insert(form_structure.field(i)->section());
   }
   EXPECT_EQ(1U, section_names.size());
 }
 
 // Verify that we do not override the author-specified sections from a form with
 // local heuristics.
-TEST(FormStructureTest, HeuristicsDontOverrideAutocompleteAttributeSections) {
+TEST_F(FormStructureTest, HeuristicsDontOverrideAutocompleteAttributeSections) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.name = ASCIIToUTF16("one");
   field.autocomplete_attribute = "address-line1";
   form.fields.push_back(field);
   field.name = base::string16();
   field.autocomplete_attribute = "section-foo email";
@@ skipping 14 matching lines @@
 
   // Normally, the two separate address fields would cause us to detect two
   // separate sections; but because there is an author-specified section in this
   // form, we do not apply these usual heuristics.
   EXPECT_EQ(ASCIIToUTF16("one"), form_structure.field(0)->name);
   EXPECT_EQ(ASCIIToUTF16("two"), form_structure.field(3)->name);
   EXPECT_EQ(form_structure.field(0)->section(),
             form_structure.field(3)->section());
 }
 
-TEST(FormStructureTest, HeuristicsSample8) {
+TEST_F(FormStructureTest, HeuristicsSample8) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Your First Name:");
   field.name = ASCIIToUTF16("bill.first");
   form.fields.push_back(field);
 
@@ skipping 56 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type());
   // Country.
   EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type());
   // Phone.
   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
       form_structure->field(8)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(9)->heuristic_type());
 }
 
-TEST(FormStructureTest, HeuristicsSample6) {
+TEST_F(FormStructureTest, HeuristicsSample6) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("E-mail address");
   field.name = ASCIIToUTF16("email");
   form.fields.push_back(field);
 
@@ skipping 41 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(4)->heuristic_type());
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(5)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type());
 }
 
 // Tests a sequence of FormFields where only labels are supplied to heuristics
 // for matching.  This works because FormFieldData labels are matched in the
 // case that input element ids (or |name| fields) are missing.
-TEST(FormStructureTest, HeuristicsLabelsOnly) {
+TEST_F(FormStructureTest, HeuristicsLabelsOnly) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = base::string16();
   form.fields.push_back(field);
 
@@ skipping 44 matching lines @@
   // Address.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(4)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(5)->heuristic_type());
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(7)->heuristic_type());
 }
 
-TEST(FormStructureTest, HeuristicsCreditCardInfo) {
+TEST_F(FormStructureTest, HeuristicsCreditCardInfo) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
@@ skipping 33 matching lines @@
   // Credit card expiration year.
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(3)->heuristic_type());
   // CVV.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(4)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(5)->heuristic_type());
 }
 
-TEST(FormStructureTest, HeuristicsCreditCardInfoWithUnknownCardField) {
+TEST_F(FormStructureTest, HeuristicsCreditCardInfoWithUnknownCardField) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
@@ skipping 41 matching lines @@
   // Credit card expiration year.
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(4)->heuristic_type());
   // CVV.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(5)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type());
 }
 
-TEST(FormStructureTest, ThreeAddressLines) {
+TEST_F(FormStructureTest, ThreeAddressLines) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("Address");
   form.fields.push_back(field);
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // Address Line 3.
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type());
 }
 
 // Numbered address lines after line two are ignored.
-TEST(FormStructureTest, SurplusAddressLinesIgnored) {
+TEST_F(FormStructureTest, SurplusAddressLinesIgnored) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("shipping.address.addressLine1");
   form.fields.push_back(field);
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
   // Address Line 4 (ignored).
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(3)->heuristic_type());
 }
 
 // This example comes from expedia.com where they used to use a "Suite" label
 // to indicate a suite or apartment number (the form has changed since this
 // test was written). We interpret this as address line 2. And the following
 // "Street address second line" we interpret as address line 3.
 // See http://crbug.com/48197 for details.
-TEST(FormStructureTest, ThreeAddressLinesExpedia) {
+TEST_F(FormStructureTest, ThreeAddressLinesExpedia) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Street:");
   field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_ads1");
   form.fields.push_back(field);
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // Address Line 3.
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type());
 }
 
 // This example comes from ebay.com where the word "suite" appears in the label
 // and the name "address2" clearly indicates that this is the address line 2.
 // See http://crbug.com/48197 for details.
-TEST(FormStructureTest, TwoAddressLinesEbay) {
+TEST_F(FormStructureTest, TwoAddressLinesEbay) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("address1");
   form.fields.push_back(field);
 
@@ skipping 12 matching lines @@
   ASSERT_EQ(3U, form_structure->autofill_count());
 
   // Address Line 1.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(2)->heuristic_type());
 }
 
-TEST(FormStructureTest, HeuristicsStateWithProvince) {
+TEST_F(FormStructureTest, HeuristicsStateWithProvince) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("Address");
   form.fields.push_back(field);
 
@@ skipping 13 matching lines @@
 
   // Address Line 1.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // State.
   EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(2)->heuristic_type());
 }
 
 // This example comes from lego.com's checkout page.
-TEST(FormStructureTest, HeuristicsWithBilling) {
+TEST_F(FormStructureTest, HeuristicsWithBilling) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name*:");
   field.name = ASCIIToUTF16("editBillingAddress$firstNameBox");
   form.fields.push_back(field);
 
@@ skipping 50 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(4)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(5)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(6)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(8)->heuristic_type());
   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
             form_structure->field(9)->heuristic_type());
   EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(10)->heuristic_type());
 }
 
-TEST(FormStructureTest, ThreePartPhoneNumber) {
+TEST_F(FormStructureTest, ThreePartPhoneNumber) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Phone:");
   field.name = ASCIIToUTF16("dayphone1");
   field.max_length = 0;
   form.fields.push_back(field);
@@ skipping 26 matching lines @@
   // Phone number suffix.
   EXPECT_EQ(PHONE_HOME_NUMBER,
             form_structure->field(1)->heuristic_type());
   // Phone number suffix.
   EXPECT_EQ(PHONE_HOME_NUMBER,
             form_structure->field(2)->heuristic_type());
   // Unknown.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(3)->heuristic_type());
 }
 
-TEST(FormStructureTest, HeuristicsInfernoCC) {
+TEST_F(FormStructureTest, HeuristicsInfernoCC) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(1)->heuristic_type());
   // Card Number.
   EXPECT_EQ(CREDIT_CARD_NUMBER, form_structure->field(2)->heuristic_type());
   // Expiration Date.
   EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type());
   // Expiration Year.
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(4)->heuristic_type());
 }
 
-TEST(FormStructureTest, CVCCodeClash) {
+TEST_F(FormStructureTest, CVCCodeClash) {
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Card number");
   field.name = ASCIIToUTF16("ccnumber");
   form.fields.push_back(field);
 
@@ skipping 34 matching lines @@
   // Expiration Date.
   EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type());
   // Expiration Year.
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(4)->heuristic_type());
   // CVC code.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(5)->heuristic_type());
 }
 
-TEST(FormStructureTest, EncodeQueryRequest) {
+TEST_F(FormStructureTest, EncodeQueryRequest) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address");
@@ skipping 107 matching lines @@
   // Check that we fail if there are only bad form(s).
   ScopedVector<FormStructure> bad_forms;
   bad_forms.push_back(new FormStructure(malformed_form));
   EXPECT_FALSE(FormStructure::EncodeQueryRequest(bad_forms.get(),
                                                  &encoded_signatures,
                                                  &encoded_xml));
   EXPECT_EQ(0U, encoded_signatures.size());
   EXPECT_EQ("", encoded_xml);
 }
 
-TEST(FormStructureTest, EncodeUploadRequest) {
+TEST_F(FormStructureTest, EncodeUploadRequest) {
   scoped_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
@@ skipping 156 matching lines @@
     possible_field_types.back().insert(ADDRESS_BILLING_LINE2);
   }
   form_structure.reset(new FormStructure(form));
   ASSERT_EQ(form_structure->field_count(), possible_field_types.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i)
     form_structure->field(i)->set_possible_types(possible_field_types[i]);
   EXPECT_FALSE(form_structure->EncodeUploadRequest(available_field_types, false,
                                                    &encoded_xml));
 }
 
-TEST(FormStructureTest, EncodeUploadRequestWithAutocomplete) {
+TEST_F(FormStructureTest, EncodeUploadRequestWithAutocomplete) {
   scoped_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
@@ skipping 38 matching lines @@
             " datapresent=\"1440\">"
             "<field signature=\"3763331450\" name=\"firstname\" type=\"text\""
             " autocomplete=\"given-name\" autofilltype=\"3\"/>"
             "<field signature=\"3494530716\" name=\"lastname\" type=\"text\""
             " autocomplete=\"family-name\" autofilltype=\"5\"/>"
             "<field signature=\"1029417091\" name=\"email\" type=\"email\""
             " autocomplete=\"email\" autofilltype=\"9\"/></autofillupload>",
             encoded_xml);
 }
 
-TEST(FormStructureTest, EncodeUploadRequestPartialMetadata) {
+TEST_F(FormStructureTest, EncodeUploadRequestPartialMetadata) {
   scoped_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Some fields don't have "name" or "autocomplete" attributes, and some have
@@ skipping 36 matching lines @@
             " formsignature=\"13043654279838250996\" autofillused=\"true\""
             " datapresent=\"1440\">"
             "<field signature=\"1318412689\" type=\"text\" autofilltype=\"3\"/>"
             "<field signature=\"3494530716\" name=\"lastname\" type=\"text\""
             " autocomplete=\"family-name\" autofilltype=\"5\"/>"
             "<field signature=\"1545468175\" name=\"lastname\" type=\"email\""
             " autocomplete=\"email\" autofilltype=\"9\"/></autofillupload>",
             encoded_xml);
 }
 
-TEST(FormStructureTest, EncodeFieldAssignments) {
+// Sending field metadata to the server is disabled.
+TEST_F(FormStructureTest, EncodeUploadRequest_DisabledMetadataTrial) {
+  DisableAutofillMetadataFieldTrial();
+
   scoped_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
+  form_structure.reset(new FormStructure(form));
+  form_structure->DetermineHeuristicTypes();
+
+  FormFieldData field;
+  field.form_control_type = "text";
+
+  field.label = ASCIIToUTF16("First Name");
+  field.name = ASCIIToUTF16("firstname");
+  field.autocomplete_attribute = "given-name";
+  form.fields.push_back(field);
+  possible_field_types.push_back(ServerFieldTypeSet());
+  possible_field_types.back().insert(NAME_FIRST);
+
+  field.label = ASCIIToUTF16("Last Name");
+  field.name = ASCIIToUTF16("lastname");
+  field.autocomplete_attribute = "family-name";
+  form.fields.push_back(field);
+  possible_field_types.push_back(ServerFieldTypeSet());
+  possible_field_types.back().insert(NAME_LAST);
+
+  field.label = ASCIIToUTF16("Email");
+  field.name = ASCIIToUTF16("email");
+  field.form_control_type = "email";
+  field.autocomplete_attribute = "email";
+  form.fields.push_back(field);
+  possible_field_types.push_back(ServerFieldTypeSet());
+  possible_field_types.back().insert(EMAIL_ADDRESS);
+
+  form_structure.reset(new FormStructure(form));
+
+  ASSERT_EQ(form_structure->field_count(), possible_field_types.size());
+  for (size_t i = 0; i < form_structure->field_count(); ++i)
+    form_structure->field(i)->set_possible_types(possible_field_types[i]);
+
+  ServerFieldTypeSet available_field_types;
+  available_field_types.insert(NAME_FIRST);
+  available_field_types.insert(NAME_LAST);
+  available_field_types.insert(EMAIL_ADDRESS);
+
+  std::string encoded_xml;
+  EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, true,
+                                                  &encoded_xml));
+  EXPECT_EQ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\""
+            " formsignature=\"14746822798145140279\" autofillused=\"true\""
+            " datapresent=\"1440\">"
+            "<field signature=\"3763331450\"/>"
+            "<field signature=\"3494530716\"/>"
+            "<field signature=\"1029417091\"/></autofillupload>",
+            encoded_xml);
+}
+
+TEST_F(FormStructureTest, EncodeFieldAssignments) {
+  scoped_ptr<FormStructure> form_structure;
+  std::vector<ServerFieldTypeSet> possible_field_types;
+  FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
@@ skipping 103 matching lines @@
       "<fields fieldid=\"509334676\" fieldtype=\"30\" name=\"address\"/>"
       "<fields fieldid=\"509334676\" fieldtype=\"31\" name=\"address\"/>"
       "<fields fieldid=\"509334676\" fieldtype=\"37\" name=\"address\"/>"
       "<fields fieldid=\"509334676\" fieldtype=\"38\" name=\"address\"/>"
       "</fieldassignments>",
       encoded_xml);
 }
 
 // Check that we compute the "datapresent" string correctly for the given
 // |available_types|.
-TEST(FormStructureTest, CheckDataPresence) {
+TEST_F(FormStructureTest, CheckDataPresence) {
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("first");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name");
@@ skipping 216 matching lines @@
             " datapresent=\"1f7e000378001fc8\">"
             "<field signature=\"1089846351\" name=\"first\" type=\"text\""
             " autofilltype=\"1\"/>"
             "<field signature=\"2404144663\" name=\"last\" type=\"text\""
             " autofilltype=\"1\"/>"
             "<field signature=\"420638584\" name=\"email\" type=\"text\""
             " autofilltype=\"1\"/></autofillupload>",
             encoded_xml);
 }
 
-TEST(FormStructureTest, CheckMultipleTypes) {
+TEST_F(FormStructureTest, CheckMultipleTypes) {
   // Throughout this test, datapresent should be
   // 0x1440000360000008 ==
   //     0b0001010001000000000000000000001101100000000000000000000000001000
   // The set bits are:
   //  3 == NAME_FIRST
   //  5 == NAME_LAST
   //  9 == EMAIL_ADDRESS
   // 30 == ADDRESS_HOME_LINE1
   // 31 == ADDRESS_HOME_LINE2
   // 33 == ADDRESS_HOME_CITY
@@ skipping 123 matching lines @@
             " autofilltype=\"3\"/>"
             "<field signature=\"2404144663\" name=\"last\" type=\"text\""
             " autofilltype=\"5\"/>"
             "<field signature=\"509334676\" name=\"address\" type=\"text\""
             " autofilltype=\"30\"/>"
             "<field signature=\"509334676\" name=\"address\" type=\"text\""
             " autofilltype=\"60\"/></autofillupload>",
             encoded_xml);
 }
 
-TEST(FormStructureTest, CheckFormSignature) {
+TEST_F(FormStructureTest, CheckFormSignature) {
   // Check that form signature is created correctly.
   scoped_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("email");
   field.name = ASCIIToUTF16("email");
   form.fields.push_back(field);
@@ skipping 47 matching lines @@
   field.label = ASCIIToUTF16("Random Field label3");
   field.name = ASCIIToUTF16("12345random");
   form.fields.push_back(field);
   form_structure.reset(new FormStructure(form));
   EXPECT_EQ(FormStructureTest::Hash64Bit(
       std::string("https://login.facebook.com&login_form&email&first&"
                   "random1234&random&1random&random")),
       form_structure->FormSignature());
 }
 
-TEST(FormStructureTest, ToFormData) {
+TEST_F(FormStructureTest, ToFormData) {
   FormData form;
   form.name = ASCIIToUTF16("the-name");
   form.origin = GURL("http://cool.com");
   form.action = form.origin.Resolve("/login");
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
   form.fields.push_back(field);
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("Submit");
   field.form_control_type = "submit";
   form.fields.push_back(field);
 
   EXPECT_TRUE(form.SameFormAs(FormStructure(form).ToFormData()));
 
   // Currently |FormStructure(form_data)ToFormData().user_submitted| is always
   // false. This forces a future author that changes this to update this test.
   form.user_submitted = true;
   EXPECT_FALSE(form.SameFormAs(FormStructure(form).ToFormData()));
 }
 
-TEST(FormStructureTest, SkipFieldTest) {
+TEST_F(FormStructureTest, SkipFieldTest) {
   FormData form;
   form.name = ASCIIToUTF16("the-name");
   form.origin = GURL("http://cool.com");
   form.action = form.origin.Resolve("/login");
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
@@ skipping 24 matching lines @@
       "</autofillquery>";
   ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(),
                                                 &encoded_signatures,
                                                 &encoded_xml));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kSignature, encoded_signatures[0]);
   EXPECT_EQ(kResponse, encoded_xml);
 }
 
 // One name is missing from one field.
-TEST(FormStructureTest, EncodeQueryRequest_MissingNames) {
+TEST_F(FormStructureTest, EncodeQueryRequest_MissingNames) {
   FormData form;
   // No name set for the form.
   form.origin = GURL("http://cool.com");
   form.action = form.origin.Resolve("/login");
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
@@ skipping 17 matching lines @@
       "<field signature=\"239111655\" name=\"username\" type=\"text\"/>"
       "<field signature=\"1318412689\" type=\"text\"/></form></autofillquery>";
   ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(),
                                                 &encoded_signatures,
                                                 &encoded_xml));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kSignature, encoded_signatures[0]);
   EXPECT_EQ(kResponse, encoded_xml);
 }
 
-TEST(FormStructureTest, PossibleValues) {
+// Sending field metadata to the server is disabled.
+TEST_F(FormStructureTest, EncodeQueryRequest_DisabledMetadataTrial) {
+  DisableAutofillMetadataFieldTrial();
+
+  FormData form;
+  // No name set for the form.
+  form.origin = GURL("http://cool.com");
+  form.action = form.origin.Resolve("/login");
+
+  FormFieldData field;
+  field.label = ASCIIToUTF16("username");
+  field.name = ASCIIToUTF16("username");
+  field.form_control_type = "text";
+  form.fields.push_back(field);
+
+  field.label = base::string16();
+  field.name = ASCIIToUTF16("country");
+  field.form_control_type = "text";
+  field.is_checkable = false;
+  form.fields.push_back(field);
+
+  ScopedVector<FormStructure> forms;
+  forms.push_back(new FormStructure(form));
+  std::vector<std::string> encoded_signatures;
+  std::string encoded_xml;
+
+  const char kSignature[] = "7635954436925888745";
+  const char kResponse[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+      "<autofillquery clientversion=\"6.1.1715.1442/en (GGLL)\">"
+      "<form signature=\"7635954436925888745\">"
+      "<field signature=\"239111655\"/>"
+      "<field signature=\"3654076265\"/>"
+      "</form></autofillquery>";
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(),
+                                                &encoded_signatures,
+                                                &encoded_xml));
+  ASSERT_EQ(1U, encoded_signatures.size());
+  EXPECT_EQ(kSignature, encoded_signatures[0]);
+  EXPECT_EQ(kResponse, encoded_xml);
+}
+
+TEST_F(FormStructureTest, PossibleValues) {
   FormData form_data;
   FormFieldData field;
   field.autocomplete_attribute = "billing country";
   field.option_contents.push_back(ASCIIToUTF16("Down Under"));
   field.option_values.push_back(ASCIIToUTF16("AU"));
   field.option_contents.push_back(ASCIIToUTF16("Fr"));
   field.option_values.push_back(ASCIIToUTF16(""));
   field.option_contents.push_back(ASCIIToUTF16("Germany"));
   field.option_values.push_back(ASCIIToUTF16("GRMNY"));
   form_data.fields.push_back(field);
@@ skipping 19 matching lines @@
 
   // A freeform input (<input>) allows any value (overriding other <select>s).
   FormFieldData freeform_field;
   freeform_field.autocomplete_attribute = "billing country";
   form_data.fields.push_back(freeform_field);
   FormStructure form_structure2(form_data);
   form_structure2.ParseFieldTypesFromAutocompleteAttributes(&unused, &unused);
   EXPECT_EQ(0U, form_structure2.PossibleValues(ADDRESS_BILLING_COUNTRY).size());
 }
 
-TEST(FormStructureTest, ParseQueryResponse) {
+TEST_F(FormStructureTest, ParseQueryResponse) {
   TestRapporService rappor_service;
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("fullname");
   field.name = ASCIIToUTF16("fullname");
   form.fields.push_back(field);
 
@@ skipping 38 matching lines @@
   EXPECT_EQ(30, forms[0]->field(1)->server_type());
   EXPECT_EQ(9, forms[1]->field(0)->server_type());
   EXPECT_EQ(0, forms[1]->field(1)->server_type());
 
   // No RAPPOR metrics are logged in the case there is server data available for
   // all forms.
   EXPECT_EQ(0, rappor_service.GetReportsCount());
 }
 
 // If user defined types are present, only parse password fields.
-TEST(FormStructureTest, ParseQueryResponseAuthorDefinedTypes) {
+TEST_F(FormStructureTest, ParseQueryResponseAuthorDefinedTypes) {
   TestRapporService rappor_service;
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
 
   field.label = ASCIIToUTF16("email");
   field.name = ASCIIToUTF16("email");
   field.form_control_type = "text";
   field.autocomplete_attribute = "email";
   form.fields.push_back(field);
@@ skipping 16 matching lines @@
 
   FormStructure::ParseQueryResponse(response, forms.get(), &rappor_service);
 
   ASSERT_GE(forms[0]->field_count(), 2U);
   EXPECT_EQ(NO_SERVER_DATA, forms[0]->field(0)->server_type());
   EXPECT_EQ(76, forms[0]->field(1)->server_type());
 }
 
 // If the server returns NO_SERVER_DATA for one of the forms, expect RAPPOR
 // logging.
-TEST(FormStructureTest, ParseQueryResponse_RapporLogging_OneFormNoServerData) {
+TEST_F(FormStructureTest,
+       ParseQueryResponse_RapporLogging_OneFormNoServerData) {
   TestRapporService rappor_service;
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("fullname");
   field.name = ASCIIToUTF16("fullname");
   form.fields.push_back(field);
 
@@ skipping 29 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service.GetRecordedSampleForMetric(
       "Autofill.QueryResponseHasNoServerDataForForm", &sample, &type));
   EXPECT_EQ("foo.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // If the server returns NO_SERVER_DATA for both of the forms, expect RAPPOR
 // logging.
-TEST(FormStructureTest, ParseQueryResponse_RapporLogging_AllFormsNoServerData) {
+TEST_F(FormStructureTest,
+       ParseQueryResponse_RapporLogging_AllFormsNoServerData) {
   TestRapporService rappor_service;
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("fullname");
   field.name = ASCIIToUTF16("fullname");
   form.fields.push_back(field);
 
@@ skipping 31 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service.GetRecordedSampleForMetric(
       "Autofill.QueryResponseHasNoServerDataForForm", &sample, &type));
   EXPECT_EQ("foo.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // If the server returns NO_SERVER_DATA for only some of the fields, expect no
 // RAPPOR logging.
-TEST(FormStructureTest, ParseQueryResponse_RapporLogging_PartialNoServerData) {
+TEST_F(FormStructureTest,
+       ParseQueryResponse_RapporLogging_PartialNoServerData) {
   TestRapporService rappor_service;
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("fullname");
   field.name = ASCIIToUTF16("fullname");
   form.fields.push_back(field);
 
@@ skipping 24 matching lines @@
       "</autofillqueryresponse>";
 
   FormStructure::ParseQueryResponse(response, forms.get(), &rappor_service);
 
   // No RAPPOR metrics are logged in the case there is at least some server data
   // available for all forms.
   EXPECT_EQ(0, rappor_service.GetReportsCount());
 }
 
 }  // namespace autofill