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;
 
 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),
+    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);
+  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_;
+}
+
 // 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() {
+  static Time integral_build_time;

[jar (doing other things), 2011/01/15 20:52:47]

Don't bother caching this.  There may be a race on multiple threads to
initialize this static. The perf cost of not caching is insignificant, so it is
hard to justify violation of style guide mandate that only POD be contained in
statics.  You could probably get away with the race, as the instance is mostly a
plain structure with no virtual methods, so premature (uninitialized) use
wouldn't be very tragic (I don't think it could crash, and could only give a
wrong answer to a racing thread), but it seems unnecessary to think about.

+  if (integral_build_time.is_null()) {
+    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 "";
 }
 
@@ skipping 39 matching lines @@
     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)
         return false;
       continue;
     }
     const int kTotalProbability = 100;
-    field_trial = new FieldTrial(name, kTotalProbability);
-    field_trial->AppendGroup(group_name, kTotalProbability);
+    field_trial =
+        new FieldTrial(name, kTotalProbability, group_name, 2099, 12, 31);

[jar (doing other things), 2011/01/15 20:52:47]

This constant is a little dangerous on two accounts. First, the code won't "work
as planned" after 2099, but even more problematic, is that the data conversion
may wrap on some platforms!  For instance, this is beyond 2038, when the "unix
millenium bug" is scheduled, so it probably wraps on linux."

I'd suggest passing in a legal date (yesterday? last year? 2010? using manifest
constants), and allowing the code to default to using the default group name,
which is exactly what you wanted anyway ;-).

+    field_trial->group();
   }
   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