Supporting command line argument to force field trials

base/metrics/field_trial_unittest.cc

Index: base/metrics/field_trial_unittest.cc
diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc
index 7dc70ec39482a5b0817099505de09fc880580080..abf3e89556ea04abaafc3e8f07fc87d049d64c62 100644
--- a/base/metrics/field_trial_unittest.cc
+++ b/base/metrics/field_trial_unittest.cc
@@ -47,8 +47,8 @@ TEST_F(FieldTrialTest, Registration) {
   EXPECT_FALSE(FieldTrialList::Find(name1));
   EXPECT_FALSE(FieldTrialList::Find(name2));
 
-  FieldTrial* trial1 =
-      new FieldTrial(name1, 10, "default name 1 test", next_year_, 12, 31);
+  FieldTrial* trial1 = FieldTrial::CreateInstance(
+      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_internal());
@@ -58,8 +58,8 @@ TEST_F(FieldTrialTest, Registration) {
   EXPECT_EQ(trial1, FieldTrialList::Find(name1));
   EXPECT_FALSE(FieldTrialList::Find(name2));
 
-  FieldTrial* trial2 =
-      new FieldTrial(name2, 10, "default name 2 test", next_year_, 12, 31);
+  FieldTrial* trial2 = FieldTrial::CreateInstance(
+      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_internal());
@@ -83,18 +83,16 @@ TEST_F(FieldTrialTest, AbsoluteProbabilities) {
     always_false[0] = i;
     default_always_false[0] = i;
 
-    FieldTrial* trial_true =
-        new FieldTrial(
-            always_true, 10, default_always_true, next_year_, 12, 31);
+    FieldTrial* trial_true = FieldTrial::CreateInstance(
+        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, default_always_false, next_year_, 12, 31);
+    FieldTrial* trial_false = FieldTrial::CreateInstance(
+        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());
@@ -109,7 +107,7 @@ TEST_F(FieldTrialTest, RemainingProbability) {
   int counter = 0;
   do {
     std::string name = StringPrintf("trial%d", ++counter);
-    trial = new FieldTrial(name, 10, winner, next_year_, 12, 31);
+    trial = FieldTrial::CreateInstance(name, 10, winner, next_year_, 12, 31);
     trial->AppendGroup(loser, 5);  // 50% chance of not being chosen.
     // If a group is not assigned, group_ will be kNotFinalized.
   } while (trial->group_ != FieldTrial::kNotFinalized);
@@ -133,8 +131,8 @@ TEST_F(FieldTrialTest, FiftyFiftyProbability) {
     std::string name = base::StringPrintf("FiftyFifty%d", ++counter);
     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));
+    scoped_refptr<FieldTrial> trial(FieldTrial::CreateInstance(
+        name, 2, default_group_name, next_year_, 12, 31));
     trial->AppendGroup("first", 1);  // 50% chance of being chosen.
     // If group_ is kNotFinalized, then a group assignement hasn't been done.
     if (trial->group_ != FieldTrial::kNotFinalized) {
@@ -157,8 +155,8 @@ TEST_F(FieldTrialTest, MiddleProbabilities) {
   for (int i = 1; i < 250; ++i) {
     name[0] = i;
     default_group_name[0] = i;
-    FieldTrial* trial =
-        new FieldTrial(name, 10, default_group_name, next_year_, 12, 31);
+    FieldTrial* trial = FieldTrial::CreateInstance(
+        name, 10, default_group_name, next_year_, 12, 31);
     int might_win = trial->AppendGroup("MightWin", 5);
 
     if (trial->group() == might_win) {
@@ -180,9 +178,8 @@ TEST_F(FieldTrialTest, OneWinner) {
   char default_group_name[] = "Default some name";
   int group_count(10);
 
-  FieldTrial* trial =
-      new FieldTrial(
-          name, group_count, default_group_name, next_year_, 12, 31);
+  FieldTrial* trial = FieldTrial::CreateInstance(
+      name, group_count, default_group_name, next_year_, 12, 31);
   int winner_index(-2);
   std::string winner_name;
 
@@ -210,7 +207,7 @@ TEST_F(FieldTrialTest, DisableProbability) {
 
   // Create a field trail that has expired.
   scoped_refptr<FieldTrial> trial;
-  trial = new FieldTrial(
+  trial = FieldTrial::CreateInstance(
       name, 1000000000, default_group_name, last_year_, 1, 1);
   trial->AppendGroup(loser, 999999999);  // 99.9999999% chance of being chosen.
 
@@ -245,7 +242,7 @@ TEST_F(FieldTrialTest, HashName) {
 TEST_F(FieldTrialTest, NameGroupIds) {
   std::string no_group("No Group");
   uint32 no_group_id = FieldTrial::HashName(no_group);
-  scoped_refptr<FieldTrial> trial(new FieldTrial(
+  scoped_refptr<FieldTrial> trial(FieldTrial::CreateInstance(
       no_group, 10, "Default", next_year_, 12, 31));
 
   // There is no winner yet, so no NameGroupId should be returned.
@@ -255,7 +252,8 @@ TEST_F(FieldTrialTest, NameGroupIds) {
   // Create a single winning group.
   std::string one_winner("One Winner");
   uint32 one_winner_id = FieldTrial::HashName(one_winner);
-  trial = new FieldTrial(one_winner, 10, "Default", next_year_, 12, 31);
+  trial = FieldTrial::CreateInstance(
+      one_winner, 10, "Default", next_year_, 12, 31);
   std::string winner("Winner");
   uint32 winner_group_id = FieldTrial::HashName(winner);
   trial->AppendGroup(winner, 10);
@@ -265,8 +263,8 @@ TEST_F(FieldTrialTest, NameGroupIds) {
 
   std::string multi_group("MultiGroup");
   uint32 multi_group_id = FieldTrial::HashName(multi_group);
-  scoped_refptr<FieldTrial> multi_group_trial =
-      new FieldTrial(multi_group, 9, "Default", next_year_, 12, 31);
+  scoped_refptr<FieldTrial> multi_group_trial = FieldTrial::CreateInstance(
+      multi_group, 9, "Default", next_year_, 12, 31);
 
   multi_group_trial->AppendGroup("Me", 3);
   multi_group_trial->AppendGroup("You", 3);
@@ -294,9 +292,8 @@ TEST_F(FieldTrialTest, NameGroupIds) {
 TEST_F(FieldTrialTest, Save) {
   std::string save_string;
 
-  FieldTrial* trial =
-      new FieldTrial(
-          "Some name", 10, "Default some name", next_year_, 12, 31);
+  FieldTrial* trial = FieldTrial::CreateInstance(
+      "Some name", 10, "Default some name", next_year_, 12, 31);
   // There is no winner yet, so no textual group name is associated with trial.
   // In this case, the trial should not be included.
   EXPECT_EQ("", trial->group_name_internal());
@@ -311,8 +308,8 @@ TEST_F(FieldTrialTest, Save) {
   save_string.clear();
 
   // Create a second trial and winning group.
-  FieldTrial* trial2 =
-      new FieldTrial("xxx", 10, "Default xxx", next_year_, 12, 31);
+  FieldTrial* trial2 = FieldTrial::CreateInstance(
+      "xxx", 10, "Default xxx", next_year_, 12, 31);
   trial2->AppendGroup("yyyy", 10);
 
   FieldTrialList::StatesToString(&save_string);
@@ -324,7 +321,7 @@ TEST_F(FieldTrialTest, Restore) {
   EXPECT_TRUE(FieldTrialList::Find("Some_name") == NULL);
   EXPECT_TRUE(FieldTrialList::Find("xxx") == NULL);
 
-  FieldTrialList::CreateTrialsInChildProcess("Some_name/Winner/xxx/yyyy/");
+  FieldTrialList::CreateTrialsFromString("Some_name/Winner/xxx/yyyy/");
 
   FieldTrial* trial = FieldTrialList::Find("Some_name");
   ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
@@ -338,28 +335,27 @@ TEST_F(FieldTrialTest, Restore) {
 }
 
 TEST_F(FieldTrialTest, BogusRestore) {
-  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingSlash"));
-  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingGroupName/"));
-  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess(
+  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingSlash"));
+  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingGroupName/"));
+  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
       "MissingFinalSlash/gname"));
-  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess(
+  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
       "noname, only group/"));
 }
 
 TEST_F(FieldTrialTest, DuplicateRestore) {
-  FieldTrial* trial =
-      new FieldTrial(
-          "Some name", 10, "Default some name", next_year_, 12, 31);
+  FieldTrial* trial = FieldTrial::CreateInstance(
+      "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::CreateTrialsInChildProcess(save_string));
+  EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(save_string));
 
   // But it is an error to try to change to a different winner.
-  EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess(
+  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
       "Some name/Loser/"));
 }
 
@@ -375,9 +371,8 @@ TEST_F(FieldTrialTest, CreateFieldTrial) {
 }
 
 TEST_F(FieldTrialTest, DuplicateFieldTrial) {
-  FieldTrial* trial =
-      new FieldTrial(
-          "Some_name", 10, "Default some name", next_year_, 12, 31);
+  FieldTrial* trial = FieldTrial::CreateInstance(
+      "Some_name", 10, "Default some name", next_year_, 12, 31);
   trial->AppendGroup("Winner", 10);
 
   // It is OK if we redundantly specify a winner.
@@ -390,8 +385,8 @@ TEST_F(FieldTrialTest, DuplicateFieldTrial) {
 }
 
 TEST_F(FieldTrialTest, MakeName) {
-  FieldTrial* trial =
-      new FieldTrial("Field Trial", 10, "Winner", next_year_, 12, 31);
+  FieldTrial* trial = FieldTrial::CreateInstance(
+      "Field Trial", 10, "Winner", next_year_, 12, 31);
   trial->group();
   EXPECT_EQ("Histogram_Winner",
             FieldTrial::MakeName("Histogram", "Field Trial"));
@@ -467,8 +462,8 @@ TEST_F(FieldTrialTest, UseOneTimeRandomization) {
   // _might_ actually give the same result, but we know that given
   // the particular client_id we use for unit tests they won't.
   scoped_refptr<FieldTrial> trials[] = {
-    new FieldTrial("one", 100, "default", next_year_, 1, 1),
-    new FieldTrial("two", 100, "default", next_year_, 1, 1),
+    FieldTrial::CreateInstance("one", 100, "default", next_year_, 1, 1),
+    FieldTrial::CreateInstance("two", 100, "default", next_year_, 1, 1),
   };
 
   for (size_t i = 0; i < arraysize(trials); ++i) {
@@ -487,7 +482,7 @@ TEST_F(FieldTrialTest, UseOneTimeRandomization) {
 
 TEST_F(FieldTrialTest, DisableImmediately) {
   FieldTrial* trial =
-      new FieldTrial("trial", 100, "default", next_year_, 12, 31);
+      FieldTrial::CreateInstance("trial", 100, "default", next_year_, 12, 31);
   trial->Disable();
   ASSERT_EQ("default", trial->group_name());
   ASSERT_EQ(FieldTrial::kDefaultGroupNumber, trial->group());
@@ -495,7 +490,7 @@ TEST_F(FieldTrialTest, DisableImmediately) {
 
 TEST_F(FieldTrialTest, DisableAfterInitialization) {
   FieldTrial* trial =
-      new FieldTrial("trial", 100, "default", next_year_, 12, 31);
+      FieldTrial::CreateInstance("trial", 100, "default", next_year_, 12, 31);
   trial->AppendGroup("non_default", 100);
   ASSERT_EQ("non_default", trial->group_name());
   trial->Disable();