Supporting command line argument to force field trials

base/metrics/field_trial.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/metrics/field_trial.h"
 
 #include "base/build_time.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sha1.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 namespace base {
 
 static const char kHistogramFieldTrialSeparator('_');
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
 const uint32 FieldTrial::kReservedHashValue = 0;
 bool FieldTrial::enable_benchmarking_ = false;
 
 const char FieldTrialList::kPersistentStringSeparator('/');
 int FieldTrialList::kExpirationYearInFuture = 0;
 
 //------------------------------------------------------------------------------
 // FieldTrial methods and members.
 
+FieldTrial* FieldTrial::CreateInstance(
+    const std::string& name, Probability total_probability,
+    const std::string& default_group_name, const int year, const int month,
+    const int day_of_month) {
+  // First check if the field trial has already been created in some other ways.

[Alexei Svitkine (slow), 2012/03/23 18:41:55]

Nit: "some other ways" -> "some other way"

[MAD, 2012/03/23 20:20:12]

Done.

+  FieldTrial* existing_trial = FieldTrialList::Find(name);
+  if (existing_trial) {
+    return existing_trial;
+  } else {

[Alexei Svitkine (slow), 2012/03/23 18:41:55]

Nit: Since you're early returning, don't need an else block.

[MAD, 2012/03/23 20:20:12]

Done.

+    FieldTrial* new_trial = new FieldTrial(
+        name, total_probability, default_group_name, year, month, day_of_month);
+    FieldTrialList::Register(new_trial);
+    return new_trial;
+  }
+}
+
 FieldTrial::FieldTrial(const std::string& name,
                        const Probability total_probability,
                        const std::string& default_group_name,
                        const int year,
                        const int month,
                        const int day_of_month)
   : name_(name),
     name_hash_(HashName(name)),
     divisor_(total_probability),
     default_group_name_(default_group_name),
     random_(static_cast<Probability>(divisor_ * RandDouble())),
     accumulated_group_probability_(0),
     next_group_number_(kDefaultGroupNumber + 1),
     group_(kNotFinalized),
     group_name_hash_(kReservedHashValue),
-    enable_field_trial_(true) {
+    enable_field_trial_(true),
+    forced_(false) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!name_.empty());
   DCHECK(!default_group_name_.empty());
-  FieldTrialList::Register(this);
 
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
   DCHECK_LT(day_of_month, 32);
 
   Time::Exploded exploded;
   exploded.year = year;
   exploded.month = month;
   exploded.day_of_week = 0;  // Should be unused.
   exploded.day_of_month = day_of_month;
   exploded.hour = 0;
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
 
   Time expiration_time = Time::FromLocalExploded(exploded);
   if (GetBuildTime() > expiration_time)
     Disable();
 }
 
 void FieldTrial::UseOneTimeRandomization() {
+  if (forced_)
+    return;
   DCHECK_EQ(group_, kNotFinalized);
   DCHECK_EQ(kDefaultGroupNumber + 1, next_group_number_);
   if (!FieldTrialList::IsOneTimeRandomizationEnabled()) {
     NOTREACHED();
     Disable();
     return;
   }
 
   random_ = static_cast<Probability>(
       divisor_ * HashClientId(FieldTrialList::client_id(), name_));
 }
 
 void FieldTrial::Disable() {
   enable_field_trial_ = false;
 
   // In case we are disabled after initialization, we need to switch
   // the trial to the default group.
   if (group_ != kNotFinalized) {
     group_ = kDefaultGroupNumber;
     group_name_ = default_group_name_;
     group_name_hash_ = HashName(group_name_);
   }
 }
 
 int FieldTrial::AppendGroup(const std::string& name,
                             Probability group_probability) {
+  if (forced_) {
+    if (name == group_name_)
+      return group_;
+    else
+      return group_ + 1;
+  }
+
   DCHECK_LE(group_probability, divisor_);
   DCHECK_GE(group_probability, 0);
 
   if (enable_benchmarking_ || !enable_field_trial_)
     group_probability = 0;
 
   accumulated_group_probability_ += group_probability;
 
   DCHECK_LE(accumulated_group_probability_, divisor_);
-  if (group_ == kNotFinalized && accumulated_group_probability_ > random_) {
+  if (group_ == kNotFinalized && (accumulated_group_probability_ > random_)) {
     // This is the group that crossed the random line, so we do the assignment.
     group_ = next_group_number_;
     if (name.empty())
       StringAppendF(&group_name_, "%d", group_);
     else
       group_name_ = name;
     group_name_hash_ = HashName(group_name_);
     FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_);
   }
   return next_group_number_++;
@@ skipping 107 matching lines @@
   while (!registered_.empty()) {
     RegistrationList::iterator it = registered_.begin();
     it->second->Release();
     registered_.erase(it->first);
   }
   DCHECK_EQ(this, global_);
   global_ = NULL;
 }
 
 // static
-void FieldTrialList::Register(FieldTrial* trial) {
-  if (!global_) {
-    used_without_global_ = true;
-    return;
-  }
-  AutoLock auto_lock(global_->lock_);
-  DCHECK(!global_->PreLockedFind(trial->name()));
-  trial->AddRef();
-  global_->registered_[trial->name()] = trial;
-}
-
-// static
 FieldTrial* FieldTrialList::Find(const std::string& name) {
   if (!global_)
     return NULL;
   AutoLock auto_lock(global_->lock_);
   return global_->PreLockedFind(name);
 }
 
 // static
 int FieldTrialList::FindValue(const std::string& name) {
   FieldTrial* field_trial = Find(name);
@@ skipping 17 matching lines @@
 
 // static
 void FieldTrialList::StatesToString(std::string* output) {
   DCHECK(output->empty());
   if (!global_)
     return;
   AutoLock auto_lock(global_->lock_);
 
   for (RegistrationList::iterator it = global_->registered_.begin();
        it != global_->registered_.end(); ++it) {
-    const std::string name = it->first;
+    const std::string& name = it->first;
     std::string group_name = it->second->group_name_internal();
     if (group_name.empty())
       continue;  // Should not include uninitialized trials.
     DCHECK_EQ(name.find(kPersistentStringSeparator), std::string::npos);
     DCHECK_EQ(group_name.find(kPersistentStringSeparator), std::string::npos);
     output->append(name);
     output->append(1, kPersistentStringSeparator);
     output->append(group_name);
     output->append(1, kPersistentStringSeparator);
   }
 }
 
 // static
 void FieldTrialList::GetFieldTrialNameGroupIds(
     std::vector<FieldTrial::NameGroupId>* name_group_ids) {
   DCHECK(name_group_ids->empty());
   if (!global_)
     return;
   AutoLock auto_lock(global_->lock_);
 
   for (RegistrationList::iterator it = global_->registered_.begin();
        it != global_->registered_.end(); ++it) {
     FieldTrial::NameGroupId name_group_id;
     if (it->second->GetNameGroupId(&name_group_id))
       name_group_ids->push_back(name_group_id);
   }
 }
 
 // static
-bool FieldTrialList::CreateTrialsInChildProcess(
-    const std::string& parent_trials) {
+bool FieldTrialList::CreateTrialsFromString(const std::string& trials_string) {
   DCHECK(global_);
-  if (parent_trials.empty() || !global_)
+  if (trials_string.empty() || !global_)
     return true;
 
   size_t next_item = 0;
-  while (next_item < parent_trials.length()) {
-    size_t name_end = parent_trials.find(kPersistentStringSeparator, next_item);
-    if (name_end == parent_trials.npos || next_item == name_end)
+  while (next_item < trials_string.length()) {
+    size_t name_end = trials_string.find(kPersistentStringSeparator, next_item);
+    if (name_end == trials_string.npos || next_item == name_end)
       return false;
-    size_t group_name_end = parent_trials.find(kPersistentStringSeparator,
+    size_t group_name_end = trials_string.find(kPersistentStringSeparator,
                                                name_end + 1);
-    if (group_name_end == parent_trials.npos || name_end + 1 == group_name_end)
+    if (group_name_end == trials_string.npos || name_end + 1 == group_name_end)
       return false;
-    std::string name(parent_trials, next_item, name_end - next_item);
-    std::string group_name(parent_trials, name_end + 1,
+    std::string name(trials_string, next_item, name_end - next_item);
+    std::string group_name(trials_string, name_end + 1,
                            group_name_end - name_end - 1);
     next_item = group_name_end + 1;
 
     if (!CreateFieldTrial(name, group_name))
       return false;
   }
   return true;
 }
 
 // static
 FieldTrial* FieldTrialList::CreateFieldTrial(
     const std::string& name,
     const std::string& group_name) {
   DCHECK(global_);
   DCHECK_GE(name.size(), 0u);
   DCHECK_GE(group_name.size(), 0u);
   if (name.empty() || group_name.empty() || !global_)
     return NULL;
 
-  FieldTrial *field_trial(FieldTrialList::Find(name));
+  FieldTrial* field_trial(FieldTrialList::Find(name));
   if (field_trial) {
-    // In single process mode, we may have already created the field trial.
+    // In single process mode, or when we force them from the command line,
+    // we may have already created the field trial.
     if (field_trial->group_name_internal() != group_name)
       return NULL;
     return field_trial;
   }
   const int kTotalProbability = 100;
   field_trial = new FieldTrial(name, kTotalProbability, group_name,
                                kExpirationYearInFuture, 1, 1);
   field_trial->AppendGroup(group_name, kTotalProbability);
+  field_trial->forced_ = true;
+  FieldTrialList::Register(field_trial);
   return field_trial;
 }
 
 // static
 void FieldTrialList::AddObserver(Observer* observer) {
   if (!global_)
     return;
   DCHECK(global_);
   global_->observer_list_.AddObserver(observer);
 }
@@ skipping 45 matching lines @@
   return global_->client_id_;
 }
 
 FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) {
   RegistrationList::iterator it = registered_.find(name);
   if (registered_.end() == it)
     return NULL;
   return it->second;
 }
 
+// static
+void FieldTrialList::Register(FieldTrial* trial) {
+  if (!global_) {
+    used_without_global_ = true;
+    return;
+  }
+  AutoLock auto_lock(global_->lock_);
+  DCHECK(!global_->PreLockedFind(trial->name()));
+  trial->AddRef();
+  global_->registered_[trial->name()] = trial;
+}
+
 }  // namespace base