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

base/metrics/field_trial.cc

 // 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.
 
 #include "base/metrics/field_trial.h"
 
 #include "base/build_time.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sha1.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 namespace base {
 
 // static
 const int FieldTrial::kNotFinalized = -1;
 
 // static
 const int FieldTrial::kDefaultGroupNumber = 0;
 
 // static
+const uint32 FieldTrial::kReservedHashValue = 0;
+
+// static
 bool FieldTrial::enable_benchmarking_ = false;
 
 // static
 const char FieldTrialList::kPersistentStringSeparator('/');
 
 static const char kHistogramFieldTrialSeparator('_');
 
 // static
 int FieldTrialList::kExpirationYearInFuture = 0;
 
 
 //------------------------------------------------------------------------------
 // FieldTrial methods and members.
 
 FieldTrial::FieldTrial(const std::string& name,
                        const Probability total_probability,
                        const std::string& default_group_name,
                        const int year,
                        const int month,
                        const int day_of_month)
   : name_(name),
+    name_hash_(HashName(name)),
     divisor_(total_probability),
     default_group_name_(default_group_name),
     random_(static_cast<Probability>(divisor_ * RandDouble())),
     accumulated_group_probability_(0),
     next_group_number_(kDefaultGroupNumber + 1),
     group_(kNotFinalized),
+    group_name_hash_(kReservedHashValue),
     enable_field_trial_(true) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!name_.empty());
   DCHECK(!default_group_name_.empty());
   FieldTrialList::Register(this);
 
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
@@ skipping 28 matching lines @@
 }
 
 void FieldTrial::Disable() {
   enable_field_trial_ = false;
 
   // In case we are disabled after initialization, we need to switch
   // the trial to the default group.
   if (group_ != kNotFinalized) {
     group_ = kDefaultGroupNumber;
     group_name_ = default_group_name_;
+    group_name_hash_ = HashName(group_name_);
   }
 }
 
 int FieldTrial::AppendGroup(const std::string& name,
                             Probability group_probability) {
   DCHECK_LE(group_probability, divisor_);
   DCHECK_GE(group_probability, 0);
 
   if (enable_benchmarking_ || !enable_field_trial_)
     group_probability = 0;
 
   accumulated_group_probability_ += group_probability;
 
   DCHECK_LE(accumulated_group_probability_, divisor_);
   if (group_ == kNotFinalized && accumulated_group_probability_ > random_) {
     // This is the group that crossed the random line, so we do the assignment.
     group_ = next_group_number_;
     if (name.empty())
       StringAppendF(&group_name_, "%d", group_);
     else
       group_name_ = name;
+    group_name_hash_ = HashName(group_name_);
     FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_);
   }
   return next_group_number_++;
 }
 
 int FieldTrial::group() {
   if (group_ == kNotFinalized) {
     accumulated_group_probability_ = divisor_;
     group_ = kDefaultGroupNumber;
     group_name_ = default_group_name_;
+    group_name_hash_ = HashName(group_name_);
     FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_);
   }
   return group_;
 }
 
 std::string FieldTrial::group_name() {
   group();  // call group() to make sure group assignment was done.
   DCHECK(!group_name_.empty());
   return group_name_;
 }
 
+bool FieldTrial::GetNameGroupId(NameGroupId* name_group_id) {
+  if (group_name_hash_ == kReservedHashValue)
+    return false;
+  name_group_id->name = name_hash_;
+  name_group_id->group = group_name_hash_;
+  return true;
+}
+
 // static
 std::string FieldTrial::MakeName(const std::string& name_prefix,
                                  const std::string& trial_name) {
   std::string big_string(name_prefix);
   big_string.append(1, kHistogramFieldTrialSeparator);
   return big_string.append(FieldTrialList::FindFullName(trial_name));
 }
 
 // static
 void FieldTrial::EnableBenchmarking() {
@@ skipping 15 matching lines @@
   SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
                 input.size(),
                 sha1_hash);
 
   COMPILE_ASSERT(sizeof(uint64) < sizeof(sha1_hash), need_more_data);
   uint64* bits = reinterpret_cast<uint64*>(&sha1_hash[0]);
 
   return BitsToOpenEndedUnitInterval(*bits);
 }
 
+// static
+uint32 FieldTrial::HashName(const std::string& name) {
+  // SHA-1 is designed to produce a uniformly random spread in its output space,
+  // even for nearly-identical name.

[Alexei Svitkine (slow), 2012/01/25 17:40:16]

"nearly-identical name" -> "nearly-identical inputs" (more grammatical).

[MAD, 2012/01/25 18:48:53]

Done.

+  unsigned char sha1_hash[kSHA1Length];
+  SHA1HashBytes(reinterpret_cast<const unsigned char*>(name.c_str()),

[Alexei Svitkine (slow), 2012/01/25 15:25:19]

I think you can use |SHA1HashString()| instead of |SHA1HashBytes()| here.

[MAD, 2012/01/25 17:02:33]

I copied the behavior from HashClientId... Should we change both?

[Alexei Svitkine (slow), 2012/01/25 17:40:16]

Looking closer at |SHA1HashString()|, it returns its output as a string - which
is not a problem since we can still cast its data() to bits for the same effect,
but is less efficient because it involves an extra temporary string and probably
an allocation.

So actually, I'm okay with keeping it as it is, since it is slightly more
efficient.

[MAD, 2012/01/25 18:48:53]

OK, Thanks for checking... ;-)

+                name.size(),
+                sha1_hash);
+
+  COMPILE_ASSERT(sizeof(uint32) < sizeof(sha1_hash), need_more_data);
+  uint32* bits = reinterpret_cast<uint32*>(&sha1_hash[0]);
+  DCHECK(*bits != kReservedHashValue) << "Bad luck, that name can't be used!";
+  return *bits;
+}
+
 //------------------------------------------------------------------------------
 // FieldTrialList methods and members.
 
 // static
 FieldTrialList* FieldTrialList::global_ = NULL;
 
 // static
 bool FieldTrialList::used_without_global_ = false;
 
 FieldTrialList::FieldTrialList(const std::string& client_id)
@@ skipping 79 matching lines @@
     DCHECK_EQ(name.find(kPersistentStringSeparator), std::string::npos);
     DCHECK_EQ(group_name.find(kPersistentStringSeparator), std::string::npos);
     output->append(name);
     output->append(1, kPersistentStringSeparator);
     output->append(group_name);
     output->append(1, kPersistentStringSeparator);
   }
 }
 
 // static
+void FieldTrialList::GetFieldTrialNameGroupIds(
+    std::vector<FieldTrial::NameGroupId>* name_group_ids) {
+  if (!global_)

[Alexei Svitkine (slow), 2012/01/25 15:25:19]

Should you clear |name_group_ids| in this case (and also before appending)?

[MAD, 2012/01/25 17:02:33]

Again, I copied the behavior from StatesToString which DCHECK that the output
argument is empty... Should we change both?

[Alexei Svitkine (slow), 2012/01/25 17:40:16]

I'm okay with the DCHECK(), though then it should be before if (!global_) and
the header comment should mention that |name_group_ids| must be empty initially.

Can you make those changes both here and StatesToString()?

[MAD, 2012/01/25 18:48:53]

Done.

+    return;
+  DCHECK(name_group_ids->empty());
+  AutoLock auto_lock(global_->lock_);
+
+  for (RegistrationList::iterator it = global_->registered_.begin();
+       it != global_->registered_.end(); ++it) {
+    FieldTrial::NameGroupId name_group_id;
+    if (it->second->GetNameGroupId(&name_group_id))
+      name_group_ids->push_back(name_group_id);
+  }
+}
+
+// static
 bool FieldTrialList::CreateTrialsInChildProcess(
     const std::string& parent_trials) {
   DCHECK(global_);
   if (parent_trials.empty() || !global_)
     return true;
 
   size_t next_item = 0;
   while (next_item < parent_trials.length()) {
     size_t name_end = parent_trials.find(kPersistentStringSeparator, next_item);
     if (name_end == parent_trials.npos || next_item == name_end)
@@ skipping 93 matching lines @@
 }
 
 FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) {
   RegistrationList::iterator it = registered_.find(name);
   if (registered_.end() == it)
     return NULL;
   return it->second;
 }
 
 }  // namespace base