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

tests are (usually) monitored for a fixed length of time. With this change
field trial tests turn them selves off (will use the default group) after
the expiration time (specified in the Field Trial constructor).

BUG=13463
TEST=field_trial_unittests tests this code thorougly. spdy session and testing
     field_trials in renderer process would be very helpful. thanks much.

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

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

1 files changed, 98 insertions, 33 deletions

diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc
index a8138bb..0af6d60 100644
--- a/base/metrics/field_trial_unittest.cc
+++ b/base/metrics/field_trial_unittest.cc
@@ -13,7 +13,23 @@ namespace base {
 
 class FieldTrialTest : public testing::Test {
  public:
-  FieldTrialTest() : trial_list_() { }
+  FieldTrialTest() : trial_list_() {
+    Time now = Time::NowFromSystemTime();
+    TimeDelta oneYear = TimeDelta::FromDays(365);
+    Time::Exploded exploded;
+
+    Time next_year_time = now + oneYear;
+    next_year_time.LocalExplode(&exploded);
+    next_year_ = exploded.year;
+
+    Time last_year_time = now - oneYear;
+    last_year_time.LocalExplode(&exploded);
+    last_year_ = exploded.year;
+  }
+
+ protected:
+  int next_year_;
+  int last_year_;
 
  private:
   FieldTrialList trial_list_;
@@ -27,20 +43,22 @@ TEST_F(FieldTrialTest, Registration) {
   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", next_year_, 12, 31);
+  EXPECT_EQ(FieldTrial::kNotFinalized, trial1->group_);
   EXPECT_EQ(name1, trial1->name());
-  EXPECT_EQ("", trial1->group_name());
+  EXPECT_EQ("", trial1->group_name_internal());
 
   trial1->AppendGroup("", 7);
 
   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", next_year_, 12, 31);
+  EXPECT_EQ(FieldTrial::kNotFinalized, trial2->group_);
   EXPECT_EQ(name2, trial2->name());
-  EXPECT_EQ("", trial2->group_name());
+  EXPECT_EQ("", trial2->group_name_internal());
 
   trial2->AppendGroup("a first group", 7);
 
@@ -51,20 +69,28 @@ TEST_F(FieldTrialTest, Registration) {
 
 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, next_year_, 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, next_year_, 12, 31);
     int loser_group = trial_false->AppendGroup("ALoser", 0);
 
     EXPECT_NE(loser_group, trial_false->group());
@@ -79,12 +105,13 @@ TEST_F(FieldTrialTest, RemainingProbability) {
   int counter = 0;
   do {
     std::string name = StringPrintf("trial%d", ++counter);
-    trial = new FieldTrial(name, 10);
+    trial = new FieldTrial(name, 10, winner, next_year_, 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 +127,18 @@ TEST_F(FieldTrialTest, FiftyFiftyProbability) {
   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, next_year_, 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 +147,14 @@ TEST_F(FieldTrialTest, FiftyFiftyProbability) {
 
 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, next_year_, 12, 31);
     int might_win = trial->AppendGroup("MightWin", 5);
 
     if (trial->group() == might_win) {
@@ -139,16 +173,21 @@ TEST_F(FieldTrialTest, MiddleProbabilities) {
 
 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, next_year_, 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,14 +199,34 @@ TEST_F(FieldTrialTest, OneWinner) {
   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, last_year_, 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", next_year_, 12, 31);
   // There is no winner yet, so no textual group name is associated with trial.
-  EXPECT_EQ("", trial->group_name());
+  EXPECT_EQ("", trial->group_name_internal());
   FieldTrialList::StatesToString(&save_string);
-  EXPECT_EQ("", save_string);
+  EXPECT_EQ("Some name/Default some name/", save_string);
   save_string.clear();
 
   // Create a winning group.
@@ -177,7 +236,8 @@ TEST_F(FieldTrialTest, Save) {
   save_string.clear();
 
   // Create a second trial and winning group.
-  FieldTrial* trial2 = new FieldTrial("xxx", 10);
+  FieldTrial* trial2 =
+      new FieldTrial("xxx", 10, "Default xxx", next_year_, 12, 31);
   trial2->AppendGroup("yyyy", 10);
 
   FieldTrialList::StatesToString(&save_string);
@@ -189,7 +249,7 @@ TEST_F(FieldTrialTest, Restore) {
   EXPECT_TRUE(FieldTrialList::Find("Some_name") == NULL);
   EXPECT_TRUE(FieldTrialList::Find("xxx") == NULL);
 
-  FieldTrialList::StringAugmentsState("Some_name/Winner/xxx/yyyy/");
+  FieldTrialList::CreateTrialsInChildProcess("Some_name/Winner/xxx/yyyy/");
 
   FieldTrial* trial = FieldTrialList::Find("Some_name");
   ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
@@ -203,29 +263,34 @@ TEST_F(FieldTrialTest, Restore) {
 }
 
 TEST_F(FieldTrialTest, BogusRestore) {
-  EXPECT_FALSE(FieldTrialList::StringAugmentsState("MissingSlash"));
-  EXPECT_FALSE(FieldTrialList::StringAugmentsState("MissingGroupName/"));
-  EXPECT_FALSE(FieldTrialList::StringAugmentsState("MissingFinalSlash/gname"));
-  EXPECT_FALSE(FieldTrialList::StringAugmentsState("/noname, only group/"));
+  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingSlash"));
+  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingGroupName/"));
+  EXPECT_FALSE(
+      FieldTrialList::CreateTrialsInChildProcess("MissingFinalSlash/gname"));
+  EXPECT_FALSE(
+      FieldTrialList::CreateTrialsInChildProcess("/noname, only group/"));
 }
 
 TEST_F(FieldTrialTest, DuplicateRestore) {
-  FieldTrial* trial = new FieldTrial("Some name", 10);
+  FieldTrial* trial =
+      new FieldTrial(
+          "Some name", 10, "Default some name", next_year_, 12, 31);
   trial->AppendGroup("Winner", 10);
   std::string save_string;
   FieldTrialList::StatesToString(&save_string);
   EXPECT_EQ("Some name/Winner/", save_string);
 
   // It is OK if we redundantly specify a winner.
-  EXPECT_TRUE(FieldTrialList::StringAugmentsState(save_string));
+  EXPECT_TRUE(FieldTrialList::CreateTrialsInChildProcess(save_string));
 
   // But it is an error to try to change to a different winner.
-  EXPECT_FALSE(FieldTrialList::StringAugmentsState("Some name/Loser/"));
+  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("Some name/Loser/"));
 }
 
 TEST_F(FieldTrialTest, MakeName) {
-  FieldTrial* trial = new FieldTrial("Field Trial", 10);
-  trial->AppendGroup("Winner", 10);
+  FieldTrial* trial =
+      new FieldTrial("Field Trial", 10, "Winner", next_year_, 12, 31);
+  trial->group();
   EXPECT_EQ("Histogram_Winner",
             FieldTrial::MakeName("Histogram", "Field Trial"));
 }