Make some field trials unforceable via command-line in the official build.

BUG=342585
TEST=Remove the OFFICIAL_BUILD ifdefs and:
1) Confirm that running with --force-fieldtrials with an unforceable experiment and a forceable one only forces the forceable one.
2) Confirm that the value which couldn't be forced in the browser also makes it unforced in the renderer.

Put the OFFICIAL_BUILD ifdefs back and confirm that unforceable experiments are still forceable in non-official builds.

Review URL: https://codereview.chromium.org/153913009

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

3 files changed, 77 insertions, 16 deletions

diff --git a/base/metrics/field_trial.cc b/base/metrics/field_trial.cc
index f718ab0..54b9521 100644
--- a/base/metrics/field_trial.cc
+++ b/base/metrics/field_trial.cc
@@ -399,8 +399,10 @@ void FieldTrialList::GetActiveFieldTrialGroups(
 }
 
 // static
-bool FieldTrialList::CreateTrialsFromString(const std::string& trials_string,
-                                            FieldTrialActivationMode mode) {
+bool FieldTrialList::CreateTrialsFromString(
+    const std::string& trials_string,
+    FieldTrialActivationMode mode,
+    const std::set<std::string>& ignored_trial_names) {
   DCHECK(global_);
   if (trials_string.empty() || !global_)
     return true;
@@ -419,6 +421,9 @@ bool FieldTrialList::CreateTrialsFromString(const std::string& trials_string,
                            group_name_end - name_end - 1);
     next_item = group_name_end + 1;
 
+    if (ignored_trial_names.find(name) != ignored_trial_names.end())
+      continue;
+
     FieldTrial* trial = CreateFieldTrial(name, group_name);
     if (!trial)
       return false;
diff --git a/base/metrics/field_trial.h b/base/metrics/field_trial.h
index 5a4375e..51177eb 100644
--- a/base/metrics/field_trial.h
+++ b/base/metrics/field_trial.h
@@ -55,6 +55,7 @@
 #define BASE_METRICS_FIELD_TRIAL_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -412,9 +413,12 @@ class BASE_EXPORT FieldTrialList {
   // browser process into this non-browser process, but could also be invoked
   // through a command line argument to the browser process. The created field
   // trials are marked as "used" for the purposes of active trial reporting if
-  // |mode| is ACTIVATE_TRIALS.
-  static bool CreateTrialsFromString(const std::string& prior_trials,
-                                     FieldTrialActivationMode mode);
+  // |mode| is ACTIVATE_TRIALS. Trial names in |ignored_trial_names| are ignored
+  // when parsing |prior_trials|.
+  static bool CreateTrialsFromString(
+      const std::string& prior_trials,
+      FieldTrialActivationMode mode,
+      const std::set<std::string>& ignored_trial_names);
 
   // Create a FieldTrial with the given |name| and using 100% probability for
   // the FieldTrial, force FieldTrial to have the same group string as
diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc
index a77633e..866095c 100644
--- a/base/metrics/field_trial_unittest.cc
+++ b/base/metrics/field_trial_unittest.cc
@@ -385,7 +385,8 @@ TEST_F(FieldTrialTest, Restore) {
   ASSERT_FALSE(FieldTrialList::TrialExists("xxx"));
 
   FieldTrialList::CreateTrialsFromString("Some_name/Winner/xxx/yyyy/",
-                                         FieldTrialList::DONT_ACTIVATE_TRIALS);
+                                         FieldTrialList::DONT_ACTIVATE_TRIALS,
+                                         std::set<std::string>());
 
   FieldTrial* trial = FieldTrialList::Find("Some_name");
   ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
@@ -400,13 +401,17 @@ TEST_F(FieldTrialTest, Restore) {
 
 TEST_F(FieldTrialTest, BogusRestore) {
   EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
-      "MissingSlash", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "MissingSlash", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
   EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
-      "MissingGroupName/", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "MissingGroupName/", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
   EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
-      "MissingFinalSlash/gname", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "MissingFinalSlash/gname", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
   EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
-      "noname, only group/", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "noname, only group/", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
 }
 
 TEST_F(FieldTrialTest, DuplicateRestore) {
@@ -420,18 +425,21 @@ TEST_F(FieldTrialTest, DuplicateRestore) {
 
   // It is OK if we redundantly specify a winner.
   EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(
-      save_string, FieldTrialList::DONT_ACTIVATE_TRIALS));
+      save_string, FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
 
   // But it is an error to try to change to a different winner.
   EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
-      "Some name/Loser/", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "Some name/Loser/", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
 }
 
 TEST_F(FieldTrialTest, CreateTrialsFromStringActive) {
   ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
   ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
   ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
-      "Abc/def/Xyz/zyx/", FieldTrialList::ACTIVATE_TRIALS));
+      "Abc/def/Xyz/zyx/", FieldTrialList::ACTIVATE_TRIALS,
+      std::set<std::string>()));
 
   FieldTrial::ActiveGroups active_groups;
   FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
@@ -446,7 +454,8 @@ TEST_F(FieldTrialTest, CreateTrialsFromStringNotActive) {
   ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
   ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
   ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
-      "Abc/def/Xyz/zyx/", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "Abc/def/Xyz/zyx/", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
 
   FieldTrial::ActiveGroups active_groups;
   FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
@@ -469,7 +478,7 @@ TEST_F(FieldTrialTest, CreateTrialsFromStringActiveObserver) {
 
   TestFieldTrialObserver observer;
   ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
-      "Abc/def/", FieldTrialList::ACTIVATE_TRIALS));
+      "Abc/def/", FieldTrialList::ACTIVATE_TRIALS, std::set<std::string>()));
 
   RunLoop().RunUntilIdle();
   EXPECT_EQ("Abc", observer.trial_name());
@@ -481,7 +490,8 @@ TEST_F(FieldTrialTest, CreateTrialsFromStringNotActiveObserver) {
 
   TestFieldTrialObserver observer;
   ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
-      "Abc/def/", FieldTrialList::DONT_ACTIVATE_TRIALS));
+      "Abc/def/", FieldTrialList::DONT_ACTIVATE_TRIALS,
+      std::set<std::string>()));
   RunLoop().RunUntilIdle();
   // Observer shouldn't be notified.
   EXPECT_TRUE(observer.trial_name().empty());
@@ -494,6 +504,48 @@ TEST_F(FieldTrialTest, CreateTrialsFromStringNotActiveObserver) {
   EXPECT_EQ("def", observer.group_name());
 }
 
+TEST_F(FieldTrialTest, CreateTrialsFromStringWithIgnoredFieldTrials) {
+  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
+  ASSERT_FALSE(FieldTrialList::TrialExists("Foo"));
+  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
+  ASSERT_FALSE(FieldTrialList::TrialExists("Bar"));
+  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
+
+  std::set<std::string> ignored_trial_names;
+  ignored_trial_names.insert("Unaccepted1");
+  ignored_trial_names.insert("Unaccepted2");
+  ignored_trial_names.insert("Unaccepted3");
+
+  FieldTrialList::CreateTrialsFromString(
+      "Unaccepted1/Unaccepted1_name/"
+      "Foo/Foo_name/"
+      "Unaccepted2/Unaccepted2_name/"
+      "Bar/Bar_name/"
+      "Unaccepted3/Unaccepted3_name/",
+      FieldTrialList::DONT_ACTIVATE_TRIALS,
+      ignored_trial_names);
+
+  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
+  EXPECT_TRUE(FieldTrialList::TrialExists("Foo"));
+  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
+  EXPECT_TRUE(FieldTrialList::TrialExists("Bar"));
+  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
+
+  FieldTrial::ActiveGroups active_groups;
+  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
+  EXPECT_TRUE(active_groups.empty());
+
+  FieldTrial* trial = FieldTrialList::Find("Foo");
+  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
+  EXPECT_EQ("Foo", trial->trial_name());
+  EXPECT_EQ("Foo_name", trial->group_name());
+
+  trial = FieldTrialList::Find("Bar");
+  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
+  EXPECT_EQ("Bar", trial->trial_name());
+  EXPECT_EQ("Bar_name", trial->group_name());
+}
+
 TEST_F(FieldTrialTest, CreateFieldTrial) {
   ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));