Switch to standard integer types in components/, part 4 of 4.

components/variations/entropy_provider_unittest.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 <stddef.h>
+#include <stdint.h>
+
 #include <cmath>
 #include <limits>
 #include <numeric>
 
-#include "base/basictypes.h"
 #include "base/guid.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/variations/metrics_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace metrics {
 
 namespace {
 
@@ skipping 23 matching lines @@
 // Computes SHA1-based entropy for the given |trial_name| based on
 // |entropy_source|
 double GenerateSHA1Entropy(const std::string& entropy_source,
                            const std::string& trial_name) {
   SHA1EntropyProvider sha1_provider(entropy_source);
   return sha1_provider.GetEntropyForTrial(trial_name, 0);
 }
 
 // Generates permutation-based entropy for the given |trial_name| based on
 // |entropy_source| which must be in the range [0, entropy_max).
-double GeneratePermutedEntropy(uint16 entropy_source,
+double GeneratePermutedEntropy(uint16_t entropy_source,
                                size_t entropy_max,
                                const std::string& trial_name) {
   PermutedEntropyProvider permuted_provider(entropy_source, entropy_max);
   return permuted_provider.GetEntropyForTrial(trial_name, 0);
 }
 
 // Helper interface for testing used to generate entropy values for a given
 // field trial. Unlike EntropyProvider, which keeps the low/high entropy source
 // value constant and generates entropy for different trial names, instances
 // of TrialEntropyGenerator keep the trial name constant and generate low/high
@@ skipping 12 matching lines @@
   explicit SHA1EntropyGenerator(const std::string& trial_name)
       : trial_name_(trial_name) {
   }
 
   ~SHA1EntropyGenerator() override {}
 
   double GenerateEntropyValue() const override {
     // Use a random GUID + 13 additional bits of entropy to match how the
     // SHA1EntropyProvider is used in metrics_service.cc.
     const int low_entropy_source =
-        static_cast<uint16>(base::RandInt(0, kMaxLowEntropySize - 1));
+        static_cast<uint16_t>(base::RandInt(0, kMaxLowEntropySize - 1));
     const std::string high_entropy_source =
         base::GenerateGUID() + base::IntToString(low_entropy_source);
     return GenerateSHA1Entropy(high_entropy_source, trial_name_);
   }
 
  private:
   std::string trial_name_;
 
   DISALLOW_COPY_AND_ASSIGN(SHA1EntropyGenerator);
 };
 
 // An TrialEntropyGenerator that uses the permuted entropy provider algorithm,
 // using 13-bit low entropy source values.
 class PermutedEntropyGenerator : public TrialEntropyGenerator {
  public:
   explicit PermutedEntropyGenerator(const std::string& trial_name)
       : mapping_(kMaxLowEntropySize) {
     // Note: Given a trial name, the computed mapping will be the same.
     // As a performance optimization, pre-compute the mapping once per trial
     // name and index into it for each entropy value.
-    const uint32 randomization_seed = HashName(trial_name);
+    const uint32_t randomization_seed = HashName(trial_name);
     internal::PermuteMappingUsingRandomizationSeed(randomization_seed,
                                                    &mapping_);
   }
 
   ~PermutedEntropyGenerator() override {}
 
   double GenerateEntropyValue() const override {
     const int low_entropy_source =
-        static_cast<uint16>(base::RandInt(0, kMaxLowEntropySize - 1));
+        static_cast<uint16_t>(base::RandInt(0, kMaxLowEntropySize - 1));
     return mapping_[low_entropy_source] /
            static_cast<double>(kMaxLowEntropySize);
   }
 
  private:
-  std::vector<uint16> mapping_;
+  std::vector<uint16_t> mapping_;
 
   DISALLOW_COPY_AND_ASSIGN(PermutedEntropyGenerator);
 };
 
 // Tests uniformity of a given |entropy_generator| using the Chi-Square Goodness
 // of Fit Test.
 void PerformEntropyUniformityTest(
     const std::string& trial_name,
     const TrialEntropyGenerator& entropy_generator) {
   // Number of buckets in the simulated field trials.
@@ skipping 102 matching lines @@
   EXPECT_NE(trials[0]->group(), trials[1]->group());
   EXPECT_NE(trials[0]->group_name(), trials[1]->group_name());
 }
 
 TEST(EntropyProviderTest, UseOneTimeRandomizationWithCustomSeedPermuted) {
   // Ensures that two trials with different names but the same custom seed used
   // for one time randomization produce the same group assignments.
   base::FieldTrialList field_trial_list(
       new PermutedEntropyProvider(1234, kMaxLowEntropySize));
   const int kNoExpirationYear = base::FieldTrialList::kNoExpirationYear;
-  const uint32 kCustomSeed = 9001;
+  const uint32_t kCustomSeed = 9001;
   scoped_refptr<base::FieldTrial> trials[] = {
       base::FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
           "one", 100, "default", kNoExpirationYear, 1, 1,
           base::FieldTrial::ONE_TIME_RANDOMIZED, kCustomSeed, NULL),
       base::FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
           "two", 100, "default", kNoExpirationYear, 1, 1,
           base::FieldTrial::ONE_TIME_RANDOMIZED, kCustomSeed, NULL),
   };
 
   for (size_t i = 0; i < arraysize(trials); ++i) {
@@ skipping 65 matching lines @@
     PermutedEntropyGenerator entropy_generator(kTestTrialNames[i]);
     PerformEntropyUniformityTest(kTestTrialNames[i], entropy_generator);
   }
 }
 
 TEST(EntropyProviderTest, SeededRandGeneratorIsUniform) {
   // Verifies that SeededRandGenerator has a uniform distribution.
   //
   // Mirrors RandUtilTest.RandGeneratorIsUniform in base/rand_util_unittest.cc.
 
-  const uint32 kTopOfRange = (std::numeric_limits<uint32>::max() / 4ULL) * 3ULL;
-  const uint32 kExpectedAverage = kTopOfRange / 2ULL;
-  const uint32 kAllowedVariance = kExpectedAverage / 50ULL;  // +/- 2%
+  const uint32_t kTopOfRange =
+      (std::numeric_limits<uint32_t>::max() / 4ULL) * 3ULL;
+  const uint32_t kExpectedAverage = kTopOfRange / 2ULL;
+  const uint32_t kAllowedVariance = kExpectedAverage / 50ULL;  // +/- 2%
   const int kMinAttempts = 1000;
   const int kMaxAttempts = 1000000;
 
   for (size_t i = 0; i < arraysize(kTestTrialNames); ++i) {
-    const uint32 seed = HashName(kTestTrialNames[i]);
+    const uint32_t seed = HashName(kTestTrialNames[i]);
     internal::SeededRandGenerator rand_generator(seed);
 
     double cumulative_average = 0.0;
     int count = 0;
     while (count < kMaxAttempts) {
-      uint32 value = rand_generator(kTopOfRange);
+      uint32_t value = rand_generator(kTopOfRange);
       cumulative_average = (count * cumulative_average + value) / (count + 1);
 
       // Don't quit too quickly for things to start converging, or we may have
       // a false positive.
       if (count > kMinAttempts &&
           kExpectedAverage - kAllowedVariance < cumulative_average &&
           cumulative_average < kExpectedAverage + kAllowedVariance) {
         break;
       }
 
       ++count;
     }
 
     ASSERT_LT(count, kMaxAttempts) << "Expected average was " <<
         kExpectedAverage << ", average ended at " << cumulative_average <<
         ", for trial " << kTestTrialNames[i];
   }
 }
 
 }  // namespace metrics