Added a Unique ID for a Field Trial containing it's hashed name and the selected group ID.

base/metrics/field_trial.h

 // Copyright (c) 2011 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, first element is a hashed value of the name
+  // and the second one is the group identifier.
+  typedef std::pair<size_t, int> UID;

[jar (doing other things), 2012/01/24 19:19:45]

You might want to send two hashes, rather than one.  The integer will vary
depending on the experiments the programmer includes.  It is common to see the
names of the experiments changed, such as when folks are trying various window
sizes.... decide that some window sizes are very bad... and decide to try some
additional sizes.  Folks *could* learn to give 0% chance to such obsolete cases,
but this is not currently enforceable.

Also, size_t should only be used when required, such as for stl:: array indices,
or malloc sizes.  Better is to use uint32 or such.

The typename UID appears to me to be pretty cryptic, and is in fact an
abbreviation (which the style guide would not endorse).  Given that the type is
in the FieldTrial class, we can assume that much is known, and might refine it
with something like:
NameGroupPair
or
NameAndChoice
other??

Lastly, it is probably better to use a struct than a pair, as readability is
improved (and it is not necessary to "remember" which field comes first).

[MAD, 2012/01/24 20:30:24]

OK! Done...
Thanks! :-)

 
   // 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;
 
   // This is the group number of the 'default' group. This provides an easy way
   // to assign all the remaining probability to a group ('default').
   static const int kDefaultGroupNumber;
 
   // The name is used to register the instance with the FieldTrialList class,
@@ skipping 36 matching lines @@
   // Return the randomly selected group number that was assigned.
   // Return kDefaultGroupNumber if the instance is in the 'default' group.
   // 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.
   std::string group_name();
 
+  // Gets the unique identifier of the Field Trial, but only if a winner was
+  // elected. Returns true if a winner is returned, false otherwise.
+  bool GetUID(UID* uid);
+
   // Return the default group name of the FieldTrial.
   std::string default_group_name() const { return default_group_name_; }
 
   // 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);
 
   // Enable benchmarking sets field trials to a common setting.
   static void EnableBenchmarking();
@@ skipping 117 matching lines @@
 
   // Returns the group name chosen for the named trial, or the
   // empty string if the trial does not exist.
   static std::string FindFullName(const std::string& name);
 
   // Returns true if the named trial has been registered.
   static bool TrialExists(const std::string& name);
 
   // Create a persistent representation of all FieldTrial instances and the
   // |client_id()| state for resurrection in another process.  This allows
-  // randomization to be done in one process, and secondary processes can by
+  // randomization to be done in one process, and secondary processes can be
   // synchronized on the result. The resulting string contains the
   // |client_id()|, the names, the trial name, and a "/" separator.
   static void StatesToString(std::string* output);
 
+  // Returns an array of Unique IDs for each currently running Field Trials.
+  static void GetFieldTrialUIDs(std::vector<FieldTrial::UID>* uids);
+
   // Use a previously generated state string (re: StatesToString()) 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. This method calls
   // CreateFieldTrial to create the FieldTrial in the non-browser process.
   // Currently only the group_name_ and name_ are restored, as well as the
   // |client_id()| state, that could be used for one-time randomized trials
   // set up only in child processes.
   static bool CreateTrialsInChildProcess(const std::string& prior_trials);
@@ skipping 76 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_