blob: d602ce94ecafa0d07166a41e839a2777f0fe2d11 [file] [log] [blame]
// Copyright 2015 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/feature_list.h"
#include <stddef.h>
#include <utility>
#include <vector>
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/field_trial.h"
#include "base/pickle.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "build/build_config.h"
namespace base {
namespace {
// Pointer to the FeatureList instance singleton that was set via
// FeatureList::SetInstance(). Does not use base/memory/singleton.h in order to
// have more control over initialization timing. Leaky.
FeatureList* g_feature_list_instance = nullptr;
// Tracks whether the FeatureList instance was initialized via an accessor.
bool g_initialized_from_accessor = false;
// An allocator entry for a feature in shared memory. The FeatureEntry is
// followed by a base::Pickle object that contains the feature and trial name.
struct FeatureEntry {
// SHA1(FeatureEntry): Increment this if structure changes!
static constexpr uint32_t kPersistentTypeId = 0x06567CA6 + 1;
// Expected size for 32/64-bit check.
static constexpr size_t kExpectedInstanceSize = 8;
// Specifies whether a feature override enables or disables the feature. Same
// values as the OverrideState enum in feature_list.h
uint32_t override_state;
// Size of the pickled structure, NOT the total size of this entry.
uint32_t pickle_size;
// Reads the feature and trial name from the pickle. Calling this is only
// valid on an initialized entry that's in shared memory.
bool GetFeatureAndTrialName(StringPiece* feature_name,
StringPiece* trial_name) const {
const char* src =
reinterpret_cast<const char*>(this) + sizeof(FeatureEntry);
Pickle pickle(src, pickle_size);
PickleIterator pickle_iter(pickle);
if (!pickle_iter.ReadStringPiece(feature_name))
return false;
// Return true because we are not guaranteed to have a trial name anyways.
auto sink = pickle_iter.ReadStringPiece(trial_name);
return true;
// Some characters are not allowed to appear in feature names or the associated
// field trial names, as they are used as special characters for command-line
// serialization. This function checks that the strings are ASCII (since they
// are used in command-line API functions that require ASCII) and whether there
// are any reserved characters present, returning true if the string is valid.
// Only called in DCHECKs.
bool IsValidFeatureOrFieldTrialName(const std::string& name) {
return IsStringASCII(name) && name.find_first_of(",<*") == std::string::npos;
} // namespace
const Feature kDCheckIsFatalFeature{"DcheckIsFatal",
#endif // defined(DCHECK_IS_CONFIGURABLE)
FeatureList::FeatureList() = default;
FeatureList::~FeatureList() = default;
void FeatureList::InitializeFromCommandLine(
const std::string& enable_features,
const std::string& disable_features) {
// Process disabled features first, so that disabled ones take precedence over
// enabled ones (since RegisterOverride() uses insert()).
RegisterOverridesFromCommandLine(disable_features, OVERRIDE_DISABLE_FEATURE);
RegisterOverridesFromCommandLine(enable_features, OVERRIDE_ENABLE_FEATURE);
initialized_from_command_line_ = true;
void FeatureList::InitializeFromSharedMemory(
PersistentMemoryAllocator* allocator) {
PersistentMemoryAllocator::Iterator iter(allocator);
const FeatureEntry* entry;
while ((entry = iter.GetNextOfObject<FeatureEntry>()) != nullptr) {
OverrideState override_state =
StringPiece feature_name;
StringPiece trial_name;
if (!entry->GetFeatureAndTrialName(&feature_name, &trial_name))
FieldTrial* trial = FieldTrialList::Find(trial_name.as_string());
RegisterOverride(feature_name, override_state, trial);
bool FeatureList::IsFeatureOverriddenFromCommandLine(
const std::string& feature_name,
OverrideState state) const {
auto it = overrides_.find(feature_name);
return it != overrides_.end() && it->second.overridden_state == state &&
void FeatureList::AssociateReportingFieldTrial(
const std::string& feature_name,
OverrideState for_overridden_state,
FieldTrial* field_trial) {
IsFeatureOverriddenFromCommandLine(feature_name, for_overridden_state));
// Only one associated field trial is supported per feature. This is generally
// enforced server-side.
OverrideEntry* entry = &overrides_.find(feature_name)->second;
if (entry->field_trial) {
NOTREACHED() << "Feature " << feature_name
<< " already has trial: " << entry->field_trial->trial_name()
<< ", associating trial: " << field_trial->trial_name();
entry->field_trial = field_trial;
void FeatureList::RegisterFieldTrialOverride(const std::string& feature_name,
OverrideState override_state,
FieldTrial* field_trial) {
DCHECK(!Contains(overrides_, feature_name) ||
<< "Feature " << feature_name
<< " has conflicting field trial overrides: "
<< overrides_.find(feature_name)->second.field_trial->trial_name()
<< " / " << field_trial->trial_name();
RegisterOverride(feature_name, override_state, field_trial);
void FeatureList::AddFeaturesToAllocator(PersistentMemoryAllocator* allocator) {
for (const auto& override : overrides_) {
Pickle pickle;
if (override.second.field_trial)
size_t total_size = sizeof(FeatureEntry) + pickle.size();
FeatureEntry* entry = allocator->New<FeatureEntry>(total_size);
if (!entry)
entry->override_state = override.second.overridden_state;
entry->pickle_size = pickle.size();
char* dst = reinterpret_cast<char*>(entry) + sizeof(FeatureEntry);
memcpy(dst,, pickle.size());
void FeatureList::GetFeatureOverrides(std::string* enable_overrides,
std::string* disable_overrides) {
GetFeatureOverridesImpl(enable_overrides, disable_overrides, false);
void FeatureList::GetCommandLineFeatureOverrides(
std::string* enable_overrides,
std::string* disable_overrides) {
GetFeatureOverridesImpl(enable_overrides, disable_overrides, true);
// static
bool FeatureList::IsEnabled(const Feature& feature) {
if (!g_feature_list_instance) {
g_initialized_from_accessor = true;
return feature.default_state == FEATURE_ENABLED_BY_DEFAULT;
return g_feature_list_instance->IsFeatureEnabled(feature);
// static
FieldTrial* FeatureList::GetFieldTrial(const Feature& feature) {
if (!g_feature_list_instance) {
g_initialized_from_accessor = true;
return nullptr;
return g_feature_list_instance->GetAssociatedFieldTrial(feature);
// static
std::vector<StringPiece> FeatureList::SplitFeatureListString(
StringPiece input) {
return SplitStringPiece(input, ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
// static
bool FeatureList::InitializeInstance(const std::string& enable_features,
const std::string& disable_features) {
// We want to initialize a new instance here to support command-line features
// in testing better. For example, we initialize a dummy instance in
// base/test/, and override it in content/browser/
// On the other hand, we want to avoid re-initialization from command line.
// For example, we initialize an instance in chrome/browser/
// and do not override it in content/browser/
// If the singleton was previously initialized from within an accessor, we
// want to prevent callers from reinitializing the singleton and masking the
// accessor call(s) which likely returned incorrect information.
bool instance_existed_before = false;
if (g_feature_list_instance) {
if (g_feature_list_instance->initialized_from_command_line_)
return false;
delete g_feature_list_instance;
g_feature_list_instance = nullptr;
instance_existed_before = true;
std::unique_ptr<FeatureList> feature_list(new FeatureList);
feature_list->InitializeFromCommandLine(enable_features, disable_features);
return !instance_existed_before;
// static
FeatureList* FeatureList::GetInstance() {
return g_feature_list_instance;
// static
void FeatureList::SetInstance(std::unique_ptr<FeatureList> instance) {
// Note: Intentional leak of global singleton.
g_feature_list_instance = instance.release();
// Update the behaviour of LOG_DCHECK to match the Feature configuration.
// DCHECK is also forced to be FATAL if we are running a death-test.
// TODO(asvitkine): If we find other use-cases that need integrating here
// then define a proper API/hook for the purpose.
if (FeatureList::IsEnabled(kDCheckIsFatalFeature) ||
"gtest_internal_run_death_test")) {
logging::LOG_DCHECK = logging::LOG_FATAL;
} else {
logging::LOG_DCHECK = logging::LOG_INFO;
#endif // defined(DCHECK_IS_CONFIGURABLE)
// static
std::unique_ptr<FeatureList> FeatureList::ClearInstanceForTesting() {
FeatureList* old_instance = g_feature_list_instance;
g_feature_list_instance = nullptr;
g_initialized_from_accessor = false;
return WrapUnique(old_instance);
// static
void FeatureList::RestoreInstanceForTesting(
std::unique_ptr<FeatureList> instance) {
// Note: Intentional leak of global singleton.
g_feature_list_instance = instance.release();
void FeatureList::FinalizeInitialization() {
// Store the field trial list pointer for DCHECKing.
field_trial_list_ = FieldTrialList::GetInstance();
initialized_ = true;
bool FeatureList::IsFeatureEnabled(const Feature& feature) {
DCHECK(IsValidFeatureOrFieldTrialName( <<;
DCHECK(CheckFeatureIdentity(feature)) <<;
auto it = overrides_.find(;
if (it != overrides_.end()) {
const OverrideEntry& entry = it->second;
// Activate the corresponding field trial, if necessary.
if (entry.field_trial)
// TODO(asvitkine) Expand this section as more support is added.
// If marked as OVERRIDE_USE_DEFAULT, simply return the default state below.
if (entry.overridden_state != OVERRIDE_USE_DEFAULT)
return entry.overridden_state == OVERRIDE_ENABLE_FEATURE;
// Otherwise, return the default state.
return feature.default_state == FEATURE_ENABLED_BY_DEFAULT;
FieldTrial* FeatureList::GetAssociatedFieldTrial(const Feature& feature) {
DCHECK(IsValidFeatureOrFieldTrialName( <<;
DCHECK(CheckFeatureIdentity(feature)) <<;
auto it = overrides_.find(;
if (it != overrides_.end()) {
const OverrideEntry& entry = it->second;
return entry.field_trial;
return nullptr;
void FeatureList::RegisterOverridesFromCommandLine(
const std::string& feature_list,
OverrideState overridden_state) {
for (const auto& value : SplitFeatureListString(feature_list)) {
StringPiece feature_name = value;
FieldTrial* trial = nullptr;
// The entry may be of the form FeatureName<FieldTrialName - in which case,
// this splits off the field trial name and associates it with the override.
std::string::size_type pos = feature_name.find('<');
if (pos != std::string::npos) {
feature_name.set(, pos);
trial = FieldTrialList::Find(value.substr(pos + 1).as_string());
#if !defined(OS_NACL)
// If the below DCHECK fires, it means a non-existent trial name was
// specified via the "Feature<Trial" command-line syntax.
DCHECK(trial) << "trial=" << value.substr(pos + 1);
#endif // !defined(OS_NACL)
RegisterOverride(feature_name, overridden_state, trial);
void FeatureList::RegisterOverride(StringPiece feature_name,
OverrideState overridden_state,
FieldTrial* field_trial) {
if (field_trial) {
<< field_trial->trial_name();
if (feature_name.starts_with("*")) {
feature_name = feature_name.substr(1);
overridden_state = OVERRIDE_USE_DEFAULT;
// Note: The semantics of insert() is that it does not overwrite the entry if
// one already exists for the key. Thus, only the first override for a given
// feature name takes effect.
feature_name.as_string(), OverrideEntry(overridden_state, field_trial)));
void FeatureList::GetFeatureOverridesImpl(std::string* enable_overrides,
std::string* disable_overrides,
bool command_line_only) {
// Check that the FieldTrialList this is associated with, if any, is the
// active one. If not, it likely indicates that this FeatureList has override
// entries from a freed FieldTrial, which may be caused by an incorrect test
// set up.
if (field_trial_list_)
DCHECK_EQ(field_trial_list_, FieldTrialList::GetInstance());
// Note: Since |overrides_| is a std::map, iteration will be in alphabetical
// order. This is not guaranteed to users of this function, but is useful for
// tests to assume the order.
for (const auto& entry : overrides_) {
if (command_line_only &&
(entry.second.field_trial != nullptr ||
entry.second.overridden_state == OVERRIDE_USE_DEFAULT)) {
std::string* target_list = nullptr;
switch (entry.second.overridden_state) {
target_list = enable_overrides;
target_list = disable_overrides;
if (!target_list->empty())
if (entry.second.overridden_state == OVERRIDE_USE_DEFAULT)
if (entry.second.field_trial) {
bool FeatureList::CheckFeatureIdentity(const Feature& feature) {
AutoLock auto_lock(feature_identity_tracker_lock_);
auto it = feature_identity_tracker_.find(;
if (it == feature_identity_tracker_.end()) {
// If it's not tracked yet, register it.
feature_identity_tracker_[] = &feature;
return true;
// Compare address of |feature| to the existing tracked entry.
return it->second == &feature;
FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
FieldTrial* field_trial)
: overridden_state(overridden_state),
overridden_by_field_trial(field_trial != nullptr) {}
} // namespace base