Feature to disable field trials in old versions of Chromium. Field trials...

base/metrics/field_trial_unittest.cc

Index: base/metrics/field_trial_unittest.cc
===================================================================
--- base/metrics/field_trial_unittest.cc	(revision 71223)
+++ base/metrics/field_trial_unittest.cc	(working copy)
@@ -27,8 +27,9 @@
   EXPECT_FALSE(FieldTrialList::Find(name1));
   EXPECT_FALSE(FieldTrialList::Find(name2));
 
-  FieldTrial* trial1 = new FieldTrial(name1, 10);
-  EXPECT_EQ(FieldTrial::kNotParticipating, trial1->group());
+  FieldTrial* trial1 =
+      new FieldTrial(name1, 10, "default name 1 test", 2011, 12, 31);

[jar (doing other things), 2011/01/15 20:52:47]

For these constants, I'd suggest writing a little function to give you dates
that are in the future, or in the past, as needed.

You could put the code to create these in the constructor for FieldTrialTest
class, and then store the constants in member variables for use throughout the
tests in this file.

+  EXPECT_EQ(FieldTrial::kNotFinalized, trial1->group_);
   EXPECT_EQ(name1, trial1->name());
   EXPECT_EQ("", trial1->group_name());
 
@@ -37,8 +38,9 @@
   EXPECT_EQ(trial1, FieldTrialList::Find(name1));
   EXPECT_FALSE(FieldTrialList::Find(name2));
 
-  FieldTrial* trial2 = new FieldTrial(name2, 10);
-  EXPECT_EQ(FieldTrial::kNotParticipating, trial2->group());
+  FieldTrial* trial2 =
+      new FieldTrial(name2, 10, "default name 2 test", 2011, 12, 31);
+  EXPECT_EQ(FieldTrial::kNotFinalized, trial2->group_);
   EXPECT_EQ(name2, trial2->name());
   EXPECT_EQ("", trial2->group_name());
 
@@ -51,20 +53,26 @@
 
 TEST_F(FieldTrialTest, AbsoluteProbabilities) {
   char always_true[] = " always true";
+  char default_always_true[] = " default always true";
   char always_false[] = " always false";
+  char default_always_false[] = " default always false";
   for (int i = 1; i < 250; ++i) {
     // Try lots of names, by changing the first character of the name.
     always_true[0] = i;
+    default_always_true[0] = i;
     always_false[0] = i;
+    default_always_false[0] = i;
 
-    FieldTrial* trial_true = new FieldTrial(always_true, 10);
+    FieldTrial* trial_true =
+        new FieldTrial(always_true, 10, default_always_true, 2011, 12, 31);
     const std::string winner = "TheWinner";
     int winner_group = trial_true->AppendGroup(winner, 10);
 
     EXPECT_EQ(winner_group, trial_true->group());
     EXPECT_EQ(winner, trial_true->group_name());
 
-    FieldTrial* trial_false = new FieldTrial(always_false, 10);
+    FieldTrial* trial_false =
+        new FieldTrial(always_false, 10, default_always_false, 2011, 12, 31);
     int loser_group = trial_false->AppendGroup("ALoser", 0);
 
     EXPECT_NE(loser_group, trial_false->group());
@@ -79,12 +87,13 @@
   int counter = 0;
   do {
     std::string name = StringPrintf("trial%d", ++counter);
-    trial = new FieldTrial(name, 10);
+    trial = new FieldTrial(name, 10, winner, 2011, 12, 31);
     trial->AppendGroup(loser, 5);  // 50% chance of not being chosen.
-  } while (trial->group() != FieldTrial::kNotParticipating);
+    // If a group is not assigned, group_ will be kNotFinalized.
+  } while (trial->group_ != FieldTrial::kNotFinalized);
 
-  // Now add a winner with all remaining probability.
-  trial->AppendGroup(winner, FieldTrial::kAllRemainingProbability);
+  // And that 'default' group (winner) should always win.
+  EXPECT_EQ(FieldTrial::kDefaultGroupNumber, trial->group());
 
   // And that winner should ALWAYS win.
   EXPECT_EQ(winner, trial->group_name());
@@ -100,14 +109,18 @@
   int counter = 0;
   do {
     std::string name = base::StringPrintf("FiftyFifty%d", ++counter);
-    scoped_refptr<FieldTrial> trial(new FieldTrial(name, 2));
+    std::string default_group_name = base::StringPrintf("Default FiftyFifty%d",
+                                                        ++counter);
+    scoped_refptr<FieldTrial> trial(
+        new FieldTrial(name, 2, default_group_name, 2011, 12, 31));
     trial->AppendGroup("first", 1);  // 50% chance of being chosen.
-    if (trial->group() != FieldTrial::kNotParticipating) {
+    // If group_ is kNotFinalized, then a group assignement hasn't been done.
+    if (trial->group_ != FieldTrial::kNotFinalized) {
       first_winner = true;
       continue;
     }
     trial->AppendGroup("second", 1);  // Always chosen at this point.
-    EXPECT_NE(FieldTrial::kNotParticipating, trial->group());
+    EXPECT_NE(FieldTrial::kNotFinalized, trial->group());
     second_winner = true;
   } while ((!second_winner || !first_winner) && counter < 100);
   EXPECT_TRUE(second_winner);
@@ -116,11 +129,14 @@
 
 TEST_F(FieldTrialTest, MiddleProbabilities) {
   char name[] = " same name";
+  char default_group_name[] = " default same name";
   bool false_event_seen = false;
   bool true_event_seen = false;
   for (int i = 1; i < 250; ++i) {
     name[0] = i;
-    FieldTrial* trial = new FieldTrial(name, 10);
+    default_group_name[0] = i;
+    FieldTrial* trial =
+        new FieldTrial(name, 10, default_group_name, 2011, 12, 31);
     int might_win = trial->AppendGroup("MightWin", 5);
 
     if (trial->group() == might_win) {
@@ -139,16 +155,20 @@
 
 TEST_F(FieldTrialTest, OneWinner) {
   char name[] = "Some name";
+  char default_group_name[] = "Default some name";
   int group_count(10);
 
-  FieldTrial* trial = new FieldTrial(name, group_count);
+  FieldTrial* trial =
+      new FieldTrial(name, group_count, default_group_name, 2011, 12, 31);
   int winner_index(-2);
   std::string winner_name;
 
   for (int i = 1; i <= group_count; ++i) {
     int might_win = trial->AppendGroup("", 1);
 
-    if (trial->group() == might_win) {
+    // Because we keep appending groups, we want to see if the last group that
+    // was added has been assigned or not.
+    if (trial->group_ == might_win) {
       EXPECT_EQ(-2, winner_index);
       winner_index = might_win;
       StringAppendF(&winner_name, "%d", might_win);
@@ -160,10 +180,28 @@
   EXPECT_EQ(trial->group_name(), winner_name);
 }
 
+TEST_F(FieldTrialTest, DisableProbability) {
+  const std::string default_group_name = "Default group";
+  const std::string loser = "Loser";
+  const std::string name = "Trial";
+
+  // Create a field trail that has expired.
+  scoped_refptr<FieldTrial> trial;
+  trial = new FieldTrial(name, 1000000000, default_group_name, 2011, 1, 1);
+  trial->AppendGroup(loser, 999999999);  // 99.9999999% chance of being chosen.
+
+  // Because trial has expired, we should always be in the default group.
+  EXPECT_EQ(FieldTrial::kDefaultGroupNumber, trial->group());
+
+  // And that default_group_name should ALWAYS win.
+  EXPECT_EQ(default_group_name, trial->group_name());
+}
+
 TEST_F(FieldTrialTest, Save) {
   std::string save_string;
 
-  FieldTrial* trial = new FieldTrial("Some name", 10);
+  FieldTrial* trial =
+      new FieldTrial("Some name", 10, "Default some name", 2011, 12, 31);
   // There is no winner yet, so no textual group name is associated with trial.
   EXPECT_EQ("", trial->group_name());
   FieldTrialList::StatesToString(&save_string);
@@ -177,7 +215,8 @@
   save_string.clear();
 
   // Create a second trial and winning group.
-  FieldTrial* trial2 = new FieldTrial("xxx", 10);
+  FieldTrial* trial2 =
+      new FieldTrial("xxx", 10, "Default xxx", 2011, 12, 31);
   trial2->AppendGroup("yyyy", 10);
 
   FieldTrialList::StatesToString(&save_string);
@@ -210,7 +249,8 @@
 }
 
 TEST_F(FieldTrialTest, DuplicateRestore) {
-  FieldTrial* trial = new FieldTrial("Some name", 10);
+  FieldTrial* trial =
+      new FieldTrial("Some name", 10, "Default some name", 2011, 12, 31);
   trial->AppendGroup("Winner", 10);
   std::string save_string;
   FieldTrialList::StatesToString(&save_string);
@@ -224,8 +264,9 @@
 }
 
 TEST_F(FieldTrialTest, MakeName) {
-  FieldTrial* trial = new FieldTrial("Field Trial", 10);
-  trial->AppendGroup("Winner", 10);
+  FieldTrial* trial =
+      new FieldTrial("Field Trial", 10, "Winner", 2011, 12, 31);
+  trial->group();
   EXPECT_EQ("Histogram_Winner",
             FieldTrial::MakeName("Histogram", "Field Trial"));
 }