Making the SHA1 entropy provider use the randomization_seed.

components/variations/entropy_provider.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 "components/variations/entropy_provider.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sha1.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "components/variations/metrics_util.h"
 
 namespace metrics {
 
 namespace internal {
 
 SeededRandGenerator::SeededRandGenerator(uint32_t seed) {
   mersenne_twister_.init_genrand(seed);
 }
@@ skipping 56 matching lines @@
     const std::string& trial_name,
     uint32_t randomization_seed) const {
   // Given enough input entropy, SHA-1 will produce a uniformly random spread
   // in its output space. In this case, the input entropy that is used is the
   // combination of the original |entropy_source_| and the |trial_name|.
   //
   // Note: If |entropy_source_| has very low entropy, such as 13 bits or less,
   // it has been observed that this method does not result in a uniform
   // distribution given the same |trial_name|. When using such a low entropy
   // source, PermutedEntropyProvider should be used instead.
-  std::string input(entropy_source_ + trial_name);
+  std::string input(entropy_source_);
+  input.append(randomization_seed == 0 ? trial_name : base::UintToString(
+                                                          randomization_seed));
+
   unsigned char sha1_hash[base::kSHA1Length];
   base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
                       input.size(),
                       sha1_hash);
 
   uint64_t bits;
   static_assert(sizeof(bits) < sizeof(sha1_hash), "more data required");
   memcpy(&bits, sha1_hash, sizeof(bits));
   bits = base::ByteSwapToLE64(bits);
 
@@ skipping 22 matching lines @@
 }
 
 uint16_t PermutedEntropyProvider::GetPermutedValue(
     uint32_t randomization_seed) const {
   std::vector<uint16_t> mapping(low_entropy_source_max_);
   internal::PermuteMappingUsingRandomizationSeed(randomization_seed, &mapping);
   return mapping[low_entropy_source_];
 }
 
 }  // namespace metrics