// Copyright (c) 2006-2009 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/field_trial.h"
#include "base/logging.h"
#include "base/rand_util.h"
#include "base/string_util.h"
using base::TimeTicks;
// static
const int FieldTrial::kNotParticipating = -1;
// static
const int FieldTrial::kAllRemainingProbability = -2;
// static
const char FieldTrialList::kPersistentStringSeparator('/');
//------------------------------------------------------------------------------
// 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) {
FieldTrialList::Register(this);
}
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
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())
StringAppendF(&group_name_, "_%d", group_);
else
group_name_ = name;
}
return next_group_number_++;
}
// static
std::string FieldTrial::MakeName(const std::string& name_prefix,
const std::string& trial_name) {
std::string big_string(name_prefix);
return big_string.append(FieldTrialList::FindFullName(trial_name));
}
//------------------------------------------------------------------------------
// FieldTrialList methods and members.
// static
FieldTrialList* FieldTrialList::global_ = NULL;
// static
bool FieldTrialList::register_without_global_ = false;
FieldTrialList::FieldTrialList() : application_start_time_(TimeTicks::Now()) {
DCHECK(!global_);
DCHECK(!register_without_global_);
global_ = this;
}
FieldTrialList::~FieldTrialList() {
AutoLock auto_lock(lock_);
while (!registered_.empty()) {
RegistrationList::iterator it = registered_.begin();
it->second->Release();
registered_.erase(it->first);
}
DCHECK(this == global_);
global_ = NULL;
}
// static
void FieldTrialList::Register(FieldTrial* trial) {
if (!global_) {
register_without_global_ = true;
return;
}
AutoLock auto_lock(global_->lock_);
DCHECK(!global_->PreLockedFind(trial->name()));
trial->AddRef();
global_->registered_[trial->name()] = trial;
}
// static
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)
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);
}
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::StatesToString(std::string* output) {
if (!global_)
return;
DCHECK(output->empty());
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();
if (group_name.empty())
continue; // No definitive winner in this trial.
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) {
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)
return false;
continue;
}
const int kTotalProbability = 100;
field_trial = new FieldTrial(name, kTotalProbability);
field_trial->AppendGroup(group_name, kTotalProbability);
}
return true;
}