Add support for autofill server experiments

BUG=none
TEST=unit_tests --gtest_filter=AutoFillMetricsTest.QualityMetricsWithExperimentId:AutoFillQueryXmlParserTest.ParseExperimentId

Review URL: http://codereview.chromium.org/6260027

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@73216 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 91 insertions, 18 deletions

diff --git a/chrome/browser/autofill/autofill_xml_parser_unittest.cc b/chrome/browser/autofill/autofill_xml_parser_unittest.cc
index ec5ebb5..11d1ee6 100644
--- a/chrome/browser/autofill/autofill_xml_parser_unittest.cc
+++ b/chrome/browser/autofill/autofill_xml_parser_unittest.cc
@@ -24,71 +24,140 @@ TEST(AutoFillQueryXmlParserTest, BasicQuery) {
   // Create a vector of AutoFillFieldTypes, to assign the parsed field types to.
   std::vector<AutoFillFieldType> field_types;
   UploadRequired upload_required = USE_UPLOAD_RATES;
+  std::string experiment_id;
 
   // Create a parser.
-  AutoFillQueryXmlParser parse_handler(&field_types, &upload_required);
+  AutoFillQueryXmlParser parse_handler(&field_types, &upload_required,
+                                       &experiment_id);
   buzz::XmlParser parser(&parse_handler);
   parser.Parse(xml.c_str(), xml.length(), true);
   EXPECT_TRUE(parse_handler.succeeded());
-  EXPECT_EQ(upload_required, USE_UPLOAD_RATES);
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
   ASSERT_EQ(4U, field_types.size());
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
   EXPECT_EQ(UNKNOWN_TYPE, field_types[1]);
   EXPECT_EQ(NAME_FIRST, field_types[2]);
   EXPECT_EQ(EMPTY_TYPE, field_types[3]);
+  EXPECT_EQ(std::string(), experiment_id);
 }
 
 // Test parsing the upload required attribute.
 TEST(AutoFillQueryXmlParserTest, TestUploadRequired) {
   std::vector<AutoFillFieldType> field_types;
   UploadRequired upload_required = USE_UPLOAD_RATES;
+  std::string experiment_id;
 
   std::string xml = "<autofillqueryresponse uploadrequired=\"true\">"
                     "<field autofilltype=\"0\" />"
                     "</autofillqueryresponse>";
 
   scoped_ptr<AutoFillQueryXmlParser> parse_handler(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+      new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                 &experiment_id));
   scoped_ptr<buzz::XmlParser> parser(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_TRUE(parse_handler->succeeded());
   EXPECT_EQ(UPLOAD_REQUIRED, upload_required);
   ASSERT_EQ(1U, field_types.size());
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
 
   field_types.clear();
   xml = "<autofillqueryresponse uploadrequired=\"false\">"
         "<field autofilltype=\"0\" />"
         "</autofillqueryresponse>";
 
-  parse_handler.reset(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
   parser.reset(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_TRUE(parse_handler->succeeded());
-  EXPECT_EQ(upload_required, UPLOAD_NOT_REQUIRED);
+  EXPECT_EQ(UPLOAD_NOT_REQUIRED, upload_required);
   ASSERT_EQ(1U, field_types.size());
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
 
   field_types.clear();
   xml = "<autofillqueryresponse uploadrequired=\"bad_value\">"
         "<field autofilltype=\"0\" />"
         "</autofillqueryresponse>";
 
-  parse_handler.reset(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
   parser.reset(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_TRUE(parse_handler->succeeded());
-  EXPECT_EQ(upload_required, USE_UPLOAD_RATES);
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
   ASSERT_EQ(1U, field_types.size());
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
+}
+
+// Test parsing the experiment id attribute
+TEST(AutoFillQueryXmlParserTest, ParseExperimentId) {
+  std::vector<AutoFillFieldType> field_types;
+  UploadRequired upload_required = USE_UPLOAD_RATES;
+  std::string experiment_id;
+
+  // When the attribute is missing, we should get back the default value -- the
+  // empty string.
+  std::string xml = "<autofillqueryresponse>"
+                    "<field autofilltype=\"0\" />"
+                    "</autofillqueryresponse>";
+
+  scoped_ptr<AutoFillQueryXmlParser> parse_handler(
+      new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                 &experiment_id));
+  scoped_ptr<buzz::XmlParser> parser(new buzz::XmlParser(parse_handler.get()));
+  parser->Parse(xml.c_str(), xml.length(), true);
+  EXPECT_TRUE(parse_handler->succeeded());
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
+  ASSERT_EQ(1U, field_types.size());
+  EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
+
+  field_types.clear();
+
+  // When the attribute is present, make sure we parse it.
+  xml = "<autofillqueryresponse experimentid=\"FancyNewAlgorithm\">"
+        "<field autofilltype=\"0\" />"
+        "</autofillqueryresponse>";
+
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
+  parser.reset(new buzz::XmlParser(parse_handler.get()));
+  parser->Parse(xml.c_str(), xml.length(), true);
+  EXPECT_TRUE(parse_handler->succeeded());
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
+  ASSERT_EQ(1U, field_types.size());
+  EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string("FancyNewAlgorithm"), experiment_id);
+
+  field_types.clear();
+
+  // Make sure that we can handle parsing both the upload required and the
+  // experiment id attribute together.
+  xml = "<autofillqueryresponse uploadrequired=\"false\""
+        "                       experimentid=\"ServerSmartyPants\">"
+        "<field autofilltype=\"0\" />"
+        "</autofillqueryresponse>";
+
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
+  parser.reset(new buzz::XmlParser(parse_handler.get()));
+  parser->Parse(xml.c_str(), xml.length(), true);
+  EXPECT_TRUE(parse_handler->succeeded());
+  EXPECT_EQ(UPLOAD_NOT_REQUIRED, upload_required);
+  ASSERT_EQ(1U, field_types.size());
+  EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string("ServerSmartyPants"), experiment_id);
 }
 
 // Test badly formed XML queries.
 TEST(AutoFillQueryXmlParserTest, ParseErrors) {
   std::vector<AutoFillFieldType> field_types;
   UploadRequired upload_required = USE_UPLOAD_RATES;
+  std::string experiment_id;
 
   // Test no AutoFill type.
   std::string xml = "<autofillqueryresponse>"
@@ -96,27 +165,30 @@ TEST(AutoFillQueryXmlParserTest, ParseErrors) {
                     "</autofillqueryresponse>";
 
   scoped_ptr<AutoFillQueryXmlParser> parse_handler(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+      new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                 &experiment_id));
   scoped_ptr<buzz::XmlParser> parser(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_FALSE(parse_handler->succeeded());
-  EXPECT_EQ(upload_required, USE_UPLOAD_RATES);
-  ASSERT_EQ(0U, field_types.size());
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
+  EXPECT_EQ(0U, field_types.size());
+  EXPECT_EQ(std::string(), experiment_id);
 
   // Test an incorrect AutoFill type.
   xml = "<autofillqueryresponse>"
         "<field autofilltype=\"307\"/>"
         "</autofillqueryresponse>";
 
-  parse_handler.reset(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
   parser.reset(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_TRUE(parse_handler->succeeded());
-  EXPECT_EQ(upload_required, USE_UPLOAD_RATES);
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
   ASSERT_EQ(1U, field_types.size());
   // AutoFillType was out of range and should be set to NO_SERVER_DATA.
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
 
   // Test an incorrect AutoFill type.
   field_types.clear();
@@ -125,14 +197,15 @@ TEST(AutoFillQueryXmlParserTest, ParseErrors) {
         "</autofillqueryresponse>";
 
   // Parse fails but an entry is still added to field_types.
-  parse_handler.reset(
-      new AutoFillQueryXmlParser(&field_types, &upload_required));
+  parse_handler.reset(new AutoFillQueryXmlParser(&field_types, &upload_required,
+                                                 &experiment_id));
   parser.reset(new buzz::XmlParser(parse_handler.get()));
   parser->Parse(xml.c_str(), xml.length(), true);
   EXPECT_FALSE(parse_handler->succeeded());
-  EXPECT_EQ(upload_required, USE_UPLOAD_RATES);
+  EXPECT_EQ(USE_UPLOAD_RATES, upload_required);
   ASSERT_EQ(1U, field_types.size());
   EXPECT_EQ(NO_SERVER_DATA, field_types[0]);
+  EXPECT_EQ(std::string(), experiment_id);
 }
 
 // Test successfull upload response.