disable field trials if the build is 30 days or older

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;
 
 // static
 const int FieldTrial::kAllRemainingProbability = -2;
 
 // 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)
   : name_(name),
     divisor_(total_probability),
     random_(static_cast<Probability>(divisor_ * base::RandDouble())),
     accumulated_group_probability_(0),
     next_group_number_(0),
-    group_(kNotParticipating) {
+    group_(kNotParticipating),
+    all_remaining_probability_set_(false),
+    usage_timeout_(base::TimeDelta::FromDays(30)) {
   FieldTrialList::Register(this);
+  disable_field_trial_ = ShouldFieldTrialBeDisabled(usage_timeout_);
 }
 
 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_;
+    all_remaining_probability_set_ = true;
   } else {
-    if (enable_benchmarking_)
+    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_) {
     // 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_++;
 }
 
+void FieldTrial::SetUsageTimeout(const base::TimeDelta& usage_timeout) {
+  usage_timeout_ = usage_timeout;
+  disable_field_trial_ = ShouldFieldTrialBeDisabled(usage_timeout);
+}
+
 // 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
+bool FieldTrial::ShouldFieldTrialBeDisabled(
+    const base::TimeDelta& usage_timeout) {
+  if (base::Time::NowFromSystemTime() - GetBuildTime() >= usage_timeout)
+    return true;
+  return false;
+}
+
+// static
+Time FieldTrial::GetBuildTime() {
+  static Time integral_build_time;
+  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 31 matching lines @@
 int FieldTrialList::FindValue(const std::string& name) {
   FieldTrial* field_trial = Find(name);
   if (field_trial)
     return field_trial->group();
   return FieldTrial::kNotParticipating;
 }
 
 // static
 std::string FieldTrialList::FindFullName(const std::string& name) {
   FieldTrial* field_trial = Find(name);
-  if (field_trial)
+  if (field_trial) {
+    DCHECK(field_trial->all_remaining_probability_set());
     return field_trial->group_name();
+  }
   return "";
 }
 
 // static
 FieldTrial* FieldTrialList::Find(const std::string& name) {
   if (!global_)
     return NULL;
   AutoLock auto_lock(global_->lock_);
   return global_->PreLockedFind(name);
 }
@@ skipping 48 matching lines @@
 
     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->AppendGroup(group_name, FieldTrial::kAllRemainingProbability);
   }
   return true;
 }
 
 // static
 size_t FieldTrialList::GetFieldTrialCount() {
   if (!global_)
     return 0;
   AutoLock auto_lock(global_->lock_);
   return global_->registered_.size();
 }
 
 }  // namespace base