Remove the hash fields from FieldTrials.

base/metrics/field_trial.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.
 
 // FieldTrial is a class for handling details of statistical experiments
 // performed by actual users in the field (i.e., in a shipped or beta product).
 // All code is called exclusively on the UI thread currently.
 //
 // The simplest example is an experiment to see whether one of two options
 // produces "better" results across our user population.  In that scenario, UMA
@@ skipping 74 matching lines @@
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 
 namespace base {
 
 class FieldTrialList;
 
 class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> {
  public:
   typedef int Probability;  // Probability type for being selected in a trial.
-  // The Unique ID of a trial, where the name and group identifiers are
-  // hashes of the trial and group name strings.
-  struct NameGroupId {
-    uint32 name;
-    uint32 group;
+
+  // A pair representing a Field Trial and its selected group.
+  struct SelectedGroup {
+    std::string trial;
+    std::string group;
   };
 
+  typedef std::vector<SelectedGroup> SelectedGroups;
+
   // A return value to indicate that a given instance has not yet had a group
   // assignment (and hence is not yet participating in the trial).
   static const int kNotFinalized;
 
   // Changes the field trial to use one-time randomization, i.e. produce the
   // same result for the current trial on every run of this client. Must be
   // called right after construction.
   void UseOneTimeRandomization();
 
   // Disables this trial, meaning it always determines the default group
@@ skipping 16 matching lines @@
 
   // Return the randomly selected group number that was assigned.
   // Note that this will force an instance to participate, and make it illegal
   // to attempt to probabilistically add any other groups to the trial.
   int group();
 
   // If the group's name is empty, a string version containing the group number
   // is used as the group name. This causes a winner to be chosen if none was.
   std::string group_name();
 
-  // Gets the unique identifier of the Field Trial, but only if a group was
+  // Gets the SelectedGroup of the Field Trial, but only if a group was
   // officially chosen, otherwise name_group_id is left untouched and false
-  // is returned. When true is returned, the name and group ids were
-  // successfully set in name_group_id.
-  bool GetNameGroupId(NameGroupId* name_group_id);
+  // is returned. When true is returned, the trial and group names were
+  // successfully set in selected_group.
+  bool GetSelectedGroup(SelectedGroup* selected_group);
 
   // Helper function for the most common use: as an argument to specify the
   // name of a HISTOGRAM.  Use the original histogram name as the name_prefix.
   static std::string MakeName(const std::string& name_prefix,
                               const std::string& trial_name);
 
-  // Helper function to create a NameGroupId from |trial_name| and |group_name|.
-  static NameGroupId MakeNameGroupId(const std::string& trial_name,
-                                     const std::string& group_name);
-
   // Enable benchmarking sets field trials to a common setting.
   static void EnableBenchmarking();
 
  private:
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Registration);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AbsoluteProbabilities);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, RemainingProbability);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FiftyFiftyProbability);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, MiddleProbabilities);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, OneWinner);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DisableProbability);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Save);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DuplicateRestore);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, MakeName);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, HashClientId);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, HashClientIdIsUniform);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, HashName);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, NameGroupIds);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, UseOneTimeRandomization);
 
   friend class base::FieldTrialList;
 
   friend class RefCounted<FieldTrial>;
 
   // This is the group number of the 'default' group when a choice wasn't forced
   // by a call to FieldTrialList::CreateFieldTrial. It is kept private so that
   // consumers don't use it by mistake in cases where the group was forced.
@@ skipping 12 matching lines @@
 
   // Returns the group_name. A winner need not have been chosen.
   std::string group_name_internal() const { return group_name_; }
 
   // Calculates a uniformly-distributed double between [0.0, 1.0) given
   // a |client_id| and a |trial_name| (the latter is used as salt to avoid
   // separate one-time randomized trials from all having the same results).
   static double HashClientId(const std::string& client_id,
                              const std::string& trial_name);
 
-  // Creates unique identifier for the trial by hashing a name string, whether
-  // it's for the field trial or the group name.
-  static uint32 HashName(const std::string& name);
-
   // The name of the field trial, as can be found via the FieldTrialList.
   const std::string name_;
 
-  // The hashed name of the field trial to be sent as a unique identifier.
-  const uint32 name_hash_;
-
   // The maximum sum of all probabilities supplied, which corresponds to 100%.
   // This is the scaling factor used to adjust supplied probabilities.
   const Probability divisor_;
 
   // The name of the default group.
   const std::string default_group_name_;
 
   // The randomly selected probability that is used to select a group (or have
   // the instance not participate).  It is the product of divisor_ and a random
   // number between [0, 1).
   Probability random_;
 
   // Sum of the probabilities of all appended groups.
   Probability accumulated_group_probability_;
 
   int next_group_number_;
 
   // The pseudo-randomly assigned group number.
   // This is kNotFinalized if no group has been assigned.
   int group_;
 
   // A textual name for the randomly selected group. Valid after |group()|
   // has been called.
   std::string group_name_;
 
-  // The hashed name of the group to be sent as a unique identifier.
-  // Is not valid while group_ is equal to kNotFinalized.
-  uint32 group_name_hash_;
-
   // When enable_field_trial_ is false, field trial reverts to the 'default'
   // group.
   bool enable_field_trial_;
 
   // When forced_ is true, we return the chosen group from AppendGroup when
   // appropriate.
   bool forced_;
 
   // When benchmarking is enabled, field trials all revert to the 'default'
   // group.
   static bool enable_benchmarking_;
 
-  // This value is reserved for an uninitialized hash value.
-  static const uint32 kReservedHashValue;
-
   DISALLOW_COPY_AND_ASSIGN(FieldTrial);
 };
 
 //------------------------------------------------------------------------------
 // Class with a list of all active field trials.  A trial is active if it has
 // been registered, which includes evaluating its state based on its probaility.
 // Only one instance of this class exists.
 class BASE_EXPORT FieldTrialList {
  public:
   // Define a separator character to use when creating a persistent form of an
@@ skipping 69 matching lines @@
   static bool TrialExists(const std::string& name);
 
   // Creates a persistent representation of all FieldTrial instances for
   // resurrection in another process. This allows randomization to be done in
   // one process, and secondary processes can be synchronized on the result.
   // The resulting string contains the name and group name pairs for all trials,
   // with "/" used to separate all names and to terminate the string. This
   // string is parsed by CreateTrialsFromString().
   static void StatesToString(std::string* output);
 
-  // Returns an array of Unique IDs for each Field Trial that has a chosen
-  // group. Field Trials for which a group has not been chosen yet are NOT
+  // Returns an array of SelectedGroup objects, each representing a chosen Field

[jar (doing other things), 2012/04/26 22:24:22]

nit: (even in pre-existing comentary): It doesn't really "return" an array (or
even a vector), but only fills in the given data structure... so better may be:

Fills in the supplied vector |selected_groups| (which must be empty when called)
with a snapshot of all existing FieldTrials for which a group has been chosen
(if the group is not yet known, then it excluded from the vector).

[SteveT, 2012/04/26 23:42:47]

Very true. Done.

+  // Trial group. Field Trials for which a group has not been chosen yet are NOT
   // returned in this list.
-  static void GetFieldTrialNameGroupIds(
-      std::vector<FieldTrial::NameGroupId>* name_group_ids);
+  static void GetFieldTrialSelectedGroups(
+      FieldTrial::SelectedGroups* selected_groups);
 
   // Use a state string (re: StatesToString()) to augment the current list of
   // field tests to include the supplied tests, and using a 100% probability for
   // each test, force them to have the same group string.  This is commonly used
   // in a non-browser process, to carry randomly selected state in a browser
   // process into this non-browser process, but could also be invoked through a
   // command line argument to the browser process.
   static bool CreateTrialsFromString(const std::string& prior_trials);
 
   // Create a FieldTrial with the given |name| and using 100% probability for
@@ skipping 78 matching lines @@
 
   // List of observers to be notified when a group is selected for a FieldTrial.
   ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_FIELD_TRIAL_H_