Remove the hash fields from FieldTrials.

base/metrics/field_trial.cc

 // 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.
 
 #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/sys_byteorder.h"
 #include "base/utf_string_conversions.h"
 
 namespace base {
 
 static const char kHistogramFieldTrialSeparator('_');
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
-const uint32 FieldTrial::kReservedHashValue = 0;
 bool FieldTrial::enable_benchmarking_ = false;
 
 const char FieldTrialList::kPersistentStringSeparator('/');
 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),
     forced_(false) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!name_.empty());
   DCHECK(!default_group_name_.empty());
 
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
@@ skipping 87 matching lines @@
   }
   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)
+bool FieldTrial::GetSelectedGroup(SelectedGroup* selected_group) {
+  if (group_ == kNotFinalized)
     return false;
-  name_group_id->name = name_hash_;
-  name_group_id->group = group_name_hash_;
+  selected_group->trial = name_;
+  selected_group->group = group_name_;
   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
-FieldTrial::NameGroupId FieldTrial::MakeNameGroupId(
-    const std::string& trial_name,
-    const std::string& group_name) {
-  NameGroupId id;
-  id.name = HashName(trial_name);
-  id.group = HashName(group_name);
-  return id;
-}
-
-// static
 void FieldTrial::EnableBenchmarking() {
   DCHECK_EQ(0u, FieldTrialList::GetFieldTrialCount());
   enable_benchmarking_ = true;
 }
 
 FieldTrial::~FieldTrial() {}
 
 void FieldTrial::SetGroupChoice(const std::string& name, int number) {
   group_ = number;
   if (name.empty())
     StringAppendF(&group_name_, "%d", group_);
   else
     group_name_ = name;
-  group_name_hash_ = HashName(group_name_);
 }
 
 // static
 double FieldTrial::HashClientId(const std::string& client_id,
                                 const std::string& trial_name) {
   // SHA-1 is designed to produce a uniformly random spread in its output space,
   // even for nearly-identical inputs, so it helps massage whatever client_id
   // and trial_name we get into something with a uniform distribution, which
   // is desirable so that we don't skew any part of the 0-100% spectrum.
   std::string input(client_id + trial_name);
   unsigned char sha1_hash[kSHA1Length];
   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;
   memcpy(&bits, sha1_hash, sizeof(bits));
   bits = base::ByteSwapToLE64(bits);
 
   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 inputs.
-  unsigned char sha1_hash[kSHA1Length];
-  SHA1HashBytes(reinterpret_cast<const unsigned char*>(name.c_str()),
-                name.size(),
-                sha1_hash);
-
-  COMPILE_ASSERT(sizeof(uint32) < sizeof(sha1_hash), need_more_data);
-  uint32 bits;
-  memcpy(&bits, sha1_hash, sizeof(bits));
-
-  // We only DCHECK, since this should not happen because the registration
-  // of the experiment on the server should have already warn the developer.
-  // If this ever happen, we'll ignore this experiment/group when reporting.
-  DCHECK(bits != kReservedHashValue);
-  return base::ByteSwapToLE32(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 97 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) {
-  DCHECK(name_group_ids->empty());
+void FieldTrialList::GetFieldTrialSelectedGroups(
+    FieldTrial::SelectedGroups* selected_groups) {
+  DCHECK(selected_groups->empty());
   if (!global_)
     return;
   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);
+    FieldTrial::SelectedGroup selected_group;
+    if (it->second->GetSelectedGroup(&selected_group))
+      selected_groups->push_back(selected_group);
   }
 }
 
 // static
 bool FieldTrialList::CreateTrialsFromString(const std::string& trials_string) {
   DCHECK(global_);
   if (trials_string.empty() || !global_)
     return true;
 
   size_t next_item = 0;
@@ skipping 113 matching lines @@
     used_without_global_ = true;
     return;
   }
   AutoLock auto_lock(global_->lock_);
   DCHECK(!global_->PreLockedFind(trial->name()));
   trial->AddRef();
   global_->registered_[trial->name()] = trial;
 }
 
 }  // namespace base