blob: 6ce8321b8a32b46d89fcded1f1a13410e365758c [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 <stddef.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/command_line.h"
#include "base/macros.h"
namespace base {
class FeatureList;
class ListValue;
namespace flags_ui {
// Internal functionality exposed for tests.
namespace internal {
// The trial group selected when feature variation parameters are registered via
// FlagsState::RegisterFeatureVariationParameters().
extern const char kTrialGroupAboutFlags[];
} // namespace internal
struct FeatureEntry;
class FlagsStorage;
struct SwitchEntry;
// Enumeration of OSs.
enum {
kOsMac = 1 << 0,
kOsWin = 1 << 1,
kOsLinux = 1 << 2,
kOsCrOS = 1 << 3,
kOsAndroid = 1 << 4,
kOsCrOSOwnerOnly = 1 << 5,
kOsIos = 1 << 6,
// A flag controlling the behavior of the |ConvertFlagsToSwitches| function -
// whether it should add the sentinel switches around flags.
enum SentinelsMode { kNoSentinels, kAddSentinels };
// Differentiate between generic flags available on a per session base and flags
// that influence the whole machine and can be said by the admin only. This flag
// is relevant for ChromeOS for now only and dictates whether entries marked
// with the |kOsCrOSOwnerOnly| label should be enabled in the UI or not.
enum FlagAccess { kGeneralAccessFlagsOnly, kOwnerAccessToFlags };
// Stores and encapsulates the little state that about:flags has.
class FlagsState {
FlagsState(const FeatureEntry* feature_entries, size_t num_feature_entries);
// Reads the state from |flags_storage| and adds the command line flags
// belonging to the active feature entries to |command_line|. Features are
// appended via |enable_features_flag_name| and |disable_features_flag_name|.
void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
base::CommandLine* command_line,
SentinelsMode sentinels,
const char* enable_features_flag_name,
const char* disable_features_flag_name);
// Reads the state from |flags_storage| and fills |switches| with the set of
// switches corresponding to enabled entries and |features| with the set of
// strings corresponding to enabled/disabled base::Feature states. Feature
// names are suffixed with ":enabled" or ":disabled" depending on their state.
void GetSwitchesAndFeaturesFromFlags(FlagsStorage* flags_storage,
std::set<std::string>* switches,
std::set<std::string>* features) const;
bool IsRestartNeededToCommitChanges();
void SetFeatureEntryEnabled(FlagsStorage* flags_storage,
const std::string& internal_name,
bool enable);
// Sets |value| as the command line switch for feature given by
// |internal_name|. |value| contains a list of origins (serialized form of
// url::Origin()) separated by whitespace and/or comma. Invalid values in this
// list are ignored.
void SetOriginListFlag(const std::string& internal_name,
const std::string& value,
FlagsStorage* flags_storage);
void RemoveFlagsSwitches(base::CommandLine::SwitchMap* switch_list);
void ResetAllFlags(FlagsStorage* flags_storage);
void Reset();
// Registers variations parameter values selected for features in about:flags.
// The selected flags are retrieved from |flags_storage|, the registered
// variation parameters are connected to their corresponding features in
// |feature_list|. Returns the (possibly empty) comma separated list of
// additional variation ids to register in the MetricsService that come from
// variations selected using chrome://flags.
std::vector<std::string> RegisterAllFeatureVariationParameters(
FlagsStorage* flags_storage,
base::FeatureList* feature_list);
// Gets the list of feature entries. Entries that are available for the
// current platform are appended to |supported_entries|; all other entries are
// appended to |unsupported_entries|.
void GetFlagFeatureEntries(
FlagsStorage* flags_storage,
FlagAccess access,
base::ListValue* supported_entries,
base::ListValue* unsupported_entries,
base::Callback<bool(const FeatureEntry&)> skip_feature_entry);
// Returns the value for the current platform. This is one of the values
// defined by the OS enum above.
// This is exposed only for testing.
static int GetCurrentPlatform();
// Compares a set of switches of the two provided command line objects and
// returns true if they are the same and false otherwise.
// If |out_difference| is not NULL, it's filled with set_symmetric_difference
// between sets.
// Only switches between --flag-switches-begin and --flag-switches-end are
// compared. The embedder may use |extra_flag_sentinel_begin_flag_name| and
// |extra_sentinel_end_flag_name| to specify other delimiters, if supported.
static bool AreSwitchesIdenticalToCurrentCommandLine(
const base::CommandLine& new_cmdline,
const base::CommandLine& active_cmdline,
std::set<base::CommandLine::StringType>* out_difference,
const char* extra_flag_sentinel_begin_flag_name,
const char* extra_flag_sentinel_end_flag_name);
// Keeps track of affected switches for each FeatureEntry, based on which
// choice is selected for it.
struct SwitchEntry;
// Adds mapping to |name_to_switch_map| to set the given switch name/value.
void AddSwitchMapping(
const std::string& key,
const std::string& switch_name,
const std::string& switch_value,
std::map<std::string, SwitchEntry>* name_to_switch_map) const;
// Adds mapping to |name_to_switch_map| to toggle base::Feature |feature_name|
// to state |feature_state|.
void AddFeatureMapping(
const std::string& key,
const std::string& feature_name,
bool feature_state,
std::map<std::string, SwitchEntry>* name_to_switch_map) const;
// Updates the switches in |command_line| by applying the modifications
// specified in |name_to_switch_map| for each entry in |enabled_entries|.
// |enable_features_flag_name| and |disable_features_flag_name| are switches
// used by the embedder to enable/disable features respectively if supported.
void AddSwitchesToCommandLine(
const std::set<std::string>& enabled_entries,
const std::map<std::string, SwitchEntry>& name_to_switch_map,
SentinelsMode sentinels,
base::CommandLine* command_line,
const char* enable_features_flag_name,
const char* disable_features_flag_name);
// Updates |command_line| by merging the value of the --enable-features= or
// --disable-features= list (per the |switch_name| param) with corresponding
// entries in |feature_switches| that have value |feature_state|. Keeps track
// of the changes by updating |appended_switches|.
void MergeFeatureCommandLineSwitch(
const std::map<std::string, bool>& feature_switches,
const char* switch_name,
bool feature_state,
base::CommandLine* command_line);
// Sanitizes |enabled_entries| to only contain entries that are defined in the
// |feature_entries_| and whose |supported_platforms| matches |platform_mask|.
// Pass -1 to |platform_mask| to not do platform filtering.
std::set<std::string> SanitizeList(
const std::set<std::string>& enabled_entries,
int platform_mask) const;
// Gets sanitized entries from |flags_storage|, filtering out any entries that
// don't exist in |feature_entries_|, and updates |flags_storage|.
void GetSanitizedEnabledFlags(FlagsStorage* flags_storage,
std::set<std::string>* result) const;
// Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
// enabled on the current platform.
void GetSanitizedEnabledFlagsForCurrentPlatform(
FlagsStorage* flags_storage,
std::set<std::string>* result) const;
// Generates a flags to switches mapping based on the set of enabled flags
// from |flags_storage|. On output, |enabled_entries| will contain the
// internal names of enabled flags and |name_to_switch_map| will contain
// information on how they map to command-line flags or features.
void GenerateFlagsToSwitchesMapping(
FlagsStorage* flags_storage,
std::set<std::string>* enabled_entries,
std::map<std::string, SwitchEntry>* name_to_switch_map) const;
// Called when the value of an entry with ORIGIN_LIST_VALUE is modified.
// Modifies the corresponding command line by adding or removing the switch
// based on the value of |enabled|.
void DidModifyOriginListFlag(const FeatureEntry& entry, bool enabled);
// Returns the FeatureEntry named |internal_name|. Returns null if no entry is
// matched.
const FeatureEntry* FindFeatureEntryByName(
const std::string& internal_name) const;
const FeatureEntry* feature_entries_;
size_t num_feature_entries_;
bool needs_restart_;
std::map<std::string, std::string> flags_switches_;
// Map from switch name to a set of string, that keeps track which strings
// were appended to existing (list value) switches.
std::map<std::string, std::set<std::string>> appended_switches_;
// Map from switch name to switch value. Only filled for features with
std::map<std::string, std::string> switch_values_;
} // namespace flags_ui