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

base/metrics/field_trial.cc

 // Copyright (c) 2010 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/logging.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+
+using base::Time;
+using base::TimeDelta;

[jar (doing other things), 2011/01/18 19:39:44]

Given that all the code is in a "namespace base" group, do we need these using
statements?

[rtenneti, 2011/01/19 01:45:28]

Done.

 
 namespace base {
 
 // static
-const int FieldTrial::kNotParticipating = -1;
+const int FieldTrial::kNotFinalized = -1;
 
 // static
-const int FieldTrial::kAllRemainingProbability = -2;
+const int FieldTrial::kDefaultGroupNumber = 0;
 
 // static
 bool FieldTrial::enable_benchmarking_ = false;
 
 // static
 const char FieldTrialList::kPersistentStringSeparator('/');
 
 static const char kHistogramFieldTrialSeparator('_');
 
 //------------------------------------------------------------------------------
 // FieldTrial methods and members.
 
 FieldTrial::FieldTrial(const std::string& name,
-                       const Probability total_probability)
+                       const Probability total_probability,
+                       const std::string& default_group_name,
+                       const int year,
+                       const int month,
+                       const int day_of_month)
   : name_(name),
     divisor_(total_probability),
+    default_group_name_(default_group_name),
     random_(static_cast<Probability>(divisor_ * base::RandDouble())),
     accumulated_group_probability_(0),
-    next_group_number_(0),
-    group_(kNotParticipating) {
+    next_group_number_(kDefaultGroupNumber+1),
+    group_(kNotFinalized),
+    expiration_year_(year),

[jar (doing other things), 2011/01/18 19:39:44]

If these are only used in the constructor, and then discarded, could we avoid
having member slots to hold this data?

[rtenneti, 2011/01/19 01:45:28]

Done.

+    expiration_month_(month),
+    expiration_day_of_month_(day_of_month) {
+  DCHECK(!default_group_name_.empty());
   FieldTrialList::Register(this);
+
+  DCHECK_GT(expiration_year_, 1970);
+  DCHECK_GT(expiration_month_, 0);
+  DCHECK_LT(expiration_month_, 13);
+  DCHECK_GT(expiration_day_of_month_, 0);
+  DCHECK_LT(expiration_day_of_month_, 32);
+
+  base::Time::Exploded exploded;
+  exploded.year = expiration_year_;
+  exploded.month = expiration_month_;
+  exploded.day_of_week = 0;  // Should be unusued.
+  exploded.day_of_month = expiration_day_of_month_;
+  exploded.hour = 0;
+  exploded.minute = 0;
+  exploded.second = 0;
+  exploded.millisecond = 0;
+
+  base::Time expiration_time = Time::FromLocalExploded(exploded);

[jar (doing other things), 2011/01/18 19:39:44]

If we were to save anything (rather than expiration_month_, etc.), we could save
this expiration time.  I don't think we need it beyond line 70.

[rtenneti, 2011/01/19 01:45:28]

Done.

+  disable_field_trial_ = (GetBuildTime() > expiration_time) ? true : false;
 }
 
 int FieldTrial::AppendGroup(const std::string& name,
                             Probability group_probability) {
   DCHECK(group_probability <= divisor_);
-  DCHECK(group_probability >=0 ||
-         group_probability == kAllRemainingProbability);
-  if (group_probability == kAllRemainingProbability) {
-    accumulated_group_probability_ = divisor_;
-  } else {
-    if (enable_benchmarking_)
-      group_probability = 0;
-    accumulated_group_probability_ += group_probability;
-  }
+  DCHECK_GE(group_probability, 0);
+
+  if (enable_benchmarking_ || disable_field_trial_)
+    group_probability = 0;
+
+  accumulated_group_probability_ += group_probability;
+
   DCHECK(accumulated_group_probability_ <= divisor_);
-  if (group_ == kNotParticipating && 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())
       base::StringAppendF(&group_name_, "%d", group_);
     else
       group_name_ = name;
   }
   return next_group_number_++;
 }
 
+int FieldTrial::group() {
+  if (group_ == kNotFinalized) {
+    accumulated_group_probability_ = divisor_;
+    group_ = kDefaultGroupNumber;
+    group_name_ = default_group_name_;
+  }
+  return group_;
+}
+
+std::string FieldTrial::group_name() {
+  group();  // call group() to make group assignment was done.
+  return group_name_;
+}
+
 // static
 std::string FieldTrial::MakeName(const std::string& name_prefix,
                                  const std::string& trial_name) {
   std::string big_string(name_prefix);
   big_string.append(1, kHistogramFieldTrialSeparator);
   return big_string.append(FieldTrialList::FindFullName(trial_name));
 }
 
 // static
 void FieldTrial::EnableBenchmarking() {
   DCHECK_EQ(0u, FieldTrialList::GetFieldTrialCount());
   enable_benchmarking_ = true;
 }
 
+// static
+Time FieldTrial::GetBuildTime() {
+  Time integral_build_time;
+  const char* kDateTime = __DATE__ " " __TIME__;
+  bool result = Time::FromString(ASCIIToWide(kDateTime).c_str(),
+                                 &integral_build_time);
+  DCHECK(result);
+  return integral_build_time;
+}
+
 FieldTrial::~FieldTrial() {}
 
 //------------------------------------------------------------------------------
 // FieldTrialList methods and members.
 
 // static
 FieldTrialList* FieldTrialList::global_ = NULL;
 
 // static
 bool FieldTrialList::register_without_global_ = false;
@@ skipping 33 matching lines @@
     return NULL;
   AutoLock auto_lock(global_->lock_);
   return global_->PreLockedFind(name);
 }
 
 // static
 int FieldTrialList::FindValue(const std::string& name) {
   FieldTrial* field_trial = Find(name);
   if (field_trial)
     return field_trial->group();
-  return FieldTrial::kNotParticipating;
+  return FieldTrial::kNotFinalized;
 }
 
 // static
 std::string FieldTrialList::FindFullName(const std::string& name) {
   FieldTrial* field_trial = Find(name);
   if (field_trial)
     return field_trial->group_name();
   return "";
 }
 
 // static
 void FieldTrialList::StatesToString(std::string* output) {
   if (!global_)
     return;
   DCHECK(output->empty());
   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 group_name = it->second->group_name();
+    const std::string group_name = it->second->group_name_internal();
     if (group_name.empty())
       continue;  // No definitive winner in this trial.

[jar (doing other things), 2011/01/18 19:39:44]

This method is used to serialize fieldTrial settings for use in a renderer
processes.
Perhaps we should use the default_name when he have not finalized the group, and
yet avoid setting the browser side group to anything.  (i.e., we should not
finalize).  I'd be fearful that a process might race to spawn while a FieldTrial
is being constructed, and wouldn't want it to finalize it by accident, but the
default_group is supposed to be "safe" as a fallback.

The only risk is that an early spawn might hear about a different fieldTrial
setting than a later spawned process... but we already have the problem that
early spawns might not even know that there was a fieldTrial defined later!

WDYT?

[rtenneti, 2011/01/19 01:45:28]

Done.

     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
 bool FieldTrialList::StringAugmentsState(const std::string& prior_state) {

[jar (doing other things), 2011/01/18 19:39:44]

nit: Again, my fault.  this name is poor IMO.  I had to struggle to see what the
function did :-(.

Better may be:
CreateTrialsInChildProcess(const std:::string& parent_trials)

[rtenneti, 2011/01/19 01:45:28]

Done.

   DCHECK(global_);
   if (prior_state.empty() || !global_)
     return true;
 
   size_t next_item = 0;
   while (next_item < prior_state.length()) {
     size_t name_end = prior_state.find(kPersistentStringSeparator, next_item);
     if (name_end == prior_state.npos || next_item == name_end)
       return false;
     size_t group_name_end = prior_state.find(kPersistentStringSeparator,
                                              name_end + 1);
     if (group_name_end == prior_state.npos || name_end + 1 == group_name_end)
       return false;
     std::string name(prior_state, next_item, name_end - next_item);
     std::string group_name(prior_state, name_end + 1,
                            group_name_end - name_end - 1);
     next_item = group_name_end + 1;
 
     FieldTrial *field_trial(FieldTrialList::Find(name));
     if (field_trial) {
       // In single process mode, we may have already created the field trial.
-      if (field_trial->group_name() != group_name)
+      if (field_trial->group_name_internal() != group_name)
         return false;
       continue;
     }
     const int kTotalProbability = 100;
-    field_trial = new FieldTrial(name, kTotalProbability);
+    field_trial =
+        new FieldTrial(name, kTotalProbability, group_name, 2011, 6, 30);

[jar (doing other things), 2011/01/18 19:39:44]

That code won't define field trials in the renderer process starting later this
year.

We need to use some calculated constants such as:
kTWO_YEARS_FROM_NOW, 1, 1)

so that it is always in the future,

[rtenneti, 2011/01/19 01:45:28]

Done.

     field_trial->AppendGroup(group_name, kTotalProbability);
   }
   return true;
 }
 
 // static
 size_t FieldTrialList::GetFieldTrialCount() {
   if (!global_)
     return 0;
   AutoLock auto_lock(global_->lock_);
   return global_->registered_.size();
 }
 
 FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) {
   RegistrationList::iterator it = registered_.find(name);
   if (registered_.end() == it)
     return NULL;
   return it->second;
 }
 
 }  // namespace base