Clean up terminology used in about_flags.

chrome/browser/about_flags.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROME_BROWSER_ABOUT_FLAGS_H_
 #define CHROME_BROWSER_ABOUT_FLAGS_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_base.h"
 #include "base/strings/string16.h"
 
 class PrefService;
 
 namespace base {
 class ListValue;
 }
 
 namespace flags_ui {
 class FlagsStorage;
 }
 
 namespace about_flags {
 
-// Experiment is used internally by about_flags to describe an experiment (and
-// for testing).
+// FeatureEntry is used by about_flags to describe an experimental feature.
+//
+// Note that features should eventually be either turned on by default with no
+// about_flags entries or deleted. Most feature entries should only be around
+// for a few milestones, until their full launch.
+//
 // This is exposed only for testing.
-struct Experiment {
+struct FeatureEntry {
   enum Type {
-    // An experiment with a single value. This is typically what you want.
+    // A feature with a single flag value. This is typically what you want.
     SINGLE_VALUE,
 
-    // A default enabled experiment with a single value to disable it. This is
-    // for default enabled SINGLE_VALUE experiments. Please consider whether
-    // you really need a flag to disable the experiment, and even if so remove
-    // the disable flag as soon as it is no longer needed.
+    // A default enabled feature with a single flag value to disable it. Please
+    // consider whether you really need a flag to disable the feature, and even
+    // if so remove the disable flag as soon as it is no longer needed.
     SINGLE_DISABLE_VALUE,
 
-    // The experiment has multiple values only one of which is ever enabled.
+    // The feature has multiple values only one of which is ever enabled.
     // The first of the values should correspond to a deactivated state for this
-    // lab (i.e. no command line option). For MULTI_VALUE experiments the
-    // command_line of the Experiment is not used. If the experiment is enabled
-    // the command line of the selected Choice is enabled.
+    // feature (i.e. no command line option). For MULTI_VALUE entries, the
+    // command_line of the FeatureEntry is not used. If the experiment is
+    // enabled the command line of the selected Choice is enabled.
     MULTI_VALUE,
 
-    // The experiment has three possible values: Default, Enabled and Disabled.
-    // This should be used for experiments that may have their own logic to
-    // decide if the feature should be on when not explicitly specified via
-    // about flags - for example via FieldTrials.
+    // The feature has three possible values: Default, Enabled and Disabled.
+    // This should be used for features that may have their own logic to decide
+    // if the feature should be on when not explicitly specified via about
+    // flags - for example via FieldTrials.
     ENABLE_DISABLE_VALUE,
   };
 
   // Used for MULTI_VALUE types to describe one of the possible values the user
   // can select.
   struct Choice {
     // ID of the message containing the choice name.
     int description_id;
 
     // Command line switch and value to enabled for this choice.
     const char* command_line_switch;
     // Simple switches that have no value should use "" for command_line_value.
     const char* command_line_value;
   };
 
-  // The internal name of the experiment. This is never shown to the user.
+  // The internal name of the feature entry. This is never shown to the user.
   // It _is_ however stored in the prefs file, so you shouldn't change the
   // name of existing flags.
   const char* internal_name;
 
-  // String id of the message containing the experiment's name.
+  // String id of the message containing the feature's name.
   int visible_name_id;
 
-  // String id of the message containing the experiment's description.
+  // String id of the message containing the feature's description.
   int visible_description_id;
 
-  // The platforms the experiment is available on
+  // The platforms the feature is available on.
   // Needs to be more than a compile-time #ifdef because of profile sync.
   unsigned supported_platforms;  // bitmask
 
-  // Type of experiment.
+  // Type of entry.
   Type type;
 
   // The commandline switch and value that are added when this flag is active.
   // This is different from |internal_name| so that the commandline flag can be
   // renamed without breaking the prefs file.
   // This is used if type is SINGLE_VALUE or ENABLE_DISABLE_VALUE.
   const char* command_line_switch;
   // Simple switches that have no value should use "" for command_line_value.
   const char* command_line_value;
 
@@ skipping 13 matching lines @@
   std::string NameForChoice(int index) const;
 
   // Returns the human readable description for the choice at |index|.
   base::string16 DescriptionForChoice(int index) const;
 };
 
 // A flag controlling the behavior of the |ConvertFlagsToSwitches| function -
 // whether it should add the sentinel switches around flags.
 enum SentinelsMode { kNoSentinels, kAddSentinels };
 
-// Reads the Labs |prefs| (called "Labs" for historical reasons) and adds the
-// commandline flags belonging to the active experiments to |command_line|.
+// Reads the state from |flags_storage| and adds the command line flags
+// belonging to the active feature entries to |command_line|.
 void ConvertFlagsToSwitches(flags_ui::FlagsStorage* flags_storage,
                             base::CommandLine* command_line,
                             SentinelsMode sentinels);
 
 // 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.
 bool AreSwitchesIdenticalToCurrentCommandLine(
     const base::CommandLine& new_cmdline,
     const base::CommandLine& active_cmdline,
     std::set<base::CommandLine::StringType>* out_difference);
 
 // 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 };
 
-// Get the list of experiments. Experiments that are available on the current
-// platform are appended to |supported_experiments|; all other experiments are
-// appended to |unsupported_experiments|.
-void GetFlagsExperimentsData(flags_ui::FlagsStorage* flags_storage,
-                             FlagAccess access,
-                             base::ListValue* supported_experiments,
-                             base::ListValue* unsupported_experiments);
+// 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(flags_ui::FlagsStorage* flags_storage,
+                           FlagAccess access,
+                           base::ListValue* supported_entries,
+                           base::ListValue* unsupported_entries);
 
-// Returns true if one of the experiment flags has been flipped since startup.
+// Returns true if one of the feature entry flags has been flipped since
+// startup.
 bool IsRestartNeededToCommitChanges();
 
-// Enables or disables the experiment with id |internal_name|.
-void SetExperimentEnabled(flags_ui::FlagsStorage* flags_storage,
-                          const std::string& internal_name,
-                          bool enable);
+// Enables or disables the current with id |internal_name|.
+void SetFeatureEntryEnabled(flags_ui::FlagsStorage* flags_storage,
+                            const std::string& internal_name,
+                            bool enable);
 
 // Removes all switches that were added to a command line by a previous call to
 // |ConvertFlagsToSwitches()|.
 void RemoveFlagsSwitches(
     std::map<std::string, base::CommandLine::StringType>* switch_list);
 
 // Reset all flags to the default state by clearing all flags.
 void ResetAllFlags(flags_ui::FlagsStorage* flags_storage);
 
 // Returns the value for the current platform. This is one of the values defined
@@ skipping 13 matching lines @@
 // |command_line_difference| is the result of
 // AreSwitchesIdenticalToCurrentCommandLine().
 void ReportCustomFlags(const std::string& uma_histogram_hame,
                        const std::set<std::string>& command_line_difference);
 
 namespace testing {
 
 // Clears internal global state, for unit tests.
 void ClearState();
 
-// Sets the list of experiments. Pass in NULL to use the default set. This does
-// NOT take ownership of the supplied Experiments.
-void SetExperiments(const Experiment* e, size_t count);
+// Sets the list of feature entries. Pass in null to use the default set. This
+// does NOT take ownership of the supplied |entries|.
+void SetFeatureEntries(const FeatureEntry* entries, size_t count);
 
-// Returns the current set of experiments.
-const Experiment* GetExperiments(size_t* count);
+// Returns the current set of feature entries.
+const FeatureEntry* GetFeatureEntries(size_t* count);
 
 // Separator used for multi values. Multi values are represented in prefs as
 // name-of-experiment + kMultiSeparator + selected_index.
 extern const char kMultiSeparator[];
 
 // This value is reported as switch histogram ID if switch name has unknown
 // format.
 extern const base::HistogramBase::Sample kBadSwitchFormatHistogramId;
 
 }  // namespace testing
 
 }  // namespace about_flags
 
 #endif  // CHROME_BROWSER_ABOUT_FLAGS_H_